upd README

raw doesn't need to be a command group
fix `nil pointer deference` for set commands
2026-04-18 06:43:33 +00:00 · 2026-02-05 04:02:01 +00:00 · 2026-02-05 04:01:34 +00:00 · 2026-02-05 03:55:08 +00:00 · 2026-02-05 03:54:53 +00:00 · 2026-02-05 03:36:22 +00:00
30 changed files with 2894 additions and 1146 deletions
--- a/README.md
+++ b/README.md
@@ -1,29 +1,139 @@
-# Xair-CLI
+# xair-cli
+
+### Installation
+
+```console
+go install github.com/onyx-and-iris/xair-cli@latest
+```

 ### Use

 ```console
-xair-cli is a command-line tool that allows users to send OSC messages
-to Behringer X Air mixers for remote control and configuration. It supports
-various commands to manage mixer settings directly from the terminal.
+Usage: xair-cli <command> [flags]

-Usage:
-  xair-cli [flags]
-  xair-cli [command]
-
-Available Commands:
-  bus         Commands to control individual buses
-  completion  Generate the autocompletion script for the specified shell
-  help        Help about any command
-  main        Commands to control the main output
-  strip       Commands to control individual strips
+A CLI to control Behringer X-Air mixers.

 Flags:
-  -h, --help              help for xair-cli
-  -H, --host string       host address of the X Air mixer (default "mixer.local")
-  -k, --kind string       Kind of mixer (xair, x32) (default "xair")
-  -l, --loglevel string   Log level (debug, info, warn, error, fatal, panic) (default "warn")
-  -p, --port int          Port number of the X Air mixer (default 10024)
+  -h, --help                  Show context-sensitive help.
+      --host="mixer.local"    The host of the X-Air device ($XAIR_CLI_HOST).
+      --port=10024            The port of the X-Air device ($XAIR_CLI_PORT).
+      --kind="xr18"           The kind of the X-Air device ($XAIR_CLI_KIND).
+  -v, --version               Print gobs-cli version information and quit

-Use "xair-cli [command] --help" for more information about a command.
+Commands:
+  completion (c)    Generate shell completion scripts.
+
+Raw
+  raw    Send raw OSC messages to the mixer.
+
+Main
+  main mute       Get or set the mute state of the Main L/R output.
+  main fader      Get or set the fader level of the Main L/R output.
+  main fadein     Get or set the fade-in time of the Main L/R output.
+  main fadeout    Get or set the fade-out time of the Main L/R output.
+
+Strip
+  strip <index> mute              Get or set the mute state of the strip.
+  strip <index> fader             Get or set the fader level of the strip.
+  strip <index> fadein            Fade in the strip over a specified duration.
+  strip <index> fadeout           Fade out the strip over a specified duration.
+  strip <index> send              Get or set the send level for a specific bus.
+  strip <index> name              Get or set the name of the strip.
+  strip <index> gate on           Get or set the gate on/off state of the strip.
+  strip <index> gate mode         Get or set the gate mode of the strip.
+  strip <index> gate threshold    Get or set the gate threshold of the strip.
+  strip <index> gate range        Get the gate range of the strip.
+  strip <index> gate attack       Get or set the gate attack time of the strip.
+  strip <index> gate hold         Get or set the gate hold time of the strip.
+  strip <index> gate release      Get or set the gate release time of the strip.
+  strip <index> eq on             Get or set the EQ on/off state of the strip.
+  strip <index> eq <band> gain    Get or set the gain of the EQ band.
+  strip <index> eq <band> freq    Get or set the frequency of the EQ band.
+  strip <index> eq <band> q       Get or set the Q factor of the EQ band.
+  strip <index> eq <band> type    Get or set the type of the EQ band.
+  strip <index> comp on           Get or set the compressor on/off state of the strip.
+  strip <index> comp mode         Get or set the compressor mode of the strip.
+  strip <index> comp threshold    Get or set the compressor threshold of the strip.
+  strip <index> comp ratio        Get or set the compressor ratio of the strip.
+  strip <index> comp mix          Get or set the compressor mix of the strip.
+  strip <index> comp makeup       Get or set the compressor makeup gain of the strip.
+  strip <index> comp attack       Get or set the compressor attack time of the strip.
+  strip <index> comp hold         Get or set the compressor hold time of the strip.
+  strip <index> comp release      Get or set the compressor release time of the strip.
+
+Bus
+  bus <index> mute              Get or set the mute state of the bus.
+  bus <index> fader             Get or set the fader level of the bus.
+  bus <index> fadein            Fade in the bus over a specified duration.
+  bus <index> fadeout           Fade out the bus over a specified duration.
+  bus <index> name              Get or set the name of the bus.
+  bus <index> eq on             Get or set the EQ on/off state of the bus.
+  bus <index> eq mode           Get or set the EQ mode of the bus (graphic or parametric).
+  bus <index> eq <band> gain    Get or set the gain of the EQ band.
+  bus <index> eq <band> freq    Get or set the frequency of the EQ band.
+  bus <index> eq <band> q       Get or set the Q factor of the EQ band.
+  bus <index> eq <band> type    Get or set the type of the EQ band (bell, high shelf, low shelf, high pass, low pass).
+  bus <index> comp on           Get or set the compressor on/off state of the bus.
+  bus <index> comp mode         Get or set the compressor mode of the bus (standard, vintage, or modern).
+  bus <index> comp threshold    Get or set the compressor threshold of the bus (in dB).
+  bus <index> comp ratio        Get or set the compressor ratio of the bus.
+  bus <index> comp mix          Get or set the compressor mix level of the bus (in %).
+  bus <index> comp makeup       Get or set the compressor makeup gain of the bus (in dB).
+  bus <index> comp attack       Get or set the compressor attack time of the bus (in ms).
+  bus <index> comp hold         Get or set the compressor hold time of the bus (in ms).
+  bus <index> comp release      Get or set the compressor release time of the bus (in ms).
+
+Headamp
+  headamp <index> gain       Get or set the gain of the headamp.
+  headamp <index> phantom    Get or set the phantom power state of the headamp.
+
+Run "xair-cli <command> --help" for more information on a command.
 ```
