@lawaty/lacode 1.0.3 → 1.2.0

package/dist/lacode-voice.js

@@ -0,0 +1,2351 @@
+#!/usr/bin/env node
+
+// bin/lacode-voice
+import { fileURLToPath } from "node:url";
+import { spawn as spawn2 } from "node:child_process";
+import { createWriteStream, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join4 } from "node:path";
+import * as net from "node:net";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+// src/voice/config.ts
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/voice/groq.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_READ_FILE = (p) => {
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+function resolveGroqKey(deps) {
+  const env = deps?.env ?? process.env;
+  const home = deps?.home ?? homedir();
+  const readFile = deps?.readFile ?? DEFAULT_READ_FILE;
+  const safeRead2 = (p) => {
+    try {
+      return readFile(p);
+    } catch {
+      return null;
+    }
+  };
+  const envVal = env?.GROQ_KEY;
+  if (typeof envVal === "string") {
+    const trimmed = envVal.trim();
+    if (trimmed !== "") return { key: trimmed, source: "env" };
+  }
+  const filePath = join(home, ".config", "lacode", "voice.json");
+  const fileContent = safeRead2(filePath);
+  if (typeof fileContent === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(fileContent);
+    } catch {
+      parsed = void 0;
+    }
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      const keys = ["groqKey", "GROQ_KEY", "apiKey", "groq_key"];
+      for (const k of keys) {
+        const v = obj[k];
+        if (typeof v === "string") {
+          const t = v.trim();
+          if (t !== "") return { key: t, source: "file" };
+        }
+      }
+    }
+  }
+  const bashFiles = [join(home, ".bashrc"), join(home, ".bash_profile"), join(home, ".profile")];
+  const skipPatterns = ["$(", "`", "$GROQ", "$HOME"];
+  const regex = /^\s*(?:export\s+)?GROQ_KEY\s*=\s*(.+?)\s*$/;
+  for (const f of bashFiles) {
+    const content = safeRead2(f);
+    if (typeof content !== "string") continue;
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      const m = regex.exec(line);
+      if (!m) continue;
+      let value = m[1];
+      const isSingle = value.startsWith("'") && value.endsWith("'") && value.length >= 2;
+      const isDouble = value.startsWith('"') && value.endsWith('"') && value.length >= 2;
+      if (isSingle || isDouble) {
+        value = value.slice(1, -1);
+      } else {
+        value = value.replace(/\s+#.*$/, "");
+        value = value.trim();
+      }
+      let skip = false;
+      for (const p of skipPatterns) {
+        if (value.includes(p)) {
+          skip = true;
+          break;
+        }
+      }
+      if (skip) continue;
+      if (value === "") continue;
+      return { key: value, source: "bashrc" };
+    }
+  }
+  return void 0;
+}
+async function transcribe(input) {
+  if (!input.audio || input.audio.length === 0) {
+    throw new Error("no audio captured");
+  }
+  const filename = input.filename ?? "audio.wav";
+  const model = input.model ?? "whisper-large-v3-turbo";
+  const language = input.language ?? "en";
+  const baseUrl = input.baseUrl ?? "https://api.groq.com/openai/v1";
+  const timeoutMs = input.timeoutMs ?? 3e4;
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const form = new FormData();
+  const blob = new Blob([input.audio], { type: "audio/wav" });
+  form.append("file", blob, filename);
+  form.append("model", model);
+  form.append("language", language);
+  form.append("temperature", "0");
+  form.append("response_format", "json");
+  if (input.prompt) form.append("prompt", input.prompt);
+  const url = `${baseUrl}/audio/transcriptions`;
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${input.key}` },
+    body: form,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    try {
+      await res.text();
+    } catch {
+    }
+    throw new Error(`groq transcription failed (HTTP ${res.status})`);
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    return "";
+  }
+  const text = json?.text;
+  if (typeof text !== "string" || text.trim() === "") return "";
+  return text.trim();
+}
+
+// src/voice/config.ts
+var DEFAULT_WAKE_PHRASES = ["hey la code"];
+var VOICE_DATA_DIR = (deps) => {
+  const env = deps?.env ?? process.env;
+  const home = deps?.home ?? homedir2();
+  const xdg = env.XDG_DATA_HOME;
+  if (typeof xdg === "string" && xdg.trim() !== "") {
+    return join2(xdg.trim(), "lacode", "voice");
+  }
+  return join2(home, ".local", "share", "lacode", "voice");
+};
+var DEFAULT_READ_FILE2 = (p) => {
+  try {
+    return readFileSync2(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+var VOICE_CONFIG_PATH = (home) => join2(home ?? homedir2(), ".config", "lacode", "voice.json");
+function safeRead(readFile, p) {
+  try {
+    return readFile(p);
+  } catch {
+    return null;
+  }
+}
+function envGet(env, names) {
+  if (!env) return void 0;
+  for (const n of names) {
+    const v = env[n];
+    if (typeof v === "string") return v;
+  }
+  return void 0;
+}
+function toInt(raw) {
+  if (typeof raw === "number") {
+    return Number.isInteger(raw) ? raw : void 0;
+  }
+  if (typeof raw === "string") {
+    const t = raw.trim();
+    if (t === "" || !/^-?\d+$/.test(t)) return void 0;
+    const n = Number(t);
+    return Number.isInteger(n) ? n : void 0;
+  }
+  return void 0;
+}
+function toFloat(raw) {
+  if (typeof raw === "number") {
+    return Number.isFinite(raw) ? raw : void 0;
+  }
+  if (typeof raw === "string") {
+    const t = raw.trim();
+    if (t === "") return void 0;
+    const n = Number(t);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function expandHome(value, home) {
+  const v = value.trim();
+  if (v === "~") return home;
+  if (v.startsWith("~/")) return join2(home, v.slice(2));
+  return v;
+}
+function isLoopbackHost(host) {
+  const h = host.trim().toLowerCase();
+  return h === "127.0.0.1" || h === "::1" || h === "localhost";
+}
+function normalizeEngine(raw) {
+  if (typeof raw !== "string") return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "vosk" || v === "porcupine") return v;
+  return void 0;
+}
+function normalizePhrases(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") continue;
+    const v = entry.trim();
+    if (v !== "") out.push(v);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function parsePhraseEnv(raw) {
+  return normalizePhrases(raw.split(","));
+}
+var PORT_ENV = ["LACODE_VOICE_PORT", "LACODE_PORT", "VOICE_PORT"];
+var SENS_ENV = ["LACODE_WAKE_SENSITIVITY", "LACODE_VOICE_SENSITIVITY", "VOICE_SENSITIVITY", "LACODE_SENSITIVITY"];
+var MODEL_ENV = ["LACODE_VOICE_MODEL", "LACODE_MODEL", "VOICE_MODEL", "LACODE_VOICE_TRANSCRIPTION_MODEL"];
+var LANG_ENV = ["LACODE_VOICE_LANGUAGE", "LACODE_LANGUAGE", "LACODE_VOICE_LANG", "VOICE_LANGUAGE"];
+var PK_ENV = ["PICOVOICE_ACCESS_KEY", "PICOVOICE_KEY", "LACODE_PICOVOICE_KEY"];
+var WW_ENV = ["LACODE_WAKE_WORD", "LACODE_VOICE_WAKE_WORD", "LACODE_WAKE_WORD_PATH", "LACODE_VOICE_WAKEWORD"];
+var INPUT_ENV = ["LACODE_VOICE_INPUT", "LACODE_INPUT", "VOICE_INPUT"];
+var SR_ENV = ["LACODE_VOICE_SAMPLE_RATE", "LACODE_SAMPLE_RATE"];
+var HOST_ENV = ["LACODE_VOICE_HOST", "LACODE_HOST"];
+function resolveVoiceConfig(deps) {
+  const env = deps?.env ?? process.env;
+  const home = deps?.home ?? homedir2();
+  const defaults = {
+    wakeSensitivity: 0.5,
+    wakeEngine: "vosk",
+    voskModelPath: join2(VOICE_DATA_DIR({ env, home }), "vosk-model-small-en-us-0.15"),
+    wakePhrases: [...DEFAULT_WAKE_PHRASES],
+    port: 8765,
+    host: "127.0.0.1",
+    model: "whisper-large-v3-turbo",
+    language: "en",
+    armOnStart: true,
+    sampleRate: 16e3
+  };
+  try {
+    const readFile = deps?.readFile ?? DEFAULT_READ_FILE2;
+    const filePath = VOICE_CONFIG_PATH(home);
+    const content = safeRead(readFile, filePath);
+    let json = null;
+    if (typeof content === "string") {
+      try {
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          json = parsed;
+        }
+      } catch {
+        json = null;
+      }
+    }
+    const j = json ?? {};
+    let groqKey;
+    let groqSource;
+    try {
+      const resolved = resolveGroqKey({ env, home, readFile });
+      if (resolved) {
+        groqKey = resolved.key;
+        groqSource = resolved.source;
+      }
+    } catch {
+      groqKey = void 0;
+      groqSource = void 0;
+    }
+    let picovoiceKey;
+    const pkEnv = envGet(env, PK_ENV);
+    if (typeof pkEnv === "string" && pkEnv.trim() !== "") {
+      picovoiceKey = pkEnv.trim();
+    } else {
+      for (const k of ["picovoiceKey", "picovoice_access_key", "picovoiceAccessKey"]) {
+        const v = j[k];
+        if (typeof v === "string" && v.trim() !== "") {
+          picovoiceKey = v.trim();
+          break;
+        }
+      }
+    }
+    let wakeWordPath;
+    const wwEnv = envGet(env, WW_ENV);
+    if (typeof wwEnv === "string" && wwEnv.trim() !== "") {
+      wakeWordPath = expandHome(wwEnv, home);
+    } else {
+      for (const k of ["wakeWordPath", "wake_word_path", "wakeWord"]) {
+        const v = j[k];
+        if (typeof v === "string" && v.trim() !== "") {
+          wakeWordPath = expandHome(v, home);
+          break;
+        }
+      }
+    }
+    const sensEnv = envGet(env, SENS_ENV);
+    const sensRaw = sensEnv !== void 0 ? sensEnv : j.wakeSensitivity ?? j.wake_sensitivity;
+    const sensNum = toFloat(sensRaw);
+    let wakeSensitivity = 0.5;
+    if (sensNum !== void 0) {
+      wakeSensitivity = Math.min(1, Math.max(0, sensNum));
+    }
+    let wakeEngine = "vosk";
+    const engineEnv = env.LACODE_WAKE_ENGINE;
+    if (typeof engineEnv === "string" && engineEnv.trim() !== "") {
+      wakeEngine = normalizeEngine(engineEnv) ?? "vosk";
+    } else {
+      wakeEngine = normalizeEngine(j.wakeEngine) ?? "vosk";
+    }
+    let voskModelPath = join2(VOICE_DATA_DIR({ env, home }), "vosk-model-small-en-us-0.15");
+    const voskEnv = env.LACODE_VOSK_MODEL;
+    if (typeof voskEnv === "string" && voskEnv.trim() !== "") {
+      voskModelPath = expandHome(voskEnv, home);
+    } else {
+      const vv = j.voskModelPath;
+      if (typeof vv === "string" && vv.trim() !== "") {
+        voskModelPath = expandHome(vv, home);
+      }
+    }
+    let wakePhrases = [...DEFAULT_WAKE_PHRASES];
+    const phraseEnv = env.LACODE_WAKE_PHRASES;
+    const envPhrases = typeof phraseEnv === "string" ? parsePhraseEnv(phraseEnv) : void 0;
+    if (envPhrases) {
+      wakePhrases = envPhrases;
+    } else {
+      const jsonPhrases = normalizePhrases(j.wakePhrases);
+      if (jsonPhrases) wakePhrases = jsonPhrases;
+    }
+    const portEnv = envGet(env, PORT_ENV);
+    const portRaw = portEnv !== void 0 ? portEnv : j.port;
+    const portNum = toInt(portRaw);
+    let port = 8765;
+    if (portNum !== void 0 && portNum >= 1 && portNum <= 65535) {
+      port = portNum;
+    }
+    const allowNonLocal = typeof env.LACODE_VOICE_ALLOW_NONLOCAL === "string" && ["1", "true", "True", "TRUE"].includes(env.LACODE_VOICE_ALLOW_NONLOCAL.trim()) || j.allowNonLocal === true;
+    let host = "127.0.0.1";
+    const hostEnv = envGet(env, HOST_ENV);
+    if (typeof hostEnv === "string" && hostEnv.trim() !== "") {
+      const h = hostEnv.trim();
+      if (isLoopbackHost(h) || allowNonLocal) {
+        host = h;
+      } else {
+        host = "127.0.0.1";
+      }
+    } else {
+      const hv = j.host;
+      if (typeof hv === "string" && hv.trim() !== "") {
+        const h = hv.trim();
+        if (isLoopbackHost(h) || allowNonLocal) {
+          host = h;
+        } else {
+          host = "127.0.0.1";
+        }
+      }
+    }
+    let model = "whisper-large-v3-turbo";
+    const modelEnv = envGet(env, MODEL_ENV);
+    if (typeof modelEnv === "string" && modelEnv.trim() !== "") {
+      model = modelEnv.trim();
+    } else {
+      const mv = j.model;
+      if (typeof mv === "string" && mv.trim() !== "") {
+        model = mv.trim();
+      }
+    }
+    let language = "en";
+    const langEnv = envGet(env, LANG_ENV);
+    if (typeof langEnv === "string" && langEnv.trim() !== "") {
+      language = langEnv.trim();
+    } else {
+      const lv = j.language;
+      if (typeof lv === "string" && lv.trim() !== "") {
+        language = lv.trim();
+      }
+    }
+    let armOnStart = true;
+    const jsonArm = j.armOnStart ?? j.arm_on_start;
+    if (typeof jsonArm === "boolean") {
+      armOnStart = jsonArm;
+    }
+    const noArm = env.LACODE_VOICE_NO_ARM;
+    if (noArm === "1" || noArm === "true" || noArm === "True" || noArm === "TRUE") {
+      armOnStart = false;
+    }
+    const srEnv = envGet(env, SR_ENV);
+    const srRaw = srEnv !== void 0 ? srEnv : j.sampleRate ?? j.sample_rate;
+    const srNum = toInt(srRaw);
+    let sampleRate = 16e3;
+    if (srNum !== void 0 && srNum > 0) {
+      sampleRate = srNum;
+    }
+    let input;
+    const inputEnv = envGet(env, INPUT_ENV);
+    if (typeof inputEnv === "string" && inputEnv.trim() !== "") {
+      input = inputEnv.trim();
+    } else {
+      const iv = j.input;
+      if (typeof iv === "string" && iv.trim() !== "") {
+        input = iv.trim();
+      }
+    }
+    return {
+      groqKey,
+      groqSource,
+      picovoiceKey,
+      wakeWordPath,
+      wakeSensitivity,
+      wakeEngine,
+      voskModelPath,
+      wakePhrases,
+      port,
+      host,
+      model,
+      language,
+      armOnStart,
+      sampleRate,
+      input
+    };
+  } catch {
+    return { ...defaults };
+  }
+}
+
+// src/voice/capture.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+function resolveBinary(name, deps) {
+  const env = deps?.env ?? {};
+  const exists = deps?.exists ?? ((f) => {
+    try {
+      return existsSync(f);
+    } catch {
+      return false;
+    }
+  });
+  if (exists(name)) return name;
+  const pathEnv = env.PATH ?? process.env.PATH ?? "";
+  const dirs = pathEnv.split(path.delimiter).filter((d) => d.length > 0).concat(["/usr/bin", "/usr/local/bin", "/opt/homebrew/bin"]);
+  for (const dir of dirs) {
+    const candidate = path.join(dir, name);
+    if (exists(candidate)) return candidate;
+  }
+  return void 0;
+}
+function sanitizeVoiceInput(input, fallback) {
+  if (input === void 0) return fallback;
+  const trimmed = typeof input === "string" ? input.trim() : String(input).trim();
+  if (trimmed === "") return fallback;
+  if (trimmed.startsWith("-")) return fallback;
+  return trimmed;
+}
+function planCapture(deps) {
+  const platform = deps?.platform ?? process.platform;
+  const env = deps?.env ?? {};
+  const input = env.LACODE_VOICE_INPUT;
+  const ffmpeg = resolveBinary("ffmpeg", deps);
+  const parec = resolveBinary("parec", deps);
+  const arecord = resolveBinary("arecord", deps);
+  if (platform === "linux") {
+    if (ffmpeg) {
+      const value = sanitizeVoiceInput(input, "default");
+      return {
+        bin: ffmpeg,
+        args: [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-f",
+          "pulse",
+          "-i",
+          value,
+          "-ac",
+          "1",
+          "-ar",
+          "16000",
+          "-f",
+          "s16le",
+          "pipe:1"
+        ]
+      };
+    }
+    if (parec) {
+      return {
+        bin: parec,
+        args: ["--format=s16le", "--rate=16000", "--channels=1", "--raw"]
+      };
+    }
+    if (arecord) {
+      return {
+        bin: arecord,
+        args: ["-q", "-t", "raw", "-f", "S16_LE", "-r", "16000", "-c", "1"]
+      };
+    }
+    return void 0;
+  }
+  if (platform === "darwin") {
+    if (ffmpeg) {
+      const value = sanitizeVoiceInput(input, ":0");
+      return {
+        bin: ffmpeg,
+        args: [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-f",
+          "avfoundation",
+          "-i",
+          value,
+          "-ac",
+          "1",
+          "-ar",
+          "16000",
+          "-f",
+          "s16le",
+          "pipe:1"
+        ]
+      };
+    }
+    return void 0;
+  }
+  if (platform === "win32") {
+    if (ffmpeg) {
+      const value = sanitizeVoiceInput(input, "audio=default");
+      return {
+        bin: ffmpeg,
+        args: [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-f",
+          "dshow",
+          "-i",
+          value,
+          "-ac",
+          "1",
+          "-ar",
+          "16000",
+          "-f",
+          "s16le",
+          "pipe:1"
+        ]
+      };
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function createCapture(onChunk, deps) {
+  const spawnImpl = deps?.spawnImpl ?? spawn;
+  const plan = planCapture(deps);
+  let running = false;
+  let child = void 0;
+  const capture = {
+    get running() {
+      return running;
+    },
+    get plan() {
+      return plan;
+    },
+    start() {
+      if (running) return;
+      if (!plan) return;
+      if (child) {
+        try {
+          child.kill?.("SIGKILL");
+        } catch {
+        }
+        child = void 0;
+      }
+      let c;
+      try {
+        c = spawnImpl(plan.bin, plan.args, { stdio: ["ignore", "pipe", "ignore"] });
+      } catch {
+        running = false;
+        child = void 0;
+        return;
+      }
+      child = c;
+      running = true;
+      try {
+        const stdout = c?.stdout;
+        if (stdout && typeof stdout.on === "function") {
+          stdout.on("data", (chunk) => {
+            try {
+              onChunk(chunk);
+            } catch {
+            }
+          });
+        }
+      } catch {
+      }
+      try {
+        if (c && typeof c.on === "function") {
+          c.on("error", () => {
+            running = false;
+          });
+          c.on("exit", () => {
+            running = false;
+          });
+          c.on("close", () => {
+            running = false;
+            child = void 0;
+          });
+        }
+      } catch {
+      }
+    },
+    stop() {
+      const c = child;
+      child = void 0;
+      running = false;
+      if (!c) return;
+      let timer;
+      const cleanup = () => {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+      };
+      try {
+        if (typeof c.on === "function") {
+          c.on("close", cleanup);
+          c.on("exit", cleanup);
+        }
+      } catch {
+      }
+      try {
+        if (typeof c.kill === "function") c.kill("SIGTERM");
+      } catch {
+        cleanup();
+      }
+      timer = setTimeout(() => {
+        try {
+          if (typeof c.kill === "function") c.kill("SIGKILL");
+        } catch {
+        }
+      }, 1500);
+      try {
+        timer?.unref?.();
+      } catch {
+      }
+      try {
+        c.unref?.();
+      } catch {
+      }
+      try {
+        c.stdout?.destroy?.();
+      } catch {
+      }
+    }
+  };
+  return capture;
+}
+function createFrameSplitter(samples, onFrame) {
+  if (!Number.isInteger(samples) || samples <= 0) {
+    throw new Error("samples must be > 0");
+  }
+  const frameBytes = samples * 2;
+  let buf = Buffer.alloc(0);
+  return (chunk) => {
+    buf = buf.length > 0 ? Buffer.concat([buf, chunk]) : Buffer.from(chunk);
+    let off = 0;
+    while (off + frameBytes <= buf.length) {
+      const slice = buf.subarray(off, off + frameBytes);
+      const frame = new Int16Array(samples);
+      for (let i = 0; i < samples; i++) {
+        frame[i] = slice.readInt16LE(i * 2);
+      }
+      try {
+        onFrame(frame);
+      } catch {
+      }
+      off += frameBytes;
+    }
+    buf = Buffer.from(buf.subarray(off));
+  };
+}
+
+// src/voice/vad.ts
+function rmsOf(frame) {
+  if (frame.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < frame.length; i++) {
+    const v = frame[i];
+    sum += v * v;
+  }
+  return Math.sqrt(sum / frame.length);
+}
+function concatFrames(frames) {
+  let total = 0;
+  for (const f of frames) total += f.length;
+  const out = new Int16Array(total);
+  let off = 0;
+  for (const f of frames) {
+    out.set(f, off);
+    off += f.length;
+  }
+  return out;
+}
+function createVad(config) {
+  const sampleRate = config?.sampleRate ?? 16e3;
+  const speechRms = config?.speechRms ?? 500;
+  const noiseMultiplier = config?.noiseMultiplier ?? 2.5;
+  const endSilenceMs = config?.endSilenceMs ?? 800;
+  const minUtteranceMs = config?.minUtteranceMs ?? 250;
+  const maxUtteranceMs = config?.maxUtteranceMs ?? 3e4;
+  const preRollMs = config?.preRollMs ?? 300;
+  const preRollSamples = Math.max(0, Math.round(preRollMs / 1e3 * sampleRate));
+  let noiseFloor = 200;
+  const alpha = 0.05;
+  let speaking = false;
+  let speechFrameCount = 0;
+  const ring = [];
+  let ringSamples = 0;
+  const accumulated = [];
+  let accumulatedSamples = 0;
+  const trailingSilence = [];
+  let silenceMs = 0;
+  function frameMs(n) {
+    return n / sampleRate * 1e3;
+  }
+  function resetState() {
+    speaking = false;
+    speechFrameCount = 0;
+    ring.length = 0;
+    ringSamples = 0;
+    accumulated.length = 0;
+    accumulatedSamples = 0;
+    trailingSilence.length = 0;
+    silenceMs = 0;
+    noiseFloor = 200;
+  }
+  function trimRing() {
+    while (ring.length > 1 && ringSamples > preRollSamples) {
+      const oldest = ring.shift();
+      ringSamples -= oldest.length;
+    }
+  }
+  function finalizeUtterance(emit, removeTrailing) {
+    let frames = accumulated.slice();
+    if (removeTrailing && trailingSilence.length > 0) {
+      const removeCount = trailingSilence.length;
+      frames = frames.slice(0, frames.length - removeCount);
+    }
+    const audio = concatFrames(frames);
+    const durMs = audio.length / sampleRate * 1e3;
+    if (durMs >= minUtteranceMs) {
+      emit({ t: "utterance", audio });
+    }
+    accumulated.length = 0;
+    accumulatedSamples = 0;
+    trailingSilence.length = 0;
+    silenceMs = 0;
+  }
+  const vad = {
+    get speaking() {
+      return speaking;
+    },
+    push(frame) {
+      const events = [];
+      const emit = (e) => events.push(e);
+      ring.push(frame);
+      ringSamples += frame.length;
+      trimRing();
+      const rms = rmsOf(frame);
+      const threshold = Math.max(speechRms, noiseFloor * noiseMultiplier);
+      const isSpeech = rms > threshold;
+      const durMs = frameMs(frame.length);
+      if (!speaking) {
+        if (isSpeech) {
+          speechFrameCount++;
+          if (speechFrameCount >= 3) {
+            speaking = true;
+            accumulated.length = 0;
+            accumulatedSamples = 0;
+            for (const f of ring) {
+              accumulated.push(f);
+              accumulatedSamples += f.length;
+            }
+            trailingSilence.length = 0;
+            silenceMs = 0;
+            emit({ t: "speech-start" });
+          }
+        } else {
+          speechFrameCount = 0;
+          noiseFloor = noiseFloor + alpha * (rms - noiseFloor);
+        }
+      } else {
+        if (isSpeech) {
+          accumulated.push(frame);
+          accumulatedSamples += frame.length;
+          trailingSilence.length = 0;
+          silenceMs = 0;
+        } else {
+          accumulated.push(frame);
+          accumulatedSamples += frame.length;
+          trailingSilence.push(frame);
+          silenceMs += durMs;
+          if (silenceMs >= endSilenceMs) {
+            finalizeUtterance(emit, true);
+            speaking = false;
+            speechFrameCount = 0;
+          }
+        }
+        if (speaking) {
+          const accDurMs = accumulatedSamples / sampleRate * 1e3;
+          if (accDurMs >= maxUtteranceMs) {
+            finalizeUtterance(emit, false);
+            silenceMs = 0;
+            trailingSilence.length = 0;
+          }
+        }
+      }
+      return events;
+    },
+    reset() {
+      resetState();
+    }
+  };
+  return vad;
+}
+
+// src/voice/wake.ts
+import { existsSync as existsSync2 } from "node:fs";
+var WakeConfigError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "WakeConfigError";
+    this.code = code;
+  }
+};
+var BUILTIN_NAMES = [
+  "alexa",
+  "americano",
+  "blueberry",
+  "bumblebee",
+  "computer",
+  "grapefruit",
+  "grasshopper",
+  "hey google",
+  "hey siri",
+  "jarvis",
+  "ok google",
+  "picovoice",
+  "porcupine",
+  "terminator"
+];
+function isBlank(v) {
+  return typeof v !== "string" || v.trim() === "";
+}
+function clampSensitivity(v) {
+  const n = typeof v === "number" ? v : Number(v);
+  const base = Number.isFinite(n) ? n : 0.5;
+  return Math.min(1, Math.max(0, base));
+}
+function coerceToInt16Array(input) {
+  if (input instanceof Int16Array) return input;
+  if (input == null) return null;
+  if (typeof input === "number" || typeof input === "string" || typeof input === "boolean") {
+    return null;
+  }
+  try {
+    if (input instanceof ArrayBuffer) {
+      return new Int16Array(input);
+    }
+    if (ArrayBuffer.isView(input)) {
+      const view = input;
+      return new Int16Array(view.buffer, view.byteOffset, view.byteLength / 2);
+    }
+    return new Int16Array(input);
+  } catch {
+    return null;
+  }
+}
+async function createWakeDetector(options, deps) {
+  const accessKey = options?.accessKey;
+  if (isBlank(accessKey)) {
+    throw new WakeConfigError(
+      "no-key",
+      "Missing Picovoice access key: set picovoiceKey in ~/.config/lacode/voice.json or PICOVOICE_ACCESS_KEY."
+    );
+  }
+  const keywordPath = options?.keywordPath;
+  if (isBlank(keywordPath)) {
+    throw new WakeConfigError(
+      "no-model",
+      "Missing wake word model: download a .ppn model and set wakeWordPath."
+    );
+  }
+  const trimmed = String(keywordPath).trim();
+  const lower = trimmed.toLowerCase();
+  let resolvedPath = "";
+  let isBuiltin = false;
+  if (BUILTIN_NAMES.includes(lower)) {
+    isBuiltin = true;
+  }
+  const exists = deps?.exists ?? ((p) => {
+    try {
+      return existsSync2(p);
+    } catch {
+      return false;
+    }
+  });
+  if (isBuiltin) {
+  } else {
+    resolvedPath = trimmed;
+    if (!exists(resolvedPath)) {
+      throw new WakeConfigError(
+        "no-model",
+        `Wake word model not found at resolved path: ${resolvedPath}`
+      );
+    }
+  }
+  const load = deps?.load ?? (() => import("@picovoice/porcupine-node"));
+  let mod;
+  try {
+    mod = await load();
+  } catch (err) {
+    throw new WakeConfigError(
+      "no-package",
+      "Missing @picovoice/porcupine-node: run `npm i @picovoice/porcupine-node`."
+    );
+  }
+  const ns = mod?.default && mod?.Porcupine == null ? mod.default : mod;
+  const PorcupineCtor = ns?.Porcupine ?? mod?.Porcupine;
+  const getBuiltinKeywordPath = ns?.getBuiltinKeywordPath ?? mod?.getBuiltinKeywordPath;
+  if (isBuiltin) {
+    if (typeof getBuiltinKeywordPath !== "function") {
+      throw new WakeConfigError("init-failed", "getBuiltinKeywordPath unavailable");
+    }
+    resolvedPath = getBuiltinKeywordPath(lower);
+  }
+  if (typeof PorcupineCtor !== "function") {
+    throw new WakeConfigError("init-failed", "Porcupine constructor unavailable");
+  }
+  const sensitivity = clampSensitivity(options?.sensitivity);
+  let instance;
+  try {
+    instance = new PorcupineCtor(accessKey, [resolvedPath], [sensitivity]);
+  } catch (err) {
+    const msg = err?.message != null ? String(err.message) : String(err);
+    throw new WakeConfigError("init-failed", `Failed to initialize wake detector: ${msg}`);
+  }
+  let released = false;
+  const detector = {
+    get frameLength() {
+      return instance.frameLength;
+    },
+    process(frame) {
+      const coerced = coerceToInt16Array(frame);
+      if (coerced == null) return false;
+      if (coerced.length !== instance.frameLength) return false;
+      try {
+        return instance.process(coerced) >= 0;
+      } catch {
+        return false;
+      }
+    },
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        instance.release();
+      } catch {
+      }
+    }
+  };
+  return detector;
+}
+
+// src/voice/wake-vosk.ts
+import { existsSync as existsSync3 } from "node:fs";
+var DEFAULT_PHRASES = ["hey la code"];
+var DEFAULT_SAMPLE_RATE = 16e3;
+var FRAME_LENGTH = 512;
+var COOLDOWN_SAMPLES = 16e3;
+function normalizeWakeText(text) {
+  if (typeof text !== "string") return "";
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+function matchesWakePhrase(text, phrases) {
+  const haystack = ` ${normalizeWakeText(text)} `;
+  if (haystack.trim() === "") return false;
+  for (const phrase of phrases ?? []) {
+    const needle = normalizeWakeText(phrase);
+    if (needle !== "" && haystack.includes(` ${needle} `)) return true;
+  }
+  return false;
+}
+var readResultField = (value, field) => {
+  if (!value) return "";
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" ? String(parsed[field] ?? "") : "";
+    } catch {
+      return "";
+    }
+  }
+  if (typeof value === "object") return String(value[field] ?? "");
+  return "";
+};
+function safeCall(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(err) {
+  return err != null && typeof err === "object" && "message" in err ? String(err.message) : String(err);
+}
+async function createVoskWakeDetector(options, deps) {
+  const rawPath = options?.modelPath;
+  if (typeof rawPath !== "string" || rawPath.trim() === "") {
+    throw new WakeConfigError(
+      "no-model",
+      "Missing Vosk model: set voskModelPath in ~/.config/lacode/voice.json."
+    );
+  }
+  const modelPath = rawPath.trim();
+  const exists = deps?.exists ?? ((p) => {
+    try {
+      return existsSync3(p);
+    } catch {
+      return false;
+    }
+  });
+  if (!exists(modelPath)) {
+    throw new WakeConfigError("no-model", `Vosk model not found at resolved path: ${modelPath}`);
+  }
+  const phrases = Array.isArray(options?.phrases) ? options.phrases : DEFAULT_PHRASES;
+  const sampleRate = typeof options?.sampleRate === "number" && Number.isFinite(options.sampleRate) && options.sampleRate > 0 ? options.sampleRate : DEFAULT_SAMPLE_RATE;
+  const load = deps?.load ?? (() => import("vosk"));
+  let mod;
+  try {
+    mod = await load();
+  } catch {
+    throw new WakeConfigError("no-package", "Missing vosk: run `npm i vosk`.");
+  }
+  const ns = mod?.default && mod?.Model == null ? mod.default : mod;
+  const ModelCtor = ns?.Model ?? mod?.Model;
+  const RecognizerCtor = ns?.Recognizer ?? mod?.Recognizer;
+  if (typeof ModelCtor !== "function" || typeof RecognizerCtor !== "function") {
+    throw new WakeConfigError("init-failed", "Vosk Model/Recognizer constructor unavailable");
+  }
+  let model;
+  let recognizer;
+  try {
+    model = new ModelCtor(modelPath);
+    recognizer = new RecognizerCtor({ model, sampleRate, grammar: phrases });
+  } catch (err) {
+    try {
+      recognizer?.free?.();
+    } catch {
+    }
+    try {
+      model?.free?.();
+    } catch {
+    }
+    throw new WakeConfigError(
+      "init-failed",
+      `Failed to initialize Vosk wake detector: ${errorMessage(err)}`
+    );
+  }
+  let released = false;
+  let cooldown = 0;
+  const resetRecognizer = () => {
+    try {
+      if (typeof recognizer?.reset === "function") {
+        recognizer.reset();
+        return;
+      }
+      recognizer = new RecognizerCtor({ model, sampleRate, grammar: phrases });
+    } catch {
+    }
+  };
+  const detector = {
+    frameLength: FRAME_LENGTH,
+    process(frame) {
+      const length = frame != null && typeof frame.length === "number" ? frame.length : NaN;
+      if (cooldown > 0) {
+        const dec = typeof length === "number" && Number.isFinite(length) && length > 0 ? length : FRAME_LENGTH;
+        cooldown = Math.max(0, cooldown - dec);
+        return false;
+      }
+      if (!(frame instanceof Int16Array) || frame.length !== FRAME_LENGTH) return false;
+      let isFinal = false;
+      try {
+        const buffer = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
+        isFinal = Boolean(recognizer.acceptWaveform(buffer));
+      } catch {
+        return false;
+      }
+      const partialText = normalizeWakeText(
+        readResultField(safeCall(() => recognizer.partialResult()), "partial")
+      );
+      const finalText = isFinal ? normalizeWakeText(readResultField(safeCall(() => recognizer.result()), "text")) : "";
+      if (matchesWakePhrase(partialText, phrases) || matchesWakePhrase(finalText, phrases)) {
+        resetRecognizer();
+        cooldown = COOLDOWN_SAMPLES;
+        return true;
+      }
+      return false;
+    },
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        recognizer?.free?.();
+      } catch {
+      }
+      try {
+        model?.free?.();
+      } catch {
+      }
+    }
+  };
+  return detector;
+}
+
+// src/voice/wav.ts
+var DEFAULT_SAMPLE_RATE2 = 16e3;
+var DEFAULT_CHANNELS = 1;
+var MIN_SAMPLE_RATE = 8e3;
+var MAX_SAMPLE_RATE = 48e3;
+var MIN_CHANNELS = 1;
+var MAX_CHANNELS = 2;
+function normalizeFormat(format) {
+  let sampleRate = format?.sampleRate;
+  if (typeof sampleRate !== "number" || !Number.isFinite(sampleRate) || sampleRate < 0) {
+    sampleRate = DEFAULT_SAMPLE_RATE2;
+  }
+  if (sampleRate < MIN_SAMPLE_RATE || sampleRate > MAX_SAMPLE_RATE) {
+    sampleRate = DEFAULT_SAMPLE_RATE2;
+  }
+  let channels = format?.channels;
+  if (typeof channels !== "number" || !Number.isFinite(channels) || channels < 0) {
+    channels = DEFAULT_CHANNELS;
+  }
+  if (channels < MIN_CHANNELS || channels > MAX_CHANNELS) {
+    channels = DEFAULT_CHANNELS;
+  }
+  channels = Math.trunc(channels);
+  if (channels < MIN_CHANNELS || channels > MAX_CHANNELS) channels = DEFAULT_CHANNELS;
+  sampleRate = Math.trunc(sampleRate);
+  return { sampleRate, channels };
+}
+function encodeWav(pcm, format) {
+  const { sampleRate, channels } = normalizeFormat(format);
+  const dataSize = pcm.length * 2;
+  const total = 44 + dataSize;
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  out[0] = 82;
+  out[1] = 73;
+  out[2] = 70;
+  out[3] = 70;
+  view.setUint32(4, 36 + dataSize, true);
+  out[8] = 87;
+  out[9] = 65;
+  out[10] = 86;
+  out[11] = 69;
+  out[12] = 102;
+  out[13] = 109;
+  out[14] = 116;
+  out[15] = 32;
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * channels * 2, true);
+  view.setUint16(32, channels * 2, true);
+  view.setUint16(34, 16, true);
+  out[36] = 100;
+  out[37] = 97;
+  out[38] = 116;
+  out[39] = 97;
+  view.setUint32(40, dataSize, true);
+  let off = 44;
+  for (let i = 0; i < pcm.length; i++) {
+    view.setInt16(off, pcm[i], true);
+    off += 2;
+  }
+  return out;
+}
+
+// src/voice/audio.ts
+function pcmStats(pcm, sampleRate = 16e3) {
+  const samples = pcm ? pcm.length : 0;
+  let sumSq = 0;
+  let peak = 0;
+  if (pcm) {
+    for (let i = 0; i < pcm.length; i++) {
+      const v = pcm[i];
+      sumSq += v * v;
+      const a = v < 0 ? -v : v;
+      if (a > peak) peak = a;
+    }
+  }
+  const rms = samples === 0 ? 0 : Math.sqrt(sumSq / samples);
+  const durationMs = sampleRate > 0 ? samples / sampleRate * 1e3 : 0;
+  return { samples, durationMs, rms, peak };
+}
+function hasSpeech(pcm, options) {
+  const sampleRate = options?.sampleRate ?? 16e3;
+  const minDurationMs = options?.minDurationMs ?? 250;
+  const minRms = options?.minRms ?? 400;
+  const minPeak = options?.minPeak ?? 1500;
+  const stats = pcmStats(pcm, sampleRate);
+  return stats.durationMs >= minDurationMs && stats.rms >= minRms && stats.peak >= minPeak;
+}
+var SILENCE_HALLUCINATIONS = /* @__PURE__ */ new Set([
+  "thank you",
+  "thanks",
+  "thanks for watching",
+  "thank you for watching",
+  "thank you for watching!",
+  "you",
+  "bye",
+  "bye bye",
+  "please subscribe",
+  "subscribe",
+  "amara.org",
+  "subtitles by",
+  "the end",
+  "okay",
+  "ok"
+]);
+function isSilenceHallucination(text, durationMs) {
+  const normalised = String(text).toLowerCase().replace(/[^a-z0-9.\s]/g, "").replace(/\s+/g, " ").trim().replace(/\.$/, "");
+  return durationMs < 3e3 && SILENCE_HALLUCINATIONS.has(normalised);
+}
+
+// src/voice/transport.ts
+import * as nodeNet from "node:net";
+
+// src/voice/protocol.ts
+var VOICE_PROTOCOL_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toText(line) {
+  return typeof line === "string" ? line : line.toString("utf8");
+}
+function normalizeLine(line) {
+  let s = toText(line);
+  if (s.endsWith("\n")) s = s.slice(0, -1);
+  if (s.endsWith("\r")) s = s.slice(0, -1);
+  return s;
+}
+function encodeMessage(message) {
+  return JSON.stringify(message) + "\n";
+}
+function decodeClientMessage(line) {
+  const text = normalizeLine(line);
+  if (text.trim() === "") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const t = parsed.t;
+  switch (t) {
+    case "hello": {
+      if (typeof parsed.v !== "number") return void 0;
+      if (parsed.client !== void 0 && typeof parsed.client !== "string") return void 0;
+      return { t: "hello", v: parsed.v, client: parsed.client };
+    }
+    case "ping":
+      return { t: "ping" };
+    case "toggle":
+      return { t: "toggle" };
+    case "arm":
+      return { t: "arm" };
+    case "disarm":
+      return { t: "disarm" };
+    case "claim":
+      return { t: "claim" };
+    default:
+      return void 0;
+  }
+}
+function decodeDaemonMessage(line) {
+  const text = normalizeLine(line);
+  if (text.trim() === "") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const t = parsed.t;
+  switch (t) {
+    case "welcome": {
+      if (typeof parsed.v !== "number") return void 0;
+      if (typeof parsed.armed !== "boolean") return void 0;
+      if (typeof parsed.wake !== "boolean") return void 0;
+      return { t: "welcome", v: parsed.v, armed: parsed.armed, wake: parsed.wake };
+    }
+    case "state": {
+      if (typeof parsed.armed !== "boolean") return void 0;
+      if (parsed.phase !== "idle" && parsed.phase !== "recording" && parsed.phase !== "transcribing") return void 0;
+      return { t: "state", armed: parsed.armed, phase: parsed.phase };
+    }
+    case "transcript": {
+      if (typeof parsed.text !== "string") return void 0;
+      if (parsed.source !== "wake" && parsed.source !== "manual") return void 0;
+      return { t: "transcript", text: parsed.text, source: parsed.source };
+    }
+    case "error": {
+      if (typeof parsed.message !== "string") return void 0;
+      return { t: "error", message: parsed.message };
+    }
+    case "pong":
+      return { t: "pong" };
+    default:
+      return void 0;
+  }
+}
+function createLineDecoder(decode) {
+  const MAX_LINE = 64 * 1024;
+  let buffer = "";
+  return (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    buffer += text;
+    const out = [];
+    while (true) {
+      const idx = buffer.indexOf("\n");
+      if (idx === -1) break;
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.length > MAX_LINE) {
+        buffer = "";
+        break;
+      }
+      const msg = decode(line);
+      if (msg !== void 0) out.push(msg);
+    }
+    if (buffer.length > MAX_LINE) {
+      buffer = "";
+    }
+    return out;
+  };
+}
+
+// src/voice/transport.ts
+function createVoiceServer(options, deps) {
+  const portOpt = options.port ?? 0;
+  const host = options.host ?? "127.0.0.1";
+  const onMessage = options.onMessage;
+  const onClientCount = options.onClientCount;
+  const onClientClosed = options.onClientClosed;
+  const onClientOpened = options.onClientOpened;
+  const netMod = deps && deps.net ? deps.net : nodeNet;
+  const clients = /* @__PURE__ */ new Map();
+  let nextClientId = 1;
+  let server;
+  let boundPort;
+  let started = false;
+  let stopped = false;
+  const closeClient = (client) => {
+    if (client.closed) return;
+    client.closed = true;
+    if (clients.delete(client.id)) {
+      try {
+        onClientCount?.(clients.size);
+      } catch {
+      }
+    }
+    try {
+      onClientClosed?.(client.id);
+    } catch {
+    }
+  };
+  const broadcast = (message) => {
+    try {
+      const data = encodeMessage(message);
+      for (const client of [...clients.values()]) {
+        try {
+          const sock = client.socket;
+          if (sock && !sock.destroyed && sock.writable) {
+            sock.write(data);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  };
+  const sendTo = (id, message) => {
+    try {
+      const client = clients.get(id);
+      if (!client || client.closed) return false;
+      const sock = client.socket;
+      if (!sock || sock.destroyed || !sock.writable) return false;
+      sock.write(encodeMessage(message));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const voiceServer = {
+    get clientCount() {
+      return clients.size;
+    },
+    get port() {
+      return boundPort;
+    },
+    start() {
+      if (started) {
+        return Promise.resolve(boundPort !== void 0 ? boundPort : portOpt);
+      }
+      started = true;
+      return new Promise((resolve, reject) => {
+        let srv;
+        try {
+          srv = netMod.createServer((sock) => {
+            const client = {
+              id: nextClientId++,
+              remote: sock.remoteAddress ?? "",
+              socket: sock,
+              closed: false
+            };
+            clients.set(client.id, client);
+            try {
+              onClientCount?.(clients.size);
+            } catch {
+            }
+            try {
+              onClientOpened?.(client.id);
+            } catch {
+            }
+            const decoder = createLineDecoder(decodeClientMessage);
+            sock.on("data", (chunk) => {
+              try {
+                const msgs = decoder(chunk);
+                for (const m of msgs) {
+                  try {
+                    onMessage?.(m, { id: client.id, remote: client.remote });
+                  } catch {
+                  }
+                }
+              } catch {
+              }
+            });
+            sock.on("close", () => {
+              closeClient(client);
+            });
+            sock.on("error", () => {
+              try {
+                sock.destroy();
+              } catch {
+              }
+              closeClient(client);
+            });
+          });
+        } catch (err) {
+          reject(err);
+          return;
+        }
+        server = srv;
+        srv.once("error", (err) => {
+          reject(err);
+        });
+        try {
+          srv.listen(portOpt, host, () => {
+            const addr = srv.address();
+            if (addr && typeof addr === "object") {
+              boundPort = addr.port;
+            } else {
+              boundPort = portOpt;
+            }
+            resolve(boundPort);
+          });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      for (const client of [...clients.values()]) {
+        try {
+          client.socket.destroy();
+        } catch {
+        }
+      }
+      clients.clear();
+      const srv = server;
+      server = void 0;
+      if (srv) {
+        await new Promise((resolve) => {
+          let done = false;
+          const finish = () => {
+            if (done) return;
+            done = true;
+            resolve();
+          };
+          try {
+            srv.close(() => finish());
+          } catch {
+            finish();
+            return;
+          }
+          setTimeout(finish, 1e3).unref?.();
+        });
+      }
+      boundPort = void 0;
+      try {
+        onClientCount?.(0);
+      } catch {
+      }
+    },
+    broadcast,
+    sendTo
+  };
+  return voiceServer;
+}
+function createVoiceClient(options, deps) {
+  const port = options.port ?? 8765;
+  const host = options.host ?? "127.0.0.1";
+  const onMessage = options.onMessage;
+  const onConnectionChange = options.onConnectionChange;
+  const reconnectMs = options.reconnectMs ?? 2e3;
+  const netMod = deps && deps.net ? deps.net : nodeNet;
+  let socket;
+  let connected = false;
+  let stopped = false;
+  let timer;
+  let decoder = createLineDecoder(decodeDaemonMessage);
+  const setConnected = (value) => {
+    if (connected === value) return;
+    connected = value;
+    try {
+      onConnectionChange?.(value);
+    } catch {
+    }
+  };
+  const scheduleReconnect = () => {
+    if (stopped) return;
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      connect();
+    }, reconnectMs);
+    try {
+      timer.unref?.();
+    } catch {
+    }
+  };
+  const connect = () => {
+    if (stopped) return;
+    if (socket && !socket.destroyed) return;
+    decoder = createLineDecoder(decodeDaemonMessage);
+    let sock;
+    try {
+      sock = netMod.createConnection({ port, host });
+    } catch {
+      socket = void 0;
+      scheduleReconnect();
+      return;
+    }
+    socket = sock;
+    sock.on("connect", () => {
+      setConnected(true);
+    });
+    sock.on("data", (chunk) => {
+      try {
+        const msgs = decoder(chunk);
+        for (const m of msgs) {
+          try {
+            onMessage?.(m);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    });
+    sock.on("close", () => {
+      socket = void 0;
+      setConnected(false);
+      scheduleReconnect();
+    });
+    sock.on("error", () => {
+      setConnected(false);
+      try {
+        sock.destroy();
+      } catch {
+      }
+      socket = void 0;
+      scheduleReconnect();
+    });
+  };
+  const client = {
+    get connected() {
+      return connected;
+    },
+    start() {
+      stopped = false;
+      connect();
+    },
+    stop() {
+      if (stopped && !socket && !timer) {
+      }
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      if (socket) {
+        try {
+          socket.destroy();
+        } catch {
+        }
+        socket = void 0;
+      }
+      setConnected(false);
+    },
+    send(message) {
+      try {
+        if (stopped) return false;
+        if (!socket || socket.destroyed || !socket.writable) return false;
+        if (!connected) return false;
+        socket.write(encodeMessage(message));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+  return client;
+}
+
+// src/voice/parse.ts
+var cleanTranscript = (text) => /[a-z0-9]/i.test(text) ? text.trim() : "";
+
+// src/voice/daemon.ts
+function createVoiceDaemon(deps) {
+  const log = deps?.log ?? ((_level, _message) => {
+  });
+  const state = {
+    armed: false,
+    phase: "idle",
+    wake: false,
+    port: void 0,
+    clients: 0
+  };
+  let config;
+  let server;
+  let capture;
+  let vad;
+  let wakeDetector;
+  let splitter;
+  let frameLength = 512;
+  let source;
+  let utteranceFrames = [];
+  let manualSamples = 0;
+  let stopped = false;
+  let inFlight;
+  let captureCheckTimer;
+  const concatFrames2 = (frames) => {
+    let total = 0;
+    for (const f of frames) total += f.length;
+    const out = new Int16Array(total);
+    let off = 0;
+    for (const f of frames) {
+      out.set(f, off);
+      off += f.length;
+    }
+    return out;
+  };
+  const broadcast = (msg) => {
+    if (stopped) return;
+    try {
+      server?.broadcast(msg);
+    } catch {
+    }
+  };
+  const broadcastState = () => {
+    broadcast({ t: "state", armed: state.armed, phase: state.phase });
+  };
+  const beginRecording = (src) => {
+    state.phase = "recording";
+    source = src;
+    utteranceFrames = [];
+    manualSamples = 0;
+    try {
+      vad?.reset();
+    } catch {
+    }
+    broadcastState();
+  };
+  const finish = async (audio, src) => {
+    if (state.phase === "transcribing" || stopped) return;
+    if (audio.length === 0) {
+      state.phase = "idle";
+      source = void 0;
+      try {
+        vad?.reset();
+      } catch {
+      }
+      broadcastState();
+      broadcast({ t: "error", message: "No audio captured" });
+      inFlight = void 0;
+      return;
+    }
+    if (!hasSpeech(audio, { sampleRate: config.sampleRate })) {
+      state.phase = "idle";
+      source = void 0;
+      try {
+        vad?.reset();
+      } catch {
+      }
+      broadcastState();
+      broadcast({ t: "error", message: "No speech detected" });
+      inFlight = void 0;
+      return;
+    }
+    state.phase = "transcribing";
+    source = void 0;
+    broadcastState();
+    const run = async () => {
+      try {
+        if (!config.groqKey) {
+          broadcast({ t: "error", message: "Groq key is not configured" });
+        } else {
+          const transcribeFn = deps?.transcribe ?? transcribe;
+          const wav = encodeWav(audio, { sampleRate: config.sampleRate });
+          const text = cleanTranscript(
+            await transcribeFn({
+              audio: wav,
+              filename: "audio.wav",
+              key: config.groqKey ?? "",
+              model: config.model,
+              language: config.language
+            })
+          );
+          if (isSilenceHallucination(text, audio.length / config.sampleRate * 1e3)) {
+            broadcast({ t: "error", message: "No speech detected" });
+          } else if (text) {
+            broadcast({ t: "transcript", text, source: src });
+          }
+        }
+      } catch (err) {
+        const msg = err?.message != null ? String(err.message) : String(err);
+        broadcast({ t: "error", message: msg });
+      } finally {
+        state.phase = "idle";
+        try {
+          vad?.reset();
+        } catch {
+        }
+        broadcastState();
+        inFlight = void 0;
+      }
+    };
+    inFlight = run();
+    try {
+      await inFlight;
+    } catch {
+    }
+  };
+  const handleClientMessage = (msg) => {
+    if (stopped) return;
+    if (!msg || typeof msg !== "object") return;
+    switch (msg.t) {
+      case "hello":
+        broadcast({ t: "welcome", v: VOICE_PROTOCOL_VERSION, armed: state.armed, wake: state.wake });
+        break;
+      case "ping":
+        broadcast({ t: "pong" });
+        break;
+      case "arm":
+        state.armed = true;
+        broadcastState();
+        break;
+      case "disarm":
+        state.armed = false;
+        if (state.phase === "recording") {
+          try {
+            vad?.reset();
+          } catch {
+          }
+          state.phase = "idle";
+          source = void 0;
+          utteranceFrames = [];
+          manualSamples = 0;
+        }
+        broadcastState();
+        break;
+      case "toggle":
+        if (state.phase === "idle") {
+          beginRecording("manual");
+        } else if (state.phase === "recording" && source === "manual") {
+          const audio = concatFrames2(utteranceFrames);
+          if (audio.length === 0) {
+            state.phase = "idle";
+            source = void 0;
+            try {
+              vad?.reset();
+            } catch {
+            }
+            broadcastState();
+            broadcast({ t: "error", message: "No audio captured" });
+          } else {
+            void finish(audio, "manual");
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  };
+  const onFrame = (frame) => {
+    if (stopped) return;
+    if (state.phase === "recording") {
+      if (source === "manual") {
+        const sr = config?.sampleRate ?? 16e3;
+        const limit = 120 * sr;
+        if (manualSamples < limit) {
+          utteranceFrames.push(new Int16Array(frame));
+          manualSamples += frame.length;
+        }
+      } else if (source === "wake") {
+        const events = vad ? vad.push(frame) : [];
+        for (const ev of events) {
+          if (ev.t === "utterance") {
+            void finish(ev.audio, "wake");
+          }
+          if (state.phase !== "recording") break;
+        }
+      }
+    } else if (state.phase === "idle" && state.armed && state.wake && wakeDetector) {
+      try {
+        if (wakeDetector.process(frame)) {
+          beginRecording("wake");
+        }
+      } catch {
+      }
+    }
+  };
+  const daemon = {
+    state,
+    async start() {
+      config = deps?.config ?? resolveVoiceConfig();
+      const createServerFn = deps?.createServer ?? createVoiceServer;
+      server = createServerFn({
+        port: config.port,
+        host: config.host,
+        onMessage: (m) => handleClientMessage(m),
+        onClientCount: (c) => {
+          state.clients = c;
+          broadcastState();
+        }
+      });
+      const resolvedPort = await server.start();
+      state.port = resolvedPort;
+      let wakeError;
+      try {
+        if (deps?.createWakeDetector) {
+          wakeDetector = await deps.createWakeDetector({
+            accessKey: config.picovoiceKey ?? "",
+            keywordPath: config.wakeWordPath ?? "",
+            sensitivity: config.wakeSensitivity
+          });
+        } else if (config.wakeEngine === "porcupine") {
+          wakeDetector = await createWakeDetector({
+            accessKey: config.picovoiceKey ?? "",
+            keywordPath: config.wakeWordPath ?? "",
+            sensitivity: config.wakeSensitivity
+          });
+        } else {
+          wakeDetector = await createVoskWakeDetector({
+            modelPath: config.voskModelPath,
+            phrases: config.wakePhrases,
+            sampleRate: config.sampleRate
+          });
+        }
+        state.wake = true;
+      } catch (err) {
+        state.wake = false;
+        wakeError = err?.message != null ? String(err.message) : String(err);
+        log("warn", wakeError);
+      }
+      const createVadFn = deps?.createVad ?? createVad;
+      vad = createVadFn({ sampleRate: config.sampleRate });
+      state.armed = Boolean(config.armOnStart && state.wake);
+      frameLength = wakeDetector?.frameLength ?? 512;
+      splitter = createFrameSplitter(frameLength, (frame) => onFrame(frame));
+      const createCaptureFn = deps?.createCapture ?? createCapture;
+      capture = createCaptureFn((chunk) => {
+        try {
+          splitter?.(chunk);
+        } catch {
+        }
+      });
+      try {
+        capture.start();
+      } catch {
+      }
+      try {
+        const cap = capture;
+        const notRunning = !cap || !cap.running || cap.plan === void 0;
+        if (notRunning) {
+          const detail = !cap || !cap.running ? "not running" : cap.plan === void 0 ? "plan undefined" : cap.plan;
+          const detailStr = typeof detail === "string" ? detail : JSON.stringify(detail);
+          const message = `microphone capture is not running: ${detailStr}`;
+          log("error", message);
+          broadcast({ t: "error", message: "microphone capture is not running" });
+        }
+      } catch {
+      }
+      try {
+        captureCheckTimer = setTimeout(() => {
+          if (stopped) return;
+          try {
+            if (!capture?.running) {
+              const message = "Microphone capture stopped unexpectedly";
+              log("error", message);
+              broadcast({ t: "error", message });
+            }
+          } catch {
+          }
+        }, 750);
+        captureCheckTimer?.unref?.();
+      } catch {
+      }
+      return { port: state.port, wake: state.wake, wakeError };
+    },
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      if (captureCheckTimer) {
+        try {
+          clearTimeout(captureCheckTimer);
+        } catch {
+        }
+        captureCheckTimer = void 0;
+      }
+      try {
+        capture?.stop();
+      } catch {
+      }
+      try {
+        wakeDetector?.release();
+      } catch {
+      }
+      try {
+        vad?.reset();
+      } catch {
+      }
+      if (inFlight) {
+        try {
+          await Promise.race([inFlight, new Promise((r) => setTimeout(r, 5e3))]);
+        } catch {
+        }
+        inFlight = void 0;
+      }
+      try {
+        await server?.stop();
+      } catch {
+      }
+    }
+  };
+  return daemon;
+}
+
+// bin/lacode-voice
+var require2 = createRequire(import.meta.url);
+if (!process.features?.typescript) {
+  if (process.env.LACODE_STRIP_TYPECHECKED === "1") {
+    console.error("lacode-voice: this node cannot load TypeScript sources; node >= 22.18 is required.");
+    process.exit(1);
+  }
+  const { spawnSync } = await import("node:child_process");
+  const result = spawnSync(
+    process.execPath,
+    ["--experimental-strip-types", "--no-warnings", fileURLToPath(import.meta.url), ...process.argv.slice(2)],
+    { stdio: "inherit", env: { ...process.env, LACODE_STRIP_TYPECHECKED: "1" } }
+  );
+  process.exit(result.status ?? 1);
+}
+var USAGE = `lacode-voice \u2014 CLI for the LaCode voice daemon
+
+  lacode-voice [start]
+      Resolve config, start the voice daemon, and keep running.
+
+  lacode-voice doctor
+      Print a diagnostic checklist. Does not start audio capture.
+
+  lacode-voice model [--force] | fetch-model [--force]
+      Download the Vosk wake-word model into the voice data directory.
+      --force re-downloads and re-extracts an existing model.
+
+  lacode-voice status
+      Query a running daemon (ping + hello) and print its state.
+
+  lacode-voice --help | -h
+      Print this help.`;
+function expandHome2(value, home) {
+  const v = value.trim();
+  if (v === "~") return home;
+  if (v.startsWith("~/")) return join4(home, v.slice(2));
+  return v;
+}
+function isBuiltinWakeWord(value) {
+  const builtins = [
+    "alexa",
+    "americano",
+    "blueberry",
+    "bumblebee",
+    "computer",
+    "grapefruit",
+    "grasshopper",
+    "hey google",
+    "hey siri",
+    "jarvis",
+    "ok google",
+    "picovoice",
+    "porcupine",
+    "terminator"
+  ];
+  return builtins.includes(value.trim().toLowerCase());
+}
+function porcupineInfo() {
+  try {
+    const resolved = require2.resolve("@picovoice/porcupine-node");
+    let dir = dirname(resolved);
+    for (let i = 0; i < 8; i++) {
+      try {
+        const pkg = JSON.parse(readFileSync3(join4(dir, "package.json"), "utf8"));
+        if (pkg && pkg.name === "@picovoice/porcupine-node" && typeof pkg.version === "string") {
+          return { installed: true, version: pkg.version };
+        }
+      } catch {
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    try {
+      const pkg = require2("@picovoice/porcupine-node/package.json");
+      if (pkg && typeof pkg.version === "string") return { installed: true, version: pkg.version };
+    } catch {
+    }
+    return { installed: true, version: "unknown" };
+  } catch {
+    return { installed: false, version: "not installed" };
+  }
+}
+function voskInfo() {
+  try {
+    const resolved = require2.resolve("vosk");
+    let dir = dirname(resolved);
+    for (let i = 0; i < 8; i++) {
+      try {
+        const pkg = JSON.parse(readFileSync3(join4(dir, "package.json"), "utf8"));
+        if (pkg && pkg.name === "vosk" && typeof pkg.version === "string") {
+          return { installed: true, version: pkg.version };
+        }
+      } catch {
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return { installed: true, version: "unknown" };
+  } catch {
+    return { installed: false, version: "not installed" };
+  }
+}
+function runUnzip(zip, dest) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("unzip", ["-q", "-o", zip, "-d", dest], { stdio: "inherit" });
+    child.once("error", reject);
+    child.once("close", (code) => resolve(code));
+  });
+}
+function canBind(port, host) {
+  return new Promise((resolve) => {
+    let server;
+    try {
+      server = net.createServer();
+    } catch {
+      resolve(false);
+      return;
+    }
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      try {
+        server.close();
+      } catch {
+      }
+      resolve(value);
+    };
+    server.once("error", () => finish(false));
+    try {
+      server.listen(port, host, () => finish(true));
+    } catch {
+      finish(false);
+    }
+    setTimeout(() => finish(false), 1e3).unref?.();
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var rawArgv = process.argv.slice(2);
+var command;
+if (rawArgv.length > 0 && rawArgv[0].startsWith("-")) {
+  if (rawArgv[0] === "--help" || rawArgv[0] === "-h") {
+    command = rawArgv.shift();
+  } else {
+    const idx = rawArgv.findIndex((a) => !a.startsWith("-"));
+    if (idx >= 0) {
+      command = rawArgv.splice(idx, 1)[0];
+    } else {
+      command = rawArgv.shift();
+    }
+  }
+} else {
+  command = rawArgv.shift();
+}
+if (command === void 0) command = "start";
+switch (command) {
+  case "start": {
+    const config = resolveVoiceConfig();
+    const daemon = createVoiceDaemon({ config });
+    let shuttingDown = false;
+    const shutdown = async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      try {
+        await daemon.stop();
+      } catch {
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", () => {
+      void shutdown();
+    });
+    process.on("SIGTERM", () => {
+      void shutdown();
+    });
+    const result = await daemon.start();
+    const wake = result.wake ? "on" : "off";
+    console.log(`voice daemon listening on ${config.host}:${result.port} (wake: ${wake})`);
+    if (result.wakeError) {
+      console.log(`warning: wake word unavailable: ${result.wakeError}`);
+    }
+    break;
+  }
+  case "doctor": {
+    const config = resolveVoiceConfig();
+    const home = homedir3();
+    if (config.groqKey) {
+      console.log(`ok groq key: ${config.groqSource ?? "unknown"}`);
+    } else {
+      console.log("fail groq key: missing");
+    }
+    console.log(`wake engine: ${config.wakeEngine}`);
+    let engineUsable = false;
+    if (config.wakeEngine === "vosk") {
+      const modelPath = config.voskModelPath;
+      const modelDisplay = modelPath && modelPath.trim() !== "" ? modelPath : "(none)";
+      let modelExists = false;
+      if (modelPath && modelPath.trim() !== "") {
+        try {
+          modelExists = existsSync4(modelPath);
+        } catch {
+          modelExists = false;
+        }
+      }
+      if (modelExists) {
+        console.log(`ok vosk model: ${modelDisplay} (exists)`);
+      } else {
+        console.log(`fail vosk model: ${modelDisplay} (not found)`);
+        console.log('hint: run "lacode-voice model" to download it');
+      }
+      const vk = voskInfo();
+      if (vk.installed) {
+        console.log(`ok vosk module: ${vk.version}`);
+      } else {
+        console.log("fail vosk module: not installed");
+      }
+      engineUsable = modelExists && vk.installed;
+    } else {
+      if (config.picovoiceKey) {
+        console.log("ok picovoice key: present");
+      } else {
+        console.log("warn picovoice key: missing");
+      }
+      const ww = config.wakeWordPath;
+      const wwDisplay = ww ? ww : "(none)";
+      let wwExists = false;
+      let wwAvailable = false;
+      if (ww) {
+        if (isBuiltinWakeWord(ww)) {
+          wwExists = true;
+          wwAvailable = true;
+        } else {
+          const expanded = expandHome2(ww, home);
+          try {
+            wwExists = existsSync4(expanded);
+          } catch {
+            wwExists = false;
+          }
+          wwAvailable = wwExists;
+        }
+      }
+      const wwStatus = wwExists ? "exists" : "not found";
+      const pp = porcupineInfo();
+      const wakeAvailable = Boolean(config.picovoiceKey) && wwAvailable && pp.installed;
+      const wwPrefix = wakeAvailable ? "ok" : "fail";
+      console.log(`${wwPrefix} wake word: ${wwDisplay} (${wwStatus})`);
+      if (pp.installed) {
+        console.log(`ok porcupine module: ${pp.version}`);
+      } else {
+        console.log("warn porcupine module: not installed");
+      }
+      engineUsable = wakeAvailable;
+    }
+    const plan = planCapture();
+    if (plan) {
+      console.log(`ok capture: ${plan.bin} ${plan.args.join(" ")}`);
+    } else {
+      console.log("warn capture: no recorder found (install ffmpeg)");
+    }
+    const bindable = await canBind(config.port, config.host);
+    const portPrefix = bindable ? "ok" : "fail";
+    const portStatus = bindable ? "available" : "in use";
+    console.log(`${portPrefix} port: ${config.port} ${portStatus}`);
+    const groqMissing = !config.groqKey;
+    const exitCode = groqMissing || !engineUsable ? 1 : 0;
+    process.exit(exitCode);
+    break;
+  }
+  case "model":
+  case "fetch-model": {
+    const config = resolveVoiceConfig();
+    const modelPath = config.voskModelPath;
+    const force = rawArgv.includes("--force");
+    try {
+      if (!force && modelPath && modelPath.trim() !== "" && existsSync4(modelPath)) {
+        console.log(`vosk model already present: ${modelPath}`);
+        process.exit(0);
+      }
+      const dataDir = VOICE_DATA_DIR();
+      const zip = join4(dataDir, "vosk-model.zip");
+      mkdirSync(dataDir, { recursive: true });
+      const url = "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip";
+      console.log("downloading vosk model (41 MB)...");
+      const response = await fetch(url);
+      if (!response.ok || !response.body) {
+        throw new Error(`download failed: HTTP ${response.status} ${response.statusText}`);
+      }
+      let bytes = 0;
+      const counter = new Transform({
+        transform(chunk, _encoding, callback) {
+          bytes += chunk.length;
+          callback(null, chunk);
+        }
+      });
+      await pipeline(Readable.fromWeb(response.body), counter, createWriteStream(zip));
+      console.log(`downloaded ${(bytes / (1024 * 1024)).toFixed(1)} MB`);
+      const code = await runUnzip(zip, dataDir);
+      if (code !== 0) throw new Error(`unzip failed with exit code ${code}`);
+      if (!existsSync4(modelPath)) {
+        throw new Error(`vosk model not found after extraction: ${modelPath}`);
+      }
+      console.log(`vosk model ready: ${modelPath}`);
+      rmSync(zip, { force: true });
+      process.exit(0);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`lacode-voice: ${message}`);
+      process.exit(1);
+    }
+    break;
+  }
+  case "status": {
+    const config = resolveVoiceConfig();
+    let got = null;
+    const client = createVoiceClient({
+      host: config.host,
+      port: config.port,
+      reconnectMs: 5e3,
+      onMessage: (m) => {
+        if (!got && (m.t === "pong" || m.t === "welcome" || m.t === "state")) got = m;
+      }
+    });
+    client.start();
+    const deadline = Date.now() + 1500;
+    while (!client.connected && Date.now() < deadline) await delay(10);
+    if (client.connected) {
+      client.send({ t: "ping" });
+      client.send({ t: "hello", v: VOICE_PROTOCOL_VERSION, client: "lacode-voice" });
+    }
+    while (!got && Date.now() < deadline) await delay(10);
+    try {
+      client.stop();
+    } catch {
+    }
+    if (!got) {
+      console.log("daemon not running");
+      process.exit(1);
+    }
+    if (got.t === "state") {
+      console.log(`armed: ${got.armed} phase: ${got.phase}`);
+    } else if (got.t === "welcome") {
+      console.log(`armed: ${got.armed} wake: ${got.wake ? "on" : "off"}`);
+    } else {
+      console.log("daemon running");
+    }
+    process.exit(0);
+    break;
+  }
+  case "--help":
+  case "-h":
+  case "help":
+    console.log(USAGE);
+    process.exit(0);
+    break;
+  default:
+    console.error(`lacode-voice: unknown command ${JSON.stringify(command)}`);
+    console.error(USAGE);
+    process.exit(1);
+    break;
+}