ensure studio mode disabled at end of tests

upd tests to reflect changes

CHANGELOG.md

@@ -5,12 +5,29 @@ 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.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 [Filter](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filtercmd)
+-   filter commands, see [FilterCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filtercmd)
 
 ### Changed
 
@@ -21,7 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 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

@@ -136,6 +136,7 @@ gobs-cli sceneitem visible --parent=test_group START "Colour Source 4"
 
 -   transform: Transform scene item.
     -   flags:
+        
         *optional*
         -   --parent: Parent group name.
 
@@ -280,6 +281,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.
@@ -523,6 +537,33 @@ 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: <source_name>
+        -   defaults to current scene
+
+```console
+gobs-cli project open
+
+gobs-cli projector open --monitor-index=1 "test_scene"
+
+gobs-cli projector open --monitor-index=1 "test_group"
+```
+
 
 [userconfigdir]: https://pkg.go.dev/os#UserConfigDir
 [obs-keyids]: https://github.com/obsproject/obs-studio/blob/master/libobs/obs-hotkeys.h

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

@@ -22,6 +22,6 @@ require (
 	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.0.0-20210615035016-665e8c7367d1 // indirect
+	golang.org/x/sys v0.1.0 // indirect
 	golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
 )

go.sum

@@ -42,8 +42,8 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 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.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
+golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+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=

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

@@ -45,6 +45,7 @@ type CLI struct {
 	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"`
 }
 
 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))
 }

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"`
+	Start     RecordStartCmd     `cmd:"" help:"Start recording."             aliases:"s"`
-	Stop   RecordStopCmd   `cmd:"" help:"Stop recording."        aliases:"st"`
+	Stop      RecordStopCmd      `cmd:"" help:"Stop recording."              aliases:"st"`
-	Toggle RecordToggleCmd `cmd:"" help:"Toggle recording."      aliases:"tg"`
+	Toggle    RecordToggleCmd    `cmd:"" help:"Toggle recording."            aliases:"tg"`
-	Status RecordStatusCmd `cmd:"" help:"Show recording status." aliases:"ss"`
+	Status    RecordStatusCmd    `cmd:"" help:"Show recording status."       aliases:"ss"`
-	Pause  RecordPauseCmd  `cmd:"" help:"Pause recording."       aliases:"p"`
+	Pause     RecordPauseCmd     `cmd:"" help:"Pause recording."             aliases:"p"`
-	Resume RecordResumeCmd `cmd:"" help:"Resume recording."      aliases:"r"`
+	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{}
+	cmdStatus := &RecordStatusCmd{}
-	err := cmdStart.Run(context)
+	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" {
+	var active bool
-		t.Fatalf("Expected output to be 'Recording started successfully.', got '%s'", out.String())
+	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" {
+	var active bool
-		t.Fatalf("Expected output to be 'Recording is in progress.', got '%s'", out.String())
+	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" {
+	if !strings.Contains(out.String(), "Recording stopped successfully. Output file: ") {
-		t.Fatalf("Expected output to be 'Recording stopped successfully.', got '%s'", out.String())
+		t.Fatalf("Expected output to contain 'Recording stopped successfully. Output file: ', 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())
 	}
+	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())
+		}
+	}
+}

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 fmt.Errorf("stream is already in progress")
-		return nil
 	}
 
 	_, 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 fmt.Errorf("stream is not in progress")
-		return nil
 	}
 
 	_, 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)
 	}
-
+	if out.String() != "Stream started successfully.\n" {
-	time.Sleep(1 * time.Second) // Wait for the stream to start
+		t.Fatalf("Expected output to contain 'Stream started successfully.', got '%s'", out.String())
-
-	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())
-		}
 	}
+	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)
 	}
-
+	if out.String() != "Stream stopped successfully.\n" {
-	time.Sleep(1 * time.Second) // Wait for the stream to stop
+		t.Fatalf("Expected output to contain 'Stream stopped successfully.', got '%s'", out.String())
-
-	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())
-		}
 	}
+	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" {
+		if out.String() != "Stream stopped successfully.\n" {
-			t.Fatalf("Expected 'Streaming stopped successfully.', got: %s", out.String())
+			t.Fatalf("Expected 'Stream stopped successfully.', got: %s", out.String())
 		}
 	} else {
-		if out.String() != "Streaming started successfully.\n" {
+		if out.String() != "Stream started successfully.\n" {
-			t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
+			t.Fatalf("Expected 'Stream started successfully.', got: %s", out.String())
 		}
 	}
+	time.Sleep(2 * time.Second) // Wait for the stream to toggle
 }

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 := &VersionCmd{}
+	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
 }