+
+### Examples
+
+*Fade out main LR all the way to -∞ over a 5s duration*
+
+```console
+xair-cli main fadeout
+```
+
+*enable phantom power and set the gain to 28.0dB over a 10s duration for headamp (strip) 09*
+```console
+xair-cli headamp 9 phantom on
+
+xair-cli headamp 9 gain --duration 10s 18.0
+```
+
+*set strip 09 send level for bus 5 to -18.0dB*
+```console
+xair-cli strip 9 send 5 -- -18.0
+```
+
+*enable eq for strip 01*
+```console
+xair-cli strip 1 eq on true
+```
+
+*rename bus 01 to 'vocal mix'*
+```console
+xair-cli bus 1 name 'vocal mix'
+```
+
+*Send a raw OSC message to the mixer*
+```console
+xair-cli raw /xinfo
+
+xair-cli raw /ch/01/config/name 'rode podmic'
+xair-cli raw /ch/01/config/name
+```
+
+
+### License
+
+`xair-cli` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+
+### Notes
+
+For an alternative, python implementation consider checking out [dc-xair-cli](https://pypi.org/project/dc-xair-cli/). It supports some operations like batch commands and network discovery which this CLI doesn't (and I have no plans to implement them).
--- a/bus.go
+++ b/bus.go
@@ -0,0 +1,505 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/alecthomas/kong"
+)
+
+type BusCmdGroup struct {
+	Index struct {
+		Index   int           `arg:"" help:"The index of the bus. (1-based indexing)"`
+		Mute    BusMuteCmd    `       help:"Get or set the mute state of the bus." cmd:""`
+		Fader   BusFaderCmd   `     help:"Get or set the fader level of the bus." cmd:""`
+		Fadein  BusFadeinCmd  `      help:"Fade in the bus over a specified duration." cmd:""`
+		Fadeout BusFadeoutCmd `     help:"Fade out the bus over a specified duration." cmd:""`
+		Name    BusNameCmd    `       help:"Get or set the name of the bus." cmd:""`
+
+		Eq   BusEqCmdGroup   `       help:"Commands related to the bus EQ." cmd:"eq"`
+		Comp BusCompCmdGroup `     help:"Commands related to the bus compressor." cmd:"comp"`
+	} `arg:"" help:"The index of the bus."`
+}
+
+type BusMuteCmd struct {
+	State *string `arg:"" help:"The mute state to set (true or false). If not provided, the current mute state will be returned." optional:"" enum:"true,false"`
+}
+
+func (cmd *BusMuteCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.Bus.Mute(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d mute state: %t\n", bus.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type BusFaderCmd struct {
+	Level *float64 `arg:"" help:"The fader level to set (in dB). If not provided, the current fader level will be returned."`
+}
+
+func (cmd *BusFaderCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Level == nil {
+		resp, err := ctx.Client.Bus.Fader(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d fader level: %.2f dB\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.SetFader(bus.Index.Index, *cmd.Level); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d fader level set to: %.2f dB\n", bus.Index.Index, *cmd.Level)
+	return nil
+}
+
+type BusFadeinCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-in effect." default:"5s"`
+	Target   float64       `        help:"The target fader level (in dB)."     default:"0.0" arg:""`
+}
+
+func (cmd *BusFadeinCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	currentLevel, err := ctx.Client.Bus.Fader(bus.Index.Index)
+	if err != nil {
+		return fmt.Errorf("failed to get current fader level: %w", err)
+	}
+
+	if currentLevel >= cmd.Target {
+		return fmt.Errorf(
+			"current fader level (%.2f dB) is already at or above the target level (%.2f dB)",
+			currentLevel,
+			cmd.Target,
+		)
+	}
+
+	totalSteps := float64(cmd.Target - currentLevel)
+	stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+	for currentLevel < cmd.Target {
+		currentLevel += totalSteps / float64(cmd.Duration.Seconds()*1000/stepDuration.Seconds())
+		if currentLevel > cmd.Target {
+			currentLevel = cmd.Target
+		}
+
+		if err := ctx.Client.Bus.SetFader(bus.Index.Index, currentLevel); err != nil {
+			return fmt.Errorf("failed to set fader level: %w", err)
+		}
+		time.Sleep(stepDuration)
+	}
+
+	fmt.Fprintf(ctx.Out, "Bus %d fade-in complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
+	return nil
+}
+
+type BusFadeoutCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-out effect." default:"5s"`
+	Target   float64       `        help:"The target fader level (in dB)."      default:"-90.0" arg:""`
+}
+
+func (cmd *BusFadeoutCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	currentLevel, err := ctx.Client.Bus.Fader(bus.Index.Index)
+	if err != nil {
+		return fmt.Errorf("failed to get current fader level: %w", err)
+	}
+
+	if currentLevel <= cmd.Target {
+		return fmt.Errorf(
+			"current fader level (%.2f dB) is already at or below the target level (%.2f dB)",
+			currentLevel,
+			cmd.Target,
+		)
+	}
+
+	totalSteps := float64(currentLevel - cmd.Target)
+	stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+	for currentLevel > cmd.Target {
+		currentLevel -= totalSteps / float64(cmd.Duration.Seconds()*1000/stepDuration.Seconds())
+		if currentLevel < cmd.Target {
+			currentLevel = cmd.Target
+		}
+
+		if err := ctx.Client.Bus.SetFader(bus.Index.Index, currentLevel); err != nil {
+			return fmt.Errorf("failed to set fader level: %w", err)
+		}
+		time.Sleep(stepDuration)
+	}
+
+	fmt.Fprintf(ctx.Out, "Bus %d fade-out complete. Final level: %.2f dB\n", bus.Index.Index, cmd.Target)
+	return nil
+}
+
+type BusNameCmd struct {
+	Name *string `arg:"" help:"The name to set for the bus. If not provided, the current name will be returned."`
+}
+
+func (cmd *BusNameCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Name == nil {
+		resp, err := ctx.Client.Bus.Name(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d name: %s\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.SetName(bus.Index.Index, *cmd.Name); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d name set to: %s\n", bus.Index.Index, *cmd.Name)
+	return nil
+}
+
+type BusEqCmdGroup struct {
+	On   BusEqOnCmd   `help:"Get or set the EQ on/off state of the bus."                 cmd:"on"`
+	Mode BusEqModeCmd `help:"Get or set the EQ mode of the bus (graphic or parametric)." cmd:"mode"`
+	Band struct {
+		Band int              `arg:"" help:"The EQ band number."`
+		Gain BusEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:"gain"`
+		Freq BusEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:"freq"`
+		Q    BusEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:"q"`
+		Type BusEqBandTypeCmd `help:"Get or set the type of the EQ band (bell, high shelf, low shelf, high pass, low pass)." cmd:"type"`
+	} `help:"Commands for controlling a specific EQ band of the bus."               arg:""`
+}
+
+func (cmd *BusEqCmdGroup) Validate(ctx kong.Context) error {
+	if cmd.Band.Band < 1 || cmd.Band.Band > 6 {
+		return fmt.Errorf("EQ band number must be between 1 and 6")
+	}
+	return nil
+}
+
+type BusEqOnCmd struct {
+	State *string `arg:"" help:"The EQ on/off state to set (true or false). If not provided, the current EQ state will be returned." optional:"" enum:"true,false"`
+}
+
+func (cmd *BusEqOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.Bus.Eq.On(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ on state: %t\n", bus.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type BusEqModeCmd struct {
+	Mode *string `arg:"" help:"The EQ mode to set (graphic or parametric). If not provided, the current EQ mode will be returned." optional:"" enum:"peq,geq,teq"`
+}
+
+func (cmd *BusEqModeCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Mode == nil {
+		resp, err := ctx.Client.Bus.Eq.Mode(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ mode: %s\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Eq.SetMode(bus.Index.Index, *cmd.Mode); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d EQ mode set to: %s\n", bus.Index.Index, *cmd.Mode)
+	return nil
+}
+
+type BusEqBandGainCmd struct {
+	Gain *float64 `arg:"" help:"The gain to set for the EQ band (in dB). If not provided, the current gain will be returned."`
+}
+
+func (cmd *BusEqBandGainCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
+	if cmd.Gain == nil {
+		resp, err := ctx.Client.Bus.Eq.Gain(bus.Index.Index, busEq.Band.Band)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain: %.2f dB\n", bus.Index.Index, busEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Eq.SetGain(bus.Index.Index, busEq.Band.Band, *cmd.Gain); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d gain set to: %.2f dB\n", bus.Index.Index, busEq.Band.Band, *cmd.Gain)
+	return nil
+}
+
+type BusEqBandFreqCmd struct {
+	Freq *float64 `arg:"" help:"The frequency to set for the EQ band (in Hz). If not provided, the current frequency will be returned."`
+}
+
+func (cmd *BusEqBandFreqCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
+	if cmd.Freq == nil {
+		resp, err := ctx.Client.Bus.Eq.Frequency(bus.Index.Index, busEq.Band.Band)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Eq.SetFrequency(bus.Index.Index, busEq.Band.Band, *cmd.Freq); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d frequency set to: %.2f Hz\n", bus.Index.Index, busEq.Band.Band, *cmd.Freq)
+	return nil
+}
+
+type BusEqBandQCmd struct {
+	Q *float64 `arg:"" help:"The Q factor to set for the EQ band. If not provided, the current Q factor will be returned."`
+}
+
+func (cmd *BusEqBandQCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
+	if cmd.Q == nil {
+		resp, err := ctx.Client.Bus.Eq.Q(bus.Index.Index, busEq.Band.Band)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor: %.2f\n", bus.Index.Index, busEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Eq.SetQ(bus.Index.Index, busEq.Band.Band, *cmd.Q); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d Q factor set to: %.2f\n", bus.Index.Index, busEq.Band.Band, *cmd.Q)
+	return nil
+}
+
+type BusEqBandTypeCmd struct {
+	Type *string `arg:"" help:"The type to set for the EQ band (bell, high shelf, low shelf, high pass, low pass). If not provided, the current type will be returned." optional:"" enum:"lcut,lshv,peq,veq,hshv,hcut"`
+}
+
+func (cmd *BusEqBandTypeCmd) Run(ctx *context, bus *BusCmdGroup, busEq *BusEqCmdGroup) error {
+	if cmd.Type == nil {
+		resp, err := ctx.Client.Bus.Eq.Type(bus.Index.Index, busEq.Band.Band)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type: %s\n", bus.Index.Index, busEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Eq.SetType(bus.Index.Index, busEq.Band.Band, *cmd.Type); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d EQ band %d type set to: %s\n", bus.Index.Index, busEq.Band.Band, *cmd.Type)
+	return nil
+}
+
+type BusCompCmdGroup struct {
+	On        BusCompOnCmd        `help:"Get or set the compressor on/off state of the bus."                        cmd:"on"`
+	Mode      BusCompModeCmd      `help:"Get or set the compressor mode of the bus (standard, vintage, or modern)." cmd:"mode"`
+	Threshold BusCompThresholdCmd `help:"Get or set the compressor threshold of the bus (in dB)."                   cmd:"threshold"`
+	Ratio     BusCompRatioCmd     `help:"Get or set the compressor ratio of the bus."                               cmd:"ratio"`
+	Mix       BusCompMixCmd       `help:"Get or set the compressor mix level of the bus (in %)."                    cmd:"mix"`
+	Makeup    BusCompMakeupCmd    `help:"Get or set the compressor makeup gain of the bus (in dB)."                 cmd:"makeup"`
+	Attack    BusCompAttackCmd    `help:"Get or set the compressor attack time of the bus (in ms)."                 cmd:"attack"`
+	Hold      BusCompHoldCmd      `help:"Get or set the compressor hold time of the bus (in ms)."                   cmd:"hold"`
+	Release   BusCompReleaseCmd   `help:"Get or set the compressor release time of the bus (in ms)."                cmd:"release"`
+}
+
+type BusCompOnCmd struct {
+	State *string `arg:"" help:"The compressor on/off state to set (true or false). If not provided, the current compressor state will be returned." optional:"" enum:"true,false"`
+}
+
+func (cmd *BusCompOnCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.Bus.Comp.On(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor on state: %t\n", bus.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type BusCompModeCmd struct {
+	Mode *string `arg:"" help:"The compressor mode to set (standard, vintage, or modern). If not provided, the current compressor mode will be returned." optional:"" enum:"comp,exp"`
+}
+
+func (cmd *BusCompModeCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Mode == nil {
+		resp, err := ctx.Client.Bus.Comp.Mode(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor mode: %s\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetMode(bus.Index.Index, *cmd.Mode); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor mode set to: %s\n", bus.Index.Index, *cmd.Mode)
+	return nil
+}
+
+type BusCompThresholdCmd struct {
+	Threshold *float64 `arg:"" help:"The compressor threshold to set (in dB). If not provided, the current compressor threshold will be returned."`
+}
+
+func (cmd *BusCompThresholdCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Threshold == nil {
+		resp, err := ctx.Client.Bus.Comp.Threshold(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor threshold: %.2f dB\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetThreshold(bus.Index.Index, *cmd.Threshold); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor threshold set to: %.2f dB\n", bus.Index.Index, *cmd.Threshold)
+	return nil
+}
+
+type BusCompRatioCmd struct {
+	Ratio *float64 `arg:"" help:"The compressor ratio to set. If not provided, the current compressor ratio will be returned."`
+}
+
+func (cmd *BusCompRatioCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Ratio == nil {
+		resp, err := ctx.Client.Bus.Comp.Ratio(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor ratio: %.2f\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetRatio(bus.Index.Index, *cmd.Ratio); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor ratio set to: %.2f\n", bus.Index.Index, *cmd.Ratio)
+	return nil
+}
+
+type BusCompMixCmd struct {
+	Mix *float64 `arg:"" help:"The compressor mix level to set (in %). If not provided, the current compressor mix level will be returned."`
+}
+
+func (cmd *BusCompMixCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Mix == nil {
+		resp, err := ctx.Client.Bus.Comp.Mix(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor mix level: %.2f%%\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetMix(bus.Index.Index, *cmd.Mix); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor mix level set to: %.2f%%\n", bus.Index.Index, *cmd.Mix)
+	return nil
+}
+
+type BusCompMakeupCmd struct {
+	Makeup *float64 `arg:"" help:"The compressor makeup gain to set (in dB). If not provided, the current compressor makeup gain will be returned."`
+}
+
+func (cmd *BusCompMakeupCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Makeup == nil {
+		resp, err := ctx.Client.Bus.Comp.Makeup(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor makeup gain: %.2f dB\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetMakeup(bus.Index.Index, *cmd.Makeup); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor makeup gain set to: %.2f dB\n", bus.Index.Index, *cmd.Makeup)
+	return nil
+}
+
+type BusCompAttackCmd struct {
+	Attack *float64 `arg:"" help:"The compressor attack time to set (in ms). If not provided, the current compressor attack time will be returned."`
+}
+
+func (cmd *BusCompAttackCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Attack == nil {
+		resp, err := ctx.Client.Bus.Comp.Attack(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor attack time: %.2f ms\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetAttack(bus.Index.Index, *cmd.Attack); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor attack time set to: %.2f ms\n", bus.Index.Index, *cmd.Attack)
+	return nil
+}
+
+type BusCompHoldCmd struct {
+	Hold *float64 `arg:"" help:"The compressor hold time to set (in ms). If not provided, the current compressor hold time will be returned."`
+}
+
+func (cmd *BusCompHoldCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Hold == nil {
+		resp, err := ctx.Client.Bus.Comp.Hold(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor hold time: %.2f ms\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetHold(bus.Index.Index, *cmd.Hold); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor hold time set to: %.2f ms\n", bus.Index.Index, *cmd.Hold)
+	return nil
+}
+
+type BusCompReleaseCmd struct {
+	Release *float64 `arg:"" help:"The compressor release time to set (in ms). If not provided, the current compressor release time will be returned."`
+}
+
+func (cmd *BusCompReleaseCmd) Run(ctx *context, bus *BusCmdGroup) error {
+	if cmd.Release == nil {
+		resp, err := ctx.Client.Bus.Comp.Release(bus.Index.Index)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(ctx.Out, "Bus %d compressor release time: %.2f ms\n", bus.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Bus.Comp.SetRelease(bus.Index.Index, *cmd.Release); err != nil {
+		return err
+	}
+	fmt.Fprintf(ctx.Out, "Bus %d compressor release time set to: %.2f ms\n", bus.Index.Index, *cmd.Release)
+	return nil
+}
--- a/cmd/bus.go
+++ b/cmd/bus.go
@@ -1,239 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/spf13/cobra"
-)
-
-// busCmd represents the bus command
-var busCmd = &cobra.Command{
-	Use:   "bus",
-	Short: "Commands to control individual buses",
-	Long:  `Commands to control individual buses of the XAir mixer, including mute status.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("bus called")
-	},
-}
-
-// busMuteCmd represents the bus mute command
-var busMuteCmd = &cobra.Command{
-	Use:   "mute",
-	Short: "Get or set the bus mute status",
-	Long:  `Get or set the mute status of a specific bus.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) < 2 {
-			cmd.PrintErrln("Please provide bus number and mute status (true/false)")
-			return
-		}
-
-		busNum := mustConvToInt(args[0])
-		var muted bool
-		switch args[1] {
-		case "true", "1":
-			muted = true
-		case "false", "0":
-			muted = false
-		default:
-			cmd.PrintErrln("Invalid mute status. Use true/false or 1/0")
-			return
-		}
-
-		err := client.SetBusMute(busNum, muted)
-		if err != nil {
-			cmd.PrintErrln("Error setting bus mute status:", err)
-			return
-		}
-		cmd.Printf("Bus %d mute set to %v\n", busNum, muted)
-	},
-}
-
-// busFaderCmd represents the bus fader command
-var busFaderCmd = &cobra.Command{
-	Use:   "fader",
-	Short: "Get or set the bus fader level",
-	Long:  `Get or set the fader level of a specific bus.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) == 1 {
-			busNum := mustConvToInt(args[0])
-			level, err := client.BusFader(busNum)
-			if err != nil {
-				cmd.PrintErrln("Error getting bus fader level:", err)
-				return
-			}
-			cmd.Printf("Bus %d fader level: %.1f dB\n", busNum, level)
-			return
-		}
-
-		if len(args) < 2 {
-			cmd.PrintErrln("Please provide bus number and fader level (in dB)")
-			return
-		}
-
-		busNum := mustConvToInt(args[0])
-		level := mustConvToFloat64(args[1])
-
-		err := client.SetBusFader(busNum, level)
-		if err != nil {
-			cmd.PrintErrln("Error setting bus fader level:", err)
-			return
-		}
-		cmd.Printf("Bus %d fader set to %.2f dB\n", busNum, level)
-	},
-}
-
-// busFadeOutCmd represents the bus fade out command
-var busFadeOutCmd = &cobra.Command{
-	Use:   "fadeout",
-	Short: "Fade out the bus fader over a specified duration",
-	Long: `Fade out the bus fader to minimum level over a specified duration in seconds.
-
-For example:
-  # Fade out bus 1 over 5 seconds
-  xair-cli bus fadeout 1 --duration 5
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) < 1 {
-			cmd.PrintErrln("Please provide bus number")
-			return
-		}
-
-		busIndex := mustConvToInt(args[0])
-
-		duration, err := cmd.Flags().GetFloat64("duration")
-		if err != nil {
-			cmd.PrintErrln("Error getting duration flag:", err)
-			return
-		}
-
-		target := -90.0
-		if len(args) > 1 {
-			target = mustConvToFloat64(args[1])
-		}
-
-		currentFader, err := client.BusFader(busIndex)
-		if err != nil {
-			cmd.PrintErrln("Error getting current bus fader level:", err)
-			return
-		}
-
-		// Calculate total steps needed to reach target dB
-		totalSteps := float64(currentFader - target)
-		if totalSteps <= 0 {
-			cmd.Println("Bus is already faded out")
-			return
-		}
-
-		stepDelay := time.Duration(duration*1000/totalSteps) * time.Millisecond
-
-		for currentFader > target {
-			currentFader -= 1.0
-			err := client.SetBusFader(busIndex, currentFader)
-			if err != nil {
-				cmd.PrintErrln("Error setting bus fader level:", err)
-				return
-			}
-			time.Sleep(stepDelay)
-		}
-
-		cmd.Println("Bus fade out completed")
-	},
-}
-
-// BusFadeInCmd represents the bus fade in command
-var busFadeInCmd = &cobra.Command{
-	Use:   "fadein",
-	Short: "Fade in the bus fader over a specified duration",
-	Long: `Fade in the bus fader to maximum level over a specified duration in seconds.
-
-For example:
-  # Fade in bus 1 over 5 seconds
-  xair-cli bus fadein 1 --duration 5
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) < 1 {
-			cmd.PrintErrln("Please provide bus number")
-			return
-		}
-
-		busIndex := mustConvToInt(args[0])
-
-		duration, err := cmd.Flags().GetFloat64("duration")
-		if err != nil {
-			cmd.PrintErrln("Error getting duration flag:", err)
-			return
-		}
-
-		target := 0.0
-		if len(args) > 1 {
-			target = mustConvToFloat64(args[1])
-		}
-
-		currentFader, err := client.BusFader(busIndex)
-		if err != nil {
-			cmd.PrintErrln("Error getting current bus fader level:", err)
-			return
-		}
-
-		// Calculate total steps needed to reach target dB
-		totalSteps := float64(target - currentFader)
-		if totalSteps <= 0 {
-			cmd.Println("Bus is already at or above target level")
-			return
-		}
-
-		stepDelay := time.Duration(duration*1000/totalSteps) * time.Millisecond
-
-		for currentFader < target {
-			currentFader += 1.0
-			err := client.SetBusFader(busIndex, currentFader)
-			if err != nil {
-				cmd.PrintErrln("Error setting bus fader level:", err)
-				return
-			}
-			time.Sleep(stepDelay)
-		}
-
-		cmd.Println("Bus fade in completed")
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(busCmd)
-
-	busCmd.AddCommand(busMuteCmd)
-
-	busCmd.AddCommand(busFaderCmd)
-	busCmd.AddCommand(busFadeOutCmd)
-	busFadeOutCmd.Flags().Float64P("duration", "d", 5, "Duration for fade out in seconds")
-	busCmd.AddCommand(busFadeInCmd)
-	busFadeInCmd.Flags().Float64P("duration", "d", 5, "Duration for fade in in seconds")
-}
--- a/cmd/context.go
+++ b/cmd/context.go
@@ -1,23 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"context"
-
-	"github.com/onyx-and-iris/xair-cli/internal/xair"
-)
-
-type clientKey string
-
-func WithContext(ctx context.Context, client *xair.Client) context.Context {
-	return context.WithValue(ctx, clientKey("oscClient"), client)
-}
-
-func ClientFromContext(ctx context.Context) *xair.Client {
-	if client, ok := ctx.Value(clientKey("oscClient")).(*xair.Client); ok {
-		return client
-	}
-	return nil
-}
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -1,241 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"time"
-
-	"github.com/spf13/cobra"
-)
-
-// mainCmd represents the main command
-var mainCmd = &cobra.Command{
-	Use:   "main",
-	Short: "Commands to control the main output",
-	Long:  `Commands to control the main output of the XAir mixer, including fader level and mute status.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		cmd.Help()
-	},
-}
-
-var mainMuteCmd = &cobra.Command{
-	Use:   "mute",
-	Short: "Get or set the main LR mute status",
-	Long: `Get or set the main L/R mute status.
-
-If no argument is provided, the current mute status is retrieved.
-If "true" or "1" is provided as an argument, the main output is muted.
-If "false" or "0" is provided, the main output is unmuted.
-
-For example:
-  # Get the current main LR mute status
-  xair-cli main mute
-
-  # Mute the main output
-  xair-cli main mute true
-
-  # Unmute the main output
-  xair-cli main mute false
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) == 0 {
-			resp, err := client.MainLRMute()
-			if err != nil {
-				cmd.PrintErrln("Error getting main LR mute status:", err)
-				return
-			}
-			cmd.Printf("Main LR mute: %v\n", resp)
-			return
-		}
-
-		var muted bool
-		if args[0] == "true" || args[0] == "1" {
-			muted = true
-		}
-
-		err := client.SetMainLRMute(muted)
-		if err != nil {
-			cmd.PrintErrln("Error setting main LR mute status:", err)
-			return
-		}
-		cmd.Println("Main LR mute status set successfully")
-	},
-}
-
-var mainFaderCmd = &cobra.Command{
-	Use:   "fader",
-	Short: "Set or get the main LR fader level",
-	Long: `Set or get the main L/R fader level in dB.
-
-If no argument is provided, the current fader level is retrieved.
-If a dB value is provided as an argument, the fader level is set to that value.
-
-For example:
-  # Get the current main LR fader level
-  xair-cli main fader
-
-  # Set the main LR fader level to -10.0 dB
-  xair-cli main fader -- -10.0
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) == 0 {
-			resp, err := client.MainLRFader()
-			if err != nil {
-				cmd.PrintErrln("Error getting main LR fader:", err)
-				return
-			}
-			cmd.Printf("Main LR fader: %.1f dB\n", resp)
-			return
-		}
-
-		err := client.SetMainLRFader(mustConvToFloat64(args[0]))
-		if err != nil {
-			cmd.PrintErrln("Error setting main LR fader:", err)
-			return
-		}
-		cmd.Println("Main LR fader set successfully")
-	},
-}
-
-var mainFadeOutCmd = &cobra.Command{
-	Use:   "fadeout [target_db]",
-	Short: "Fade out the main output",
-	Long: `Fade out the main output over a specified duration.
-For example:
-
-xair-cli main fadeout --duration 10 -- -20.0
-xair-cli main fadeout -- -90.0  # Uses default 5 second duration
-
-This command will fade out the main output to the specified dB level.
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		duration, err := cmd.Flags().GetFloat64("duration")
-		if err != nil {
-			cmd.PrintErrln("Error getting duration flag:", err)
-			return
-		}
-
-		// Default target for fadeout
-		target := -90.0
-		if len(args) > 0 {
-			target = mustConvToFloat64(args[0])
-		}
-
-		currentFader, err := client.MainLRFader()
-		if err != nil {
-			cmd.PrintErrln("Error getting current main LR fader:", err)
-			return
-		}
-
-		// Calculate total steps needed to reach target dB
-		totalSteps := float64(currentFader - target)
-		if totalSteps <= 0 {
-			cmd.Println("Main output is already faded out")
-			return
-		}
-
-		// Calculate delay per step to achieve exact duration
-		stepDelay := time.Duration(duration*1000/totalSteps) * time.Millisecond
-
-		for currentFader > target {
-			currentFader -= 1.0
-			err = client.SetMainLRFader(currentFader)
-			if err != nil {
-				cmd.PrintErrln("Error setting main LR fader:", err)
-				return
-			}
-			time.Sleep(stepDelay)
-		}
-		cmd.Println("Main output faded out successfully")
-	},
-}
-
-var mainFadeInCmd = &cobra.Command{
-	Use:   "fadein [target_db]",
-	Short: "Fade in the main output",
-	Long: `Fade in the main output over a specified duration.
-
-For example:
-
-xair-cli main fadein --duration 10 -- -6.0
-xair-cli main fadein -- -0.0  # Uses default 5 second duration
-
-This command will fade in the main output to the specified dB level.
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		duration, err := cmd.Flags().GetFloat64("duration")
-		if err != nil {
-			cmd.PrintErrln("Error getting duration flag:", err)
-			return
-		}
-
-		target := 0.0
-		if len(args) > 0 {
-			target = mustConvToFloat64(args[0])
-		}
-
-		currentFader, err := client.MainLRFader()
-		if err != nil {
-			cmd.PrintErrln("Error getting current main LR fader:", err)
-			return
-		}
-
-		// Calculate total steps needed to reach target dB
-		totalSteps := float64(target - currentFader)
-		if totalSteps <= 0 {
-			cmd.Println("Main output is already at or above target level")
-			return
-		}
-
-		// Calculate delay per step to achieve exact duration
-		stepDelay := time.Duration(duration*1000/totalSteps) * time.Millisecond
-
-		for currentFader < target {
-			currentFader += 1.0
-			err = client.SetMainLRFader(currentFader)
-			if err != nil {
-				cmd.PrintErrln("Error setting main LR fader:", err)
-				return
-			}
-			time.Sleep(stepDelay)
-		}
-		cmd.Println("Main output faded in successfully")
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(mainCmd)
-
-	mainCmd.AddCommand(mainMuteCmd)
-
-	mainCmd.AddCommand(mainFaderCmd)
-	mainCmd.AddCommand(mainFadeOutCmd)
-	mainFadeOutCmd.Flags().Float64P("duration", "d", 5, "Duration for fade out in seconds")
-	mainCmd.AddCommand(mainFadeInCmd)
-	mainFadeInCmd.Flags().Float64P("duration", "d", 5, "Duration for fade in in seconds")
-}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -1,91 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/log"
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-
-	"github.com/onyx-and-iris/xair-cli/internal/xair"
-)
-
-// rootCmd represents the base command when called without any subcommands
-var rootCmd = &cobra.Command{
-	Use:   "xair-cli",
-	Short: "A command-line utility to interact with Behringer X Air mixers via OSC",
-	Long: `xair-cli is a command-line tool that allows users to send OSC messages
-to Behringer X Air mixers for remote control and configuration. It supports
-various commands to manage mixer settings directly from the terminal.`,
-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		level, err := log.ParseLevel(viper.GetString("loglevel"))
-		if err != nil {
-			return err
-		}
-		log.SetLevel(level)
-
-		kind := viper.GetString("kind")
-		log.Debugf("Initializing client for mixer kind: %s", kind)
-
-		if kind == "x32" && !viper.IsSet("port") {
-			viper.Set("port", 10023)
-		}
-
-		client, err := xair.NewClient(
-			viper.GetString("host"),
-			viper.GetInt("port"),
-			xair.WithKind(kind),
-		)
-		if err != nil {
-			return err
-		}
-		cmd.SetContext(WithContext(cmd.Context(), client))
-
-		client.StartListening()
-		err, resp := client.RequestInfo()
-		if err != nil {
-			return err
-		}
-
-		log.Infof("Received mixer info: %+v", resp)
-
-		return nil
-	},
-	PersistentPostRunE: func(cmd *cobra.Command, args []string) error {
-		client := ClientFromContext(cmd.Context())
-		if client != nil {
-			client.Stop()
-		}
-		return nil
-	},
-	Run: func(cmd *cobra.Command, args []string) {
-		cmd.Help()
-	},
-}
-
-func Execute() {
-	err := rootCmd.Execute()
-	if err != nil {
-		os.Exit(1)
-	}
-}
-
-func init() {
-	rootCmd.PersistentFlags().StringP("host", "H", "mixer.local", "host address of the X Air mixer")
-	rootCmd.PersistentFlags().IntP("port", "p", 10024, "Port number of the X Air mixer")
-	rootCmd.PersistentFlags().
-		StringP("loglevel", "l", "warn", "Log level (debug, info, warn, error, fatal, panic)")
-	rootCmd.PersistentFlags().StringP("kind", "k", "xair", "Kind of mixer (xair, x32)")
-
-	viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
-	viper.SetEnvPrefix("XAIR_CLI")
-	viper.AutomaticEnv()
-	viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("host"))
-	viper.BindPFlag("port", rootCmd.PersistentFlags().Lookup("port"))
-	viper.BindPFlag("loglevel", rootCmd.PersistentFlags().Lookup("loglevel"))
-	viper.BindPFlag("kind", rootCmd.PersistentFlags().Lookup("kind"))
-}
--- a/cmd/strip.go
+++ b/cmd/strip.go
@@ -1,92 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-// stripCmd represents the strip command
-var stripCmd = &cobra.Command{
-	Use:   "strip",
-	Short: "Commands to control individual strips",
-	Long:  `Commands to control individual strips of the XAir mixer, including fader level and mute status.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("strip called")
-	},
-}
-
-var stripMuteCmd = &cobra.Command{
-	Use:   "mute",
-	Short: "Get or set the mute status of a strip",
-	Long: `Get or set the mute status of a specific strip.
-
-If no argument is provided, the current mute status is retrieved.
-If "true" or "1" is provided as an argument, the strip is muted.
-If "false" or "0" is provided, the strip is unmuted.
-
-For example:
-  # Get the current mute status of strip 1
-  xair-cli strip mute 1
-  
-  # Mute strip 1
-  xair-cli strip mute 1 true
-  # Unmute strip 1
-  xair-cli strip mute 1 false
-`,
-	Run: func(cmd *cobra.Command, args []string) {
-		client := ClientFromContext(cmd.Context())
-		if client == nil {
-			cmd.PrintErrln("OSC client not found in context")
-			return
-		}
-
-		if len(args) < 1 {
-			cmd.PrintErrln("Please provide a strip number")
-			return
-		}
-
-		stripIndex := mustConvToInt(args[0])
-
-		if len(args) == 1 {
-			resp, err := client.StripMute(stripIndex)
-			if err != nil {
-				cmd.PrintErrln("Error getting strip mute status:", err)
-				return
-			}
-			cmd.Printf("Strip %d mute: %v\n", stripIndex, resp)
-			return
-		}
-
-		var muted bool
-		switch args[1] {
-		case "true", "1":
-			muted = true
-		case "false", "0":
-			muted = false
-		default:
-			cmd.PrintErrln("Invalid mute status. Use true/false or 1/0")
-			return
-		}
-
-		err := client.SetStripMute(stripIndex, muted)
-		if err != nil {
-			cmd.PrintErrln("Error setting strip mute status:", err)
-			return
-		}
-		if muted {
-			cmd.Printf("Strip %d muted successfully\n", stripIndex)
-		} else {
-			cmd.Printf("Strip %d unmuted successfully\n", stripIndex)
-		}
-	},
-}
-
-func init() {
-	rootCmd.AddCommand(stripCmd)
-
-	stripCmd.AddCommand(stripMuteCmd)
-}
--- a/cmd/util.go
+++ b/cmd/util.go
@@ -1,24 +0,0 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
-package cmd
-
-import (
-	"strconv"
-)
-
-func mustConvToFloat64(floatStr string) float64 {
-	level, err := strconv.ParseFloat(floatStr, 64)
-	if err != nil {
-		panic(err)
-	}
-	return level
-}
-
-func mustConvToInt(intStr string) int {
-	val, err := strconv.Atoi(intStr)
-	if err != nil {
-		panic(err)
-	}
-	return val
-}
--- a/go.mod
+++ b/go.mod
@@ -1,43 +1,35 @@
 module github.com/onyx-and-iris/xair-cli

