onyx_online/xair-cli
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/xair-cli.git synced 2026-02-26 08:19:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

timeout now a flag on the root command.

Browse Source 
It applies to all messages sent

new option function WithTimeout added
This commit is contained in:
onyx-and-iris 2026-02-06 11:28:40 +00:00
parent 1ad214ba4a
commit 3f8861ded2
13 changed files with 223 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
internal/xair/bus.go
View File

@ -26,8 +26,11 @@ func (b *Bus) Mute(bus int) (bool, error) {
return false, err return false, err
} }
resp := <-b.client.respChan msg, err := b.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for bus mute value") return false, fmt.Errorf("unexpected argument type for bus mute value")
} }
@ -52,8 +55,11 @@ func (b *Bus) Fader(bus int) (float64, error) {
return 0, err return 0, err
} }
resp := <-b.client.respChan msg, err := b.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for bus fader value") return 0, fmt.Errorf("unexpected argument type for bus fader value")
} }
@ -75,8 +81,11 @@ func (b *Bus) Name(bus int) (string, error) {
return "", fmt.Errorf("failed to send bus name request: %v", err) return "", fmt.Errorf("failed to send bus name request: %v", err)
} }
resp := <-b.client.respChan msg, err := b.client.ReceiveMessage()
val, ok := resp.Arguments[0].(string) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(string)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for bus name value") return "", fmt.Errorf("unexpected argument type for bus name value")
} }

30
internal/xair/client.go
View File

@ -41,6 +41,7 @@ func NewClient(mixerIP string, mixerPort int, opts ...Option) (*Client, error) {
e := &engine{ e := &engine{
Kind: KindXAir, Kind: KindXAir,
timeout: 100 * time.Millisecond,
conn: conn, conn: conn,
mixerAddr: mixerAddr, mixerAddr: mixerAddr,
parser: newParser(), parser: newParser(),
@ -85,32 +86,35 @@ func (c *Client) SendMessage(address string, args ...any) error {
} }
// ReceiveMessage receives an OSC message from the mixer // ReceiveMessage receives an OSC message from the mixer
func (c *Client) ReceiveMessage(timeout time.Duration) (*osc.Message, error) { func (c *Client) ReceiveMessage() (*osc.Message, error) {
t := time.Tick(timeout) t := time.Tick(c.engine.timeout)
select { select {
case <-t: case <-t:
return nil, nil return nil, fmt.Errorf("timeout waiting for response")
case val := <-c.respChan: case msg := <-c.respChan:
if val == nil { if msg == nil {
return nil, fmt.Errorf("no message received") return nil, fmt.Errorf("no message received")
} }
return val, nil return msg, nil
} }
} }
// RequestInfo requests mixer information // RequestInfo requests mixer information
func (c *Client) RequestInfo() (InfoResponse, error) { func (c *Client) RequestInfo() (InfoResponse, error) {
var info InfoResponse
err := c.SendMessage("/xinfo") err := c.SendMessage("/xinfo")
if err != nil { if err != nil {
return InfoResponse{}, err return info, err
} }
val := <-c.respChan msg, err := c.ReceiveMessage()
var info InfoResponse if err != nil {
if len(val.Arguments) >= 3 { return info, err
info.Host = val.Arguments[0].(string) }
info.Name = val.Arguments[1].(string) if len(msg.Arguments) >= 3 {
info.Model = val.Arguments[2].(string) info.Host = msg.Arguments[0].(string)
info.Name = msg.Arguments[1].(string)
info.Model = msg.Arguments[2].(string)
} }
return info, nil return info, nil
} }

63
internal/xair/comp.go
View File

@ -31,8 +31,11 @@ func (c *Comp) On(index int) (bool, error) {
return false, err return false, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for Compressor on value") return false, fmt.Errorf("unexpected argument type for Compressor on value")
} }
@ -59,8 +62,11 @@ func (c *Comp) Mode(index int) (string, error) {
possibleModes := []string{"comp", "exp"} possibleModes := []string{"comp", "exp"}
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for Compressor mode value") return "", fmt.Errorf("unexpected argument type for Compressor mode value")
} }
@ -82,8 +88,11 @@ func (c *Comp) Threshold(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor threshold value") return 0, fmt.Errorf("unexpected argument type for Compressor threshold value")
} }
@ -106,8 +115,11 @@ func (c *Comp) Ratio(index int) (float32, error) {
possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100} 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 msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor ratio value") return 0, fmt.Errorf("unexpected argument type for Compressor ratio value")
} }
@ -131,8 +143,11 @@ func (c *Comp) Attack(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor attack value") return 0, fmt.Errorf("unexpected argument type for Compressor attack value")
} }
@ -153,8 +168,11 @@ func (c *Comp) Hold(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor hold value") return 0, fmt.Errorf("unexpected argument type for Compressor hold value")
} }
@ -175,8 +193,11 @@ func (c *Comp) Release(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor release value") return 0, fmt.Errorf("unexpected argument type for Compressor release value")
} }
@ -197,8 +218,11 @@ func (c *Comp) Makeup(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor makeup gain value") return 0, fmt.Errorf("unexpected argument type for Compressor makeup gain value")
} }
@ -219,8 +243,11 @@ func (c *Comp) Mix(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-c.client.respChan msg, err := c.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Compressor mix value") return 0, fmt.Errorf("unexpected argument type for Compressor mix value")
} }

