codmir 0.3.3 → 0.4.1

package/dist/voice-daemon/index.mjs

@@ -0,0 +1,1046 @@
+import {
+  __require
+} from "../chunk-EBO3CZXG.mjs";
+
+// src/voice-daemon/logger.ts
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+function normalizeLogLevel(value) {
+  if (!value) return "info";
+  const lower = value.toLowerCase();
+  if (LOG_LEVELS.includes(lower)) {
+    return lower;
+  }
+  return "info";
+}
+var Logger = class {
+  constructor(level, prefix = "codmir-voice") {
+    this.level = level;
+    this.prefix = prefix;
+  }
+  /**
+   * Logs a debug-level message.
+   */
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  /**
+   * Logs an info-level message.
+   */
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  /**
+   * Logs a warning-level message.
+   */
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  /**
+   * Logs an error-level message.
+   */
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  log(level, message, meta) {
+    const currentIndex = LOG_LEVELS.indexOf(this.level);
+    const messageIndex = LOG_LEVELS.indexOf(level);
+    if (messageIndex < currentIndex) return;
+    const time = (/* @__PURE__ */ new Date()).toISOString();
+    const levelTag = level.toUpperCase().padEnd(5);
+    const base = `[${time}] [${this.prefix}] [${levelTag}] ${message}`;
+    if (meta !== void 0) {
+      console.log(`${base} ${JSON.stringify(meta)}`);
+    } else {
+      console.log(base);
+    }
+  }
+};
+
+// src/voice-daemon/config.ts
+function loadConfig(logger) {
+  const portEnv = process.env.CODMIR_VOICE_PORT;
+  const httpPortEnv = process.env.CODMIR_VOICE_HTTP_PORT;
+  const port = parsePort(portEnv, 9410, logger, "CODMIR_VOICE_PORT");
+  const httpPort = parsePort(httpPortEnv, 9411, logger, "CODMIR_VOICE_HTTP_PORT");
+  const logLevel = normalizeLogLevel(process.env.CODMIR_VOICE_LOG_LEVEL);
+  const desktopAutomationUrl = process.env.DESKTOP_AUTOMATION_URL || "http://localhost:8095";
+  const ttsWorkerUrl = process.env.TTS_WORKER_URL || "http://localhost:8094";
+  const orchestratorUrl = process.env.ORCHESTRATOR_URL || "http://localhost:8096";
+  const overlayUrl = process.env.OVERLAY_URL || "http://localhost:9412";
+  const approvalMode = process.env.CODMIR_APPROVAL_MODE !== "0";
+  const muted = process.env.CODMIR_MUTED === "1";
+  return {
+    port,
+    httpPort,
+    logLevel,
+    desktopAutomationUrl,
+    ttsWorkerUrl,
+    orchestratorUrl,
+    overlayUrl,
+    approvalMode,
+    muted
+  };
+}
+function parsePort(value, defaultValue, logger, envName) {
+  if (!value) return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 65535) {
+    logger.warn(`Invalid ${envName} '${value}', using default ${defaultValue}`);
+    return defaultValue;
+  }
+  return parsed;
+}
+
+// src/voice-daemon/state-machine.ts
+var AssistantStateMachine = class {
+  constructor(logger) {
+    this.state = "idle";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.logger = logger;
+  }
+  /**
+   * Returns the current assistant state.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Transitions to a new state and notifies listeners.
+   */
+  setState(newState) {
+    if (newState === this.state) return;
+    const previous = this.state;
+    this.state = newState;
+    this.logger.info("State change", { from: previous, to: newState });
+    for (const callback of this.listeners) {
+      try {
+        callback(newState, previous);
+      } catch (error) {
+        this.logger.warn("State listener error", { error: String(error) });
+      }
+    }
+  }
+  /**
+   * Registers a callback to be invoked on state changes.
+   */
+  onStateChange(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /**
+   * Called when wake word is detected.
+   */
+  handleWake() {
+    if (this.state === "idle") {
+      this.setState("listening");
+    }
+  }
+  /**
+   * Called when speech-to-text is complete.
+   */
+  handleTranscriptComplete() {
+    if (this.state === "listening") {
+      this.setState("thinking");
+    }
+  }
+  /**
+   * Called when AI response is ready and TTS begins.
+   */
+  handleSpeakStart() {
+    if (this.state === "thinking") {
+      this.setState("speaking");
+    }
+  }
+  /**
+   * Called when TTS playback is complete.
+   */
+  handleSpeakEnd() {
+    if (this.state === "speaking") {
+      this.setState("idle");
+    }
+  }
+  /**
+   * Called on any error, resets to idle.
+   */
+  handleError() {
+    this.setState("error");
+    setTimeout(() => {
+      if (this.state === "error") {
+        this.setState("idle");
+      }
+    }, 3e3);
+  }
+  /**
+   * Force reset to idle.
+   */
+  reset() {
+    this.setState("idle");
+  }
+};
+
+// src/voice-daemon/command-executor.ts
+var CommandExecutor = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * Executes a single command.
+   */
+  async execute(command) {
+    this.logger.info("Executing command", { type: command.type });
+    try {
+      switch (command.type) {
+        case "open_app":
+          return this.callDesktopAutomation("/launch/app", { cmd: command.name });
+        case "open_url":
+          return this.callDesktopAutomation("/open/url", { url: command.url });
+        case "focus_window":
+          return this.callDesktopAutomation("/window/activate", {
+            name_contains: command.titleContains
+          });
+        case "type_text":
+          return this.callDesktopAutomation("/type", { text: command.text });
+        case "press_key":
+          return this.callDesktopAutomation("/key", { sequence: command.key });
+        case "click":
+          return this.callDesktopAutomation("/click", { button: command.button ?? 1 });
+        case "scroll":
+          const btn = command.direction === "up" ? 4 : 5;
+          const clicks = command.amount ?? 3;
+          for (let i = 0; i < clicks; i++) {
+            await this.callDesktopAutomation("/click", { button: btn });
+          }
+          return { success: true };
+        case "speak":
+          return this.callTts(command.text, command.voice);
+        case "run_script":
+          this.logger.warn("run_script not implemented for security reasons");
+          return { success: false, error: "run_script disabled" };
+        default: {
+          const exhaustive = command;
+          return { success: false, error: `Unknown command type: ${exhaustive.type}` };
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error("Command execution failed", { command, error: message });
+      return { success: false, error: message };
+    }
+  }
+  async callDesktopAutomation(endpoint, body) {
+    const url = `${this.config.desktopAutomationUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      return { success: false, error: `HTTP ${response.status}: ${text}` };
+    }
+    return { success: true };
+  }
+  async callTts(text, voice) {
+    const url = `${this.config.ttsWorkerUrl}/speak`;
+    const body = { text };
+    if (voice) body.voice = voice;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      return { success: false, error: `TTS failed: ${errText}` };
+    }
+    this.logger.info("TTS audio generated", { textLength: text.length });
+    return { success: true };
+  }
+};
+
+// src/voice-daemon/ws-server.ts
+import os from "os";
+import { WebSocketServer, WebSocket } from "ws";
+var DAEMON_VERSION = "0.1.0";
+var VoiceDaemonWebSocketServer = class {
+  constructor(config, logger, stateMachine, executor) {
+    this.clients = /* @__PURE__ */ new Set();
+    this.config = config;
+    this.logger = logger;
+    this.stateMachine = stateMachine;
+    this.executor = executor;
+    this.wss = new WebSocketServer({
+      port: this.config.port,
+      host: "127.0.0.1"
+    });
+    this.setupListeners();
+    this.setupStateListener();
+  }
+  setupListeners() {
+    this.wss.on("listening", () => {
+      this.logger.info("WebSocket server listening", { port: this.config.port });
+    });
+    this.wss.on("connection", (socket) => {
+      const client = { socket };
+      this.clients.add(client);
+      this.logger.info("Client connected", { total: this.clients.size });
+      this.sendDaemonStarted(client);
+      socket.on("message", (data) => {
+        this.handleMessage(client, data.toString("utf8"));
+      });
+      socket.on("close", () => {
+        this.clients.delete(client);
+        this.logger.info("Client disconnected", { total: this.clients.size });
+      });
+      socket.on("error", (error) => {
+        this.logger.warn("WebSocket client error", { error: String(error) });
+      });
+    });
+    this.wss.on("error", (error) => {
+      this.logger.error("WebSocket server error", { error: String(error) });
+    });
+  }
+  setupStateListener() {
+    this.stateMachine.onStateChange((newState, previousState) => {
+      this.broadcast({
+        type: "state_change",
+        state: newState,
+        previousState,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  sendDaemonStarted(client) {
+    const message = {
+      type: "daemon_started",
+      version: DAEMON_VERSION,
+      hostname: os.hostname(),
+      platform: process.platform,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.sendToClient(client, message);
+  }
+  handleMessage(client, raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.logger.warn("Failed to parse client message", { raw: raw.slice(0, 100) });
+      return;
+    }
+    switch (parsed.type) {
+      case "ping":
+        this.sendToClient(client, {
+          type: "pong",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      case "identify":
+        client.id = parsed.clientId;
+        client.type = parsed.clientType;
+        this.logger.info("Client identified", { id: client.id, type: client.type });
+        return;
+      case "wake_detected":
+        this.handleWakeEvent(parsed.wakeword);
+        return;
+      case "set_state":
+        this.stateMachine.setState(parsed.state);
+        return;
+      case "execute_command":
+        this.handleExecuteCommand(parsed.command);
+        return;
+      case "mute":
+        this.logger.info("Mute requested");
+        return;
+      case "unmute":
+        this.logger.info("Unmute requested");
+        return;
+      default: {
+        const exhaustive = parsed;
+        this.logger.warn("Unknown message type", { type: exhaustive.type });
+      }
+    }
+  }
+  /**
+   * Called when wake word is detected (from wakeword-listener webhook or client).
+   */
+  handleWakeEvent(wakeword) {
+    if (this.config.muted) {
+      this.logger.debug("Ignoring wake event (muted)");
+      return;
+    }
+    this.logger.info("Wake word detected", { wakeword });
+    this.stateMachine.handleWake();
+    this.broadcast({
+      type: "wake",
+      wakeword,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async handleExecuteCommand(command) {
+    const result = await this.executor.execute(command);
+    this.broadcast({
+      type: "command_executed",
+      command,
+      success: result.success,
+      error: result.error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Broadcasts a transcript update to all clients.
+   */
+  broadcastTranscript(text, isFinal) {
+    this.broadcast({
+      type: "transcript",
+      text,
+      isFinal,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (isFinal) {
+      this.stateMachine.handleTranscriptComplete();
+    }
+  }
+  /**
+   * Broadcasts an AI response to all clients.
+   */
+  broadcastResponse(text, commands) {
+    this.broadcast({
+      type: "response",
+      text,
+      commands,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Broadcasts an error to all clients.
+   */
+  broadcastError(message, code) {
+    this.stateMachine.handleError();
+    this.broadcast({
+      type: "error",
+      message,
+      code,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  broadcast(message) {
+    const payload = JSON.stringify(message);
+    for (const client of this.clients) {
+      this.sendToClientRaw(client, payload);
+    }
+  }
+  sendToClient(client, message) {
+    this.sendToClientRaw(client, JSON.stringify(message));
+  }
+  sendToClientRaw(client, payload) {
+    if (client.socket.readyState !== WebSocket.OPEN) return;
+    try {
+      client.socket.send(payload);
+    } catch (error) {
+      this.logger.warn("Failed to send to client", { error: String(error) });
+    }
+  }
+  /**
+   * Shuts down the WebSocket server.
+   */
+  async shutdown() {
+    this.logger.info("Shutting down WebSocket server");
+    for (const client of this.clients) {
+      client.socket.close(1001, "Server shutting down");
+    }
+    this.clients.clear();
+    await new Promise((resolve, reject) => {
+      this.wss.close((err) => err ? reject(err) : resolve());
+    });
+  }
+};
+
+// src/voice-daemon/http-server.ts
+import http from "http";
+var VoiceDaemonHttpServer = class {
+  constructor(config, logger, wsServer) {
+    this.config = config;
+    this.logger = logger;
+    this.wsServer = wsServer;
+    this.server = http.createServer((req, res) => this.handleRequest(req, res));
+  }
+  /**
+   * Starts the HTTP server.
+   */
+  start() {
+    this.server.listen(this.config.httpPort, "127.0.0.1", () => {
+      this.logger.info("HTTP server listening", { port: this.config.httpPort });
+    });
+  }
+  handleRequest(req, res) {
+    const url = req.url || "/";
+    const method = req.method || "GET";
+    if (method === "GET" && url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", version: "0.1.0" }));
+      return;
+    }
+    if (method === "POST" && url === "/webhook/wakeword") {
+      this.handleWakewordWebhook(req, res);
+      return;
+    }
+    if (method === "GET" && url === "/status") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          status: "ok",
+          muted: this.config.muted,
+          approvalMode: this.config.approvalMode
+        })
+      );
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  }
+  handleWakewordWebhook(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const payload = JSON.parse(body);
+        if (payload.event === "wakeword" && payload.wakeword) {
+          this.logger.debug("Received wakeword webhook", { wakeword: payload.wakeword });
+          this.wsServer.handleWakeEvent(payload.wakeword);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        } else {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid payload" }));
+        }
+      } catch (error) {
+        this.logger.warn("Failed to parse wakeword webhook", { error: String(error) });
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+      }
+    });
+  }
+  /**
+   * Shuts down the HTTP server.
+   */
+  async shutdown() {
+    await new Promise((resolve, reject) => {
+      this.server.close((err) => err ? reject(err) : resolve());
+    });
+  }
+};
+
+// src/voice-daemon/cli/terminal-ball.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  blink: "\x1B[5m",
+  // Colors
+  gray: "\x1B[90m",
+  blue: "\x1B[34m",
+  brightBlue: "\x1B[94m",
+  purple: "\x1B[35m",
+  green: "\x1B[32m",
+  brightGreen: "\x1B[92m",
+  red: "\x1B[31m",
+  brightRed: "\x1B[91m",
+  white: "\x1B[37m",
+  // Background
+  bgBlue: "\x1B[44m",
+  bgPurple: "\x1B[45m",
+  bgGreen: "\x1B[42m",
+  bgRed: "\x1B[41m",
+  bgGray: "\x1B[100m",
+  // Cursor
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  clear: "\x1B[2J\x1B[H",
+  clearLine: "\x1B[2K",
+  moveTo: (row, col) => `\x1B[${row};${col}H`
+};
+var BALL_FRAMES = {
+  idle: [
+    "    \u25CB    ",
+    "   (\xB7)   ",
+    "    \u25CB    "
+  ],
+  listening: [
+    [
+      "   .\u25CB.   ",
+      "  (( ))  ",
+      "   '\u25CB'   "
+    ],
+    [
+      "  . \u25CB .  ",
+      " ((   )) ",
+      "  ' \u25CB '  "
+    ],
+    [
+      " .  \u25CB  . ",
+      "((     ))",
+      " '  \u25CB  ' "
+    ]
+  ],
+  thinking: [
+    [
+      "    \u25D0    ",
+      "   \xB7\xB7\xB7   ",
+      "    \u25D0    "
+    ],
+    [
+      "    \u25D3    ",
+      "   \xB7\xB7\xB7   ",
+      "    \u25D3    "
+    ],
+    [
+      "    \u25D1    ",
+      "   \xB7\xB7\xB7   ",
+      "    \u25D1    "
+    ],
+    [
+      "    \u25D2    ",
+      "   \xB7\xB7\xB7   ",
+      "    \u25D2    "
+    ]
+  ],
+  speaking: [
+    [
+      "   \u2581\u2583\u2585   ",
+      "  (\u25C9\u25C9\u25C9)  ",
+      "   \u2594\u2594\u2594   "
+    ],
+    [
+      "   \u2583\u2585\u2587   ",
+      "  (\u25C9\u25C9\u25C9)  ",
+      "   \u2594\u2594\u2594   "
+    ],
+    [
+      "   \u2585\u2587\u2585   ",
+      "  (\u25C9\u25C9\u25C9)  ",
+      "   \u2594\u2594\u2594   "
+    ],
+    [
+      "   \u2587\u2585\u2583   ",
+      "  (\u25C9\u25C9\u25C9)  ",
+      "   \u2594\u2594\u2594   "
+    ]
+  ],
+  error: [
+    [
+      "   \u26A0\uFE0F    ",
+      "  (\u2717\u2717\u2717)  ",
+      "   \u26A0\uFE0F    "
+    ],
+    [
+      "    \u26A0\uFE0F   ",
+      "  (\u2717\u2717\u2717)  ",
+      "    \u26A0\uFE0F   "
+    ]
+  ]
+};
+var STATE_COLORS = {
+  idle: ANSI.gray,
+  listening: ANSI.brightBlue,
+  thinking: ANSI.purple,
+  speaking: ANSI.brightGreen,
+  error: ANSI.brightRed
+};
+var STATE_LABELS = {
+  idle: "IDLE - Say 'codmir' to activate",
+  listening: "LISTENING...",
+  thinking: "THINKING...",
+  speaking: "SPEAKING...",
+  error: "ERROR"
+};
+var TerminalBall = class {
+  constructor(options = {}) {
+    this.state = "idle";
+    this.frameIndex = 0;
+    this.intervalId = null;
+    this.lastTranscript = "";
+    this.lastResponse = "";
+    this.isRunning = false;
+    this.compact = options.compact ?? false;
+  }
+  /**
+   * Start the terminal ball animation.
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    process.stdout.write(ANSI.hide);
+    this.render();
+    this.intervalId = setInterval(() => {
+      this.frameIndex++;
+      this.render();
+    }, 200);
+    process.on("SIGINT", () => this.stop());
+    process.on("SIGTERM", () => this.stop());
+  }
+  /**
+   * Stop the terminal ball.
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    process.stdout.write(ANSI.show);
+    process.stdout.write(ANSI.reset);
+    process.stdout.write("\n");
+  }
+  /**
+   * Update the assistant state.
+   */
+  setState(state) {
+    if (state !== this.state) {
+      this.state = state;
+      this.frameIndex = 0;
+      this.render();
+    }
+  }
+  /**
+   * Update the transcript display.
+   */
+  setTranscript(text) {
+    this.lastTranscript = text;
+    this.render();
+  }
+  /**
+   * Update the response display.
+   */
+  setResponse(text) {
+    this.lastResponse = text;
+    this.render();
+  }
+  /**
+   * Get the current state.
+   */
+  getState() {
+    return this.state;
+  }
+  render() {
+    if (!this.isRunning) return;
+    const color = STATE_COLORS[this.state];
+    const label = STATE_LABELS[this.state];
+    const frames = this.getFrames();
+    const frame = Array.isArray(frames[0]) ? frames[this.frameIndex % frames.length] : frames;
+    if (this.compact) {
+      this.renderCompact(color, label, frame);
+    } else {
+      this.renderFull(color, label, frame);
+    }
+  }
+  getFrames() {
+    return BALL_FRAMES[this.state];
+  }
+  renderCompact(color, label, frame) {
+    const line = frame.join(" ").replace(/\s+/g, " ").trim();
+    process.stdout.write(ANSI.clearLine);
+    process.stdout.write("\r");
+    process.stdout.write(`${color}${ANSI.bold}[codmir]${ANSI.reset} `);
+    process.stdout.write(`${color}${line}${ANSI.reset} `);
+    process.stdout.write(`${ANSI.dim}${label}${ANSI.reset}`);
+  }
+  renderFull(color, label, frame) {
+    const width = process.stdout.columns || 80;
+    const height = process.stdout.rows || 24;
+    const startRow = Math.floor(height / 2) - 2;
+    const startCol = Math.floor((width - 12) / 2);
+    process.stdout.write(ANSI.moveTo(startRow, 1));
+    const header = `${ANSI.bold}codmir Voice Assistant${ANSI.reset}`;
+    const headerPad = Math.floor((width - 22) / 2);
+    process.stdout.write(ANSI.clearLine);
+    process.stdout.write(" ".repeat(Math.max(0, headerPad)) + header + "\n");
+    for (const line of frame) {
+      process.stdout.write(ANSI.clearLine);
+      process.stdout.write(" ".repeat(Math.max(0, startCol)));
+      process.stdout.write(`${color}${line}${ANSI.reset}
+`);
+    }
+    process.stdout.write(ANSI.clearLine);
+    const statusPad = Math.floor((width - label.length) / 2);
+    process.stdout.write(" ".repeat(Math.max(0, statusPad)));
+    process.stdout.write(`${color}${ANSI.bold}${label}${ANSI.reset}
+`);
+    if (this.lastTranscript) {
+      process.stdout.write(ANSI.clearLine);
+      const tPad = Math.floor((width - this.lastTranscript.length - 8) / 2);
+      process.stdout.write(" ".repeat(Math.max(0, tPad)));
+      process.stdout.write(`${ANSI.dim}You: "${this.lastTranscript}"${ANSI.reset}
+`);
+    } else {
+      process.stdout.write(ANSI.clearLine + "\n");
+    }
+    if (this.lastResponse) {
+      process.stdout.write(ANSI.clearLine);
+      const rPad = Math.floor((width - this.lastResponse.length - 10) / 2);
+      process.stdout.write(" ".repeat(Math.max(0, rPad)));
+      process.stdout.write(`${ANSI.brightGreen}codmir: "${this.lastResponse}"${ANSI.reset}
+`);
+    }
+  }
+};
+var InlineBallIndicator = class {
+  constructor() {
+    this.state = "idle";
+  }
+  setState(state) {
+    this.state = state;
+  }
+  getIndicator() {
+    const indicators = {
+      idle: "\u25CB",
+      listening: "\u25C9",
+      thinking: "\u25D0",
+      speaking: "\u25C8",
+      error: "\u2717"
+    };
+    const colors = {
+      idle: ANSI.gray,
+      listening: ANSI.brightBlue,
+      thinking: ANSI.purple,
+      speaking: ANSI.brightGreen,
+      error: ANSI.brightRed
+    };
+    return `${colors[this.state]}${indicators[this.state]}${ANSI.reset}`;
+  }
+  getStatusLine() {
+    const labels = {
+      idle: "idle",
+      listening: "listening",
+      thinking: "thinking",
+      speaking: "speaking",
+      error: "error"
+    };
+    return `[codmir ${this.getIndicator()}] ${labels[this.state]}`;
+  }
+};
+
+// src/voice-daemon/cli/renderer.ts
+function detectDisplayMode() {
+  const hasDisplay = !!process.env.DISPLAY || !!process.env.WAYLAND_DISPLAY;
+  const isTTY = process.stdout.isTTY;
+  const isCI = !!process.env.CI || !!process.env.GITHUB_ACTIONS;
+  const isSSH = !!process.env.SSH_CLIENT || !!process.env.SSH_TTY;
+  const termSupportsColor = process.env.TERM !== "dumb" && process.env.COLORTERM !== void 0;
+  if (hasDisplay && !isSSH && !isCI) {
+    return "gui";
+  }
+  if (isTTY && !isCI) {
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    if (cols >= 40 && rows >= 10) {
+      return "terminal";
+    }
+    return "compact";
+  }
+  if (termSupportsColor) {
+    return "inline";
+  }
+  return "none";
+}
+var CLIRenderer = class {
+  constructor(options = {}) {
+    this.terminalBall = null;
+    this.inlineIndicator = null;
+    this.state = "idle";
+    this.guiProcess = null;
+    this.mode = options.forceMode ? options.mode || "terminal" : detectDisplayMode();
+  }
+  /**
+   * Get the current display mode.
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Start the renderer.
+   */
+  async start() {
+    switch (this.mode) {
+      case "gui":
+        await this.startGUI();
+        break;
+      case "terminal":
+        this.terminalBall = new TerminalBall({ compact: false });
+        this.terminalBall.start();
+        break;
+      case "compact":
+        this.terminalBall = new TerminalBall({ compact: true });
+        this.terminalBall.start();
+        break;
+      case "inline":
+        this.inlineIndicator = new InlineBallIndicator();
+        console.log("[codmir] Voice assistant started (inline mode)");
+        break;
+      case "none":
+        console.log("[codmir] Voice assistant started (no display)");
+        break;
+    }
+  }
+  /**
+   * Stop the renderer.
+   */
+  stop() {
+    if (this.terminalBall) {
+      this.terminalBall.stop();
+      this.terminalBall = null;
+    }
+    if (this.guiProcess) {
+      this.guiProcess.kill();
+      this.guiProcess = null;
+    }
+  }
+  /**
+   * Update the assistant state.
+   */
+  setState(state) {
+    this.state = state;
+    if (this.terminalBall) {
+      this.terminalBall.setState(state);
+    }
+    if (this.inlineIndicator) {
+      this.inlineIndicator.setState(state);
+      console.log(this.inlineIndicator.getStatusLine());
+    }
+  }
+  /**
+   * Update transcript display.
+   */
+  setTranscript(text) {
+    if (this.terminalBall) {
+      this.terminalBall.setTranscript(text);
+    }
+    if (this.mode === "inline" || this.mode === "none") {
+      console.log(`[codmir] Transcript: "${text}"`);
+    }
+  }
+  /**
+   * Update response display.
+   */
+  setResponse(text) {
+    if (this.terminalBall) {
+      this.terminalBall.setResponse(text);
+    }
+    if (this.mode === "inline" || this.mode === "none") {
+      console.log(`[codmir] Response: "${text}"`);
+    }
+  }
+  async startGUI() {
+    const { spawn } = await import("child_process");
+    const path = await import("path");
+    const overlayScript = path.join(__dirname, "..", "..", "overlay", "ball.py");
+    try {
+      this.guiProcess = spawn("python3", [overlayScript], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env }
+      });
+      this.guiProcess.unref();
+    } catch (error) {
+      console.warn("[codmir] Failed to start GUI overlay, falling back to terminal mode");
+      this.terminalBall = new TerminalBall({ compact: false });
+      this.terminalBall.start();
+    }
+  }
+};
+function createRenderer(options) {
+  return new CLIRenderer(options);
+}
+
+// src/voice-daemon/index.ts
+var TEST_STATES = ["idle", "listening", "thinking", "speaking", "idle"];
+var TEST_TRANSCRIPTS = ["", "open firefox", "", "", ""];
+var TEST_RESPONSES = ["", "", "", "Opening Firefox for you", ""];
+async function main() {
+  const logLevel = normalizeLogLevel(process.env.CODMIR_VOICE_LOG_LEVEL);
+  const logger = new Logger(logLevel);
+  const isTestMode = process.env.CODMIR_TEST_MODE === "1";
+  const displayMode = process.env.CODMIR_DISPLAY_MODE;
+  logger.info("Starting codmir voice daemon...");
+  const config = loadConfig(logger);
+  logger.info("Configuration loaded", {
+    port: config.port,
+    httpPort: config.httpPort,
+    approvalMode: config.approvalMode,
+    displayMode: displayMode || "auto",
+    testMode: isTestMode
+  });
+  const stateMachine = new AssistantStateMachine(logger);
+  const executor = new CommandExecutor(config, logger);
+  const wsServer = new VoiceDaemonWebSocketServer(config, logger, stateMachine, executor);
+  const httpServer = new VoiceDaemonHttpServer(config, logger, wsServer);
+  const renderer = createRenderer({
+    mode: displayMode,
+    forceMode: !!displayMode
+  });
+  stateMachine.onStateChange((state) => {
+    renderer.setState(state);
+  });
+  httpServer.start();
+  await renderer.start();
+  if (isTestMode) {
+    logger.info("Running in test mode - cycling through states");
+    let stateIndex = 0;
+    const cycleStates = () => {
+      const state = TEST_STATES[stateIndex];
+      const transcript = TEST_TRANSCRIPTS[stateIndex];
+      const response = TEST_RESPONSES[stateIndex];
+      stateMachine.setState(state);
+      if (transcript) renderer.setTranscript(transcript);
+      if (response) renderer.setResponse(response);
+      stateIndex = (stateIndex + 1) % TEST_STATES.length;
+    };
+    cycleStates();
+    setInterval(cycleStates, 2500);
+  }
+  const shutdown = async (signal) => {
+    logger.info("Received shutdown signal", { signal });
+    try {
+      renderer.stop();
+      await httpServer.shutdown();
+      await wsServer.shutdown();
+    } catch (error) {
+      logger.error("Error during shutdown", { error: String(error) });
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  logger.info("codmir voice daemon ready", {
+    wsPort: config.port,
+    httpPort: config.httpPort,
+    displayMode: renderer.getMode()
+  });
+}
+if (__require.main === module) {
+  void main().catch((error) => {
+    console.error("Fatal error starting codmir voice daemon:", error);
+    process.exit(1);
+  });
+}
+export {
+  AssistantStateMachine,
+  CLIRenderer,
+  CommandExecutor,
+  InlineBallIndicator,
+  Logger,
+  TerminalBall,
+  VoiceDaemonHttpServer,
+  VoiceDaemonWebSocketServer,
+  createRenderer,
+  loadConfig,
+  normalizeLogLevel
+};