-go 1.24.2
+go 1.25

 require (
+	github.com/alecthomas/kong v1.13.0
 	github.com/charmbracelet/log v0.4.2
 	github.com/hypebeast/go-osc v0.0.0-20220308234300-cec5a8a1e5f5
-	github.com/spf13/cobra v1.10.2
-	github.com/spf13/viper v1.21.0
+	github.com/jotaen/kong-completion v0.0.11
 )

 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.3.3 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/lipgloss v1.1.0 // indirect
-	github.com/charmbracelet/x/ansi v0.10.3 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
+	github.com/charmbracelet/x/ansi v0.11.4 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect
-	github.com/clipperhouse/displaywidth v0.4.1 // indirect
+	github.com/clipperhouse/displaywidth v0.9.0 // indirect
 	github.com/clipperhouse/stringish v0.1.1 // indirect
-	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
-	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/go-logfmt/logfmt v0.6.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/clipperhouse/uax29/v2 v2.5.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.19 // indirect
 	github.com/muesli/termenv v0.16.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/posener/complete v1.2.3 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/sagikazarmark/locafero v0.11.0 // indirect
-	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
-	github.com/spf13/afero v1.15.0 // indirect
-	github.com/spf13/cast v1.10.0 // indirect
-	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
-	golang.org/x/sys v0.37.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/exp v0.0.0-20260112195511-716be5621a96 // indirect
+	golang.org/x/sys v0.40.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,44 +1,48 @@
+github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
+github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/kong v1.13.0 h1:5e/7XC3ugvhP1DQBmTS+WuHtCbcv44hsohMgcvVxSrA=
+github.com/alecthomas/kong v1.13.0/go.mod h1:wrlbXem1CWqUV5Vbmss5ISYhsVPkBb1Yo7YKJghju2I=
+github.com/alecthomas/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.3.3 h1:DjJzJtLP6/NZ8p7Cgjno0CKGr7wwRJGxWUwh2IyhfAI=
-github.com/charmbracelet/colorprofile v0.3.3/go.mod h1:nB1FugsAbzq284eJcjfah2nhdSLppN2NqvfotkfRYP4=
+github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
+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=
 github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
-github.com/charmbracelet/x/ansi v0.10.3 h1:3WoV9XN8uMEnFRZZ+vBPRy59TaIWa+gJodS4Vg5Fut0=
-github.com/charmbracelet/x/ansi v0.10.3/go.mod h1:uQt8bOrq/xgXjlGcFMc8U2WYbnxyjrKhnvTQluvfCaE=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/ansi v0.11.4 h1:6G65PLu6HjmE858CnTUQY1LXT3ZUWwfvqEROLF8vqHI=
+github.com/charmbracelet/x/ansi v0.11.4/go.mod h1:/5AZ+UfWExW3int5H5ugnsG/PWjNcSQcwYsHBlPFQN4=
+github.com/charmbracelet/x/cellbuf v0.0.14 h1:iUEMryGyFTelKW3THW4+FfPgi4fkmKnnaLOXuc+/Kj4=
+github.com/charmbracelet/x/cellbuf v0.0.14/go.mod h1:P447lJl49ywBbil/KjCk2HexGh4tEY9LH0/1QrZZ9rA=
 github.com/charmbracelet/x/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.4.1 h1:uVw9V8UDfnggg3K2U84VWY1YLQ/x2aKSCtkRyYozfoU=
-github.com/clipperhouse/displaywidth v0.4.1/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=
+github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=
 github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
 github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
