add filter commands

upd README, CHANGELOG

.gitignore

@@ -35,6 +35,3 @@ gobs-cli.1
 
 # Config files
 config.yaml
-
-# Test files
-*_test.go

CHANGELOG.md

@@ -5,11 +5,26 @@ 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.4.0] - 2025-05-07
+# [0.6.0] - 2025-05-25
+
+### Added
+
+-   filter commands, see [Filter](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#filter)
+
+# [0.5.0] - 2025-05-22
+
+### Added
+
+-   hotkey commands, see [Hotkey](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#hotkeycmd)
+
+# [0.4.2] - 2025-05-08
 
 ### Added
 
 -   replaybuffer toggle command
+-   studiomode enable/disable now print output to console
+-   stream start/stop now print output to console
+-   Unit tests
 
 # [0.3.1] - 2025-05-02
 
@@ -28,4 +43,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
--   Initial release.
+-   Initial release.

README.md

@@ -443,4 +443,76 @@ gobs-cli virtualcam toggle
 gobs-cli virtualcam status
 ```
 
-[userconfigdir]: https://pkg.go.dev/os#UserConfigDir
+### HotkeyCmd
+
+-   list: List all hotkeys.
+
+```console
+gobs-cli hotkey list
+```
+
+-   trigger: Trigger a hotkey by name.
+
+```console
+gobs-cli hotkey trigger OBSBasic.StartStreaming
+
+gobs-cli hotkey trigger OBSBasic.StopStreaming
+```
+
+-   trigger-sequence: Trigger a hotkey by sequence.
+    -   flags:
+
+        *optional*
+        -   --shift: Press shift.
+        -   --ctrl: Press control.
+        -   --alt: Press alt.
+        -   --cmd: Press command (mac).
+
+    -   args: keyID
+        -   Check [obs-hotkeys.h][obs-keyids] for a full list of OBS key ids.
+
+```console
+gobs-cli hotkey trigger-sequence OBS_KEY_F1 --ctrl
+
+gobs-cli hotkey trigger-sequence OBS_KEY_F1 --shift --ctrl
+```
+
+### FilterCmd
+
+-   list: List all filters.
+
+```console
+gobs-cli filter list
+```
+
+-   enable: Enable filter.
+    -   args: SourceName FilterName
+
+```console
+gobs-cli enable 'Mic/Aux' 'Gain'
+```
+
+-   disable: Disable filter.
+    -   args: SourceName FilterName
+
+```console
+gobs-cli disable 'Mic/Aux' 'Gain'
+```
+
+-   toggle: Toggle filter.
+    -   args: SourceName FilterName
+
+```console
+gobs-cli toggle 'Mic/Aux' 'Gain'
+```
+
+-   status: Get filter status.
+    -   args: SourceName FilterName
+
+```console
+gobs-cli status 'Mic/Aux' 'Gain'
+```
+
+
+[userconfigdir]: https://pkg.go.dev/os#UserConfigDir
+[obs-keyids]: https://github.com/obsproject/obs-studio/blob/master/libobs/obs-hotkeys.h

filter.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/filters"
+)
+
+// FilterCmd provides commands to manage filters in OBS Studio.
+type FilterCmd struct {
+	List    FilterListCmd    `cmd:"" help:"List all filters."  aliases:"ls"`
+	Enable  FilterEnableCmd  `cmd:"" help:"Enable filter."     aliases:"on"`
+	Disable FilterDisableCmd `cmd:"" help:"Disable filter."    aliases:"off"`
+	Toggle  FilterToggleCmd  `cmd:"" help:"Toggle filter."     aliases:"tg"`
+	Status  FilterStatusCmd  `cmd:"" help:"Get filter status." aliases:"ss"`
+}
+
+// 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."`
+}
+
+// Run executes the command to list all filters in a scene.
+func (cmd *FilterListCmd) Run(ctx *context) error {
+	filters, 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)
+	}
+	return nil
+}
+
+// FilterEnableCmd provides a command to enable a filter in a scene.
+type FilterEnableCmd struct {
+	SourceName string `arg:"" help:"Name of the source to enable filter from."`
+	FilterName string `arg:"" help:"Name of the filter to enable."`
+}
+
+// Run executes the command to enable a filter in a scene.
+func (cmd *FilterEnableCmd) Run(ctx *context) error {
+	_, err := ctx.Client.Filters.SetSourceFilterEnabled(
+		filters.NewSetSourceFilterEnabledParams().
+			WithSourceName(cmd.SourceName).
+			WithFilterName(cmd.FilterName).
+			WithFilterEnabled(true),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to enable filter %s on source %s: %w",
+			cmd.FilterName, cmd.SourceName, err)
+	}
+	fmt.Fprintf(ctx.Out, "Filter %s enabled on source %s.\n",
+		cmd.FilterName, cmd.SourceName)
+	return nil
+}
+
+// FilterDisableCmd provides a command to disable a filter in a scene.
+type FilterDisableCmd struct {
+	SourceName string `arg:"" help:"Name of the source to disable filter from."`
+	FilterName string `arg:"" help:"Name of the filter to disable."`
+}
+
+// Run executes the command to disable a filter in a scene.
+func (cmd *FilterDisableCmd) Run(ctx *context) error {
+	_, err := ctx.Client.Filters.SetSourceFilterEnabled(
+		filters.NewSetSourceFilterEnabledParams().
+			WithSourceName(cmd.SourceName).
+			WithFilterName(cmd.FilterName).
+			WithFilterEnabled(false),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to disable filter %s on source %s: %w",
+			cmd.FilterName, cmd.SourceName, err)
+	}
+	fmt.Fprintf(ctx.Out, "Filter %s disabled on source %s.\n",
+		cmd.FilterName, cmd.SourceName)
+	return nil
+}
+
+// FilterToggleCmd provides a command to toggle a filter in a scene.
+type FilterToggleCmd struct {
+	SourceName string `arg:"" help:"Name of the source to toggle filter from."`
+	FilterName string `arg:"" help:"Name of the filter to toggle."`
+}
+
+// Run executes the command to toggle a filter in a scene.
+func (cmd *FilterToggleCmd) Run(ctx *context) error {
+	filter, err := ctx.Client.Filters.GetSourceFilter(
+		filters.NewGetSourceFilterParams().
+			WithSourceName(cmd.SourceName).
+			WithFilterName(cmd.FilterName),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get filter %s on source %s: %w",
+			cmd.FilterName, cmd.SourceName, err)
+	}
+
+	newStatus := !filter.FilterEnabled
+	_, err = ctx.Client.Filters.SetSourceFilterEnabled(
+		filters.NewSetSourceFilterEnabledParams().
+			WithSourceName(cmd.SourceName).
+			WithFilterName(cmd.FilterName).
+			WithFilterEnabled(newStatus),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to toggle filter %s on source %s: %w",
+			cmd.FilterName, cmd.SourceName, err)
+	}
+
+	if newStatus {
+		fmt.Fprintf(ctx.Out, "Filter %s on source %s is now enabled.\n",
+			cmd.FilterName, cmd.SourceName)
+	} else {
+		fmt.Fprintf(ctx.Out, "Filter %s on source %s is now disabled.\n",
+			cmd.FilterName, cmd.SourceName)
+	}
+	return nil
+}
+
+// FilterStatusCmd provides a command to get the status of a filter in a scene.
+type FilterStatusCmd struct {
+	SourceName string `arg:"" help:"Name of the source to get filter status from."`
+	FilterName string `arg:"" help:"Name of the filter to get status."`
+}
+
+// Run executes the command to get the status of a filter in a scene.
+func (cmd *FilterStatusCmd) Run(ctx *context) error {
+	filter, err := ctx.Client.Filters.GetSourceFilter(
+		filters.NewGetSourceFilterParams().
+			WithSourceName(cmd.SourceName).
+			WithFilterName(cmd.FilterName),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get status of filter %s on source %s: %w",
+			cmd.FilterName, cmd.SourceName, err)
+	}
+	if filter.FilterEnabled {
+		fmt.Fprintf(ctx.Out, "Filter %s on source %s is enabled.\n",
+			cmd.FilterName, cmd.SourceName)
+	} else {
+		fmt.Fprintf(ctx.Out, "Filter %s on source %s is disabled.\n",
+			cmd.FilterName, cmd.SourceName)
+	}
+	return nil
+}

