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,13 @@ 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

README.md

@@ -264,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:
 
@@ -281,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
 
@@ -302,6 +322,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 +725,58 @@ 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.
+    -   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.

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"`
-	Mute   InputMuteCmd   `cmd:"" help:"Mute input."      aliases:"m"`
-	Unmute InputUnmuteCmd `cmd:"" help:"Unmute input."    aliases:"um"`
-	Toggle InputToggleCmd `cmd:"" help:"Toggle input."    aliases:"tg"`
+	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
+}

main.go

@@ -71,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 {

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
+}