-github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
-github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
-github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U=
+github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
-github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
-github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
-github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
-github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/go-logfmt/logfmt v0.6.1 h1:4hvbpePJKnIzH1B+8OR/JPbTx37NktoI9LE2QZBBkvE=
+github.com/go-logfmt/logfmt v0.6.1/go.mod h1:EV2pOAQoZaT1ZXZbqDl5hrymndi4SY9ED9/z6CO0XAk=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+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/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
-github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/jotaen/kong-completion v0.0.11 h1:ZRyQt+IwjcAObbiyxJZ3YR7r/o/f6HYidTK1+7YNtnE=
+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=
@@ -47,47 +51,26 @@ github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byF
 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/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/posener/complete v1.2.3 h1:NP0eAhjcjImqslEwo/1hq7gpajME0fTLTezBKDqfXqo=
+github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
-github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
-github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
-github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
-github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
-github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
-github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
+github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab h1:ZjX6I48eZSFetPb41dHudEyVr5v953N15TsNZXlkcWY=
+github.com/riywo/loginshell v0.0.0-20200815045211-7d26008be1ab/go.mod h1:/PfPXh0EntGc3QAAyUaviy4S9tzy4Zp0e2ilq4voC6E=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
-github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 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=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96 h1:Z/6YuSHTLOHfNFdb8zVZomZr7cqNgTJvA8+Qz75D8gU=
+golang.org/x/exp v0.0.0-20260112195511-716be5621a96/go.mod h1:nzimsREAkjBCIEFtHiYkrJyT+2uy9YZJB7H1k68CXZU=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/headamp.go
+++ b/headamp.go
@@ -0,0 +1,124 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/charmbracelet/log"
+)
+
+type HeadampCmdGroup struct {
+	Index struct {
+		Index   int               `arg:"" help:"The index of the headamp."`
+		Gain    HeadampGainCmd    `help:"Get or set the gain of the headamp."                cmd:""`
+		Phantom HeadampPhantomCmd `help:"Get or set the phantom power state of the headamp." cmd:""`
+	} `arg:"" help:"Control a specific headamp by index."`
+}
+
+type HeadampGainCmd struct {
+	Duration time.Duration `help:"The duration of the fade in/out when setting the gain." default:"5s"`
+	Gain     *float64      `help:"The gain of the headamp in dB."                                      arg:""`
+}
+
+func (cmd *HeadampGainCmd) Run(ctx *context, headamp *HeadampCmdGroup) error {
+	if cmd.Gain == nil {
+		resp, err := ctx.Client.HeadAmp.Gain(headamp.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get headamp gain: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Headamp %d gain: %.2f dB\n", headamp.Index.Index, resp)
+		return nil
+	}
+
+	currentGain, err := ctx.Client.HeadAmp.Gain(headamp.Index.Index)
+	if err != nil {
+		return fmt.Errorf("failed to get current headamp gain: %w", err)
+	}
+
+	if err := gradualGainAdjust(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
+func gradualGainAdjust(
+	ctx *context,
+	index int,
+	currentGain, targetGain float64,
+	duration time.Duration,
+) error {
+	gainDiff := targetGain - currentGain
+
+	stepInterval := 100 * time.Millisecond
+	totalSteps := int(duration / stepInterval)
+
+	if totalSteps < 1 {
+		totalSteps = 1
+		stepInterval = duration
+	}
+
+	stepIncrement := gainDiff / float64(totalSteps)
+
+	log.Debugf("Adjusting Headamp %d gain from %.2f dB to %.2f dB over %v...\n",
+		index, currentGain, targetGain, duration)
+
+	for step := 1; step <= totalSteps; step++ {
+		newGain := currentGain + (stepIncrement * float64(step))
+
+		if step == totalSteps {
+			newGain = targetGain
+		}
+
+		err := ctx.Client.HeadAmp.SetGain(index, newGain)
+		if err != nil {
+			return err
+		}
+
+		if step%10 == 0 || step == totalSteps {
+			log.Debugf("  Step %d/%d: %.2f dB\n", step, totalSteps, newGain)
+		}
+
+		if step < totalSteps {
+			time.Sleep(stepInterval)
+		}
+	}
+
+	return nil
+}
+
+type HeadampPhantomCmd struct {
+	State *string `help:"The phantom power state of the headamp." arg:"" enum:"true,on,false,off" optional:""`
+}
+
+func (cmd *HeadampPhantomCmd) Validate() error {
+	if cmd.State != nil {
+		switch *cmd.State {
+		case "true", "on":
+			*cmd.State = "true"
+		case "false", "off":
+			*cmd.State = "false"
+		default:
+			return fmt.Errorf("invalid phantom power state: %s", *cmd.State)
+		}
+	}
+	return nil
+}
+
+func (cmd *HeadampPhantomCmd) Run(ctx *context, headamp *HeadampCmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.HeadAmp.PhantomPower(headamp.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get headamp phantom power state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Headamp %d phantom power: %t\n", headamp.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.HeadAmp.SetPhantomPower(headamp.Index.Index, *cmd.State == "true"); 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)
+	return nil
+}
--- a/internal/xair/address.go
+++ b/internal/xair/address.go
@@ -1,11 +1,16 @@
 package xair

 var xairAddressMap = map[string]string{
-	"bus": "/bus/%01d",
+	"strip":    "/ch/%02d",
+	"bus":      "/bus/%01d",
+	"headamp":  "/headamp/%02d",
+	"snapshot": "/-snap",
 }

 var x32AddressMap = map[string]string{
-	"bus": "/bus/%02d",
+	"strip":   "/ch/%02d",
+	"bus":     "/bus/%02d",
+	"headamp": "/headamp/%02d",
 }

 func addressMapForMixerKind(kind MixerKind) map[string]string {
--- a/internal/xair/bus.go
+++ b/internal/xair/bus.go
@@ -0,0 +1,90 @@
+package xair
+
+import "fmt"
+
+type Bus struct {
+	baseAddress string
+	client      *Client
+	Eq          *Eq
+	Comp        *Comp
+}
+
+func NewBus(c *Client) *Bus {
+	return &Bus{
+		baseAddress: c.addressMap["bus"],
+		client:      c,
+		Eq:          newEqForBus(c),
+		Comp:        newCompForBus(c),
+	}
+}
+
+// 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)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-b.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for bus mute value")
+	}
+	return val == 0, nil
+}
+
+// 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
+	if !muted {
+		value = 1
+	}
+	return b.client.SendMessage(address, value)
+}
+
+// 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)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-b.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for bus fader value")
+	}
+
+	return mustDbFrom(float64(val)), nil
+}
+
+// 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
+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: %v", err)
+	}
+
+	resp := <-b.client.respChan
+	val, ok := resp.Arguments[0].(string)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for bus name value")
+	}
+	return val, nil
+}
+
+// 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)
+}
--- a/internal/xair/client.go
+++ b/internal/xair/client.go
@@ -1,6 +1,3 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
 package xair

 import (
@@ -17,20 +14,13 @@ type parser interface {
 	Parse(data []byte) (*osc.Message, error)
 }

-type engine struct {
-	Kind      MixerKind
-	conn      *net.UDPConn
-	mixerAddr *net.UDPAddr
-
-	parser     parser
-	addressMap map[string]string
-
-	done     chan bool
-	respChan chan *osc.Message
-}
-
 type Client struct {
 	engine
+	Main     *Main
+	Strip    *Strip
+	Bus      *Bus
+	HeadAmp  *HeadAmp
+	Snapshot *Snapshot
 }

 // NewClient creates a new XAirClient instance
@@ -67,111 +57,55 @@ func NewClient(mixerIP string, mixerPort int, opts ...Option) (*Client, error) {
 		opt(e)
 	}

-	return &Client{
+	c := &Client{
 		engine: *e,
-	}, nil
+	}
+	c.Main = newMain(c)
+	c.Strip = NewStrip(c)
+	c.Bus = NewBus(c)
+	c.HeadAmp = NewHeadAmp(c)
+
+	return c, nil
 }

 // Start begins listening for messages in a goroutine
 func (c *Client) StartListening() {
-	go c.receiveLoop()
-	log.Debugf("Started listening on %s...", c.conn.LocalAddr().String())
+	go c.engine.receiveLoop()
+	log.Debugf("Started listening on %s...", c.engine.conn.LocalAddr().String())
 }