group_test.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestGroupList(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &GroupListCmd{
+		SceneName: "Scene",
+	}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list groups: %v", err)
+	}
+	if !strings.Contains(out.String(), "test_group") {
+		t.Fatalf("Expected output to contain 'test_group', got '%s'", out.String())
+	}
+}
+
+func TestGroupShow(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &GroupShowCmd{
+		SceneName: "Scene",
+		GroupName: "test_group",
+	}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to show group: %v", err)
+	}
+	if out.String() != "Group test_group is now shown.\n" {
+		t.Fatalf("Expected output to be 'Group test_group is now shown.', got '%s'", out.String())
+	}
+}
+
+func TestGroupToggle(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStatus := &GroupStatusCmd{
+		SceneName: "Scene",
+		GroupName: "test_group",
+	}
+	err := cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get group status: %v", err)
+	}
+	var enabled bool
+	if strings.Contains(out.String(), "Group test_group is shown.") {
+		enabled = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdToggle := &GroupToggleCmd{
+		SceneName: "Scene",
+		GroupName: "test_group",
+	}
+	err = cmdToggle.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to toggle group: %v", err)
+	}
+	if enabled {
+		if out.String() != "Group test_group is now hidden.\n" {
+			t.Fatalf("Expected output to be 'Group test_group is now hidden.', got '%s'", out.String())
+		}
+	} else {
+		if out.String() != "Group test_group is now shown.\n" {
+			t.Fatalf("Expected output to be 'Group test_group is now shown.', got '%s'", out.String())
+		}
+	}
+}
+
+func TestGroupStatus(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdShow := &GroupShowCmd{
+		SceneName: "Scene",
+		GroupName: "test_group",
+	}
+	err := cmdShow.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to show group: %v", err)
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStatus := &GroupStatusCmd{
+		SceneName: "Scene",
+		GroupName: "test_group",
+	}
+	err = cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get group status: %v", err)
+	}
+	if out.String() != "Group test_group is shown.\n" {
+		t.Fatalf("Expected output to be 'Group test_group is shown.', got '%s'", out.String())
+	}
+}

