add 0.10.3 to CHANGELOG

add Muted column to table

CHANGELOG.md

@@ -5,17 +5,83 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-# [0.6.0] - 2025-05-25
+# [0.10.3] - 2025-06-07
 
 ### Added
 
--   filter commands, see [Filter](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filter)
+-   filter list:
+    -   --ffmpeg, --vlc flags
+    -   Muted column to list table
+
+# [0.10.2] - 2025-06-04
+
+### Added
+
+-   screenshot save command, see [ScreenshotCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#screenshotcmd)
+
+### Fixed
+
+-   filter list:
+    -   sourceName arg now defaults to current scene. 
+    -   defaults are printed for any unmodified values.
+-   sceneitem list:
+    -   prints enabled mark instead of true/false
+
+# [0.9.0] - 2025-06-02
+
+### Added
+
+-   --version/-v option. See [Flags](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#flags)
+
+### Changed
+
+-   version command renamed to obs-version
+
+# [0.8.2] - 2025-05-29
+
+### Added
+
+-   record start/stop and stream start/stop commands check outputActive states first. 
+    -   Errors are returned if the command cannot be performed.
+
+### Changed
+
+-   The --parent flag for the sceneitem commands has been renamed to --group, see [SceneItemCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#sceneitemcmd)
+
+# [0.8.0] - 2025-05-27
+
+### Added
+
+-   record directory command, see [directory under RecordCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#recordcmd)
+
+### Changed
+
+-   record stop now prints the output path of the recording.
+
+
+# [0.7.0] - 2025-05-26
+
+### Added
+
+-   projector commands, see [ProjectorCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#projectorcmd)
+
+
+# [0.6.1] - 2025-05-25
+
+### Added
+
+-   filter commands, see [FilterCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filtercmd)
+
+### Changed
+
+-   list commands are now printed as tables.
+    - This affects group, hotkey, input, profile, scene, scenecollection and sceneitem command groups.
 
 # [0.5.0] - 2025-05-22
 
 ### Added
 
--   hotkey commands, see [Hotkey](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#hotkeycmd)
+-   hotkey commands, see [HotkeyCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#hotkeycmd)
 
 # [0.4.2] - 2025-05-08
 

README.md

@@ -14,10 +14,16 @@ go install github.com/onyx-and-iris/gobs-cli@latest
 
 #### Flags
 
-Pass `--host`, `--port` and `--password` as flags to the root command, for example:
+-   --host/-H: Websocket host
+-   --port/-P Websocket port
+-   --password/-p: Websocket password
+-   --timeout/-T: Websocket timeout
+-   --version/-v: Print the gobs-cli version
+
+Pass `--host`, `--port` and `--password` as flags on the root command, for example:
 
 ```console
-gobs-cli --host=localhost --port=4455 --password=<websocket password> --help
+gobs-cli --host localhost --port 4455 --password 'websocket password' --help
 ```
 
 #### Environment Variables
@@ -37,10 +43,12 @@ OBS_TIMEOUT=5
 
 ## Commands
 
-### VersionCmd
+### ObsVersionCmd
+
+-   Print OBS client and websocket version.
 
 ```console
-gobs-cli version
+gobs-cli obs-version
 ```
 
 ### SceneCmd
@@ -79,9 +87,14 @@ gobs-cli scene switch --preview LIVE
 ### SceneItemCmd
 
 -   list: List all scene items.
+
+    *optional*
     -   args: SceneName
+        -   defaults to current scene
 
 ```console
+gobs-cli sceneitem list
+
 gobs-cli sceneitem list LIVE
 ```
 
@@ -89,7 +102,7 @@ gobs-cli sceneitem list LIVE
     -   flags:
 
         *optional*
-        -   --parent: Parent group name.
+        -   --group: Parent group name.
     -   args: SceneName ItemName
 
 ```console
@@ -100,7 +113,7 @@ gobs-cli sceneitem show START "Colour Source"
     -   flags:
 
         *optional*
-        -   --parent: Parent group name.
+        -   --group: Parent group name.
     -   args: SceneName ItemName
 
 ```console
@@ -111,28 +124,29 @@ gobs-cli sceneitem hide START "Colour Source"
     -   flags:
 
         *optional*
-        -   --parent: Parent group name.
+        -   --group: Parent group name.
     -   args: SceneName ItemName
 
 ```console
-gobs-cli sceneitem toggle --parent=test_group START "Colour Source 3"
+gobs-cli sceneitem toggle --group=test_group START "Colour Source 3"
 ```
 
 -   visible: Get scene item visibility.
     -   flags:
 
         *optional*
-        -   --parent: Parent group name.
+        -   --group: Parent group name.
     -   args: SceneName ItemName
 
 ```console
-gobs-cli sceneitem visible --parent=test_group START "Colour Source 4"
+gobs-cli sceneitem visible --group=test_group START "Colour Source 4"
 ```
 
 -   transform: Transform scene item.
     -   flags:
+        
         *optional*
-        -   --parent: Parent group name.
+        -   --group: Parent group name.
 
         -   --alignment: Alignment of the scene item.
         -   --bounds-alignment: Bounds alignment of the scene item.
@@ -161,9 +175,14 @@ gobs-cli sceneitem transform \
 ### GroupCmd
 
 -   list: List all groups.
+
+    *optional*
     -   args: SceneName
+        -   defaults to current scene
 
 ```console
+gobs-cli group list
+
 gobs-cli group list START
 ```
 
@@ -204,6 +223,8 @@ gobs-cli group status START "test_group"
         -   --input: List all inputs.
         -   --output: List all outputs.
         -   --colour: List all colour sources.
+        -   --ffmpeg: List all ffmpeg sources.
+        -   --vlc: List all VLC sources.
 
 ```console
 gobs-cli input list
@@ -270,6 +291,19 @@ gobs-cli record pause
 gobs-cli record resume
 ```
 
+-   directory: Get/Set recording directory.
+
+    *optional*
+    -   args: RecordDirectory
+        -   if not passed the current record directory will be printed.
+
+```console
+gobs-cli record directory
+
+gobs-cli record directory "/home/me/obs-vids/"
+gobs-cli record directory "C:/Users/me/Videos"
+```
+
 ### StreamCmd
 
 -   start: Start streaming.
@@ -481,6 +515,10 @@ gobs-cli hotkey trigger-sequence OBS_KEY_F1 --shift --ctrl
 
 -   list: List all filters.
 
+    *optional*
+    -   args: SourceName
+        -   defaults to current scene
+
 ```console
 gobs-cli filter list
 ```
@@ -513,6 +551,52 @@ gobs-cli toggle 'Mic/Aux' 'Gain'
 gobs-cli status 'Mic/Aux' 'Gain'
 ```
 
+### ProjectorCmd
+
+-   list-monitors: List available monitors.
+
+```console
+gobs-cli projector list-monitors
+```
+
+-   open: Open a fullscreen projector for a source on a specific monitor.
+    -   flags:
+
+        *optional*
+        -   --monitor-index: Index of the monitor to open the projector on.
+            -   defaults to 0
+
+    *optional*
+    -   args: SourceName
+        -   defaults to current scene
+
+```console
+gobs-cli projector open
+
+gobs-cli projector open --monitor-index=1 "test_scene"
+
+gobs-cli projector open --monitor-index=1 "test_group"
+```
+
+### ScreenshotCmd
+
+-   save: Take a screenshot and save it to a file.
+    -   flags:
+
+        *optional*
+        -   --width:
+            -   defaults to 1920
+        -   --height:
+            -   defaults to 1080
+        -   --quality:
+            -   defaults to -1
+
+    -   args: SourceName FilePath
+
+```console
+gobs-cli screenshot save --width=2560 --height=1440 "Scene" "C:\Users\me\Videos\screenshot.png"
+```
+
 
 [userconfigdir]: https://pkg.go.dev/os#UserConfigDir
 [obs-keyids]: https://github.com/obsproject/obs-studio/blob/master/libobs/obs-hotkeys.h

Taskfile.yaml

@@ -7,6 +7,8 @@ vars:
   PROGRAM: gobs-cli
   SHELL: '{{if eq .OS "Windows_NT"}}powershell{{end}}'
   BIN_DIR: bin
+  VERSION:
+    sh: 'git describe --tags $(git rev-list --tags --max-count=1)'
 
 tasks:
   default:
@@ -35,13 +37,13 @@ tasks:
   build-windows:
     desc: Build the gobs-cli project for Windows
     cmds:
-      - GOOS=windows GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe
+      - GOOS=windows GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe
     internal: true
 
   build-linux:
     desc: Build the gobs-cli project for Linux
     cmds:
-      - GOOS=linux GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64
+      - GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64
     internal: true
 
   test:

filter.go

@@ -2,8 +2,12 @@ package main
 
 import (
 	"fmt"
+	"maps"
+	"sort"
+	"strings"
 
 	"github.com/andreykaipov/goobs/api/requests/filters"
+	"github.com/aquasecurity/table"
 )
 
 // FilterCmd provides commands to manage filters in OBS Studio.
@@ -17,21 +21,63 @@ type FilterCmd struct {
 
 // FilterListCmd provides a command to list all filters in a scene.
 type FilterListCmd struct {
-	SourceName string `arg:"" help:"Name of the source to list filters from."`
+	SourceName string `arg:"" help:"Name of the source to list filters from." default:""`
 }
 
 // Run executes the command to list all filters in a scene.
 func (cmd *FilterListCmd) Run(ctx *context) error {
-	filters, err := ctx.Client.Filters.GetSourceFilterList(
+	if cmd.SourceName == "" {
+		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
+		if err != nil {
+			return fmt.Errorf("failed to get current program scene: %w", err)
+		}
+		cmd.SourceName = currentScene.SceneName
+	}
+
+	sourceFilters, err := ctx.Client.Filters.GetSourceFilterList(
 		filters.NewGetSourceFilterListParams().WithSourceName(cmd.SourceName),
 	)
 	if err != nil {
 		return err
 	}
-	for _, filter := range filters.Filters {
-		fmt.Fprintf(ctx.Out, "Name: %s\n  Kind: %s\n  Enabled: %t\n  Settings: %+v\n",
-			filter.FilterName, filter.FilterKind, filter.FilterEnabled, filter.FilterSettings)
+
+	if len(sourceFilters.Filters) == 0 {
+		fmt.Fprintf(ctx.Out, "No filters found for source %s.\n", cmd.SourceName)
+		return nil
 	}
+
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter, table.AlignLeft)
+	t.SetHeaders("Filter Name", "Kind", "Enabled", "Settings")
+
+	for _, filter := range sourceFilters.Filters {
+		defaultSettings, err := ctx.Client.Filters.GetSourceFilterDefaultSettings(
+			filters.NewGetSourceFilterDefaultSettingsParams().
+				WithFilterKind(filter.FilterKind),
+		)
+		if err != nil {
+			return fmt.Errorf("failed to get default settings for filter %s: %w",
+				filter.FilterName, err)
+		}
+		maps.Insert(defaultSettings.DefaultFilterSettings, maps.All(filter.FilterSettings))
+
+		var lines []string
+		for k, v := range defaultSettings.DefaultFilterSettings {
+			lines = append(lines, fmt.Sprintf("%s: %v", snakeCaseToTitleCase(k), v))
+		}
+		sort.Slice(lines, func(i, j int) bool {
+			return strings.ToLower(lines[i]) < strings.ToLower(lines[j])
+		})
+
+		t.AddRow(
+			filter.FilterName,
+			snakeCaseToTitleCase(filter.FilterKind),
+			getEnabledMark(filter.FilterEnabled),
+			strings.Join(lines, "\n"),
+		)
+	}
+	t.Render()
 	return nil
 }
 

filter_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestFilterList(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &FilterListCmd{
+		SourceName: "Mic/Aux",
+	}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list filters: %v", err)
+	}
+	if !strings.Contains(out.String(), "test_filter") {
+		t.Fatalf("Expected output to contain 'test_filter', got '%s'", out.String())
+	}
+}
+
+func TestFilterListScene(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &FilterListCmd{
+		SourceName: "gobs-test",
+	}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list filters in scene: %v", err)
+	}
+	if !strings.Contains(out.String(), "test_filter") {
+		t.Fatalf("Expected output to contain 'test_filter', got '%s'", out.String())
+	}
+}
+
+func TestFilterListEmpty(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &FilterListCmd{
+		SourceName: "NonExistentSource",
+	}
+	err := cmd.Run(context)
+	if err == nil {
+		t.Fatal("Expected error for non-existent source, but got none")
+	}
+	if !strings.Contains(err.Error(), "No source was found by the name of `NonExistentSource`.") {
+		t.Fatalf(
+			"Expected error to contain 'No source was found by the name of `NonExistentSource`.', got '%s'",
+			err.Error(),
+		)
+	}
+}

go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/alecthomas/kong v1.10.0
 	github.com/alecthomas/mango-kong v0.1.0
 	github.com/andreykaipov/goobs v1.5.6
+	github.com/aquasecurity/table v1.10.0
 	github.com/titusjaka/kong-dotenv-go v0.1.0
 )
 
@@ -14,9 +15,13 @@ require (
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/hashicorp/logutils v1.0.0 // indirect
 	github.com/joho/godotenv v1.5.1 // indirect
+	github.com/mattn/go-runewidth v0.0.13 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mmcloughlin/profile v0.1.1 // indirect
 	github.com/muesli/mango v0.1.1-0.20220205060214-77e2058169ab // indirect
 	github.com/muesli/roff v0.1.0 // indirect
 	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	golang.org/x/sys v0.1.0 // indirect
+	golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
 )

go.sum

@@ -8,6 +8,8 @@ github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/andreykaipov/goobs v1.5.6 h1:eIkEqYN99+2VJvmlY/56Ah60nkRKS6efMQvpM3oUgPQ=
 github.com/andreykaipov/goobs v1.5.6/go.mod h1:iSZP93FJ4d9X/U1x4DD4IyILLtig+vViqZWBGjLywcY=
+github.com/aquasecurity/table v1.10.0 h1:gPWV28qp9XSlvXdT3ku8yKQoZE6II0vsmegKpW+dB08=
+github.com/aquasecurity/table v1.10.0/go.mod h1:eqOmvjjB7AhXFgFqpJUEE/ietg7RrMSJZXyTN8E/wZw=
 github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
 github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -20,6 +22,8 @@ github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUq
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mmcloughlin/profile v0.1.1 h1:jhDmAqPyebOsVDOCICJoINoLb/AnLBaUw58nFzxWS2w=
@@ -32,9 +36,15 @@ github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/
 github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/titusjaka/kong-dotenv-go v0.1.0 h1:TmUjP/sXoNiKLr6oR7n9xrB5XyXi/Ssuebzfz5nxZj4=
 github.com/titusjaka/kong-dotenv-go v0.1.0/go.mod h1:pBgLjcu82oqUgb7+bngK9+Ch7jg49E0YADP8Wnj2MXU=
+golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 h1:CBpWXWQpIRjzmkkA+M7q9Fqnwd2mZr3AFqexg8YTfoM=
+golang.org/x/term v0.0.0-20220526004731-065cf7ba2467/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

group.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/andreykaipov/goobs/api/requests/sceneitems"
+	"github.com/aquasecurity/table"
 )
 
 // GroupCmd provides commands to manage groups in OBS Studio.
@@ -17,21 +18,36 @@ type GroupCmd struct {
 
 // GroupListCmd provides a command to list all groups in a scene.
 type GroupListCmd struct {
-	SceneName string `arg:"" help:"Name of the scene to list groups from."`
+	SceneName string `arg:"" help:"Name of the scene to list groups from." default:""`
 }
 
 // Run executes the command to list all groups in a scene.
 func (cmd *GroupListCmd) Run(ctx *context) error {
+	if cmd.SceneName == "" {
+		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
+		if err != nil {
+			return fmt.Errorf("failed to get current program scene: %w", err)
+		}
+		cmd.SceneName = currentScene.SceneName
+	}
+
 	resp, err := ctx.Client.SceneItems.GetSceneItemList(sceneitems.NewGetSceneItemListParams().
 		WithSceneName(cmd.SceneName))
 	if err != nil {
 		return fmt.Errorf("failed to get scene item list: %w", err)
 	}
+
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter)
+	t.SetHeaders("ID", "Group Name", "Enabled")
+
 	for _, item := range resp.SceneItems {
 		if item.IsGroup {
-			fmt.Fprintf(ctx.Out, "Group ID: %d, Source Name: %s\n", item.SceneItemID, item.SourceName)
+			t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, getEnabledMark(item.SceneItemEnabled))
 		}
 	}
+	t.Render()
 	return nil
 }
 

hotkey.go

@@ -1,10 +1,9 @@
 package main
 
 import (
-	"fmt"
-
 	"github.com/andreykaipov/goobs/api/requests/general"
 	"github.com/andreykaipov/goobs/api/typedefs"
+	"github.com/aquasecurity/table"
 )
 
 // HotkeyCmd provides commands to manage hotkeys in OBS Studio.
@@ -24,9 +23,15 @@ func (cmd *HotkeyListCmd) Run(ctx *context) error {
 		return err
 	}
 
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft)
+	t.SetHeaders("Hotkey Name")
+
 	for _, hotkey := range resp.Hotkeys {
-		fmt.Fprintln(ctx.Out, hotkey)
+		t.AddRow(hotkey)
 	}
+	t.Render()
 	return nil
 }
 

input.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/andreykaipov/goobs/api/requests/inputs"
+	"github.com/aquasecurity/table"
 )
 
 // InputCmd provides commands to manage inputs in OBS Studio.
@@ -20,6 +21,8 @@ type InputListCmd struct {
 	Input  bool `flag:"" help:"List all inputs."         aliases:"i"`
 	Output bool `flag:"" help:"List all outputs."        aliases:"o"`
 	Colour bool `flag:"" help:"List all colour sources." aliases:"c"`
+	Ffmpeg bool `flag:"" help:"List all ffmpeg sources." aliases:"f"`
+	Vlc    bool `flag:"" help:"List all VLC sources."    aliases:"v"`
 }
 
 // Run executes the command to list all inputs.
@@ -28,21 +31,53 @@ func (cmd *InputListCmd) Run(ctx *context) error {
 	if err != nil {
 		return err
 	}
+
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft, table.AlignLeft, table.AlignCenter)
+	t.SetHeaders("Input Name", "Kind", "Muted")
+
 	for _, input := range resp.Inputs {
-		if cmd.Input && strings.Contains(input.InputKind, "input") {
-			fmt.Fprintln(ctx.Out, "Input:", input.InputName)
-		}
-		if cmd.Output && strings.Contains(input.InputKind, "output") {
-			fmt.Fprintln(ctx.Out, "Output:", input.InputName)
-		}
-		if cmd.Colour && strings.Contains(input.InputKind, "color") { // nolint
-			fmt.Fprintln(ctx.Out, "Colour Source:", input.InputName)
+		var muteMark string
+		for _, kind := range []string{"input", "output", "ffmpeg", "vlc"} {
+			if strings.Contains(input.InputKind, kind) {
+				resp, err := ctx.Client.Inputs.GetInputMute(
+					inputs.NewGetInputMuteParams().WithInputName(input.InputName),
+				)
+				if err != nil {
+					return fmt.Errorf("failed to get input mute state: %w", err)
+				}
+				muteMark = getEnabledMark(resp.InputMuted)
+				break
+			}
 		}
 
-		if !cmd.Input && !cmd.Output && !cmd.Colour {
-			fmt.Fprintln(ctx.Out, "Source:", input.InputName)
+		type filter struct {
+			enabled bool
+			keyword string
+		}
+		filters := []filter{
+			{cmd.Input, "input"},
+			{cmd.Output, "output"},
+			{cmd.Colour, "color"}, // nolint: misspell
+			{cmd.Ffmpeg, "ffmpeg"},
+			{cmd.Vlc, "vlc"},
+		}
+
+		var added bool
+		for _, f := range filters {
+			if f.enabled && strings.Contains(input.InputKind, f.keyword) {
+				t.AddRow(input.InputName, input.InputKind, muteMark)
+				added = true
+				break
+			}
+		}
+
+		if !added && (!cmd.Input && !cmd.Output && !cmd.Colour && !cmd.Ffmpeg && !cmd.Vlc) {
+			t.AddRow(input.InputName, input.InputKind, muteMark)
 		}
 	}
+	t.Render()
 	return nil
 }
 

input_test.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestInputList(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &InputListCmd{}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list inputs: %v", err)
+	}
+
+	expectedInputs := []string{
+		"Desktop Audio",
+		"Mic/Aux",
+		"Colour Source",
+		"Colour Source 2",
+		"Colour Source 3",
+	}
+	output := out.String()
+	for _, input := range expectedInputs {
+		if !strings.Contains(output, input) {
+			t.Fatalf("Expected output to contain '%s', got '%s'", input, output)
+		}
+	}
+}
+
+func TestInputListFilterInput(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &InputListCmd{Input: true}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list inputs with filter: %v", err)
+	}
+
+	expectedInputs := []string{
+		"Mic/Aux",
+	}
+	expectedFilteredOut := []string{
+		"Desktop Audio",
+		"Colour Source",
+		"Colour Source 2",
+		"Colour Source 3",
+	}
+	for _, input := range expectedInputs {
+		if !strings.Contains(out.String(), input) {
+			t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
+		}
+	}
+	for _, filteredOut := range expectedFilteredOut {
+		if strings.Contains(out.String(), filteredOut) {
+			t.Fatalf("Expected output to NOT contain '%s', got '%s'", filteredOut, out.String())
+		}
+	}
+}
+
+func TestInputListFilterOutput(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &InputListCmd{Output: true}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list outputs with filter: %v", err)
+	}
+
+	expectedInputs := []string{
+		"Desktop Audio",
+	}
+	expectedFilteredOut := []string{
+		"Mic/Aux",
+		"Colour Source",
+		"Colour Source 2",
+		"Colour Source 3",
+	}
+	for _, input := range expectedInputs {
+		if !strings.Contains(out.String(), input) {
+			t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
+		}
+	}
+	for _, filteredOut := range expectedFilteredOut {
+		if strings.Contains(out.String(), filteredOut) {
+			t.Fatalf("Expected output to NOT contain '%s', got '%s'", filteredOut, out.String())
+		}
+	}
+}
+
+func TestInputListFilterColour(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &InputListCmd{Colour: true}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list colour inputs with filter: %v", err)
+	}
+
+	expectedInputs := []string{
+		"Colour Source",
+		"Colour Source 2",
+		"Colour Source 3",
+	}
+	for _, input := range expectedInputs {
+		if !strings.Contains(out.String(), input) {
+			t.Fatalf("Expected output to contain '%s', got '%s'", input, out.String())
+		}
+	}
+}

main.go

@@ -18,10 +18,10 @@ import (
 
 // ObsConfig holds the configuration for connecting to the OBS WebSocket server.
 type ObsConfig struct {
-	Host     string `flag:"host"     help:"Host to connect to."          default:"localhost" env:"OBS_HOST"`
-	Port     int    `flag:"port"     help:"Port to connect to."          default:"4455"      env:"OBS_PORT"`
-	Password string `flag:"password" help:"Password for authentication." default:""          env:"OBS_PASSWORD"`
-	Timeout  int    `flag:"timeout"  help:"Timeout in seconds."          default:"5"         env:"OBS_TIMEOUT"`
+	Host     string `flag:"host"     help:"Host to connect to."          default:"localhost" env:"OBS_HOST"     short:"H"`
+	Port     int    `flag:"port"     help:"Port to connect to."          default:"4455"      env:"OBS_PORT"     short:"P"`
+	Password string `flag:"password" help:"Password for authentication." default:""          env:"OBS_PASSWORD" short:"p"`
+	Timeout  int    `flag:"timeout"  help:"Timeout in seconds."          default:"5"         env:"OBS_TIMEOUT"  short:"T"`
 }
 
 // CLI is the main command line interface structure.
@@ -29,22 +29,25 @@ type ObsConfig struct {
 type CLI struct {
 	ObsConfig `embed:"" help:"OBS WebSocket configuration."`
 
-	Man mangokong.ManFlag `help:"Print man page."`
+	Man     mangokong.ManFlag `help:"Print man page."`
+	Version VersionFlag       `help:"Print gobs-cli version information and quit" name:"version" short:"v"`
 
-	Version         VersionCmd         `help:"Show version."             cmd:"" aliases:"v"`
-	Scene           SceneCmd           `help:"Manage scenes."            cmd:"" aliases:"sc"`
-	Sceneitem       SceneItemCmd       `help:"Manage scene items."       cmd:"" aliases:"si"`
-	Group           GroupCmd           `help:"Manage groups."            cmd:"" aliases:"g"`
-	Input           InputCmd           `help:"Manage inputs."            cmd:"" aliases:"i"`
-	Record          RecordCmd          `help:"Manage recording."         cmd:"" aliases:"rec"`
-	Stream          StreamCmd          `help:"Manage streaming."         cmd:"" aliases:"st"`
-	Scenecollection SceneCollectionCmd `help:"Manage scene collections." cmd:"" aliases:"scn"`
-	Profile         ProfileCmd         `help:"Manage profiles."          cmd:"" aliases:"p"`
-	Replaybuffer    ReplayBufferCmd    `help:"Manage replay buffer."     cmd:"" aliases:"rb"`
-	Studiomode      StudioModeCmd      `help:"Manage studio mode."       cmd:"" aliases:"sm"`
-	Virtualcam      VirtualCamCmd      `help:"Manage virtual camera."    cmd:"" aliases:"vc"`
-	Hotkey          HotkeyCmd          `help:"Manage hotkeys."           cmd:"" aliases:"hk"`
-	Filter          FilterCmd          `help:"Manage filters."           cmd:"" aliases:"f"`
+	ObsVersion      ObsVersionCmd      `help:"Print OBS client and websocket version." cmd:"" aliases:"v"`
+	Scene           SceneCmd           `help:"Manage scenes."                          cmd:"" aliases:"sc"`
+	Sceneitem       SceneItemCmd       `help:"Manage scene items."                     cmd:"" aliases:"si"`
+	Group           GroupCmd           `help:"Manage groups."                          cmd:"" aliases:"g"`
+	Input           InputCmd           `help:"Manage inputs."                          cmd:"" aliases:"i"`
+	Record          RecordCmd          `help:"Manage recording."                       cmd:"" aliases:"rec"`
+	Stream          StreamCmd          `help:"Manage streaming."                       cmd:"" aliases:"st"`
+	Scenecollection SceneCollectionCmd `help:"Manage scene collections."               cmd:"" aliases:"scn"`
+	Profile         ProfileCmd         `help:"Manage profiles."                        cmd:"" aliases:"p"`
+	Replaybuffer    ReplayBufferCmd    `help:"Manage replay buffer."                   cmd:"" aliases:"rb"`
+	Studiomode      StudioModeCmd      `help:"Manage studio mode."                     cmd:"" aliases:"sm"`
+	Virtualcam      VirtualCamCmd      `help:"Manage virtual camera."                  cmd:"" aliases:"vc"`
+	Hotkey          HotkeyCmd          `help:"Manage hotkeys."                         cmd:"" aliases:"hk"`
+	Filter          FilterCmd          `help:"Manage filters."                         cmd:"" aliases:"f"`
+	Projector       ProjectorCmd       `help:"Manage projectors."                      cmd:"" aliases:"prj"`
+	Screenshot      ScreenshotCmd      `help:"Take screenshots."                       cmd:"" aliases:"ss"`
 }
 
 type context struct {

main_test.go

@@ -6,8 +6,10 @@ import (
 
 	"github.com/andreykaipov/goobs"
 	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/andreykaipov/goobs/api/requests/filters"
 	"github.com/andreykaipov/goobs/api/requests/inputs"
 	"github.com/andreykaipov/goobs/api/requests/scenes"
+	"github.com/andreykaipov/goobs/api/requests/ui"
 	typedefs "github.com/andreykaipov/goobs/api/typedefs"
 )
 
@@ -87,9 +89,39 @@ func setup(client *goobs.Client) {
 			"visible": true,
 		}).
 		WithSceneItemEnabled(true))
+
+	// Create source filter on an audio input
+	client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
+		WithSourceName("Mic/Aux").
+		WithFilterName("test_filter").
+		WithFilterKind("compressor_filter").
+		WithFilterSettings(map[string]any{
+			"threshold":        -20,
+			"ratio":            4,
+			"attack_time":      10,
+			"release_time":     100,
+			"output_gain":      -3.6,
+			"sidechain_source": nil,
+		}))
+
+	// Create source filter on a scene
+	client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
+		WithSourceName("gobs-test").
+		WithFilterName("test_filter").
+		WithFilterKind("luma_key_filter_v2").
+		WithFilterSettings(map[string]any{
+			"luma": 0.5,
+		}))
 }
 
 func teardown(client *goobs.Client) {
+	client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
+		WithSourceName("Mic/Aux").
+		WithFilterName("test_filter"))
+	client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
+		WithSourceName("gobs-test").
+		WithFilterName("test_filter"))
+
 	client.Scenes.RemoveScene(scenes.NewRemoveSceneParams().
 		WithSceneName("gobs-test"))
 
@@ -98,4 +130,7 @@ func teardown(client *goobs.Client) {
 
 	client.Stream.StopStream()
 	client.Record.StopRecord()
+	client.Outputs.StopReplayBuffer()
+	client.Ui.SetStudioModeEnabled(ui.NewSetStudioModeEnabledParams().
+		WithStudioModeEnabled(false))
 }

profile.go

@@ -5,6 +5,7 @@ import (
 	"slices"
 
 	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/aquasecurity/table"
 )
 
 // ProfileCmd provides commands to manage profiles in OBS Studio.
@@ -26,10 +27,20 @@ func (cmd *ProfileListCmd) Run(ctx *context) error {
 		return err
 	}
 
-	for _, profile := range profiles.Profiles {
-		fmt.Fprintln(ctx.Out, profile)
-	}
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft, table.AlignCenter)
+	t.SetHeaders("Profile Name", "Current")
 
+	for _, profile := range profiles.Profiles {
+		var enabledMark string
+		if profile == profiles.CurrentProfileName {
+			enabledMark = getEnabledMark(true)
+		}
+
+		t.AddRow(profile, enabledMark)
+	}
+	t.Render()
 	return nil
 }
 

projector.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/ui"
+	"github.com/aquasecurity/table"
+)
+
+// ProjectorCmd provides a command to manage projectors in OBS.
+type ProjectorCmd struct {
+	ListMonitors ProjectorListMonitorsCmd `cmd:"" help:"List available monitors."                                        aliases:"ls-m"`
+	Open         ProjectorOpenCmd         `cmd:"" help:"Open a fullscreen projector for a source on a specific monitor." aliases:"o"`
+}
+
+// ProjectorListMonitorsCmd provides a command to list all monitors available for projectors.
+type ProjectorListMonitorsCmd struct{} // size = 0x0
+
+// Run executes the command to list all monitors available for projectors.
+func (cmd *ProjectorListMonitorsCmd) Run(ctx *context) error {
+	monitors, err := ctx.Client.Ui.GetMonitorList()
+	if err != nil {
+		return err
+	}
+
+	if len(monitors.Monitors) == 0 {
+		ctx.Out.Write([]byte("No monitors found for projectors.\n"))
+		return nil
+	}
+
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignCenter, table.AlignLeft)
+	t.SetHeaders("Monitor ID", "Monitor Name")
+
+	for _, monitor := range monitors.Monitors {
+		t.AddRow(fmt.Sprintf("%d", monitor.MonitorIndex), monitor.MonitorName)
+	}
+
+	t.Render()
+	return nil
+}
+
+// ProjectorOpenCmd provides a command to open a fullscreen projector for a specific source.
+type ProjectorOpenCmd struct {
+	MonitorIndex int    `flag:"" help:"Index of the monitor to open the projector on." default:"0"`
+	SourceName   string `        help:"Name of the source to project."                 default:""  arg:""`
+}
+
+// Run executes the command to show details of a specific projector.
+func (cmd *ProjectorOpenCmd) Run(ctx *context) error {
+	if cmd.SourceName == "" {
+		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
+		if err != nil {
+			return fmt.Errorf("failed to get current program scene: %w", err)
+		}
+		cmd.SourceName = currentScene.SceneName
+	}
+
+	ctx.Client.Ui.OpenSourceProjector(ui.NewOpenSourceProjectorParams().
+		WithSourceName(cmd.SourceName).
+		WithMonitorIndex(cmd.MonitorIndex))
+
+	fmt.Fprintf(ctx.Out, "Opened projector for source '%s' on monitor index %d.\n", cmd.SourceName, cmd.MonitorIndex)
+	return nil
+}

record.go

@@ -2,16 +2,19 @@ package main
 
 import (
 	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/config"
 )
 
 // RecordCmd handles the recording commands.
 type RecordCmd struct {
-	Start  RecordStartCmd  `cmd:"" help:"Start recording."       aliases:"s"`
-	Stop   RecordStopCmd   `cmd:"" help:"Stop recording."        aliases:"st"`
-	Toggle RecordToggleCmd `cmd:"" help:"Toggle recording."      aliases:"tg"`
-	Status RecordStatusCmd `cmd:"" help:"Show recording status." aliases:"ss"`
-	Pause  RecordPauseCmd  `cmd:"" help:"Pause recording."       aliases:"p"`
-	Resume RecordResumeCmd `cmd:"" help:"Resume recording."      aliases:"r"`
+	Start     RecordStartCmd     `cmd:"" help:"Start recording."             aliases:"s"`
+	Stop      RecordStopCmd      `cmd:"" help:"Stop recording."              aliases:"st"`
+	Toggle    RecordToggleCmd    `cmd:"" help:"Toggle recording."            aliases:"tg"`
+	Status    RecordStatusCmd    `cmd:"" help:"Show recording status."       aliases:"ss"`
+	Pause     RecordPauseCmd     `cmd:"" help:"Pause recording."             aliases:"p"`
+	Resume    RecordResumeCmd    `cmd:"" help:"Resume recording."            aliases:"r"`
+	Directory RecordDirectoryCmd `cmd:"" help:"Get/Set recording directory." aliases:"d"`
 }
 
 // RecordStartCmd starts the recording.
@@ -19,7 +22,19 @@ type RecordStartCmd struct{} // size = 0x0
 
 // Run executes the command to start recording.
 func (cmd *RecordStartCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Record.StartRecord()
+	status, err := ctx.Client.Record.GetRecordStatus()
+	if err != nil {
+		return err
+	}
+
+	if status.OutputActive {
+		if status.OutputPaused {
+			return fmt.Errorf("recording is already in progress and paused")
+		}
+		return fmt.Errorf("recording is already in progress")
+	}
+
+	_, err = ctx.Client.Record.StartRecord()
 	if err != nil {
 		return err
 	}
@@ -32,11 +47,20 @@ type RecordStopCmd struct{} // size = 0x0
 
 // Run executes the command to stop recording.
 func (cmd *RecordStopCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Record.StopRecord()
+	status, err := ctx.Client.Record.GetRecordStatus()
 	if err != nil {
 		return err
 	}
-	fmt.Fprintln(ctx.Out, "Recording stopped successfully.")
+
+	if !status.OutputActive {
+		return fmt.Errorf("recording is not in progress")
+	}
+
+	resp, err := ctx.Client.Record.StopRecord()
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "%s", fmt.Sprintf("Recording stopped successfully. Output file: %s\n", resp.OutputPath))
 	return nil
 }
 
@@ -132,3 +156,30 @@ func (cmd *RecordResumeCmd) Run(ctx *context) error {
 	fmt.Fprintln(ctx.Out, "Recording resumed successfully.")
 	return nil
 }
+
+// RecordDirectoryCmd sets the recording directory.
+type RecordDirectoryCmd struct {
+	RecordDirectory string `arg:"" help:"Directory to save recordings." default:""`
+}
+
+// Run executes the command to set the recording directory.
+func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
+	if cmd.RecordDirectory == "" {
+		resp, err := ctx.Client.Config.GetRecordDirectory()
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Current recording directory: %s\n", resp.RecordDirectory)
+		return nil
+	}
+
+	_, err := ctx.Client.Config.SetRecordDirectory(
+		config.NewSetRecordDirectoryParams().WithRecordDirectory(cmd.RecordDirectory),
+	)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", cmd.RecordDirectory)
+	return nil
+}

record_test.go

@@ -2,11 +2,12 @@ package main
 
 import (
 	"bytes"
+	"strings"
 	"testing"
 	"time"
 )
 
-func TestRecordStartStatusStop(t *testing.T) {
+func TestRecordStart(t *testing.T) {
 	client, disconnect := getClient(t)
 	defer disconnect()
 
@@ -16,51 +17,80 @@ func TestRecordStartStatusStop(t *testing.T) {
 		Out:    &out,
 	}
 
-	cmdStart := &RecordStartCmd{}
-	err := cmdStart.Run(context)
+	cmdStatus := &RecordStatusCmd{}
+	err := cmdStatus.Run(context)
 	if err != nil {
-		t.Fatalf("Failed to start recording: %v", err)
+		t.Fatalf("Failed to get recording status: %v", err)
 	}
-	if out.String() != "Recording started successfully.\n" {
-		t.Fatalf("Expected output to be 'Recording started successfully.', got '%s'", out.String())
+	var active bool
+	if out.String() == "Recording is in progress.\n" {
+		active = true
 	}
 	// Reset output buffer for the next command
 	out.Reset()
 
-	time.Sleep(1 * time.Second) // Wait for a second to ensure recording has started
+	cmdStart := &RecordStartCmd{}
+	err = cmdStart.Run(context)
+	if active {
+		if err == nil {
+			t.Fatalf("Expected error when starting recording while active, got nil")
+		}
+		if !strings.Contains(err.Error(), "recording is already in progress") {
+			t.Fatalf("Expected error message to contain 'recording is already in progress', got '%s'", err.Error())
+		}
+		return
+	}
+
+	if err != nil {
+		t.Fatalf("Failed to start recording: %v", err)
+	}
+	if out.String() != "Recording started successfully.\n" {
+		t.Fatalf("Expected output to contain 'Recording started successfully.', got '%s'", out.String())
+	}
+	time.Sleep(1 * time.Second) // Wait for the recording to start
+}
+
+func TestRecordStop(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
 
 	cmdStatus := &RecordStatusCmd{}
-	err = cmdStatus.Run(context)
+	err := cmdStatus.Run(context)
 	if err != nil {
 		t.Fatalf("Failed to get recording status: %v", err)
 	}
-	if out.String() != "Recording is in progress.\n" {
-		t.Fatalf("Expected output to be 'Recording is in progress.', got '%s'", out.String())
+	var active bool
+	if out.String() == "Recording is in progress.\n" {
+		active = true
 	}
 	// Reset output buffer for the next command
 	out.Reset()
 
 	cmdStop := &RecordStopCmd{}
 	err = cmdStop.Run(context)
+	if !active {
+		if err == nil {
+			t.Fatalf("Expected error when stopping recording while inactive, got nil")
+		}
+		if !strings.Contains(err.Error(), "recording is not in progress") {
+			t.Fatalf("Expected error message to contain 'recording is not in progress', got '%s'", err.Error())
+		}
+		return
+	}
+
 	if err != nil {
 		t.Fatalf("Failed to stop recording: %v", err)
 	}
-	if out.String() != "Recording stopped successfully.\n" {
-		t.Fatalf("Expected output to be 'Recording stopped successfully.', got '%s'", out.String())
-	}
-	// Reset output buffer for the next command
-	out.Reset()
-
-	time.Sleep(1 * time.Second) // Wait for a second to ensure recording has stopped
-
-	cmdStatus = &RecordStatusCmd{}
-	err = cmdStatus.Run(context)
-	if err != nil {
-		t.Fatalf("Failed to get recording status: %v", err)
-	}
-	if out.String() != "Recording is not in progress.\n" {
-		t.Fatalf("Expected output to be 'Recording is not in progress.', got '%s'", out.String())
+	if !strings.Contains(out.String(), "Recording stopped successfully. Output file: ") {
+		t.Fatalf("Expected output to contain 'Recording stopped successfully. Output file: ', got '%s'", out.String())
 	}
+	time.Sleep(1 * time.Second) // Wait for the recording to stop
 }
 
 func TestRecordToggle(t *testing.T) {

replaybuffer.go

@@ -19,7 +19,11 @@ type ReplayBufferStartCmd struct{} // size = 0x0
 // Run executes the command to start the replay buffer.
 func (cmd *ReplayBufferStartCmd) Run(ctx *context) error {
 	_, err := ctx.Client.Outputs.StartReplayBuffer()
-	return err
+	if err != nil {
+		return fmt.Errorf("failed to start replay buffer: %w", err)
+	}
+	fmt.Fprintln(ctx.Out, "Replay buffer started.")
+	return nil
 }
 
 // ReplayBufferStopCmd stops the replay buffer.
@@ -28,7 +32,11 @@ type ReplayBufferStopCmd struct{} // size = 0x0
 // Run executes the command to stop the replay buffer.
 func (cmd *ReplayBufferStopCmd) Run(ctx *context) error {
 	_, err := ctx.Client.Outputs.StopReplayBuffer()
-	return err
+	if err != nil {
+		return fmt.Errorf("failed to stop replay buffer: %w", err)
+	}
+	fmt.Fprintln(ctx.Out, "Replay buffer stopped.")
+	return nil
 }
 
 // ReplayBufferToggleCmd toggles the replay buffer state.
@@ -42,9 +50,9 @@ func (cmd *ReplayBufferToggleCmd) Run(ctx *context) error {
 	}
 
 	if status.OutputActive {
-		fmt.Fprintln(ctx.Out, "Replay buffer started successfully.")
+		fmt.Fprintln(ctx.Out, "Replay buffer started.")
 	} else {
-		fmt.Fprintln(ctx.Out, "Replay buffer stopped successfully.")
+		fmt.Fprintln(ctx.Out, "Replay buffer stopped.")
 	}
 	return nil
 }

replaybuffer_test.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestReplayBufferStart(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &ReplayBufferStartCmd{}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to start replay buffer: %v", err)
+	}
+	if out.String() != "Replay buffer started.\n" {
+		t.Fatalf("Expected output to be 'Replay buffer started', got '%s'", out.String())
+	}
+}
+
+func TestReplayBufferStop(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &ReplayBufferStopCmd{}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to stop replay buffer: %v", err)
+	}
+	if out.String() != "Replay buffer stopped.\n" {
+		t.Fatalf("Expected output to be 'Replay buffer stopped.', got '%s'", out.String())
+	}
+}
+
+func TestReplayBufferToggle(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStatus := &ReplayBufferStatusCmd{}
+	err := cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get replay buffer status: %v", err)
+	}
+	var active bool
+	if strings.Contains(out.String(), "Replay buffer is active") {
+		active = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdToggle := &ReplayBufferToggleCmd{}
+	err = cmdToggle.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to toggle replay buffer: %v", err)
+	}
+	if active {
+		if out.String() != "Replay buffer stopped.\n" {
+			t.Fatalf("Expected output to be 'Replay buffer stopped.', got '%s'", out.String())
+		}
+	} else {
+		if out.String() != "Replay buffer started.\n" {
+			t.Fatalf("Expected output to be 'Replay buffer started.', got '%s'", out.String())
+		}
+	}
+}

scene.go

@@ -5,6 +5,7 @@ import (
 	"slices"
 
 	"github.com/andreykaipov/goobs/api/requests/scenes"
+	"github.com/aquasecurity/table"
 )
 
 // SceneCmd provides commands to manage scenes in OBS Studio.
@@ -24,10 +25,16 @@ func (cmd *SceneListCmd) Run(ctx *context) error {
 		return err
 	}
 
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft, table.AlignLeft)
+	t.SetHeaders("Scene Name", "UUID")
+
 	slices.Reverse(scenes.Scenes)
 	for _, scene := range scenes.Scenes {
-		fmt.Fprintln(ctx.Out, scene.SceneName)
+		t.AddRow(scene.SceneName, scene.SceneUuid)
 	}
+	t.Render()
 	return nil
 }
 

scenecollection.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/aquasecurity/table"
 )
 
 // SceneCollectionCmd provides commands to manage scene collections in OBS Studio.
@@ -24,10 +25,15 @@ func (cmd *SceneCollectionListCmd) Run(ctx *context) error {
 		return fmt.Errorf("failed to get scene collection list: %w", err)
 	}
 
-	for _, collection := range collections.SceneCollections {
-		fmt.Fprintln(ctx.Out, collection)
-	}
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignLeft)
+	t.SetHeaders("Scene Collection Name")
 
+	for _, collection := range collections.SceneCollections {
+		t.AddRow(collection)
+	}
+	t.Render()
 	return nil
 }
 

sceneitem.go

@@ -2,9 +2,11 @@ package main
 
 import (
 	"fmt"
+	"sort"
 
 	"github.com/andreykaipov/goobs"
 	"github.com/andreykaipov/goobs/api/requests/sceneitems"
+	"github.com/aquasecurity/table"
 )
 
 // SceneItemCmd provides commands to manage scene items in OBS Studio.
@@ -19,37 +21,83 @@ type SceneItemCmd struct {
 
 // SceneItemListCmd provides a command to list all scene items in a scene.
 type SceneItemListCmd struct {
-	SceneName string `arg:"" help:"Scene name."`
+	SceneName string `arg:"" help:"Name of the scene to list items from." default:""`
 }
 
 // Run executes the command to list all scene items in a scene.
 func (cmd *SceneItemListCmd) Run(ctx *context) error {
+	if cmd.SceneName == "" {
+		currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
+		if err != nil {
+			return fmt.Errorf("failed to get current program scene: %w", err)
+		}
+		cmd.SceneName = currentScene.SceneName
+	}
+
 	resp, err := ctx.Client.SceneItems.GetSceneItemList(sceneitems.NewGetSceneItemListParams().
 		WithSceneName(cmd.SceneName))
 	if err != nil {
 		return fmt.Errorf("failed to get scene item list: %w", err)
 	}
-	for _, item := range resp.SceneItems {
-		fmt.Fprintf(ctx.Out, "Item ID: %d, Source Name: %s\n", item.SceneItemID, item.SourceName)
+
+	if len(resp.SceneItems) == 0 {
+		fmt.Fprintf(ctx.Out, "No scene items found in scene '%s'.\n", cmd.SceneName)
+		return nil
 	}
+
+	t := table.New(ctx.Out)
+	t.SetPadding(3)
+	t.SetAlignment(table.AlignCenter, table.AlignLeft, table.AlignCenter, table.AlignCenter)
+	t.SetHeaders("Item ID", "Item Name", "In Group", "Enabled")
+
+	sort.Slice(resp.SceneItems, func(i, j int) bool {
+		return resp.SceneItems[i].SceneItemID < resp.SceneItems[j].SceneItemID
+	})
+
+	for _, item := range resp.SceneItems {
+		if item.IsGroup {
+			resp, err := ctx.Client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
+				WithSceneName(item.SourceName))
+			if err != nil {
+				return fmt.Errorf("failed to get group scene item list for '%s': %w", item.SourceName, err)
+			}
+
+			sort.Slice(resp.SceneItems, func(i, j int) bool {
+				return resp.SceneItems[i].SceneItemID < resp.SceneItems[j].SceneItemID
+			})
+
+			for _, groupItem := range resp.SceneItems {
+				t.AddRow(
+					fmt.Sprintf("%d", groupItem.SceneItemID),
+					groupItem.SourceName,
+					item.SourceName,
+					getEnabledMark(item.SceneItemEnabled && groupItem.SceneItemEnabled),
+				)
+			}
+		} else {
+			t.AddRow(fmt.Sprintf("%d", item.SceneItemID), item.SourceName, "", getEnabledMark(item.SceneItemEnabled))
+		}
+	}
+	t.Render()
 	return nil
 }
 
+// getSceneNameAndItemID retrieves the scene name and item ID for a given item in a scene or group.
 func getSceneNameAndItemID(
 	client *goobs.Client,
 	sceneName string,
 	itemName string,
-	parent string,
+	group string,
 ) (string, int, error) {
-	if parent != "" {
+	if group != "" {
 		resp, err := client.SceneItems.GetGroupSceneItemList(sceneitems.NewGetGroupSceneItemListParams().
-			WithSceneName(parent))
+			WithSceneName(group))
 		if err != nil {
 			return "", 0, err
 		}
 		for _, item := range resp.SceneItems {
 			if item.SourceName == itemName {
-				return parent, int(item.SceneItemID), nil
+				return group, int(item.SceneItemID), nil
 			}
 		}
 		return "", 0, fmt.Errorf("item '%s' not found in scene '%s'", itemName, sceneName)
@@ -66,7 +114,7 @@ func getSceneNameAndItemID(
 
 // SceneItemShowCmd provides a command to show a scene item.
 type SceneItemShowCmd struct {
-	Parent string `flag:"" help:"Parent group name."`
+	Group string `flag:"" help:"Parent group name."`
 
 	SceneName string `arg:"" help:"Scene name."`
 	ItemName  string `arg:"" help:"Item name."`
@@ -74,7 +122,7 @@ type SceneItemShowCmd struct {
 
 // Run executes the command to show a scene item.
 func (cmd *SceneItemShowCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@@ -87,8 +135,8 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
 		return err
 	}
 
-	if cmd.Parent != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now visible.\n", cmd.ItemName, cmd.Parent)
+	if cmd.Group != "" {
+		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now visible.\n", cmd.ItemName, cmd.Group)
 	} else {
 		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now visible.\n", cmd.ItemName, cmd.SceneName)
 	}
@@ -98,7 +146,7 @@ func (cmd *SceneItemShowCmd) Run(ctx *context) error {
 
 // SceneItemHideCmd provides a command to hide a scene item.
 type SceneItemHideCmd struct {
-	Parent string `flag:"" help:"Parent group name."`
+	Group string `flag:"" help:"Parent group name."`
 
 	SceneName string `arg:"" help:"Scene name."`
 	ItemName  string `arg:"" help:"Item name."`
@@ -106,7 +154,7 @@ type SceneItemHideCmd struct {
 
 // Run executes the command to hide a scene item.
 func (cmd *SceneItemHideCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@@ -119,8 +167,8 @@ func (cmd *SceneItemHideCmd) Run(ctx *context) error {
 		return err
 	}
 
-	if cmd.Parent != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now hidden.\n", cmd.ItemName, cmd.Parent)
+	if cmd.Group != "" {
+		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' is now hidden.\n", cmd.ItemName, cmd.Group)
 	} else {
 		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' is now hidden.\n", cmd.ItemName, cmd.SceneName)
 	}
@@ -141,7 +189,7 @@ func getItemEnabled(client *goobs.Client, sceneName string, itemID int) (bool, e
 
 // SceneItemToggleCmd provides a command to toggle the visibility of a scene item.
 type SceneItemToggleCmd struct {
-	Parent string `flag:"" help:"Parent group name."`
+	Group string `flag:"" help:"Parent group name."`
 
 	SceneName string `arg:"" help:"Scene name."`
 	ItemName  string `arg:"" help:"Item name."`
@@ -149,7 +197,7 @@ type SceneItemToggleCmd struct {
 
 // Run executes the command to toggle the visibility of a scene item.
 func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@@ -178,7 +226,7 @@ func (cmd *SceneItemToggleCmd) Run(ctx *context) error {
 
 // SceneItemVisibleCmd provides a command to check the visibility of a scene item.
 type SceneItemVisibleCmd struct {
-	Parent string `flag:"" help:"Parent group name."`
+	Group string `flag:"" help:"Parent group name."`
 
 	SceneName string `arg:"" help:"Scene name."`
 	ItemName  string `arg:"" help:"Item name."`
@@ -186,7 +234,7 @@ type SceneItemVisibleCmd struct {
 
 // Run executes the command to check the visibility of a scene item.
 func (cmd *SceneItemVisibleCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@@ -209,7 +257,7 @@ type SceneItemTransformCmd struct {
 	SceneName string `arg:"" help:"Scene name."`
 	ItemName  string `arg:"" help:"Item name."`
 
-	Parent string `flag:"" help:"Parent group name."`
+	Group string `flag:"" help:"Parent group name."`
 
 	Alignment       float64 `flag:"" help:"Alignment of the scene item."`
 	BoundsAlignment float64 `flag:"" help:"Bounds alignment of the scene item."`
@@ -230,7 +278,7 @@ type SceneItemTransformCmd struct {
 
 // Run executes the command to transform a scene item.
 func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
-	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Parent)
+	sceneName, sceneItemID, err := getSceneNameAndItemID(ctx.Client, cmd.SceneName, cmd.ItemName, cmd.Group)
 	if err != nil {
 		return err
 	}
@@ -302,8 +350,8 @@ func (cmd *SceneItemTransformCmd) Run(ctx *context) error {
 		return err
 	}
 
-	if cmd.Parent != "" {
-		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' transformed.\n", cmd.ItemName, cmd.Parent)
+	if cmd.Group != "" {
+		fmt.Fprintf(ctx.Out, "Scene item '%s' in group '%s' transformed.\n", cmd.ItemName, cmd.Group)
 	} else {
 		fmt.Fprintf(ctx.Out, "Scene item '%s' in scene '%s' transformed.\n", cmd.ItemName, cmd.SceneName)
 	}

screenshot.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/andreykaipov/goobs/api/requests/sources"
+)
+
+// ScreenshotCmd provides commands to manage screenshots in OBS Studio.
+type ScreenshotCmd struct {
+	Save ScreenshotSaveCmd `cmd:"" help:"Take a screenshot and save it to a file." aliases:"sv"`
+}
+
+// ScreenshotSaveCmd represents the command to save a screenshot of a source in OBS.
+type ScreenshotSaveCmd struct {
+	SourceName string  `arg:"" help:"Name of the source to take a screenshot of."`
+	FilePath   string  `arg:"" help:"Path to the file where the screenshot will be saved."`
+	Width      float64 `       help:"Width of the screenshot in pixels."                   flag:"" default:"1920"`
+	Height     float64 `       help:"Height of the screenshot in pixels."                  flag:"" default:"1080"`
+	Quality    float64 `       help:"Quality of the screenshot (1-100)."                   flag:"" default:"-1"`
+}
+
+// Run executes the command to take a screenshot and save it to a file.
+func (cmd *ScreenshotSaveCmd) Run(ctx *context) error {
+	_, err := ctx.Client.Sources.SaveSourceScreenshot(
+		sources.NewSaveSourceScreenshotParams().
+			WithSourceName(cmd.SourceName).
+			WithImageFormat(trimPrefix(filepath.Ext(cmd.FilePath), ".")).
+			WithImageFilePath(cmd.FilePath).
+			WithImageWidth(cmd.Width).
+			WithImageHeight(cmd.Height).
+			WithImageCompressionQuality(cmd.Quality),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to take screenshot: %w", err)
+	}
+
+	fmt.Fprintf(ctx.Out, "Screenshot saved to %s.\n", cmd.FilePath)
+	return nil
+}

stream.go

@@ -23,8 +23,7 @@ func (cmd *StreamStartCmd) Run(ctx *context) error {
 		return err
 	}
 	if status.OutputActive {
-		fmt.Fprintln(ctx.Out, "Stream is already active.")
-		return nil
+		return fmt.Errorf("stream is already in progress")
 	}
 
 	_, err = ctx.Client.Stream.StartStream()
@@ -32,7 +31,7 @@ func (cmd *StreamStartCmd) Run(ctx *context) error {
 		return err
 	}
 
-	fmt.Fprintln(ctx.Out, "Streaming started successfully.")
+	fmt.Fprintln(ctx.Out, "Stream started successfully.")
 	return nil
 }
 
@@ -47,8 +46,7 @@ func (cmd *StreamStopCmd) Run(ctx *context) error {
 		return err
 	}
 	if !status.OutputActive {
-		fmt.Fprintln(ctx.Out, "Stream is already inactive.")
-		return nil
+		return fmt.Errorf("stream is not in progress")
 	}
 
 	_, err = ctx.Client.Stream.StopStream()
@@ -56,7 +54,7 @@ func (cmd *StreamStopCmd) Run(ctx *context) error {
 		return err
 	}
 
-	fmt.Fprintln(ctx.Out, "Streaming stopped successfully.")
+	fmt.Fprintln(ctx.Out, "Stream stopped successfully.")
 	return nil
 }
 
@@ -71,9 +69,9 @@ func (cmd *StreamToggleCmd) Run(ctx *context) error {
 	}
 
 	if status.OutputActive {
-		fmt.Fprintln(ctx.Out, "Streaming started successfully.")
+		fmt.Fprintln(ctx.Out, "Stream started successfully.")
 	} else {
-		fmt.Fprintln(ctx.Out, "Streaming stopped successfully.")
+		fmt.Fprintln(ctx.Out, "Stream stopped successfully.")
 	}
 	return nil
 }

stream_test.go

@@ -31,21 +31,22 @@ func TestStreamStart(t *testing.T) {
 
 	cmdStart := &StreamStartCmd{}
 	err = cmdStart.Run(context)
+	if active {
+		if err == nil {
+			t.Fatalf("Expected error when starting stream while active, got nil")
+		}
+		if !strings.Contains(err.Error(), "stream is already in progress") {
+			t.Fatalf("Expected error message to contain 'stream is already in progress', got '%s'", err.Error())
+		}
+		return
+	}
 	if err != nil {
 		t.Fatalf("Failed to start stream: %v", err)
 	}
-
-	time.Sleep(1 * time.Second) // Wait for the stream to start
-
-	if active {
-		if out.String() != "Stream is already active.\n" {
-			t.Fatalf("Expected 'Stream is already active.', got: %s", out.String())
-		}
-	} else {
-		if out.String() != "Streaming started successfully.\n" {
-			t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
-		}
+	if out.String() != "Stream started successfully.\n" {
+		t.Fatalf("Expected output to contain 'Stream started successfully.', got '%s'", out.String())
 	}
+	time.Sleep(2 * time.Second) // Wait for the stream to start
 }
 
 func TestStreamStop(t *testing.T) {
@@ -72,21 +73,22 @@ func TestStreamStop(t *testing.T) {
 
 	cmdStop := &StreamStopCmd{}
 	err = cmdStop.Run(context)
+	if !active {
+		if err == nil {
+			t.Fatalf("Expected error when stopping stream while inactive, got nil")
+		}
+		if !strings.Contains(err.Error(), "stream is not in progress") {
+			t.Fatalf("Expected error message to contain 'stream is not in progress', got '%s'", err.Error())
+		}
+		return
+	}
 	if err != nil {
 		t.Fatalf("Failed to stop stream: %v", err)
 	}
-
-	time.Sleep(1 * time.Second) // Wait for the stream to stop
-
-	if active {
-		if out.String() != "Streaming stopped successfully.\n" {
-			t.Fatalf("Expected 'Streaming stopped successfully.', got: %s", out.String())
-		}
-	} else {
-		if out.String() != "Stream is already inactive.\n" {
-			t.Fatalf("Expected 'Stream is already inactive.', got: %s", out.String())
-		}
+	if out.String() != "Stream stopped successfully.\n" {
+		t.Fatalf("Expected output to contain 'Stream stopped successfully.', got '%s'", out.String())
 	}
+	time.Sleep(2 * time.Second) // Wait for the stream to stop
 }
 
 func TestStreamToggle(t *testing.T) {
@@ -117,15 +119,14 @@ func TestStreamToggle(t *testing.T) {
 		t.Fatalf("Failed to toggle stream: %v", err)
 	}
 
-	time.Sleep(1 * time.Second) // Wait for the stream to toggle
-
 	if active {
-		if out.String() != "Streaming stopped successfully.\n" {
-			t.Fatalf("Expected 'Streaming stopped successfully.', got: %s", out.String())
+		if out.String() != "Stream stopped successfully.\n" {
+			t.Fatalf("Expected 'Stream stopped successfully.', got: %s", out.String())
 		}
 	} else {
-		if out.String() != "Streaming started successfully.\n" {
-			t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
+		if out.String() != "Stream started successfully.\n" {
+			t.Fatalf("Expected 'Stream started successfully.', got: %s", out.String())
 		}
 	}
+	time.Sleep(2 * time.Second) // Wait for the stream to toggle
 }

util.go

@@ -0,0 +1,29 @@
+// Package util provides utility functions for the application.
+
+package main
+
+import "strings"
+
+func snakeCaseToTitleCase(snake string) string {
+	words := strings.Split(snake, "_")
+	for i, word := range words {
+		if len(word) > 0 {
+			words[i] = strings.ToUpper(word[:1]) + word[1:]
+		}
+	}
+	return strings.Join(words, " ")
+}
+
+func getEnabledMark(enabled bool) string {
+	if enabled {
+		return "\u2713" // green check mark
+	}
+	return "\u274c" // red cross mark
+}
+
+func trimPrefix(s, prefix string) string {
+	if strings.HasPrefix(s, prefix) {
+		return s[len(prefix):]
+	}
+	return s
+}

util_test.go

@@ -0,0 +1,20 @@
+package main
+
+import "testing"
+
+func TestSnakeCaseToTitleCase(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"hello_world", "Hello World"},
+		{"snake_case_to_title_case", "Snake Case To Title Case"},
+	}
+
+	for _, test := range tests {
+		result := snakeCaseToTitleCase(test.input)
+		if result != test.expected {
+			t.Errorf("Expected '%s' but got '%s'", test.expected, result)
+		}
+	}
+}

version.go

@@ -2,13 +2,43 @@ package main
 
 import (
 	"fmt"
+	"runtime/debug"
+	"strings"
+
+	"github.com/alecthomas/kong"
 )
 
-// VersionCmd handles the version command.
-type VersionCmd struct{} // size = 0x0
+var version string
+
+// VersionFlag is a custom flag type for displaying version information.
+type VersionFlag string
+
+// Decode implements the kong.Flag interface for VersionFlag.
+func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }
+
+// IsBool implements the kong.Flag interface for VersionFlag.
+func (v VersionFlag) IsBool() bool { return true }
+
+// BeforeApply implements the kong.Flag interface for VersionFlag.
+func (v VersionFlag) BeforeApply(app *kong.Kong, _ kong.Vars) error { // nolint: unparam
+	if version == "" {
+		info, ok := debug.ReadBuildInfo()
+		if !ok {
+			return fmt.Errorf("failed to read build info")
+		}
+		version = strings.Split(info.Main.Version, "-")[0]
+	}
+
+	fmt.Printf("gobs-cli version: %s\n", version)
+	app.Exit(0) // Exit the application after printing the version
+	return nil
+}
+
+// ObsVersionCmd handles the version command.
+type ObsVersionCmd struct{} // size = 0x0
 
 // Run executes the command to get the OBS client version.
-func (cmd *VersionCmd) Run(ctx *context) error {
+func (cmd *ObsVersionCmd) Run(ctx *context) error {
 	version, err := ctx.Client.General.GetVersion()
 	if err != nil {
 		return err

version_test.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestVersion(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &ObsVersionCmd{}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get version: %v", err)
+	}
+	if !strings.Contains(out.String(), "OBS Client Version:") {
+		t.Fatalf("Expected output to contain 'OBS Client Version:', got '%s'", out.String())
+	}
+	if !strings.Contains(out.String(), "with Websocket Version:") {
+		t.Fatalf("Expected output to contain 'with Websocket Version:', got '%s'", out.String())
+	}
+}

virtualcam.go

@@ -43,10 +43,16 @@ type VirtualCamToggleCmd struct{} // size = 0x0
 
 // Run executes the command to toggle the virtual camera.
 func (c *VirtualCamToggleCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Outputs.ToggleVirtualCam()
+	resp, err := ctx.Client.Outputs.ToggleVirtualCam()
 	if err != nil {
 		return fmt.Errorf("failed to toggle virtual camera: %w", err)
 	}
+
+	if resp.OutputActive {
+		fmt.Fprintln(ctx.Out, "Virtual camera is now active.")
+	} else {
+		fmt.Fprintln(ctx.Out, "Virtual camera is now inactive.")
+	}
 	return nil
 }