3
internal/xair/engine.go
View File

@ -15,6 +15,7 @@ type parser interface {
type engine struct { type engine struct {
Kind MixerKind Kind MixerKind
timeout time.Duration
conn *net.UDPConn conn *net.UDPConn
mixerAddr *net.UDPAddr mixerAddr *net.UDPAddr
@ -34,7 +35,7 @@ func (e *engine) receiveLoop() {
case <-e.done: case <-e.done:
return return
default: default:
// Set read timeout to avoid blocking forever // Set a short read deadline to prevent blocking indefinitely
e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond)) e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
n, _, err := e.conn.ReadFromUDP(buffer) n, _, err := e.conn.ReadFromUDP(buffer)
if err != nil { if err != nil {

42
internal/xair/eq.go
View File

@ -31,8 +31,11 @@ func (e *Eq) On(index int) (bool, error) {
return false, err return false, err
} }
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for EQ on value") return false, fmt.Errorf("unexpected argument type for EQ on value")
} }
@ -58,8 +61,11 @@ func (e *Eq) Mode(index int) (string, error) {
possibleModes := []string{"peq", "geq", "teq"} possibleModes := []string{"peq", "geq", "teq"}
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for EQ mode value") return "", fmt.Errorf("unexpected argument type for EQ mode value")
} }
@ -80,8 +86,11 @@ func (e *Eq) Gain(index int, band int) (float64, error) {
return 0, err return 0, err
} }
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ gain value") return 0, fmt.Errorf("unexpected argument type for EQ gain value")
} }
@ -102,8 +111,11 @@ func (e *Eq) Frequency(index int, band int) (float64, error) {
return 0, err return 0, err
} }
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ frequency value") return 0, fmt.Errorf("unexpected argument type for EQ frequency value")
} }
@ -124,8 +136,11 @@ func (e *Eq) Q(index int, band int) (float64, error) {
return 0, err return 0, err
} }
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for EQ Q value") return 0, fmt.Errorf("unexpected argument type for EQ Q value")
} }
@ -148,8 +163,11 @@ func (e *Eq) Type(index int, band int) (string, error) {
possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"} possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
resp := <-e.client.respChan msg, err := e.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for EQ type value") return "", fmt.Errorf("unexpected argument type for EQ type value")
} }

49
internal/xair/gate.go
View File