hotkey.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/general"
+	"github.com/andreykaipov/goobs/api/typedefs"
+)
+
+// HotkeyCmd provides commands to manage hotkeys in OBS Studio.
+type HotkeyCmd struct {
+	List            HotkeyListCmd            `cmd:"" help:"List all hotkeys."             aliases:"ls"`
+	Trigger         HotkeyTriggerCmd         `cmd:"" help:"Trigger a hotkey by name."     aliases:"tr"`
+	TriggerSequence HotkeyTriggerSequenceCmd `cmd:"" help:"Trigger a hotkey by sequence." aliases:"trs"`
+}
+
+// HotkeyListCmd provides a command to list all hotkeys.
+type HotkeyListCmd struct{} // size = 0x0
+
+// Run executes the command to list all hotkeys.
+func (cmd *HotkeyListCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.General.GetHotkeyList()
+	if err != nil {
+		return err
+	}
+
+	for _, hotkey := range resp.Hotkeys {
+		fmt.Fprintln(ctx.Out, hotkey)
+	}
+	return nil
+}
+
+// HotkeyTriggerCmd provides a command to trigger a hotkey.
+type HotkeyTriggerCmd struct {
+	Hotkey string `help:"Hotkey name to trigger." arg:""`
+}
+
+// Run executes the command to trigger a hotkey.
+func (cmd *HotkeyTriggerCmd) Run(ctx *context) error {
+	_, err := ctx.Client.General.TriggerHotkeyByName(
+		general.NewTriggerHotkeyByNameParams().WithHotkeyName(cmd.Hotkey),
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// HotkeyTriggerSequenceCmd provides a command to trigger a hotkey sequence.
+type HotkeyTriggerSequenceCmd struct {
+	Shift bool   `flag:"" help:"Shift modifier."`
+	Ctrl  bool   `flag:"" help:"Control modifier."`
+	Alt   bool   `flag:"" help:"Alt modifier."`
+	Cmd   bool   `flag:"" help:"Command modifier."`
+	KeyID string `        help:"Key ID to trigger." arg:""`
+}
+
+// Run executes the command to trigger a hotkey sequence.
+func (cmd *HotkeyTriggerSequenceCmd) Run(ctx *context) error {
+	_, err := ctx.Client.General.TriggerHotkeyByKeySequence(
+		general.NewTriggerHotkeyByKeySequenceParams().
+			WithKeyId(cmd.KeyID).
+			WithKeyModifiers(&typedefs.KeyModifiers{
+				Shift:   cmd.Shift,
+				Control: cmd.Ctrl,
+				Alt:     cmd.Alt,
+				Command: cmd.Cmd,
+			}),
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}

main.go

@@ -24,9 +24,9 @@ type ObsConfig struct {
 	Timeout  int    `flag:"timeout"  help:"Timeout in seconds."          default:"5"         env:"OBS_TIMEOUT"`
 }
 
-// cli is the main command line interface structure.
+// CLI is the main command line interface structure.
 // It embeds the ObsConfig struct to inherit its fields and flags.
-type cli struct {
+type CLI struct {
 	ObsConfig `embed:"" help:"OBS WebSocket configuration."`
 
 	Man mangokong.ManFlag `help:"Print man page."`
@@ -43,6 +43,8 @@ type cli struct {
 	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"`
 }
 
 type context struct {
@@ -57,7 +59,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	var cli cli
+	var cli CLI
 	ctx := kong.Parse(
 		&cli,
 		kong.Name("GOBS-CLI"),

main_test.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"os"
+	"testing"
+
+	"github.com/andreykaipov/goobs"
+	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/andreykaipov/goobs/api/requests/inputs"
+	"github.com/andreykaipov/goobs/api/requests/scenes"
+	typedefs "github.com/andreykaipov/goobs/api/typedefs"
+)
+
+func getClient(t *testing.T) (*goobs.Client, func()) {
+	t.Helper()
+	client, err := connectObs(ObsConfig{
+		Host:     os.Getenv("OBS_HOST"),
+		Port:     4455,
+		Password: os.Getenv("OBS_PASSWORD"),
+		Timeout:  5,
+	})
+	if err != nil {
+		t.Fatalf("Failed to connect to OBS: %v", err)
+	}
+	return client, func() {
+		if err := client.Disconnect(); err != nil {
+			t.Fatalf("Failed to disconnect from OBS: %v", err)
+		}
+	}
+}
+
+func TestMain(m *testing.M) {
+	client, err := connectObs(ObsConfig{
+		Host:     os.Getenv("OBS_HOST"),
+		Port:     4455,
+		Password: os.Getenv("OBS_PASSWORD"),
+		Timeout:  5,
+	})
+	if err != nil {
+		os.Exit(1)
+	}
+	defer client.Disconnect()
+
+	setup(client)
+
+	// Run the tests
+	exitCode := m.Run()
+
+	teardown(client)
+
+	// Exit with the appropriate code
+	os.Exit(exitCode)
+}
+
+func setup(client *goobs.Client) {
+	client.Config.SetStreamServiceSettings(config.NewSetStreamServiceSettingsParams().
+		WithStreamServiceType("rtmp_common").
+		WithStreamServiceSettings(&typedefs.StreamServiceSettings{
+			Server: "auto",
+			Key:    os.Getenv("OBS_STREAM_KEY"),
+		}))
+
+	client.Config.SetCurrentSceneCollection(config.NewSetCurrentSceneCollectionParams().
+		WithSceneCollectionName("test-collection"))
+
+	client.Scenes.CreateScene(scenes.NewCreateSceneParams().
+		WithSceneName("gobs-test"))
+	client.Inputs.CreateInput(inputs.NewCreateInputParams().
+		WithSceneName("gobs-test").
+		WithInputName("gobs-test-input").
+		WithInputKind("color_source_v3").
+		WithInputSettings(map[string]any{
+			"color":   3279460728,
+			"width":   1920,
+			"height":  1080,
+			"visible": true,
+		}).
+		WithSceneItemEnabled(true))
+	client.Inputs.CreateInput(inputs.NewCreateInputParams().
+		WithSceneName("gobs-test").
+		WithInputName("gobs-test-input-2").
+		WithInputKind("color_source_v3").
+		WithInputSettings(map[string]any{
+			"color":   1789347616,
+			"width":   720,
+			"height":  480,
+			"visible": true,
+		}).
+		WithSceneItemEnabled(true))
+}
+
+func teardown(client *goobs.Client) {
+	client.Scenes.RemoveScene(scenes.NewRemoveSceneParams().
+		WithSceneName("gobs-test"))
+
+	client.Config.SetCurrentSceneCollection(config.NewSetCurrentSceneCollectionParams().
+		WithSceneCollectionName("default"))
+
+	client.Stream.StopStream()
+	client.Record.StopRecord()
+}

record_test.go

@@ -0,0 +1,105 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+	"time"
+)
+
+func TestRecordStartStatusStop(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStart := &RecordStartCmd{}
+	err := cmdStart.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to start recording: %v", err)
+	}
+	if out.String() != "Recording started successfully.\n" {
+		t.Fatalf("Expected output to be 'Recording started 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 started
+
+	cmdStatus := &RecordStatusCmd{}
+	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())
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStop := &RecordStopCmd{}
+	err = cmdStop.Run(context)
+	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())
+	}
+}
+
+func TestRecordToggle(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)
+	if err != nil {
+		t.Fatalf("Failed to get recording status: %v", err)
+	}
+	var active bool
+	if out.String() == "Recording is in progress.\n" {
+		active = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdToggle := &RecordToggleCmd{}
+	err = cmdToggle.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to toggle recording: %v", err)
+	}
+
+	time.Sleep(1 * time.Second) // Wait for a second to ensure toggle has taken effect
+
+	if active {
+		if out.String() != "Recording stopped successfully.\n" {
+			t.Fatalf("Expected output to be 'Recording stopped successfully.', got '%s'", out.String())
+		}
+	} else {
+		if out.String() != "Recording started successfully.\n" {
+			t.Fatalf("Expected output to be 'Recording started successfully.', got '%s'", out.String())
+		}
+	}
+}

scene_test.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestSceneList(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &SceneListCmd{}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list scenes: %v", err)
+	}
+	if !strings.Contains(out.String(), "gobs-test") {
+		t.Fatalf("Expected output to contain 'gobs-test', got '%s'", out.String())
+	}
+}
+
+func TestSceneCurrent(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	// Set the current scene to "gobs-test"
+	cmdSwitch := &SceneSwitchCmd{
+		NewScene: "gobs-test",
+	}
+	err := cmdSwitch.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to switch to scene: %v", err)
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdCurrent := &SceneCurrentCmd{}
+	err = cmdCurrent.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get current scene: %v", err)
+	}
+	if out.String() != "gobs-test\n" {
+		t.Fatalf("Expected output to contain 'gobs-test', got '%s'", out.String())
+	}
+}

