.github/workflows/golang-ci.yml

@@ -23,8 +23,7 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version: '1.24'
-      - name: golangci-lint
+      - name: Install golangci-lint
-        uses: golangci/golangci-lint-action@v9
+        run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-        with:
+      - name: Run golangci-lint
-          version: v2.6.0
+        run: golangci-lint run ./...
-          args: --config .golangci.yml

.golangci.yml

@@ -1,142 +1,54 @@
-version: '2'
-
 run:
+  # timeout for analysis, e.g. 30s, 3m, default is 1m
   timeout: 3m
+  # exclude test files
   tests: true
-  go: '1.24'
 
 linters:
-  disable: [dupl]
+  # Set to true runs only fast linters.
+  # Good option for 'lint on save', pre-commit hook or CI.
+  fast: true
+
+  disable-all: true
+
   enable:
-    # Default enabled linters
+    - gosimple
-    - errcheck # Check for unchecked errors
+    - govet
-    - govet # Go's built-in vetting tool
+    - ineffassign
-    - ineffassign # Detect ineffectual assignments
+    - staticcheck
-    - staticcheck # Advanced static analysis
+    - unused
-    - unused # Check for unused code
+    - gofmt
-    # Additional useful linters
+    - gofumpt
-    - misspell # Detect common misspellings
+    - misspell
-    - unparam # Check for unused function parameters
+    - unparam
-    - gosec # Security checks
+    - gosec
-    - asciicheck # Check for non-ASCII characters
+    - asciicheck
-    - errname # Check error variable names
+    - errname
-    - godot # Check for missing periods in comments
+    - gci
-    - revive # Highly configurable linter for style and correctness
+    - godot
-    - gocritic # Detect code issues and suggest improvements
+    - goimports
-    - gocyclo # Check for cyclomatic complexity
+    - revive
-    - dupl # Check for code duplication
-    - predeclared # Check for shadowing of predeclared identifiers
-    - copyloopvar # Check for loop variable capture in goroutines
-    - errorlint # Check for common mistakes in error handling
-    - goconst # Check for repeated strings that could be constants
-    - gosmopolitan # Check for non-portable code
 
-  settings:
+linters-settings:
-    misspell:
+  gofmt:
-      locale: UK
+    rewrite-rules:
+      - pattern: 'interface{}'
+        replacement: 'any'
+      - pattern: 'a[b:len(a)]'
+        replacement: 'a[b:]'
 
-    errcheck:
+  misspell:
-      check-type-assertions: true
+    locale: UK
-      check-blank: true
-      exclude-functions:
-        - fmt.Fprintf
-        - fmt.Fprintln
-        - fmt.Printf
-        - fmt.Println
-        - fmt.Errorf
 
-    revive:
+  errcheck:
-      severity: warning
+    check-type-assertions: true
-      rules:
-        # Code quality and style
-        - name: exported
-          arguments:
-            - 'checkPrivateReceivers'
-            - 'sayRepetitiveInsteadOfStutters'
-        - name: var-naming
-        - name: package-comments
-        - name: range-val-in-closure
-        - name: time-naming
-        - name: context-as-argument
-        - name: context-keys-type
-        - name: dot-imports
-        - name: empty-block
-        - name: error-return
-        - name: error-strings
-        - name: error-naming
-        - name: if-return
-        - name: increment-decrement
-        - name: indent-error-flow
-        - name: receiver-naming
-        - name: redefines-builtin-id
-        - name: superfluous-else
-        - name: unexported-return
-        - name: unreachable-code
-        - name: unused-parameter
-        - name: var-declaration
-        - name: blank-imports
-        - name: range
-
-        # Disabled rules (can be enabled if needed)
-        # - name: line-length-limit
-        #   arguments: [120]
-        # - name: function-length
-        #   arguments: [50, 0]
-        # - name: cyclomatic
-        #   arguments: [10]
-
-    gosec:
-      excludes:
-        - G104 # Duplicated errcheck checks
-        - G115 # integer overflow conversion int -> uint32
-
-  exclusions:
-    warn-unused: false
-    rules:
-      # Exclude some linters from running on tests files.
-      - path: _test\.go
-        linters:
-          - gocyclo
-          - errcheck
-          - dupl
-          - gosec
-
-    paths:
-      - vendor
-
-# Formatters configuration
-formatters:
-  # Enable specific formatters
-  enable:
-    - gofumpt # Stricter gofmt alternative
-    - goimports # Organizes imports
-    - gci # Controls import order/grouping
-    - golines # Enforces line length
-
-  # Formatter-specific settings
-  settings:
-    goimports:
-      local-prefixes: [github.com/onyx-and-iris/xair-cli]
-
-    gci:
-      # Define import sections order
-      sections:
-        - standard # Standard library
-        - default # Everything else
-        - prefix(github.com/onyx-and-iris/xair-cli) # Current module
-
-    gofumpt:
-      extra-rules: true # Enable additional formatting rules
-
-  exclusions:
-    warn-unused: true
-
-    paths:
-      - vendor
 
 issues:
-  # Limit the number of same issues reported to avoid spam
+  max-same-issues: 0
-  max-same-issues: 50
+  max-issues-per-linter: 0
-
+  exclude-use-default: false
-  # Limit the number of issues per linter to keep output manageable
+  exclude:
-  max-issues-per-linter: 100
+    # gosec: Duplicated errcheck checks
+    - G104
+    # gosec: integer overflow conversion int -> uint32
+    - G115

cmd/x32-cli/bus.go

@@ -36,7 +36,7 @@ func (cmd *BusMuteCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.SetMute(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.SetMute(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d mute state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -101,12 +101,7 @@ func (cmd *BusFadeinCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d fade-in complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
-		ctx.Out,
-		"Bus %d fade-in complete. Final level: %.2f dB\n",
-		bus.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -145,12 +140,7 @@ func (cmd *BusFadeoutCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d fade-out complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
-		ctx.Out,
-		"Bus %d fade-out complete. Final level: %.2f dB\n",
-		bus.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -218,7 +208,7 @@ func (cmd *BusEqOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetOn(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.Eq.SetOn(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d EQ on state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -260,26 +250,14 @@ func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
-		ctx.Out,
-		"Bus %d EQ band %d gain set to: %.2f dB\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Gain,
-	)
 	return nil
 }
 
@@ -295,30 +273,14 @@ func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Freq,
-	); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
-		ctx.Out,
-		"Bus %d EQ band %d frequency set to: %.2f Hz\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Freq,
-	)
 	return nil
 }
 
@@ -334,26 +296,14 @@ func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGro
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
-		ctx.Out,
-		"Bus %d EQ band %d Q factor set to: %.2f\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Q,
-	)
 	return nil
 }
 
@@ -369,26 +319,14 @@ func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
-		ctx.Out,
-		"Bus %d EQ band %d type set to: %s\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Type,
-	)
 	return nil
 }
 
