@hxnnxs/opencode-voice 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project are documented here.
 
+## 0.1.7 - 2026-06-17
+
+### Fixed
+
+- Hardened Windows ffmpeg resolution to handle executable-resolution edge cases (extensionless bundled binary paths and local module fallback), so recorder startup can use the actual resolved binary path.
+- Improved diagnostics to print exact recorder command paths and quick per-command probe results in `opencode-voice doctor` output.
+
+## 0.1.6 - 2026-06-17
+
+### Fixed
+
+- Fixed Windows recorder startup to use resolved recorder command paths (including bundled ffmpeg) directly when spawning, preventing startup failures when ffmpeg is present only by absolute path.
+
 ## 0.1.5 - 2026-06-17
 
 ### Fixed

package/bin/opencode-voice.js

@@ -32,6 +32,34 @@ function packageName() {
   return process.env.OPENCODE_VOICE_PACKAGE || manifest.name || "opencode-voice";
 }
 
+function probeCommand(command, args = ["-version"]) {
+  if (!command) return { ok: false, message: "missing" };
+  try {
+    const result = spawnSync(command, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 2000,
+    });
+
+    if (result.error) {
+      return { ok: false, message: result.error.message };
+    }
+
+    if (typeof result.status === "number" && result.status !== 0) {
+      return {
+        ok: false,
+        message: `exit ${result.status}`,
+        stderr: (result.stderr || "").trim(),
+      };
+    }
+
+    const output = `${result.stdout || ""}${result.stderr || ""}`;
+    return { ok: true, versionLine: output.split("\n").filter(Boolean)[0] || "" };
+  } catch (error) {
+    return { ok: false, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 async function runtime() {
   const [engine, models, engines] = await Promise.all([import("../lib/engine.js"), import("../lib/models.js"), import("../lib/engines.js")]);
   return { ...engine, ...models, ...engines };
@@ -40,6 +68,7 @@ async function runtime() {
 async function doctor() {
   const {
     commandExists,
+    resolveCommand,
     getAudioDir,
     getCacheDir,
     getEngineStatus,
@@ -50,6 +79,9 @@ async function doctor() {
 
   const engine = getEngineStatus("whisper.cpp");
   const probe = engine.resolvedBinary ? await probeEngine("whisper.cpp", engine.resolvedBinary) : { ok: false, message: "missing binary" };
+  const ffmpeg = resolveCommand("ffmpeg");
+  const arecord = resolveCommand("arecord");
+  const sox = resolveCommand("sox");
   const payload = {
     platform: `${process.platform}-${process.arch}`,
     cacheDir: getCacheDir(),
@@ -58,9 +90,15 @@ async function doctor() {
     engine,
     probe,
     recorders: {
-      ffmpeg: commandExists("ffmpeg"),
-      arecord: commandExists("arecord"),
-      sox: commandExists("sox"),
+      ffmpeg,
+      arecord,
+      sox,
+      ffmpegPresent: commandExists("ffmpeg"),
+      arecordPresent: commandExists("arecord"),
+      soxPresent: commandExists("sox"),
+      ffmpegProbe: probeCommand(ffmpeg),
+      arecordProbe: probeCommand(arecord, ["--help"]),
+      soxProbe: probeCommand(sox, ["--help"]),
     },
     microphones: listMicrophones(),
   };
@@ -80,7 +118,7 @@ async function doctor() {
         `Managed engine dir: ${engine.managedDir}`,
         `whisper-cli: ${engine.resolvedBinary || "missing"}`,
         `Probe: ${probe.ok ? "ok" : probe.message}`,
-        `Recorders: ffmpeg=${payload.recorders.ffmpeg ? "yes" : "no"}, arecord=${payload.recorders.arecord ? "yes" : "no"}, sox=${payload.recorders.sox ? "yes" : "no"}`,
+        `Recorders: ffmpeg=${payload.recorders.ffmpegPresent ? "yes" : "no"}${payload.recorders.ffmpeg ? ` (${payload.recorders.ffmpeg})` : ""}, arecord=${payload.recorders.arecordPresent ? "yes" : "no"}${payload.recorders.arecord ? ` (${payload.recorders.arecord})` : ""}, sox=${payload.recorders.soxPresent ? "yes" : "no"}${payload.recorders.sox ? ` (${payload.recorders.sox})` : ""}`,
         `Microphones: ${payload.microphones.join(", ")}`,
       ].join("\n"),
     );
@@ -162,7 +200,13 @@ function printEngineRetry({ error, nextAttempt, attempts }) {
 
 async function installCommand() {
   const pluginArgs = args.filter((arg) => arg !== "--no-engine");
-  const result = spawnSync("opencode", ["plugin", packageName(), ...pluginArgs], { stdio: "inherit" });
+  const spawnOptions = { stdio: "inherit" };
+  if (process.platform === "win32") spawnOptions.shell = true;
+  const result = spawnSync("opencode", ["plugin", packageName(), ...pluginArgs], spawnOptions);
+  if (result.error) {
+    console.error(`Failed to run opencode: ${result.error.message}`);
+    process.exit(1);
+  }
   if ((result.status ?? 1) !== 0) process.exit(result.status ?? 1);
 
   if (!hasFlag("--no-engine")) {

package/lib/download.js

@@ -70,7 +70,7 @@ function contentRangeStart(value) {
   return match ? Number(match[1]) : null;
 }
 
-async function replaceFile(source, destination) {
+export async function replaceFile(source, destination) {
   await fs.promises.unlink(destination).catch(() => {});
 
   for (let attempt = 1; attempt <= 5; attempt++) {

package/lib/engine.js

@@ -24,6 +24,31 @@ function isExecutable(file) {
   }
 }
 
+function executableExtensions() {
+  if (process.platform !== "win32") return [""];
+  return (process.env.PATHEXT || ".EXE;.CMD;.BAT")
+    .split(";")
+    .map((entry) => entry.trim().toLowerCase())
+    .filter(Boolean)
+    .filter((entry) => entry.startsWith("."));
+}
+
+function resolveExecutable(file) {
+  const normalized = path.resolve(file);
+  if (isExecutable(normalized)) return normalized;
+
+  if (path.extname(normalized) || process.platform !== "win32") {
+    return "";
+  }
+
+  for (const ext of executableExtensions()) {
+    const candidate = `${normalized}${ext}`;
+    if (isExecutable(candidate)) return candidate;
+  }
+
+  return "";
+}
+
 function executableNames(command) {
   const names = [command];
   if (path.extname(command)) return names;
@@ -46,12 +71,18 @@ function bundledFfmpegPath() {
   const resolveFromDependency = () => {
     try {
       const candidate = require("ffmpeg-static");
-      return typeof candidate === "string" ? path.resolve(candidate) : "";
+      if (typeof candidate !== "string") return "";
+      return resolveExecutable(candidate);
     } catch {
       return "";
     }
   };
 
+  const resolveFromLocalModule = () => {
+    const fallback = path.join(PLUGIN_ROOT, "node_modules", "ffmpeg-static", "ffmpeg");
+    return resolveExecutable(fallback);
+  };
+
   const installDependency = () => {
     const npm = process.platform === "win32" ? "npm.cmd" : "npm";
     try {
@@ -66,6 +97,7 @@ function bundledFfmpegPath() {
   };
 
   let candidate = resolveFromDependency();
+  if (!candidate) candidate = resolveFromLocalModule();
   if (!candidate && !ffmpegStaticInstallAttempted) {
     ffmpegStaticInstallAttempted = true;
     if (installDependency()) {
@@ -73,6 +105,8 @@ function bundledFfmpegPath() {
     }
   }
 
+  if (!candidate) candidate = resolveFromLocalModule();
+
   ffmpegStaticPathCache = candidate || "";
   return ffmpegStaticPathCache;
 }
@@ -134,7 +168,8 @@ function candidateCommands(command, options = {}) {
 export function resolveCommand(command, options = {}) {
   for (const candidate of candidateCommands(command, options)) {
     if (looksLikePath(candidate)) {
-      if (isExecutable(candidate)) return candidate;
+      const resolved = resolveExecutable(candidate);
+      if (resolved) return resolved;
       continue;
     }
 
@@ -182,8 +217,11 @@ function parseWindowsMicrophones(stderr) {
 }
 
 export function listMicrophones() {
-  if (process.platform === "linux" && commandExists("arecord")) {
-    const result = spawnSync("arecord", ["-L"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const arecordCommand = resolveCommand("arecord");
+  const ffmpegCommand = resolveCommand("ffmpeg");
+
+  if (process.platform === "linux" && arecordCommand) {
+    const result = spawnSync(arecordCommand, ["-L"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     const devices = result.stdout
       .split(/\r?\n/)
       .map((line) => line.trim())
@@ -191,8 +229,8 @@ export function listMicrophones() {
     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", ""], {
+  if (process.platform === "darwin" && ffmpegCommand) {
+    const result = spawnSync(ffmpegCommand, ["-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""], {
       encoding: "utf8",
       stdio: ["ignore", "ignore", "pipe"],
     });
@@ -203,8 +241,8 @@ export function listMicrophones() {
       .map((id) => `:${id}`);
   }
 
-  if (process.platform === "win32" && commandExists("ffmpeg")) {
-    const result = spawnSync("ffmpeg", ["-hide_banner", "-f", "dshow", "-list_devices", "true", "-i", "dummy"], {
+  if (process.platform === "win32" && ffmpegCommand) {
+    const result = spawnSync(ffmpegCommand, ["-hide_banner", "-f", "dshow", "-list_devices", "true", "-i", "dummy"], {
       encoding: "utf8",
       stdio: ["ignore", "ignore", "pipe"],
     });
@@ -218,54 +256,60 @@ export function listMicrophones() {
 function buildRecorders(file, settings = {}) {
   const mic = settings.mic || "";
   const recorders = [];
+  const arecordCommand = resolveCommand("arecord", settings);
+  const ffmpegCommand = resolveCommand("ffmpeg", settings);
+  const soxCommand = resolveCommand("sox", settings);
 
-  if (process.platform === "linux" && commandExists("arecord")) {
+  if (process.platform === "linux" && arecordCommand) {
     recorders.push({
       label: mic ? `arecord (${mic})` : "arecord (default)",
-      command: "arecord",
+      command: arecordCommand,
       args: ["-q", "-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "wav", ...(mic ? ["-D", mic] : []), file],
     });
   }
 
-  if (process.platform === "linux" && commandExists("ffmpeg")) {
+  if (process.platform === "linux" && ffmpegCommand) {
     if (!mic) {
       recorders.push({
         label: "ffmpeg pulse (default)",
-        command: "ffmpeg",
+        command: ffmpegCommand,
         args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "pulse", "-i", "default", "-ac", "1", "-ar", "16000", file],
       });
     }
 
     recorders.push({
       label: `ffmpeg alsa (${mic || "default"})`,
-      command: "ffmpeg",
+      command: ffmpegCommand,
       args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "alsa", "-i", mic || "default", "-ac", "1", "-ar", "16000", file],
     });
   }
 
-  if (process.platform === "darwin" && commandExists("ffmpeg")) {
+  if (process.platform === "darwin" && ffmpegCommand) {
     recorders.push({
       label: `ffmpeg avfoundation (${mic || ":0"})`,
-      command: "ffmpeg",
+      command: ffmpegCommand,
       args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "avfoundation", "-i", mic || ":0", "-ac", "1", "-ar", "16000", file],
     });
   }
 
-  if (process.platform === "win32" && commandExists("ffmpeg")) {
-    const inputs = [...new Set([normalizeWindowsAudioInput(mic), "audio=default"])];
-    for (const input of inputs) {
-      recorders.push({
-        label: `ffmpeg dshow (${input.replace(/^audio=/, "")})`,
-        command: "ffmpeg",
-        args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "dshow", "-i", input, "-ac", "1", "-ar", "16000", file],
-      });
+  if (process.platform === "win32" && ffmpegCommand) {
+    const ffmpegCmd = ffmpegCommand;
+    if (ffmpegCmd) {
+      const inputs = [...new Set([normalizeWindowsAudioInput(mic), "audio=default"])];
+      for (const input of inputs) {
+        recorders.push({
+          label: `ffmpeg dshow (${input.replace(/^audio=/, "")})`,
+          command: ffmpegCmd,
+          args: ["-hide_banner", "-loglevel", "error", "-y", "-f", "dshow", "-i", input, "-ac", "1", "-ar", "16000", file],
+        });
+      }
     }
   }
 
-  if (commandExists("sox")) {
+  if (soxCommand) {
     recorders.push({
       label: "sox default",
-      command: "sox",
+      command: soxCommand,
       args: ["-d", "-r", "16000", "-c", "1", "-b", "16", file],
     });
   }

package/lib/engines.js

@@ -5,7 +5,7 @@ import { createGunzip } from "node:zlib";
 import { spawn } from "node:child_process";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { sha256, ensureDir } from "./download.js";
+import { sha256, ensureDir, replaceFile } from "./download.js";
 import { getCacheDir } from "./models.js";
 import { getBundledEngineDir, resolveCommand } from "./engine.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hxnnxs/opencode-voice",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Local voice input plugin for OpenCode",
   "type": "module",
   "license": "MIT",