sceneitem_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestSceneItemList(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmd := &SceneItemListCmd{
+		SceneName: "gobs-test",
+	}
+	err := cmd.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to list scene items: %v", err)
+	}
+	if !strings.Contains(out.String(), "gobs-test-input") {
+		t.Fatalf("Expected output to contain 'gobs-test-input', got '%s'", out.String())
+	}
+	if !strings.Contains(out.String(), "gobs-test-input-2") {
+		t.Fatalf("Expected output to contain 'gobs-test-input-2', got '%s'", out.String())
+	}
+}

stream.go

@@ -17,10 +17,22 @@ type StreamStartCmd struct{} // size = 0x0
 
 // Run executes the command to start streaming.
 func (cmd *StreamStartCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Stream.StartStream()
+	// Check if the stream is already active
+	status, err := ctx.Client.Stream.GetStreamStatus()
 	if err != nil {
 		return err
 	}
+	if status.OutputActive {
+		fmt.Fprintln(ctx.Out, "Stream is already active.")
+		return nil
+	}
+
+	_, err = ctx.Client.Stream.StartStream()
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintln(ctx.Out, "Streaming started successfully.")
 	return nil
 }
 
@@ -29,10 +41,22 @@ type StreamStopCmd struct{} // size = 0x0
 
 // Run executes the command to stop streaming.
 func (cmd *StreamStopCmd) Run(ctx *context) error {
-	_, err := ctx.Client.Stream.StopStream()
+	// Check if the stream is already inactive
+	status, err := ctx.Client.Stream.GetStreamStatus()
 	if err != nil {
 		return err
 	}
+	if !status.OutputActive {
+		fmt.Fprintln(ctx.Out, "Stream is already inactive.")
+		return nil
+	}
+
+	_, err = ctx.Client.Stream.StopStream()
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintln(ctx.Out, "Streaming stopped successfully.")
 	return nil
 }
 

