.github/workflows/golang-ci.yml

@@ -2,11 +2,11 @@ name: CI
 
 on:
   push:
-    branches: ['main']
+    branches: [ "main" ]
     paths:
       - '**.go'
   pull_request:
-    branches: ['main']
+    branches: [ "main" ]
     paths:
       - '**.go'
 jobs:
@@ -23,8 +23,7 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version: '1.24'
-      - name: golangci-lint
+      - name: Install golangci-lint
-        uses: golangci/golangci-lint-action@v9
+        run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-        with:
+      - name: Run golangci-lint
-          version: v2.6.0
+        run: golangci-lint run ./...
-          args: --config .golangci.yml

.gitignore

@@ -17,5 +17,3 @@ bin/
 
 # Added by goreleaser init:
 dist/
-
-.envrc

.golangci.yml

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

.goreleaser.yaml

@@ -22,10 +22,8 @@ builds:
     goos:
       - linux
       - windows
-      - darwin
     goarch:
       - amd64
-      - arm64
 
 archives:
   - formats: ['tar.gz']
@@ -48,7 +46,6 @@ changelog:
     exclude:
       - '^docs:'
       - '^test:'
-      - '^chore:'
 
 release:
   footer: >-

.pre-commit-config.yaml

@@ -1,5 +0,0 @@
-repos:
-  - repo: https://github.com/tekwizely/pre-commit-golang
-    rev: v1.0.0-rc.4
-    hooks:
-      - id: go-mod-tidy

CHANGELOG.md

@@ -11,44 +11,6 @@ Before any major/minor/patch bump all unit tests will be run to verify they pass
 
 -   [x]
 