@ -19,8 +19,11 @@ func (g *Gate) On(index int) (bool, error) {
return false, err return false, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for Gate on value") return false, fmt.Errorf("unexpected argument type for Gate on value")
} }
@ -47,8 +50,11 @@ func (g *Gate) Mode(index int) (string, error) {
possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"} possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"}
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for Gate mode value") return "", fmt.Errorf("unexpected argument type for Gate mode value")
} }
@ -71,8 +77,11 @@ func (g *Gate) Threshold(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate threshold value") return 0, fmt.Errorf("unexpected argument type for Gate threshold value")
} }
@ -93,8 +102,11 @@ func (g *Gate) Range(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate range value") return 0, fmt.Errorf("unexpected argument type for Gate range value")
} }
@ -115,8 +127,11 @@ func (g *Gate) Attack(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate attack value") return 0, fmt.Errorf("unexpected argument type for Gate attack value")
} }
@ -137,8 +152,11 @@ func (g *Gate) Hold(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate hold value") return 0, fmt.Errorf("unexpected argument type for Gate hold value")
} }
@ -159,8 +177,11 @@ func (g *Gate) Release(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-g.client.respChan msg, err := g.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for Gate release value") return 0, fmt.Errorf("unexpected argument type for Gate release value")
} }

14
internal/xair/headamp.go
View File

@ -22,8 +22,11 @@ func (h *HeadAmp) Gain(index int) (float64, error) {
return 0, err return 0, err
} }
resp := <-h.client.respChan msg, err := h.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for headamp gain value") return 0, fmt.Errorf("unexpected argument type for headamp gain value")
} }
@ -45,8 +48,11 @@ func (h *HeadAmp) PhantomPower(index int) (bool, error) {
return false, err return false, err
} }
resp := <-h.client.respChan msg, err := h.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for phantom power value") return false, fmt.Errorf("unexpected argument type for phantom power value")
} }

14
internal/xair/main.go
View File

@ -31,8 +31,11 @@ func (m *Main) Fader() (float64, error) {
return 0, err return 0, err
} }
resp := <-m.client.respChan msg, err := m.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for main LR fader value") return 0, fmt.Errorf("unexpected argument type for main LR fader value")
} }
@ -53,8 +56,11 @@ func (m *Main) Mute() (bool, error) {
return false, err return false, err
} }
resp := <-m.client.respChan msg, err := m.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for main LR mute value") return false, fmt.Errorf("unexpected argument type for main LR mute value")
} }

8
internal/xair/option.go
View File

@ -1,5 +1,7 @@
package xair package xair
import "time"
type Option func(*engine) type Option func(*engine)
func WithKind(kind string) Option { func WithKind(kind string) Option {
@ -8,3 +10,9 @@ func WithKind(kind string) Option {
e.addressMap = addressMapForMixerKind(e.Kind) e.addressMap = addressMapForMixerKind(e.Kind)
} }
} }
func WithTimeout(timeout time.Duration) Option {
return func(e *engine) {
e.timeout = timeout
}
}

7
internal/xair/snapshot.go
View File

@ -22,8 +22,11 @@ func (s *Snapshot) Name(index int) (string, error) {
return "", err return "", err
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
name, ok := resp.Arguments[0].(string) if err != nil {
return "", err
}
name, ok := msg.Arguments[0].(string)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for snapshot name") return "", fmt.Errorf("unexpected argument type for snapshot name")
} }

35
internal/xair/strip.go
View File