stream_test.go

@@ -0,0 +1,131 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestStreamStart(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStatus := &StreamStatusCmd{}
+	err := cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get stream status: %v", err)
+	}
+	var active bool
+	if strings.Contains(out.String(), "Output active: true") {
+		active = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStart := &StreamStartCmd{}
+	err = cmdStart.Run(context)
+	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())
+		}
+	}
+}
+
+func TestStreamStop(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStatus := &StreamStatusCmd{}
+	err := cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get stream status: %v", err)
+	}
+	var active bool
+	if strings.Contains(out.String(), "Output active: true") {
+		active = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStop := &StreamStopCmd{}
+	err = cmdStop.Run(context)
+	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())
+		}
+	}
+}
+
+func TestStreamToggle(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdStatus := &StreamStatusCmd{}
+	err := cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("Failed to get stream status: %v", err)
+	}
+	var active bool
+	if strings.Contains(out.String(), "Output active: true") {
+		active = true
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdToggle := &StreamToggleCmd{}
+	err = cmdToggle.Run(context)
+	if err != nil {
+		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())
+		}
+	} else {
+		if out.String() != "Streaming started successfully.\n" {
+			t.Fatalf("Expected 'Streaming started successfully.', got: %s", out.String())
+		}
+	}
+}

studiomode.go

