main.go

package main

import (
	"context"
	_ "embed"
	"fmt"
	"log"
	"os"
	"slices"
	"strconv"
	"strings"
	"syscall"
	"time"

	"github.com/richiejp/VoxInput/internal/audio"
	"github.com/richiejp/VoxInput/internal/gui"
	"github.com/richiejp/VoxInput/internal/input"
	"github.com/richiejp/VoxInput/internal/ipc"
	"github.com/richiejp/VoxInput/internal/localvqe"
	"github.com/richiejp/VoxInput/internal/pid"
	"github.com/richiejp/VoxInput/internal/semver"
)

//go:embed version.txt
var version []byte

func main() {

	if err := semver.SetVersion(version); err != nil {
		fmt.Printf("Version format error '%s': %v\n", string(version), err)
		os.Exit(1)
	}

	if len(os.Args) < 2 {
		fmt.Println("Expected 'listen', 'tui', 'record', 'write', 'toggle', 'status', or 'help' subcommands")
		os.Exit(1)
	}

	cmd := os.Args[1]

	switch cmd {
	case "help":
		fmt.Println(`Available commands:
  listen - Start speech to text daemon
           --replay play the audio just recorded for transcription
           --no-realtime use the HTTP API instead of the realtime API; disables VAD
           --no-show-status don't show when recording has started or stopped
           --output-file <path> Write transcribed text to file instead of keyboard
           --prompt <text> Text used to condition model output. Could be previously transcribed text or uncommon words you expect to use
           --mode <transcription|assistant> (realtime only, default: transcription)
           --instructions <text> System prompt for the assistant model
           --no-dotool (assistant mode only) Disable the dotool function call
           --no-aec (assistant mode only) Disable acoustic echo cancellation
           --screenshot-command <cmd> (assistant mode only) Command to capture a screenshot (e.g. "grim /tmp/screenshot.png")
           --screenshot-file <path> (assistant mode only) Path where the screenshot command saves its output
           --dump-audio <dir> (assistant mode only) Dump raw mic and speaker PCM to files for AEC analysis
           --socket <path> Enable IPC socket server at the given path for TUI connections

  tui    - Launch interactive terminal UI with chat and log tabs
           --connect <path> Connect to an existing listen process socket instead of starting a subprocess
           Additional flags are passed through to the listen subprocess

  record - Tell existing listener to start recording audio. In realtime mode it also begins transcription
  write  - Tell existing listener to stop recording audio and begin transcription if not in realtime mode
  stop   - Alias for write; makes more sense in realtime mode
  toggle - Toggle recording on/off (start recording if idle, stop if recording)
  status - Show whether the server is listening and if it's currently recording
  devices - List capture devices
  help   - Show this help message
  ver    - Print version

Environment variables:
  VOXINPUT_API_KEY or OPENAI_API_KEY - OpenAI API key (default: sk-xxx)
  VOXINPUT_BASE_URL or OPENAI_BASE_URL - HTTP API base URL (default: http://localhost:8080/v1)
  VOXINPUT_WS_BASE_URL or OPENAI_WS_BASE_URL - WebSocket API base URL (default: ws://localhost:8080/v1/realtime)
  VOXINPUT_LANG - Language code for transcription (full string used as-is, default: none)
  LANG - Language code for transcription (only first 2 characters used, default: none)
  VOXINPUT_TRANSCRIPTION_MODEL or TRANSCRIPTION_MODEL - Transcription model (default: none)
  VOXINPUT_ASSISTANT_MODEL or ASSISTANT_MODEL - Assistant model (default: gpt-realtime)
  VOXINPUT_ASSISTANT_VOICE or ASSISTANT_VOICE - Assistant voice (default: none)
	VOXINPUT_ASSISTANT_INSTRUCTIONS - System prompt for the assistant model (default: none)
  VOXINPUT_ASSISTANT_ENABLE_WRITE_TEXT - Enable the write_text tool in assistant mode (yes/no, default: yes)
  VOXINPUT_ASSISTANT_SCREENSHOT_COMMAND - Command to capture a screenshot, e.g. "grim -t jpeg $XDG_RUNTIME_DIR/vox-screenshot.jpeg" (default: none)
  VOXINPUT_ASSISTANT_SCREENSHOT_FILE - Path where the screenshot command saves its file, e.g. "$XDG_RUNTIME_DIR/vox-screenshot.jpeg" (default: none)
  VOXINPUT_TRANSCRIPTION_TIMEOUT or TRANSCRIPTION_TIMEOUT - Transcription timeout (default: 30s)
  VOXINPUT_SHOW_STATUS or SHOW_STATUS - Show status notifications (yes/no, default: yes)
  VOXINPUT_CAPTURE_DEVICE - Name of the capture device (default: system default; use 'devices' to list)
  VOXINPUT_OUTPUT_FILE - File to write transcribed text to (instead of keyboard)
  VOXINPUT_PROMPT - Text used to condition the transcription model output. Could be previously transcribed text or uncommon words you expect to use (default: none)
  VOXINPUT_MODE - Realtime mode (transcription|assistant, default: transcription)
  VOXINPUT_ENABLE_AEC - Enable acoustic echo cancellation in assistant mode (yes/no, default: yes)
  VOXINPUT_LOCALVQE_MODEL - Path to a LocalVQE GGUF model file, overriding the bundled models (default: the bundled model selected by VOXINPUT_LOCALVQE_MODEL_VERSION)
  VOXINPUT_LOCALVQE_MODEL_VERSION - Which bundled LocalVQE model to use: v1.2 (default) or v1.3; also accepts the full version-size form (v1.2-1.3M, v1.3-4.8M). Both are bundled by the CMake build; with a plain 'go build' the chosen model is downloaded into the user cache on first use. Ignored when VOXINPUT_LOCALVQE_MODEL is set.
  VOXINPUT_LOCALVQE_LIB - Path to liblocalvqe.so (default: next to the binary or system library path)
  VOXINPUT_AEC_REF_SOURCE - AEC reference signal: 'playback' (far-end TTS buffer, default) or 'monitor' (samples from a loopback capture device)
  VOXINPUT_AEC_MONITOR_DEVICE - Capture device name feeding the AEC reference when AEC_REF_SOURCE=monitor (e.g. "Monitor of <sink>" on PipeWire, a BlackHole/Loopback device on macOS; use 'devices' to list)
  VOXINPUT_AEC_NOISE_GATE - Enable LocalVQE residual-echo noise gate (yes/no, default: no). Mutes hops whose RMS sits at or below the threshold; useful when the model's quiet residual is audible during far-end-only stretches. Also settable via --aec-noise-gate / --no-aec-noise-gate.
  VOXINPUT_AEC_NOISE_GATE_DBFS - Noise gate threshold in dBFS (default: -45.0). Lower = gates fewer frames; higher (less negative) = gates more aggressively but may clip quiet near-end speech. Also settable via --aec-noise-gate-dbfs.
  VOXINPUT_DUMP_AUDIO_DIR - Directory to dump raw mic/speaker PCM for AEC analysis (default: none)
  VOXINPUT_INPUT_SAMPLE_RATE - Sample rate for audio input/recording in Hz (default: 24000)
  VOXINPUT_OUTPUT_SAMPLE_RATE - Sample rate for audio output/playback in Hz (default: 24000)
  VOXINPUT_SOCKET - Socket path for IPC (default: $XDG_RUNTIME_DIR/VoxInput.sock)
  XDG_RUNTIME_DIR - Directory for PID and state files (required, standard XDG variable)`)
		return
	case "ver":
		fmt.Printf("v%s\n", strings.TrimSpace(string(version)))
		return
	case "tui":
		tuiCommand(os.Args[2:])
		return
	default:
	}

	pidPath, err := pid.Path()
	if err != nil {
		log.Fatalln("main: failed to get PID file path: ", err)
	}

	statePath, err := pid.StatePath()
	if err != nil {
		log.Fatalln("main: failed to get state file path: ", err)
	}

	if cmd == "listen" {
		apiKey := getOpenaiEnv("API_KEY", "sk-xxx")
		httpApiBase := getOpenaiEnv("BASE_URL", "http://localhost:8080/v1")
		wsApiBase := getOpenaiEnv("WS_BASE_URL", "ws://localhost:8080/v1/realtime")

		// VOXINPUT_LANG takes precedence and is used as-is to allow setting language names that diverge from OpenAI's for e.g. Qwen ASR uses names like "English"
		// LANG is truncated to first 2 characters which matches OpenAI's use of language codes (I hope)
		lang := os.Getenv("VOXINPUT_LANG")
		if lang == "" {
			if langEnv := os.Getenv("LANG"); langEnv != "" && len(langEnv) >= 2 {
				lang = langEnv[:2]
			}
		}
		model := getPrefixedEnv([]string{"VOXINPUT", ""}, "TRANSCRIPTION_MODEL", "")
		assistantModel := getPrefixedEnv([]string{"VOXINPUT", ""}, "ASSISTANT_MODEL", "gpt-realtime")
		assistantVoice := getPrefixedEnv([]string{"VOXINPUT", ""}, "ASSISTANT_VOICE", "")
		instructions := getPrefixedEnv([]string{"VOXINPUT", ""}, "ASSISTANT_INSTRUCTIONS", "")
		enableDotoolStr := getPrefixedEnv([]string{"VOXINPUT"}, "ASSISTANT_ENABLE_DOTOOL", "yes")
		enableAECStr := getPrefixedEnv([]string{"VOXINPUT"}, "ENABLE_AEC", "yes")
		timeoutStr := getPrefixedEnv([]string{"VOXINPUT", ""}, "TRANSCRIPTION_TIMEOUT", "30s")
		showStatusText := getPrefixedEnv([]string{"VOXINPUT", ""}, "SHOW_STATUS", "yes")
		captureDeviceName := getPrefixedEnv([]string{"VOXINPUT"}, "CAPTURE_DEVICE", "")
		prompt := getPrefixedEnv([]string{"VOXINPUT"}, "PROMPT", "")
		outputFile := getPrefixedEnv([]string{"VOXINPUT"}, "OUTPUT_FILE", "")
		inputSampleRateStr := getPrefixedEnv([]string{"VOXINPUT"}, "INPUT_SAMPLE_RATE", "24000")
		outputSampleRateStr := getPrefixedEnv([]string{"VOXINPUT"}, "OUTPUT_SAMPLE_RATE", "24000")
		dumpAudioDir := getPrefixedEnv([]string{"VOXINPUT"}, "DUMP_AUDIO_DIR", "")
		localvqeModelPath := getPrefixedEnv([]string{"VOXINPUT"}, "LOCALVQE_MODEL", "")
		localvqeModelVersion := getPrefixedEnv([]string{"VOXINPUT"}, "LOCALVQE_MODEL_VERSION", "")
		localvqeLibPath := getPrefixedEnv([]string{"VOXINPUT"}, "LOCALVQE_LIB", "")
		aecRefSourceStr := getPrefixedEnv([]string{"VOXINPUT"}, "AEC_REF_SOURCE", "playback")
		aecMonitorDevice := getPrefixedEnv([]string{"VOXINPUT"}, "AEC_MONITOR_DEVICE", "")
		aecNoiseGateStr := getPrefixedEnv([]string{"VOXINPUT"}, "AEC_NOISE_GATE", "no")
		aecNoiseGateDBFSStr := getPrefixedEnv([]string{"VOXINPUT"}, "AEC_NOISE_GATE_DBFS", "-45.0")

		mode := getPrefixedEnv([]string{"VOXINPUT"}, "MODE", "transcription")
		socketPath := getPrefixedEnv([]string{"VOXINPUT"}, "SOCKET", "")
		screenshotCommand := getPrefixedEnv([]string{"VOXINPUT"}, "ASSISTANT_SCREENSHOT_COMMAND", "")
		screenshotFile := getPrefixedEnv([]string{"VOXINPUT"}, "ASSISTANT_SCREENSHOT_FILE", "")

		timeout, err := time.ParseDuration(timeoutStr)
		if err != nil {
			log.Println("main: failed to parse timeout", err)
			timeout = time.Second * 30
		}

		inputSampleRate, err := strconv.Atoi(inputSampleRateStr)
		if err != nil {
			log.Println("main: failed to parse input sample rate", err)
			inputSampleRate = 24000
		}

		outputSampleRate, err := strconv.Atoi(outputSampleRateStr)
		if err != nil {
			log.Println("main: failed to parse output sample rate", err)
			outputSampleRate = 24000
		}

		if lang != "" {
			log.Println("main: language is set to ", lang)
		}

		if slices.Contains(os.Args[2:], "--no-show-status") {
			showStatusText = "no"
		}
		showStatus := !(showStatusText == "no" || showStatusText == "false")

		if slices.Contains(os.Args[2:], "--no-dotool") {
			enableDotoolStr = "no"
		}
		enableDotool := !(enableDotoolStr == "no" || enableDotoolStr == "false")

		if slices.Contains(os.Args[2:], "--no-aec") {
			enableAECStr = "no"
		}
		enableAEC := !(enableAECStr == "no" || enableAECStr == "false")

		replay := slices.Contains(os.Args[2:], "--replay")
		realtime := !slices.Contains(os.Args[2:], "--no-realtime")

		var outputFileArg string
		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--output-file" && i+1 < len(os.Args) {
				outputFileArg = os.Args[i+1]
				break
			}
		}
		if outputFileArg != "" {
			outputFile = outputFileArg
		}

		var promptArg string
		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--prompt" && i+1 < len(os.Args) {
				promptArg = os.Args[i+1]
				break
			}
		}
		if promptArg != "" {
			prompt = promptArg
		}

		var modeArg string
		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--mode" && i+1 < len(os.Args) {
				modeArg = os.Args[i+1]
				break
			}
		}
		if modeArg != "" {
			mode = modeArg
		}

		var instructionsArg string
		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--instructions" && i+1 < len(os.Args) {
				instructionsArg = os.Args[i+1]
				break
			}
		}
		if instructionsArg != "" {
			instructions = instructionsArg
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--screenshot-command" && i+1 < len(os.Args) {
				screenshotCommand = os.Args[i+1]
				break
			}
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--screenshot-file" && i+1 < len(os.Args) {
				screenshotFile = os.Args[i+1]
				break
			}
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--dump-audio" && i+1 < len(os.Args) {
				dumpAudioDir = os.Args[i+1]
				break
			}
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--socket" && i+1 < len(os.Args) {
				socketPath = os.Args[i+1]
				break
			}
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--aec-ref-source" && i+1 < len(os.Args) {
				aecRefSourceStr = os.Args[i+1]
				break
			}
		}

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--aec-monitor-device" && i+1 < len(os.Args) {
				aecMonitorDevice = os.Args[i+1]
				break
			}
		}

		if slices.Contains(os.Args[2:], "--aec-noise-gate") {
			aecNoiseGateStr = "yes"
		}
		if slices.Contains(os.Args[2:], "--no-aec-noise-gate") {
			aecNoiseGateStr = "no"
		}
		aecNoiseGate := !(aecNoiseGateStr == "no" || aecNoiseGateStr == "false")

		for i := 2; i < len(os.Args); i++ {
			arg := os.Args[i]
			if arg == "--aec-noise-gate-dbfs" && i+1 < len(os.Args) {
				aecNoiseGateDBFSStr = os.Args[i+1]
				break
			}
		}
		aecNoiseGateDBFS64, err := strconv.ParseFloat(aecNoiseGateDBFSStr, 32)
		if err != nil {
			log.Printf("main: failed to parse VOXINPUT_AEC_NOISE_GATE_DBFS=%q, using -45.0: %v", aecNoiseGateDBFSStr, err)
			aecNoiseGateDBFS64 = -45.0
		}
		aecNoiseGateDBFS := float32(aecNoiseGateDBFS64)

		var aecRefSource AECRefSource
		switch aecRefSourceStr {
		case string(AECRefPlayback):
			aecRefSource = AECRefPlayback
		case string(AECRefMonitor):
			aecRefSource = AECRefMonitor
		default:
			log.Fatalf("main: invalid --aec-ref-source %q (expected %q or %q)",
				aecRefSourceStr, AECRefPlayback, AECRefMonitor)
		}

		// Create input controller for keyboard/mouse simulation.
		// Only required when we need to type text (no output file) or use input control in assistant mode.
		var inputCtrl input.Controller
		needsInput := outputFile == "" || enableDotool
		if needsInput {
			var err error
			inputCtrl, err = input.New()
			if err != nil {
				log.Fatalln("main: failed to create input controller: ", err)
			}
		}

		if realtime {
			ctx, cancel := context.WithCancel(context.Background())
			guiSink := gui.New(ctx, showStatus)

			var sink gui.StatusSink = guiSink
			var ipcServer *ipc.Server

			if socketPath != "" {
				var err error
				ipcServer, err = ipc.NewServer(socketPath)
				if err != nil {
					log.Fatalln("main: failed to create IPC server:", err)
				}
				defer ipcServer.Close()
				sink = &gui.MultiSink{Sinks: []gui.StatusSink{guiSink, ipcServer}}
				log.Println("main: IPC socket server listening on", socketPath)
			}

			go func() {
				listen(ListenConfig{
					PIDPath:              pidPath,
					APIKey:               apiKey,
					HTTPAPIBase:          httpApiBase,
					WSAPIBase:            wsApiBase,
					Lang:                 lang,
					Model:                model,
					Timeout:              timeout,
					UI:                   sink,
					CaptureDevice:        captureDeviceName,
					OutputFile:           outputFile,
					Prompt:               prompt,
					Mode:                 mode,
					AssistantModel:       assistantModel,
					AssistantVoice:       assistantVoice,
					Instructions:         instructions,
					EnableDotool:         enableDotool,
					InputController:      inputCtrl,
					ScreenshotCommand:    screenshotCommand,
					ScreenshotFile:       screenshotFile,
					InputSampleRate:      inputSampleRate,
					OutputSampleRate:     outputSampleRate,
					EnableAEC:            enableAEC,
					LocalVQEModelPath:    localvqeModelPath,
					LocalVQEModelVersion: localvqe.ModelVariant(localvqeModelVersion),
					LocalVQELibPath:      localvqeLibPath,
					AECRefSource:         aecRefSource,
					AECMonitorDevice:     aecMonitorDevice,
					AECNoiseGate:         aecNoiseGate,
					AECNoiseGateDBFS:     aecNoiseGateDBFS,
					DumpAudioDir:         dumpAudioDir,
					IPCServer:            ipcServer,
				})
				cancel()
			}()

			guiSink.Run()
		} else {
			listenOld(pidPath, apiKey, httpApiBase, lang, model, prompt, replay, timeout, inputCtrl)
		}

		return
	}

	if cmd == "devices" {
		if err := audio.ListCaptureDevices(); err != nil {
			log.Fatalln("Failed to enumerate devices:", err)
		}
		return
	}

	id, err := pid.Read(pidPath)
	if err != nil {
		log.Fatalln("main: failed to read listener PID: ", err)
	}

	proc, err := os.FindProcess(id)
	if err != nil {
		log.Fatalln("main: Failed to find listen process: ", err)
	}

	switch cmd {
	case "record":
		log.Println("main: Sending record signal")
		err = proc.Signal(syscall.SIGUSR1)
	case "stop":
		fallthrough
	case "write":
		log.Println("main: Sending stop/write signal")
		err = proc.Signal(syscall.SIGUSR2)
	case "status":
		err = proc.Signal(syscall.Signal(0))
		if err != nil {
			log.Fatalln("main: Failed to signal listen process: ", err)
		}

		recording, err := pid.ReadState(statePath)
		if err != nil {
			log.Fatalln("main: Failed to read state file: ", err)
		}

		if recording {
			fmt.Println("recording")
		} else {
			fmt.Println("idle")
		}
	case "toggle":
		// Read current state
		recording, readErr := pid.ReadState(statePath)
		if readErr != nil {
			log.Fatalln("main: Failed to read state: ", readErr)
		}

		if recording {
			log.Println("main: Currently recording, sending stop signal")
			err = proc.Signal(syscall.SIGUSR2)
		} else {
			log.Println("main: Currently idle, sending record signal")
			err = proc.Signal(syscall.SIGUSR1)
		}
	default:
		log.Fatalln("main: Unknown command: ", os.Args[1])
	}

	if err != nil {
		log.Fatalln("main: Error sending signal: ", err)
	}
}