-# [0.6.0] - 2025-02-14
-
-### Added
-
-- streamname length validation added to {packet} factory method.
-
-### Changed
-- {packet}.bspIndex now defaults to *indexOf(BpsOpts, 256000)*.
-    -   this doesn't affect the CLI which already defaulted to 256000.
-- WithBPSOpt and WithChannel functional options now log at warn level if passed out of bounds value. They will fallback to valid defaults.
-
-# [0.5.0] - 2025-06-25
-
-### Added
-
--   it's now possible to load configuration from environment variables. See [Environment Variables](https://github.com/onyx-and-iris/vbantxt/tree/main?tab=readme-ov-file#environment-variables)
--   --version/-v command
-
-### Changed
-
--   shortname for --host flag is now -H.
--   shortname for --channel flag is now -n.
--   toml loader no longer requires a `[connection]` table. See [TOML Config](https://github.com/onyx-and-iris/vbantxt/tree/main?tab=readme-ov-file#toml-config)
-
-
-# [0.4.1] - 2025-04-05
-
-### Changed
-
--   `-loglevel` flag is now of type string. It accepts any one of trace, debug, info, warn, error, fatal or panic.
-    -   It defaults to warn.
-
-# [0.3.1] - 2025-03-31
-
-### Fixed
-
--   The CLI now uses `os.UserConfigDir()` to load the default *config.toml*, which should respect `$XDG_CONFIG_HOME`. See [UserConfigDir](https://pkg.go.dev/os#UserConfigDir)
-
 # [0.2.1] - 2024-11-07
 
 ### Fixed

README.md

@@ -1,6 +1,5 @@
 ![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white)
 ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)
-![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)
 
 # VBAN Sendtext
 
@@ -8,34 +7,23 @@ Send Voicemeeter/Matrix vban requests.
 
 For an outline of past/future changes refer to: [CHANGELOG](CHANGELOG.md)
 
----
+## Tested against
 
-## Table of Contents
+-   Basic 1.0.8.4
-
+-   Banana 2.0.6.4
-- [Installation](#installation)
+-   Potato 3.0.2.4
-- [VBANTXT Package](#vbantxt-package)
+-   Matrix 1.0.0.3
-- [VBANTXT CLI](#vbantxt-cli)
-- [License](#license)
 
 ## Requirements
 
 -   [Voicemeeter](https://voicemeeter.com/) or [Matrix](https://vb-audio.com/Matrix/)
--   Go 1.18 or greater (a binary is available in [Releases](https://github.com/onyx-and-iris/vbantxt/releases))
+-   Go 1.18 or greater (if you want to compile yourself, otherwise check `Releases`)
-
-## Tested against
-
--   Basic 1.1.2.2
--   Banana 2.1.2.2
--   Potato 3.1.2.2
--   Matrix 1.0.2.6
 
 ---
 
-## `VBANTXT Package`
+## `Use`
 
-```console
+`go get github.com/onyx-and-iris/vbantxt`
-go get github.com/onyx-and-iris/vbantxt
-```
 
 ```go
 package main
@@ -67,91 +55,44 @@ func main() {
 }
 ```
 
-## `VBANTXT CLI`
+## `Command Line`
 
-### Installation
+Pass `host`, `port` and `streamname` as flags, for example:
 
-```console
+```
-go install github.com/onyx-and-iris/vbantxt/cmd/vbantxt@latest
+vbantxt -h="gamepc.local" -p=6980 -s=Command1 "strip[0].mute=1 strip[1].mono=1"
 ```
 
-### Use
+You may also store them in a `config.toml` located in `home directory / .config / vbantxt /`
 
-Simply pass your vban commands as command line arguments:
+A valid `config.toml` might look like this:
-
-```console
-vbantxt "strip[0].mute=1 strip[1].mono=1"
-```
-
-### Configuration
-
-#### Flags
-
-```console
-FLAGS
-  -H, --host STRING         VBAN host (default: localhost)
-  -p, --port INT            VBAN port (default: 6980)
-  -s, --streamname STRING   VBAN stream name (default: Command1)
-  -b, --bps INT             VBAN BPS (default: 256000)
-  -n, --channel INT         VBAN channel (default: 0)
-  -r, --ratelimit INT       VBAN rate limit (ms) (default: 20)
-  -C, --config STRING       Path to the configuration file (default: $XDG_CONFIG_HOME/vbantxt/config.toml)
-  -l, --loglevel STRING     Log level (debug, info, warn, error, fatal, panic) (default: warn)
-  -v, --version             Show version information
-```
-
-Pass --host, --port and --streamname as flags on the root command, for example:
-
-```console
-vbantxt --host=localhost --port=6980 --streamname=Command1 --help
-```
-
-#### Environment Variables
-
-All flags have corresponding environment variables, prefixed with `VBANTXT_`:
-
-```bash
-#!/usr/bin/env bash
-
-export VBANTXT_HOST=localhost
-export VBANTXT_PORT=6980
-export VBANTXT_STREAMNAME=Command1
-```
-
-Flags will override environment variables.
-
-#### TOML Config
-
-By default the config loader will look for a config in:
-
--	$XDG_CONFIG_HOME / vbantxt / config.toml (see [os.UserConfigDir](https://pkg.go.dev/os#UserConfigDir))
-	-	A custom config path may be passed with the --config/-C flag.
-
-All flags have corresponding keys in the config file, for example:
 
 ```toml
+[connection]
 host="gamepc.local"
 port=6980
 streamname="Command1"
 ```
 
+-   `host` defaults to "localhost"
+-   `port` defaults to 6980
+-   `streamname` defaults to "Command1"
+
+Command line flags will override values in a config.toml.
+
 ---
 
 ## `Script files`
 
-The vbantxt CLI accepts a single string request or an array of string requests. This means you can pass scripts stored in files.
+The vbantxt-cli utility accepts a single string request or an array of string requests. This means you can pass scripts stored in files.
 
 For example, in Windows with Powershell you could:
 
-```console
+`vbantxt $(Get-Content .\script.txt)`
-vbantxt $(Get-Content .\script.txt)
-```
 
 Or with Bash:
 
-```console
+`xargs vbantxt < script.txt`
-xargs vbantxt < script.txt
-```
 
 to load commands from a file:
 
@@ -167,34 +108,16 @@ bus[3].eq.On=0
 
 Sending commands to VB-Audio Matrix is also possible, for example:
 
-```console
+```
-vbantxt "Point(ASIO128.IN[2],ASIO128.OUT[1]).dBGain = -8"
+vbantxt -s=streamname "Point(ASIO128.IN[2],ASIO128.OUT[1]).dBGain = -8"
 ```
 
 ---
 
 ## `Logging`
 
-The --loglevel/-l flag allows you to control the verbosity of the application's logging output. 
+Log level may be set by passing the `-l` flag with a number from 0 up to 6 where
 
-Acceptable values for this flag are:
+0 = Panic, 1 = Fatal, 2 = Error, 3 = Warning, 4 = Info, 5 = Debug, 6 = Trace
 
-- `debug`
+Log level defaults to Warning level.
-- `info`
-- `warn`
-- `error`
-- `fatal`
-- `panic`
-
-For example, to set the log level to `debug`, you can use:
-
-```console
-vbantxt --loglevel=debug "bus[0].eq.on=1 bus[1].gain=-12.8"
-```
-
-The default log level is `warn` if the flag is not specified.
-
-
-## License
-
-`vbantxt` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

Taskfile.yml

@@ -4,12 +4,11 @@ vars:
   PROGRAM: vbantxt
   SHELL: '{{if eq .OS "Windows_NT"}}powershell{{end}}'
   BIN_DIR: bin
-  VERSION:
-    sh: 'git describe --tags $(git rev-list --tags --max-count=1)'
 
   WINDOWS: '{{.BIN_DIR}}/{{.PROGRAM}}_windows_amd64.exe'
   LINUX: '{{.BIN_DIR}}/{{.PROGRAM}}_linux_amd64'
-  MACOS: '{{.BIN_DIR}}/{{.PROGRAM}}_darwin_amd64'
+  GIT_COMMIT:
+    sh: git log -n 1 --format=%h
 
 tasks:
   default:
@@ -23,7 +22,7 @@ tasks:
     cmds:
       - task: build-windows
       - task: build-linux
-      - task: build-macos
+
   vet:
     desc: Vet the code
     deps: [fmt]
@@ -38,20 +37,12 @@ tasks:
   build-windows:
     desc: Build the vbantxt project for Windows
     cmds:
-      - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}/
+      - GOOS=windows GOARCH=amd64 go build -o {{.WINDOWS}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}/
-    internal: true
 
   build-linux:
     desc: Build the vbantxt project for Linux
     cmds:
-      - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}/
+      - GOOS=linux GOARCH=amd64 go build -o {{.LINUX}} -ldflags="-X main.Version={{.GIT_COMMIT}}" ./cmd/{{.PROGRAM}}/
-    internal: true
-
-  build-macos:
-    desc: Build the vbantxt project for macOS
-    cmds:
-      - GOOS=darwin GOARCH=amd64 go build -o {{.MACOS}} -ldflags="-X main.version={{.VERSION}}" ./cmd/{{.PROGRAM}}/
-    internal: true
 
   test:
     desc: Run tests

cmd/vbantxt/config.go

@@ -0,0 +1,43 @@
+// Package main provides the configuration loading functionality for the vbantxt application.
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/BurntSushi/toml"
+	log "github.com/sirupsen/logrus"
+)
+
+type config struct {
+	Connection connection `toml:"connection"`
+}
+
+func (c config) String() string {
+	return fmt.Sprintf(
+		"host: %s port: %d streamname: %s",
+		c.Connection.Host, c.Connection.Port, c.Connection.Streamname)
+}
+
+type connection struct {
+	Host       string `toml:"host"`
+	Port       int    `toml:"port"`
+	Streamname string `toml:"streamname"`
+}
+
+func loadConfig(configPath string) (*connection, error) {
+	_, err := os.Stat(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var config config
+
+	_, err = toml.DecodeFile(configPath, &config)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(config)
+
+	return &config.Connection, nil
+}

cmd/vbantxt/config_internal_test.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadConfig_Success(t *testing.T) {
+	conn, err := loadConfig("testdata/config.toml")
+	require.NoError(t, err)
+
+	assert.Equal(t, conn.Host, "localhost")
+	assert.Equal(t, conn.Port, 7000)
+	assert.Equal(t, conn.Streamname, "vbantxt")
+}
+
+func TestLoadConfig_Errors(t *testing.T) {
+	tt := map[string]struct {
+		input string
+		err   string
+	}{
+		"no such file": {
+			input: "/no/such/dir/config.toml",
+			err:   "no such file or directory",
+		},
+	}
+
+	for name, tc := range tt {
+		_, err := loadConfig("/no/such/dir/config.toml")
+
+		t.Run(name, func(t *testing.T) {
+			assert.Error(t, err)
+			assert.ErrorContains(t, err, tc.err)
+		})
+	}
+}

cmd/vbantxt/main.go

@@ -1,194 +1,97 @@
-// Package main implements a command-line tool for sending text messages over VBAN using the vbantxt library.
 package main
 
 import (
-	"errors"
+	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
-	"runtime/debug"
+	"slices"
-	"strings"
 	"time"
 
-	"github.com/charmbracelet/log"
-	"github.com/peterbourgon/ff/v4"
-	"github.com/peterbourgon/ff/v4/ffhelp"
-	"github.com/peterbourgon/ff/v4/fftoml"
-
 	"github.com/onyx-and-iris/vbantxt"
+	log "github.com/sirupsen/logrus"
 )
 
-var version string // Version will be set at build time
+func exit(err error) {
-
+	_, _ = fmt.Fprintf(os.Stderr, "Error: %s", err)
-// versionFromBuild retrieves the version information from the build metadata.
+	os.Exit(1)
-func versionFromBuild() string {
-	if version != "" {
-		return version
-	}
-
-	info, ok := debug.ReadBuildInfo()
-	if !ok {
-		return "(unable to read version)"
-	}
-	return strings.Split(info.Main.Version, "-")[0]
 }
 
-// Flags holds the command-line flags for the VBANTXT client.
-type Flags struct {
-	Host       string
-	Port       int
-	Streamname string
-	Bps        int
-	Channel    int
-	Ratelimit  int
-	ConfigPath string // Path to the configuration file
-	Loglevel   string // Log level
-	Version    bool   // Version flag
-}
-
-func (f *Flags) String() string {
-	return fmt.Sprintf(
-		"Host: %s, Port: %d, Streamname: %s, Bps: %d, Channel: %d, Ratelimit: %dms, ConfigPath: %s, Loglevel: %s",
-		f.Host,
-		f.Port,
-		f.Streamname,
-		f.Bps,
-		f.Channel,
-		f.Ratelimit,
-		f.ConfigPath,
-		f.Loglevel,
-	)
-}
-
-// main is the entry point of the application.
-// It sets up a deferred function to handle exiting with the appropriate exit code
-// and calls the run function to execute the main logic.
 func main() {
-	var exitCode int
+	var (
+		host       string
+		port       int
+		streamname string
+		loglevel   int
+		configPath string
+		bps        int
+		channel    int
+		ratelimit  int
+	)
 
-	// Defer exit with the final exit code
+	flag.StringVar(&host, "host", "localhost", "vban host")
-	defer func() {
+	flag.StringVar(&host, "h", "localhost", "vban host (shorthand)")
-		if exitCode != 0 {
+	flag.IntVar(&port, "port", 6980, "vban server port")
-			os.Exit(exitCode)
+	flag.IntVar(&port, "p", 6980, "vban server port (shorthand)")
-		}
+	flag.StringVar(&streamname, "streamname", "Command1", "stream name for text requests")
-	}()
+	flag.StringVar(&streamname, "s", "Command1", "stream name for text requests (shorthand)")
 
-	closer, err := run()
+	flag.IntVar(&bps, "bps", 0, "vban bps")
-	if closer != nil {
+	flag.IntVar(&bps, "b", 0, "vban bps (shorthand)")
-		defer closer()
+	flag.IntVar(&channel, "channel", 0, "vban channel")
-	}
+	flag.IntVar(&channel, "c", 0, "vban channel (shorthand)")
-	if err != nil {
+	flag.IntVar(&ratelimit, "ratelimit", 20, "request ratelimit in milliseconds")
-		log.Error(err)
+	flag.IntVar(&ratelimit, "r", 20, "request ratelimit in milliseconds (shorthand)")
-		exitCode = 1
-	}
-}
-
-// run contains the main application logic and returns a closer function and any error.
-func run() (func(), error) {
-	var flags Flags
-
-	// VBAN specific flags
-	fs := ff.NewFlagSet("vbantxt - A command-line tool for sending text requests over VBAN")
-	fs.StringVar(&flags.Host, 'H', "host", "localhost", "VBAN host")
-	fs.IntVar(&flags.Port, 'p', "port", 6980, "VBAN port")
-	fs.StringVar(&flags.Streamname, 's', "streamname", "Command1", "VBAN stream name")
-	fs.IntVar(&flags.Bps, 'b', "bps", 256000, "VBAN BPS")
-	fs.IntVar(&flags.Channel, 'n', "channel", 0, "VBAN channel")
-	fs.IntVar(&flags.Ratelimit, 'r', "ratelimit", 20, "VBAN rate limit (ms)")
 
 	configDir, err := os.UserConfigDir()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get user config directory: %w", err)
+		exit(err)
 	}
 	defaultConfigPath := filepath.Join(configDir, "vbantxt", "config.toml")
+	flag.StringVar(&configPath, "config", defaultConfigPath, "config path")
+	flag.StringVar(&configPath, "C", defaultConfigPath, "config path (shorthand)")
+	flag.IntVar(&loglevel, "loglevel", int(log.WarnLevel), "log level")
+	flag.IntVar(&loglevel, "l", int(log.WarnLevel), "log level (shorthand)")
+	flag.Parse()
 
-	// Configuration file and logging flags
+	if slices.Contains(log.AllLevels, log.Level(loglevel)) {
-	fs.StringVar(
+		log.SetLevel(log.Level(loglevel))
-		&flags.ConfigPath,
-		'C',
-		"config",
-		defaultConfigPath,
-		"Path to the configuration file",
-	)
-	fs.StringVar(
-		&flags.Loglevel,
-		'l',
-		"loglevel",
-		"warn",
-		"Log level (debug, info, warn, error, fatal, panic)",
-	)
-	fs.BoolVar(&flags.Version, 'v', "version", "Show version information")
-
-	err = ff.Parse(fs, os.Args[1:],
-		ff.WithEnvVarPrefix("VBANTXT"),
-		ff.WithConfigFileFlag("config"),
-		ff.WithConfigAllowMissingFile(),
-		ff.WithConfigFileParser(fftoml.Parser{Delimiter: "."}.Parse),
-	)
-	switch {
-	case errors.Is(err, ff.ErrHelp):
-		fmt.Fprintf(os.Stderr, "%s\n", ffhelp.Flags(fs, "vbantxt [flags] <vban commands>"))
-		return nil, nil
-	case err != nil:
-		return nil, fmt.Errorf("failed to parse flags: %w", err)
 	}
 
-	if flags.Version {
+	if !flagsPassed([]string{"host", "h", "port", "p", "streamname", "s"}) {
-		fmt.Printf("vbantxt version: %s\n", versionFromBuild())
+		config, err := loadConfig(configPath)
-		return nil, nil
+		if err != nil {
+			exit(err)
+		}
+		host = config.Host
+		port = config.Port
+		streamname = config.Streamname
 	}
 
-	level, err := log.ParseLevel(flags.Loglevel)
+	client, err := createClient(host, port, streamname, bps, channel, ratelimit)
 	if err != nil {
-		return nil, fmt.Errorf("invalid log level %q", flags.Loglevel)
+		exit(err)
 	}
-	log.SetLevel(level)
+	defer client.Close()
 
-	log.Debugf("Loaded configuration: %s", flags.String())
+	for _, arg := range flag.Args() {
-
+		err := client.Send(arg)
-	client, closer, err := createClient(&flags)
+		if err != nil {
-	if err != nil {
-		return nil, fmt.Errorf("failed to create VBAN client: %w", err)
-	}
-
-	commands := fs.GetArgs()
-	if len(commands) == 0 {
-		return closer, errors.New(
-			"no VBAN commands provided; please provide at least one command as an argument",
-		)
-	}
-	sendCommands(client, commands)
-
-	return closer, nil
-}
-
-// createClient creates a new vban client with the provided options.
-func createClient(flags *Flags) (*vbantxt.VbanTxt, func(), error) {
-	client, err := vbantxt.New(
-		flags.Host,
-		flags.Port,
-		flags.Streamname,
-		vbantxt.WithBPSOpt(flags.Bps),
-		vbantxt.WithChannel(flags.Channel),
-		vbantxt.WithRateLimit(time.Duration(flags.Ratelimit)*time.Millisecond))
-	if err != nil {
-		return nil, nil, err
-	}
-
-	closer := func() {
-		if err := client.Close(); err != nil {
 			log.Error(err)
 		}
 	}
-
-	return client, closer, nil
 }
 
-// sendCommands sends the provided VBAN commands using the client and logs any errors that occur.
+func createClient(host string, port int, streamname string, bps, channel, ratelimit int) (*vbantxt.VbanTxt, error) {
-func sendCommands(client *vbantxt.VbanTxt, commands []string) {
+	client, err := vbantxt.New(
-	for _, cmd := range commands {
+		host,
-		if err := client.Send(cmd); err != nil {
+		port,
-			log.Errorf("Failed to send command '%s': %v", cmd, err)
+		streamname,
-		}
+		vbantxt.WithBPSOpt(bps),
+		vbantxt.WithChannel(channel),
+		vbantxt.WithRateLimit(time.Duration(ratelimit)*time.Millisecond))
+	if err != nil {
+		return nil, err
 	}
+	return client, err
 }

cmd/vbantxt/testdata/config.toml

@@ -0,0 +1,4 @@
+[connection]
+host = "localhost"
+port = 7000
+streamname = "vbantxt"

cmd/vbantxt/util.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"flag"
+	"slices"
+)
+
+func flagsPassed(flags []string) bool {
+	found := false
+	flag.Visit(func(f *flag.Flag) {
+		if slices.Contains(flags, f.Name) {
+			found = true
+			return
+		}
+	})
+	return found
+}

go.mod

@@ -1,35 +1,18 @@
 module github.com/onyx-and-iris/vbantxt
 
-go 1.25.0
+go 1.23.0
+
+toolchain go1.24.1
 
 require (
-	github.com/charmbracelet/log v1.0.0
+	github.com/BurntSushi/toml v1.5.0
-	github.com/peterbourgon/ff/v4 v4.0.0-beta.1
+	github.com/sirupsen/logrus v1.9.3
-	github.com/stretchr/testify v1.11.1
+	github.com/stretchr/testify v1.9.0
 )
 
 require (
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.4.3 // indirect
-	github.com/charmbracelet/lipgloss v1.1.0 // indirect
-	github.com/charmbracelet/x/ansi v0.11.6 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
-	github.com/charmbracelet/x/term v0.2.2 // indirect
-	github.com/clipperhouse/displaywidth v0.11.0 // indirect
-	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-logfmt/logfmt v0.6.1 // indirect
-	github.com/kr/pretty v0.1.0 // 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.21 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sys v0.31.0 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,61 +1,21 @@
-github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
-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 v1.0.0 h1:HVVVMmfOorfj3BA9i8X8UL69Hoz9lI0PYwXfJvOdRc4=
-github.com/charmbracelet/log v1.0.0/go.mod h1:uYgY3SmLpwJWxmlrPwXvzVYujxis1vAKRV/0VQB7yWA=
-github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
-github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
-github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
-github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
-github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
-github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
-github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
-github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
-github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
-github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
 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/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/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
-github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.21 h1:jJKAZiQH+2mIinzCJIaIG9Be1+0NR+5sz/lYEEjdM8w=
-github.com/mattn/go-runewidth v0.0.21/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/peterbourgon/ff/v4 v4.0.0-beta.1 h1:hV8qRu3V7YfiSMsBSfPfdcznAvPQd3jI5zDddSrDoUc=
-github.com/peterbourgon/ff/v4 v4.0.0-beta.1/go.mod h1:onQJUKipvCyFmZ1rIYwFAh1BhPOvftb1uhvSI7krNLc=
 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/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

makefile

@@ -5,27 +5,24 @@ BIN_DIR := bin
 
 WINDOWS=$(BIN_DIR)/$(PROGRAM)_windows_amd64.exe
 LINUX=$(BIN_DIR)/$(PROGRAM)_linux_amd64
-MACOS=$(BIN_DIR)/$(PROGRAM)_darwin_amd64
+VERSION=$(shell git log -n 1 --format=%h)
-VERSION=$(shell git describe --tags $(shell git rev-list --tags --max-count=1))
 
 .DEFAULT_GOAL := build
 
-.PHONY: fmt vet build windows linux macos test clean
+.PHONY: fmt vet build windows linux test clean
 fmt:        
 	$(GO) fmt ./...
 
 vet: fmt        
 	$(GO) vet ./...
 
-build: vet windows linux macos | $(BIN_DIR)
+build: vet windows linux | $(BIN_DIR)
 	@echo version: $(VERSION)
 
 windows: $(WINDOWS)
 
 linux: $(LINUX)
 
-macos: $(MACOS)
-
 
 $(WINDOWS):
 	env GOOS=windows GOARCH=amd64 go build -v -o $(WINDOWS) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/$(PROGRAM)/
@@ -33,9 +30,6 @@ $(WINDOWS):
 $(LINUX):
 	env GOOS=linux GOARCH=amd64 go build -v -o $(LINUX) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/$(PROGRAM)/
 
-$(MACOS):
-	env GOOS=darwin GOARCH=amd64 go build -v -o $(MACOS) -ldflags="-s -w -X main.version=$(VERSION)"  ./cmd/$(PROGRAM)/
-
 test:
 	$(GO) test ./...
 

option.go

@@ -3,7 +3,7 @@ package vbantxt
 import (
 	"time"
 
-	"github.com/charmbracelet/log"
+	log "github.com/sirupsen/logrus"
 )
 
 // Option is a functional option type that allows us to configure the VbanTxt.
@@ -19,37 +19,18 @@ func WithRateLimit(ratelimit time.Duration) Option {
 // WithBPSOpt is a functional option to set the bps index for {VbanTxt}.packet.
 func WithBPSOpt(bps int) Option {
 	return func(vt *VbanTxt) {
-		defaultBps := BpsOpts[vt.packet.bpsIndex]
-
 		bpsIndex := indexOf(BpsOpts, bps)
 		if bpsIndex == -1 {
-			log.Warnf(
+			log.Warnf("invalid bps value %d, expected one of %v, defaulting to 0", bps, BpsOpts)
-				"invalid bps value %d, expected one of %v, defaulting to %d",
-				bps,
-				BpsOpts,
-				defaultBps,
-			)
 			return
 		}
-		if bpsIndex > 255 {
+		vt.packet.bpsIndex = bpsIndex
-			log.Warnf("bps index %d too large for uint8, defaulting to %d", bpsIndex, defaultBps)
-			return
-		}
-		vt.packet.bpsIndex = uint8(bpsIndex)
 	}
 }
 
 // WithChannel is a functional option to set the channel for {VbanTxt}.packet.
 func WithChannel(channel int) Option {
 	return func(vt *VbanTxt) {
-		if channel < 0 || channel > 255 {
+		vt.packet.channel = channel
-			log.Warnf(
-				"channel value %d out of range [0,255], defaulting to %d",
-				channel,
-				vt.packet.channel,
-			)
-			return
-		}
-		vt.packet.channel = uint8(channel)
 	}
 }

packet.go

@@ -3,14 +3,12 @@ package vbantxt
 import (
 	"bytes"
 	"encoding/binary"
-	"fmt"
 
-	"github.com/charmbracelet/log"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
 	vbanProtocolTxt = 0x40
-	vbanTxtUtf8     = 0x10
 	streamNameSz    = 16
 	headerSz        = 4 + 1 + 1 + 1 + 1 + 16 + 4
 )
@@ -23,44 +21,30 @@ var BpsOpts = []int{
 }
 
 type packet struct {
-	streamname   [streamNameSz]byte
+	streamname   []byte
-	bpsIndex     uint8
+	bpsIndex     int
-	channel      uint8
+	channel      int
-	framecounter uint32
+	framecounter []byte
 	hbuf         *bytes.Buffer
 }
 
-// newPacket creates a new packet with the given stream name and default values for other fields.
+// newPacket returns a packet struct with default values, framecounter at 0.
-// It validates the stream name length and ensures the default baud rate is present in BpsOpts.
+func newPacket(streamname string) packet {
-func newPacket(streamname string) (packet, error) {
+	streamnameBuf := make([]byte, streamNameSz)
-	if len(streamname) > streamNameSz {
+	copy(streamnameBuf, streamname)
-		return packet{}, fmt.Errorf(
-			"streamname too long: %d chars, max %d",
-			len(streamname),
-			streamNameSz,
-		)
-	}
-
-	var streamnameBuf [streamNameSz]byte
-	copy(streamnameBuf[:], streamname)
-
-	bpsIndex := indexOf(BpsOpts, 256000)
-	if bpsIndex == -1 {
-		return packet{}, fmt.Errorf("default baud rate 256000 not found in BpsOpts")
-	}
 
 	return packet{
 		streamname:   streamnameBuf,
-		bpsIndex:     uint8(bpsIndex),
+		bpsIndex:     0,
 		channel:      0,
-		framecounter: 0,
+		framecounter: make([]byte, 4),
-		hbuf:         bytes.NewBuffer(make([]byte, 0, headerSz)),
+		hbuf:         bytes.NewBuffer(make([]byte, headerSz)),
-	}, nil
+	}
 }
 
 // sr defines the samplerate for the request.
 func (p *packet) sr() byte {
-	return byte(p.bpsIndex | vbanProtocolTxt)
+	return byte(vbanProtocolTxt + p.bpsIndex)
 }
 
 // nbc defines the channel of the request.
@@ -75,21 +59,16 @@ func (p *packet) header() []byte {
 	p.hbuf.WriteByte(p.sr())
 	p.hbuf.WriteByte(byte(0))
 	p.hbuf.WriteByte(p.nbc())
-	p.hbuf.WriteByte(byte(vbanTxtUtf8))
+	p.hbuf.WriteByte(byte(0x10))
-	p.hbuf.Write(p.streamname[:])
+	p.hbuf.Write(p.streamname)
-
+	p.hbuf.Write(p.framecounter)
-	var frameBytes [4]byte
-	binary.LittleEndian.PutUint32(frameBytes[:], p.framecounter)
-	p.hbuf.Write(frameBytes[:])
-
 	return p.hbuf.Bytes()
 }
 
 // bumpFrameCounter increments the frame counter by 1.
-// The uint32 will safely wrap to 0 after reaching max value (4,294,967,295),
-// which is expected behaviour for network protocol sequence numbers.
 func (p *packet) bumpFrameCounter() {
-	p.framecounter++
+	x := binary.LittleEndian.Uint32(p.framecounter)
+	binary.LittleEndian.PutUint32(p.framecounter, x+1)
 
-	log.Debugf("framecounter: %d", p.framecounter)
+	log.Tracef("framecounter: %d", x)
 }

udpconn.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/charmbracelet/log"
+	log "github.com/sirupsen/logrus"
 )
 
 // udpConn represents the UDP client.

vbantxt.go

@@ -4,34 +4,26 @@ import (
 	"fmt"
 	"io"
 	"time"
-
-	"github.com/charmbracelet/log"
 )
 
 // VbanTxt is used to send VBAN-TXT requests to a distant Voicemeeter/Matrix.
 type VbanTxt struct {
-	conn      io.WriteCloser
+	udpConn   io.WriteCloser
 	packet    packet
 	ratelimit time.Duration
-	lastSend  time.Time
 }
 
 // New constructs a fully formed VbanTxt instance. This is the package's entry point.
 // It sets default values for it's fields and then runs the option functions.
 func New(host string, port int, streamname string, options ...Option) (*VbanTxt, error) {
-	conn, err := newUDPConn(host, port)
+	udpConn, err := newUDPConn(host, port)
 	if err != nil {
 		return nil, fmt.Errorf("error creating UDP client for (%s:%d): %w", host, port, err)
 	}
 
-	packet, err := newPacket(streamname)
-	if err != nil {
-		return nil, fmt.Errorf("error creating packet: %w", err)
-	}
-
 	vt := &VbanTxt{
-		conn:      conn,
+		udpConn:   udpConn,
-		packet:    packet,
+		packet:    newPacket(streamname),
 		ratelimit: time.Duration(20) * time.Millisecond,
 	}
 
@@ -42,32 +34,24 @@ func New(host string, port int, streamname string, options ...Option) (*VbanTxt,
 	return vt, nil
 }
 
-// Send is responsible for firing each VBAN-TXT request.
+// Send is resonsible for firing each VBAN-TXT request.
-// It enforces rate limiting by waiting only when necessary.
+// It waits for {vt.ratelimit} time before returning.
-func (vt *VbanTxt) Send(cmd string) error {
+func (vt VbanTxt) Send(cmd string) error {
-	if elapsed := time.Since(vt.lastSend); elapsed < vt.ratelimit {
+	_, err := vt.udpConn.Write(append(vt.packet.header(), []byte(cmd)...))
-		log.Debugf(
-			"Rate limit in effect. Waiting for %v before sending next command.",
-			vt.ratelimit-elapsed,
-		)
-		time.Sleep(vt.ratelimit - elapsed)
-	}
-
-	vt.lastSend = time.Now()
-
-	_, err := vt.conn.Write(append(vt.packet.header(), cmd...))
 	if err != nil {
 		return fmt.Errorf("error sending command (%s): %w", cmd, err)
 	}
 
 	vt.packet.bumpFrameCounter()
 
+	time.Sleep(vt.ratelimit)
+
 	return nil
 }
 
 // Close is responsible for closing the UDP Client connection.
-func (vt *VbanTxt) Close() error {
+func (vt VbanTxt) Close() error {
-	err := vt.conn.Close()
+	err := vt.udpConn.Close()
 	if err != nil {
 		return fmt.Errorf("error attempting to close UDP Client: %w", err)
 	}

vbantxt_test.go

@@ -4,12 +4,10 @@ import (
 	"bufio"
 	"bytes"
 	_ "embed"
-	"os"
 	"testing"
 
-	"github.com/stretchr/testify/require"
-
 	"github.com/onyx-and-iris/vbantxt"
+	"github.com/stretchr/testify/require"
 )
 
 //go:embed testdata/vm.txt
@@ -30,14 +28,14 @@ func run(t *testing.T, client *vbantxt.VbanTxt, script []byte) {
 }
 
 func TestSendVm(t *testing.T) {
-	client, err := vbantxt.New(os.Getenv("VBANTXT_HOST"), 6980, os.Getenv("VBANTXT_STREAMNAME"))
+	client, err := vbantxt.New("vm.local", 6980, "onyx")
 	require.NoError(t, err)
 
 	run(t, client, vm)
 }
 
 func TestSendMatrix(t *testing.T) {
-	client, err := vbantxt.New(os.Getenv("VBANTXT_HOST"), 6990, os.Getenv("VBANTXT_STREAMNAME"))
+	client, err := vbantxt.New("vm.local", 6990, "onyx")
 	require.NoError(t, err)
 
 	run(t, client, matrix)