-// receiveLoop handles incoming OSC messages
-func (c *Client) receiveLoop() {
-	buffer := make([]byte, 4096)
-
-	for {
-		select {
-		case <-c.done:
-			return
-		default:
-			// Set read timeout to avoid blocking forever
-			c.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
-
-			n, _, err := c.conn.ReadFromUDP(buffer)
-			if err != nil {
-				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-					// Timeout is expected, continue loop
-					continue
-				}
-				// Check if we're shutting down to avoid logging expected errors
-				select {
-				case <-c.done:
-					return
-				default:
-					log.Errorf("Read error: %v", err)
-					return
-				}
-			}
-
-			msg, err := c.parseOSCMessage(buffer[:n])
-			if err != nil {
-				log.Errorf("Failed to parse OSC message: %v", err)
-				continue
-			}
-			c.respChan <- msg
-		}
-	}
-}
-
-// parseOSCMessage parses raw bytes into an OSC message with improved error handling
-func (c *Client) parseOSCMessage(data []byte) (*osc.Message, error) {
-	msg, err := c.parser.Parse(data)
-	if err != nil {
-		return nil, err
-	}
-
-	return msg, nil
-}
-
-// Stop stops the client and closes the connection
-func (c *Client) Stop() {
-	close(c.done)
-	if c.conn != nil {
-		c.conn.Close()
+// Close stops the client and closes the connection
+func (c *Client) Close() {
+	close(c.engine.done)
+	if c.engine.conn != nil {
+		c.engine.conn.Close()
 	}
 }

 // SendMessage sends an OSC message to the mixer using the unified connection
 func (c *Client) SendMessage(address string, args ...any) error {
-	return c.SendToAddress(c.mixerAddr, address, args...)
+	return c.engine.sendToAddress(c.mixerAddr, address, args...)
 }

-// SendToAddress sends an OSC message to a specific address (enables replying to different ports)
-func (c *Client) SendToAddress(addr *net.UDPAddr, oscAddress string, args ...any) error {
-	msg := osc.NewMessage(oscAddress)
-	for _, arg := range args {
-		msg.Append(arg)
-	}
-
-	log.Debugf("Sending to %v: %s", addr, msg.String())
-	if len(args) > 0 {
-		log.Debug(" - Arguments: ")
-		for i, arg := range args {
-			if i > 0 {
-				log.Debug(", ")
-			}
-			log.Debugf("%v", arg)
+// ReceiveMessage receives an OSC message from the mixer
+func (c *Client) ReceiveMessage(timeout time.Duration) (*osc.Message, error) {
+	t := time.Tick(timeout)
+	select {
+	case <-t:
+		return nil, nil
+	case val := <-c.respChan:
+		if val == nil {
+			return nil, fmt.Errorf("no message received")
 		}
+		return val, nil
 	}
-	log.Debug("")
-
-	data, err := msg.MarshalBinary()
-	if err != nil {
-		return fmt.Errorf("failed to marshal message: %v", err)
-	}
-
-	_, err = c.conn.WriteToUDP(data, addr)
-	return err
 }

 // RequestInfo requests mixer information
-func (c *Client) RequestInfo() (error, InfoResponse) {
+func (c *Client) RequestInfo() (InfoResponse, error) {
 	err := c.SendMessage("/xinfo")
 	if err != nil {
-		return err, InfoResponse{}
+		return InfoResponse{}, err
 	}

 	val := <-c.respChan
@@ -181,7 +115,7 @@ func (c *Client) RequestInfo() (error, InfoResponse) {
 		info.Name = val.Arguments[1].(string)
 		info.Model = val.Arguments[2].(string)
 	}
-	return nil, info
+	return info, nil
 }

 // KeepAlive sends keep-alive message (required for multi-client usage)
@@ -193,221 +127,3 @@ func (c *Client) KeepAlive() error {
 func (c *Client) RequestStatus() error {
 	return c.SendMessage("/status")
 }
-
-/* STRIP METHODS */
-
-// StripMute gets mute state for a specific strip (1-based indexing)
-func (c *Client) StripMute(strip int) (bool, error) {
-	address := fmt.Sprintf("/ch/%02d/mix/on", strip)
-	err := c.SendMessage(address)
-	if err != nil {
-		return false, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(int32)
-	if !ok {
-		return false, fmt.Errorf("unexpected argument type for strip mute value")
-	}
-	return val == 0, nil
-}
-
-// SetStripMute sets mute state for a specific strip (1-based indexing)
-func (c *Client) SetStripMute(strip int, muted bool) error {
-	address := fmt.Sprintf("/ch/%02d/mix/on", strip)
-	var value int32 = 0
-	if !muted {
-		value = 1
-	}
-	return c.SendMessage(address, value)
-}
-
-// StripFader requests the current fader level for a strip
-func (c *Client) StripFader(strip int) (float64, error) {
-	address := fmt.Sprintf("/ch/%02d/mix/fader", strip)
-	err := c.SendMessage(address)
-	if err != nil {
-		return 0, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(float32)
-	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for fader value")
-	}
-
-	return mustDbFrom(float64(val)), nil
-}
-
-// SetStripFader sets the fader level for a specific strip (1-based indexing)
-func (c *Client) SetStripFader(strip int, level float64) error {
-	address := fmt.Sprintf("/ch/%02d/mix/fader", strip)
-	return c.SendMessage(address, float32(mustDbInto(level)))
-}
-
-// StripMicGain requests the phantom gain for a specific strip
-func (c *Client) StripMicGain(strip int) (float64, error) {
-	address := fmt.Sprintf("/ch/%02d/mix/gain", strip)
-	err := c.SendMessage(address)
-	if err != nil {
-		return 0, fmt.Errorf("failed to send strip gain request: %v", err)
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(float32)
-	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for strip gain value")
-	}
-	return mustDbFrom(float64(val)), nil
-}
-
-// SetStripMicGain sets the phantom gain for a specific strip (1-based indexing)
-func (c *Client) SetStripMicGain(strip int, gain float32) error {
-	address := fmt.Sprintf("/ch/%02d/mix/gain", strip)
-	return c.SendMessage(address, gain)
-}
-
-// StripName requests the name for a specific strip
-func (c *Client) StripName(strip int) (string, error) {
-	address := fmt.Sprintf("/ch/%02d/config/name", strip)
-	err := c.SendMessage(address)
-	if err != nil {
-		return "", fmt.Errorf("failed to send strip name request: %v", err)
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(string)
-	if !ok {
-		return "", fmt.Errorf("unexpected argument type for strip name value")
-	}
-	return val, nil
-}
-
-// SetStripName sets the name for a specific strip
-func (c *Client) SetStripName(strip int, name string) error {
-	address := fmt.Sprintf("/ch/%02d/config/name", strip)
-	return c.SendMessage(address, name)
-}
-
-// StripColor requests the color for a specific strip
-func (c *Client) StripColor(strip int) (int32, error) {
-	address := fmt.Sprintf("/ch/%02d/config/color", strip)
-	err := c.SendMessage(address)
-	if err != nil {
-		return 0, fmt.Errorf("failed to send strip color request: %v", err)
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(int32)
-	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for strip color value")
-	}
-	return val, nil
-}
-
-// SetStripColor sets the color for a specific strip (0-15)
-func (c *Client) SetStripColor(strip int, color int32) error {
-	address := fmt.Sprintf("/ch/%02d/config/color", strip)
-	return c.SendMessage(address, color)
-}
-
-/* BUS METHODS */
-
-// BusMute requests the current mute status for a bus
-func (c *Client) BusMute(bus int) (bool, error) {
-	formatter := c.addressMap["bus"]
-	address := fmt.Sprintf(formatter, bus) + "/mix/on"
-	err := c.SendMessage(address)
-	if err != nil {
-		return false, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(int32)
-	if !ok {
-		return false, fmt.Errorf("unexpected argument type for bus mute value")
-	}
-	return val == 0, nil
-}
-
-// SetBusMute sets the mute status for a specific bus (1-based indexing)
-func (c *Client) SetBusMute(bus int, muted bool) error {
-	formatter := c.addressMap["bus"]
-	address := fmt.Sprintf(formatter, bus) + "/mix/on"
-	var value int32
-	if !muted {
-		value = 1
-	}
-	return c.SendMessage(address, value)
-}
-
-// BusFader requests the current fader level for a bus
-func (c *Client) BusFader(bus int) (float64, error) {
-	formatter := c.addressMap["bus"]
-	address := fmt.Sprintf(formatter, bus) + "/mix/fader"
-	err := c.SendMessage(address)
-	if err != nil {
-		return 0, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(float32)
-	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for bus fader value")
-	}
-
-	return mustDbFrom(float64(val)), nil
-}
-
-// SetBusFader sets the fader level for a specific bus (1-based indexing)
-func (c *Client) SetBusFader(bus int, level float64) error {
-	formatter := c.addressMap["bus"]
-	address := fmt.Sprintf(formatter, bus) + "/mix/fader"
-	return c.SendMessage(address, float32(mustDbInto(level)))
-}
-
-/* MAIN LR METHODS */
-
-// MainLRFader requests the current main L/R fader level
-func (c *Client) MainLRFader() (float64, error) {
-	err := c.SendMessage("/lr/mix/fader")
-	if err != nil {
-		return 0, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(float32)
-	if !ok {
-		return 0, fmt.Errorf("unexpected argument type for main LR fader value")
-	}
-	return mustDbFrom(float64(val)), nil
-}
-
-// SetMainLRFader sets the main L/R fader level
-func (c *Client) SetMainLRFader(level float64) error {
-	return c.SendMessage("/lr/mix/fader", float32(mustDbInto(level)))
-}
-
-// MainLRMute requests the current main L/R mute status
-func (c *Client) MainLRMute() (bool, error) {
-	err := c.SendMessage("/lr/mix/on")
-	if err != nil {
-		return false, err
-	}
-
-	resp := <-c.respChan
-	val, ok := resp.Arguments[0].(int32)
-	if !ok {
-		return false, fmt.Errorf("unexpected argument type for main LR mute value")
-	}
-	return val == 0, nil
-}
-
-// SetMainLRMute sets the main L/R mute status
-func (c *Client) SetMainLRMute(muted bool) error {
-	var value int32
-	if !muted {
-		value = 1
-	}
-	return c.SendMessage("/lr/mix/on", value)
-}
--- a/internal/xair/comp.go
+++ b/internal/xair/comp.go
@@ -0,0 +1,234 @@
+package xair
+
+import "fmt"
+
+type Comp struct {
+	client      *Client
+	baseAddress string
+}
+
+// Factory function to create Comp instance for Strip
+func newCompForStrip(c *Client) *Comp {
+	return &Comp{
+		client:      c,
+		baseAddress: c.addressMap["strip"],
+	}
+}
+
+// Factory function to create Comp instance for Bus
+func newCompForBus(c *Client) *Comp {
+	return &Comp{
+		client:      c,
+		baseAddress: c.addressMap["bus"],
+	}
+}
+
+// On retrieves the on/off status of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) On(index int) (bool, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/on"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for Compressor on value")
+	}
+	return val != 0, nil
+}
+
+// SetOn sets the on/off status of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetOn(index int, on bool) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/on"
+	var value int32
+	if on {
+		value = 1
+	}
+	return c.client.SendMessage(address, value)
+}
+
+// Mode retrieves the current mode of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Mode(index int) (string, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mode"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	possibleModes := []string{"comp", "exp"}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for Compressor mode value")
+	}
+	return possibleModes[val], nil
+}
+
+// SetMode sets the mode of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetMode(index int, mode string) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mode"
+	possibleModes := []string{"comp", "exp"}
+	return c.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
+}
+
+// Threshold retrieves the threshold value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Threshold(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/thr"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor threshold value")
+	}
+	return linGet(-60, 0, float64(val)), nil
+}
+
+// SetThreshold sets the threshold value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetThreshold(index int, threshold float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/thr"
+	return c.client.SendMessage(address, float32(linSet(-60, 0, threshold)))
+}
+
+// Ratio retrieves the ratio value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Ratio(index int) (float32, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/ratio"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor ratio value")
+	}
+
+	return possibleValues[val], nil
+}
+
+// SetRatio sets the ratio value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetRatio(index int, ratio float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/ratio"
+	possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100}
+
+	return c.client.SendMessage(address, int32(indexOf(possibleValues, float32(ratio))))
+}
+
+// Attack retrieves the attack time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Attack(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/attack"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor attack value")
+	}
+	return linGet(0, 120, float64(val)), nil
+}
+
+// SetAttack sets the attack time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetAttack(index int, attack float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/attack"
+	return c.client.SendMessage(address, float32(linSet(0, 120, attack)))
+}
+
+// Hold retrieves the hold time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Hold(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/hold"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor hold value")
+	}
+	return logGet(0.02, 2000, float64(val)), nil
+}
+
+// SetHold sets the hold time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetHold(index int, hold float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/hold"
+	return c.client.SendMessage(address, float32(logSet(0.02, 2000, hold)))
+}
+
+// Release retrieves the release time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Release(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/release"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor release value")
+	}
+	return logGet(4, 4000, float64(val)), nil
+}
+
+// SetRelease sets the release time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetRelease(index int, release float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/release"
+	return c.client.SendMessage(address, float32(logSet(4, 4000, release)))
+}
+
+// Makeup retrieves the makeup gain of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Makeup(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mgain"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor makeup gain value")
+	}
+	return linGet(0, 24, float64(val)), nil
+}
+
+// SetMakeup sets the makeup gain of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetMakeup(index int, makeup float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mgain"
+	return c.client.SendMessage(address, float32(linSet(0, 24, makeup)))
+}
+
+// Mix retrieves the mix value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Mix(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mix"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor mix value")
+	}
+	return linGet(0, 100, float64(val)), nil
+}
+
+// SetMix sets the mix value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetMix(index int, mix float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mix"
+	return c.client.SendMessage(address, float32(linSet(0, 100, mix)))
+}
--- a/internal/xair/engine.go
+++ b/internal/xair/engine.go
@@ -0,0 +1,97 @@
+package xair
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/charmbracelet/log"
+	"github.com/hypebeast/go-osc/osc"
+)
+
+type engine struct {
+	Kind      MixerKind
+	conn      *net.UDPConn
+	mixerAddr *net.UDPAddr
+
+	parser     parser
+	addressMap map[string]string
+
+	done     chan bool
+	respChan chan *osc.Message
+}
+
+// receiveLoop handles incoming OSC messages
+func (e *engine) receiveLoop() {
+	buffer := make([]byte, 4096)
+
+	for {
+		select {
+		case <-e.done:
+			return
+		default:
+			// Set read timeout to avoid blocking forever
+			e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+			n, _, err := e.conn.ReadFromUDP(buffer)
+			if err != nil {
+				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+					// Timeout is expected, continue loop
+					continue
+				}
+				// Check if we're shutting down to avoid logging expected errors
+				select {
+				case <-e.done:
+					return
+				default:
+					log.Errorf("Read error: %v", err)
+					return
+				}
+			}
+
+			msg, err := e.parseOSCMessage(buffer[:n])
+			if err != nil {
+				log.Errorf("Failed to parse OSC message: %v", err)
+				continue
+			}
+			e.respChan <- msg
+		}
+	}
+}
+
+// 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 {
+		return nil, err
+	}
+
+	return msg, nil
+}
+
+// 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 {
+		msg.Append(arg)
+	}
+
+	log.Debugf("Sending to %v: %s", addr, msg.String())
+	if len(args) > 0 {
+		log.Debug(" - Arguments: ")
+		for i, arg := range args {
+			if i > 0 {
+				log.Debug(", ")
+			}
+			log.Debugf("%v", arg)
+		}
+	}
+	log.Debug("")
+
+	data, err := msg.MarshalBinary()
+	if err != nil {
+		return fmt.Errorf("failed to marshal message: %v", err)
+	}
+
+	_, err = e.conn.WriteToUDP(data, addr)
+	return err
+}
--- a/internal/xair/eq.go
+++ b/internal/xair/eq.go
@@ -0,0 +1,164 @@
+package xair
+
+import "fmt"
+
+type Eq struct {
+	client      *Client
+	baseAddress string
+}
+
+// Factory function to create Eq instance for Strip
+func newEqForStrip(c *Client) *Eq {
+	return &Eq{
+		client:      c,
+		baseAddress: c.addressMap["strip"],
+	}
+}
+
+// Factory function to create Eq instance for Bus
+func newEqForBus(c *Client) *Eq {
+	return &Eq{
+		client:      c,
+		baseAddress: c.addressMap["bus"],
+	}
+}
+
+// On retrieves the on/off status of the EQ for a specific strip or bus (1-based indexing).
+func (e *Eq) On(index int) (bool, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + "/eq/on"
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for EQ on value")
+	}
+	return val != 0, nil
+}
+
+// SetOn sets the on/off status of the EQ for a specific strip or bus (1-based indexing).
+func (e *Eq) SetOn(index int, on bool) error {
+	address := fmt.Sprintf(e.baseAddress, index) + "/eq/on"
+	var value int32
+	if on {
+		value = 1
+	}
+	return e.client.SendMessage(address, value)
+}
+
+func (e *Eq) Mode(index int) (string, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + "/eq/mode"
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	possibleModes := []string{"peq", "geq", "teq"}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for EQ mode value")
+	}
+	return possibleModes[val], nil
+}
+
+func (e *Eq) SetMode(index int, mode string) error {
+	address := fmt.Sprintf(e.baseAddress, index) + "/eq/mode"
+	possibleModes := []string{"peq", "geq", "teq"}
+	return e.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
+}
+
+// Gain retrieves the gain for a specific EQ band on a strip or bus (1-based indexing).
+func (e *Eq) Gain(index int, band int) (float64, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%d/g", band)
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for EQ gain value")
+	}
+	return linGet(-15, 15, float64(val)), nil
+}
+
+// SetGain sets the gain for a specific EQ band on a strip or bus (1-based indexing).
+func (e *Eq) SetGain(index int, band int, gain float64) error {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%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 int, band int) (float64, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%d/f", band)
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for EQ frequency value")
+	}
+	return logGet(20, 20000, float64(val)), nil
+}
+
+// SetFrequency sets the frequency for a specific EQ band on a strip or bus (1-based indexing).
+func (e *Eq) SetFrequency(index int, band int, frequency float64) error {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%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 int, band int) (float64, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%d/q", band)
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for EQ Q value")
+	}
+	return logGet(0.3, 10, 1.0-float64(val)), nil
+}
+
+// SetQ sets the Q factor for a specific EQ band on a strip or bus (1-based indexing).
+func (e *Eq) SetQ(index int, band int, q float64) error {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%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 int, band int) (string, error) {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%d/type", band)
+	err := e.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
+
+	resp := <-e.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for EQ type value")
+	}
+	return possibleTypes[val], nil
+}
+
+// SetType sets the type for a specific EQ band on a strip or bus (1-based indexing).
+func (e *Eq) SetType(index int, band int, eqType string) error {
+	address := fmt.Sprintf(e.baseAddress, index) + fmt.Sprintf("/eq/%d/type", band)
+	possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
+	return e.client.SendMessage(address, int32(indexOf(possibleTypes, eqType)))
+}
--- a/internal/xair/gate.go
+++ b/internal/xair/gate.go
@@ -0,0 +1,174 @@
+package xair
+
+import "fmt"
+
+type Gate struct {
+	client      *Client
+	baseAddress string
+}
+
+func newGate(c *Client) *Gate {
+	return &Gate{client: c, baseAddress: c.addressMap["strip"]}
+}
+
+// On retrieves the on/off status of the Gate for a specific strip (1-based indexing).
+func (g *Gate) On(index int) (bool, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/on"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for Gate on value")
+	}
+	return val != 0, nil
+}
+
+// SetOn sets the on/off status of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetOn(index int, on bool) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/on"
+	var value int32
+	if on {
+		value = 1
+	}
+	return g.client.SendMessage(address, value)
+}
+
+// Mode retrieves the current mode of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Mode(index int) (string, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/mode"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for Gate mode value")
+	}
+	return possibleModes[val], nil
+}
+
+// SetMode sets the mode of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetMode(index int, mode string) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/mode"
+	possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"}
+
+	return g.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
+}
+
+// Threshold retrieves the threshold value of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Threshold(index int) (float64, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/thr"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Gate threshold value")
+	}
+	return linGet(-80, 0, float64(val)), nil
+}
+
+// SetThreshold sets the threshold value of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetThreshold(index int, threshold float64) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/thr"
+	return g.client.SendMessage(address, float32(linSet(-80, 0, threshold)))
+}
+
+// Range retrieves the range value of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Range(index int) (float64, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/range"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Gate range value")
+	}
+	return linGet(3, 60, float64(val)), nil
+}
+
+// SetRange sets the range value of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetRange(index int, rangeVal float64) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/range"
+	return g.client.SendMessage(address, float32(linSet(3, 60, rangeVal)))
+}
+
+// Attack retrieves the attack time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Attack(index int) (float64, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/attack"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Gate attack value")
+	}
+	return linGet(0, 120, float64(val)), nil
+}
+
+// SetAttack sets the attack time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetAttack(index int, attack float64) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/attack"
+	return g.client.SendMessage(address, float32(linSet(0, 120, attack)))
+}
+
+// Hold retrieves the hold time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Hold(index int) (float64, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/hold"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Gate hold value")
+	}
+	return logGet(0.02, 2000, float64(val)), nil
+}
+
+// SetHold sets the hold time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetHold(index int, hold float64) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/hold"
+	return g.client.SendMessage(address, float32(logSet(0.02, 2000, hold)))
+}
+
+// Release retrieves the release time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) Release(index int) (float64, error) {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/release"
+	err := g.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-g.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Gate release value")
+	}
+	return logGet(5, 4000, float64(val)), nil
+}
+
+// SetRelease sets the release time of the Gate for a specific strip (1-based indexing).
+func (g *Gate) SetRelease(index int, release float64) error {
+	address := fmt.Sprintf(g.baseAddress, index) + "/gate/release"
+	return g.client.SendMessage(address, float32(logSet(5, 4000, release)))
+}
--- a/internal/xair/headamp.go
+++ b/internal/xair/headamp.go
@@ -0,0 +1,67 @@
+package xair
+
+import "fmt"
+
+type HeadAmp struct {
+	baseAddress string
+	client      *Client
+}
+
+func NewHeadAmp(c *Client) *HeadAmp {
+	return &HeadAmp{
+		baseAddress: c.addressMap["headamp"],
+		client:      c,
+	}
+}
+
+// Gain gets the gain level for the specified headamp index.
+func (h *HeadAmp) Gain(index int) (float64, error) {
+	address := fmt.Sprintf(h.baseAddress, index) + "/gain"
+	err := h.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-h.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for headamp gain value")
+	}
+
+	return linGet(-12, 60, float64(val)), nil
+}
+
+// SetGain sets the gain level for the specified headamp index.
+func (h *HeadAmp) SetGain(index int, level float64) error {
+	address := fmt.Sprintf(h.baseAddress, index) + "/gain"
+	return h.client.SendMessage(address, float32(linSet(-12, 60, level)))
+}
+
+// PhantomPower gets the phantom power status for the specified headamp index.
+func (h *HeadAmp) PhantomPower(index int) (bool, error) {
+	address := fmt.Sprintf(h.baseAddress, index) + "/phantom"
+	err := h.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-h.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for phantom power value")
+	}
+
+	return val != 0, nil
+}
+
+// SetPhantomPower sets the phantom power status for the specified headamp index.
+func (h *HeadAmp) SetPhantomPower(index int, enabled bool) error {
+	address := fmt.Sprintf(h.baseAddress, index) + "/phantom"
+	var val int32
+	if enabled {
+		val = 1
+	} else {
+		val = 0
+	}
+	return h.client.SendMessage(address, val)
+}
--- a/internal/xair/main.go
+++ b/internal/xair/main.go
@@ -0,0 +1,57 @@
+package xair
+
+import "fmt"
+
+type Main struct {
+	client *Client
+}
+
+func newMain(c *Client) *Main {
+	return &Main{
+		client: c,
+	}
+}
+
+// Fader requests the current main L/R fader level
+func (m *Main) Fader() (float64, error) {
+	err := m.client.SendMessage("/lr/mix/fader")
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-m.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for main LR fader value")
+	}
+	return mustDbFrom(float64(val)), nil
+}
+
+// SetFader sets the main L/R fader level
+func (m *Main) SetFader(level float64) error {
+	return m.client.SendMessage("/lr/mix/fader", float32(mustDbInto(level)))
+}
+
+// Mute requests the current main L/R mute status
+func (m *Main) Mute() (bool, error) {
+	err := m.client.SendMessage("/lr/mix/on")
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-m.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for main LR mute value")
+	}
+	return val == 0, nil
+}
+
+// SetMute sets the main L/R mute status
+func (m *Main) SetMute(muted bool) error {
+	var value int32
+	if !muted {
+		value = 1
+	}
+	return m.client.SendMessage("/lr/mix/on", value)
+}
--- a/internal/xair/models.go
+++ b/internal/xair/models.go
@@ -1,6 +1,3 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
 package xair

 type InfoResponse struct {
--- a/internal/xair/parser.go
+++ b/internal/xair/parser.go
@@ -1,6 +1,3 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
 package xair

 import (
--- a/internal/xair/snapshot.go
+++ b/internal/xair/snapshot.go
@@ -0,0 +1,55 @@
+package xair
+
+import "fmt"
+
+type Snapshot struct {
+	baseAddress string
+	client      *Client
+}
+
+func NewSnapshot(c *Client) *Snapshot {
+	return &Snapshot{
+		baseAddress: c.addressMap["snapshot"],
+		client:      c,
+	}
+}
+
+// Name gets the name of the snapshot at the given index.
+func (s *Snapshot) Name(index int) (string, error) {
+	address := s.baseAddress + fmt.Sprintf("/name/%d", index)
+	err := s.client.SendMessage(address)
+	if err != nil {
+		return "", err
+	}
+
+	resp := <-s.client.respChan
+	name, ok := resp.Arguments[0].(string)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for snapshot name")
+	}
+	return name, nil
+}
+
+// SetName sets the name of the snapshot at the given index.
+func (s *Snapshot) SetName(index int, name string) error {
+	address := s.baseAddress + fmt.Sprintf("/name/%d", index)
+	return s.client.SendMessage(address, name)
+}
+
+// Load loads the snapshot at the given index.
+func (s *Snapshot) Load(index int) error {
+	address := s.baseAddress + fmt.Sprintf("/load/%d", index)
+	return s.client.SendMessage(address)
+}
+
+// Save saves the current state to the snapshot at the given index.
+func (s *Snapshot) Save(index int) error {
+	address := s.baseAddress + fmt.Sprintf("/save/%d", index)
+	return s.client.SendMessage(address)
+}
+
+// Delete deletes the snapshot at the given index.
+func (s *Snapshot) Delete(index int) error {
+	address := s.baseAddress + fmt.Sprintf("/delete/%d", index)
+	return s.client.SendMessage(address)
+}
--- a/internal/xair/strip.go
+++ b/internal/xair/strip.go
@@ -0,0 +1,136 @@
+package xair
+
+import "fmt"
+
+type Strip struct {
+	baseAddress string
+	client      *Client
+	Gate        *Gate
+	Eq          *Eq
+	Comp        *Comp
+}
+
+func NewStrip(c *Client) *Strip {
+	return &Strip{
+		baseAddress: c.addressMap["strip"],
+		client:      c,
+		Gate:        newGate(c),
+		Eq:          newEqForStrip(c),
+		Comp:        newCompForStrip(c),
+	}
+}
+
+// Mute gets the mute status of the specified strip (1-based indexing).
+func (s *Strip) Mute(index int) (bool, error) {
+	address := fmt.Sprintf(s.baseAddress, index) + "/mix/on"
+	err := s.client.SendMessage(address)
+	if err != nil {
+		return false, err
+	}
+
+	resp := <-s.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return false, fmt.Errorf("unexpected argument type for strip mute value")
+	}
+	return val == 0, nil
+}
+
+// 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 = 0
+	if !muted {
+		value = 1
+	}
+	return s.client.SendMessage(address, value)
+}
+
+// Fader gets the fader level of the specified strip (1-based indexing).
+func (s *Strip) Fader(strip int) (float64, error) {
+	address := fmt.Sprintf(s.baseAddress, strip) + "/mix/fader"
+	err := s.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-s.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for fader value")
+	}
+
+	return mustDbFrom(float64(val)), nil
+}
+
+// SetFader sets the fader level of the specified strip (1-based indexing).
+func (s *Strip) SetFader(strip int, level float64) error {
+	address := fmt.Sprintf(s.baseAddress, strip) + "/mix/fader"
+	return s.client.SendMessage(address, float32(mustDbInto(level)))
+}
+
+// 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: %v", err)
+	}
+
+	resp := <-s.client.respChan
+	val, ok := resp.Arguments[0].(string)
+	if !ok {
+		return "", fmt.Errorf("unexpected argument type for strip name value")
+	}
+	return val, nil
+}
+
+// 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)
+}
+
+// Color requests the color for a specific strip
+func (s *Strip) Color(strip int) (int32, error) {
+	address := fmt.Sprintf(s.baseAddress, strip) + "/config/color"
+	err := s.client.SendMessage(address)
+	if err != nil {
+		return 0, fmt.Errorf("failed to send strip color request: %v", err)
+	}
+
+	resp := <-s.client.respChan
+	val, ok := resp.Arguments[0].(int32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for strip color value")
+	}
+	return val, nil
+}
+
+// SetColor sets the color for a specific strip (0-15)
+func (s *Strip) SetColor(strip int, color int32) error {
+	address := fmt.Sprintf(s.baseAddress, strip) + "/config/color"
+	return s.client.SendMessage(address, color)
+}
+
+// Sends requests the sends level for a mixbus.
+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: %v", err)
+	}
+
+	resp := <-s.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for strip send level value")
+	}
+	return mustDbFrom(float64(val)), nil
+}
+
+// SetSendLevel sets the sends level for a mixbus.
+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)))
+}
--- a/internal/xair/util.go
+++ b/internal/xair/util.go
@@ -1,10 +1,23 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
 package xair

 import "math"