@ -28,8 +28,11 @@ func (s *Strip) Mute(index int) (bool, error) {
return false, err return false, err
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return false, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return false, fmt.Errorf("unexpected argument type for strip mute value") return false, fmt.Errorf("unexpected argument type for strip mute value")
} }
@ -54,8 +57,11 @@ func (s *Strip) Fader(strip int) (float64, error) {
return 0, err return 0, err
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for fader value") return 0, fmt.Errorf("unexpected argument type for fader value")
} }
@ -77,8 +83,11 @@ func (s *Strip) Name(strip int) (string, error) {
return "", fmt.Errorf("failed to send strip name request: %v", err) return "", fmt.Errorf("failed to send strip name request: %v", err)
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
val, ok := resp.Arguments[0].(string) if err != nil {
return "", err
}
val, ok := msg.Arguments[0].(string)
if !ok { if !ok {
return "", fmt.Errorf("unexpected argument type for strip name value") return "", fmt.Errorf("unexpected argument type for strip name value")
} }
@ -99,8 +108,11 @@ func (s *Strip) Color(strip int) (int32, error) {
return 0, fmt.Errorf("failed to send strip color request: %v", err) return 0, fmt.Errorf("failed to send strip color request: %v", err)
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
val, ok := resp.Arguments[0].(int32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(int32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for strip color value") return 0, fmt.Errorf("unexpected argument type for strip color value")
} }
@ -121,8 +133,11 @@ func (s *Strip) SendLevel(strip int, bus int) (float64, error) {
return 0, fmt.Errorf("failed to send strip send level request: %v", err) return 0, fmt.Errorf("failed to send strip send level request: %v", err)
} }
resp := <-s.client.respChan msg, err := s.client.ReceiveMessage()
val, ok := resp.Arguments[0].(float32) if err != nil {
return 0, err
}
val, ok := msg.Arguments[0].(float32)
if !ok { if !ok {
return 0, fmt.Errorf("unexpected argument type for strip send level value") return 0, fmt.Errorf("unexpected argument type for strip send level value")
} }

15
main.go
View File

@ -6,6 +6,7 @@ import (
"os" "os"
"runtime/debug" "runtime/debug"
"strings" "strings"
"time"
"github.com/alecthomas/kong" "github.com/alecthomas/kong"
"github.com/charmbracelet/log" "github.com/charmbracelet/log"
@ -32,9 +33,10 @@ type context struct {
} }
type Config struct { type Config struct {
Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST" short:"H"` Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST" short:"H"`
Port int `default:"10024" help:"The port of the X-Air device." env:"XAIR_CLI_PORT" short:"P"` Port int `default:"10024" help:"The port of the X-Air device." env:"XAIR_CLI_PORT" short:"P"`
Kind string `default:"xair" help:"The kind of the X-Air device." env:"XAIR_CLI_KIND" short:"K" enum:"xair,x32"` Kind string `default:"xair" help:"The kind of the X-Air device." env:"XAIR_CLI_KIND" short:"K" enum:"xair,x32"`
Timeout time.Duration `default:"100ms" help:"Timeout for OSC operations." env:"XAIR_CLI_TIMEOUT" short:"T"`
} }
// CLI is the main struct for the command-line interface. // CLI is the main struct for the command-line interface.
@ -107,7 +109,12 @@ func run(ctx *kong.Context, config Config) error {
// connect creates a new X-Air client based on the provided configuration. // connect creates a new X-Air client based on the provided configuration.
func connect(config Config) (*xair.Client, error) { func connect(config Config) (*xair.Client, error) {
client, err := xair.NewClient(config.Host, config.Port, xair.WithKind(config.Kind)) client, err := xair.NewClient(
config.Host,
config.Port,
xair.WithKind(config.Kind),
xair.WithTimeout(config.Timeout),
)
if err != nil { if err != nil {
return nil, err return nil, err
} }

15
raw.go
View File

@ -2,14 +2,14 @@ package main
import ( import (
"fmt" "fmt"
"time"
"github.com/charmbracelet/log"
) )
// RawCmd represents the command to send raw OSC messages to the mixer. // RawCmd represents the command to send raw OSC messages to the mixer.
type RawCmd struct { type RawCmd struct {
Timeout time.Duration `help:"Timeout for the OSC message send operation." default:"100ms" short:"t" env:"XAIR_CLI_RAW_TIMEOUT"` Address string `help:"The OSC address to send the message to." arg:""`
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:""`
Args []string `help:"The arguments to include in the OSC message." arg:"" optional:""`
} }
// Run executes the RawCmd by sending the specified OSC message to the mixer and optionally waiting for a response. // Run executes the RawCmd by sending the specified OSC message to the mixer and optionally waiting for a response.
@ -22,7 +22,12 @@ func (cmd *RawCmd) Run(ctx *context) error {
return fmt.Errorf("failed to send raw OSC message: %w", err) return fmt.Errorf("failed to send raw OSC message: %w", err)
} }
msg, err := ctx.Client.ReceiveMessage(cmd.Timeout) if len(params) > 0 {
log.Debugf("Sent OSC message: %s with args: %v\n", cmd.Address, cmd.Args)
return nil
}
msg, err := ctx.Client.ReceiveMessage()
if err != nil { if err != nil {
return fmt.Errorf("failed to receive response for raw OSC message: %w", err) return fmt.Errorf("failed to receive response for raw OSC message: %w", err)
} }