@hxnnxs/opencode-voice 0.1.0

package/lib/download.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { getModelPath, getModelsDir, getModelVerificationPath } from "./models.js";
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function ensureDir(dir) {
+  await fs.promises.mkdir(dir, { recursive: true });
+}
+
+export async function sha256(file) {
+  const hash = createHash("sha256");
+  const input = fs.createReadStream(file);
+  for await (const chunk of input) hash.update(chunk);
+  return hash.digest("hex");
+}
+
+export async function verifyModel(model, file) {
+  if (!model.sha256) return true;
+  const actual = await sha256(file);
+  return actual === model.sha256;
+}
+
+export async function writeModelVerificationMarker(model, file, options = {}, settings = {}) {
+  if (!model.sha256) return;
+  const marker = getModelVerificationPath(model, options, settings);
+  await fs.promises.writeFile(marker, `${model.sha256}\n`);
+}
+
+async function fetchWithTimeout(url, init = {}, timeoutMs = 60000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (error) {
+    if (error?.name === "AbortError") throw new Error(`Download timed out after ${Math.round(timeoutMs / 1000)}s`);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function downloadModelOnce(model, options = {}, settings = {}, hooks = {}, attempt = 1, attempts = 1) {
+  if (!model?.implemented || !model.url || !model.filename) {
+    throw new Error(`${model?.name || "Model"} is not supported by the current local engine yet`);
+  }
+
+  const dir = getModelsDir(options, settings);
+  const file = getModelPath(model, options, settings);
+  const partial = `${file}.partial`;
+  await ensureDir(dir);
+
+  if (fs.existsSync(file)) {
+    hooks.onProgress?.({ state: "verifying", downloaded: fs.statSync(file).size, total: fs.statSync(file).size, percent: 100, attempt, attempts });
+    if (await verifyModel(model, file)) {
+      await writeModelVerificationMarker(model, file, options, settings);
+      return file;
+    }
+    await fs.promises.unlink(file);
+    await fs.promises.unlink(getModelVerificationPath(model, options, settings)).catch(() => {});
+  }
+
+  const partialSize = fs.existsSync(partial) ? fs.statSync(partial).size : 0;
+  const headers = partialSize > 0 ? { Range: `bytes=${partialSize}-` } : undefined;
+  const response = await fetchWithTimeout(model.url, { headers }, Number(options.downloadTimeoutMs || hooks.timeoutMs || 60000));
+
+  if (response.status === 416 && partialSize > 0) {
+    await fs.promises.unlink(partial).catch(() => {});
+    return downloadModelOnce(model, options, settings, hooks, attempt, attempts);
+  }
+
+  if (!response.ok && response.status !== 206) {
+    throw new Error(`Download failed: HTTP ${response.status}`);
+  }
+
+  const append = response.status === 206 && partialSize > 0;
+  const contentLength = Number(response.headers.get("content-length") || 0);
+  const total = contentLength > 0 ? contentLength + (append ? partialSize : 0) : model.sizeMB ? model.sizeMB * 1024 * 1024 : 0;
+  let downloaded = append ? partialSize : 0;
+
+  hooks.onProgress?.({ state: "downloading", downloaded, total, percent: total ? (downloaded / total) * 100 : 0, attempt, attempts });
+
+  const body = response.body?.getReader ? Readable.fromWeb(response.body) : response.body;
+  if (!body) throw new Error("Download failed: empty response body");
+
+  const progress = new Transform({
+    transform(chunk, _encoding, callback) {
+      downloaded += chunk.length ?? chunk.byteLength ?? 0;
+      hooks.onProgress?.({ state: "downloading", downloaded, total, percent: total ? (downloaded / total) * 100 : 0, attempt, attempts });
+      callback(null, chunk);
+    },
+  });
+
+  await pipeline(body, progress, fs.createWriteStream(partial, { flags: append ? "a" : "w" }));
+
+  hooks.onProgress?.({ state: "verifying", downloaded, total: total || downloaded, percent: 100, attempt, attempts });
+
+  if (!(await verifyModel(model, partial))) {
+    await fs.promises.unlink(partial).catch(() => {});
+    throw new Error(`SHA256 mismatch for ${model.name}`);
+  }
+
+  await fs.promises.rename(partial, file);
+  await writeModelVerificationMarker(model, file, options, settings);
+  hooks.onProgress?.({ state: "done", downloaded, total: total || downloaded, percent: 100, attempt, attempts });
+  return file;
+}
+
+export async function downloadModel(model, options = {}, settings = {}, hooks = {}) {
+  const attempts = Number(options.downloadRetries || hooks.retries || 3);
+  let lastError;
+
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await downloadModelOnce(model, options, settings, hooks, attempt, attempts);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= attempts) break;
+      hooks.onRetry?.({ error, attempt, attempts, nextAttempt: attempt + 1 });
+      await sleep(Math.min(1000 * attempt, 3000));
+    }
+  }
+
+  throw lastError;
+}