@@ -23,6 +23,8 @@ func (cmd *StudioModeEnableCmd) Run(ctx *context) error {
 	if err != nil {
 		return fmt.Errorf("failed to enable studio mode: %w", err)
 	}
+
+	fmt.Fprintln(ctx.Out, "Studio mode is now enabled")
 	return nil
 }
 
@@ -35,6 +37,8 @@ func (cmd *StudioModeDisableCmd) Run(ctx *context) error {
 	if err != nil {
 		return fmt.Errorf("failed to disable studio mode: %w", err)
 	}
+
+	fmt.Fprintln(ctx.Out, "Studio mode is now disabled")
 	return nil
 }
 

studiomode_test.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestStudioModeEnable(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdEnable := &StudioModeEnableCmd{}
+	err := cmdEnable.Run(context)
+	if err != nil {
+		t.Fatalf("failed to enable studio mode: %v", err)
+	}
+	if out.String() != "Studio mode is now enabled\n" {
+		t.Fatalf("expected 'Studio mode is now enabled', got: %s", out.String())
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStatus := &StudioModeStatusCmd{}
+	err = cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("failed to get studio mode status: %v", err)
+	}
+	if out.String() != "Studio mode is enabled\n" {
+		t.Fatalf("expected 'Studio mode is enabled', got: %s", out.String())
+	}
+}
+
+func TestStudioModeDisable(t *testing.T) {
+	client, disconnect := getClient(t)
+	defer disconnect()
+
+	var out bytes.Buffer
+	context := &context{
+		Client: client,
+		Out:    &out,
+	}
+
+	cmdDisable := &StudioModeDisableCmd{}
+	err := cmdDisable.Run(context)
+	if err != nil {
+		t.Fatalf("failed to disable studio mode: %v", err)
+	}
+	if out.String() != "Studio mode is now disabled\n" {
+		t.Fatalf("expected 'Studio mode is now disabled', got: %s", out.String())
+	}
+	// Reset output buffer for the next command
+	out.Reset()
+
+	cmdStatus := &StudioModeStatusCmd{}
+	err = cmdStatus.Run(context)
+	if err != nil {
+		t.Fatalf("failed to get studio mode status: %v", err)
+	}
+	if out.String() != "Studio mode is disabled\n" {
+		t.Fatalf("expected 'Studio mode is disabled', got: %s", out.String())
+	}
+}