@@ -421,7 +359,7 @@ func (cmd *BusCompOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Comp.SetOn(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.Comp.SetOn(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d compressor on state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -470,12 +408,7 @@ func (cmd *BusCompThresholdCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetThreshold(bus.Index.Index, *cmd.Threshold); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor threshold set to: %.2f dB\n", bus.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Bus %d compressor threshold set to: %.2f dB\n",
-		bus.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -544,12 +477,7 @@ func (cmd *BusCompMakeupCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetMakeup(bus.Index.Index, *cmd.Makeup); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor makeup gain set to: %.2f dB\n", bus.Index.Index, *cmd.Makeup)
-		ctx.Out,
-		"Bus %d compressor makeup gain set to: %.2f dB\n",
-		bus.Index.Index,
-		*cmd.Makeup,
-	)
 	return nil
 }
 
@@ -572,12 +500,7 @@ func (cmd *BusCompAttackCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetAttack(bus.Index.Index, *cmd.Attack); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor attack time set to: %.2f ms\n", bus.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Bus %d compressor attack time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -600,12 +523,7 @@ func (cmd *BusCompHoldCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetHold(bus.Index.Index, *cmd.Hold); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor hold time set to: %.2f ms\n", bus.Index.Index, *cmd.Hold)
-		ctx.Out,
-		"Bus %d compressor hold time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Hold,
-	)
 	return nil
 }
 
@@ -628,11 +546,6 @@ func (cmd *BusCompReleaseCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetRelease(bus.Index.Index, *cmd.Release); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor release time set to: %.2f ms\n", bus.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Bus %d compressor release time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }

cmd/x32-cli/cli.go

@@ -11,15 +11,9 @@ import (
 	"github.com/alecthomas/kong"
 	"github.com/charmbracelet/log"
 	kongcompletion "github.com/jotaen/kong-completion"
-
 	"github.com/onyx-and-iris/xair-cli/internal/xair"
 )
 
-const (
-	trueStr  = "true"
-	falseStr = "false"
-)
-
 var version string // Version of the CLI, set at build time.
 
 // VersionFlag is a custom flag type that prints the version and exits.
@@ -52,10 +46,9 @@ 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:""`
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
-	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"`
@@ -79,15 +72,14 @@ func main() {
 		}),
 		kong.Vars{
 			"version": func() string {
-				if version != "" {
+				if version == "" {
-					return version
+					info, ok := debug.ReadBuildInfo()
+					if !ok {
+						return "(unable to read build info)"
+					}
+					version = strings.Split(info.Main.Version, "-")[0]
 				}
-
+				return version
-				info, ok := debug.ReadBuildInfo()
-				if !ok {
-					return "(unable to read version)"
-				}
-				return strings.Split(info.Main.Version, "-")[0]
 			}(),
 		},
 	)
@@ -108,11 +100,7 @@ func run(ctx *kong.Context, config Config) error {
 	if err != nil {
 		return fmt.Errorf("failed to connect to X32 device: %w", err)
 	}
-	defer func() {
+	defer client.Close()
-		if err := client.Close(); err != nil {
-			log.Errorf("failed to close client connection: %v", err)
-		}
-	}()
 
 	client.StartListening()
 	resp, err := client.RequestInfo()
@@ -137,7 +125,7 @@ func connect(config Config) (*xair.X32Client, error) {
 		xair.WithTimeout(config.Timeout),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create X32 client: %w", err)
+		return nil, err
 	}
 
 	return client, nil

cmd/x32-cli/dca.go

@@ -36,7 +36,7 @@ func (cmd *DCAMuteCmd) Run(ctx *context, dca *DCACmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.DCA.SetMute(dca.Index.Index, *cmd.State == trueStr); err != 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

cmd/x32-cli/headamp.go

@@ -38,20 +38,14 @@ func (cmd *HeadampGainCmd) Run(ctx *context, headamp *HeadampCmdGroup) error {
 		return fmt.Errorf("failed to get current headamp gain: %w", err)
 	}
 
-	if err := gradualGainAdjust(
+	if err := gradualGainAdjust(ctx, headamp.Index.Index, currentGain, *cmd.Gain, cmd.Duration); err != nil {
-		ctx,
-		headamp.Index.Index,
-		currentGain,
-		*cmd.Gain,
-		cmd.Duration,
-	); err != nil {
 		return fmt.Errorf("failed to set headamp gain: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Headamp %d gain set to: %.2f dB\n", headamp.Index.Index, *cmd.Gain)
 	return nil
 }
 
-// gradualGainAdjust gradually adjusts gain from current to target over specified duration.
+// gradualGainAdjust gradually adjusts gain from current to target over specified duration
 func gradualGainAdjust(
 	ctx *context,
 	index int,
@@ -102,14 +96,14 @@ type HeadampPhantomCmd struct {
 	State *string `help:"The phantom power state of the headamp." arg:"" enum:"true,on,false,off" optional:""`
 }
 
-// Validate checks if the provided phantom power state is valid and normalises it to "true" or "false".
+// Validate checks if the provided phantom power state is valid and normalizes it to "true" or "false".
 func (cmd *HeadampPhantomCmd) Validate() error {
 	if cmd.State != nil {
 		switch *cmd.State {
-		case trueStr, "on":
+		case "true", "on":
-			*cmd.State = trueStr
+			*cmd.State = "true"
-		case falseStr, "off":
+		case "false", "off":
-			*cmd.State = falseStr
+			*cmd.State = "false"
 		default:
 			return fmt.Errorf("invalid phantom power state: %s", *cmd.State)
 		}
@@ -128,10 +122,7 @@ func (cmd *HeadampPhantomCmd) Run(ctx *context, headamp *HeadampCmdGroup) error
 		return nil
 	}
 
-	if err := ctx.Client.HeadAmp.SetPhantomPower(
+	if err := ctx.Client.HeadAmp.SetPhantomPower(headamp.Index.Index, *cmd.State == "true"); err != nil {
-		headamp.Index.Index,
-		*cmd.State == trueStr,
-	); err != nil {
 		return fmt.Errorf("failed to set headamp phantom power state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Headamp %d phantom power set to: %s\n", headamp.Index.Index, *cmd.State)

cmd/x32-cli/info.go

@@ -1,17 +0,0 @@
-package main
-
-import "fmt"
-
-type InfoCmd struct{}
-
-func (cmd *InfoCmd) Run(ctx *context) error { // nolint: unparam
-	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

@@ -1,4 +1,3 @@
-// Package main implements the command-line interface for controlling an X32 digital mixer.
 package main
 
 import (
@@ -14,7 +13,7 @@ type MainCmdGroup struct {
 	Fadein  MainFadeinCmd  `help:"Fade in the Main L/R output over a specified duration."  cmd:""`
 	Fadeout MainFadeoutCmd `help:"Fade out the Main L/R output over a specified duration." cmd:""`
 
-	Eq   MainEqCmdGroup   `help:"Commands for controlling the equaliser settings of the Main L/R output."  cmd:"eq"`
+	Eq   MainEqCmdGroup   `help:"Commands for controlling the equalizer settings of the Main L/R output."  cmd:"eq"`
 	Comp MainCompCmdGroup `help:"Commands for controlling the compressor settings of the Main L/R output." cmd:"comp"`
 }
 
@@ -34,7 +33,7 @@ func (cmd *MainMuteCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.SetMute(*cmd.Mute == trueStr); err != nil {
+	if err := ctx.Client.Main.SetMute(*cmd.Mute == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Main L/R mute state set to: %s\n", *cmd.Mute)
@@ -132,7 +131,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 	return nil
 }
 
-// MainEqCmdGroup defines the command group for controlling the equaliser settings of the Main L/R output, including commands for getting or setting the EQ parameters.
+// MainEqCmdGroup defines the command group for controlling the equalizer settings of the Main L/R output, including commands for getting or setting the EQ parameters.
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
@@ -162,7 +161,7 @@ type MainEqOnCmd struct {
 }
 
 // Run executes the MainEqOnCmd command, either retrieving the current EQ on/off state of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainEqOnCmd) Run(ctx *context) error {
+func (cmd *MainEqOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.Main.Eq.On(0)
 		if err != nil {
@@ -172,10 +171,10 @@ func (cmd *MainEqOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Main.Eq.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R EQ on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -185,7 +184,7 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
@@ -198,12 +197,7 @@ func (cmd *MainEqBandGainCmd) Run(ctx *context, mainEq *MainEqCmdGroup) error {
 	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(
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
-		ctx.Out,
-		"Main L/R EQ band %d gain set to: %.2f dB\n",
-		*mainEq.Band.Band,
-		*cmd.Level,
-	)
 	return nil
 }
 
@@ -213,15 +207,11 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
@@ -230,12 +220,7 @@ func (cmd *MainEqBandFreqCmd) Run(ctx *context, mainEq *MainEqCmdGroup) error {
 	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(
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
-		ctx.Out,
-		"Main L/R EQ band %d frequency set to: %.2f Hz\n",
-		*mainEq.Band.Band,
-		*cmd.Frequency,
-	)
 	return nil
 }
 
@@ -245,15 +230,11 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
@@ -272,7 +253,7 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
@@ -308,7 +289,7 @@ type MainCompOnCmd struct {
 }
 
 // Run executes the MainCompOnCmd command, either retrieving the current compressor on/off state of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompOnCmd) Run(ctx *context) error {
+func (cmd *MainCompOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.Main.Comp.On(0)
 		if err != nil {
@@ -318,10 +299,10 @@ func (cmd *MainCompOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.Comp.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Main.Comp.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R compressor on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R compressor on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main L/R compressor on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -331,7 +312,7 @@ type MainCompModeCmd struct {
 }
 
 // Run executes the MainCompModeCmd command, either retrieving the current compressor mode of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompModeCmd) Run(ctx *context) error {
+func (cmd *MainCompModeCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mode == nil {
 		resp, err := ctx.Client.Main.Comp.Mode(0)
 		if err != nil {
@@ -354,7 +335,7 @@ type MainCompThresholdCmd struct {
 }
 
 // Run executes the MainCompThresholdCmd command, either retrieving the current compressor threshold of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompThresholdCmd) Run(ctx *context) error {
+func (cmd *MainCompThresholdCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Threshold == nil {
 		resp, err := ctx.Client.Main.Comp.Threshold(0)
 		if err != nil {
@@ -377,7 +358,7 @@ type MainCompRatioCmd struct {
 }
 
 // Run executes the MainCompRatioCmd command, either retrieving the current compressor ratio of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompRatioCmd) Run(ctx *context) error {
+func (cmd *MainCompRatioCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Ratio == nil {
 		resp, err := ctx.Client.Main.Comp.Ratio(0)
 		if err != nil {
@@ -400,7 +381,7 @@ type MainCompMixCmd struct {
 }
 
 // Run executes the MainCompMixCmd command, either retrieving the current compressor mix level of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompMixCmd) Run(ctx *context) error {
+func (cmd *MainCompMixCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mix == nil {
 		resp, err := ctx.Client.Main.Comp.Mix(0)
 		if err != nil {
@@ -423,7 +404,7 @@ type MainCompMakeupCmd struct {
 }
 
 // Run executes the MainCompMakeupCmd command, either retrieving the current compressor makeup gain of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompMakeupCmd) Run(ctx *context) error {
+func (cmd *MainCompMakeupCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Makeup == nil {
 		resp, err := ctx.Client.Main.Comp.Makeup(0)
 		if err != nil {
@@ -446,7 +427,7 @@ type MainCompAttackCmd struct {
 }
 
 // Run executes the MainCompAttackCmd command, either retrieving the current compressor attack time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompAttackCmd) Run(ctx *context) error {
+func (cmd *MainCompAttackCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Attack == nil {
 		resp, err := ctx.Client.Main.Comp.Attack(0)
 		if err != nil {
@@ -469,7 +450,7 @@ type MainCompHoldCmd struct {
 }
 
 // Run executes the MainCompHoldCmd command, either retrieving the current compressor hold time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompHoldCmd) Run(ctx *context) error {
+func (cmd *MainCompHoldCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Hold == nil {
 		resp, err := ctx.Client.Main.Comp.Hold(0)
 		if err != nil {
@@ -492,7 +473,7 @@ type MainCompReleaseCmd struct {
 }
 
 // Run executes the MainCompReleaseCmd command, either retrieving the current compressor release time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompReleaseCmd) Run(ctx *context) error {
+func (cmd *MainCompReleaseCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Release == nil {
 		resp, err := ctx.Client.Main.Comp.Release(0)
 		if err != nil {

cmd/x32-cli/mainmono.go

@@ -13,7 +13,7 @@ type MainMonoCmdGroup struct {
 	Fadein  MainMonoFadeinCmd  `help:"Fade in the Main Mono output over a specified duration."  cmd:""`
 	Fadeout MainMonoFadeoutCmd `help:"Fade out the Main Mono output over a specified duration." cmd:""`
 
-	Eq   MainMonoEqCmdGroup   `help:"Commands for controlling the equaliser settings of the Main Mono output."  cmd:"eq"`
+	Eq   MainMonoEqCmdGroup   `help:"Commands for controlling the equalizer settings of the Main Mono output."  cmd:"eq"`
 	Comp MainMonoCompCmdGroup `help:"Commands for controlling the compressor settings of the Main Mono output." cmd:"comp"`
 }
 
@@ -33,7 +33,7 @@ func (cmd *MainMonoMuteCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.SetMute(*cmd.Mute == trueStr); err != nil {
+	if err := ctx.Client.MainMono.SetMute(*cmd.Mute == "true"); err != nil {
 		return fmt.Errorf("failed to set Main Mono mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Main Mono mute state set to: %s\n", *cmd.Mute)
@@ -131,7 +131,7 @@ func (cmd *MainMonoFadeoutCmd) Run(ctx *context) error {
 	return nil
 }
 
-// MainMonoEqCmdGroup defines the command group for controlling the equaliser settings of the Main Mono output, including commands for getting or setting the EQ parameters.
+// MainMonoEqCmdGroup defines the command group for controlling the equalizer settings of the Main Mono output, including commands for getting or setting the EQ parameters.
 type MainMonoEqCmdGroup struct {
 	On   MainMonoEqOnCmd `help:"Get or set the EQ on/off state of the Main Mono output."               cmd:"on"`
 	Band struct {
@@ -161,7 +161,7 @@ type MainMonoEqOnCmd struct {
 }
 
 // Run executes the MainMonoEqOnCmd command, either retrieving the current EQ on/off state of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoEqOnCmd) Run(ctx *context) error {
+func (cmd *MainMonoEqOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.MainMono.Eq.On(0)
 		if err != nil {
@@ -171,10 +171,10 @@ func (cmd *MainMonoEqOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.MainMono.Eq.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main Mono EQ on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono EQ on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main Mono EQ on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -184,10 +184,7 @@ 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(
+func (cmd *MainMonoEqBandGainCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
-	ctx *context,
-	mainEq *MainMonoEqCmdGroup,
-) error {
 	if cmd.Level == nil {
 		resp, err := ctx.Client.MainMono.Eq.Gain(0, *mainEq.Band.Band)
 		if err != nil {
@@ -200,12 +197,7 @@ func (cmd *MainMonoEqBandGainCmd) Run(
 	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(
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
-		ctx.Out,
-		"Main Mono EQ band %d gain set to: %.2f dB\n",
-		*mainEq.Band.Band,
-		*cmd.Level,
-	)
 	return nil
 }
 
@@ -215,40 +207,20 @@ 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(
+func (cmd *MainMonoEqBandFreqCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
-	ctx *context,
-	mainEq *MainMonoEqCmdGroup,
-) error {
 	if cmd.Frequency == nil {
 		resp, err := ctx.Client.MainMono.Eq.Frequency(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Eq.SetFrequency(
+	if err := ctx.Client.MainMono.Eq.SetFrequency(0, *mainEq.Band.Band, *cmd.Frequency); err != nil {
-		0,
+		return fmt.Errorf("failed to set Main Mono EQ band %d frequency: %w", *mainEq.Band.Band, err)
-		*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(
+	fmt.Fprintf(ctx.Out, "Main Mono EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
-		ctx.Out,
-		"Main Mono EQ band %d frequency set to: %.2f Hz\n",
-		*mainEq.Band.Band,
-		*cmd.Frequency,
-	)
 	return nil
 }
 
@@ -258,18 +230,11 @@ 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(
+func (cmd *MainMonoEqBandQCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
-	ctx *context,
-	mainEq *MainMonoEqCmdGroup,
-) error {
 	if cmd.Q == nil {
 		resp, err := ctx.Client.MainMono.Eq.Q(0, *mainEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main Mono EQ band %d Q factor: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
@@ -288,10 +253,7 @@ 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(
+func (cmd *MainMonoEqBandTypeCmd) Run(ctx *context, main *MainCmdGroup, mainEq *MainMonoEqCmdGroup) error {
-	ctx *context,
-	mainEq *MainMonoEqCmdGroup,
-) error {
 	if cmd.Type == nil {
 		resp, err := ctx.Client.MainMono.Eq.Type(0, *mainEq.Band.Band)
 		if err != nil {
@@ -327,7 +289,7 @@ type MainMonoCompOnCmd struct {
 }
 
 // Run executes the MainMonoCompOnCmd command, either retrieving the current compressor on/off state of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompOnCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.MainMono.Comp.On(0)
 		if err != nil {
@@ -337,10 +299,10 @@ func (cmd *MainMonoCompOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.MainMono.Comp.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.MainMono.Comp.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main Mono compressor on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main Mono compressor on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main Mono compressor on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -350,7 +312,7 @@ type MainMonoCompModeCmd struct {
 }
 
 // Run executes the MainMonoCompModeCmd command, either retrieving the current compressor mode of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompModeCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompModeCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mode == nil {
 		resp, err := ctx.Client.MainMono.Comp.Mode(0)
 		if err != nil {
@@ -373,7 +335,7 @@ type MainMonoCompThresholdCmd struct {
 }
 
 // Run executes the MainMonoCompThresholdCmd command, either retrieving the current compressor threshold of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompThresholdCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompThresholdCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Threshold == nil {
 		resp, err := ctx.Client.MainMono.Comp.Threshold(0)
 		if err != nil {
@@ -396,7 +358,7 @@ type MainMonoCompRatioCmd struct {
 }
 
 // Run executes the MainMonoCompRatioCmd command, either retrieving the current compressor ratio of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompRatioCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompRatioCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Ratio == nil {
 		resp, err := ctx.Client.MainMono.Comp.Ratio(0)
 		if err != nil {
@@ -419,7 +381,7 @@ type MainMonoCompMixCmd struct {
 }
 
 // Run executes the MainMonoCompMixCmd command, either retrieving the current compressor mix level of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompMixCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompMixCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mix == nil {
 		resp, err := ctx.Client.MainMono.Comp.Mix(0)
 		if err != nil {
@@ -442,7 +404,7 @@ type MainMonoCompMakeupCmd struct {
 }
 
 // Run executes the MainMonoCompMakeupCmd command, either retrieving the current compressor makeup gain of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompMakeupCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompMakeupCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Makeup == nil {
 		resp, err := ctx.Client.MainMono.Comp.Makeup(0)
 		if err != nil {
@@ -465,7 +427,7 @@ type MainMonoCompAttackCmd struct {
 }
 
 // Run executes the MainMonoCompAttackCmd command, either retrieving the current compressor attack time of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompAttackCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompAttackCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Attack == nil {
 		resp, err := ctx.Client.MainMono.Comp.Attack(0)
 		if err != nil {
@@ -488,7 +450,7 @@ type MainMonoCompHoldCmd struct {
 }
 
 // Run executes the MainMonoCompHoldCmd command, either retrieving the current compressor hold time of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompHoldCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompHoldCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Hold == nil {
 		resp, err := ctx.Client.MainMono.Comp.Hold(0)
 		if err != nil {
@@ -511,7 +473,7 @@ type MainMonoCompReleaseCmd struct {
 }
 
 // Run executes the MainMonoCompReleaseCmd command, either retrieving the current compressor release time of the Main Mono output or setting it based on the provided argument.
-func (cmd *MainMonoCompReleaseCmd) Run(ctx *context) error {
+func (cmd *MainMonoCompReleaseCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Release == nil {
 		resp, err := ctx.Client.MainMono.Comp.Release(0)
 		if err != nil {

cmd/x32-cli/matrix.go

@@ -15,14 +15,14 @@ type MatrixCmdGroup struct {
 		Fadein  MatrixFadeinCmd  `help:"Fade in the Matrix output over a specified duration."  cmd:""`
 		Fadeout MatrixFadeoutCmd `help:"Fade out the Matrix output over a specified duration." cmd:""`
 
-		Eq   MatrixEqCmdGroup   `help:"Commands for controlling the equaliser settings of the Matrix output."  cmd:"eq"`
+		Eq   MatrixEqCmdGroup   `help:"Commands for controlling the equalizer settings of the Matrix output."  cmd:"eq"`
 		Comp MatrixCompCmdGroup `help:"Commands for controlling the compressor settings of the Matrix output." cmd:"comp"`
 	} `help:"Commands for controlling individual Matrix outputs." arg:""`
 }
 
 func (cmd *MatrixCmdGroup) Validate() error {
 	if cmd.Index.Index < 1 || cmd.Index.Index > 6 {
-		return fmt.Errorf("matrix output index must be between 1 and 6, got %d", cmd.Index.Index)
+		return fmt.Errorf("Matrix output index must be between 1 and 6, got %d", cmd.Index.Index)
 	}
 	return nil
 }
@@ -43,7 +43,7 @@ func (cmd *MatrixMuteCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.SetMute(matrix.Index.Index, *cmd.Mute == trueStr); err != nil {
+	if err := ctx.Client.Matrix.SetMute(matrix.Index.Index, *cmd.Mute == "true"); err != nil {
 		return fmt.Errorf("failed to set Matrix mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Matrix mute state set to: %s\n", *cmd.Mute)
@@ -141,7 +141,7 @@ func (cmd *MatrixFadeoutCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 	return nil
 }
 
-// MatrixEqCmdGroup defines the command group for controlling the equaliser settings of the Matrix output, including commands for getting or setting the EQ parameters.
+// MatrixEqCmdGroup defines the command group for controlling the equalizer settings of the Matrix output, including commands for getting or setting the EQ parameters.
 type MatrixEqCmdGroup struct {
 	On   MatrixEqOnCmd `help:"Get or set the EQ on/off state of the Matrix output."               cmd:"on"`
 	Band struct {
@@ -181,10 +181,10 @@ func (cmd *MatrixEqOnCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetOn(matrix.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Matrix.Eq.SetOn(matrix.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Matrix EQ on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix EQ on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Matrix EQ on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -194,11 +194,7 @@ 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(
+func (cmd *MatrixEqBandGainCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
-	ctx *context,
-	matrix *MatrixCmdGroup,
-	matrixEq *MatrixEqCmdGroup,
-) error {
 	if cmd.Level == nil {
 		resp, err := ctx.Client.Matrix.Eq.Gain(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
@@ -208,19 +204,10 @@ func (cmd *MatrixEqBandGainCmd) Run(
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetGain(
+	if err := ctx.Client.Matrix.Eq.SetGain(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Level); err != nil {
-		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(
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d gain set to: %.2f dB\n", *matrixEq.Band.Band, *cmd.Level)
-		ctx.Out,
-		"Matrix EQ band %d gain set to: %.2f dB\n",
-		*matrixEq.Band.Band,
-		*cmd.Level,
-	)
 	return nil
 }
 
@@ -230,37 +217,20 @@ 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(
+func (cmd *MatrixEqBandFreqCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
-	ctx *context,
-	matrix *MatrixCmdGroup,
-	matrixEq *MatrixEqCmdGroup,
-) error {
 	if cmd.Frequency == nil {
 		resp, err := ctx.Client.Matrix.Eq.Frequency(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Matrix EQ band %d frequency: %w", *matrixEq.Band.Band, err)
-				"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)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetFrequency(
+	if err := ctx.Client.Matrix.Eq.SetFrequency(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Frequency); err != nil {
-		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(
+	fmt.Fprintf(ctx.Out, "Matrix EQ band %d frequency set to: %.2f Hz\n", *matrixEq.Band.Band, *cmd.Frequency)
-		ctx.Out,
-		"Matrix EQ band %d frequency set to: %.2f Hz\n",
-		*matrixEq.Band.Band,
-		*cmd.Frequency,
-	)
 	return nil
 }
 
@@ -270,29 +240,17 @@ 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(
+func (cmd *MatrixEqBandQCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
-	ctx *context,
-	matrix *MatrixCmdGroup,
-	matrixEq *MatrixEqCmdGroup,
-) error {
 	if cmd.Q == nil {
 		resp, err := ctx.Client.Matrix.Eq.Q(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Matrix EQ band %d Q factor: %w", *matrixEq.Band.Band, err)
-				"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)
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetQ(
+	if err := ctx.Client.Matrix.Eq.SetQ(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Q); err != nil {
-		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)
@@ -305,11 +263,7 @@ 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(
+func (cmd *MatrixEqBandTypeCmd) Run(ctx *context, matrix *MatrixCmdGroup, matrixEq *MatrixEqCmdGroup) error {
-	ctx *context,
-	matrix *MatrixCmdGroup,
-	matrixEq *MatrixEqCmdGroup,
-) error {
 	if cmd.Type == nil {
 		resp, err := ctx.Client.Matrix.Eq.Type(matrix.Index.Index, *matrixEq.Band.Band)
 		if err != nil {
@@ -319,11 +273,7 @@ func (cmd *MatrixEqBandTypeCmd) Run(
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Eq.SetType(
+	if err := ctx.Client.Matrix.Eq.SetType(matrix.Index.Index, *matrixEq.Band.Band, *cmd.Type); err != nil {
-		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)
@@ -359,10 +309,10 @@ func (cmd *MatrixCompOnCmd) Run(ctx *context, matrix *MatrixCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Matrix.Comp.SetOn(matrix.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Matrix.Comp.SetOn(matrix.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Matrix compressor on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Matrix compressor on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Matrix compressor on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 

cmd/x32-cli/snapshot.go

@@ -14,25 +14,26 @@ type SnapshotCmdGroup struct {
 }
 
 // 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 (cmd *SnapshotCmdGroup) Validate() error {
+func (c *SnapshotCmdGroup) Validate() error {
-	if cmd.Index.Index == nil {
+	if c.Index.Index == nil {
 		return nil
 	}
 
-	if *cmd.Index.Index < 1 || *cmd.Index.Index > 64 {
+	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{}
+type ListCmd struct {
+}
 
-func (cmd *ListCmd) Run(ctx *context) error {
+func (c *ListCmd) Run(ctx *context) error {
 	for i := range 64 {
 		name, err := ctx.Client.Snapshot.Name(i + 1)
 		if err != nil {
-			return fmt.Errorf("failed to get name for snapshot %d: %w", i+1, err)
+			break
 		}
 		if name == "" {
 			continue
@@ -46,8 +47,8 @@ type NameCmd struct {
 	Name *string `arg:"" help:"The name of the snapshot." optional:""`
 }
 
-func (cmd *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
+func (c *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	if cmd.Name == nil {
+	if c.Name == nil {
 		name, err := ctx.Client.Snapshot.Name(*snapshot.Index.Index)
 		if err != nil {
 			return err
@@ -56,15 +57,15 @@ func (cmd *NameCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 		return nil
 	}
 
-	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *cmd.Name)
+	return ctx.Client.Snapshot.SetName(*snapshot.Index.Index, *c.Name)
 }
 
 type SaveCmd struct {
 	Name string `arg:"" help:"The name of the snapshot."`
 }
 
-func (cmd *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
+func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
-	err := ctx.Client.Snapshot.CurrentName(cmd.Name)
+	err := ctx.Client.Snapshot.CurrentName(c.Name)
 	if err != nil {
 		return err
 	}
@@ -72,14 +73,16 @@ func (cmd *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
-type LoadCmd struct{}
+type LoadCmd struct {
+}
 
-func (cmd *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
+func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
-type DeleteCmd struct{}
+type DeleteCmd struct {
+}
 
-func (cmd *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
+func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)
 }

cmd/x32-cli/strip.go

@@ -38,7 +38,7 @@ func (cmd *StripMuteCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetMute(strip.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Strip.SetMute(strip.Index.Index, *cmd.State == "true"); err != nil {
 		return fmt.Errorf("failed to set mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d mute state set to: %s\n", strip.Index.Index, *cmd.State)
@@ -99,12 +99,7 @@ func (cmd *StripFadeinCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d fade-in complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
-		ctx.Out,
-		"Strip %d fade-in complete. Final level: %.2f dB\n",
-		strip.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -140,59 +135,36 @@ func (cmd *StripFadeoutCmd) Run(ctx *context, strip *StripCmdGroup) error {
 			time.Sleep(stepDuration)
 		}
 
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Strip %d fade-out complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
-			ctx.Out,
-			"Strip %d fade-out complete. Final level: %.2f dB\n",
-			strip.Index.Index,
-			cmd.Target,
-		)
 		return nil
 	}
 }
 
-// StripSendCmd defines the command for getting or setting the auxiliary send level
+// 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.
-// for a specific send destination (mix bus) on a strip.
 type StripSendCmd struct {
-	SendIndex int      `arg:"" help:"The index of the send destination (mix bus). (1-based indexing)"`
+	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:""`
+	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 send destination
+// 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.
-// 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.SendIndex)
+		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.BusNum)
 		if err != nil {
 			return fmt.Errorf("failed to get send level: %w", err)
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d: %.2f dB\n", strip.Index.Index, cmd.BusNum, resp)
-			ctx.Out,
-			"Strip %d send %d level: %.2f dB\n",
-			strip.Index.Index,
-			cmd.SendIndex,
-			resp,
-		)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetSendLevel(
+	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.BusNum, *cmd.Level); err != nil {
-		strip.Index.Index,
-		cmd.SendIndex,
-		*cmd.Level,
-	); err != nil {
 		return fmt.Errorf("failed to set send level: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d set to: %.2f dB\n", strip.Index.Index, cmd.BusNum, *cmd.Level)
-		ctx.Out,
-		"Strip %d send %d level set to: %.2f dB\n",
-		strip.Index.Index,
-		cmd.SendIndex,
-		*cmd.Level,
-	)
 	return nil
 }
 
-// StripNameCmd defines the command for getting or setting the name of a strip, allowing users to assign custom names to strips for easier identification and organisation.
+// StripNameCmd defines the command for getting or setting the name of a strip, allowing users to assign custom names to strips for easier identification and organization.
 type StripNameCmd struct {
 	Name *string `arg:"" help:"The name to set for the strip." optional:""`
 }
@@ -242,7 +214,7 @@ func (cmd *StripGateOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Gate.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Gate.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set gate state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d gate state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -291,12 +263,7 @@ func (cmd *StripGateThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error
 	if err := ctx.Client.Strip.Gate.SetThreshold(strip.Index.Index, *cmd.Threshold); err != nil {
 		return fmt.Errorf("failed to set gate threshold: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Strip %d gate threshold set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -342,12 +309,7 @@ func (cmd *StripGateAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Gate.SetAttack(strip.Index.Index, *cmd.Attack); err != nil {
 		return fmt.Errorf("failed to set gate attack time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Strip %d gate attack time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -393,12 +355,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Gate.SetRelease(strip.Index.Index, *cmd.Release); err != nil {
 		return fmt.Errorf("failed to set gate release time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Strip %d gate release time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }
 
@@ -442,7 +399,7 @@ func (cmd *StripEqOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Eq.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set EQ state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d EQ state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -455,74 +412,40 @@ 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(
+func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Gain == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Gain,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
-		ctx.Out,
-		"Strip %d EQ band %d gain set to: %.2f\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Gain,
-	)
 	return nil
 }
 
-// StripEqBandFreqCmd defines the command for getting or setting the frequency of a specific EQ band on a strip, allowing users to adjust the centre frequency of the band in hertz (Hz).
+// StripEqBandFreqCmd defines the command for getting or setting the frequency of a specific EQ band on a strip, allowing users to adjust the center frequency of the band in hertz (Hz).
 type StripEqBandFreqCmd struct {
 	Freq *float64 `arg:"" help:"The frequency to set for the EQ band (in Hz)." optional:""`
 }
 
 // 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(
+func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Freq == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Freq,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
@@ -541,36 +464,20 @@ 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(
+func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Q == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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 {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
-		ctx.Out,
-		"Strip %d EQ band %d Q factor set to: %.2f\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Q,
-	)
 	return nil
 }
 
@@ -580,40 +487,20 @@ 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(
+func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Type == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Type,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
-		ctx.Out,
-		"Strip %d EQ band %d type set to: %s\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Type,
-	)
 	return nil
 }
 
@@ -646,7 +533,7 @@ func (cmd *StripCompOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Comp.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Comp.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set compressor state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d compressor state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -695,12 +582,7 @@ func (cmd *StripCompThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error
 	if err := ctx.Client.Strip.Comp.SetThreshold(strip.Index.Index, *cmd.Threshold); err != nil {
 		return fmt.Errorf("failed to set compressor threshold: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Strip %d compressor threshold set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -769,12 +651,7 @@ func (cmd *StripCompMakeupCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetMakeup(strip.Index.Index, *cmd.Makeup); err != nil {
 		return fmt.Errorf("failed to set compressor makeup gain: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor makeup gain set to: %.2f\n", strip.Index.Index, *cmd.Makeup)
-		ctx.Out,
-		"Strip %d compressor makeup gain set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Makeup,
-	)
 	return nil
 }
 
@@ -797,12 +674,7 @@ func (cmd *StripCompAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetAttack(strip.Index.Index, *cmd.Attack); err != nil {
 		return fmt.Errorf("failed to set compressor attack time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Strip %d compressor attack time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -825,12 +697,7 @@ func (cmd *StripCompHoldCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetHold(strip.Index.Index, *cmd.Hold); err != nil {
 		return fmt.Errorf("failed to set compressor hold time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor hold time set to: %.2f ms\n", strip.Index.Index, *cmd.Hold)
-		ctx.Out,
-		"Strip %d compressor hold time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Hold,
-	)
 	return nil
 }
 
@@ -853,11 +720,6 @@ func (cmd *StripCompReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetRelease(strip.Index.Index, *cmd.Release); err != nil {
 		return fmt.Errorf("failed to set compressor release time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Strip %d compressor release time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }

cmd/xair-cli/bus.go

@@ -36,7 +36,7 @@ func (cmd *BusMuteCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.SetMute(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.SetMute(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d mute state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -101,12 +101,7 @@ func (cmd *BusFadeinCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d fade-in complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
-		ctx.Out,
-		"Bus %d fade-in complete. Final level: %.2f dB\n",
-		bus.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -145,12 +140,7 @@ func (cmd *BusFadeoutCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d fade-out complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
-		ctx.Out,
-		"Bus %d fade-out complete. Final level: %.2f dB\n",
-		bus.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -218,7 +208,7 @@ func (cmd *BusEqOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Eq.SetOn(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.Eq.SetOn(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d EQ on state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -260,26 +250,14 @@ func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, *busEq.Band.Band, *cmd.Gain)
-		ctx.Out,
-		"Bus %d EQ band %d gain set to: %.2f dB\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Gain,
-	)
 	return nil
 }
 
@@ -295,30 +273,14 @@ func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, *busEq.Band.Band, *cmd.Freq); err != nil {
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Freq,
-	); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, *busEq.Band.Band, *cmd.Freq)
-		ctx.Out,
-		"Bus %d EQ band %d frequency set to: %.2f Hz\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Freq,
-	)
 	return nil
 }
 
@@ -334,26 +296,14 @@ func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGro
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, *busEq.Band.Band, *cmd.Q)
-		ctx.Out,
-		"Bus %d EQ band %d Q factor set to: %.2f\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Q,
-	)
 	return nil
 }
 
@@ -369,26 +319,14 @@ func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmd
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, *busEq.Band.Band, resp)
-			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 {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, *busEq.Band.Band, *cmd.Type)
-		ctx.Out,
-		"Bus %d EQ band %d type set to: %s\n",
-		bus.Index.Index,
-		*busEq.Band.Band,
-		*cmd.Type,
-	)
 	return nil
 }
 
@@ -421,7 +359,7 @@ func (cmd *BusCompOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Bus.Comp.SetOn(bus.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Bus.Comp.SetOn(bus.Index.Index, *cmd.State == "true"); err != nil {
 		return err
 	}
 	fmt.Fprintf(ctx.Out, "Bus %d compressor on state set to: %s\n", bus.Index.Index, *cmd.State)
@@ -470,12 +408,7 @@ func (cmd *BusCompThresholdCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetThreshold(bus.Index.Index, *cmd.Threshold); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor threshold set to: %.2f dB\n", bus.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Bus %d compressor threshold set to: %.2f dB\n",
-		bus.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -544,12 +477,7 @@ func (cmd *BusCompMakeupCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetMakeup(bus.Index.Index, *cmd.Makeup); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor makeup gain set to: %.2f dB\n", bus.Index.Index, *cmd.Makeup)
-		ctx.Out,
-		"Bus %d compressor makeup gain set to: %.2f dB\n",
-		bus.Index.Index,
-		*cmd.Makeup,
-	)
 	return nil
 }
 
@@ -572,12 +500,7 @@ func (cmd *BusCompAttackCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetAttack(bus.Index.Index, *cmd.Attack); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor attack time set to: %.2f ms\n", bus.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Bus %d compressor attack time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -600,12 +523,7 @@ func (cmd *BusCompHoldCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetHold(bus.Index.Index, *cmd.Hold); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor hold time set to: %.2f ms\n", bus.Index.Index, *cmd.Hold)
-		ctx.Out,
-		"Bus %d compressor hold time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Hold,
-	)
 	return nil
 }
 
@@ -628,11 +546,6 @@ func (cmd *BusCompReleaseCmd) Run(ctx *context, bus *BusCmdGroup) error {
 	if err := ctx.Client.Bus.Comp.SetRelease(bus.Index.Index, *cmd.Release); err != nil {
 		return err
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Bus %d compressor release time set to: %.2f ms\n", bus.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Bus %d compressor release time set to: %.2f ms\n",
-		bus.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }

cmd/xair-cli/cli.go

@@ -11,15 +11,9 @@ import (
 	"github.com/alecthomas/kong"
 	"github.com/charmbracelet/log"
 	kongcompletion "github.com/jotaen/kong-completion"
-
 	"github.com/onyx-and-iris/xair-cli/internal/xair"
 )
 
-const (
-	trueStr  = "true"
-	falseStr = "false"
-)
-
 var version string // Version of the CLI, set at build time.
 
 // VersionFlag is a custom flag type that prints the version and exits.
@@ -52,10 +46,9 @@ 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:""`
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
-	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"`
@@ -77,15 +70,14 @@ func main() {
 		}),
 		kong.Vars{
 			"version": func() string {
-				if version != "" {
+				if version == "" {
-					return version
+					info, ok := debug.ReadBuildInfo()
+					if !ok {
+						return "(unable to read build info)"
+					}
+					version = strings.Split(info.Main.Version, "-")[0]
 				}
-
+				return version
-				info, ok := debug.ReadBuildInfo()
-				if !ok {
-					return "(unable to read version)"
-				}
-				return strings.Split(info.Main.Version, "-")[0]
 			}(),
 		},
 	)
@@ -106,11 +98,7 @@ func run(ctx *kong.Context, config Config) error {
 	if err != nil {
 		return fmt.Errorf("failed to connect to X-Air device: %w", err)
 	}
-	defer func() {
+	defer client.Close()
-		if err := client.Close(); err != nil {
-			log.Errorf("failed to close client connection: %v", err)
-		}
-	}()
 
 	client.StartListening()
 	resp, err := client.RequestInfo()
@@ -135,7 +123,7 @@ func connect(config Config) (*xair.XAirClient, error) {
 		xair.WithTimeout(config.Timeout),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create X-Air client: %w", err)
+		return nil, err
 	}
 
 	return client, nil

cmd/xair-cli/dca.go

@@ -37,7 +37,7 @@ func (cmd *DCAMuteCmd) Run(ctx *context, dca *DCACmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.DCA.SetMute(dca.Index.Index, *cmd.State == trueStr); err != 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

cmd/xair-cli/headamp.go

@@ -38,20 +38,14 @@ func (cmd *HeadampGainCmd) Run(ctx *context, headamp *HeadampCmdGroup) error {
 		return fmt.Errorf("failed to get current headamp gain: %w", err)
 	}
 
-	if err := gradualGainAdjust(
+	if err := gradualGainAdjust(ctx, headamp.Index.Index, currentGain, *cmd.Gain, cmd.Duration); err != nil {
-		ctx,
-		headamp.Index.Index,
-		currentGain,
-		*cmd.Gain,
-		cmd.Duration,
-	); err != nil {
 		return fmt.Errorf("failed to set headamp gain: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Headamp %d gain set to: %.2f dB\n", headamp.Index.Index, *cmd.Gain)
 	return nil
 }
 
-// gradualGainAdjust gradually adjusts gain from current to target over specified duration.
+// gradualGainAdjust gradually adjusts gain from current to target over specified duration
 func gradualGainAdjust(
 	ctx *context,
 	index int,
@@ -102,14 +96,14 @@ type HeadampPhantomCmd struct {
 	State *string `help:"The phantom power state of the headamp." arg:"" enum:"true,on,false,off" optional:""`
 }
 
-// Validate checks if the provided phantom power state is valid and normalises it to "true" or "false".
+// Validate checks if the provided phantom power state is valid and normalizes it to "true" or "false".
 func (cmd *HeadampPhantomCmd) Validate() error {
 	if cmd.State != nil {
 		switch *cmd.State {
-		case trueStr, "on":
+		case "true", "on":
-			*cmd.State = trueStr
+			*cmd.State = "true"
-		case falseStr, "off":
+		case "false", "off":
-			*cmd.State = falseStr
+			*cmd.State = "false"
 		default:
 			return fmt.Errorf("invalid phantom power state: %s", *cmd.State)
 		}
@@ -128,10 +122,7 @@ func (cmd *HeadampPhantomCmd) Run(ctx *context, headamp *HeadampCmdGroup) error
 		return nil
 	}
 
-	if err := ctx.Client.HeadAmp.SetPhantomPower(
+	if err := ctx.Client.HeadAmp.SetPhantomPower(headamp.Index.Index, *cmd.State == "true"); err != nil {
-		headamp.Index.Index,
-		*cmd.State == trueStr,
-	); err != nil {
 		return fmt.Errorf("failed to set headamp phantom power state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Headamp %d phantom power set to: %s\n", headamp.Index.Index, *cmd.State)

cmd/xair-cli/info.go

@@ -1,17 +0,0 @@
-package main
-
-import "fmt"
-
-type InfoCmd struct{}
-
-func (cmd *InfoCmd) Run(ctx *context) error { // nolint: unparam
-	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

@@ -1,4 +1,3 @@
-// Package main implements the command-line interface for controlling an XAir digital mixer.
 package main
 
 import (
@@ -14,7 +13,7 @@ type MainCmdGroup struct {
 	Fadein  MainFadeinCmd  `help:"Fade in the Main L/R output over a specified duration."  cmd:""`
 	Fadeout MainFadeoutCmd `help:"Fade out the Main L/R output over a specified duration." cmd:""`
 
-	Eq   MainEqCmdGroup   `help:"Commands for controlling the equaliser settings of the Main L/R output."  cmd:"eq"`
+	Eq   MainEqCmdGroup   `help:"Commands for controlling the equalizer settings of the Main L/R output."  cmd:"eq"`
 	Comp MainCompCmdGroup `help:"Commands for controlling the compressor settings of the Main L/R output." cmd:"comp"`
 }
 
@@ -34,7 +33,7 @@ func (cmd *MainMuteCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.SetMute(*cmd.Mute == trueStr); err != nil {
+	if err := ctx.Client.Main.SetMute(*cmd.Mute == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Main L/R mute state set to: %s\n", *cmd.Mute)
@@ -132,7 +131,7 @@ func (cmd *MainFadeoutCmd) Run(ctx *context) error {
 	return nil
 }
 
-// MainEqCmdGroup defines the command group for controlling the equaliser settings of the Main L/R output, including commands for getting or setting the EQ parameters.
+// MainEqCmdGroup defines the command group for controlling the equalizer settings of the Main L/R output, including commands for getting or setting the EQ parameters.
 type MainEqCmdGroup struct {
 	On   MainEqOnCmd `help:"Get or set the EQ on/off state of the Main L/R output."               cmd:"on"`
 	Band struct {
@@ -162,7 +161,7 @@ type MainEqOnCmd struct {
 }
 
 // Run executes the MainEqOnCmd command, either retrieving the current EQ on/off state of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainEqOnCmd) Run(ctx *context) error {
+func (cmd *MainEqOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.Main.Eq.On(0)
 		if err != nil {
@@ -172,10 +171,10 @@ func (cmd *MainEqOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.Eq.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Main.Eq.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R EQ on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R EQ on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main L/R EQ on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -185,7 +184,7 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
@@ -198,12 +197,7 @@ func (cmd *MainEqBandGainCmd) Run(ctx *context, mainEq *MainEqCmdGroup) error {
 	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(
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d gain set to: %.2f dB\n", *mainEq.Band.Band, *cmd.Level)
-		ctx.Out,
-		"Main L/R EQ band %d gain set to: %.2f dB\n",
-		*mainEq.Band.Band,
-		*cmd.Level,
-	)
 	return nil
 }
 
@@ -213,15 +207,11 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main L/R EQ band %d frequency: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
@@ -230,12 +220,7 @@ func (cmd *MainEqBandFreqCmd) Run(ctx *context, mainEq *MainEqCmdGroup) error {
 	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(
+	fmt.Fprintf(ctx.Out, "Main L/R EQ band %d frequency set to: %.2f Hz\n", *mainEq.Band.Band, *cmd.Frequency)
-		ctx.Out,
-		"Main L/R EQ band %d frequency set to: %.2f Hz\n",
-		*mainEq.Band.Band,
-		*cmd.Frequency,
-	)
 	return nil
 }
 
@@ -245,15 +230,11 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
-			return fmt.Errorf(
+			return fmt.Errorf("failed to get Main L/R EQ band %d Q factor: %w", *mainEq.Band.Band, err)
-				"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)
 		return nil
@@ -272,7 +253,7 @@ 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, mainEq *MainEqCmdGroup) error {
+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)
 		if err != nil {
@@ -308,7 +289,7 @@ type MainCompOnCmd struct {
 }
 
 // Run executes the MainCompOnCmd command, either retrieving the current compressor on/off state of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompOnCmd) Run(ctx *context) error {
+func (cmd *MainCompOnCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Enable == nil {
 		resp, err := ctx.Client.Main.Comp.On(0)
 		if err != nil {
@@ -318,10 +299,10 @@ func (cmd *MainCompOnCmd) Run(ctx *context) error {
 		return nil
 	}
 
-	if err := ctx.Client.Main.Comp.SetOn(0, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Main.Comp.SetOn(0, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set Main L/R compressor on/off state: %w", err)
 	}
-	fmt.Fprintf(ctx.Out, "Main L/R compressor on/off state set to: %t\n", *cmd.Enable == trueStr)
+	fmt.Fprintf(ctx.Out, "Main L/R compressor on/off state set to: %t\n", *cmd.Enable == "true")
 	return nil
 }
 
@@ -331,7 +312,7 @@ type MainCompModeCmd struct {
 }
 
 // Run executes the MainCompModeCmd command, either retrieving the current compressor mode of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompModeCmd) Run(ctx *context) error {
+func (cmd *MainCompModeCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mode == nil {
 		resp, err := ctx.Client.Main.Comp.Mode(0)
 		if err != nil {
@@ -354,7 +335,7 @@ type MainCompThresholdCmd struct {
 }
 
 // Run executes the MainCompThresholdCmd command, either retrieving the current compressor threshold of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompThresholdCmd) Run(ctx *context) error {
+func (cmd *MainCompThresholdCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Threshold == nil {
 		resp, err := ctx.Client.Main.Comp.Threshold(0)
 		if err != nil {
@@ -377,7 +358,7 @@ type MainCompRatioCmd struct {
 }
 
 // Run executes the MainCompRatioCmd command, either retrieving the current compressor ratio of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompRatioCmd) Run(ctx *context) error {
+func (cmd *MainCompRatioCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Ratio == nil {
 		resp, err := ctx.Client.Main.Comp.Ratio(0)
 		if err != nil {
@@ -400,7 +381,7 @@ type MainCompMixCmd struct {
 }
 
 // Run executes the MainCompMixCmd command, either retrieving the current compressor mix level of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompMixCmd) Run(ctx *context) error {
+func (cmd *MainCompMixCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Mix == nil {
 		resp, err := ctx.Client.Main.Comp.Mix(0)
 		if err != nil {
@@ -423,7 +404,7 @@ type MainCompMakeupCmd struct {
 }
 
 // Run executes the MainCompMakeupCmd command, either retrieving the current compressor makeup gain of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompMakeupCmd) Run(ctx *context) error {
+func (cmd *MainCompMakeupCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Makeup == nil {
 		resp, err := ctx.Client.Main.Comp.Makeup(0)
 		if err != nil {
@@ -446,7 +427,7 @@ type MainCompAttackCmd struct {
 }
 
 // Run executes the MainCompAttackCmd command, either retrieving the current compressor attack time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompAttackCmd) Run(ctx *context) error {
+func (cmd *MainCompAttackCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Attack == nil {
 		resp, err := ctx.Client.Main.Comp.Attack(0)
 		if err != nil {
@@ -469,7 +450,7 @@ type MainCompHoldCmd struct {
 }
 
 // Run executes the MainCompHoldCmd command, either retrieving the current compressor hold time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompHoldCmd) Run(ctx *context) error {
+func (cmd *MainCompHoldCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Hold == nil {
 		resp, err := ctx.Client.Main.Comp.Hold(0)
 		if err != nil {
@@ -492,7 +473,7 @@ type MainCompReleaseCmd struct {
 }
 
 // Run executes the MainCompReleaseCmd command, either retrieving the current compressor release time of the Main L/R output or setting it based on the provided argument.
-func (cmd *MainCompReleaseCmd) Run(ctx *context) error {
+func (cmd *MainCompReleaseCmd) Run(ctx *context, main *MainCmdGroup) error {
 	if cmd.Release == nil {
 		resp, err := ctx.Client.Main.Comp.Release(0)
 		if err != nil {

cmd/xair-cli/snapshot.go

@@ -26,13 +26,14 @@ func (c *SnapshotCmdGroup) Validate() error {
 	return nil
 }
 
-type ListCmd struct{}
+type ListCmd struct {
+}
 
 func (c *ListCmd) Run(ctx *context) error {
 	for i := range 64 {
 		name, err := ctx.Client.Snapshot.Name(i + 1)
 		if err != nil {
-			return fmt.Errorf("failed to get name for snapshot %d: %w", i+1, err)
+			break
 		}
 		if name == "" {
 			continue
@@ -72,13 +73,15 @@ func (c *SaveCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentSave(*snapshot.Index.Index)
 }
 
-type LoadCmd struct{}
+type LoadCmd struct {
+}
 
 func (c *LoadCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentLoad(*snapshot.Index.Index)
 }
 
-type DeleteCmd struct{}
+type DeleteCmd struct {
+}
 
 func (c *DeleteCmd) Run(ctx *context, snapshot *SnapshotCmdGroup) error {
 	return ctx.Client.Snapshot.CurrentDelete(*snapshot.Index.Index)

cmd/xair-cli/strip.go

@@ -38,7 +38,7 @@ func (cmd *StripMuteCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetMute(strip.Index.Index, *cmd.State == trueStr); err != nil {
+	if err := ctx.Client.Strip.SetMute(strip.Index.Index, *cmd.State == "true"); err != nil {
 		return fmt.Errorf("failed to set mute state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d mute state set to: %s\n", strip.Index.Index, *cmd.State)
@@ -99,12 +99,7 @@ func (cmd *StripFadeinCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		time.Sleep(stepDuration)
 	}
 
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d fade-in complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
-		ctx.Out,
-		"Strip %d fade-in complete. Final level: %.2f dB\n",
-		strip.Index.Index,
-		cmd.Target,
-	)
 	return nil
 }
 
@@ -140,59 +135,36 @@ func (cmd *StripFadeoutCmd) Run(ctx *context, strip *StripCmdGroup) error {
 			time.Sleep(stepDuration)
 		}
 
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Strip %d fade-out complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
-			ctx.Out,
-			"Strip %d fade-out complete. Final level: %.2f dB\n",
-			strip.Index.Index,
-			cmd.Target,
-		)
 		return nil
 	}
 }
 
-// StripSendCmd defines the command for getting or setting the auxiliary send level
+// 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.
-// for a specific send destination (mix bus or effects channel) on a strip.
 type StripSendCmd struct {
-	SendIndex int      `arg:"" help:"The index of the send destination (mix bus or effects channel). (1-based indexing)"`
+	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:""`
+	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 destination
+// 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.
-// 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.SendIndex)
+		resp, err := ctx.Client.Strip.SendLevel(strip.Index.Index, cmd.BusNum)
 		if err != nil {
 			return fmt.Errorf("failed to get send level: %w", err)
 		}
-		fmt.Fprintf(
+		fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d: %.2f dB\n", strip.Index.Index, cmd.BusNum, resp)
-			ctx.Out,
-			"Strip %d send %d level: %.2f dB\n",
-			strip.Index.Index,
-			cmd.SendIndex,
-			resp,
-		)
 		return nil
 	}
 
-	if err := ctx.Client.Strip.SetSendLevel(
+	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.BusNum, *cmd.Level); err != nil {
-		strip.Index.Index,
-		cmd.SendIndex,
-		*cmd.Level,
-	); err != nil {
 		return fmt.Errorf("failed to set send level: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d set to: %.2f dB\n", strip.Index.Index, cmd.BusNum, *cmd.Level)
-		ctx.Out,
-		"Strip %d send %d level set to: %.2f dB\n",
-		strip.Index.Index,
-		cmd.SendIndex,
-		*cmd.Level,
-	)
 	return nil
 }
 
-// StripNameCmd defines the command for getting or setting the name of a strip, allowing users to assign custom names to strips for easier identification and organisation.
+// StripNameCmd defines the command for getting or setting the name of a strip, allowing users to assign custom names to strips for easier identification and organization.
 type StripNameCmd struct {
 	Name *string `arg:"" help:"The name to set for the strip." optional:""`
 }
@@ -242,7 +214,7 @@ func (cmd *StripGateOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Gate.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Gate.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set gate state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d gate state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -291,12 +263,7 @@ func (cmd *StripGateThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error
 	if err := ctx.Client.Strip.Gate.SetThreshold(strip.Index.Index, *cmd.Threshold); err != nil {
 		return fmt.Errorf("failed to set gate threshold: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Strip %d gate threshold set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -342,12 +309,7 @@ func (cmd *StripGateAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Gate.SetAttack(strip.Index.Index, *cmd.Attack); err != nil {
 		return fmt.Errorf("failed to set gate attack time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Strip %d gate attack time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -393,12 +355,7 @@ func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Gate.SetRelease(strip.Index.Index, *cmd.Release); err != nil {
 		return fmt.Errorf("failed to set gate release time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d gate release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Strip %d gate release time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }
 
@@ -442,7 +399,7 @@ func (cmd *StripEqOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Eq.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Eq.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set EQ state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d EQ state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -455,74 +412,40 @@ 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(
+func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Gain == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, *stripEq.Band.Band, *cmd.Gain); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Gain,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band gain: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Gain)
-		ctx.Out,
-		"Strip %d EQ band %d gain set to: %.2f\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Gain,
-	)
 	return nil
 }
 
-// StripEqBandFreqCmd defines the command for getting or setting the frequency of a specific EQ band on a strip, allowing users to adjust the centre frequency of the band in hertz (Hz).
+// StripEqBandFreqCmd defines the command for getting or setting the frequency of a specific EQ band on a strip, allowing users to adjust the center frequency of the band in hertz (Hz).
 type StripEqBandFreqCmd struct {
 	Freq *float64 `arg:"" help:"The frequency to set for the EQ band (in Hz)." optional:""`
 }
 
 // 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(
+func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Freq == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, *stripEq.Band.Band, *cmd.Freq); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Freq,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band frequency: %w", err)
 	}
 	fmt.Fprintf(
@@ -541,36 +464,20 @@ 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(
+func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Q == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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 {
 		return fmt.Errorf("failed to set EQ band Q factor: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Q)
-		ctx.Out,
-		"Strip %d EQ band %d Q factor set to: %.2f\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Q,
-	)
 	return nil
 }
 
@@ -580,40 +487,20 @@ 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(
+func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
-	ctx *context,
-	strip *StripCmdGroup,
-	stripEq *StripEqCmdGroup,
-) error {
 	if cmd.Type == nil {
 		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(
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, *stripEq.Band.Band, resp)
-			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(
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, *stripEq.Band.Band, *cmd.Type); err != nil {
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Type,
-	); err != nil {
 		return fmt.Errorf("failed to set EQ band type: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, *stripEq.Band.Band, *cmd.Type)
-		ctx.Out,
-		"Strip %d EQ band %d type set to: %s\n",
-		strip.Index.Index,
-		*stripEq.Band.Band,
-		*cmd.Type,
-	)
 	return nil
 }
 
@@ -646,7 +533,7 @@ func (cmd *StripCompOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
 		return nil
 	}
 
-	if err := ctx.Client.Strip.Comp.SetOn(strip.Index.Index, *cmd.Enable == trueStr); err != nil {
+	if err := ctx.Client.Strip.Comp.SetOn(strip.Index.Index, *cmd.Enable == "true"); err != nil {
 		return fmt.Errorf("failed to set compressor state: %w", err)
 	}
 	fmt.Fprintf(ctx.Out, "Strip %d compressor state set to: %s\n", strip.Index.Index, *cmd.Enable)
@@ -695,12 +582,7 @@ func (cmd *StripCompThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error
 	if err := ctx.Client.Strip.Comp.SetThreshold(strip.Index.Index, *cmd.Threshold); err != nil {
 		return fmt.Errorf("failed to set compressor threshold: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
-		ctx.Out,
-		"Strip %d compressor threshold set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Threshold,
-	)
 	return nil
 }
 
@@ -769,12 +651,7 @@ func (cmd *StripCompMakeupCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetMakeup(strip.Index.Index, *cmd.Makeup); err != nil {
 		return fmt.Errorf("failed to set compressor makeup gain: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor makeup gain set to: %.2f\n", strip.Index.Index, *cmd.Makeup)
-		ctx.Out,
-		"Strip %d compressor makeup gain set to: %.2f\n",
-		strip.Index.Index,
-		*cmd.Makeup,
-	)
 	return nil
 }
 
@@ -797,12 +674,7 @@ func (cmd *StripCompAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetAttack(strip.Index.Index, *cmd.Attack); err != nil {
 		return fmt.Errorf("failed to set compressor attack time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
-		ctx.Out,
-		"Strip %d compressor attack time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Attack,
-	)
 	return nil
 }
 
@@ -825,12 +697,7 @@ func (cmd *StripCompHoldCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetHold(strip.Index.Index, *cmd.Hold); err != nil {
 		return fmt.Errorf("failed to set compressor hold time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor hold time set to: %.2f ms\n", strip.Index.Index, *cmd.Hold)
-		ctx.Out,
-		"Strip %d compressor hold time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Hold,
-	)
 	return nil
 }
 
@@ -853,11 +720,6 @@ func (cmd *StripCompReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
 	if err := ctx.Client.Strip.Comp.SetRelease(strip.Index.Index, *cmd.Release); err != nil {
 		return fmt.Errorf("failed to set compressor release time: %w", err)
 	}
-	fmt.Fprintf(
+	fmt.Fprintf(ctx.Out, "Strip %d compressor release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
-		ctx.Out,
-		"Strip %d compressor release time set to: %.2f ms\n",
-		strip.Index.Index,
-		*cmd.Release,
-	)
 	return nil
 }

go.mod

@@ -1,34 +1,35 @@
 module github.com/onyx-and-iris/xair-cli
 
-go 1.25.0
+go 1.25
 
 require (
 	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.12
+	github.com/jotaen/kong-completion v0.0.11
 )
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.4.2 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/lipgloss v1.1.0 // 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.11.0 // indirect
+	github.com/clipperhouse/displaywidth v0.9.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // 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
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/posener/complete v1.2.3 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa // indirect
+	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // indirect
 	golang.org/x/sys v0.41.0 // indirect
 )

go.sum

@@ -6,8 +6,8 @@ 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=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/charmbracelet/colorprofile v0.4.2 h1:BdSNuMjRbotnxHSfxy+PCSa4xAmz7szw70ktAtWRYrY=
+github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
-github.com/charmbracelet/colorprofile v0.4.2/go.mod h1:0rTi81QpwDElInthtrQ6Ni7cG0sDtwAd4C4le060fT8=
+github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
@@ -18,10 +18,12 @@ github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMx
 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.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
+github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=
-github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
+github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=
-github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
-github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+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=
@@ -39,14 +41,14 @@ github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUq
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/hypebeast/go-osc v0.0.0-20220308234300-cec5a8a1e5f5 h1:fqwINudmUrvGCuw+e3tedZ2UJ0hklSw6t8UPomctKyQ=
 github.com/hypebeast/go-osc v0.0.0-20220308234300-cec5a8a1e5f5/go.mod h1:lqMjoCs0y0GoRRujSPZRBaGb4c5ER6TfkFKSClxkMbY=
-github.com/jotaen/kong-completion v0.0.12 h1:a9jmSaWgkdAUMQT583UxLIJrO9tfdSmYqcIxrBByjPc=
+github.com/jotaen/kong-completion v0.0.11 h1:ZRyQt+IwjcAObbiyxJZ3YR7r/o/f6HYidTK1+7YNtnE=
-github.com/jotaen/kong-completion v0.0.12/go.mod h1:dyIG20e3qq128SUBtF8jzI7YtkfzjWMlgbqkAJd6xHQ=
+github.com/jotaen/kong-completion v0.0.11/go.mod h1:dyIG20e3qq128SUBtF8jzI7YtkfzjWMlgbqkAJd6xHQ=
 github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
 github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.20 h1:WcT52H91ZUAwy8+HUkdM3THM6gXqXuLJi9O3rjcQQaQ=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
-github.com/mattn/go-runewidth v0.0.20/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -63,8 +65,8 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
-golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
+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.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
 golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

internal/xair/bus.go

@@ -2,16 +2,15 @@ package xair
 
 import "fmt"
 
-// Bus represents the bus parameters of the mixer.
 type Bus struct {
-	client      *client
+	client      *Client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
-// newBus creates a new Bus instance.
+// newBus creates a new Bus instance
-func newBus(c *client) *Bus {
+func newBus(c *Client) *Bus {
 	return &Bus{
 		client:      c,
 		baseAddress: c.addressMap["bus"],
@@ -20,7 +19,7 @@ func newBus(c *client) *Bus {
 	}
 }
 
-// Mute requests the current mute status for a bus.
+// Mute requests the current mute status for a bus
 func (b *Bus) Mute(bus int) (bool, error) {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/mix/on"
 	err := b.client.SendMessage(address)
@@ -39,7 +38,7 @@ func (b *Bus) Mute(bus int) (bool, error) {
 	return val == 0, nil
 }
 
-// SetMute sets the mute status for a specific bus (1-based indexing).
+// SetMute sets the mute status for a specific bus (1-based indexing)
 func (b *Bus) SetMute(bus int, muted bool) error {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/mix/on"
 	var value int32
@@ -49,7 +48,7 @@ func (b *Bus) SetMute(bus int, muted bool) error {
 	return b.client.SendMessage(address, value)
 }
 
-// Fader requests the current fader level for a bus.
+// Fader requests the current fader level for a bus
 func (b *Bus) Fader(bus int) (float64, error) {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/mix/fader"
 	err := b.client.SendMessage(address)
@@ -69,18 +68,18 @@ func (b *Bus) Fader(bus int) (float64, error) {
 	return mustDbFrom(float64(val)), nil
 }
 
-// SetFader sets the fader level for a specific bus (1-based indexing).
+// SetFader sets the fader level for a specific bus (1-based indexing)
 func (b *Bus) SetFader(bus int, level float64) error {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/mix/fader"
 	return b.client.SendMessage(address, float32(mustDbInto(level)))
 }
 
-// Name requests the name for a specific bus.
+// Name requests the name for a specific bus
 func (b *Bus) Name(bus int) (string, error) {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/config/name"
 	err := b.client.SendMessage(address)
 	if err != nil {
-		return "", fmt.Errorf("failed to send bus name request: %w", err)
+		return "", fmt.Errorf("failed to send bus name request: %v", err)
 	}
 
 	msg, err := b.client.ReceiveMessage()
@@ -94,7 +93,7 @@ func (b *Bus) Name(bus int) (string, error) {
 	return val, nil
 }
 
-// SetName sets the name for a specific bus.
+// SetName sets the name for a specific bus
 func (b *Bus) SetName(bus int, name string) error {
 	address := fmt.Sprintf(b.baseAddress, bus) + "/config/name"
 	return b.client.SendMessage(address, name)

internal/xair/client.go

@@ -1,4 +1,3 @@
-// Package xair provides a client for controlling XAir and X32 mixers using OSC messages.
 package xair
 
 import (
@@ -6,12 +5,17 @@ import (
 	"time"
 
 	"github.com/charmbracelet/log"
+
 	"github.com/hypebeast/go-osc/osc"
 )
 
-// XAirClient is a client for controlling XAir mixers.
+type Client struct {
-type XAirClient struct { // nolint: revive
+	*engine
-	client
+}
+
+// XAirClient is a client for controlling XAir mixers
+type XAirClient struct {
+	Client
 	Main     *Main
 	Strip    *Strip
 	Bus      *Bus
@@ -20,29 +24,9 @@ type XAirClient struct { // nolint: revive
 	DCA      *DCA
 }
 
-// NewXAirClient creates a new XAirClient instance with optional engine configuration.
+// X32Client is a client for controlling X32 mixers
-func NewXAirClient(mixerIP string, mixerPort int, opts ...EngineOption) (*XAirClient, error) {
+type X32Client struct {
-	e, err := newEngine(mixerIP, mixerPort, kindXAir, opts...)
+	Client
-	if err != nil {
-		return nil, err
-	}
-
-	c := &XAirClient{
-		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.DCA = newDCA(&c.client)
-
-	return c, nil
-}
-
-// X32Client is a client for controlling X32 mixers.
-type X32Client struct { // nolint: revive
-	client
 	Main     *Main
 	MainMono *Main
 	Matrix   *Matrix
@@ -53,7 +37,7 @@ type X32Client struct { // nolint: revive
 	DCA      *DCA
 }
 
-// NewX32Client creates a new X32Client instance with optional engine configuration.
+// 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 {
@@ -61,50 +45,62 @@ func NewX32Client(mixerIP string, mixerPort int, opts ...EngineOption) (*X32Clie
 	}
 
 	c := &X32Client{
-		client: client{e, InfoResponse{}},
+		Client: Client{e},
 	}
-	c.Main = newMainStereo(&c.client)
+	c.Main = newMainStereo(&c.Client)
-	c.MainMono = newMainMono(&c.client)
+	c.MainMono = newMainMono(&c.Client)
-	c.Matrix = newMatrix(&c.client)
+	c.Matrix = newMatrix(&c.Client)
-	c.Strip = newStrip(&c.client)
+	c.Strip = newStrip(&c.Client)
-	c.Bus = newBus(&c.client)
+	c.Bus = newBus(&c.Client)
-	c.HeadAmp = newHeadAmp(&c.client)
+	c.HeadAmp = newHeadAmp(&c.Client)
-	c.Snapshot = newSnapshot(&c.client)
+	c.Snapshot = newSnapshot(&c.Client)
-	c.DCA = newDCA(&c.client)
+	c.DCA = newDCA(&c.Client)
 
 	return c, nil
 }
 
-type client struct {
+// NewXAirClient creates a new XAirClient instance with optional engine configuration
-	*engine
+func NewXAirClient(mixerIP string, mixerPort int, opts ...EngineOption) (*XAirClient, error) {
-	Info InfoResponse
+	e, err := newEngine(mixerIP, mixerPort, kindXAir, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &XAirClient{
+		Client: Client{e},
+	}
+	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
 }
 
-// StartListening begins listening for messages in a goroutine.
+// Start begins listening for messages in a goroutine
-func (c *client) StartListening() {
+func (c *Client) StartListening() {
-	go c.receiveLoop()
+	go c.engine.receiveLoop()
 	log.Debugf("Started listening on %s...", c.engine.conn.LocalAddr().String())
 }
 
-// Close stops the client and closes the connection.
+// Close stops the client and closes the connection
-func (c *client) Close() error {
+func (c *Client) Close() {
-	close(c.done)
+	close(c.engine.done)
-	if c.conn != nil {
+	if c.engine.conn != nil {
-		if err := c.conn.Close(); err != nil {
+		c.engine.conn.Close()
-			return fmt.Errorf("failed to close connection: %w", err)
-		}
 	}
-	return nil
 }
 
-// SendMessage sends an OSC message to the mixer using the unified connection.
+// 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.sendToAddress(c.mixerAddr, address, args...)
+	return c.engine.sendToAddress(c.mixerAddr, address, args...)
 }
 
-// ReceiveMessage receives an OSC message from the mixer.
+// 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.timeout)
+	t := time.Tick(c.engine.timeout)
 	select {
 	case <-t:
 		return nil, fmt.Errorf("timeout waiting for response")
@@ -116,8 +112,8 @@ func (c *client) ReceiveMessage() (*osc.Message, error) {
 	}
 }
 
-// RequestInfo requests mixer information.
+// 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 {
@@ -128,31 +124,20 @@ func (c *client) RequestInfo() (InfoResponse, error) {
 	if err != nil {
 		return info, err
 	}
-	if len(msg.Arguments) == 4 {
+	if len(msg.Arguments) >= 3 {
-		if host, ok := msg.Arguments[0].(string); ok {
+		info.Host = msg.Arguments[0].(string)
-			info.Host = host
+		info.Name = msg.Arguments[1].(string)
-		}
+		info.Model = msg.Arguments[2].(string)
-		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).
+// 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.
+// 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.
+// 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

@@ -2,21 +2,20 @@ package xair
 
 import "fmt"
 
-// DCA represents the DCA group parameters of the mixer.
 type DCA struct {
-	client      *client
+	client      *Client
 	baseAddress string
 }
 
-// newDCA creates a new DCA instance.
+// newDCA creates a new DCA instance
-func newDCA(c *client) *DCA {
+func newDCA(c *Client) *DCA {
 	return &DCA{
 		client:      c,
 		baseAddress: c.addressMap["dca"],
 	}
 }
 
-// Mute requests the current mute status for a DCA group.
+// 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)
@@ -35,7 +34,7 @@ func (d *DCA) Mute(group int) (bool, error) {
 	return val == 0, nil
 }
 
-// SetMute sets the mute status for a specific DCA group (1-based indexing).
+// 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
@@ -45,7 +44,7 @@ func (d *DCA) SetMute(group int, muted bool) error {
 	return d.client.SendMessage(address, value)
 }
 
-// Name requests the current name for a DCA group.
+// 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)
@@ -64,15 +63,15 @@ func (d *DCA) Name(group int) (string, error) {
 	return name, nil
 }
 
-// SetName sets the name for a specific DCA group (1-based indexing).
+// 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)
 }
 
-// Colour requests the current colour for a DCA group.
+// Color requests the current color for a DCA group
-func (d *DCA) Colour(group int) (int32, error) {
+func (d *DCA) Color(group int) (int32, error) {
-	address := fmt.Sprintf(d.baseAddress, group) + "/config/colour"
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/color"
 	err := d.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -82,15 +81,15 @@ func (d *DCA) Colour(group int) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	colour, ok := msg.Arguments[0].(int32)
+	color, ok := msg.Arguments[0].(int32)
 	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for DCA colour value")
+		return 0, fmt.Errorf("unexpected argument type for DCA color value")
 	}
-	return colour, nil
+	return color, nil
 }
 
-// SetColor sets the colour for a specific DCA group (1-based indexing).
+// SetColor sets the color for a specific DCA group (1-based indexing)
-func (d *DCA) SetColor(group int, colour int32) error {
+func (d *DCA) SetColor(group int, color int32) error {
-	address := fmt.Sprintf(d.baseAddress, group) + "/config/colour"
+	address := fmt.Sprintf(d.baseAddress, group) + "/config/color"
-	return d.client.SendMessage(address, colour)
+	return d.client.SendMessage(address, color)
 }

internal/xair/engine.go

@@ -1,7 +1,6 @@
 package xair
 
 import (
-	"errors"
 	"fmt"
 	"net"
 	"time"
@@ -27,28 +26,21 @@ type engine struct {
 	respChan chan *osc.Message
 }
 
-func newEngine(
+func newEngine(mixerIP string, mixerPort int, kind mixerKind, opts ...EngineOption) (*engine, error) {
-	mixerIP string,
-	mixerPort int,
-	kind mixerKind,
-	opts ...EngineOption,
-) (*engine, error) {
 	localAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", 0))
 	if err != nil {
-		return nil, fmt.Errorf("failed to resolve local address: %w", err)
+		return nil, fmt.Errorf("failed to resolve local address: %v", err)
 	}
 
 	conn, err := net.ListenUDP("udp", localAddr)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create UDP connection: %w", err)
+		return nil, fmt.Errorf("failed to create UDP connection: %v", err)
 	}
 
 	mixerAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", mixerIP, mixerPort))
 	if err != nil {
-		if err := conn.Close(); err != nil {
+		conn.Close()
-			log.Errorf("failed to close UDP connection: %v", err)
+		return nil, fmt.Errorf("failed to resolve mixer address: %v", err)
-		}
-		return nil, fmt.Errorf("failed to resolve mixer address: %w", err)
 	}
 
 	log.Debugf("Local UDP connection: %s	", conn.LocalAddr().String())
@@ -70,7 +62,7 @@ func newEngine(
 	return e, nil
 }
 
-// receiveLoop handles incoming OSC messages.
+// receiveLoop handles incoming OSC messages
 func (e *engine) receiveLoop() {
 	buffer := make([]byte, 4096)
 
@@ -80,14 +72,10 @@ func (e *engine) receiveLoop() {
 			return
 		default:
 			// Set a short read deadline to prevent blocking indefinitely
-			if err := e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
+			e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
-				log.Errorf("Failed to set read deadline: %v", err)
-				continue
-			}
 			n, _, err := e.conn.ReadFromUDP(buffer)
 			if err != nil {
-				var netErr net.Error
+				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-				if errors.As(err, &netErr) {
 					// Timeout is expected, continue loop
 					continue
 				}
@@ -111,7 +99,7 @@ func (e *engine) receiveLoop() {
 	}
 }
 
-// parseOSCMessage parses raw bytes into an OSC message with improved error handling.
+// parseOSCMessage parses raw bytes into an OSC message with improved error handling
 func (e *engine) parseOSCMessage(data []byte) (*osc.Message, error) {
 	msg, err := e.parser.Parse(data)
 	if err != nil {
@@ -121,7 +109,7 @@ func (e *engine) parseOSCMessage(data []byte) (*osc.Message, error) {
 	return msg, nil
 }
 
-// sendToAddress sends an OSC message to a specific address (enables replying to different ports).
+// sendToAddress sends an OSC message to a specific address (enables replying to different ports)
 func (e *engine) sendToAddress(addr *net.UDPAddr, oscAddress string, args ...any) error {
 	msg := osc.NewMessage(oscAddress)
 	for _, arg := range args {
@@ -142,7 +130,7 @@ func (e *engine) sendToAddress(addr *net.UDPAddr, oscAddress string, args ...any
 
 	data, err := msg.MarshalBinary()
 	if err != nil {
-		return fmt.Errorf("failed to marshal message: %w", err)
+		return fmt.Errorf("failed to marshal message: %v", err)
 	}
 
 	_, err = e.conn.WriteToUDP(data, addr)

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.
+// 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),
@@ -55,7 +55,6 @@ func (e *Eq) SetOn(index int, on bool) error {
 	return e.client.SendMessage(address, value)
 }
 
-// Mode retrieves the EQ mode for a specific strip or bus (1-based indexing).
 func (e *Eq) Mode(index int) (string, error) {
 	address := e.AddressFunc(e.baseAddress, index) + "/mode"
 	err := e.client.SendMessage(address)
@@ -76,7 +75,6 @@ func (e *Eq) Mode(index int) (string, error) {
 	return possibleModes[val], nil
 }
 
-// SetMode sets the EQ mode for a specific strip or bus (1-based indexing).
 func (e *Eq) SetMode(index int, mode string) error {
 	address := e.AddressFunc(e.baseAddress, index) + "/mode"
 	possibleModes := []string{"peq", "geq", "teq"}
@@ -84,7 +82,7 @@ func (e *Eq) SetMode(index int, mode string) error {
 }
 
 // Gain retrieves the gain for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) Gain(index, band int) (float64, error) {
+func (e *Eq) Gain(index int, band int) (float64, error) {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/g", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
@@ -103,13 +101,13 @@ func (e *Eq) Gain(index, band int) (float64, error) {
 }
 
 // SetGain sets the gain for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) SetGain(index, band int, gain float64) error {
+func (e *Eq) SetGain(index int, band int, gain float64) error {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/g", band)
 	return e.client.SendMessage(address, float32(linSet(-15, 15, gain)))
 }
 
 // Frequency retrieves the frequency for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) Frequency(index, band int) (float64, error) {
+func (e *Eq) Frequency(index int, band int) (float64, error) {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/f", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
@@ -128,13 +126,13 @@ func (e *Eq) Frequency(index, band int) (float64, error) {
 }
 
 // SetFrequency sets the frequency for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) SetFrequency(index, band int, frequency float64) error {
+func (e *Eq) SetFrequency(index int, band int, frequency float64) error {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/f", band)
 	return e.client.SendMessage(address, float32(logSet(20, 20000, frequency)))
 }
 
 // Q retrieves the Q factor for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) Q(index, band int) (float64, error) {
+func (e *Eq) Q(index int, band int) (float64, error) {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/q", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
@@ -153,13 +151,13 @@ func (e *Eq) Q(index, band int) (float64, error) {
 }
 
 // SetQ sets the Q factor for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) SetQ(index, band int, q float64) error {
+func (e *Eq) SetQ(index int, band int, q float64) error {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/q", band)
 	return e.client.SendMessage(address, float32(1.0-logSet(0.3, 10, q)))
 }
 
 // Type retrieves the type for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) Type(index, band int) (string, error) {
+func (e *Eq) Type(index int, band int) (string, error) {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/type", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
@@ -180,7 +178,7 @@ func (e *Eq) Type(index, band int) (string, error) {
 }
 
 // SetType sets the type for a specific EQ band on a strip or bus (1-based indexing).
-func (e *Eq) SetType(index, band int, eqType string) error {
+func (e *Eq) SetType(index int, band int, eqType string) error {
 	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/type", band)
 	possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
 	return e.client.SendMessage(address, int32(indexOf(possibleTypes, eqType)))

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.
+// 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

@@ -2,14 +2,13 @@ package xair
 
 import "fmt"
 
-// HeadAmp represents the headphone amplifier parameters of the mixer.
 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

@@ -2,17 +2,16 @@ package xair
 
 import "fmt"
 
-// Main represents the main output parameters of the mixer.
 type Main struct {
-	client      *client
+	client      *Client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
-// newMainStereo creates a new Main instance for stereo main output.
+// newMainStereo creates a new Main instance for stereo main output
-func newMainStereo(c *client) *Main {
+func newMainStereo(c *Client) *Main {
-	addressFunc := func(fmtString string, _ ...any) string {
+	addressFunc := func(fmtString string, args ...any) string {
 		return fmtString
 	}
 
@@ -24,9 +23,9 @@ func newMainStereo(c *client) *Main {
 	}
 }
 
-// newMainMono creates a new MainMono instance for mono main output (X32 only).
+// 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, _ ...any) string {
+	addressFunc := func(fmtString string, args ...any) string {
 		return fmtString
 	}
 
@@ -38,7 +37,7 @@ func newMainMono(c *client) *Main {
 	}
 }
 
-// Fader requests the current main L/R fader level.
+// Fader requests the current main L/R fader level
 func (m *Main) Fader() (float64, error) {
 	address := m.baseAddress + "/mix/fader"
 	err := m.client.SendMessage(address)
@@ -57,13 +56,13 @@ func (m *Main) Fader() (float64, error) {
 	return mustDbFrom(float64(val)), nil
 }
 
-// SetFader sets the main L/R fader level.
+// SetFader sets the main L/R fader level
 func (m *Main) SetFader(level float64) error {
 	address := m.baseAddress + "/mix/fader"
 	return m.client.SendMessage(address, float32(mustDbInto(level)))
 }
 
-// Mute requests the current main L/R mute status.
+// Mute requests the current main L/R mute status
 func (m *Main) Mute() (bool, error) {
 	address := m.baseAddress + "/mix/on"
 	err := m.client.SendMessage(address)
@@ -82,7 +81,7 @@ func (m *Main) Mute() (bool, error) {
 	return val == 0, nil
 }
 
-// SetMute sets the main L/R mute status.
+// SetMute sets the main L/R mute status
 func (m *Main) SetMute(muted bool) error {
 	address := m.baseAddress + "/mix/on"
 	var value int32

internal/xair/matrix.go

@@ -2,16 +2,15 @@ package xair
 
 import "fmt"
 
-// Matrix represents the matrix parameters of the mixer.
 type Matrix struct {
-	client      *client
+	client      *Client
 	baseAddress string
 	Eq          *Eq
 	Comp        *Comp
 }
 
-// newMatrix creates a new Matrix instance.
+// newMatrix creates a new Matrix instance
-func newMatrix(c *client) *Matrix {
+func newMatrix(c *Client) *Matrix {
 	return &Matrix{
 		client:      c,
 		baseAddress: c.addressMap["matrix"],
@@ -20,7 +19,7 @@ func newMatrix(c *client) *Matrix {
 	}
 }
 
-// Fader requests the current main L/R fader level.
+// Fader requests the current main L/R fader level
 func (m *Matrix) Fader(index int) (float64, error) {
 	address := fmt.Sprintf(m.baseAddress, index) + "/mix/fader"
 	err := m.client.SendMessage(address)
@@ -39,13 +38,13 @@ func (m *Matrix) Fader(index int) (float64, error) {
 	return mustDbFrom(float64(val)), nil
 }
 
-// SetFader sets the matrix fader level.
+// SetFader sets the matrix fader level
 func (m *Matrix) SetFader(index int, level float64) error {
 	address := fmt.Sprintf(m.baseAddress, index) + "/mix/fader"
 	return m.client.SendMessage(address, float32(mustDbInto(level)))
 }
 
-// Mute requests the current matrix mute status.
+// Mute requests the current matrix mute status
 func (m *Matrix) Mute(index int) (bool, error) {
 	address := fmt.Sprintf(m.baseAddress, index) + "/mix/on"
 	err := m.client.SendMessage(address)
@@ -64,7 +63,7 @@ func (m *Matrix) Mute(index int) (bool, error) {
 	return val == 0, nil
 }
 
-// SetMute sets the matrix mute status.
+// SetMute sets the matrix mute status
 func (m *Matrix) SetMute(index int, muted bool) error {
 	address := fmt.Sprintf(m.baseAddress, index) + "/mix/on"
 	var value int32

internal/xair/models.go

@@ -1,9 +1,7 @@
 package xair
 
-// InfoResponse represents the response from the /info OSC address, containing details about the X-Air device.
 type InfoResponse struct {
-	Host     string
+	Host  string
-	Name     string
+	Name  string
-	Model    string
+	Model string
-	Firmware string
 }

internal/xair/option.go

@@ -2,40 +2,36 @@ package xair
 
 import "time"
 
-// EngineOption defines a functional option for configuring the engine.
 type EngineOption func(*engine)
 
-// WithTimeout sets the timeout duration for OSC message responses.
+// WithTimeout sets the timeout duration for OSC message responses
 func WithTimeout(timeout time.Duration) EngineOption {
 	return func(e *engine) {
 		e.timeout = timeout
 	}
 }
 
-// CompOption defines a functional option for configuring Comp parameters.
 type CompOption func(*Comp)
 
-// WithCompAddressFunc allows customization of the OSC address formatting for Comp parameters.
+// WithCompAddressFunc allows customization of the OSC address formatting for Comp parameters
 func WithCompAddressFunc(f func(fmtString string, args ...any) string) CompOption {
 	return func(c *Comp) {
 		c.AddressFunc = f
 	}
 }
 
-// EqOption defines a functional option for configuring Eq parameters.
 type EqOption func(*Eq)
 
-// WithEqAddressFunc allows customization of the OSC address formatting for Eq parameters.
+// WithEqAddressFunc allows customization of the OSC address formatting for Eq parameters
 func WithEqAddressFunc(f func(fmtString string, args ...any) string) EqOption {
 	return func(e *Eq) {
 		e.AddressFunc = f
 	}
 }
 
-// GateOption defines a functional option for configuring Gate parameters.
 type GateOption func(*Gate)
 
-// WithGateAddressFunc allows customization of the OSC address formatting for Gate parameters.
+// WithGateAddressFunc allows customization of the OSC address formatting for Gate parameters
 func WithGateAddressFunc(f func(fmtString string, args ...any) string) GateOption {
 	return func(g *Gate) {
 		g.AddressFunc = f

internal/xair/parser.go

@@ -10,13 +10,14 @@ import (
 	"github.com/hypebeast/go-osc/osc"
 )
 
-type xairParser struct{}
+type xairParser struct {
+}
 
 func newParser() *xairParser {
 	return &xairParser{}
 }
 
-// Parse parses raw bytes into an OSC message with improved error handling.
+// parseOSCMessage parses raw bytes into an OSC message with improved error handling
 func (p *xairParser) Parse(data []byte) (*osc.Message, error) {
 	log.Debug("=== PARSING OSC MESSAGE BEGIN ===")
 	defer log.Debug("=== PARSING OSC MESSAGE END ===")
@@ -46,7 +47,7 @@ func (p *xairParser) Parse(data []byte) (*osc.Message, error) {
 	return msg, nil
 }
 
-// validateOSCData performs basic validation on OSC message data.
+// validateOSCData performs basic validation on OSC message data
 func (p *xairParser) validateOSCData(data []byte) error {
 	if len(data) < 4 {
 		return fmt.Errorf("data too short for OSC message")
@@ -57,7 +58,7 @@ func (p *xairParser) validateOSCData(data []byte) error {
 	return nil
 }
 
-// extractOSCAddress extracts the OSC address from the message data.
+// extractOSCAddress extracts the OSC address from the message data
 func (p *xairParser) extractOSCAddress(data []byte) (address string, nextPos int, err error) {
 	nullPos := bytes.IndexByte(data, 0)
 	if nullPos <= 0 {
@@ -72,11 +73,8 @@ func (p *xairParser) extractOSCAddress(data []byte) (address string, nextPos int
 	return address, nextPos, nil
 }
 
-// extractOSCTypeTags extracts and validates OSC type tags.
+// extractOSCTypeTags extracts and validates OSC type tags
-func (p *xairParser) extractOSCTypeTags(
+func (p *xairParser) extractOSCTypeTags(data []byte, start int) (typeTags string, nextPos int, err error) {
-	data []byte,
-	start int,
-) (typeTags string, nextPos int, err error) { // nolint: unparam
 	if start >= len(data) {
 		return "", start, nil // No type tags available
 	}
@@ -99,13 +97,8 @@ func (p *xairParser) extractOSCTypeTags(
 	return typeTags, nextPos, nil
 }
 
-// parseOSCArguments parses OSC arguments based on type tags.
+// parseOSCArguments parses OSC arguments based on type tags
-func (p *xairParser) parseOSCArguments(
+func (p *xairParser) parseOSCArguments(data []byte, argsStart int, typeTags string, msg *osc.Message) error {
-	data []byte,
-	argsStart int,
-	typeTags string,
-	msg *osc.Message,
-) error { // nolint: unparam
 	argData := data[argsStart:]
 	argNum := 0
 
@@ -145,7 +138,7 @@ func (p *xairParser) parseOSCArguments(
 	return nil
 }
 
-// parseStringArgument parses a string argument from OSC data.
+// parseStringArgument parses a string argument from OSC data
 func (p *xairParser) parseStringArgument(data []byte, msg *osc.Message, argNum int) (int, error) {
 	nullPos := bytes.IndexByte(data, 0)
 	if nullPos < 0 {
@@ -160,7 +153,7 @@ func (p *xairParser) parseStringArgument(data []byte, msg *osc.Message, argNum i
 	return ((nullPos + 4) / 4) * 4, nil
 }
 
-// parseInt32Argument parses an int32 argument from OSC data.
+// parseInt32Argument parses an int32 argument from OSC data
 func (p *xairParser) parseInt32Argument(data []byte, msg *osc.Message, argNum int) (int, error) {
 	if len(data) < 4 {
 		return 0, fmt.Errorf("insufficient data for int32")
@@ -173,7 +166,7 @@ func (p *xairParser) parseInt32Argument(data []byte, msg *osc.Message, argNum in
 	return 4, nil
 }
 
-// parseFloat32Argument parses a float32 argument from OSC data.
+// parseFloat32Argument parses a float32 argument from OSC data
 func (p *xairParser) parseFloat32Argument(data []byte, msg *osc.Message, argNum int) (int, error) {
 	if len(data) < 4 {
 		return 0, fmt.Errorf("insufficient data for float32")
@@ -186,7 +179,7 @@ func (p *xairParser) parseFloat32Argument(data []byte, msg *osc.Message, argNum
 	return 4, nil
 }
 
-// parseBlobArgument parses a blob argument from OSC data.
+// parseBlobArgument parses a blob argument from OSC data
 func (p *xairParser) parseBlobArgument(data []byte, msg *osc.Message, argNum int) (int, error) {
 	if len(data) < 4 {
 		return 0, fmt.Errorf("insufficient data for blob size")
@@ -210,7 +203,7 @@ func (p *xairParser) parseBlobArgument(data []byte, msg *osc.Message, argNum int
 	return ((4 + int(size) + 3) / 4) * 4, nil
 }
 
-// skipUnknownArgument skips an unknown argument type.
+// skipUnknownArgument skips an unknown argument type
 func (p *xairParser) skipUnknownArgument(data []byte) int {
 	// Skip unknown types by moving 4 bytes if available
 	if len(data) >= 4 {

internal/xair/snapshot.go

@@ -2,14 +2,13 @@ package xair
 
 import "fmt"
 
-// Snapshot represents a snapshot of the mixer's state, allowing for saving and recalling settings.
 type Snapshot struct {
-	client      *client
+	client      *Client
 	baseAddress string
 }
 
-// newSnapshot creates a new Snapshot instance.
+// 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

@@ -2,17 +2,16 @@ package xair
 
 import "fmt"
 
-// Strip represents an input channel strip on the mixer.
 type Strip struct {
-	client      *client
+	client      *Client
 	baseAddress string
 	Gate        *Gate
 	Eq          *Eq
 	Comp        *Comp
 }
 
-// newStrip creates a new Strip instance.
+// newStrip creates a new Strip instance
-func newStrip(c *client) *Strip {
+func newStrip(c *Client) *Strip {
 	return &Strip{
 		client:      c,
 		baseAddress: c.addressMap["strip"],
@@ -44,7 +43,7 @@ func (s *Strip) Mute(index int) (bool, error) {
 // SetMute sets the mute status of the specified strip (1-based indexing).
 func (s *Strip) SetMute(strip int, muted bool) error {
 	address := fmt.Sprintf(s.baseAddress, strip) + "/mix/on"
-	var value int32
+	var value int32 = 0
 	if !muted {
 		value = 1
 	}
@@ -77,12 +76,12 @@ func (s *Strip) SetFader(strip int, level float64) error {
 	return s.client.SendMessage(address, float32(mustDbInto(level)))
 }
 
-// Name requests the name for a specific strip.
+// Name requests the name for a specific strip
 func (s *Strip) Name(strip int) (string, error) {
 	address := fmt.Sprintf(s.baseAddress, strip) + "/config/name"
 	err := s.client.SendMessage(address)
 	if err != nil {
-		return "", fmt.Errorf("failed to send strip name request: %w", err)
+		return "", fmt.Errorf("failed to send strip name request: %v", err)
 	}
 
 	msg, err := s.client.ReceiveMessage()
@@ -96,18 +95,18 @@ func (s *Strip) Name(strip int) (string, error) {
 	return val, nil
 }
 
-// SetName sets the name for a specific strip.
+// SetName sets the name for a specific strip
 func (s *Strip) SetName(strip int, name string) error {
 	address := fmt.Sprintf(s.baseAddress, strip) + "/config/name"
 	return s.client.SendMessage(address, name)
 }
 
-// Colour requests the colour for a specific strip.
+// Color requests the color for a specific strip
-func (s *Strip) Colour(strip int) (int32, error) {
+func (s *Strip) Color(strip int) (int32, error) {
-	address := fmt.Sprintf(s.baseAddress, strip) + "/config/colour"
+	address := fmt.Sprintf(s.baseAddress, strip) + "/config/color"
 	err := s.client.SendMessage(address)
 	if err != nil {
-		return 0, fmt.Errorf("failed to send strip colour request: %w", err)
+		return 0, fmt.Errorf("failed to send strip color request: %v", err)
 	}
 
 	msg, err := s.client.ReceiveMessage()
@@ -116,23 +115,23 @@ func (s *Strip) Colour(strip int) (int32, error) {
 	}
 	val, ok := msg.Arguments[0].(int32)
 	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for strip colour value")
+		return 0, fmt.Errorf("unexpected argument type for strip color value")
 	}
 	return val, nil
 }
 
-// SetColor sets the colour for a specific strip (0-15).
+// SetColor sets the color for a specific strip (0-15)
-func (s *Strip) SetColor(strip int, colour int32) error {
+func (s *Strip) SetColor(strip int, color int32) error {
-	address := fmt.Sprintf(s.baseAddress, strip) + "/config/colour"
+	address := fmt.Sprintf(s.baseAddress, strip) + "/config/color"
-	return s.client.SendMessage(address, colour)
+	return s.client.SendMessage(address, color)
 }
 
-// SendLevel requests auxiliary send level for a send destination.
+// SendLevel requests the sends level for a mixbus.
-func (s *Strip) SendLevel(strip, bus int) (float64, error) {
+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)
 	if err != nil {
-		return 0, fmt.Errorf("failed to send strip send level request: %w", err)
+		return 0, fmt.Errorf("failed to send strip send level request: %v", err)
 	}
 
 	msg, err := s.client.ReceiveMessage()
@@ -146,8 +145,8 @@ func (s *Strip) SendLevel(strip, bus int) (float64, error) {
 	return mustDbFrom(float64(val)), nil
 }
 
-// SetSendLevel sets the auxiliary send level for a send destination.
+// SetSendLevel sets the sends level for a mixbus.
-func (s *Strip) SetSendLevel(strip, bus int, level float64) error {
+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)))
 }

internal/xair/util.go

@@ -2,20 +2,20 @@ package xair
 
 import "math"
 
-func linGet(minVal, maxVal, value float64) float64 {
+func linGet(min float64, max float64, value float64) float64 {
-	return minVal + (maxVal-minVal)*value
+	return min + (max-min)*value
 }
 
-func linSet(minVal, maxVal, value float64) float64 {
+func linSet(min float64, max float64, value float64) float64 {
-	return (value - minVal) / (maxVal - minVal)
+	return (value - min) / (max - min)
 }
 
-func logGet(minVal, maxVal, value float64) float64 {
+func logGet(min float64, max float64, value float64) float64 {
-	return minVal * math.Exp(math.Log(maxVal/minVal)*value)
+	return min * math.Exp(math.Log(max/min)*value)
 }
 
-func logSet(minVal, maxVal, value float64) float64 {
+func logSet(min float64, max float64, value float64) float64 {
-	return math.Log(value/minVal) / math.Log(maxVal/minVal)
+	return math.Log(value/min) / math.Log(max/min)
 }
 
 func mustDbInto(db float64) float64 {
@@ -52,7 +52,7 @@ func mustDbFrom(level float64) float64 {
 	}
 }
 
-func toFixed(num float64, precision int) float64 { // nolint: unparam
+func toFixed(num float64, precision int) float64 {
 	output := math.Pow(10, float64(precision))
 	return float64(math.Round(num*output)) / output
 }

x32-help.md

@@ -12,9 +12,10 @@ Flags:
   -v, --version               Print x32-cli version information and quit
 
 Commands:
-  completion    Generate shell completion scripts.
+  completion (c)    Generate shell completion scripts.
-  info          Print mixer information.
+
-  raw           Send raw OSC messages to the mixer.
+Raw
+  raw    Send raw OSC messages to the mixer.
 
 Main
   main mute              Get or set the mute state of the Main L/R output.

xair-help.md

@@ -12,9 +12,10 @@ Flags:
   -v, --version               Print xair-cli version information and quit
 
 Commands:
-  completion    Generate shell completion scripts.
+  completion (c)    Generate shell completion scripts.
-  info          Print mixer information.
+
-  raw           Send raw OSC messages to the mixer.
+Raw
+  raw    Send raw OSC messages to the mixer.
 
 Main
   main mute              Get or set the mute state of the Main L/R output.