package/lib/engine.js

@@ -0,0 +1,406 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { ensureDir } from "./download.js";
+import { getAudioDir, getEnginesDir, getModelPath } from "./models.js";
+
+const RECORDING_MIN_BYTES = 44;
+
+function isExecutable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function executableNames(command) {
+  const names = [command];
+  if (path.extname(command)) return names;
+
+  if (process.platform === "win32") {
+    const extensions = (process.env.PATHEXT || ".EXE;.CMD;.BAT")
+      .split(";")
+      .map((item) => item.trim().toLowerCase())
+      .filter(Boolean);
+    for (const extension of extensions) names.push(`${command}${extension}`);
+  }
+
+  return [...new Set(names)];
+}
+
+function platformKey(options = {}) {
+  return `${options.platform || process.platform}-${options.arch || process.arch}`;
+}
+
+export function getBundledEngineDir(command, options = {}) {
+  if (command !== "whisper-cli") return "";
+  return path.join(getEnginesDir(options, options), "whisper.cpp", platformKey(options));
+}
+
+function looksLikePath(value) {
+  return path.isAbsolute(value) || value.includes("/") || value.includes("\\");
+}
+
+function candidateCommands(command, options = {}) {
+  const candidates = [];
+
+  if (command === "whisper-cli") {
+    if (options.whisperCli) candidates.push(options.whisperCli);
+    if (process.env.OPENCODE_VOICE_WHISPER_CLI) candidates.push(process.env.OPENCODE_VOICE_WHISPER_CLI);
+  }
+
+  const bundledDir = getBundledEngineDir(command, options);
+  if (bundledDir) {
+    for (const name of executableNames(command)) candidates.push(path.join(bundledDir, name));
+  }
+
+  candidates.push(...executableNames(command));
+
+  const fallbackDirs = [
+    path.join(os.homedir(), ".local", "bin"),
+    path.join(os.homedir(), ".opencode-voice", "bin"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+  ];
+
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    fallbackDirs.unshift(path.join(localAppData, "opencode-voice", "bin"));
+  }
+
+  for (const dir of fallbackDirs) {
+    for (const name of executableNames(command)) candidates.push(path.join(dir, name));
+  }
+
+  return [...new Set(candidates.filter(Boolean))];
+}
+
+export function resolveCommand(command, options = {}) {
+  for (const candidate of candidateCommands(command, options)) {
+    if (looksLikePath(candidate)) {
+      if (isExecutable(candidate)) return candidate;
+      continue;
+    }
+
+    for (const dir of (process.env.PATH || "").split(path.delimiter).filter(Boolean)) {
+      const file = path.join(dir, candidate);
+      if (isExecutable(file)) return file;
+    }
+  }
+
+  return null;
+}
+
+export function commandExists(command, options = {}) {
+  return Boolean(resolveCommand(command, options));
+}
+
+function childEnv(options = {}) {
+  const localLib = path.join(os.homedir(), ".local", "lib");
+  const localBin = path.join(os.homedir(), ".local", "bin");
+  const bundledDir = getBundledEngineDir("whisper-cli", options);
+  const pathEntries = [bundledDir, localBin, localLib, process.env.PATH].filter(Boolean);
+  return {
+    ...process.env,
+    PATH: pathEntries.join(path.delimiter),
+    LD_LIBRARY_PATH: [localLib, process.env.LD_LIBRARY_PATH].filter(Boolean).join(path.delimiter),
+    DYLD_LIBRARY_PATH: [localLib, process.env.DYLD_LIBRARY_PATH].filter(Boolean).join(path.delimiter),
+  };
+}
+
+export function listMicrophones() {
+  if (process.platform === "linux" && commandExists("arecord")) {
+    const result = spawnSync("arecord", ["-L"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const devices = result.stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#") && !line.includes(" ") && line !== "null");
+    return ["default", ...devices.filter((item) => item !== "default")];
+  }
+
+  if (process.platform === "darwin" && commandExists("ffmpeg")) {
+    const result = spawnSync("ffmpeg", ["-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""], {
+      encoding: "utf8",
+      stdio: ["ignore", "ignore", "pipe"],
+    });
+    return result.stderr
+      .split(/\r?\n/)
+      .map((line) => line.match(/\[(\d+)\]\s+(.+)$/)?.[1])
+      .filter(Boolean)
+      .map((id) => `:${id}`);
+  }
+
+  return ["default"];
+}
+
+function buildRecorders(file, settings = {}) {
+  const mic = settings.mic || "";
+  const recorders = [];
+
+  if (process.platform === "linux" && commandExists("arecord")) {
+    recorders.push({
+      label: mic ? `arecord (${mic})` : "arecord (default)",
+      command: "arecord",
+      args: ["-q", "-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "wav", ...(mic ? ["-D", mic] : []), file],
+    });
+  }
+
+  if (process.platform === "linux" && commandExists("ffmpeg")) {
+    if (!mic) {
+      recorders.push({
+        label: "ffmpeg pulse (default)",
+        command: "ffmpeg",
+        args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "pulse", "-i", "default", "-ac", "1", "-ar", "16000", file],
+      });
+    }
+
+    recorders.push({
+      label: `ffmpeg alsa (${mic || "default"})`,
+      command: "ffmpeg",
+      args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "alsa", "-i", mic || "default", "-ac", "1", "-ar", "16000", file],
+    });
+  }
+
+  if (process.platform === "darwin" && commandExists("ffmpeg")) {
+    recorders.push({
+      label: `ffmpeg avfoundation (${mic || ":0"})`,
+      command: "ffmpeg",
+      args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "avfoundation", "-i", mic || ":0", "-ac", "1", "-ar", "16000", file],
+    });
+  }
+
+  if (commandExists("sox")) {
+    recorders.push({
+      label: "sox default",
+      command: "sox",
+      args: ["-d", "-r", "16000", "-c", "1", "-b", "16", file],
+    });
+  }
+
+  if (!recorders.length) throw new Error("No recorder found. Install ffmpeg, arecord, or sox.");
+  return recorders;
+}
+
+function waitForExit(proc, timeoutMs = 3000) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      finish();
+    }, timeoutMs);
+
+    proc.once("exit", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    proc.once("error", () => {
+      clearTimeout(timer);
+      finish();
+    });
+  });
+}
+
+function cleanTranscription(text) {
+  return text
+    .replace(/\[[^\]]*\]/g, " ")
+    .replace(/\([^)]*\)/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function lastLine(value) {
+  return value.trim().split("\n").filter(Boolean).pop() || "";
+}
+
+function startRecorder(recorder, file) {
+  return new Promise((resolve, reject) => {
+    let stderr = "";
+    let exited = false;
+    let exitCode = null;
+
+    const proc = spawn(recorder.command, recorder.args, { stdio: ["ignore", "ignore", "pipe"] });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.once("error", (error) => {
+      exited = true;
+      reject(new Error(`${recorder.label}: ${error.message}`));
+    });
+    proc.once("exit", (code) => {
+      exited = true;
+      exitCode = code;
+    });
+
+    setTimeout(() => {
+      if (exited) {
+        reject(new Error(`${recorder.label}: ${lastLine(stderr) || `exited with code ${exitCode}`}`));
+        return;
+      }
+
+      if (!fs.existsSync(file)) {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+        reject(new Error(`${recorder.label}: did not create an audio file`));
+        return;
+      }
+
+      resolve({ proc, file, recorder, stderr: () => stderr });
+    }, 650);
+  });
+}
+
+export class VoiceRuntime {
+  constructor(options = {}) {
+    this.options = options;
+    this.recording = null;
+    this.recordingError = "";
+    this.transcription = null;
+    this.pendingSubmit = false;
+  }
+
+  isRecording() {
+    return Boolean(this.recording);
+  }
+
+  isTranscribing() {
+    return Boolean(this.transcription);
+  }
+
+  async start(settings = {}) {
+    if (this.recording) return this.recording.file;
+
+    const dir = getAudioDir(this.options, settings);
+    await ensureDir(dir);
+
+    const file = path.join(dir, `voice-${Date.now()}.wav`);
+    const recorders = buildRecorders(file, settings);
+    const errors = [];
+    this.recordingError = "";
+
+    for (const recorder of recorders) {
+      await fs.promises.unlink(file).catch(() => {});
+      try {
+        const active = await startRecorder(recorder, file);
+        active.proc.on("exit", () => {
+          if (this.recording?.proc === active.proc) this.recording = null;
+        });
+        this.recording = active;
+        return file;
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+
+    throw new Error(`Could not start recorder. Tried: ${errors.join("; ")}`);
+  }
+
+  async stop() {
+    const active = this.recording;
+    if (!active) return null;
+
+    try {
+      active.proc.kill("SIGINT");
+    } catch {}
+
+    await waitForExit(active.proc);
+    this.recording = null;
+
+    if (!fs.existsSync(active.file)) {
+      const lastError = lastLine(active.stderr?.() || this.recordingError);
+      throw new Error(lastError || `${active.recorder?.label || "Recorder"} did not create an audio file`);
+    }
+
+    if (fs.statSync(active.file).size <= RECORDING_MIN_BYTES) {
+      throw new Error("Recording is empty. Check your microphone input.");
+    }
+
+    return active.file;
+  }
+
+  async cancel() {
+    if (this.recording) {
+      try {
+        this.recording.proc.kill("SIGKILL");
+      } catch {}
+      this.recording = null;
+    }
+
+    if (this.transcription) {
+      try {
+        this.transcription.kill("SIGKILL");
+      } catch {}
+      this.transcription = null;
+    }
+  }
+
+  async transcribe(audioFile, model, settings = {}) {
+    const commandOptions = { ...this.options, downloadDir: settings.downloadDir };
+    const whisperCli = resolveCommand("whisper-cli", commandOptions);
+    if (!whisperCli) {
+      throw new Error("whisper-cli not found. Install whisper.cpp or set OPENCODE_VOICE_WHISPER_CLI to the binary path.");
+    }
+
+    const modelFile = getModelPath(model, this.options, settings);
+    if (!fs.existsSync(modelFile)) {
+      throw new Error(`Model is not downloaded: ${model.name}`);
+    }
+
+    const args = ["-m", modelFile, "-f", audioFile, "-np", "-nt"];
+    if (settings.language && settings.language !== "auto") args.push("-l", settings.language);
+
+    return new Promise((resolve, reject) => {
+      let stdout = "";
+      let stderr = "";
+      const proc = spawn(whisperCli, args, { env: childEnv(commandOptions), stdio: ["ignore", "pipe", "pipe"] });
+      this.transcription = proc;
+
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+        this.transcription = null;
+        reject(new Error("Transcription timed out"));
+      }, this.options.transcriptionTimeoutMs || 120000);
+
+      proc.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("error", (error) => {
+        clearTimeout(timer);
+        this.transcription = null;
+        reject(error);
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timer);
+        this.transcription = null;
+        if (code !== 0) {
+          reject(new Error(stderr.trim().split("\n").pop() || `whisper-cli exited with code ${code}`));
+          return;
+        }
+
+        const text = cleanTranscription(stdout);
+        if (!text) {
+          reject(new Error("Transcription returned empty text"));
+          return;
+        }
+        resolve(text);
+      });
+    });
+  }
+}