+func linGet(min float64, max float64, value float64) float64 {
+	return min + (max-min)*value
+}
+
+func linSet(min float64, max float64, value float64) float64 {
+	return (value - min) / (max - min)
+}
+
+func logGet(min float64, max float64, value float64) float64 {
+	return min * math.Exp(math.Log(max/min)*value)
+}
+
+func logSet(min float64, max float64, value float64) float64 {
+	return math.Log(value/min) / math.Log(max/min)
+}
+
 func mustDbInto(db float64) float64 {
 	switch {
 	case db >= 10:
@@ -43,3 +56,13 @@ func toFixed(num float64, precision int) float64 {
 	output := math.Pow(10, float64(precision))
 	return float64(math.Round(num*output)) / output
 }
+
+// generic indexOf returns the index of elem in slice, or -1 if not found.
+func indexOf[T comparable](slice []T, elem T) int {
+	for i, v := range slice {
+		if v == elem {
+			return i
+		}
+	}
+	return -1
+}
--- a/lr.go
+++ b/lr.go
@@ -0,0 +1,120 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+type MainCmdGroup struct {
+	Mute MainMuteCmd `help:"Get or set the mute state of the Main L/R output." cmd:""`
+
+	Fader   MainFaderCmd   `help:"Get or set the fader level of the Main L/R output."   cmd:""`
+	Fadein  MainFadeinCmd  `help:"Get or set the fade-in time of the Main L/R output."  cmd:""`
+	Fadeout MainFadeoutCmd `help:"Get or set the fade-out time of the Main L/R output." cmd:""`
+}
+
+type MainMuteCmd struct {
+	Mute *bool `arg:"" help:"The mute state to set. If not provided, the current state will be printed."`
+}
+
+func (cmd *MainMuteCmd) Run(ctx *context) error {
+	if cmd.Mute == nil {
+		resp, err := ctx.Client.Main.Mute()
+		if err != nil {
+			return fmt.Errorf("failed to get Main L/R mute state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Main L/R mute state: %t\n", resp)
+		return nil
+	}
+
+	if err := ctx.Client.Main.SetMute(*cmd.Mute); 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: %t\n", *cmd.Mute)
+	return nil
+}
+
+type MainFaderCmd struct {
+	Level *float64 `arg:"" help:"The fader level to set. If not provided, the current level will be printed."`
+}
+
+func (cmd *MainFaderCmd) Run(ctx *context) error {
+	if cmd.Level == nil {
+		resp, err := ctx.Client.Main.Fader()
+		if err != nil {
+			return fmt.Errorf("failed to get Main L/R fader level: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Main L/R fader level: %.2f\n", resp)
+		return nil
+	}
+
+	if err := ctx.Client.Main.SetFader(*cmd.Level); err != nil {
+		return fmt.Errorf("failed to set Main L/R fader level: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Main L/R fader level set to: %.2f\n", *cmd.Level)
+	return nil
+}
+
+type MainFadeinCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-in. (in seconds.)"                                                   default:"5s"`
+	Target   float64       `        help:"The target level for the fade-in. If not provided, the current target level will be printed." default:"0.0" arg:""`
+}
+
+func (cmd *MainFadeinCmd) Run(ctx *context) error {
+	currentLevel, err := ctx.Client.Main.Fader()
+	if err != nil {
+		return fmt.Errorf("failed to get Main L/R fader level: %w", err)
+	}
+
+	if currentLevel >= cmd.Target {
+		return fmt.Errorf(
+			"current fader level (%.2f) is already at or above the target level (%.2f)",
+			currentLevel,
+			cmd.Target,
+		)
+	}
+
+	totalSteps := float64(cmd.Target - currentLevel)
+	stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+	for currentLevel < cmd.Target {
+		currentLevel++
+		if err := ctx.Client.Main.SetFader(currentLevel); err != nil {
+			return fmt.Errorf("failed to set Main L/R fader level: %w", err)
+		}
+		time.Sleep(stepDuration)
+	}
+	fmt.Fprintf(ctx.Out, "Main L/R fade-in completed. Final level: %.2f\n", currentLevel)
+	return nil
+}
+
+type MainFadeoutCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-out. (in seconds.)"                                                   default:"5s"`
+	Target   float64       `        help:"The target level for the fade-out. If not provided, the current target level will be printed." default:"-90.0" arg:""`
+}
+
+func (cmd *MainFadeoutCmd) Run(ctx *context) error {
+	currentLevel, err := ctx.Client.Main.Fader()
+	if err != nil {
+		return fmt.Errorf("failed to get Main L/R fader level: %w", err)
+	}
+
+	if currentLevel <= cmd.Target {
+		return fmt.Errorf(
+			"current fader level (%.2f) is already at or below the target level (%.2f)",
+			currentLevel,
+			cmd.Target,
+		)
+	}
+
+	totalSteps := float64(currentLevel - cmd.Target)
+	stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+	for currentLevel > cmd.Target {
+		currentLevel--
+		if err := ctx.Client.Main.SetFader(currentLevel); err != nil {
+			return fmt.Errorf("failed to set Main L/R fader level: %w", err)
+		}
+		time.Sleep(stepDuration)
+	}
+	fmt.Fprintf(ctx.Out, "Main L/R fade-out completed. Final level: %.2f\n", currentLevel)
+	return nil
+}
--- a/main.go
+++ b/main.go
@@ -1,10 +1,113 @@
-/*
-LICENSE: https://github.com/onyx-and-iris/xair-cli/blob/main/LICENSE
-*/
 package main

-import "github.com/onyx-and-iris/xair-cli/cmd"
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime/debug"
+	"strings"
+
+	"github.com/alecthomas/kong"
+	"github.com/charmbracelet/log"
+	kongcompletion "github.com/jotaen/kong-completion"
+	"github.com/onyx-and-iris/xair-cli/internal/xair"
+)
+
+var version string // Version of the CLI, set at build time.
+
+// VersionFlag is a custom flag type that prints the version and exits.
+type VersionFlag string
+
+func (v VersionFlag) Decode(_ *kong.DecodeContext) error { return nil }  // nolint: revive
+func (v VersionFlag) IsBool() bool                       { return true } // nolint: revive
+func (v VersionFlag) BeforeApply(app *kong.Kong, vars kong.Vars) error { // nolint: revive, unparam
+	fmt.Printf("xair-cli version: %s\n", vars["version"])
+	app.Exit(0)
+	return nil
+}
+
+type context struct {
+	Client *xair.Client
+	Out    io.Writer
+}
+
+type Config struct {
+	Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST"`
+	Port int    `default:"10024"       help:"The port of the X-Air device." env:"XAIR_CLI_PORT"`
+	Kind string `default:"xr18"        help:"The kind of the X-Air device." env:"XAIR_CLI_KIND"`
+}
+
+type CLI struct {
+	Config `embed:"" prefix:"" help:"The configuration for the CLI."`
+
+	Version VersionFlag `help:"Print gobs-cli version information and quit" name:"version" short:"v"`
+
+	Completion kongcompletion.Completion `help:"Generate shell completion scripts." cmd:"" aliases:"c"`
+
+	Raw     RawCmd          `help:"Send raw OSC messages to the mixer."   cmd:"" group:"Raw"`
+	Main    MainCmdGroup    `help:"Control the Main L/R output"           cmd:"" group:"Main"`
+	Strip   StripCmdGroup   `help:"Control the strips."                   cmd:"" group:"Strip"`
+	Bus     BusCmdGroup     `help:"Control the buses."                    cmd:"" group:"Bus"`
+	Headamp HeadampCmdGroup `help:"Control input gain and phantom power." cmd:"" group:"Headamp"`
+}

 func main() {
-	cmd.Execute()
+	var cli CLI
+	kongcompletion.Register(kong.Must(&cli))
+	ctx := kong.Parse(
+		&cli,
+		kong.Name("xair-cli"),
+		kong.Description("A CLI to control Behringer X-Air mixers."),
+		kong.UsageOnError(),
+		kong.ConfigureHelp(kong.HelpOptions{
+			Compact: true,
+		}),
+		kong.Vars{
+			"version": func() string {
+				if version == "" {
+					info, ok := debug.ReadBuildInfo()
+					if !ok {
+						return "(unable to read build info)"
+					}
+					version = strings.Split(info.Main.Version, "-")[0]
+				}
+				return version
+			}(),
+		},
+	)
+
+	ctx.FatalIfErrorf(run(ctx, cli.Config))
+}
+
+// run is the main entry point for the CLI.
+// It connects to the X-Air device, retrieves mixer info, and then runs the command.
+func run(ctx *kong.Context, config Config) error {
+	client, err := connect(config)
+	if err != nil {
+		return fmt.Errorf("failed to connect to X-Air device: %w", err)
+	}
+	defer client.Close()
+
+	client.StartListening()
+	resp, err := client.RequestInfo()
+	if err != nil {
+		return err
+	}
+	log.Infof("Received mixer info: %+v", resp)
+
+	ctx.Bind(&context{
+		Client: client,
+		Out:    os.Stdout,
+	})
+
+	return ctx.Run()
+}
+
+func connect(config Config) (*xair.Client, error) {
+	client, err := xair.NewClient(config.Host, config.Port, xair.WithKind(config.Kind))
+	if err != nil {
+		return nil, err
+	}
+
+	return client, nil
 }
--- a/raw.go
+++ b/raw.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+type RawCmd struct {
+	Timeout time.Duration `help:"Timeout for the OSC message send operation."  default:"200ms" short:"t"`
+	Address string        `help:"The OSC address to send the message to."                                arg:""`
+	Args    []string      `help:"The arguments to include in the OSC message."                           arg:"" optional:""`
+}
+
+func (cmd *RawCmd) Run(ctx *context) error {
+	params := make([]any, len(cmd.Args))
+	for i, arg := range cmd.Args {
+		params[i] = arg
+	}
+	if err := ctx.Client.SendMessage(cmd.Address, params...); err != nil {
+		return fmt.Errorf("failed to send raw OSC message: %w", err)
+	}
+
+	msg, err := ctx.Client.ReceiveMessage(cmd.Timeout)
+	if err != nil {
+		return fmt.Errorf("failed to receive response for raw OSC message: %w", err)
+	}
+	if msg != nil {
+		fmt.Fprintf(ctx.Out, "Received response: %s with args: %v\n", msg.Address, msg.Arguments)
+	}
+
+	return nil
+}
--- a/strip.go
+++ b/strip.go
@@ -0,0 +1,665 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/alecthomas/kong"
+)
+
+type StripCmdGroup struct {
+	Index struct {
+		Index   int             `arg:"" help:"The index of the strip. (1-based indexing)"`
+		Mute    StripMuteCmd    `       help:"Get or set the mute state of the strip." cmd:""`
+		Fader   StripFaderCmd   `     help:"Get or set the fader level of the strip." cmd:""`
+		Fadein  StripFadeinCmd  `      help:"Fade in the strip over a specified duration." cmd:""`
+		Fadeout StripFadeoutCmd `     help:"Fade out the strip over a specified duration." cmd:""`
+		Send    StripSendCmd    `      help:"Get or set the send level for a specific bus." cmd:""`
+		Name    StripNameCmd    `      help:"Get or set the name of the strip." cmd:""`
+
+		Gate StripGateCmdGroup `     help:"Commands related to the strip gate." cmd:"gate"`
+		Eq   StripEqCmdGroup   `       help:"Commands related to the strip EQ." cmd:"eq"`
+		Comp StripCompCmdGroup `      help:"Commands related to the strip compressor." cmd:"comp"`
+	} `arg:"" help:"The index of the strip."`
+}
+
+type StripMuteCmd struct {
+	State *string `arg:"" help:"The mute state to set (true or false). If not provided, the current mute state will be returned." optional:"" enum:"true,false"`
+}
+
+func (cmd *StripMuteCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.State == nil {
+		resp, err := ctx.Client.Strip.Mute(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get mute state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d mute state: %t\n", strip.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type StripFaderCmd struct {
+	Level *float64 `arg:"" help:"The fader level to set (in dB)." optional:""`
+}
+
+func (cmd *StripFaderCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Level == nil {
+		resp, err := ctx.Client.Strip.Fader(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get fader level: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d fader level: %.2f dB\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.SetFader(strip.Index.Index, *cmd.Level); err != nil {
+		return fmt.Errorf("failed to set fader level: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d fader level set to: %.2f dB\n", strip.Index.Index, *cmd.Level)
+	return nil
+}
+
+type StripFadeinCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-in (in seconds)." default:"5s"`
+	Target   float64       `        help:"The target fader level (in dB)."           default:"0.0" arg:""`
+}
+
+func (cmd *StripFadeinCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	currentLevel, err := ctx.Client.Strip.Fader(strip.Index.Index)
+	if err != nil {
+		return fmt.Errorf("failed to get current fader level: %w", err)
+	}
+
+	if currentLevel >= cmd.Target {
+		return fmt.Errorf(
+			"current fader level (%.2f dB) is already at or above the target level (%.2f dB)",
+			currentLevel,
+			cmd.Target,
+		)
+	}
+
+	totalSteps := float64(cmd.Target - currentLevel)
+	stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+	for currentLevel < cmd.Target {
+		currentLevel++
+		if err := ctx.Client.Strip.SetFader(strip.Index.Index, currentLevel); err != nil {
+			return fmt.Errorf("failed to set fader level during fade-in: %w", err)
+		}
+		time.Sleep(stepDuration)
+	}
+
+	fmt.Fprintf(ctx.Out, "Strip %d fade-in complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
+	return nil
+}
+
+type StripFadeoutCmd struct {
+	Duration time.Duration `flag:"" help:"The duration of the fade-out (in seconds)." default:"5s"`
+	Target   float64       `        help:"The target fader level (in dB)."            default:"-90.0" arg:""`
+}
+
+func (cmd *StripFadeoutCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	{
+		currentLevel, err := ctx.Client.Strip.Fader(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get current fader level: %w", err)
+		}
+
+		if currentLevel <= cmd.Target {
+			return fmt.Errorf(
+				"current fader level (%.2f dB) is already at or below the target level (%.2f dB)",
+				currentLevel,
+				cmd.Target,
+			)
+		}
+
+		totalSteps := float64(currentLevel - cmd.Target)
+		stepDuration := time.Duration(cmd.Duration.Seconds()*1000/totalSteps) * time.Millisecond
+		for currentLevel > cmd.Target {
+			currentLevel--
+			if err := ctx.Client.Strip.SetFader(strip.Index.Index, currentLevel); err != nil {
+				return fmt.Errorf("failed to set fader level during fade-out: %w", err)
+			}
+			time.Sleep(stepDuration)
+		}
+
+		fmt.Fprintf(ctx.Out, "Strip %d fade-out complete. Final level: %.2f dB\n", strip.Index.Index, cmd.Target)
+		return nil
+	}
+}
+
+type StripSendCmd struct {
+	BusNum int     `arg:"" help:"The bus number to get or set the send level for."`
+	Level  *string `arg:"" help:"The send level to set (in dB)."                   optional:""`
+}
+
+func (cmd *StripSendCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Level == nil {
+		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(ctx.Out, "Strip %d send level for bus %d: %.2f dB\n", strip.Index.Index, cmd.BusNum, resp)
+		return nil
+	}
+
+	level := mustConvToFloat64(*cmd.Level)
+	if err := ctx.Client.Strip.SetSendLevel(strip.Index.Index, cmd.BusNum, level); err != nil {
+		return fmt.Errorf("failed to set send level: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d send level for bus %d set to: %.2f dB\n", strip.Index.Index, cmd.BusNum, level)
+	return nil
+}
+
+type StripNameCmd struct {
+	Name *string `arg:"" help:"The name to set for the strip." optional:""`
+}
+
+func (cmd *StripNameCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Name == nil {
+		resp, err := ctx.Client.Strip.Name(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get strip name: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d name: %s\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.SetName(strip.Index.Index, *cmd.Name); err != nil {
+		return fmt.Errorf("failed to set strip name: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d name set to: %s\n", strip.Index.Index, *cmd.Name)
+	return nil
+}
+
+type StripGateCmdGroup struct {
+	On        StripGateOnCmd        `help:"Get or set the gate on/off state of the strip." cmd:""`
+	Mode      StripGateModeCmd      `help:"Get or set the gate mode of the strip."         cmd:""`
+	Threshold StripGateThresholdCmd `help:"Get or set the gate threshold of the strip."    cmd:""`
+	Range     StripGateRangeCmd     `help:"Get the gate range of the strip."               cmd:""`
+	Attack    StripGateAttackCmd    `help:"Get or set the gate attack time of the strip."  cmd:""`
+	Hold      StripGateHoldCmd      `help:"Get or set the gate hold time of the strip."    cmd:""`
+	Release   StripGateReleaseCmd   `help:"Get or set the gate release time of the strip." cmd:""`
+}
+
+type StripGateOnCmd struct {
+	Enable *string `arg:"" help:"Whether to enable or disable the gate." optional:"" enum:"true,false"`
+}
+
+func (cmd *StripGateOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Enable == nil {
+		resp, err := ctx.Client.Strip.Gate.On(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate state: %t\n", strip.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type StripGateModeCmd struct {
+	Mode *string `arg:"" help:"The gate mode to set." optional:"" enum:"exp2,exp3,exp4,gate,duck"`
+}
+
+func (cmd *StripGateModeCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Mode == nil {
+		resp, err := ctx.Client.Strip.Gate.Mode(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate mode: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate mode: %s\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Gate.SetMode(strip.Index.Index, *cmd.Mode); err != nil {
+		return fmt.Errorf("failed to set gate mode: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d gate mode set to: %s\n", strip.Index.Index, *cmd.Mode)
+	return nil
+}
+
+type StripGateThresholdCmd struct {
+	Threshold *float64 `arg:"" help:"The gate threshold to set (in dB)." optional:""`
+}
+
+func (cmd *StripGateThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Threshold == nil {
+		resp, err := ctx.Client.Strip.Gate.Threshold(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate threshold: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate threshold: %.2f\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d gate threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
+	return nil
+}
+
+type StripGateRangeCmd struct {
+	Range *float64 `arg:"" help:"The gate range to set (in dB)." optional:""`
+}
+
+func (cmd *StripGateRangeCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Range == nil {
+		resp, err := ctx.Client.Strip.Gate.Range(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate range: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate range: %.2f\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Gate.SetRange(strip.Index.Index, *cmd.Range); err != nil {
+		return fmt.Errorf("failed to set gate range: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d gate range set to: %.2f\n", strip.Index.Index, *cmd.Range)
+	return nil
+}
+
+type StripGateAttackCmd struct {
+	Attack *float64 `arg:"" help:"The gate attack time to set (in ms)." optional:""`
+}
+
+func (cmd *StripGateAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Attack == nil {
+		resp, err := ctx.Client.Strip.Gate.Attack(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate attack time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate attack time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d gate attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
+	return nil
+}
+
+type StripGateHoldCmd struct {
+	Hold *float64 `arg:"" help:"The gate hold time to set (in ms)." optional:""`
+}
+
+func (cmd *StripGateHoldCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Hold == nil {
+		resp, err := ctx.Client.Strip.Gate.Hold(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate hold time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate hold time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Gate.SetHold(strip.Index.Index, *cmd.Hold); err != nil {
+		return fmt.Errorf("failed to set gate hold time: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d gate hold time set to: %.2f ms\n", strip.Index.Index, *cmd.Hold)
+	return nil
+}
+
+type StripGateReleaseCmd struct {
+	Release *float64 `arg:"" help:"The gate release time to set (in ms)." optional:""`
+}
+
+func (cmd *StripGateReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Release == nil {
+		resp, err := ctx.Client.Strip.Gate.Release(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get gate release time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d gate release time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d gate release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
+	return nil
+}
+
+type StripEqCmdGroup struct {
+	On   StripEqOnCmd `help:"Get or set the EQ on/off state of the strip."              cmd:""`
+	Band struct {
+		Band int                `arg:"" help:"The EQ band number."`
+		Gain StripEqBandGainCmd `help:"Get or set the gain of the EQ band." cmd:""`
+		Freq StripEqBandFreqCmd `help:"Get or set the frequency of the EQ band." cmd:""`
+		Q    StripEqBandQCmd    `help:"Get or set the Q factor of the EQ band." cmd:""`
+		Type StripEqBandTypeCmd `help:"Get or set the type of the EQ band." cmd:""`
+	} `help:"Commands for controlling a specific EQ band of the strip."        arg:""`
+}
+
+func (cmd *StripEqCmdGroup) Validate(ctx kong.Context) error {
+	if cmd.Band.Band < 1 || cmd.Band.Band > 4 {
+		return fmt.Errorf("EQ band number must be between 1 and 4")
+	}
+	return nil
+}
+
+type StripEqOnCmd struct {
+	Enable *string `arg:"" help:"Whether to enable or disable the EQ." optional:"" enum:"true,false"`
+}
+
+func (cmd *StripEqOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Enable == nil {
+		resp, err := ctx.Client.Strip.Eq.On(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get EQ state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d EQ state: %t\n", strip.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type StripEqBandGainCmd struct {
+	Gain *float64 `arg:"" help:"The gain to set for the EQ band (in dB)." optional:""`
+}
+
+func (cmd *StripEqBandGainCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
+	if cmd.Gain == nil {
+		resp, err := ctx.Client.Strip.Eq.Gain(strip.Index.Index, stripEq.Band.Band)
+		if err != nil {
+			return fmt.Errorf("failed to get EQ band gain: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Eq.SetGain(strip.Index.Index, stripEq.Band.Band, *cmd.Gain); err != nil {
+		return fmt.Errorf("failed to set EQ band gain: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d gain set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Gain)
+	return nil
+}
+
+type StripEqBandFreqCmd struct {
+	Freq *float64 `arg:"" help:"The frequency to set for the EQ band (in Hz)." optional:""`
+}
+
+func (cmd *StripEqBandFreqCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
+	if cmd.Freq == nil {
+		resp, err := ctx.Client.Strip.Eq.Frequency(strip.Index.Index, stripEq.Band.Band)
+		if err != nil {
+			return fmt.Errorf("failed to get EQ band frequency: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d frequency: %.2f Hz\n", strip.Index.Index, stripEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Eq.SetFrequency(strip.Index.Index, stripEq.Band.Band, *cmd.Freq); err != nil {
+		return fmt.Errorf("failed to set EQ band frequency: %w", err)
+	}
+	fmt.Fprintf(
+		ctx.Out,
+		"Strip %d EQ band %d frequency set to: %.2f Hz\n",
+		strip.Index.Index,
+		stripEq.Band.Band,
+		*cmd.Freq,
+	)
+	return nil
+}
+
+type StripEqBandQCmd struct {
+	Q *float64 `arg:"" help:"The Q factor to set for the EQ band." optional:""`
+}
+
+func (cmd *StripEqBandQCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
+	if cmd.Q == nil {
+		resp, err := ctx.Client.Strip.Eq.Q(strip.Index.Index, stripEq.Band.Band)
+		if err != nil {
+			return fmt.Errorf("failed to get EQ band Q factor: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d Q factor: %.2f\n", strip.Index.Index, stripEq.Band.Band, resp)
+		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(ctx.Out, "Strip %d EQ band %d Q factor set to: %.2f\n", strip.Index.Index, stripEq.Band.Band, *cmd.Q)
+	return nil
+}
+
+type StripEqBandTypeCmd struct {
+	Type *string `arg:"" help:"The type to set for the EQ band." optional:"" enum:"lcut,lshv,peq,veq,hshv,hcut"`
+}
+
+func (cmd *StripEqBandTypeCmd) Run(ctx *context, strip *StripCmdGroup, stripEq *StripEqCmdGroup) error {
+	if cmd.Type == nil {
+		resp, err := ctx.Client.Strip.Eq.Type(strip.Index.Index, stripEq.Band.Band)
+		if err != nil {
+			return fmt.Errorf("failed to get EQ band type: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type: %s\n", strip.Index.Index, stripEq.Band.Band, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Eq.SetType(strip.Index.Index, stripEq.Band.Band, *cmd.Type); err != nil {
+		return fmt.Errorf("failed to set EQ band type: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d EQ band %d type set to: %s\n", strip.Index.Index, stripEq.Band.Band, *cmd.Type)
+	return nil
+}
+
+type StripCompCmdGroup struct {
+	On        StripCompOnCmd        `help:"Get or set the compressor on/off state of the strip." cmd:""`
+	Mode      StripCompModeCmd      `help:"Get or set the compressor mode of the strip."         cmd:""`
+	Threshold StripCompThresholdCmd `help:"Get or set the compressor threshold of the strip."    cmd:""`
+	Ratio     StripCompRatioCmd     `help:"Get or set the compressor ratio of the strip."        cmd:""`
+	Mix       StripCompMixCmd       `help:"Get or set the compressor mix of the strip."          cmd:""`
+	Makeup    StripCompMakeupCmd    `help:"Get or set the compressor makeup gain of the strip."  cmd:""`
+	Attack    StripCompAttackCmd    `help:"Get or set the compressor attack time of the strip."  cmd:""`
+	Hold      StripCompHoldCmd      `help:"Get or set the compressor hold time of the strip."    cmd:""`
+	Release   StripCompReleaseCmd   `help:"Get or set the compressor release time of the strip." cmd:""`
+}
+
+type StripCompOnCmd struct {
+	Enable *string `arg:"" help:"Whether to enable or disable the compressor." optional:"" enum:"true,false"`
+}
+
+func (cmd *StripCompOnCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Enable == nil {
+		resp, err := ctx.Client.Strip.Comp.On(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor state: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor state: %t\n", strip.Index.Index, resp)
+		return 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)
+	return nil
+}
+
+type StripCompModeCmd struct {
+	Mode *string `arg:"" help:"The compressor mode to set." optional:"" enum:"comp,exp"`
+}
+
+func (cmd *StripCompModeCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Mode == nil {
+		resp, err := ctx.Client.Strip.Comp.Mode(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor mode: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor mode: %s\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Comp.SetMode(strip.Index.Index, *cmd.Mode); err != nil {
+		return fmt.Errorf("failed to set compressor mode: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d compressor mode set to: %s\n", strip.Index.Index, *cmd.Mode)
+	return nil
+}
+
+type StripCompThresholdCmd struct {
+	Threshold *float64 `arg:"" help:"The compressor threshold to set (in dB)." optional:""`
+}
+
+func (cmd *StripCompThresholdCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Threshold == nil {
+		resp, err := ctx.Client.Strip.Comp.Threshold(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor threshold: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor threshold: %.2f\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d compressor threshold set to: %.2f\n", strip.Index.Index, *cmd.Threshold)
+	return nil
+}
+
+type StripCompRatioCmd struct {
+	Ratio *float64 `arg:"" help:"The compressor ratio to set." optional:""`
+}
+
+func (cmd *StripCompRatioCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Ratio == nil {
+		resp, err := ctx.Client.Strip.Comp.Ratio(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor ratio: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor ratio: %.2f\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Comp.SetRatio(strip.Index.Index, *cmd.Ratio); err != nil {
+		return fmt.Errorf("failed to set compressor ratio: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d compressor ratio set to: %.2f\n", strip.Index.Index, *cmd.Ratio)
+	return nil
+}
+
+type StripCompMixCmd struct {
+	Mix *float64 `arg:"" help:"The compressor mix to set (0-100%)." optional:""`
+}
+
+func (cmd *StripCompMixCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Mix == nil {
+		resp, err := ctx.Client.Strip.Comp.Mix(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor mix: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor mix: %.2f%%\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	if err := ctx.Client.Strip.Comp.SetMix(strip.Index.Index, *cmd.Mix); err != nil {
+		return fmt.Errorf("failed to set compressor mix: %w", err)
+	}
+	fmt.Fprintf(ctx.Out, "Strip %d compressor mix set to: %.2f%%\n", strip.Index.Index, *cmd.Mix)
+	return nil
+}
+
+type StripCompMakeupCmd struct {
+	Makeup *float64 `arg:"" help:"The compressor makeup gain to set (in dB)." optional:""`
+}
+
+func (cmd *StripCompMakeupCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Makeup == nil {
+		resp, err := ctx.Client.Strip.Comp.Makeup(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor makeup gain: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor makeup gain: %.2f\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d compressor makeup gain set to: %.2f\n", strip.Index.Index, *cmd.Makeup)
+	return nil
+}
+
+type StripCompAttackCmd struct {
+	Attack *float64 `arg:"" help:"The compressor attack time to set (in ms)." optional:""`
+}
+
+func (cmd *StripCompAttackCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Attack == nil {
+		resp, err := ctx.Client.Strip.Comp.Attack(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor attack time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor attack time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d compressor attack time set to: %.2f ms\n", strip.Index.Index, *cmd.Attack)
+	return nil
+}
+
+type StripCompHoldCmd struct {
+	Hold *float64 `arg:"" help:"The compressor hold time to set (in ms)." optional:""`
+}
+
+func (cmd *StripCompHoldCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Hold == nil {
+		resp, err := ctx.Client.Strip.Comp.Hold(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor hold time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor hold time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d compressor hold time set to: %.2f ms\n", strip.Index.Index, *cmd.Hold)
+	return nil
+}
+
+type StripCompReleaseCmd struct {
+	Release *float64 `arg:"" help:"The compressor release time to set (in ms)." optional:""`
+}
+
+func (cmd *StripCompReleaseCmd) Run(ctx *context, strip *StripCmdGroup) error {
+	if cmd.Release == nil {
+		resp, err := ctx.Client.Strip.Comp.Release(strip.Index.Index)
+		if err != nil {
+			return fmt.Errorf("failed to get compressor release time: %w", err)
+		}
+		fmt.Fprintf(ctx.Out, "Strip %d compressor release time: %.2f ms\n", strip.Index.Index, resp)
+		return nil
+	}
+
+	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(ctx.Out, "Strip %d compressor release time set to: %.2f ms\n", strip.Index.Index, *cmd.Release)
+	return nil
+}
--- a/util.go
+++ b/util.go
@@ -0,0 +1,12 @@
+package main
+
+import "strconv"
+
+// mustConvToFloat64 converts a string to float64, panicking on error.
+func mustConvToFloat64(floatStr string) float64 {
+	level, err := strconv.ParseFloat(floatStr, 64)
+	if err != nil {
+		panic(err)
+	}
+	return level
+}
Author	SHA1	Message	Date
onyx-and-iris	b075515654	upd README	2026-02-05 04:02:01 +00:00
onyx-and-iris	139e092937	raw doesn't need to be a command group fix `nil pointer deference` for set commands	2026-02-05 04:01:34 +00:00
onyx-and-iris	8539685770	upd README	2026-02-05 03:55:08 +00:00
onyx-and-iris	8fc5a55eff	fixes bug where strip/bus eq on would try to validate the band number.	2026-02-05 03:54:53 +00:00
onyx-and-iris	128f0c1df6	migrate CLI component to Kong	2026-02-05 03:36:22 +00:00
onyx-and-iris	49cf3ff49e	upd Name methods	2026-02-04 11:18:17 +00:00
onyx-and-iris	66ab937296	implement Snapshot on Client struct	2026-02-04 11:15:52 +00:00
onyx-and-iris	6f995397a1	fix example	2026-02-04 10:46:20 +00:00
onyx-and-iris	e6d6ac77f6	upd long desc	2026-02-04 10:45:26 +00:00
onyx-and-iris	b39dc86236	add raw command for sending raw OSC messages	2026-02-04 10:44:06 +00:00
onyx-and-iris	056ebc9116	add strip comp mode + strip gate subcommands	2026-02-04 07:31:00 +00:00
onyx-and-iris	ce955deb38	add bus comp mode	2026-02-04 07:30:44 +00:00
onyx-and-iris	6e3953e946	print hold to 2dp	2026-02-04 05:27:48 +00:00
onyx-and-iris	86ff40952b	implement {Comp} threshold, ratio, attack, hold, release, makeup and mix methods add new compressor subcommands to strip/bus command groups	2026-02-04 05:22:47 +00:00
onyx-and-iris	2590a43c18	fix examples in README reword Notes section	2026-02-03 01:23:04 +00:00
onyx-and-iris	0559899666	add eq example + update notes section in README.	2026-02-02 04:28:39 +00:00
github-actions[bot]	20fed03c48	chore: auto-update Go modules	2026-02-02 00:04:06 +00:00
onyx-and-iris	fc36e9bf5c	implement eq type/mode/gain/freq/q commands for strip/bus	2026-02-01 22:37:17 +00:00
onyx-and-iris	a9110f0986	implement strip/bus gate/comp on commands	2026-02-01 15:50:11 +00:00
onyx-and-iris	72f43452a8	pass pointers to factory methods	2026-02-01 15:09:45 +00:00
onyx-and-iris	89ab8ee258	setup the skeletal structure for Eq, Comp and Gate. implement strip/bus eq on commands.	2026-02-01 15:09:38 +00:00
onyx-and-iris	c4a86adf14	upd fadeout main lr desc	2026-02-01 04:17:55 +00:00
onyx-and-iris	1623b53cff	headamp gain now accepts a --duration flag for safe gain staging.	2026-02-01 04:15:59 +00:00
onyx-and-iris	98e131d4ad	reword	2026-02-01 03:43:21 +00:00
onyx-and-iris	c44413da6b	add examples, notes and license to README	2026-02-01 03:37:42 +00:00
onyx-and-iris	90839d24a1	use baseAddress	2026-02-01 03:20:14 +00:00
onyx-and-iris	7d521e0111	remove LICENSE header from main.go	2026-02-01 02:19:29 +00:00
onyx-and-iris	625987759f	remove methods now implemented in headamp struct	2026-02-01 02:07:09 +00:00
onyx-and-iris	08b232dcbf	use RunE throughout	2026-02-01 01:56:03 +00:00
onyx-and-iris	0b72556b7e	upd readme	2026-02-01 01:31:17 +00:00
onyx-and-iris	9898c21197	add headamp gain and phantom commands	2026-02-01 01:25:47 +00:00
onyx-and-iris	64b4be032f	use addressMap in strip struct	2026-02-01 00:53:32 +00:00
onyx-and-iris	d894cc1317	add strip/bus name commands	2026-02-01 00:50:24 +00:00
onyx-and-iris	4c4d52c74e	add --version flag	2026-01-31 23:13:09 +00:00
onyx-and-iris	7536c4fe24	reword short desc for strip send	2026-01-31 22:59:26 +00:00
onyx-and-iris	2730f8dc5d	reorganise command fields	2026-01-31 22:26:31 +00:00
onyx-and-iris	e7dd589243	update use strings	2026-01-31 21:33:05 +00:00
onyx-and-iris	a0663350f8	add strip send command	2026-01-31 21:30:48 +00:00
onyx-and-iris	ad7c910180	move main methods into Main struct update the cli	2026-01-31 21:19:38 +00:00
onyx-and-iris	615a95d9da	move bus commands into bus struct update the cli	2026-01-31 20:55:36 +00:00
onyx-and-iris	19779ae4c1	move lower level logic into engine	2026-01-31 20:48:09 +00:00
onyx-and-iris	fc8c8ad69a	move strip commands into their own struct update the cli	2026-01-31 20:40:29 +00:00
onyx-and-iris	205baf310f	lint fix	2026-01-31 20:04:31 +00:00
onyx-and-iris	d823aeeb8e	lint fixes	2026-01-31 19:33:04 +00:00
onyx-and-iris	d1657e09ab	implement strip fader commands	2026-01-31 19:31:33 +00:00
onyx-and-iris	c851d0e804	lint fixes	2026-01-31 19:28:59 +00:00