move obs connection logic into run() so we can exit early when running completion

replace set-cursor with cursor which can now get/set cursor position

CHANGELOG.md

@@ -5,6 +5,25 @@ 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.18.0] - 2026-01-23
+
+### Added
+
+-   support for shell completion, see [Shell Completion](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#shell-completion)
+
+# [0.17.0] - 2026-01-09
+
+### Added
+
+-   media command group, see [MediaCmd](https://github.com/onyx-and-iris/gobs-cli?tab=readme-ov-file#mediacmd)
+
+# [0.16.2] - 2026-01-08
+
+### 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

README.md

@@ -12,6 +12,7 @@ For an outline of past/future changes refer to: [CHANGELOG](CHANGELOG.md)
 - [Configuration](#configuration)
 - [Style](#style)
 - [Commands](#commands)
+- [Shell Completion](#shell-completion)
 - [License](#license)
 
 ## Installation
@@ -264,6 +265,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:
 
@@ -281,6 +296,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
 
@@ -302,6 +323,34 @@ 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.
@@ -677,6 +726,115 @@ gobs-cli projector open --monitor-index=1 "test_group"
 gobs-cli screenshot save --width=2560 --height=1440 "Scene" "C:\Users\me\Videos\screenshot.png"
 ```
 
+### SettingsCmd
+
+-   show: Show settings.
+    -   flags:
+
+        *optional*
+        -   --video: Show video settings.
+        -   --record: Show record directory.
+        -   --profile: Show profile parameters.
+
+```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.
+    -   flags:
+        -   --key: Stream key.
+        -   --server: Stream server URL.
+
+    *optional*
+    -   args: Type
+
+```console
+gobs-cli settings stream-service
+
+gobs-cli settings stream-service --key='live_xyzxyzxyzxyz' rtmp_common
+```
+
+-   video: Get/Set video setting.
+    -   flags:
+
+        *optional*
+        -   --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
+
+gobs-cli settings video --base-width=1920 --base-height=1080
+```
+
+### MediaCmd
+
+-   cursor: Get/set the cursor position of a media input.
+    -   args: InputName
+
+        *optional*
+        -   TimeString
+
+```console
+gobs-cli media cursor "Media"
+
+gobs-cli media cursor "Media" "00:08:30"
+```
+
+-   play: Plays a media input.
+
+```console
+gobs-cli media play "Media"
+```
+
+-   pause: Pauses a media input.
+
+```console
+gobs-cli media pause "Media"
+```
+
+-   stop: Stops a media input.
+
+```console
+gobs-cli media stop "Media"
+```
+
+-   restart: Restarts a media input.
+
+```console
+gobs-cli media restart "Media"
+```
+
+
+## Shell Completion
+
+-   completion:
+
+    *optional*
+    -   args: Shell
+
+```console
+gobs-cli completion
+
+gobs-cli completion bash
+```
+
+Currently supported shells: *bash* *zsh* *fish*. If no shell is passed completion will attempt to detect the current user shell.
+
+
 ## License
 
 `gobs-cli` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

go.mod

@@ -1,12 +1,13 @@
 module github.com/onyx-and-iris/gobs-cli
 
-go 1.24.0
+go 1.25
 
 require (
-	github.com/alecthomas/kong v1.10.0
+	github.com/alecthomas/kong v1.13.0
 	github.com/alecthomas/mango-kong v0.1.0
 	github.com/andreykaipov/goobs v1.5.6
 	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/jotaen/kong-completion v0.0.9
 	github.com/titusjaka/kong-dotenv-go v0.1.0
 )
 
@@ -18,6 +19,8 @@ require (
 	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/hashicorp/logutils v1.0.0 // indirect
 	github.com/joho/godotenv v1.5.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
@@ -29,7 +32,9 @@ require (
 	github.com/muesli/roff v0.1.0 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
+	github.com/posener/complete v1.2.3 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/sys v0.30.0 // indirect
 )

go.sum

@@ -1,11 +1,11 @@
 github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
 github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/kong v1.10.0 h1:8K4rGDpT7Iu+jEXCIJUeKqvpwZHbsFRoebLbnzlmrpw=
+github.com/alecthomas/kong v1.13.0 h1:5e/7XC3ugvhP1DQBmTS+WuHtCbcv44hsohMgcvVxSrA=
-github.com/alecthomas/kong v1.10.0/go.mod h1:p2vqieVMeTAnaC83txKtXe8FLke2X07aruPWXyMPQrU=
+github.com/alecthomas/kong v1.13.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
 github.com/alecthomas/mango-kong v0.1.0 h1:iFVfP1k1K4qpml3JUQmD5I8MCQYfIvsD9mRdrw7jJC4=
 github.com/alecthomas/mango-kong v0.1.0/go.mod h1:t+TYVdsONUolf/BwVcm+15eqcdAj15h4Qe9MMFAwwT4=
-github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
-github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/andreykaipov/goobs v1.5.6 h1:eIkEqYN99+2VJvmlY/56Ah60nkRKS6efMQvpM3oUgPQ=
 github.com/andreykaipov/goobs v1.5.6/go.mod h1:iSZP93FJ4d9X/U1x4DD4IyILLtig+vViqZWBGjLywcY=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
@@ -26,16 +26,25 @@ github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a h1:G99k
 github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
 github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
 github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
 github.com/hashicorp/logutils v1.0.0 h1:dLEQVugN8vlakKOUE3ihGLTZJRB4j+M2cdTm/ORI65Y=
 github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/jotaen/kong-completion v0.0.9 h1:yXKSRvjWuuZlTGpPMpvo96sFjh5PEh/skrcK4DjJnfg=
+github.com/jotaen/kong-completion v0.0.9/go.mod h1:dyIG20e3qq128SUBtF8jzI7YtkfzjWMlgbqkAJd6xHQ=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -56,11 +65,17 @@ github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/
 github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/posener/complete v1.2.3 h1:NP0eAhjcjImqslEwo/1hq7gpajME0fTLTezBKDqfXqo=
+github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab h1:ZjX6I48eZSFetPb41dHudEyVr5v953N15TsNZXlkcWY=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab/go.mod h1:/PfPXh0EntGc3QAAyUaviy4S9tzy4Zp0e2ilq4voC6E=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/titusjaka/kong-dotenv-go v0.1.0 h1:TmUjP/sXoNiKLr6oR7n9xrB5XyXi/Ssuebzfz5nxZj4=
 github.com/titusjaka/kong-dotenv-go v0.1.0/go.mod h1:pBgLjcu82oqUgb7+bngK9+Ch7jg49E0YADP8Wnj2MXU=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
@@ -70,5 +85,7 @@ golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

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 {
-	List   InputListCmd   `cmd:"" help:"List all inputs." aliases:"ls"`
+	Create       InputCreateCmd       `cmd:"" help:"Create input."                           aliases:"c"`
-	Mute   InputMuteCmd   `cmd:"" help:"Mute input."      aliases:"m"`
+	Remove       InputRemoveCmd       `cmd:"" help:"Remove input."                           aliases:"d"`
-	Unmute InputUnmuteCmd `cmd:"" help:"Unmute input."    aliases:"um"`
+	List         InputListCmd         `cmd:"" help:"List all inputs."                        aliases:"ls"`
-	Toggle InputToggleCmd `cmd:"" help:"Toggle input."    aliases:"tg"`
+	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
+}

main.go

@@ -15,6 +15,7 @@ import (
 	"github.com/alecthomas/kong"
 	mangokong "github.com/alecthomas/mango-kong"
 	"github.com/andreykaipov/goobs"
+	kongcompletion "github.com/jotaen/kong-completion"
 	kongdotenv "github.com/titusjaka/kong-dotenv-go"
 )
 
@@ -54,6 +55,8 @@ type CLI struct {
 	Man     mangokong.ManFlag `help:"Print man page."`
 	Version VersionFlag       `help:"Print gobs-cli version information and quit" name:"version" short:"v"`
 
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
+
 	ObsVersion      ObsVersionCmd      `help:"Print OBS client and websocket version." cmd:"" aliases:"v"`
 	Scene           SceneCmd           `help:"Manage scenes."                          cmd:"" aliases:"sc"  group:"Scene"`
 	Sceneitem       SceneItemCmd       `help:"Manage scene items."                     cmd:"" aliases:"si"  group:"Scene Item"`
@@ -71,6 +74,8 @@ 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"`
+	Media           MediaCmd           `help:"Manage media inputs."                    cmd:"" aliases:"mi"  group:"Media Input"`
 }
 
 type context struct {
@@ -95,6 +100,7 @@ func main() {
 	}
 
 	var cli CLI
+	kongcompletion.Register(kong.Must(&cli))
 	ctx := kong.Parse(
 		&cli,
 		kong.Name("gobs-cli"),
@@ -117,12 +123,7 @@ func main() {
 			}(),
 		})
 
-	client, err := connectObs(cli.ObsConfig)
+	ctx.FatalIfErrorf(run(ctx, cli.ObsConfig, cli.StyleConfig))
-	ctx.FatalIfErrorf(err)
-
-	ctx.Bind(newContext(client, os.Stdout, cli.StyleConfig))
-
-	ctx.FatalIfErrorf(run(ctx, client))
 }
 
 // connectObs creates a new OBS client and connects to the OBS WebSocket server.
@@ -139,8 +140,18 @@ func connectObs(cfg ObsConfig) (*goobs.Client, error) {
 }
 
 // run executes the command line interface.
-// It disconnects the OBS client after the command is executed.
+// It connects to the OBS WebSocket server and binds the context to the selected command.
-func run(ctx *kong.Context, client *goobs.Client) error {
+// It also handles the "completion" command separately to avoid unnecessary connections.
+func run(ctx *kong.Context, obsCfg ObsConfig, styleCfg StyleConfig) error {
+	if ctx.Selected().Name == "completion" {
+		return ctx.Run()
+	}
+
+	client, err := connectObs(obsCfg)
+	if err != nil {
+		return err
+	}
+
 	defer func() error {
 		if err := client.Disconnect(); err != nil {
 			return fmt.Errorf("failed to disconnect from OBS: %w", err)
@@ -148,5 +159,7 @@ func run(ctx *kong.Context, client *goobs.Client) error {
 		return nil
 	}()
 
+	ctx.Bind(newContext(client, os.Stdout, styleCfg))
+
 	return ctx.Run()
 }

media.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/andreykaipov/goobs/api/requests/mediainputs"
+)
+
+// MediaCmd represents a collection of commands to control media inputs.
+type MediaCmd struct {
+	Cursor  MediaCursorCmd  `cmd:"" help:"Get/set the cursor position of a media input." aliases:"c"`
+	Play    MediaPlayCmd    `cmd:"" help:"Plays a media input."                          aliases:"p"`
+	Pause   MediaPauseCmd   `cmd:"" help:"Pauses a media input."                         aliases:"pa"`
+	Stop    MediaStopCmd    `cmd:"" help:"Stops a media input."                          aliases:"s"`
+	Restart MediaRestartCmd `cmd:"" help:"Restarts a media input."                       aliases:"r"`
+}
+
+// MediaCursorCmd represents the command to get or set the cursor position of a media input.
+type MediaCursorCmd struct {
+	InputName  string `arg:"" help:"Name of the media input."`
+	TimeString string `arg:"" help:"Time position to set the cursor to (e.g., '00:01:30' for 1 minute 30 seconds). If not provided, the current cursor position will be displayed." optional:""`
+}
+
+// Run executes the command to set the cursor position of the media input.
+func (cmd *MediaCursorCmd) Run(ctx *context) error {
+	if cmd.TimeString == "" {
+		resp, err := ctx.Client.MediaInputs.GetMediaInputStatus(
+			mediainputs.NewGetMediaInputStatusParams().
+				WithInputName(cmd.InputName))
+		if err != nil {
+			return fmt.Errorf("failed to get media input cursor: %w", err)
+		}
+
+		fmt.Fprintf(
+			ctx.Out,
+			"%s cursor position: %s\n",
+			ctx.Style.Highlight(cmd.InputName),
+			formatMillisecondsToTimeString(resp.MediaCursor),
+		)
+		return nil
+	}
+
+	position, err := parseTimeStringToMilliseconds(cmd.TimeString)
+	if err != nil {
+		return fmt.Errorf("failed to parse time string: %w", err)
+	}
+
+	_, err = ctx.Client.MediaInputs.SetMediaInputCursor(
+		mediainputs.NewSetMediaInputCursorParams().
+			WithInputName(cmd.InputName).
+			WithMediaCursor(position))
+	if err != nil {
+		return fmt.Errorf("failed to set media input cursor: %w", err)
+	}
+
+	fmt.Fprintf(
+		ctx.Out,
+		"Set %s cursor to %s (%.0f ms)\n",
+		ctx.Style.Highlight(cmd.InputName),
+		ctx.Style.Highlight(cmd.TimeString),
+		position,
+	)
+	return nil
+}
+
+// MediaPlayCmd represents the command to play a media input.
+type MediaPlayCmd struct {
+	InputName string `arg:"" help:"Name of the media input."`
+}
+
+// Run executes the command to play the media input.
+func (cmd *MediaPlayCmd) Run(ctx *context) error {
+	_, err := ctx.Client.MediaInputs.TriggerMediaInputAction(
+		mediainputs.NewTriggerMediaInputActionParams().
+			WithInputName(cmd.InputName).
+			WithMediaAction("OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY"))
+	if err != nil {
+		return fmt.Errorf("failed to play media input: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Playing media input:", cmd.InputName)
+	return nil
+}
+
+// MediaPauseCmd represents the command to pause a media input.
+type MediaPauseCmd struct {
+	InputName string `arg:"" help:"Name of the media input."`
+}
+
+// Run executes the command to pause the media input.
+func (cmd *MediaPauseCmd) Run(ctx *context) error {
+	_, err := ctx.Client.MediaInputs.TriggerMediaInputAction(
+		mediainputs.NewTriggerMediaInputActionParams().
+			WithInputName(cmd.InputName).
+			WithMediaAction("OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE"))
+	if err != nil {
+		return fmt.Errorf("failed to pause media input: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Pausing media input:", cmd.InputName)
+	return nil
+}
+
+// MediaStopCmd represents the command to stop a media input.
+type MediaStopCmd struct {
+	InputName string `arg:"" help:"Name of the media input."`
+}
+
+// Run executes the command to stop the media input.
+func (cmd *MediaStopCmd) Run(ctx *context) error {
+	_, err := ctx.Client.MediaInputs.TriggerMediaInputAction(
+		mediainputs.NewTriggerMediaInputActionParams().
+			WithInputName(cmd.InputName).
+			WithMediaAction("OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP"))
+	if err != nil {
+		return fmt.Errorf("failed to stop media input: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Stopping media input:", cmd.InputName)
+	return nil
+}
+
+// MediaRestartCmd represents the command to restart a media input.
+type MediaRestartCmd struct {
+	InputName string `arg:"" help:"Name of the media input."`
+}
+
+// Run executes the command to restart the media input.
+func (cmd *MediaRestartCmd) Run(ctx *context) error {
+	_, err := ctx.Client.MediaInputs.TriggerMediaInputAction(
+		mediainputs.NewTriggerMediaInputActionParams().
+			WithInputName(cmd.InputName).
+			WithMediaAction("OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART"))
+	if err != nil {
+		return fmt.Errorf("failed to restart media input: %w", err)
+	}
+
+	fmt.Fprintln(ctx.Out, "Restarting media input:", cmd.InputName)
+	return 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)." optional:""`
+	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.Type == "" {
+		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", resp.StreamServiceType)
+		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 {
+	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.BaseWidth == 0 && cmd.BaseHeight == 0 && cmd.OutputWidth == 0 &&
+		cmd.OutputHeight == 0 && cmd.FPSNum == 0 && cmd.FPSDen == 0 {
+		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
+}

util.go

@@ -3,8 +3,10 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"strings"
+	"time"
 )
 
 func snakeCaseToTitleCase(snake string) string {
@@ -36,3 +38,41 @@ func trimPrefix(s, prefix string) string {
 	}
 	return s
 }
+
+func parseTimeStringToMilliseconds(timeStr string) (float64, error) {
+	parts := strings.Split(timeStr, ":")
+	var durationStr string
+
+	switch len(parts) {
+	case 1:
+		// Format: SS -> "SSs"
+		durationStr = parts[0] + "s"
+	case 2:
+		// Format: MM:SS -> "MMmSSs"
+		durationStr = parts[0] + "m" + parts[1] + "s"
+	case 3:
+		// Format: HH:MM:SS -> "HHhMMmSSs"
+		durationStr = parts[0] + "h" + parts[1] + "m" + parts[2] + "s"
+	default:
+		return 0, fmt.Errorf("invalid time format: %s", timeStr)
+	}
+
+	duration, err := time.ParseDuration(durationStr)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse duration: %w", err)
+	}
+
+	return duration.Seconds() * 1000, nil
+}
+
+func formatMillisecondsToTimeString(ms float64) string {
+	totalSeconds := int(ms / 1000)
+	hours := totalSeconds / 3600
+	minutes := (totalSeconds % 3600) / 60
+	seconds := totalSeconds % 60
+
+	if hours > 0 {
+		return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+	}
+	return fmt.Sprintf("%02d:%02d", minutes, seconds)
+}