implement info command

upd help mds

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+  - repo: local
+    hooks:
+      - id: update-readme
+        name: update-readme
+        entry: python update_readme.py
+        language: python
+        pass_filenames: false

README.md

@@ -54,134 +54,14 @@ export X32_CLI_TIMEOUT=100ms
 export X32_CLI_LOGLEVEL=warn
 ```
 
+---
+
 ### Use
 
-```console
-Usage: xair-cli <command> [flags]
+For each command/subcommand in the tree there exists a `--help` flag, use it to print usage information.
 
-A CLI to control Behringer X-Air mixers.
-
-Flags:
-  -h, --help                  Show context-sensitive help.
-  -H, --host="mixer.local"    The host of the X-Air device ($XAIR_CLI_HOST).
-  -P, --port=10024            The port of the X-Air device ($XAIR_CLI_PORT).
-  -T, --timeout=100ms         Timeout for OSC operations ($XAIR_CLI_TIMEOUT).
-  -L, --loglevel="warn"       Log level for the CLI ($XAIR_CLI_LOGLEVEL).
-  -v, --version               Print xair-cli version information and quit
-
-Commands:
-  completion (c)    Generate shell completion scripts.
-
-Raw
-  raw    Send raw OSC messages to the mixer.
-
-Main
-  main mute              Get or set the mute state of the Main L/R output.
-  main fader             Get or set the fader level of the Main L/R output.
-  main fadein            Fade in the Main L/R output over a specified duration.
-  main fadeout           Fade out the Main L/R output over a specified duration.
-  main eq on             Get or set the EQ on/off state of the Main L/R output.
-  main eq <band> gain    Get or set the gain of the specified EQ band.
-  main eq <band> freq    Get or set the frequency of the specified EQ band.
-  main eq <band> q       Get or set the Q factor of the specified EQ band.
-  main eq <band> type    Get or set the type of the specified EQ band.
-  main comp on           Get or set the compressor on/off state of the Main L/R
-                         output.
-  main comp mode         Get or set the compressor mode of the Main L/R output.
-  main comp threshold    Get or set the compressor threshold of the Main L/R
-                         output.
-  main comp ratio        Get or set the compressor ratio of the Main L/R output.
-  main comp mix          Get or set the compressor mix level of the Main L/R
-                         output.
-  main comp makeup       Get or set the compressor makeup gain of the Main L/R
-                         output.
-  main comp attack       Get or set the compressor attack time of the Main L/R
-                         output.
-  main comp hold         Get or set the compressor hold time of the Main L/R
-                         output.
-  main comp release      Get or set the compressor release time of the Main L/R
-                         output.
-
-Strip
-  strip <index> mute              Get or set the mute state of the strip.
-  strip <index> fader             Get or set the fader level of the strip.
-  strip <index> fadein            Fade in the strip over a specified duration.
-  strip <index> fadeout           Fade out the strip over a specified duration.
-  strip <index> send              Get or set the send level for a specific bus.
-  strip <index> name              Get or set the name of the strip.
-  strip <index> gate on           Get or set the gate on/off state of the strip.
-  strip <index> gate mode         Get or set the gate mode of the strip.
-  strip <index> gate threshold    Get or set the gate threshold of the strip.
-  strip <index> gate range        Get or set the gate range of the strip.
-  strip <index> gate attack       Get or set the gate attack time of the strip.
-  strip <index> gate hold         Get or set the gate hold time of the strip.
-  strip <index> gate release      Get or set the gate release time of the strip.
-  strip <index> eq on             Get or set the EQ on/off state of the strip.
-  strip <index> eq <band> gain    Get or set the gain of the EQ band.
-  strip <index> eq <band> freq    Get or set the frequency of the EQ band.
-  strip <index> eq <band> q       Get or set the Q factor of the EQ band.
-  strip <index> eq <band> type    Get or set the type of the EQ band.
-  strip <index> comp on           Get or set the compressor on/off state of the
-                                  strip.
-  strip <index> comp mode         Get or set the compressor mode of the strip.
-  strip <index> comp threshold    Get or set the compressor threshold of the
-                                  strip.
-  strip <index> comp ratio        Get or set the compressor ratio of the strip.
-  strip <index> comp mix          Get or set the compressor mix of the strip.
-  strip <index> comp makeup       Get or set the compressor makeup gain of the
-                                  strip.
-  strip <index> comp attack       Get or set the compressor attack time of the
-                                  strip.
-  strip <index> comp hold         Get or set the compressor hold time of the
-                                  strip.
-  strip <index> comp release      Get or set the compressor release time of the
-                                  strip.
-
-Bus
-  bus <index> mute              Get or set the mute state of the bus.
-  bus <index> fader             Get or set the fader level of the bus.
-  bus <index> fadein            Fade in the bus over a specified duration.
-  bus <index> fadeout           Fade out the bus over a specified duration.
-  bus <index> name              Get or set the name of the bus.
-  bus <index> eq on             Get or set the EQ on/off state of the bus.
-  bus <index> eq mode           Get or set the EQ mode of the bus (peq, geq or
-                                teq).
-  bus <index> eq <band> gain    Get or set the gain of the EQ band.
-  bus <index> eq <band> freq    Get or set the frequency of the EQ band.
-  bus <index> eq <band> q       Get or set the Q factor of the EQ band.
-  bus <index> eq <band> type    Get or set the type of the EQ band (lcut, lshv,
-                                peq, veq, hshv, hcut).
-  bus <index> comp on           Get or set the compressor on/off state of the
-                                bus.
-  bus <index> comp mode         Get or set the compressor mode of the bus (comp,
-                                exp).
-  bus <index> comp threshold    Get or set the compressor threshold of the bus
-                                (in dB).
-  bus <index> comp ratio        Get or set the compressor ratio of the bus.
-  bus <index> comp mix          Get or set the compressor mix level of the bus
-                                (in %).
-  bus <index> comp makeup       Get or set the compressor makeup gain of the bus
-                                (in dB).
-  bus <index> comp attack       Get or set the compressor attack time of the bus
-                                (in ms).
-  bus <index> comp hold         Get or set the compressor hold time of the bus
-                                (in ms).
-  bus <index> comp release      Get or set the compressor release time of the
-                                bus (in ms).
-
-Headamp
-  headamp <index> gain       Get or set the gain of the headamp.
-  headamp <index> phantom    Get or set the phantom power state of the headamp.
-
-Snapshot
-  snapshot list              List all snapshots.
-  snapshot <index> name      Get or set the name of a snapshot.
-  snapshot <index> save      Save the current mixer state to a snapshot.
-  snapshot <index> load      Load a mixer state from a snapshot.
-  snapshot <index> delete    Delete a snapshot.
-
-Run "xair-cli <command> --help" for more information on a command.
-```
+- [xair-cli](./xair-help.md)
+- [x32-cli](./x32-help.md)
 
 ### Examples
 
@@ -231,6 +111,7 @@ xair-cli raw /ch/01/config/name
 xair-cli snapshot 20 save 'twitch live'
 ```
 
+---
 
 ### License
 

Taskfile.build-x32.yml

@@ -1,23 +1,22 @@
 version: '3'
 
 vars:
-  BIN_X32: x32-cli
+  WINDOWS: '{{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe'
+  LINUX: '{{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64'
+  MACOS: '{{.BIN_DIR}}/{{.PROGRAM}}_darwin_amd64'
 
 tasks:
   windows-amd64:
     desc: Build the x32-cli project for Windows
     cmds:
-      - GOOS=windows GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_X32}}_windows_amd64.exe -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_X32}}
-    internal: true
+      - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}
 
   linux-amd64:
     desc: Build the x32-cli project for Linux
     cmds:
-      - GOOS=linux GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_X32}}_linux_amd64 -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_X32}}
-    internal: true
+      - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}
 
   darwin-amd64:
     desc: Build the x32-cli project for macOS
     cmds:
-      - GOOS=darwin GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_X32}}_darwin_amd64 -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_X32}}
-    internal: true
+      - GOOS=darwin GOARCH=amd64 go build -o {{.MACOS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}

Taskfile.build-xair.yml

@@ -1,23 +1,22 @@
 version: '3'
 
 vars:
-  BIN_XAIR: xair-cli
+  WINDOWS: '{{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe'
+  LINUX: '{{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64'
+  MACOS: '{{.BIN_DIR}}/{{.PROGRAM}}_darwin_amd64'
 
 tasks:
   windows-amd64:
     desc: Build the xair-cli project for Windows
     cmds:
-      - GOOS=windows GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_XAIR}}_windows_amd64.exe -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_XAIR}}
-    internal: true
+      - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}
 
   linux-amd64:
     desc: Build the xair-cli project for Linux
     cmds:
-      - GOOS=linux GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_XAIR}}_linux_amd64 -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_XAIR}}
-    internal: true
+      - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}
 
   darwin-amd64:
     desc: Build the xair-cli project for macOS
     cmds:
-      - GOOS=darwin GOARCH=amd64 go build -o {{.BIN_DIR}}/{{.BIN_XAIR}}_darwin_amd64 -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.BIN_XAIR}}
-    internal: true
+      - GOOS=darwin GOARCH=amd64 go build -o {{.MACOS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}

Taskfile.yml

@@ -1,8 +1,16 @@
 version: '3'
 
 includes:
-  build-xair: ./Taskfile.build-xair.yml
-  build-x32: ./Taskfile.build-x32.yml
+  build-xair:
+    taskfile: ./Taskfile.build-xair.yml
+    internal: true
+    vars:
+      PROGRAM: xair-cli
+  build-x32:
+    taskfile: ./Taskfile.build-x32.yml
+    internal: true
+    vars:
+      PROGRAM: x32-cli
 
 vars:
   SHELL: '{{if eq .OS "Windows_NT"}}powershell{{end}}'
@@ -20,13 +28,11 @@ tasks:
     desc: Build the xair-cli and x32-cli projects for all platforms
     deps: [vet]
     cmds:
-      - task: build-xair:windows-amd64
-      - task: build-xair:linux-amd64
-      - task: build-xair:darwin-amd64
-
-      - task: build-x32:windows-amd64
-      - task: build-x32:linux-amd64
-      - task: build-x32:darwin-amd64
+      - for:
+          matrix:
+            PROGRAM: ['build-xair', 'build-x32']
+            TARGET: ['windows-amd64', 'linux-amd64', 'darwin-amd64']
+        task: '{{.ITEM.PROGRAM}}:{{.ITEM.TARGET}}'
 
   vet:
     desc: Vet the code

cmd/x32-cli/bus.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // BusCmdGroup defines the commands related to controlling the buses of the X-Air device.
@@ -174,7 +172,7 @@ type BusEqCmdGroup struct {
 	On   BusEqOnCmd   `help:"Get or set the EQ on/off state of the bus."              cmd:"on"`
 	Mode BusEqModeCmd `help:"Get or set the EQ mode of the bus (peq, geq or teq)."    cmd:"mode"`
 	Band struct {
-		Band int              `arg:"" help:"The EQ band number."`
+		Band *int             `arg:"" help:"The EQ band number." optional:""`
 		Gain BusEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:"gain"`
 		Freq BusEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:"freq"`
 		Q    BusEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:"q"`
@@ -183,9 +181,13 @@ type BusEqCmdGroup struct {
 }
 
 // Validate checks that the provided EQ band number is within the valid range (1-6).
-func (cmd *BusEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6")
+func (cmd *BusEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -244,18 +246,18 @@ type BusEqBandGainCmd struct {
 // Run executes the BusEqBandGainCmd command, either retrieving the current gain of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, busEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, *busEq.Band.Band, *cmd.Gain); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, busEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -267,18 +269,18 @@ type BusEqBandFreqCmd struct {
 // Run executes the BusEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, busEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, *cmd.Freq)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
 	return nil
 }
 
@@ -290,18 +292,18 @@ type BusEqBandQCmd struct {
 // Run executes the BusEqBandQCmd command, either retrieving the current Q factor of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, busEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, *busEq.Band.Band, *cmd.Q); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, busEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -313,18 +315,18 @@ type BusEqBandTypeCmd struct {
 // Run executes the BusEqBandTypeCmd command, either retrieving the current type of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, busEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, *busEq.Band.Band, *cmd.Type); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, busEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/x32-cli/cli.go

@@ -46,9 +46,10 @@ type CLI struct {
 
 	Version VersionFlag `help:"Print x32-cli version information and quit" name:"version" short:"v"`
 
-	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts."  cmd:""`
+	Info       InfoCmd                   `help:"Print mixer information."            cmd:""`
+	Raw        RawCmd                    `help:"Send raw OSC messages to the mixer." cmd:""`
 
-	Raw      RawCmd           `help:"Send raw OSC messages to the mixer."   cmd:"" group:"Raw"`
 	Main     MainCmdGroup     `help:"Control the Main L/R output"           cmd:"" group:"Main"`
 	Mainmono MainMonoCmdGroup `help:"Control the Main Mono output"          cmd:"" group:"MainMono"`
 	Matrix   MatrixCmdGroup   `help:"Control the matrix outputs."           cmd:"" group:"Matrix"`
@@ -56,6 +57,7 @@ type CLI struct {
 	Bus      BusCmdGroup      `help:"Control the buses."                    cmd:"" group:"Bus"`
 	Headamp  HeadampCmdGroup  `help:"Control input gain and phantom power." cmd:"" group:"Headamp"`
 	Snapshot SnapshotCmdGroup `help:"Save and load mixer states."           cmd:"" group:"Snapshot"`
+	Dca      DCACmdGroup      `help:"Control DCA groups."                   cmd:"" group:"DCA"`
 }
 
 func main() {

cmd/x32-cli/dca.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"fmt"
+)
+
+type DCACmdGroup struct {
+	Index struct {
+		Index int        `arg:"" help:"The index of the DCA group (1-8)."`
+		Mute  DCAMuteCmd `help:"Get or set the mute status of the DCA group." cmd:""`
+		Name  DCANameCmd `help:"Get or set the name of the DCA group." cmd:""`
+	} `arg:"" help:"Control a specific DCA group by its index."`
+}
+
+// Validate checks if the provided index is within the valid range.
+func (cmd *DCACmdGroup) Validate() error {
+	if cmd.Index.Index < 1 || cmd.Index.Index > 8 {
+		return fmt.Errorf("DCA group index must be between 1 and 8, got %d", cmd.Index.Index)
+	}
+	return nil
+}
+
+// DCAMuteCmd is the command to get or set the mute status of a DCA group.
+type DCAMuteCmd struct {
+	State *string `arg:"" help:"Set the mute status of the DCA group." optional:"" enum:"true,false"`
+}
+
+// Run executes the DCAMuteCmd command.
+func (cmd *DCAMuteCmd) Run(ctx *context, dca *DCACmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.DCA.Mute(dca.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get DCA mute status: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "DCA Group %d mute state: %t\n", dca.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.DCA.SetMute(dca.Index.Index, *cmd.State == "true"); err != nil {
+		return fmt.Errorf("failed to set DCA mute status: %w", err)
+	}
+	return nil
+}
+
+// DCANameCmd is the command to get or set the name of a DCA group.
+type DCANameCmd struct {
+	Name *string `arg:"" help:"Set the name of the DCA group." optional:""`
+}
+
+// Run executes the DCANameCmd command.
+func (cmd *DCANameCmd) Run(ctx *context, dca *DCACmdGroup) error {
+	if cmd.Name == nil {
+		resp, err := ctx.Client.DCA.Name(dca.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get DCA name: %w", err)
+		}
+		if resp == "" {
+			resp = fmt.Sprintf("DCA %d", dca.Index.Index)
+		}
+		fmt.Fprintf(ctx.Out, "DCA Group %d is named '%s'\n", dca.Index.Index, resp)
+		return nil
+	}
+	if err := ctx.Client.DCA.SetName(dca.Index.Index, *cmd.Name); err != nil {
+		return fmt.Errorf("failed to set DCA name: %w", err)
+	}
+	return nil
+}

cmd/x32-cli/info.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+type InfoCmd struct {
+}
+
+func (c *InfoCmd) Run(ctx *context) error {
+	fmt.Fprintf(
+		ctx.Out,
+		"Host: %s | Name: %s | Model: %s | Firmware: %s\n",
+		ctx.Client.Info.Host,
+		ctx.Client.Info.Name,
+		ctx.Client.Info.Model,
+		ctx.Client.Info.Firmware,
+	)
+	return nil
+}

cmd/x32-cli/main.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // MainCmdGroup defines the command group for controlling the Main L/R output, including commands for mute state, fader level, and fade-in/fade-out times.
@@ -137,7 +135,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
-		Band int               `arg:"" help:"The EQ band number."`
+		Band *int              `arg:"" help:"The EQ band number." optional:""`
 		Gain MainEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -146,9 +144,13 @@ type MainEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main L/R output.
-func (cmd *MainEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("invalid EQ band number: %d. Valid range is 1-6", cmd.Band.Band)
+func (cmd *MainEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -184,18 +186,18 @@ type MainEqBandGainCmd struct {
 // Run executes the MainEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Main.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -207,18 +209,18 @@ type MainEqBandFreqCmd struct {
 // Run executes the MainEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Main.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -230,18 +232,18 @@ type MainEqBandQCmd struct {
 // Run executes the MainEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Main.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -253,18 +255,18 @@ type MainEqBandTypeCmd struct {
 // Run executes the MainEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Main.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/x32-cli/mainmono.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // MainMonoCmdGroup defines the command group for controlling the Main Mono output, including commands for mute state, fader level, and fade-in/fade-out times.
@@ -137,7 +135,7 @@ func (cmd *MainMonoFadeoutCmd) Run(ctx *context) error {
 type MainMonoEqCmdGroup struct {
 	On   MainMonoEqOnCmd `help:"Get or set the EQ on/off state of the Main Mono output."               cmd:"on"`
 	Band struct {
-		Band int                   `arg:"" help:"The EQ band number."`
+		Band *int                  `arg:"" help:"The EQ band number." optional:""`
 		Gain MainMonoEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainMonoEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainMonoEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -146,9 +144,13 @@ type MainMonoEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main Mono output.
-func (cmd *MainMonoEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("invalid EQ band number: %d. Valid range is 1-6", cmd.Band.Band)
+func (cmd *MainMonoEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -184,18 +186,18 @@ type MainMonoEqBandGainCmd struct {
 // Run executes the MainMonoEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.MainMono.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -207,18 +209,18 @@ type MainMonoEqBandFreqCmd struct {
 // Run executes the MainMonoEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.MainMono.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -230,18 +232,18 @@ type MainMonoEqBandQCmd struct {
 // Run executes the MainMonoEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.MainMono.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -253,18 +255,18 @@ type MainMonoEqBandTypeCmd struct {
 // Run executes the MainMonoEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main Mono output or setting it based on the provided argument.
 func (cmd *MainMonoEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.MainMono.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.MainMono.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main Mono EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main Mono EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main Mono EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.MainMono.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main Mono EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/x32-cli/matrix.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // MatrixCmdGroup defines the command group for controlling the Matrix outputs, including commands for mute state, fader level, and fade-in/fade-out times.
@@ -22,9 +20,9 @@ type MatrixCmdGroup struct {
 	} `help:"Commands for controlling individual Matrix outputs." arg:""`
 }
 
-func (cmd *MatrixCmdGroup) Validate(ctx kong.Context) error {
+func (cmd *MatrixCmdGroup) Validate() error {
 	if cmd.Index.Index < 1 || cmd.Index.Index > 6 {
-		return fmt.Errorf("invalid Matrix output index: %d. Valid range is 1-6", cmd.Index.Index)
+		return fmt.Errorf("Matrix output index must be between 1 and 6, got %d", cmd.Index.Index)
 	}
 	return nil
 }
@@ -147,7 +145,7 @@ func (cmd *MatrixFadeoutCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 type MatrixEqCmdGroup struct {
 	On   MatrixEqOnCmd `help:"Get or set the EQ on/off state of the Matrix output."               cmd:"on"`
 	Band struct {
-		Band int                 `arg:"" help:"The EQ band number."`
+		Band *int                `arg:"" help:"The EQ band number." optional:""`
 		Gain MatrixEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MatrixEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MatrixEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -156,9 +154,13 @@ type MatrixEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Matrix output.
-func (cmd *MatrixEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("invalid EQ band number: %d. Valid range is 1-6", cmd.Band.Band)
+func (cmd *MatrixEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -194,18 +196,18 @@ type MatrixEqBandGainCmd struct {
 // Run executes the MatrixEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandGainCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Matrix.Eq.Gain(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Gain(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d gain: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d gain: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain: %.2f dB\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain: %.2f dB\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetGain(matrix.Index.Index, matrixEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d gain: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetGain(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d gain: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain set to: %.2f dB\n", matrixEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain set to: %.2f dB\n", *matrixEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -217,18 +219,18 @@ type MatrixEqBandFreqCmd struct {
 // Run executes the MatrixEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandFreqCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Matrix.Eq.Frequency(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Frequency(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d frequency: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d frequency: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency: %.2f Hz\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency: %.2f Hz\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetFrequency(matrix.Index.Index, matrixEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d frequency: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetFrequency(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d frequency: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency set to: %.2f Hz\n", matrixEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency set to: %.2f Hz\n", *matrixEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -240,18 +242,18 @@ type MatrixEqBandQCmd struct {
 // Run executes the MatrixEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandQCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Matrix.Eq.Q(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Q(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d Q factor: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d Q factor: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor: %.2f\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor: %.2f\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetQ(matrix.Index.Index, matrixEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d Q factor: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetQ(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d Q factor: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor set to: %.2f\n", matrixEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d Q factor set to: %.2f\n", *matrixEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -263,18 +265,18 @@ type MatrixEqBandTypeCmd struct {
 // Run executes the MatrixEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Matrix output or setting it based on the provided argument.
 func (cmd *MatrixEqBandTypeCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Matrix.Eq.Type(matrix.Index.Index, matrixEq.Band.Band)
+		resp, err := ctx.Client.Matrix.Eq.Type(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Matrix EQ band %d type: %w", matrixEq.Band.Band, err)
+			return fmt.Errorf("failed to get Matrix EQ band %d type: %w", *matrixEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Matrix EQ band %d type: %s\n", matrixEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Matrix EQ band %d type: %s\n", *matrixEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetType(matrix.Index.Index, matrixEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Matrix EQ band %d type: %w", matrixEq.Band.Band, err)
+	if err := ctx.Client.Matrix.Eq.SetType(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Matrix EQ band %d type: %w", *matrixEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ band %d type set to: %s\n", matrixEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d type set to: %s\n", *matrixEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/x32-cli/snapshot.go

@@ -5,7 +5,7 @@ import "fmt"
 type SnapshotCmdGroup struct {
 	List  ListCmd `help:"List all snapshots."        cmd:"list"`
 	Index struct {
-		Index  int       `arg:"" help:"The index of the snapshot."`
+		Index  *int      `arg:"" help:"The index of the snapshot." optional:""`
 		Name   NameCmd   `help:"Get or set the name of a snapshot."      cmd:"name"`
 		Save   SaveCmd   `help:"Save the current mixer state to a snapshot." cmd:"save"`
 		Load   LoadCmd   `help:"Load a mixer state from a snapshot."         cmd:"load"`
@@ -13,6 +13,19 @@ type SnapshotCmdGroup struct {
 	} `help:"The index of the snapshot."            arg:""`
 }
 
+// Validate checks if the provided snapshot index is within the valid range (1-64) when any of the subcommands that require an index are used.
+func (c *SnapshotCmdGroup) Validate() error {
+	if c.Index.Index == nil {
+		return nil
+	}
+
+	if *c.Index.Index < 1 || *c.Index.Index > 64 {
+		return fmt.Errorf("snapshot index must be between 1 and 64")
+	}
+
+	return nil
+}
+
 type ListCmd struct {
 }
 
@@ -36,7 +49,7 @@ type NameCmd struct {
 
 func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	if c.Name == nil {
-		name, err := ctx.Client.Snapshot.Name(snapshot.Index.Index)
+		name, err := ctx.Client.Snapshot.Name(*snapshot.Index.Index)
 		if err != nil {
 			return err
 		}
@@ -44,7 +57,7 @@ func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return nil
 	}
 
-	return ctx.Client.Snapshot.SetName(snapshot.Index.Index, *c.Name)
+	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *c.Name)
 }
 
 type SaveCmd struct {
@@ -57,19 +70,19 @@ func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return err
 	}
 
-	return ctx.Client.Snapshot.CurrentSave(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
 type LoadCmd struct {
 }
 
 func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentLoad(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
 type DeleteCmd struct {
 }
 
 func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentDelete(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)
 }

cmd/x32-cli/strip.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // StripCmdGroup defines the command group for controlling the strips of the mixer, including commands for getting and setting various parameters such as mute state, fader level, send levels, and EQ settings.
@@ -142,27 +140,41 @@ func (cmd *StripFadeoutCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	}
 }
 
-// StripSendCmd defines the command for getting or setting the send level for a specific bus on a strip, allowing users to control the level of the signal being sent from the strip to a particular bus.
+// StripSendCmd defines the command for getting or setting the auxiliary send level
+// for a specific send destination (mix bus) on a strip.
 type StripSendCmd struct {
-	BusNum int      `arg:"" help:"The bus number to get or set the send level for."`
-	Level  *float64 `arg:"" help:"The send level to set (in dB)."                   optional:""`
+	SendIndex int      `arg:"" help:"The index of the send destination (mix bus). (1-based indexing)"`
+	Level     *float64 `arg:"" help:"The send level to set (in dB)."                                  optional:""`
 }
 
-// Run executes the StripSendCmd command, either retrieving the current send level for the specified bus on the strip or setting it based on the provided argument.
+// Run executes the StripSendCmd command, either retrieving the current send level for the specified send destination
+// or setting it based on the provided argument.
 func (cmd *StripSendCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.BusNum)
+		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.SendIndex)
 		if err != nil {
 			return fmt.Errorf("failed to get send level: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d: %.2f dB\n", strip.Index.Index, cmd.BusNum, resp)
+		fmt.Fprintf(
+			ctx.Out,
+			"Strip %d send %d level: %.2f dB\n",
+			strip.Index.Index,
+			cmd.SendIndex,
+			resp,
+		)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.BusNum, *cmd.Level); err != nil {
+	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.SendIndex, *cmd.Level); err != nil {
 		return fmt.Errorf("failed to set send level: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d set to: %.2f dB\n", strip.Index.Index, cmd.BusNum, *cmd.Level)
+	fmt.Fprintf(
+		ctx.Out,
+		"Strip %d send %d level set to: %.2f dB\n",
+		strip.Index.Index,
+		cmd.SendIndex,
+		*cmd.Level,
+	)
 	return nil
 }
 
@@ -365,7 +377,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 type StripEqCmdGroup struct {
 	On   StripEqOnCmd `help:"Get or set the EQ on/off state of the strip."              cmd:""`
 	Band struct {
-		Band int                `arg:"" help:"The EQ band number."`
+		Band *int               `arg:"" help:"The EQ band number." optional:""`
 		Gain StripEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:""`
 		Freq StripEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:""`
 		Q    StripEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:""`
@@ -374,9 +386,13 @@ type StripEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is valid (between 1 and 4) and returns an error if it is not.
-func (cmd *StripEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 4 {
-		return fmt.Errorf("EQ band number must be between 1 and 4")
+func (cmd *StripEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 4 {
+		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -412,18 +428,18 @@ type StripEqBandGainCmd struct {
 // Run executes the StripEqBandGainCmd command, either retrieving the current gain of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band gain: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, stripEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -435,22 +451,22 @@ type StripEqBandFreqCmd struct {
 // Run executes the StripEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band frequency: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, stripEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
 		ctx.Out,
 		"Strip %d EQ band %d frequency set to: %.2f Hz\n",
 		strip.Index.Index,
-		stripEq.Band.Band,
+		*stripEq.Band.Band,
 		*cmd.Freq,
 	)
 	return nil
@@ -464,18 +480,18 @@ type StripEqBandQCmd struct {
 // Run executes the StripEqBandQCmd command, either retrieving the current Q factor of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band Q factor: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, stripEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, *stripEq.Band.Band, *cmd.Q); err != nil {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -487,18 +503,18 @@ type StripEqBandTypeCmd struct {
 // Run executes the StripEqBandTypeCmd command, either retrieving the current type of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band type: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, stripEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, stripEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/xair-cli/bus.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // BusCmdGroup defines the commands related to controlling the buses of the X-Air device.
@@ -174,7 +172,7 @@ type BusEqCmdGroup struct {
 	On   BusEqOnCmd   `help:"Get or set the EQ on/off state of the bus."              cmd:"on"`
 	Mode BusEqModeCmd `help:"Get or set the EQ mode of the bus (peq, geq or teq)."    cmd:"mode"`
 	Band struct {
-		Band int              `arg:"" help:"The EQ band number."`
+		Band *int             `arg:"" help:"The EQ band number." optional:""`
 		Gain BusEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:"gain"`
 		Freq BusEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:"freq"`
 		Q    BusEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:"q"`
@@ -183,9 +181,13 @@ type BusEqCmdGroup struct {
 }
 
 // Validate checks that the provided EQ band number is within the valid range (1-6).
-func (cmd *BusEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("EQ band number must be between 1 and 6")
+func (cmd *BusEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -244,7 +246,7 @@ type BusEqBandGainCmd struct {
 // Run executes the BusEqBandGainCmd command, either retrieving the current gain of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
@@ -252,10 +254,10 @@ func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, busEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, *busEq.Band.Band, *cmd.Gain); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, busEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -267,18 +269,18 @@ type BusEqBandFreqCmd struct {
 // Run executes the BusEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, busEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, *cmd.Freq)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
 	return nil
 }
 
@@ -290,18 +292,18 @@ type BusEqBandQCmd struct {
 // Run executes the BusEqBandQCmd command, either retrieving the current Q factor of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, busEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, *busEq.Band.Band, *cmd.Q); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, busEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -313,18 +315,18 @@ type BusEqBandTypeCmd struct {
 // Run executes the BusEqBandTypeCmd command, either retrieving the current type of the specified EQ band of the bus or setting it based on the provided argument.
 func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, busEq.Band.Band)
+		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, *busEq.Band.Band)
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, busEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, busEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, *busEq.Band.Band, *cmd.Type); err != nil {
 		return err
 	}
-	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, busEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/xair-cli/cli.go

@@ -46,14 +46,16 @@ type CLI struct {
 
 	Version VersionFlag `help:"Print xair-cli version information and quit" name:"version" short:"v"`
 
-	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts."  cmd:""`
+	Info       InfoCmd                   `help:"Print mixer information."            cmd:""`
+	Raw        RawCmd                    `help:"Send raw OSC messages to the mixer." cmd:""`
 
-	Raw      RawCmd           `help:"Send raw OSC messages to the mixer."   cmd:"" group:"Raw"`
 	Main     MainCmdGroup     `help:"Control the Main L/R output"           cmd:"" group:"Main"`
 	Strip    StripCmdGroup    `help:"Control the strips."                   cmd:"" group:"Strip"`
 	Bus      BusCmdGroup      `help:"Control the buses."                    cmd:"" group:"Bus"`
 	Headamp  HeadampCmdGroup  `help:"Control input gain and phantom power." cmd:"" group:"Headamp"`
 	Snapshot SnapshotCmdGroup `help:"Save and load mixer states."           cmd:"" group:"Snapshot"`
+	Dca      DCACmdGroup      `help:"Control DCA groups."                   cmd:"" group:"DCA"`
 }
 
 func main() {

cmd/xair-cli/dca.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+)
+
+// DCACmdGroup is the command group for controlling DCA groups.
+type DCACmdGroup struct {
+	Index struct {
+		Index int        `arg:"" help:"The index of the DCA group (1-4)."`
+		Mute  DCAMuteCmd `help:"Get or set the mute status of the DCA group." cmd:""`
+		Name  DCANameCmd `help:"Get or set the name of the DCA group." cmd:""`
+	} `arg:"" help:"Control a specific DCA group by its index."`
+}
+
+// Validate checks if the provided index is within the valid range.
+func (cmd *DCACmdGroup) Validate() error {
+	if cmd.Index.Index < 1 || cmd.Index.Index > 4 {
+		return fmt.Errorf("DCA group index must be between 1 and 4, got %d", cmd.Index.Index)
+	}
+	return nil
+}
+
+// DCAMuteCmd is the command to get or set the mute status of a DCA group.
+type DCAMuteCmd struct {
+	State *string `arg:"" help:"Set the mute status of the DCA group." optional:"" enum:"true,false"`
+}
+
+// Run executes the DCAMuteCmd command.
+func (cmd *DCAMuteCmd) Run(ctx *context, dca *DCACmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.DCA.Mute(dca.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get DCA mute status: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "DCA Group %d mute state: %t\n", dca.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.DCA.SetMute(dca.Index.Index, *cmd.State == "true"); err != nil {
+		return fmt.Errorf("failed to set DCA mute status: %w", err)
+	}
+	return nil
+}
+
+// DCANameCmd is the command to get or set the name of a DCA group.
+type DCANameCmd struct {
+	Name *string `arg:"" help:"Set the name of the DCA group." optional:""`
+}
+
+// Run executes the DCANameCmd command.
+func (cmd *DCANameCmd) Run(ctx *context, dca *DCACmdGroup) error {
+	if cmd.Name == nil {
+		resp, err := ctx.Client.DCA.Name(dca.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get DCA name: %w", err)
+		}
+		if resp == "" {
+			resp = fmt.Sprintf("DCA %d", dca.Index.Index)
+		}
+		fmt.Fprintf(ctx.Out, "DCA Group %d is named '%s'\n", dca.Index.Index, resp)
+		return nil
+	}
+	if err := ctx.Client.DCA.SetName(dca.Index.Index, *cmd.Name); err != nil {
+		return fmt.Errorf("failed to set DCA name: %w", err)
+	}
+	return nil
+}

cmd/xair-cli/info.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+type InfoCmd struct {
+}
+
+func (c *InfoCmd) Run(ctx *context) error {
+	fmt.Fprintf(
+		ctx.Out,
+		"Host: %s | Name: %s | Model: %s | Firmware: %s\n",
+		ctx.Client.Info.Host,
+		ctx.Client.Info.Name,
+		ctx.Client.Info.Model,
+		ctx.Client.Info.Firmware,
+	)
+	return nil
+}

cmd/xair-cli/main.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // MainCmdGroup defines the command group for controlling the Main L/R output, including commands for mute state, fader level, and fade-in/fade-out times.
@@ -137,7 +135,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
-		Band int               `arg:"" help:"The EQ band number."`
+		Band *int              `arg:"" help:"The EQ band number." optional:""`
 		Gain MainEqBandGainCmd `help:"Get or set the gain of the specified EQ band." cmd:"gain"`
 		Freq MainEqBandFreqCmd `help:"Get or set the frequency of the specified EQ band." cmd:"freq"`
 		Q    MainEqBandQCmd    `help:"Get or set the Q factor of the specified EQ band." cmd:"q"`
@@ -146,9 +144,13 @@ type MainEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is within the valid range (1-6) for the Main L/R output.
-func (cmd *MainEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
-		return fmt.Errorf("invalid EQ band number: %d. Valid range is 1-6", cmd.Band.Band)
+func (cmd *MainEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -184,18 +186,18 @@ type MainEqBandGainCmd struct {
 // Run executes the MainEqBandGainCmd command, either retrieving the current gain of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Main.Eq.Gain(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain: %.2f dB\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetGain(0, mainEq.Band.Band, *cmd.Level); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetGain(0, *mainEq.Band.Band, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d gain: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", mainEq.Band.Band, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
 	return nil
 }
 
@@ -207,18 +209,18 @@ type MainEqBandFreqCmd struct {
 // Run executes the MainEqBandFreqCmd command, either retrieving the current frequency of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Frequency == nil {
-		resp, err := ctx.Client.Main.Eq.Frequency(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency: %.2f Hz\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetFrequency(0, mainEq.Band.Band, *cmd.Frequency); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", mainEq.Band.Band, *cmd.Frequency)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
 	return nil
 }
 
@@ -230,18 +232,18 @@ type MainEqBandQCmd struct {
 // Run executes the MainEqBandQCmd command, either retrieving the current Q factor of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Main.Eq.Q(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor: %.2f\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetQ(0, mainEq.Band.Band, *cmd.Q); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetQ(0, *mainEq.Band.Band, *cmd.Q); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", mainEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d Q factor set to: %.2f\n", *mainEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -253,18 +255,18 @@ type MainEqBandTypeCmd struct {
 // Run executes the MainEqBandTypeCmd command, either retrieving the current type of a specific EQ band on the Main L/R output or setting it based on the provided argument.
 func (cmd *MainEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Main.Eq.Type(0, mainEq.Band.Band)
+		resp, err := ctx.Client.Main.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+			return fmt.Errorf("failed to get Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 		}
-		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", mainEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type: %s\n", *mainEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetType(0, mainEq.Band.Band, *cmd.Type); err != nil {
-		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", mainEq.Band.Band, err)
+	if err := ctx.Client.Main.Eq.SetType(0, *mainEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set Main L/R EQ band %d type: %w", *mainEq.Band.Band, err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", mainEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d type set to: %s\n", *mainEq.Band.Band, *cmd.Type)
 	return nil
 }
 

cmd/xair-cli/snapshot.go

@@ -5,7 +5,7 @@ import "fmt"
 type SnapshotCmdGroup struct {
 	List  ListCmd `help:"List all snapshots."        cmd:"list"`
 	Index struct {
-		Index  int       `arg:"" help:"The index of the snapshot."`
+		Index  *int      `arg:"" help:"The index of the snapshot." optional:""`
 		Name   NameCmd   `help:"Get or set the name of a snapshot."      cmd:"name"`
 		Save   SaveCmd   `help:"Save the current mixer state to a snapshot." cmd:"save"`
 		Load   LoadCmd   `help:"Load a mixer state from a snapshot."         cmd:"load"`
@@ -13,6 +13,19 @@ type SnapshotCmdGroup struct {
 	} `help:"The index of the snapshot."            arg:""`
 }
 
+// Validate checks if the provided snapshot index is within the valid range (1-64) when any of the subcommands that require an index are used.
+func (c *SnapshotCmdGroup) Validate() error {
+	if c.Index.Index == nil {
+		return nil
+	}
+
+	if *c.Index.Index < 1 || *c.Index.Index > 64 {
+		return fmt.Errorf("snapshot index must be between 1 and 64")
+	}
+
+	return nil
+}
+
 type ListCmd struct {
 }
 
@@ -36,7 +49,7 @@ type NameCmd struct {
 
 func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	if c.Name == nil {
-		name, err := ctx.Client.Snapshot.Name(snapshot.Index.Index)
+		name, err := ctx.Client.Snapshot.Name(*snapshot.Index.Index)
 		if err != nil {
 			return err
 		}
@@ -44,7 +57,7 @@ func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return nil
 	}
 
-	return ctx.Client.Snapshot.SetName(snapshot.Index.Index, *c.Name)
+	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *c.Name)
 }
 
 type SaveCmd struct {
@@ -57,19 +70,19 @@ func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return err
 	}
 
-	return ctx.Client.Snapshot.CurrentSave(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
 type LoadCmd struct {
 }
 
 func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentLoad(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
 type DeleteCmd struct {
 }
 
 func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	return ctx.Client.Snapshot.CurrentDelete(snapshot.Index.Index)
+	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)
 }

cmd/xair-cli/strip.go

@@ -3,8 +3,6 @@ package main
 import (
 	"fmt"
 	"time"
-
-	"github.com/alecthomas/kong"
 )
 
 // StripCmdGroup defines the command group for controlling the strips of the mixer, including commands for getting and setting various parameters such as mute state, fader level, send levels, and EQ settings.
@@ -142,27 +140,29 @@ func (cmd *StripFadeoutCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	}
 }
 
-// StripSendCmd defines the command for getting or setting the send level for a specific bus on a strip, allowing users to control the level of the signal being sent from the strip to a particular bus.
+// StripSendCmd defines the command for getting or setting the auxiliary send level
+// for a specific send destination (mix bus or effects channel) on a strip.
 type StripSendCmd struct {
-	BusNum int      `arg:"" help:"The bus number to get or set the send level for."`
-	Level  *float64 `arg:"" help:"The send level to set (in dB)."                   optional:""`
+	SendIndex int      `arg:"" help:"The index of the send destination (mix bus or effects channel). (1-based indexing)"`
+	Level     *float64 `arg:"" help:"The send level to set (in dB)."                                                     optional:""`
 }
 
-// Run executes the StripSendCmd command, either retrieving the current send level for the specified bus on the strip or setting it based on the provided argument.
+// Run executes the StripSendCmd command, either retrieving the current send level for the specified destination
+// or setting it based on the provided argument.
 func (cmd *StripSendCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if cmd.Level == nil {
-		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.BusNum)
+		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.SendIndex)
 		if err != nil {
 			return fmt.Errorf("failed to get send level: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d: %.2f dB\n", strip.Index.Index, cmd.BusNum, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d send %d level: %.2f dB\n", strip.Index.Index, cmd.SendIndex, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.BusNum, *cmd.Level); err != nil {
+	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.SendIndex, *cmd.Level); err != nil {
 		return fmt.Errorf("failed to set send level: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d set to: %.2f dB\n", strip.Index.Index, cmd.BusNum, *cmd.Level)
+	fmt.Fprintf(ctx.Out, "Strip %d send %d level set to: %.2f dB\n", strip.Index.Index, cmd.SendIndex, *cmd.Level)
 	return nil
 }
 
@@ -365,7 +365,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 type StripEqCmdGroup struct {
 	On   StripEqOnCmd `help:"Get or set the EQ on/off state of the strip."              cmd:""`
 	Band struct {
-		Band int                `arg:"" help:"The EQ band number."`
+		Band *int               `arg:"" help:"The EQ band number." optional:""`
 		Gain StripEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:""`
 		Freq StripEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:""`
 		Q    StripEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:""`
@@ -374,9 +374,13 @@ type StripEqCmdGroup struct {
 }
 
 // Validate checks if the provided EQ band number is valid (between 1 and 4) and returns an error if it is not.
-func (cmd *StripEqCmdGroup) Validate(ctx kong.Context) error {
-	if cmd.Band.Band < 1 || cmd.Band.Band > 4 {
-		return fmt.Errorf("EQ band number must be between 1 and 4")
+func (cmd *StripEqCmdGroup) Validate() error {
+	if cmd.Band.Band == nil {
+		return nil
+	}
+
+	if *cmd.Band.Band < 1 || *cmd.Band.Band > 4 {
+		return fmt.Errorf("EQ band number must be between 1 and 4, got %d", *cmd.Band.Band)
 	}
 	return nil
 }
@@ -412,18 +416,18 @@ type StripEqBandGainCmd struct {
 // Run executes the StripEqBandGainCmd command, either retrieving the current gain of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Gain == nil {
-		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band gain: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, stripEq.Band.Band, *cmd.Gain); err != nil {
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Gain)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
 	return nil
 }
 
@@ -435,22 +439,22 @@ type StripEqBandFreqCmd struct {
 // Run executes the StripEqBandFreqCmd command, either retrieving the current frequency of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Freq == nil {
-		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band frequency: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, stripEq.Band.Band, *cmd.Freq); err != nil {
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
 		ctx.Out,
 		"Strip %d EQ band %d frequency set to: %.2f Hz\n",
 		strip.Index.Index,
-		stripEq.Band.Band,
+		*stripEq.Band.Band,
 		*cmd.Freq,
 	)
 	return nil
@@ -464,18 +468,18 @@ type StripEqBandQCmd struct {
 // Run executes the StripEqBandQCmd command, either retrieving the current Q factor of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Q == nil {
-		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band Q factor: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, stripEq.Band.Band, *cmd.Q); err != nil {
+	if err := ctx.Client.Strip.Eq.SetQ(strip.Index.Index, *stripEq.Band.Band, *cmd.Q); err != nil {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Q)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
 	return nil
 }
 
@@ -487,18 +491,18 @@ type StripEqBandTypeCmd struct {
 // Run executes the StripEqBandTypeCmd command, either retrieving the current type of the specified EQ band on the strip or setting it based on the provided argument.
 func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
 	if cmd.Type == nil {
-		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, stripEq.Band.Band)
+		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, *stripEq.Band.Band)
 		if err != nil {
 			return fmt.Errorf("failed to get EQ band type: %w", err)
 		}
-		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, stripEq.Band.Band, resp)
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, stripEq.Band.Band, *cmd.Type); err != nil {
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, stripEq.Band.Band, *cmd.Type)
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
 	return nil
 }
 

go.mod

@@ -3,7 +3,7 @@ module github.com/onyx-and-iris/xair-cli
 go 1.25
 
 require (
-	github.com/alecthomas/kong v1.13.0
+	github.com/alecthomas/kong v1.14.0
 	github.com/charmbracelet/log v0.4.2
 	github.com/hypebeast/go-osc v0.0.0-20220308234300-cec5a8a1e5f5
 	github.com/jotaen/kong-completion v0.0.11
@@ -13,12 +13,12 @@ require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/lipgloss v1.1.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.4 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect
+	github.com/charmbracelet/x/ansi v0.11.6 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect
 	github.com/clipperhouse/displaywidth v0.9.0 // indirect
 	github.com/clipperhouse/stringish v0.1.1 // indirect
-	github.com/clipperhouse/uax29/v2 v2.5.0 // indirect
+	github.com/clipperhouse/uax29/v2 v2.6.0 // indirect
 	github.com/go-logfmt/logfmt v0.6.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
@@ -31,5 +31,5 @@ require (
 	github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // indirect
-	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
 )

go.sum

@@ -1,7 +1,7 @@
 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.13.0 h1:5e/7XC3ugvhP1DQBmTS+WuHtCbcv44hsohMgcvVxSrA=
-github.com/alecthomas/kong v1.13.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
+github.com/alecthomas/kong v1.14.0 h1:gFgEUZWu2ZmZ+UhyZ1bDhuutbKN1nTtJTwh19Wsn21s=
+github.com/alecthomas/kong v1.14.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
 github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
 github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
@@ -12,18 +12,18 @@ github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoF
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
-github.com/charmbracelet/x/ansi v0.11.4 h1:6G65PLu6HjmE858CnTUQY1LXT3ZUWwfvqEROLF8vqHI=
-github.com/charmbracelet/x/ansi v0.11.4/go.mod h1:/5AZ+UfWExW3int5H5ugnsG/PWjNcSQcwYsHBlPFQN4=
-github.com/charmbracelet/x/cellbuf v0.0.14 h1:iUEMryGyFTelKW3THW4+FfPgi4fkmKnnaLOXuc+/Kj4=
-github.com/charmbracelet/x/cellbuf v0.0.14/go.mod h1:P447lJl49ywBbil/KjCk2HexGh4tEY9LH0/1QrZZ9rA=
+github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
+github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
+github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
+github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
 github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
 github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
 github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=
 github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=
 github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
 github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
-github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U=
-github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
+github.com/clipperhouse/uax29/v2 v2.6.0 h1:z0cDbUV+aPASdFb2/ndFnS9ts/WNXgTNNGFoKXuhpos=
+github.com/clipperhouse/uax29/v2 v2.6.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 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=
@@ -68,8 +68,8 @@ github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJu
 golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
 golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
-golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 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=

internal/xair/address.go

@@ -3,9 +3,10 @@ package xair
 var xairAddressMap = map[string]string{
 	"main":     "/lr",
 	"strip":    "/ch/%02d",
-	"bus":      "/bus/%01d",
+	"bus":      "/bus/%d",
 	"headamp":  "/headamp/%02d",
 	"snapshot": "/-snap",
+	"dca":      "/dca/%d",
 }
 
 var x32AddressMap = map[string]string{
@@ -16,6 +17,7 @@ var x32AddressMap = map[string]string{
 	"bus":      "/bus/%02d",
 	"headamp":  "/headamp/%03d",
 	"snapshot": "/-snap",
+	"dca":      "/dca/%d",
 }
 
 func addressMapFromMixerKind(kind mixerKind) map[string]string {

internal/xair/bus.go

@@ -3,14 +3,14 @@ package xair
 import "fmt"
 
 type Bus struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
 // newBus creates a new Bus instance
-func newBus(c *Client) *Bus {
+func newBus(c *client) *Bus {
 	return &Bus{
 		client:      c,
 		baseAddress: c.addressMap["bus"],

internal/xair/client.go

@@ -9,51 +9,15 @@ import (
 	"github.com/hypebeast/go-osc/osc"
 )
 
-type Client struct {
-	*engine
-}
-
 // XAirClient is a client for controlling XAir mixers
 type XAirClient struct {
-	Client
+	client
 	Main     *Main
 	Strip    *Strip
 	Bus      *Bus
 	HeadAmp  *HeadAmp
 	Snapshot *Snapshot
-}
-
-// X32Client is a client for controlling X32 mixers
-type X32Client struct {
-	Client
-	Main     *Main
-	MainMono *Main
-	Matrix   *Matrix
-	Strip    *Strip
-	Bus      *Bus
-	HeadAmp  *HeadAmp
-	Snapshot *Snapshot
-}
-
-// NewX32Client creates a new X32Client instance with optional engine configuration
-func NewX32Client(mixerIP string, mixerPort int, opts ...EngineOption) (*X32Client, error) {
-	e, err := newEngine(mixerIP, mixerPort, kindX32, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	c := &X32Client{
-		Client: Client{e},
-	}
-	c.Main = newMainStereo(&c.Client)
-	c.MainMono = newMainMono(&c.Client)
-	c.Matrix = newMatrix(&c.Client)
-	c.Strip = newStrip(&c.Client)
-	c.Bus = newBus(&c.Client)
-	c.HeadAmp = newHeadAmp(&c.Client)
-	c.Snapshot = newSnapshot(&c.Client)
-
-	return c, nil
+	DCA      *DCA
 }
 
 // NewXAirClient creates a new XAirClient instance with optional engine configuration
@@ -64,25 +28,66 @@ func NewXAirClient(mixerIP string, mixerPort int, opts ...EngineOption) (*XAirCl
 	}
 
 	c := &XAirClient{
-		Client: Client{e},
+		client: client{e, InfoResponse{}},
 	}
-	c.Main = newMainStereo(&c.Client)
-	c.Strip = newStrip(&c.Client)
-	c.Bus = newBus(&c.Client)
-	c.HeadAmp = newHeadAmp(&c.Client)
-	c.Snapshot = newSnapshot(&c.Client)
+	c.Main = newMainStereo(&c.client)
+	c.Strip = newStrip(&c.client)
+	c.Bus = newBus(&c.client)
+	c.HeadAmp = newHeadAmp(&c.client)
+	c.Snapshot = newSnapshot(&c.client)
+	c.DCA = newDCA(&c.client)
 
 	return c, nil
 }
 
+// X32Client is a client for controlling X32 mixers
+type X32Client struct {
+	client
+	Main     *Main
+	MainMono *Main
+	Matrix   *Matrix
+	Strip    *Strip
+	Bus      *Bus
+	HeadAmp  *HeadAmp
+	Snapshot *Snapshot
+	DCA      *DCA
+}
+
+// NewX32Client creates a new X32Client instance with optional engine configuration
+func NewX32Client(mixerIP string, mixerPort int, opts ...EngineOption) (*X32Client, error) {
+	e, err := newEngine(mixerIP, mixerPort, kindX32, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &X32Client{
+		client: client{e, InfoResponse{}},
+	}
+	c.Main = newMainStereo(&c.client)
+	c.MainMono = newMainMono(&c.client)
+	c.Matrix = newMatrix(&c.client)
+	c.Strip = newStrip(&c.client)
+	c.Bus = newBus(&c.client)
+	c.HeadAmp = newHeadAmp(&c.client)
+	c.Snapshot = newSnapshot(&c.client)
+	c.DCA = newDCA(&c.client)
+
+	return c, nil
+}
+
+type client struct {
+	*engine
+	Info InfoResponse
+}
+
 // Start begins listening for messages in a goroutine
-func (c *Client) StartListening() {
+func (c *client) StartListening() {
 	go c.engine.receiveLoop()
 	log.Debugf("Started listening on %s...", c.engine.conn.LocalAddr().String())
 }
 
 // Close stops the client and closes the connection
-func (c *Client) Close() {
+func (c *client) Close() {
 	close(c.engine.done)
 	if c.engine.conn != nil {
 		c.engine.conn.Close()
@@ -90,12 +95,12 @@ func (c *Client) Close() {
 }
 
 // SendMessage sends an OSC message to the mixer using the unified connection
-func (c *Client) SendMessage(address string, args ...any) error {
+func (c *client) SendMessage(address string, args ...any) error {
 	return c.engine.sendToAddress(c.mixerAddr, address, args...)
 }
 
 // ReceiveMessage receives an OSC message from the mixer
-func (c *Client) ReceiveMessage() (*osc.Message, error) {
+func (c *client) ReceiveMessage() (*osc.Message, error) {
 	t := time.Tick(c.engine.timeout)
 	select {
 	case <-t:
@@ -109,7 +114,7 @@ func (c *Client) ReceiveMessage() (*osc.Message, error) {
 }
 
 // RequestInfo requests mixer information
-func (c *Client) RequestInfo() (InfoResponse, error) {
+func (c *client) RequestInfo() (InfoResponse, error) {
 	var info InfoResponse
 	err := c.SendMessage("/xinfo")
 	if err != nil {
@@ -120,20 +125,31 @@ func (c *Client) RequestInfo() (InfoResponse, error) {
 	if err != nil {
 		return info, err
 	}
-	if len(msg.Arguments) >= 3 {
-		info.Host = msg.Arguments[0].(string)
-		info.Name = msg.Arguments[1].(string)
-		info.Model = msg.Arguments[2].(string)
+	if len(msg.Arguments) == 4 {
+		if host, ok := msg.Arguments[0].(string); ok {
+			info.Host = host
+		}
+		if name, ok := msg.Arguments[1].(string); ok {
+			info.Name = name
+		}
+		if model, ok := msg.Arguments[2].(string); ok {
+			info.Model = model
+		}
+		if firmware, ok := msg.Arguments[3].(string); ok {
+			info.Firmware = firmware
+		}
 	}
+	c.Info = info
+
 	return info, nil
 }
 
 // KeepAlive sends keep-alive message (required for multi-client usage)
-func (c *Client) KeepAlive() error {
+func (c *client) KeepAlive() error {
 	return c.SendMessage("/xremote")
 }
 
 // RequestStatus requests mixer status
-func (c *Client) RequestStatus() error {
+func (c *client) RequestStatus() error {
 	return c.SendMessage("/status")
 }

internal/xair/comp.go

@@ -4,13 +4,13 @@ import "fmt"
 
 // Comp represents the compressor parameters.
 type Comp struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	AddressFunc func(fmtString string, args ...any) string
 }
 
 // Factory function to create Comp instance with optional configuration
-func newComp(c *Client, baseAddress string, opts ...CompOption) *Comp {
+func newComp(c *client, baseAddress string, opts ...CompOption) *Comp {
 	comp := &Comp{
 		client:      c,
 		baseAddress: fmt.Sprintf("%s/dyn", baseAddress),

internal/xair/dca.go

@@ -0,0 +1,95 @@
+package xair
+
+import "fmt"
+
+type DCA struct {
+	client      *client
+	baseAddress string
+}
+
+// newDCA creates a new DCA instance
+func newDCA(c *client) *DCA {
+	return &DCA{
+		client:      c,
+		baseAddress: c.addressMap["dca"],
+	}
+}
+
+// Mute requests the current mute status for a DCA group
+func (d *DCA) Mute(group int) (bool, error) {
+	address := fmt.Sprintf(d.baseAddress, group) + "/on"
+	err := d.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	msg, err := d.client.ReceiveMessage()
+	if err != nil {
+		return false, err
+	}
+	val, ok := msg.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for DCA mute value")
+	}
+	return val == 0, nil
+}
+
+// SetMute sets the mute status for a specific DCA group (1-based indexing)
+func (d *DCA) SetMute(group int, muted bool) error {
+	address := fmt.Sprintf(d.baseAddress, group) + "/on"
+	var value int32
+	if !muted {
+		value = 1
+	}
+	return d.client.SendMessage(address, value)
+}
+
+// Name requests the current name for a DCA group
+func (d *DCA) Name(group int) (string, error) {
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/name"
+	err := d.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	msg, err := d.client.ReceiveMessage()
+	if err != nil {
+		return "", err
+	}
+	name, ok := msg.Arguments[0].(string)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for DCA name value")
+	}
+	return name, nil
+}
+
+// SetName sets the name for a specific DCA group (1-based indexing)
+func (d *DCA) SetName(group int, name string) error {
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/name"
+	return d.client.SendMessage(address, name)
+}
+
+// Color requests the current color for a DCA group
+func (d *DCA) Color(group int) (int32, error) {
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/color"
+	err := d.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	msg, err := d.client.ReceiveMessage()
+	if err != nil {
+		return 0, err
+	}
+	color, ok := msg.Arguments[0].(int32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for DCA color value")
+	}
+	return color, nil
+}
+
+// SetColor sets the color for a specific DCA group (1-based indexing)
+func (d *DCA) SetColor(group int, color int32) error {
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/color"
+	return d.client.SendMessage(address, color)
+}

internal/xair/eq.go

@@ -6,13 +6,13 @@ import (
 
 // Eq represents the EQ parameters.
 type Eq struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	AddressFunc func(fmtString string, args ...any) string
 }
 
 // Factory function to create Eq instance with optional configuration
-func newEq(c *Client, baseAddress string, opts ...EqOption) *Eq {
+func newEq(c *client, baseAddress string, opts ...EqOption) *Eq {
 	eq := &Eq{
 		client:      c,
 		baseAddress: fmt.Sprintf("%s/eq", baseAddress),

internal/xair/gate.go

@@ -4,13 +4,13 @@ import "fmt"
 
 // Gate represents the gate parameters.
 type Gate struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	AddressFunc func(fmtString string, args ...any) string
 }
 
 // Factory function to create Gate instance with optional configuration
-func newGate(c *Client, baseAddress string, opts ...GateOption) *Gate {
+func newGate(c *client, baseAddress string, opts ...GateOption) *Gate {
 	gate := &Gate{
 		client:      c,
 		baseAddress: fmt.Sprintf("%s/gate", baseAddress),

internal/xair/headamp.go

@@ -3,12 +3,12 @@ package xair
 import "fmt"
 
 type HeadAmp struct {
-	client      *Client
+	client      *client
 	baseAddress string
 }
 
 // newHeadAmp creates a new HeadAmp instance with the provided client.
-func newHeadAmp(c *Client) *HeadAmp {
+func newHeadAmp(c *client) *HeadAmp {
 	return &HeadAmp{
 		client:      c,
 		baseAddress: c.addressMap["headamp"],

internal/xair/main.go

@@ -3,14 +3,14 @@ package xair
 import "fmt"
 
 type Main struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
 // newMainStereo creates a new Main instance for stereo main output
-func newMainStereo(c *Client) *Main {
+func newMainStereo(c *client) *Main {
 	addressFunc := func(fmtString string, args ...any) string {
 		return fmtString
 	}
@@ -24,7 +24,7 @@ func newMainStereo(c *Client) *Main {
 }
 
 // newMainMono creates a new MainMono instance for mono main output (X32 only)
-func newMainMono(c *Client) *Main {
+func newMainMono(c *client) *Main {
 	addressFunc := func(fmtString string, args ...any) string {
 		return fmtString
 	}

internal/xair/matrix.go

@@ -3,14 +3,14 @@ package xair
 import "fmt"
 
 type Matrix struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
 // newMatrix creates a new Matrix instance
-func newMatrix(c *Client) *Matrix {
+func newMatrix(c *client) *Matrix {
 	return &Matrix{
 		client:      c,
 		baseAddress: c.addressMap["matrix"],

internal/xair/models.go

@@ -1,7 +1,8 @@
 package xair
 
 type InfoResponse struct {
-	Host  string
-	Name  string
-	Model string
+	Host     string
+	Name     string
+	Model    string
+	Firmware string
 }

internal/xair/snapshot.go

@@ -3,12 +3,12 @@ package xair
 import "fmt"
 
 type Snapshot struct {
-	client      *Client
+	client      *client
 	baseAddress string
 }
 
 // newSnapshot creates a new Snapshot instance
-func newSnapshot(c *Client) *Snapshot {
+func newSnapshot(c *client) *Snapshot {
 	return &Snapshot{
 		client:      c,
 		baseAddress: c.addressMap["snapshot"],

internal/xair/strip.go

@@ -3,7 +3,7 @@ package xair
 import "fmt"
 
 type Strip struct {
-	client      *Client
+	client      *client
 	baseAddress string
 	Gate        *Gate
 	Eq          *Eq
@@ -11,7 +11,7 @@ type Strip struct {
 }
 
 // newStrip creates a new Strip instance
-func newStrip(c *Client) *Strip {
+func newStrip(c *client) *Strip {
 	return &Strip{
 		client:      c,
 		baseAddress: c.addressMap["strip"],
@@ -126,7 +126,7 @@ func (s *Strip) SetColor(strip int, color int32) error {
 	return s.client.SendMessage(address, color)
 }
 
-// Sends requests the sends level for a mixbus.
+// SendLevel requests auxiliary send level for a send destination.
 func (s *Strip) SendLevel(strip int, bus int) (float64, error) {
 	address := fmt.Sprintf(s.baseAddress, strip) + fmt.Sprintf("/mix/%02d/level", bus)
 	err := s.client.SendMessage(address)
@@ -145,7 +145,7 @@ func (s *Strip) SendLevel(strip int, bus int) (float64, error) {
 	return mustDbFrom(float64(val)), nil
 }
 
-// SetSendLevel sets the sends level for a mixbus.
+// SetSendLevel sets the auxiliary send level for a send destination.
 func (s *Strip) SetSendLevel(strip int, bus int, level float64) error {
 	address := fmt.Sprintf(s.baseAddress, strip) + fmt.Sprintf("/mix/%02d/level", bus)
 	return s.client.SendMessage(address, float32(mustDbInto(level)))

x32-help.md

@@ -0,0 +1,197 @@
+```console
+Usage: x32-cli <command> [flags]
+
+A CLI to control Behringer X32 mixers.
+
+Flags:
+  -h, --help                  Show context-sensitive help.
+  -H, --host="mixer.local"    The host of the X32 device ($X32_CLI_HOST).
+  -P, --port=10023            The port of the X32 device ($X32_CLI_PORT).
+  -T, --timeout=100ms         Timeout for OSC operations ($X32_CLI_TIMEOUT).
+  -L, --loglevel="warn"       Log level for the CLI ($X32_CLI_LOGLEVEL).
+  -v, --version               Print x32-cli version information and quit
+
+Commands:
+  completion    Generate shell completion scripts.
+  info          Print mixer information.
+  raw           Send raw OSC messages to the mixer.
+
+Main
+  main mute              Get or set the mute state of the Main L/R output.
+  main fader             Get or set the fader level of the Main L/R output.
+  main fadein            Fade in the Main L/R output over a specified duration.
+  main fadeout           Fade out the Main L/R output over a specified duration.
+  main eq on             Get or set the EQ on/off state of the Main L/R output.
+  main eq <band> gain    Get or set the gain of the specified EQ band.
+  main eq <band> freq    Get or set the frequency of the specified EQ band.
+  main eq <band> q       Get or set the Q factor of the specified EQ band.
+  main eq <band> type    Get or set the type of the specified EQ band.
+  main comp on           Get or set the compressor on/off state of the Main L/R
+                         output.
+  main comp mode         Get or set the compressor mode of the Main L/R output.
+  main comp threshold    Get or set the compressor threshold of the Main L/R
+                         output.
+  main comp ratio        Get or set the compressor ratio of the Main L/R output.
+  main comp mix          Get or set the compressor mix level of the Main L/R
+                         output.
+  main comp makeup       Get or set the compressor makeup gain of the Main L/R
+                         output.
+  main comp attack       Get or set the compressor attack time of the Main L/R
+                         output.
+  main comp hold         Get or set the compressor hold time of the Main L/R
+                         output.
+  main comp release      Get or set the compressor release time of the Main L/R
+                         output.
+
+MainMono
+  mainmono mute              Get or set the mute state of the Main Mono output.
+  mainmono fader             Get or set the fader level of the Main Mono output.
+  mainmono fadein            Fade in the Main Mono output over a specified
+                             duration.
+  mainmono fadeout           Fade out the Main Mono output over a specified
+                             duration.
+  mainmono eq on             Get or set the EQ on/off state of the Main Mono
+                             output.
+  mainmono eq <band> gain    Get or set the gain of the specified EQ band.
+  mainmono eq <band> freq    Get or set the frequency of the specified EQ band.
+  mainmono eq <band> q       Get or set the Q factor of the specified EQ band.
+  mainmono eq <band> type    Get or set the type of the specified EQ band.
+  mainmono comp on           Get or set the compressor on/off state of the Main
+                             Mono output.
+  mainmono comp mode         Get or set the compressor mode of the Main Mono
+                             output.
+  mainmono comp threshold    Get or set the compressor threshold of the Main
+                             Mono output.
+  mainmono comp ratio        Get or set the compressor ratio of the Main Mono
+                             output.
+  mainmono comp mix          Get or set the compressor mix level of the Main
+                             Mono output.
+  mainmono comp makeup       Get or set the compressor makeup gain of the Main
+                             Mono output.
+  mainmono comp attack       Get or set the compressor attack time of the Main
+                             Mono output.
+  mainmono comp hold         Get or set the compressor hold time of the Main
+                             Mono output.
+  mainmono comp release      Get or set the compressor release time of the Main
+                             Mono output.
+
+Matrix
+  matrix <index> mute              Get or set the mute state of the Matrix
+                                   output.
+  matrix <index> fader             Get or set the fader level of the Matrix
+                                   output.
+  matrix <index> fadein            Fade in the Matrix output over a specified
+                                   duration.
+  matrix <index> fadeout           Fade out the Matrix output over a specified
+                                   duration.
+  matrix <index> eq on             Get or set the EQ on/off state of the Matrix
+                                   output.
+  matrix <index> eq <band> gain    Get or set the gain of the specified EQ band.
+  matrix <index> eq <band> freq    Get or set the frequency of the specified EQ
+                                   band.
+  matrix <index> eq <band> q       Get or set the Q factor of the specified EQ
+                                   band.
+  matrix <index> eq <band> type    Get or set the type of the specified EQ band.
+  matrix <index> comp on           Get or set the compressor on/off state of the
+                                   Matrix output.
+  matrix <index> comp mode         Get or set the compressor mode of the Matrix
+                                   output.
+  matrix <index> comp threshold    Get or set the compressor threshold of the
+                                   Matrix output.
+  matrix <index> comp ratio        Get or set the compressor ratio of the Matrix
+                                   output.
+  matrix <index> comp mix          Get or set the compressor mix level of the
+                                   Matrix output.
+  matrix <index> comp makeup       Get or set the compressor makeup gain of the
+                                   Matrix output.
+  matrix <index> comp attack       Get or set the compressor attack time of the
+                                   Matrix output.
+  matrix <index> comp hold         Get or set the compressor hold time of the
+                                   Matrix output.
+  matrix <index> comp release      Get or set the compressor release time of the
+                                   Matrix output.
+
+Strip
+  strip <index> mute              Get or set the mute state of the strip.
+  strip <index> fader             Get or set the fader level of the strip.
+  strip <index> fadein            Fade in the strip over a specified duration.
+  strip <index> fadeout           Fade out the strip over a specified duration.
+  strip <index> send              Get or set the send level for a specific bus.
+  strip <index> name              Get or set the name of the strip.
+  strip <index> gate on           Get or set the gate on/off state of the strip.
+  strip <index> gate mode         Get or set the gate mode of the strip.
+  strip <index> gate threshold    Get or set the gate threshold of the strip.
+  strip <index> gate range        Get or set the gate range of the strip.
+  strip <index> gate attack       Get or set the gate attack time of the strip.
+  strip <index> gate hold         Get or set the gate hold time of the strip.
+  strip <index> gate release      Get or set the gate release time of the strip.
+  strip <index> eq on             Get or set the EQ on/off state of the strip.
+  strip <index> eq <band> gain    Get or set the gain of the EQ band.
+  strip <index> eq <band> freq    Get or set the frequency of the EQ band.
+  strip <index> eq <band> q       Get or set the Q factor of the EQ band.
+  strip <index> eq <band> type    Get or set the type of the EQ band.
+  strip <index> comp on           Get or set the compressor on/off state of the
+                                  strip.
+  strip <index> comp mode         Get or set the compressor mode of the strip.
+  strip <index> comp threshold    Get or set the compressor threshold of the
+                                  strip.
+  strip <index> comp ratio        Get or set the compressor ratio of the strip.
+  strip <index> comp mix          Get or set the compressor mix of the strip.
+  strip <index> comp makeup       Get or set the compressor makeup gain of the
+                                  strip.
+  strip <index> comp attack       Get or set the compressor attack time of the
+                                  strip.
+  strip <index> comp hold         Get or set the compressor hold time of the
+                                  strip.
+  strip <index> comp release      Get or set the compressor release time of the
+                                  strip.
+
+Bus
+  bus <index> mute              Get or set the mute state of the bus.
+  bus <index> fader             Get or set the fader level of the bus.
+  bus <index> fadein            Fade in the bus over a specified duration.
+  bus <index> fadeout           Fade out the bus over a specified duration.
+  bus <index> name              Get or set the name of the bus.
+  bus <index> eq on             Get or set the EQ on/off state of the bus.
+  bus <index> eq mode           Get or set the EQ mode of the bus (peq, geq or
+                                teq).
+  bus <index> eq <band> gain    Get or set the gain of the EQ band.
+  bus <index> eq <band> freq    Get or set the frequency of the EQ band.
+  bus <index> eq <band> q       Get or set the Q factor of the EQ band.
+  bus <index> eq <band> type    Get or set the type of the EQ band (lcut, lshv,
+                                peq, veq, hshv, hcut).
+  bus <index> comp on           Get or set the compressor on/off state of the
+                                bus.
+  bus <index> comp mode         Get or set the compressor mode of the bus (comp,
+                                exp).
+  bus <index> comp threshold    Get or set the compressor threshold of the bus
+                                (in dB).
+  bus <index> comp ratio        Get or set the compressor ratio of the bus.
+  bus <index> comp mix          Get or set the compressor mix level of the bus
+                                (in %).
+  bus <index> comp makeup       Get or set the compressor makeup gain of the bus
+                                (in dB).
+  bus <index> comp attack       Get or set the compressor attack time of the bus
+                                (in ms).
+  bus <index> comp hold         Get or set the compressor hold time of the bus
+                                (in ms).
+  bus <index> comp release      Get or set the compressor release time of the
+                                bus (in ms).
+
+Headamp
+  headamp <index> gain       Get or set the gain of the headamp.
+  headamp <index> phantom    Get or set the phantom power state of the headamp.
+
+Snapshot
+  snapshot list              List all snapshots.
+  snapshot <index> name      Get or set the name of a snapshot.
+  snapshot <index> save      Save the current mixer state to a snapshot.
+  snapshot <index> load      Load a mixer state from a snapshot.
+  snapshot <index> delete    Delete a snapshot.
+
+DCA
+  dca <index> mute    Get or set the mute status of the DCA group.
+  dca <index> name    Get or set the name of the DCA group.
+
+Run "x32-cli <command> --help" for more information on a command.
+```

xair-help.md

@@ -0,0 +1,129 @@
+```console
+Usage: xair-cli <command> [flags]
+
+A CLI to control Behringer X-Air mixers.
+
+Flags:
+  -h, --help                  Show context-sensitive help.
+  -H, --host="mixer.local"    The host of the X-Air device ($XAIR_CLI_HOST).
+  -P, --port=10024            The port of the X-Air device ($XAIR_CLI_PORT).
+  -T, --timeout=100ms         Timeout for OSC operations ($XAIR_CLI_TIMEOUT).
+  -L, --loglevel="warn"       Log level for the CLI ($XAIR_CLI_LOGLEVEL).
+  -v, --version               Print xair-cli version information and quit
+
+Commands:
+  completion    Generate shell completion scripts.
+  info          Print mixer information.
+  raw           Send raw OSC messages to the mixer.
+
+Main
+  main mute              Get or set the mute state of the Main L/R output.
+  main fader             Get or set the fader level of the Main L/R output.
+  main fadein            Fade in the Main L/R output over a specified duration.
+  main fadeout           Fade out the Main L/R output over a specified duration.
+  main eq on             Get or set the EQ on/off state of the Main L/R output.
+  main eq <band> gain    Get or set the gain of the specified EQ band.
+  main eq <band> freq    Get or set the frequency of the specified EQ band.
+  main eq <band> q       Get or set the Q factor of the specified EQ band.
+  main eq <band> type    Get or set the type of the specified EQ band.
+  main comp on           Get or set the compressor on/off state of the Main L/R
+                         output.
+  main comp mode         Get or set the compressor mode of the Main L/R output.
+  main comp threshold    Get or set the compressor threshold of the Main L/R
+                         output.
+  main comp ratio        Get or set the compressor ratio of the Main L/R output.
+  main comp mix          Get or set the compressor mix level of the Main L/R
+                         output.
+  main comp makeup       Get or set the compressor makeup gain of the Main L/R
+                         output.
+  main comp attack       Get or set the compressor attack time of the Main L/R
+                         output.
+  main comp hold         Get or set the compressor hold time of the Main L/R
+                         output.
+  main comp release      Get or set the compressor release time of the Main L/R
+                         output.
+
+Strip
+  strip <index> mute              Get or set the mute state of the strip.
+  strip <index> fader             Get or set the fader level of the strip.
+  strip <index> fadein            Fade in the strip over a specified duration.
+  strip <index> fadeout           Fade out the strip over a specified duration.
+  strip <index> send              Get or set the send level for a specific bus.
+  strip <index> name              Get or set the name of the strip.
+  strip <index> gate on           Get or set the gate on/off state of the strip.
+  strip <index> gate mode         Get or set the gate mode of the strip.
+  strip <index> gate threshold    Get or set the gate threshold of the strip.
+  strip <index> gate range        Get or set the gate range of the strip.
+  strip <index> gate attack       Get or set the gate attack time of the strip.
+  strip <index> gate hold         Get or set the gate hold time of the strip.
+  strip <index> gate release      Get or set the gate release time of the strip.
+  strip <index> eq on             Get or set the EQ on/off state of the strip.
+  strip <index> eq <band> gain    Get or set the gain of the EQ band.
+  strip <index> eq <band> freq    Get or set the frequency of the EQ band.
+  strip <index> eq <band> q       Get or set the Q factor of the EQ band.
+  strip <index> eq <band> type    Get or set the type of the EQ band.
+  strip <index> comp on           Get or set the compressor on/off state of the
+                                  strip.
+  strip <index> comp mode         Get or set the compressor mode of the strip.
+  strip <index> comp threshold    Get or set the compressor threshold of the
+                                  strip.
+  strip <index> comp ratio        Get or set the compressor ratio of the strip.
+  strip <index> comp mix          Get or set the compressor mix of the strip.
+  strip <index> comp makeup       Get or set the compressor makeup gain of the
+                                  strip.
+  strip <index> comp attack       Get or set the compressor attack time of the
+                                  strip.
+  strip <index> comp hold         Get or set the compressor hold time of the
+                                  strip.
+  strip <index> comp release      Get or set the compressor release time of the
+                                  strip.
+
+Bus
+  bus <index> mute              Get or set the mute state of the bus.
+  bus <index> fader             Get or set the fader level of the bus.
+  bus <index> fadein            Fade in the bus over a specified duration.
+  bus <index> fadeout           Fade out the bus over a specified duration.
+  bus <index> name              Get or set the name of the bus.
+  bus <index> eq on             Get or set the EQ on/off state of the bus.
+  bus <index> eq mode           Get or set the EQ mode of the bus (peq, geq or
+                                teq).
+  bus <index> eq <band> gain    Get or set the gain of the EQ band.
+  bus <index> eq <band> freq    Get or set the frequency of the EQ band.
+  bus <index> eq <band> q       Get or set the Q factor of the EQ band.
+  bus <index> eq <band> type    Get or set the type of the EQ band (lcut, lshv,
+                                peq, veq, hshv, hcut).
+  bus <index> comp on           Get or set the compressor on/off state of the
+                                bus.
+  bus <index> comp mode         Get or set the compressor mode of the bus (comp,
+                                exp).
+  bus <index> comp threshold    Get or set the compressor threshold of the bus
+                                (in dB).
+  bus <index> comp ratio        Get or set the compressor ratio of the bus.
+  bus <index> comp mix          Get or set the compressor mix level of the bus
+                                (in %).
+  bus <index> comp makeup       Get or set the compressor makeup gain of the bus
+                                (in dB).
+  bus <index> comp attack       Get or set the compressor attack time of the bus
+                                (in ms).
+  bus <index> comp hold         Get or set the compressor hold time of the bus
+                                (in ms).
+  bus <index> comp release      Get or set the compressor release time of the
+                                bus (in ms).
+
+Headamp
+  headamp <index> gain       Get or set the gain of the headamp.
+  headamp <index> phantom    Get or set the phantom power state of the headamp.
+
+Snapshot
+  snapshot list              List all snapshots.
+  snapshot <index> name      Get or set the name of a snapshot.
+  snapshot <index> save      Save the current mixer state to a snapshot.
+  snapshot <index> load      Load a mixer state from a snapshot.
+  snapshot <index> delete    Delete a snapshot.
+
+DCA
+  dca <index> mute    Get or set the mute status of the DCA group.
+  dca <index> name    Get or set the name of the DCA group.
+
+Run "xair-cli <command> --help" for more information on a command.
+```