add settings command group to CHANGELOG. Bump version.

show and profile set were prototyped in:
https://github.com/nzoschke/gobs-cli/blob/config/settings.go

CHANGELOG.md

@@ -5,6 +5,53 @@ 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.16.0] - 2026-01-26
+
+### Added
+
+-   new subcommands added to input, see [InputCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#inputcmd)
+-   settings command group, see [SettingsCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#settingscmd)
+
+# [0.14.1] - 2025-07-14
+
+### Added
+
+-   text command group, see [TextCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#textcmd)
+
+# [0.13.3] - 2025-06-27
+
+### Changed
+
+-   usage is now printed on errors.
+-   help is printed in compact mode. This should make it easier to page through help on the root command.
+
+### Fixed
+
+-   Item ID alignment in sceneitem list table.
+
+# [0.13.0] - 2025-06-23
+
+### Added
+
+-   record split and record chapter commands, see [RecordCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#recordcmd)
+    -   As of OBS 30.2.0, the only file format supporting *record chapter* is Hybrid MP4.
+
+# [0.12.1] - 2025-06-21
+
+### Added
+
+-   Various colouring styles, see [Style](https://github.com/onyx-and-iris/gobs-cli/tree/main?tab=readme-ov-file#style)
+    -   colouring is applied to list tables as well as highlighted information in stdout/stderr output.
+    -   table border styling may be optionally disabled with the --no-border flag.
+
+### Changed
+
+-   if an itemName is passed to a sceneitem command that's in a group, without the --group flag, a friendlier error message is displayed.
+    -   it will suggest using *gobs-cli si ls* to list sources in the scene.
+-   if an invalid --monitor-index is passed to projector open a friendlier error message is displayed.
+    -   it will suggest using *gobs-cli prj ls-m* to list available monitors.
+
+
 # [0.11.0] - 2025-06-20
 
 ### Added

README.md

@@ -4,6 +4,16 @@ A command line interface for OBS Websocket v5
 
 For an outline of past/future changes refer to: [CHANGELOG](CHANGELOG.md)
 
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Style](#style)
+- [Commands](#commands)
+- [License](#license)
+
 ## Installation
 
 ```console
@@ -40,6 +50,36 @@ OBS_PASSWORD=<websocket password>
 OBS_TIMEOUT=5
 ```
 
+## Style
+
+Styling is opt-in, by default you will get a colourless output:
+
+![colourless](./img/colourless.png)
+
+You may enable styling with the --style/-s flag:
+
+```console
+gobs-cli --style="red" sceneitem list
+```
+
+Available styles: _red, magenta, purple, blue, cyan, green, yellow, orange, white, grey, navy, black_
+
+![coloured](./img/coloured-border.png)
+
+Optionally you may disable border colouring with the --no-border flag:
+
+![coloured-no-border](./img/coloured-no-border.png)
+
+```console
+gobs-cli --style="red" --no-border sceneitem list
+```
+
+Or with environment variables:
+
+```env
+GOBS_STYLE=red
+GOBS_STYLE_NO_BORDER=true
+```
 
 ## Commands
 
@@ -224,6 +264,20 @@ gobs-cli group status START "test_group"
 
 ### InputCmd
 
+-   create: Create input.
+    -   args: Name Kind
+
+```console
+gobs-cli input create 'stream mix' 'wasapi_input_capture'
+```
+
+-   remove: Remove input.
+    -   args: Name
+
+```console
+gobs-cli input remove 'stream mix'
+```
+
 -   list: List all inputs.
     -   flags:
 
@@ -241,6 +295,12 @@ gobs-cli input list
 gobs-cli input list --input --colour
 ```
 
+-   list-kinds: List input kinds.
+
+```console
+gobs-cli input list-kinds
+```
+
 -   mute: Mute input.
     -   args: InputName
 
@@ -262,6 +322,50 @@ gobs-cli input unmute "Mic/Aux"
 gobs-cli input toggle "Mic/Aux"
 ```
 
+-   volume: Set input volume.
+    -   args: InputName Volume
+
+```console
+gobs-cli input volume -- 'Mic/Aux' -30.6
+```
+
+-   show: Show input details.
+    -   args: Name
+    -   flags:
+
+        *optional*
+        -   --verbose: List all available input devices.
+
+-   update: Update input settings.
+    -   args: InputName DeviceName
+
+```console
+gobs-cli input update 'Mic/Aux' 'Voicemeeter Out B1 (VB-Audio Voicemeeter VAIO)'
+```
+
+-   kind-defaults: Get default settings for an input kind.
+    -   args: Kind
+
+```console
+gobs-cli input kind-defaults 'wasapi_input_capture'
+```
+
+### TextCmd
+
+-   current: Display current text for a text input.
+    -   args: InputName
+
+```console
+gobs-cli text current "My Text Input"
+```
+
+-   update: Update the text of a text input.
+    -   args: InputName NewText
+
+```console
+gobs-cli text update "My Text Input" "hi OBS!"
+```
+
 ### RecordCmd
 
 -   start: Start recording.
@@ -313,6 +417,21 @@ gobs-cli record directory "/home/me/obs-vids/"
 gobs-cli record directory "C:/Users/me/Videos"
 ```
 
+-   split: Split recording.
+
+```console
+gobs-cli record split
+```
+
+-   chapter: Create a chapter in the recording.
+
+    *optional*
+    -   arg: ChapterName
+
+```console
+gobs-cli record chapter "Chapter Name"
+```
+
 ### StreamCmd
 
 -   start: Start streaming.
@@ -606,24 +725,61 @@ gobs-cli projector open --monitor-index=1 "test_group"
 gobs-cli screenshot save --width=2560 --height=1440 "Scene" "C:\Users\me\Videos\screenshot.png"
 ```
 
-## Style
+### SettingsCmd
 
-By default styling is disabled but you may enable it with the --style/-s flag.
+-   show: Show settings.
+    -   flags:
 
-Available options are:
+        *optional*
+        -   --video: Show video settings.
+        -   --record: Show record directory.
+        -   --profile: Show profile parameters.
 
-- red
-- magenta
-- purple
-- blue
-- cyan
-- green
-- yellow
-- orange
-- white
-- grey
-- navy
-- black
+```console
+gobs-cli settings show --video --record
+```
+
+-   profile: Get/Set profile parameter setting.
+    -   args: Category Name Value
+
+```console
+gobs-cli settings profile SimpleOutput VBitrate
+
+gobs-cli settings profile SimpleOutput VBitrate 6000
+```
+
+-   stream-service: Get/Set stream service setting.
+    -   args: Type
+    -   flags:
+        -   --key: Stream key.
+        -   --server: Stream server URL.
+
+```console
+gobs-cli settings stream-service
+
+gobs-cli settings stream-service rtmp_common --key='live_xyzxyzxyzxyz'
+```
+
+-   video: Get/Set video setting.
+-   flags:
+    -   --show: Show video settings.
+    -   --base-width: Base (canvas) width.
+    -   --base-height: Base (canvas) height.
+    -   --output-width: Output (scaled) width.
+    -   --output-height: Output (scaled) height.
+    -   --fps-num: Frames per second numerator.
+    -   --fps-den: Frames per second denominator.
+
+```console
+gobs-cli settings video --show
+
+gobs-cli settings video --base-width=1920 --base-height=1080
+```
+
+
+## License
+
+`gobs-cli` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
 
 
 [userconfigdir]: https://pkg.go.dev/os#UserConfigDir

Taskfile.yaml

@@ -22,6 +22,7 @@ tasks:
     cmds:
       - task: build-windows
       - task: build-linux
+      - task: build-macos
 
   vet:
     desc: Vet the code
@@ -46,6 +47,12 @@ tasks:
       - GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64
     internal: true
 
+  build-macos:
+    desc: Build the gobs-cli project for macOS
+    cmds:
+      - GOOS=darwin GOARCH=amd64 go build -ldflags "-X 'main.version={{.VERSION}}'" -o {{.BIN_DIR}}/{{.PROGRAM}}_darwin_amd64
+    internal: true
+
   test:
     desc: Run tests
     cmds:

filter_test.go

@@ -11,7 +11,7 @@ func TestFilterList(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &FilterListCmd{
 		SourceName: "Mic/Aux",
@@ -30,10 +30,10 @@ func TestFilterListScene(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &FilterListCmd{
-		SourceName: "gobs-test",
+		SourceName: "gobs-test-scene",
 	}
 	err := cmd.Run(context)
 	if err != nil {
@@ -49,7 +49,7 @@ func TestFilterListEmpty(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &FilterListCmd{
 		SourceName: "NonExistentSource",

group_test.go

@@ -2,16 +2,25 @@ package main
 
 import (
 	"bytes"
+	"os"
 	"strings"
 	"testing"
 )
 
+func skipIfSkipGroupTests(t *testing.T) {
+	if os.Getenv("GOBS_TEST_SKIP_GROUP_TESTS") != "" {
+		t.Skip("Skipping group tests due to GOBS_TEST_SKIP_GROUP_TESTS environment variable")
+	}
+}
+
 func TestGroupList(t *testing.T) {
+	skipIfSkipGroupTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &GroupListCmd{
 		SceneName: "Scene",
@@ -26,11 +35,13 @@ func TestGroupList(t *testing.T) {
 }
 
 func TestGroupShow(t *testing.T) {
+	skipIfSkipGroupTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &GroupShowCmd{
 		SceneName: "Scene",
@@ -46,11 +57,13 @@ func TestGroupShow(t *testing.T) {
 }
 
 func TestGroupToggle(t *testing.T) {
+	skipIfSkipGroupTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &GroupStatusCmd{
 		SceneName: "Scene",
@@ -87,11 +100,13 @@ func TestGroupToggle(t *testing.T) {
 }
 
 func TestGroupStatus(t *testing.T) {
+	skipIfSkipGroupTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdShow := &GroupShowCmd{
 		SceneName: "Scene",

input.go

@@ -3,6 +3,7 @@ package main
 
 import (
 	"fmt"
+	"maps"
 	"sort"
 	"strings"
 
@@ -13,10 +14,63 @@ import (
 
 // InputCmd provides commands to manage inputs in OBS Studio.
 type InputCmd struct {
+	Create       InputCreateCmd       `cmd:"" help:"Create input."                           aliases:"c"`
+	Remove       InputRemoveCmd       `cmd:"" help:"Remove input."                           aliases:"d"`
 	List         InputListCmd         `cmd:"" help:"List all inputs."                        aliases:"ls"`
+	ListKinds    InputListKindsCmd    `cmd:"" help:"List input kinds."                       aliases:"k"`
 	Mute         InputMuteCmd         `cmd:"" help:"Mute input."                             aliases:"m"`
 	Unmute       InputUnmuteCmd       `cmd:"" help:"Unmute input."                           aliases:"um"`
 	Toggle       InputToggleCmd       `cmd:"" help:"Toggle input."                           aliases:"tg"`
+	Volume       InputVolumeCmd       `cmd:"" help:"Set input volume."                       aliases:"v"`
+	Show         InputShowCmd         `cmd:"" help:"Show input details."                     aliases:"s"`
+	Update       InputUpdateCmd       `cmd:"" help:"Update input settings."                  aliases:"up"`
+	KindDefaults InputKindDefaultsCmd `cmd:"" help:"Get default settings for an input kind." aliases:"df"`
+}
+
+// InputCreateCmd provides a command to create an input.
+type InputCreateCmd struct {
+	Name string `arg:"" help:"Name for the input."                                          required:""`
+	Kind string `arg:"" help:"Input kind (e.g., coreaudio_input_capture, macos-avcapture)." required:""`
+}
+
+// Run executes the command to create an input.
+func (cmd *InputCreateCmd) Run(ctx *context) error {
+	currentScene, err := ctx.Client.Scenes.GetCurrentProgramScene()
+	if err != nil {
+		return err
+	}
+
+	_, err = ctx.Client.Inputs.CreateInput(
+		inputs.NewCreateInputParams().
+			WithInputKind(cmd.Kind).
+			WithInputName(cmd.Name).
+			WithSceneName(currentScene.CurrentProgramSceneName),
+	)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(ctx.Out, "Created input: %s (%s) in scene %s\n",
+		ctx.Style.Highlight(cmd.Name), cmd.Kind, ctx.Style.Highlight(currentScene.CurrentProgramSceneName))
+	return nil
+}
+
+// InputRemoveCmd provides a command to remove an input.
+type InputRemoveCmd struct {
+	Name string `arg:"" help:"Name of the input to remove." required:""`
+}
+
+// Run executes the command to remove an input.
+func (cmd *InputRemoveCmd) Run(ctx *context) error {
+	_, err := ctx.Client.Inputs.RemoveInput(
+		inputs.NewRemoveInputParams().WithInputName(cmd.Name),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to delete input: %w", err)
+	}
+
+	fmt.Fprintf(ctx.Out, "Deleted %s\n", ctx.Style.Highlight(cmd.Name))
+	return nil
 }
 
 // InputListCmd provides a command to list all inputs.
@@ -122,6 +176,47 @@ func (cmd *InputListCmd) Run(ctx *context) error {
 	return nil
 }
 
+// InputListKindsCmd provides a command to list all input kinds.
+type InputListKindsCmd struct{}
+
+// Run executes the command to list all input kinds.
+func (cmd *InputListKindsCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Inputs.GetInputKindList(
+		inputs.NewGetInputKindListParams().WithUnversioned(false),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get input kinds: %w", err)
+	}
+
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
+	t.Headers("Kind")
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})
+
+	for _, kind := range resp.InputKinds {
+		t.Row(kind)
+	}
+
+	fmt.Fprintln(ctx.Out, t.Render())
+
+	return nil
+}
+
 // InputMuteCmd provides a command to mute an input.
 type InputMuteCmd struct {
 	InputName string `arg:"" help:"Name of the input to mute."`
@@ -188,3 +283,273 @@ func (cmd *InputToggleCmd) Run(ctx *context) error {
 	}
 	return nil
 }
+
+// InputVolumeCmd provides a command to set the volume of an input.
+type InputVolumeCmd struct {
+	InputName string  `arg:"" help:"Name of the input to set volume for." required:""`
+	Volume    float64 `arg:"" help:"Volume level (-90.0 to 0.0)."         required:""`
+}
+
+// Run executes the command to set the volume of an input.
+// accepts values between -90.0 and 0.0 representing decibels (dB).
+func (cmd *InputVolumeCmd) Run(ctx *context) error {
+	if cmd.Volume < -90.0 || cmd.Volume > 0.0 {
+		return fmt.Errorf("volume must be between -90.0 and 0.0 dB")
+	}
+
+	_, err := ctx.Client.Inputs.SetInputVolume(
+		inputs.NewSetInputVolumeParams().
+			WithInputName(cmd.InputName).
+			WithInputVolumeDb(cmd.Volume),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to set input volume: %w", err)
+	}
+
+	fmt.Fprintf(ctx.Out, "Set volume of input %s to %.1f dB\n",
+		ctx.Style.Highlight(cmd.InputName), cmd.Volume)
+	return nil
+}
+
+// InputShowCmd provides a command to show input details.
+type InputShowCmd struct {
+	Name    string `arg:"" help:"Name of the input to show."        required:""`
+	Verbose bool   `       help:"List all available input devices."             flag:""`
+}
+
+// Run executes the command to show input details.
+func (cmd *InputShowCmd) Run(ctx *context) error {
+	lresp, err := ctx.Client.Inputs.GetInputList(inputs.NewGetInputListParams())
+	if err != nil {
+		return fmt.Errorf("failed to get input list: %w", err)
+	}
+
+	var inputKind string
+	var found bool
+	for _, input := range lresp.Inputs {
+		if input.InputName == cmd.Name {
+			inputKind = input.InputKind
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("input '%s' not found", cmd.Name)
+	}
+
+	prop, name := device(ctx, cmd.Name)
+	if prop == "" {
+		return fmt.Errorf("no device property found for input '%s'", cmd.Name)
+	}
+
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
+	t.Headers("Input Name", "Kind", "Device")
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		case 1:
+			style = style.Align(lipgloss.Left)
+		case 2:
+			style = style.Align(lipgloss.Center)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})
+	t.Row(cmd.Name, snakeCaseToTitleCase(inputKind), name)
+
+	fmt.Fprintln(ctx.Out, t.Render())
+
+	if cmd.Verbose {
+		deviceListResp, err := ctx.Client.Inputs.GetInputPropertiesListPropertyItems(
+			inputs.NewGetInputPropertiesListPropertyItemsParams().
+				WithInputName(cmd.Name).
+				WithPropertyName(prop),
+		)
+		if err != nil {
+			return fmt.Errorf("failed to get device list: %w", err)
+		}
+
+		t := table.New().Border(lipgloss.RoundedBorder()).
+			BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
+		t.StyleFunc(func(row, col int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch col {
+			case 0:
+				style = style.Align(lipgloss.Left)
+			}
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})
+
+		t.Headers("Devices")
+
+		for _, item := range deviceListResp.PropertyItems {
+			if item.ItemName != "" {
+				t.Row(item.ItemName)
+			}
+		}
+
+		fmt.Fprintln(ctx.Out, t.Render())
+	}
+
+	return nil
+}
+
+func device(ctx *context, inputName string) (string, string) {
+	settings, err := ctx.Client.Inputs.GetInputSettings(
+		inputs.NewGetInputSettingsParams().WithInputName(inputName),
+	)
+	if err != nil {
+		return "", ""
+	}
+
+	for _, propName := range []string{"device", "device_id"} {
+		deviceListResp, err := ctx.Client.Inputs.GetInputPropertiesListPropertyItems(
+			inputs.NewGetInputPropertiesListPropertyItemsParams().
+				WithInputName(inputName).
+				WithPropertyName(propName),
+		)
+		if err == nil && len(deviceListResp.PropertyItems) > 0 {
+			for _, item := range deviceListResp.PropertyItems {
+				if item.ItemValue == settings.InputSettings[propName] {
+					return propName, item.ItemName
+				}
+			}
+		}
+	}
+
+	return "", ""
+}
+
+// InputUpdateCmd provides a command to update input settings.
+type InputUpdateCmd struct {
+	InputName  string `arg:"" help:"Name of the input to update." required:""`
+	DeviceName string `arg:"" help:"Name of the device to set."   required:""`
+}
+
+// Run executes the command to update input settings.
+func (cmd *InputUpdateCmd) Run(ctx *context) error {
+	// Use the device helper to find the correct device property name
+	prop, _ := device(ctx, cmd.InputName)
+	if prop == "" {
+		return fmt.Errorf("no device property found for input '%s'", cmd.InputName)
+	}
+
+	resp, err := ctx.Client.Inputs.GetInputPropertiesListPropertyItems(
+		inputs.NewGetInputPropertiesListPropertyItemsParams().
+			WithInputName(cmd.InputName).
+			WithPropertyName(prop),
+	)
+	if err != nil {
+		return err
+	}
+
+	var deviceValue any
+	var found bool
+	for _, item := range resp.PropertyItems {
+		if item.ItemName == cmd.DeviceName {
+			deviceValue = item.ItemValue
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("device '%s' not found for input '%s'", cmd.DeviceName, cmd.InputName)
+	}
+
+	sresp, err := ctx.Client.Inputs.GetInputSettings(
+		inputs.NewGetInputSettingsParams().WithInputName(cmd.InputName),
+	)
+	if err != nil {
+		return err
+	}
+
+	settings := make(map[string]any)
+	maps.Copy(settings, sresp.InputSettings)
+	settings[prop] = deviceValue
+
+	_, err = ctx.Client.Inputs.SetInputSettings(
+		inputs.NewSetInputSettingsParams().
+			WithInputName(cmd.InputName).
+			WithInputSettings(settings),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to update input settings: %w", err)
+	}
+
+	fmt.Fprintf(ctx.Out, "Input %s %s set to %s\n",
+		ctx.Style.Highlight(cmd.InputName), prop, ctx.Style.Highlight(cmd.DeviceName))
+
+	return nil
+}
+
+// InputKindDefaultsCmd provides a command to get default settings for an input kind.
+type InputKindDefaultsCmd struct {
+	Kind string `arg:"" help:"Input kind to get default settings for." required:""`
+}
+
+// Run executes the command to get default settings for an input kind.
+func (cmd *InputKindDefaultsCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Inputs.GetInputDefaultSettings(
+		inputs.NewGetInputDefaultSettingsParams().
+			WithInputKind(cmd.Kind),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get default settings for input kind '%s': %w", cmd.Kind, err)
+	}
+
+	t := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border))
+	t.Headers("Setting", "Value")
+	t.StyleFunc(func(row, col int) lipgloss.Style {
+		style := lipgloss.NewStyle().Padding(0, 3)
+		switch col {
+		case 0:
+			style = style.Align(lipgloss.Left)
+		case 1:
+			style = style.Align(lipgloss.Center)
+		}
+		switch {
+		case row == table.HeaderRow:
+			style = style.Bold(true).Align(lipgloss.Center)
+		case row%2 == 0:
+			style = style.Foreground(ctx.Style.evenRows)
+		default:
+			style = style.Foreground(ctx.Style.oddRows)
+		}
+		return style
+	})
+
+	keys := make([]string, 0, len(resp.DefaultInputSettings))
+	for k := range resp.DefaultInputSettings {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		value := resp.DefaultInputSettings[key]
+		t.Row(key, fmt.Sprintf("%v", value))
+	}
+
+	fmt.Fprintln(ctx.Out, t.Render())
+	return nil
+}

input_test.go

@@ -11,7 +11,7 @@ func TestInputList(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &InputListCmd{}
 	err := cmd.Run(context)
@@ -22,9 +22,8 @@ func TestInputList(t *testing.T) {
 	expectedInputs := []string{
 		"Desktop Audio",
 		"Mic/Aux",
-		"Colour Source",
-		"Colour Source 2",
-		"Colour Source 3",
+		"gobs-test-input",
+		"gobs-test-input-2",
 	}
 	output := out.String()
 	for _, input := range expectedInputs {
@@ -39,7 +38,7 @@ func TestInputListFilterInput(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &InputListCmd{Input: true}
 	err := cmd.Run(context)
@@ -52,9 +51,8 @@ func TestInputListFilterInput(t *testing.T) {
 	}
 	expectedFilteredOut := []string{
 		"Desktop Audio",
-		"Colour Source",
-		"Colour Source 2",
-		"Colour Source 3",
+		"gobs-test-input",
+		"gobs-test-input-2",
 	}
 	for _, input := range expectedInputs {
 		if !strings.Contains(out.String(), input) {
@@ -73,7 +71,7 @@ func TestInputListFilterOutput(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &InputListCmd{Output: true}
 	err := cmd.Run(context)
@@ -86,9 +84,8 @@ func TestInputListFilterOutput(t *testing.T) {
 	}
 	expectedFilteredOut := []string{
 		"Mic/Aux",
-		"Colour Source",
-		"Colour Source 2",
-		"Colour Source 3",
+		"gobs-test-input",
+		"gobs-test-input-2",
 	}
 	for _, input := range expectedInputs {
 		if !strings.Contains(out.String(), input) {
@@ -107,7 +104,7 @@ func TestInputListFilterColour(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &InputListCmd{Colour: true}
 	err := cmd.Run(context)
@@ -116,9 +113,8 @@ func TestInputListFilterColour(t *testing.T) {
 	}
 
 	expectedInputs := []string{
-		"Colour Source",
-		"Colour Source 2",
-		"Colour Source 3",
+		"gobs-test-input",
+		"gobs-test-input-2",
 	}
 	for _, input := range expectedInputs {
 		if !strings.Contains(out.String(), input) {

main.go

@@ -8,6 +8,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"runtime/debug"
+	"strings"
 	"time"
 
 	"github.com/alecthomas/kong"
@@ -16,6 +18,19 @@ import (
 	kongdotenv "github.com/titusjaka/kong-dotenv-go"
 )
 
+var version string // Version of the CLI, set at build time.
+
+// VersionFlag is a custom flag type that prints the version and exits.
+type VersionFlag string
+
+func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }  // nolint: revive
+func (v VersionFlag) IsBool() bool                       { return true } // nolint: revive
+func (v VersionFlag) BeforeApply(app *kong.Kong, vars kong.Vars) error { // nolint: revive, unparam
+	fmt.Printf("gobs-cli version: %s\n", vars["version"])
+	app.Exit(0)
+	return nil
+}
+
 // 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"     short:"H"`
@@ -27,10 +42,11 @@ type ObsConfig struct {
 // StyleConfig holds the configuration for styling the CLI output.
 type StyleConfig struct {
 	Style    string `help:"Style used in output."                   flag:"style"     default:""      env:"GOBS_STYLE"           short:"s" enum:",red,magenta,purple,blue,cyan,green,yellow,orange,white,grey,navy,black"`
+	NoBorder bool   `help:"Disable table border styling in output." flag:"no-border" default:"false" env:"GOBS_STYLE_NO_BORDER" short:"b"`
 }
 
 // CLI is the main command line interface structure.
-// It embeds the ObsConfig struct to inherit its fields and flags.
+// It embeds ObsConfig and StyleConfig to provide configuration options.
 type CLI struct {
 	ObsConfig   `embed:"" help:"OBS WebSocket configuration."`
 	StyleConfig `embed:"" help:"Style configuration."`
@@ -43,6 +59,7 @@ type CLI struct {
 	Sceneitem       SceneItemCmd       `help:"Manage scene items."                     cmd:"" aliases:"si"  group:"Scene Item"`
 	Group           GroupCmd           `help:"Manage groups."                          cmd:"" aliases:"g"   group:"Group"`
 	Input           InputCmd           `help:"Manage inputs."                          cmd:"" aliases:"i"   group:"Input"`
+	Text            TextCmd            `help:"Manage text inputs."                     cmd:"" aliases:"t"   group:"Text Input"`
 	Record          RecordCmd          `help:"Manage recording."                       cmd:"" aliases:"rec" group:"Recording"`
 	Stream          StreamCmd          `help:"Manage streaming."                       cmd:"" aliases:"st"  group:"Streaming"`
 	Scenecollection SceneCollectionCmd `help:"Manage scene collections."               cmd:"" aliases:"scn" group:"Scene Collection"`
@@ -54,6 +71,7 @@ type CLI struct {
 	Filter          FilterCmd          `help:"Manage filters."                         cmd:"" aliases:"f"   group:"Filter"`
 	Projector       ProjectorCmd       `help:"Manage projectors."                      cmd:"" aliases:"prj" group:"Projector"`
 	Screenshot      ScreenshotCmd      `help:"Take screenshots."                       cmd:"" aliases:"ss"  group:"Screenshot"`
+	Settings        SettingsCmd        `help:"Manage video and profile settings."      cmd:"" aliases:"set" group:"Settings"`
 }
 
 type context struct {
@@ -62,11 +80,11 @@ type context struct {
 	Style  *Style
 }
 
-func newContext(client *goobs.Client, out io.Writer, styleName string) *context {
+func newContext(client *goobs.Client, out io.Writer, styleCfg StyleConfig) *context {
 	return &context{
 		Client: client,
 		Out:    out,
-		Style:  styleFromFlag(styleName),
+		Style:  styleFromFlag(styleCfg),
 	}
 }
 
@@ -80,15 +98,30 @@ func main() {
 	var cli CLI
 	ctx := kong.Parse(
 		&cli,
-		kong.Name("GOBS-CLI"),
+		kong.Name("gobs-cli"),
 		kong.Description("A command line tool to interact with OBS Websocket."),
 		kong.Configuration(kongdotenv.ENVFileReader, ".env", filepath.Join(userConfigDir, "gobs-cli", "config.env")),
-	)
+		kong.UsageOnError(),
+		kong.ConfigureHelp(kong.HelpOptions{
+			Compact: true,
+		}),
+		kong.Vars{
+			"version": func() string {
+				if version == "" {
+					info, ok := debug.ReadBuildInfo()
+					if !ok {
+						return "(unable to read build info)"
+					}
+					version = strings.Split(info.Main.Version, "-")[0]
+				}
+				return version
+			}(),
+		})
 
 	client, err := connectObs(cli.ObsConfig)
 	ctx.FatalIfErrorf(err)
 
-	ctx.Bind(newContext(client, os.Stdout, cli.StyleConfig.Style))
+	ctx.Bind(newContext(client, os.Stdout, cli.StyleConfig))
 
 	ctx.FatalIfErrorf(run(ctx, client))
 }

main_test.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"os"
+	"runtime"
 	"testing"
+	"time"
 
 	"github.com/andreykaipov/goobs"
 	"github.com/andreykaipov/goobs/api/requests/config"
@@ -62,13 +64,23 @@ func setup(client *goobs.Client) {
 			Key:    os.Getenv("OBS_STREAM_KEY"),
 		}))
 
-	client.Config.SetCurrentSceneCollection(config.NewSetCurrentSceneCollectionParams().
-		WithSceneCollectionName("test-collection"))
+	client.Config.CreateProfile(config.NewCreateProfileParams().
+		WithProfileName("gobs-test-profile"))
+	time.Sleep(100 * time.Millisecond) // Wait for the profile to be created
+	client.Config.SetProfileParameter(config.NewSetProfileParameterParams().
+		WithParameterCategory("SimpleOutput").
+		WithParameterName("RecRB").
+		WithParameterValue("true"))
+	// hack to ensure the Replay Buffer setting is applied
+	client.Config.SetCurrentProfile(config.NewSetCurrentProfileParams().
+		WithProfileName("Untitled"))
+	client.Config.SetCurrentProfile(config.NewSetCurrentProfileParams().
+		WithProfileName("gobs-test-profile"))
 
 	client.Scenes.CreateScene(scenes.NewCreateSceneParams().
-		WithSceneName("gobs-test"))
+		WithSceneName("gobs-test-scene"))
 	client.Inputs.CreateInput(inputs.NewCreateInputParams().
-		WithSceneName("gobs-test").
+		WithSceneName("gobs-test-scene").
 		WithInputName("gobs-test-input").
 		WithInputKind("color_source_v3").
 		WithInputSettings(map[string]any{
@@ -79,7 +91,7 @@ func setup(client *goobs.Client) {
 		}).
 		WithSceneItemEnabled(true))
 	client.Inputs.CreateInput(inputs.NewCreateInputParams().
-		WithSceneName("gobs-test").
+		WithSceneName("gobs-test-scene").
 		WithInputName("gobs-test-input-2").
 		WithInputKind("color_source_v3").
 		WithInputSettings(map[string]any{
@@ -90,6 +102,37 @@ func setup(client *goobs.Client) {
 		}).
 		WithSceneItemEnabled(true))
 
+	// ensure Desktop Audio input is created
+	desktopAudioKinds := map[string]string{
+		"windows": "wasapi_output_capture",
+		"linux":   "pulse_output_capture",
+		"darwin":  "coreaudio_output_capture",
+	}
+	platform := os.Getenv("GOBS_TEST_PLATFORM")
+	if platform == "" {
+		platform = runtime.GOOS
+	}
+	client.Inputs.CreateInput(inputs.NewCreateInputParams().
+		WithSceneName("gobs-test-scene").
+		WithInputName("Desktop Audio").
+		WithInputKind(desktopAudioKinds[platform]).
+		WithInputSettings(map[string]any{
+			"device_id": "default",
+		}))
+	// ensure Mic/Aux input is created
+	micKinds := map[string]string{
+		"windows": "wasapi_input_capture",
+		"linux":   "pulse_input_capture",
+		"darwin":  "coreaudio_input_capture",
+	}
+	client.Inputs.CreateInput(inputs.NewCreateInputParams().
+		WithSceneName("gobs-test-scene").
+		WithInputName("Mic/Aux").
+		WithInputKind(micKinds[platform]).
+		WithInputSettings(map[string]any{
+			"device_id": "default",
+		}))
+
 	// Create source filter on an audio input
 	client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
 		WithSourceName("Mic/Aux").
@@ -106,7 +149,7 @@ func setup(client *goobs.Client) {
 
 	// Create source filter on a scene
 	client.Filters.CreateSourceFilter(filters.NewCreateSourceFilterParams().
-		WithSourceName("gobs-test").
+		WithSourceName("gobs-test-scene").
 		WithFilterName("test_filter").
 		WithFilterKind("luma_key_filter_v2").
 		WithFilterSettings(map[string]any{
@@ -115,18 +158,21 @@ func setup(client *goobs.Client) {
 }
 
 func teardown(client *goobs.Client) {
+	client.Config.RemoveProfile(config.NewRemoveProfileParams().
+		WithProfileName("gobs-test-profile"))
+
 	client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
 		WithSourceName("Mic/Aux").
 		WithFilterName("test_filter"))
 	client.Filters.RemoveSourceFilter(filters.NewRemoveSourceFilterParams().
-		WithSourceName("gobs-test").
+		WithSourceName("gobs-test-scene").
 		WithFilterName("test_filter"))
 
 	client.Scenes.RemoveScene(scenes.NewRemoveSceneParams().
-		WithSceneName("gobs-test"))
+		WithSceneName("gobs-test-scene"))
 
 	client.Config.SetCurrentSceneCollection(config.NewSetCurrentSceneCollectionParams().
-		WithSceneCollectionName("default"))
+		WithSceneCollectionName("Untitled"))
 
 	client.Stream.StopStream()
 	client.Record.StopRecord()

record.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/andreykaipov/goobs/api/requests/record"
 )
 
 // RecordCmd handles the recording commands.
@@ -15,6 +16,8 @@ type RecordCmd struct {
 	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"`
+	Split     RecordSplitCmd     `cmd:"" help:"Split recording."                   aliases:"sp"`
+	Chapter   RecordChapterCmd   `cmd:"" help:"Create a chapter in the recording." aliases:"c"`
 }
 
 // RecordStartCmd starts the recording.
@@ -187,3 +190,68 @@ func (cmd *RecordDirectoryCmd) Run(ctx *context) error {
 	fmt.Fprintf(ctx.Out, "Recording directory set to: %s\n", ctx.Style.Highlight(cmd.RecordDirectory))
 	return nil
 }
+
+// RecordSplitCmd splits the current recording.
+type RecordSplitCmd struct{} // size = 0x0
+
+// Run executes the command to split the recording.
+func (cmd *RecordSplitCmd) Run(ctx *context) error {
+	status, err := ctx.Client.Record.GetRecordStatus()
+	if err != nil {
+		return err
+	}
+
+	if !status.OutputActive {
+		return fmt.Errorf("recording is not in progress")
+	}
+	if status.OutputPaused {
+		return fmt.Errorf("recording is paused, cannot split")
+	}
+
+	_, err = ctx.Client.Record.SplitRecordFile()
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintln(ctx.Out, "Recording split successfully.")
+	return nil
+}
+
+// RecordChapterCmd creates a chapter in the recording.
+type RecordChapterCmd struct {
+	ChapterName string `arg:"" help:"Name of the chapter to create." default:""`
+}
+
+// Run executes the command to create a chapter in the recording.
+func (cmd *RecordChapterCmd) Run(ctx *context) error {
+	status, err := ctx.Client.Record.GetRecordStatus()
+	if err != nil {
+		return err
+	}
+
+	if !status.OutputActive {
+		return fmt.Errorf("recording is not in progress")
+	}
+	if status.OutputPaused {
+		return fmt.Errorf("recording is paused, cannot create chapter")
+	}
+
+	var params *record.CreateRecordChapterParams
+	if cmd.ChapterName == "" {
+		params = record.NewCreateRecordChapterParams()
+	} else {
+		params = record.NewCreateRecordChapterParams().WithChapterName(cmd.ChapterName)
+	}
+
+	_, err = ctx.Client.Record.CreateRecordChapter(params)
+	if err != nil {
+		return err
+	}
+
+	if cmd.ChapterName == "" {
+		cmd.ChapterName = "unnamed"
+	}
+
+	fmt.Fprintf(ctx.Out, "Chapter %s created successfully.\n", ctx.Style.Highlight(cmd.ChapterName))
+	return nil
+}

record_test.go

@@ -12,7 +12,7 @@ func TestRecordStart(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -44,7 +44,7 @@ func TestRecordStart(t *testing.T) {
 	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
+	time.Sleep(500 * time.Millisecond) // Wait for the recording to start
 }
 
 func TestRecordStop(t *testing.T) {
@@ -52,7 +52,7 @@ func TestRecordStop(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -84,7 +84,7 @@ func TestRecordStop(t *testing.T) {
 	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
+	time.Sleep(500 * time.Millisecond) // Wait for the recording to stop
 }
 
 func TestRecordToggle(t *testing.T) {
@@ -92,7 +92,7 @@ func TestRecordToggle(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &RecordStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -112,8 +112,6 @@ func TestRecordToggle(t *testing.T) {
 		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())
@@ -123,4 +121,5 @@ func TestRecordToggle(t *testing.T) {
 			t.Fatalf("Expected output to be 'Recording started successfully.', got '%s'", out.String())
 		}
 	}
+	time.Sleep(500 * time.Millisecond) // Wait for the toggle to take effect
 }

replaybuffer_test.go

@@ -2,16 +2,26 @@ package main
 
 import (
 	"bytes"
+	"os"
 	"strings"
 	"testing"
+	"time"
 )
 
+func skipIfSkipReplayBufferTests(t *testing.T) {
+	if os.Getenv("GOBS_TEST_SKIP_REPLAYBUFFER_TESTS") != "" {
+		t.Skip("Skipping replay buffer tests due to GOBS_TEST_SKIP_REPLAYBUFFER_TESTS environment variable")
+	}
+}
+
 func TestReplayBufferStart(t *testing.T) {
+	skipIfSkipReplayBufferTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &ReplayBufferStartCmd{}
 	err := cmd.Run(context)
@@ -21,14 +31,17 @@ func TestReplayBufferStart(t *testing.T) {
 	if out.String() != "Replay buffer started.\n" {
 		t.Fatalf("Expected output to be 'Replay buffer started', got '%s'", out.String())
 	}
+	time.Sleep(500 * time.Millisecond) // Wait for the replay buffer to start
 }
 
 func TestReplayBufferStop(t *testing.T) {
+	skipIfSkipReplayBufferTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &ReplayBufferStopCmd{}
 	err := cmd.Run(context)
@@ -38,14 +51,17 @@ func TestReplayBufferStop(t *testing.T) {
 	if out.String() != "Replay buffer stopped.\n" {
 		t.Fatalf("Expected output to be 'Replay buffer stopped.', got '%s'", out.String())
 	}
+	time.Sleep(500 * time.Millisecond) // Wait for the replay buffer to stop
 }
 
 func TestReplayBufferToggle(t *testing.T) {
+	skipIfSkipReplayBufferTests(t)
+
 	client, disconnect := getClient(t)
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &ReplayBufferStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -73,4 +89,5 @@ func TestReplayBufferToggle(t *testing.T) {
 			t.Fatalf("Expected output to be 'Replay buffer started.', got '%s'", out.String())
 		}
 	}
+	time.Sleep(500 * time.Millisecond) // Wait for the toggle to take effect
 }

scene_test.go

@@ -10,15 +10,15 @@ func TestSceneList(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &SceneListCmd{}
 	err := cmd.Run(context)
 	if err != nil {
 		t.Fatalf("Failed to list scenes: %v", err)
 	}
-	if out.String() == "Current program scene: gobs-test\n" {
-		t.Fatalf("Expected output to be 'Current program scene: gobs-test', got '%s'", out.String())
+	if out.String() == "Current program scene: gobs-test-scene\n" {
+		t.Fatalf("Expected output to be 'Current program scene: gobs-test-scene', got '%s'", out.String())
 	}
 }
 
@@ -27,11 +27,11 @@ func TestSceneCurrent(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
-	// Set the current scene to "gobs-test"
+	// Set the current scene to "gobs-test-scene"
 	cmdSwitch := &SceneSwitchCmd{
-		NewScene: "gobs-test",
+		NewScene: "gobs-test-scene",
 	}
 	err := cmdSwitch.Run(context)
 	if err != nil {
@@ -45,7 +45,7 @@ func TestSceneCurrent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to get current scene: %v", err)
 	}
-	if out.String() != "Current program scene: gobs-test\n" {
-		t.Fatalf("Expected output to be 'Current program scene: gobs-test', got '%s'", out.String())
+	if out.String() != "Current program scene: gobs-test-scene\n" {
+		t.Fatalf("Expected output to be 'Current program scene: gobs-test-scene', got '%s'", out.String())
 	}
 }

sceneitem.go

@@ -59,7 +59,7 @@ func (cmd *SceneItemListCmd) Run(ctx *context) error {
 		style := lipgloss.NewStyle().Padding(0, 3)
 		switch col {
 		case 0:
-			style = style.Align(lipgloss.Left)
+			style = style.Align(lipgloss.Center)
 		case 1:
 			style = style.Align(lipgloss.Left)
 		case 2:

sceneitem_test.go

@@ -11,10 +11,10 @@ func TestSceneItemList(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &SceneItemListCmd{
-		SceneName: "gobs-test",
+		SceneName: "gobs-test-scene",
 	}
 	err := cmd.Run(context)
 	if err != nil {

settings.go

@@ -0,0 +1,334 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/config"
+	"github.com/andreykaipov/goobs/api/typedefs"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
+)
+
+// SettingsCmd handles settings management.
+type SettingsCmd struct {
+	Show          SettingsShowCmd          `help:"Show settings."                     cmd:"" aliases:"s"`
+	Profile       SettingsProfileCmd       `help:"Get/Set profile parameter setting." cmd:"" aliases:"p"`
+	StreamService SettingsStreamServiceCmd `help:"Get/Set stream service setting."    cmd:"" aliases:"ss"`
+	Video         SettingsVideoCmd         `help:"Get/Set video setting."             cmd:"" aliases:"v"`
+}
+
+// SettingsShowCmd shows the video settings.
+type SettingsShowCmd struct {
+	Video   bool `flag:"" help:"Show video settings."`
+	Record  bool `flag:"" help:"Show record directory."`
+	Profile bool `flag:"" help:"Show profile parameters."`
+}
+
+// Run executes the show command.
+// nolint: misspell
+func (cmd *SettingsShowCmd) Run(ctx *context) error {
+	if !cmd.Video && !cmd.Record && !cmd.Profile {
+		cmd.Video = true
+		cmd.Record = true
+		cmd.Profile = true
+	}
+
+	// Get video settings
+	videoResp, err := ctx.Client.Config.GetVideoSettings()
+	if err != nil {
+		return fmt.Errorf("failed to get video settings: %w", err)
+	}
+
+	vt := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Video Setting", "Value").
+		StyleFunc(func(row, _ int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})
+
+	vt.Row("Base Width", fmt.Sprintf("%.0f", videoResp.BaseWidth))
+	vt.Row("Base Height", fmt.Sprintf("%.0f", videoResp.BaseHeight))
+	vt.Row("Output Width", fmt.Sprintf("%.0f", videoResp.OutputWidth))
+	vt.Row("Output Height", fmt.Sprintf("%.0f", videoResp.OutputHeight))
+	vt.Row("FPS Numerator", fmt.Sprintf("%.0f", videoResp.FpsNumerator))
+	vt.Row("FPS Denominator", fmt.Sprintf("%.0f", videoResp.FpsDenominator))
+
+	// Get record directory
+	dirResp, err := ctx.Client.Config.GetRecordDirectory()
+	if err != nil {
+		return fmt.Errorf("failed to get record directory: %w", err)
+	}
+
+	rt := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Record Setting", "Value").
+		StyleFunc(func(row, _ int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})
+
+	rt.Row("Directory", dirResp.RecordDirectory)
+
+	// Get profile prameters
+	pt := table.New().Border(lipgloss.RoundedBorder()).
+		BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+		Headers("Profile Parameter", "Value").
+		StyleFunc(func(row, _ int) lipgloss.Style {
+			style := lipgloss.NewStyle().Padding(0, 3)
+			switch {
+			case row == table.HeaderRow:
+				style = style.Bold(true).Align(lipgloss.Center)
+			case row%2 == 0:
+				style = style.Foreground(ctx.Style.evenRows)
+			default:
+				style = style.Foreground(ctx.Style.oddRows)
+			}
+			return style
+		})
+
+	// Common profile parameters to display
+	params := []struct {
+		category string
+		name     string
+		label    string
+	}{
+		{"Output", "Mode", "Output Mode"},
+
+		{"SimpleOutput", "StreamEncoder", "Simple Streaming Encoder"},
+		{"SimpleOutput", "RecEncoder", "Simple Recording Encoder"},
+		{"SimpleOutput", "RecFormat2", "Simple Recording Video Format"},
+		{"SimpleOutput", "RecAudioEncoder", "Simple Recording Audio Format"},
+		{"SimpleOutput", "RecQuality", "Simple Recording Quality"},
+
+		{"AdvOut", "Encoder", "Advanced Streaming Encoder"},
+		{"AdvOut", "RecEncoder", "Advanced Recording Encoder"},
+		{"AdvOut", "RecType", "Advanced Recording Type"},
+		{"AdvOut", "RecFormat2", "Advanced Recording Video Format"},
+		{"AdvOut", "RecAudioEncoder", "Advanced Recording Audio Format"},
+	}
+
+	for _, param := range params {
+		resp, err := ctx.Client.Config.GetProfileParameter(
+			config.NewGetProfileParameterParams().
+				WithParameterCategory(param.category).
+				WithParameterName(param.name),
+		)
+		if err == nil && resp.ParameterValue != "" {
+			pt.Row(param.label, resp.ParameterValue)
+		}
+	}
+
+	if cmd.Video {
+		fmt.Fprintln(ctx.Out, vt.Render())
+	}
+
+	if cmd.Record {
+		fmt.Fprintln(ctx.Out, rt.Render())
+	}
+
+	if cmd.Profile {
+		fmt.Fprintln(ctx.Out, pt.Render())
+	}
+
+	return nil
+}
+
+// SettingsProfileCmd gets/ sets a profile parameter.
+type SettingsProfileCmd struct {
+	Category string `arg:"" help:"Parameter category (e.g., AdvOut, SimpleOutput, Output)." required:""`
+	Name     string `arg:"" help:"Parameter name (e.g., RecFormat2, RecEncoder)."           required:""`
+	Value    string `arg:"" help:"Parameter value to set."                                              optional:""`
+}
+
+// Run executes the set command.
+func (cmd *SettingsProfileCmd) Run(ctx *context) error {
+	if cmd.Value == "" {
+		resp, err := ctx.Client.Config.GetProfileParameter(
+			config.NewGetProfileParameterParams().
+				WithParameterCategory(cmd.Category).
+				WithParameterName(cmd.Name),
+		)
+		if err != nil {
+			return fmt.Errorf("failed to get parameter %s.%s: %w", cmd.Category, cmd.Name, err)
+		}
+
+		fmt.Fprintf(ctx.Out, "%s.%s = %s\n", cmd.Category, cmd.Name, resp.ParameterValue)
+		return nil
+	}
+
+	_, err := ctx.Client.Config.SetProfileParameter(
+		config.NewSetProfileParameterParams().
+			WithParameterCategory(cmd.Category).
+			WithParameterName(cmd.Name).
+			WithParameterValue(cmd.Value),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to set parameter %s.%s: %w", cmd.Category, cmd.Name, err)
+	}
+
+	fmt.Fprintf(ctx.Out, "Set %s.%s = %s\n", cmd.Category, cmd.Name, cmd.Value)
+	return nil
+}
+
+// SettingsStreamServiceCmd gets/ sets stream service settings.
+type SettingsStreamServiceCmd struct {
+	Type   string `arg:"" help:"Stream type (e.g., rtmp_common, rtmp_custom)." required:""`
+	Key    string `       help:"Stream key."                                               flag:""`
+	Server string `       help:"Stream server URL."                                        flag:""`
+}
+
+// Run executes the set stream service command.
+// nolint: misspell
+func (cmd *SettingsStreamServiceCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Config.GetStreamServiceSettings()
+	if err != nil {
+		return fmt.Errorf("failed to get stream service settings: %w", err)
+	}
+
+	if cmd.Key == "" && cmd.Server == "" {
+		t := table.New().Border(lipgloss.RoundedBorder()).
+			BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+			Headers("Stream Service Setting", "Value").
+			StyleFunc(func(row, _ int) lipgloss.Style {
+				style := lipgloss.NewStyle().Padding(0, 3)
+				switch {
+				case row == table.HeaderRow:
+					style = style.Bold(true).Align(lipgloss.Center)
+				case row%2 == 0:
+					style = style.Foreground(ctx.Style.evenRows)
+				default:
+					style = style.Foreground(ctx.Style.oddRows)
+				}
+				return style
+			})
+
+		t.Row("Type", cmd.Type)
+		t.Row("Key", resp.StreamServiceSettings.Key)
+		t.Row("Server", resp.StreamServiceSettings.Server)
+
+		fmt.Fprintln(ctx.Out, t.Render())
+		return nil
+	}
+
+	if cmd.Key == "" {
+		cmd.Key = resp.StreamServiceSettings.Key
+	}
+	if cmd.Server == "" {
+		cmd.Server = resp.StreamServiceSettings.Server
+	}
+
+	_, err = ctx.Client.Config.SetStreamServiceSettings(
+		config.NewSetStreamServiceSettingsParams().
+			WithStreamServiceSettings(&typedefs.StreamServiceSettings{
+				Key:    cmd.Key,
+				Server: cmd.Server,
+			}).
+			WithStreamServiceType(cmd.Type),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to set stream service settings: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Stream service settings updated successfully.")
+	return nil
+}
+
+// SettingsVideoCmd gets/ sets video settings.
+type SettingsVideoCmd struct {
+	Show         bool `flag:"" help:"Show video settings."`
+	BaseWidth    int  `flag:"" help:"Base (canvas) width."           min:"8"`
+	BaseHeight   int  `flag:"" help:"Base (canvas) height."          min:"8"`
+	OutputWidth  int  `flag:"" help:"Output (scaled) width."         min:"8"`
+	OutputHeight int  `flag:"" help:"Output (scaled) height."        min:"8"`
+	FPSNum       int  `flag:"" help:"Frames per second numerator."   min:"1"`
+	FPSDen       int  `flag:"" help:"Frames per second denominator." min:"1"`
+}
+
+// Run executes the gets/ set video command.
+// nolint: misspell
+func (cmd *SettingsVideoCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Config.GetVideoSettings()
+	if err != nil {
+		return fmt.Errorf("failed to get video settings: %w", err)
+	}
+
+	if cmd.Show {
+		t := table.New().Border(lipgloss.RoundedBorder()).
+			BorderStyle(lipgloss.NewStyle().Foreground(ctx.Style.border)).
+			Headers("Video Setting", "Value").
+			StyleFunc(func(row, _ int) lipgloss.Style {
+				style := lipgloss.NewStyle().Padding(0, 3)
+				switch {
+				case row == table.HeaderRow:
+					style = style.Bold(true).Align(lipgloss.Center)
+				case row%2 == 0:
+					style = style.Foreground(ctx.Style.evenRows)
+				default:
+					style = style.Foreground(ctx.Style.oddRows)
+				}
+				return style
+			})
+
+		t.Row("Base Width", fmt.Sprintf("%.0f", resp.BaseWidth))
+		t.Row("Base Height", fmt.Sprintf("%.0f", resp.BaseHeight))
+		t.Row("Output Width", fmt.Sprintf("%.0f", resp.OutputWidth))
+		t.Row("Output Height", fmt.Sprintf("%.0f", resp.OutputHeight))
+		t.Row("FPS Numerator", fmt.Sprintf("%.0f", resp.FpsNumerator))
+		t.Row("FPS Denominator", fmt.Sprintf("%.0f", resp.FpsDenominator))
+
+		fmt.Fprintln(ctx.Out, t.Render())
+		return nil
+	}
+
+	if cmd.BaseWidth == 0 {
+		cmd.BaseWidth = int(resp.BaseWidth)
+	}
+	if cmd.BaseHeight == 0 {
+		cmd.BaseHeight = int(resp.BaseHeight)
+	}
+	if cmd.OutputWidth == 0 {
+		cmd.OutputWidth = int(resp.OutputWidth)
+	}
+	if cmd.OutputHeight == 0 {
+		cmd.OutputHeight = int(resp.OutputHeight)
+	}
+	if cmd.FPSNum == 0 {
+		cmd.FPSNum = int(resp.FpsNumerator)
+	}
+	if cmd.FPSDen == 0 {
+		cmd.FPSDen = int(resp.FpsDenominator)
+	}
+
+	_, err = ctx.Client.Config.SetVideoSettings(
+		config.NewSetVideoSettingsParams().
+			WithBaseWidth(float64(cmd.BaseWidth)).
+			WithBaseHeight(float64(cmd.BaseHeight)).
+			WithOutputWidth(float64(cmd.OutputWidth)).
+			WithOutputHeight(float64(cmd.OutputHeight)).
+			WithFpsNumerator(float64(cmd.FPSNum)).
+			WithFpsDenominator(float64(cmd.FPSDen)),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to set video settings: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Video settings updated successfully.")
+	return nil
+}

stream_test.go

@@ -12,7 +12,7 @@ func TestStreamStart(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -43,7 +43,7 @@ func TestStreamStart(t *testing.T) {
 	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
+	time.Sleep(500 * time.Millisecond) // Wait for the stream to start
 }
 
 func TestStreamStop(t *testing.T) {
@@ -51,7 +51,7 @@ func TestStreamStop(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -82,7 +82,7 @@ func TestStreamStop(t *testing.T) {
 	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
+	time.Sleep(500 * time.Millisecond) // Wait for the stream to stop
 }
 
 func TestStreamToggle(t *testing.T) {
@@ -90,7 +90,7 @@ func TestStreamToggle(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdStatus := &StreamStatusCmd{}
 	err := cmdStatus.Run(context)
@@ -119,5 +119,5 @@ func TestStreamToggle(t *testing.T) {
 			t.Fatalf("Expected 'Stream started successfully.', got: %s", out.String())
 		}
 	}
-	time.Sleep(2 * time.Second) // Wait for the stream to toggle
+	time.Sleep(500 * time.Millisecond) // Wait for the stream to toggle
 }

studiomode_test.go

@@ -10,7 +10,7 @@ func TestStudioModeEnable(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdEnable := &StudioModeEnableCmd{}
 	err := cmdEnable.Run(context)
@@ -38,7 +38,7 @@ func TestStudioModeDisable(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmdDisable := &StudioModeDisableCmd{}
 	err := cmdDisable.Run(context)

style.go

@@ -26,88 +26,88 @@ func (s *Style) Error(text string) string {
 	return lipgloss.NewStyle().Foreground(lipgloss.Color("#FF0000")).Render(text) // Red for errors
 }
 
-func newRedStyle() *Style {
-	return &Style{
+func newRedStyle() Style {
+	return Style{
 		name:      "red",
 		border:    lipgloss.Color("#D32F2F"), // Strong red for border
 		oddRows:   lipgloss.Color("#FFCDD2"), // Very light red for odd rows
 		evenRows:  lipgloss.Color("#EF9A9A"), // Light red for even rows
-		highlight: lipgloss.Color("#EF9A9A"),
+		highlight: lipgloss.Color("#EF9A9A"), // Highlight in light red
 	}
 }
 
-func newMagentaStyle() *Style {
-	return &Style{
+func newMagentaStyle() Style {
+	return Style{
 		name:      "magenta",
 		border:    lipgloss.Color("#C2185B"), // Strong magenta for border
 		oddRows:   lipgloss.Color("#F8BBD0"), // Very light magenta/pink for odd rows
 		evenRows:  lipgloss.Color("#F48FB1"), // Light magenta/pink for even rows
-		highlight: lipgloss.Color("#F48FB1"),
+		highlight: lipgloss.Color("#F48FB1"), // Highlight in light magenta/pink
 	}
 }
 
-func newPurpleStyle() *Style {
-	return &Style{
+func newPurpleStyle() Style {
+	return Style{
 		name:      "purple",
 		border:    lipgloss.Color("#7B1FA2"), // Strong purple for border
 		oddRows:   lipgloss.Color("#E1BEE7"), // Very light purple for odd rows
 		evenRows:  lipgloss.Color("#CE93D8"), // Light purple for even rows
-		highlight: lipgloss.Color("#CE93D8"),
+		highlight: lipgloss.Color("#CE93D8"), // Highlight in light purple
 	}
 }
 
-func newBlueStyle() *Style {
-	return &Style{
+func newBlueStyle() Style {
+	return Style{
 		name:      "blue",
 		border:    lipgloss.Color("#1976D2"), // Medium blue for border
 		oddRows:   lipgloss.Color("#E3F2FD"), // Very light blue for odd rows
 		evenRows:  lipgloss.Color("#BBDEFB"), // Light blue for even rows
-		highlight: lipgloss.Color("#1976D2"),
+		highlight: lipgloss.Color("#1976D2"), // Highlight in medium blue
 	}
 }
 
-func newCyanStyle() *Style {
-	return &Style{
+func newCyanStyle() Style {
+	return Style{
 		name:      "cyan",
 		border:    lipgloss.Color("#00BFCF"), // A strong cyan for border
 		oddRows:   lipgloss.Color("#E0F7FA"), // Very light cyan for odd rows
 		evenRows:  lipgloss.Color("#B2EBF2"), // Slightly darker light cyan for even rows
-		highlight: lipgloss.Color("#00BFCF"),
+		highlight: lipgloss.Color("#00BFCF"), // Highlight in strong cyan
 	}
 }
 
-func newGreenStyle() *Style {
-	return &Style{
+func newGreenStyle() Style {
+	return Style{
 		name:      "green",
 		border:    lipgloss.Color("#43A047"), // Medium green for border
 		oddRows:   lipgloss.Color("#E8F5E9"), // Very light green for odd rows
 		evenRows:  lipgloss.Color("#C8E6C9"), // Light green for even rows
-		highlight: lipgloss.Color("#43A047"),
+		highlight: lipgloss.Color("#43A047"), // Highlight in medium green
 	}
 }
 
-func newYellowStyle() *Style {
-	return &Style{
+func newYellowStyle() Style {
+	return Style{
 		name:      "yellow",
 		border:    lipgloss.Color("#FBC02D"), // Strong yellow for border
 		oddRows:   lipgloss.Color("#FFF9C4"), // Very light yellow for odd rows
 		evenRows:  lipgloss.Color("#FFF59D"), // Light yellow for even rows
-		highlight: lipgloss.Color("#FBC02D"),
+		highlight: lipgloss.Color("#FBC02D"), // Highlight in strong yellow
 	}
 }
 
-func newOrangeStyle() *Style {
-	return &Style{
+func newOrangeStyle() Style {
+	return Style{
 		name:      "orange",
 		border:    lipgloss.Color("#F57C00"), // Strong orange for border
 		oddRows:   lipgloss.Color("#FFF3E0"), // Very light orange for odd rows
 		evenRows:  lipgloss.Color("#FFE0B2"), // Light orange for even rows
-		highlight: lipgloss.Color("#F57C00"),
+		highlight: lipgloss.Color("#F57C00"), // Highlight in strong orange
 	}
 }
 
-func newWhiteStyle() *Style {
-	return &Style{
+func newWhiteStyle() Style {
+	return Style{
 		name:      "white",
 		border:    lipgloss.Color("#FFFFFF"), // White for border
 		oddRows:   lipgloss.Color("#F0F0F0"), // Very light grey for odd rows
@@ -116,8 +116,8 @@ func newWhiteStyle() *Style {
 	}
 }
 
-func newGreyStyle() *Style {
-	return &Style{
+func newGreyStyle() Style {
+	return Style{
 		name:      "grey",
 		border:    lipgloss.Color("#9E9E9E"), // Medium grey for border
 		oddRows:   lipgloss.Color("#F5F5F5"), // Very light grey for odd rows
@@ -126,8 +126,8 @@ func newGreyStyle() *Style {
 	}
 }
 
-func newNavyBlueStyle() *Style {
-	return &Style{
+func newNavyBlueStyle() Style {
+	return Style{
 		name:      "navy",
 		border:    lipgloss.Color("#001F3F"), // Navy blue for border
 		oddRows:   lipgloss.Color("#CFE2F3"), // Very light blue for odd rows
@@ -136,8 +136,8 @@ func newNavyBlueStyle() *Style {
 	}
 }
 
-func newBlackStyle() *Style {
-	return &Style{
+func newBlackStyle() Style {
+	return Style{
 		name:      "black",
 		border:    lipgloss.Color("#000000"), // Black for border
 		oddRows:   lipgloss.Color("#333333"), // Dark grey for odd rows
@@ -146,32 +146,34 @@ func newBlackStyle() *Style {
 	}
 }
 
-func styleFromFlag(colour string) *Style {
-	switch colour {
+func styleFromFlag(cfg StyleConfig) *Style {
+	var style Style
+
+	switch cfg.Style {
 	case "red":
-		return newRedStyle()
+		style = newRedStyle()
 	case "magenta":
-		return newMagentaStyle()
+		style = newMagentaStyle()
 	case "purple":
-		return newPurpleStyle()
+		style = newPurpleStyle()
 	case "blue":
-		return newBlueStyle()
+		style = newBlueStyle()
 	case "cyan":
-		return newCyanStyle()
+		style = newCyanStyle()
 	case "green":
-		return newGreenStyle()
+		style = newGreenStyle()
 	case "yellow":
-		return newYellowStyle()
+		style = newYellowStyle()
 	case "orange":
-		return newOrangeStyle()
+		style = newOrangeStyle()
 	case "white":
-		return newWhiteStyle()
+		style = newWhiteStyle()
 	case "grey":
-		return newGreyStyle()
+		style = newGreyStyle()
 	case "navy":
-		return newNavyBlueStyle()
+		style = newNavyBlueStyle()
 	case "black":
-		return newBlackStyle()
+		style = newBlackStyle()
 	default:
 		err := os.Setenv("NO_COLOR", "1") // nolint: misspell
 		if err != nil {
@@ -179,6 +181,12 @@ func styleFromFlag(colour string) *Style {
 			// This is a fallback to ensure that the application can still run
 			fmt.Fprintf(os.Stderr, "Error setting NO_COLOR: %v\n", err)
 		}
-		return &Style{}
 	}
+
+	// If noBorder is true, we disable the border styling
+	if cfg.NoBorder {
+		style.border = ""
+	}
+
+	return &style
 }

text.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/andreykaipov/goobs/api/requests/inputs"
+)
+
+// TextCmd provides commands for managing text inputs in OBS.
+type TextCmd struct {
+	Current TextCurrentCmd `cmd:"current" help:"Display current text for a text input." aliases:"c"`
+	Update  TextUpdateCmd  `cmd:"update"  help:"Update the text of a text input."       aliases:"u"`
+}
+
+// TextCurrentCmd provides a command to display the current text of a text input.
+type TextCurrentCmd struct {
+	InputName string `arg:"" help:"Name of the text source."`
+}
+
+// Run executes the command to display the current text of a text input.
+func (cmd *TextCurrentCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Inputs.GetInputSettings(
+		inputs.NewGetInputSettingsParams().WithInputName(cmd.InputName),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get input settings: %w", err)
+	}
+
+	// Check if the input is a text input
+	kind := resp.InputKind
+	if !strings.HasPrefix(kind, "text_") {
+		return fmt.Errorf("input %s is of %s", cmd.InputName, kind)
+	}
+
+	currentText, ok := resp.InputSettings["text"]
+	if !ok {
+		return fmt.Errorf("input %s does not have a 'text' setting", cmd.InputName)
+	}
+	if currentText == "" {
+		currentText = "(empty)"
+	}
+	fmt.Fprintf(
+		ctx.Out,
+		"Current text for source %s: %s\n",
+		ctx.Style.Highlight(cmd.InputName),
+		currentText,
+	)
+	return nil
+}
+
+// TextUpdateCmd provides a command to update the text of a text input.
+type TextUpdateCmd struct {
+	InputName string `arg:"" help:"Name of the text source."`
+	NewText   string `arg:"" help:"New text to set for the source." default:""`
+}
+
+// Run executes the command to update the text of a text input.
+func (cmd *TextUpdateCmd) Run(ctx *context) error {
+	resp, err := ctx.Client.Inputs.GetInputSettings(
+		inputs.NewGetInputSettingsParams().WithInputName(cmd.InputName),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to get input settings: %w", err)
+	}
+
+	// Check if the input is a text input
+	kind := resp.InputKind
+	if !strings.HasPrefix(kind, "text_") {
+		return fmt.Errorf("input %s is of %s", cmd.InputName, kind)
+	}
+
+	if _, err := ctx.Client.Inputs.SetInputSettings(&inputs.SetInputSettingsParams{
+		InputName:     &cmd.InputName,
+		InputSettings: map[string]any{"text": &cmd.NewText},
+	}); err != nil {
+		return fmt.Errorf("failed to update text for source %s: %w", cmd.InputName, err)
+	}
+
+	if cmd.NewText == "" {
+		cmd.NewText = "(empty)"
+	}
+	fmt.Fprintf(ctx.Out, "Updated text for source %s to: %s\n", ctx.Style.Highlight(cmd.InputName), cmd.NewText)
+	return nil
+}

version.go

@@ -2,38 +2,8 @@ package main
 
 import (
 	"fmt"
-	"runtime/debug"
-	"strings"
-
-	"github.com/alecthomas/kong"
 )
 
-var version string
-
-// VersionFlag is a custom flag type for displaying version information.
-type VersionFlag string
-
-// Decode implements the kong.Flag interface.
-func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }
-
-// IsBool implements the kong.Flag interface.
-func (v VersionFlag) IsBool() bool { return true }
-
-// BeforeApply implements the kong.Flag interface.
-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
 

version_test.go

@@ -11,7 +11,7 @@ func TestVersion(t *testing.T) {
 	defer disconnect()
 
 	var out bytes.Buffer
-	context := newContext(client, &out, "")
+	context := newContext(client, &out, StyleConfig{})
 
 	cmd := &ObsVersionCmd{}
 	err := cmd.Run(context)