@hxnnxs/opencode-voice 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project are documented here.
 
+## 0.1.9 - 2026-06-21
+
+### Fixed
+
+- Rebuilt the managed Windows `whisper-cli.exe` engine asset as a static MinGW binary so clean Windows installs do not need the Visual C++ runtime DLLs.
+- Fixed managed engine path handling so explicit `downloadDir` and Windows platform overrides are honored consistently.
+- Added streaming timeout protection and clearer VC++ runtime diagnostics to managed engine downloads and probes.
+
 ## 0.1.8 - 2026-06-21
 
 ### Fixed

package/lib/engines.js

@@ -9,7 +9,7 @@ import { sha256, ensureDir, replaceFile } from "./download.js";
 import { getCacheDir } from "./models.js";
 import { getBundledEngineDir, resolveCommand } from "./engine.js";
 
-export const DEFAULT_ENGINE_REGISTRY_URL = "https://github.com/ihxnnxs/opencode-voice/releases/download/v0.1.0/registry.json";
+export const DEFAULT_ENGINE_REGISTRY_URL = "https://github.com/ihxnnxs/opencode-voice/releases/download/v0.1.9/registry.json";
 
 const ENGINE = {
   id: "whisper.cpp",
@@ -19,13 +19,14 @@ const ENGINE = {
 };
 
 const DEFAULT_ENGINE_DOWNLOAD_RETRIES = 5;
+const DEFAULT_ENGINE_DOWNLOAD_TIMEOUT_MS = 120000;
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function executableName() {
-  return process.platform === "win32" ? "whisper-cli.exe" : "whisper-cli";
+function executableName(options = {}) {
+  return (options.platform || process.platform) === "win32" ? "whisper-cli.exe" : "whisper-cli";
 }
 
 function temporaryBinaryPath(binaryPath) {
@@ -45,13 +46,17 @@ export function getEnginePlatformKey(options = {}) {
   return `${options.platform || process.platform}-${normalizePlatform(options.arch || process.arch)}`;
 }
 
+function withDownloadDir(options = {}, settings = {}) {
+  return { ...options, downloadDir: settings.downloadDir || options.downloadDir };
+}
+
 export function getManagedEngineDir(engineId = ENGINE.id, options = {}, settings = {}) {
   if (engineId !== ENGINE.id) throw new Error(`Unsupported engine: ${engineId}`);
-  return getBundledEngineDir(ENGINE.command, { ...options, downloadDir: settings.downloadDir });
+  return getBundledEngineDir(ENGINE.command, withDownloadDir(options, settings));
 }
 
 export function getManagedEngineBinary(engineId = ENGINE.id, options = {}, settings = {}) {
-  return path.join(getManagedEngineDir(engineId, options, settings), executableName());
+  return path.join(getManagedEngineDir(engineId, options, settings), executableName(options));
 }
 
 export function getEngineManifestPath(engineId = ENGINE.id, options = {}, settings = {}) {
@@ -77,32 +82,52 @@ function engineSource(resolved, managedBinary, options = {}) {
 }
 
 export function getEngineStatus(engineId = ENGINE.id, options = {}, settings = {}) {
-  const commandOptions = { ...options, downloadDir: settings.downloadDir };
-  const managedDir = getManagedEngineDir(engineId, options, settings);
-  const managedBinary = getManagedEngineBinary(engineId, options, settings);
-  const manifest = readEngineManifest(engineId, options, settings);
+  const commandOptions = withDownloadDir(options, settings);
+  const managedDir = getManagedEngineDir(engineId, commandOptions);
+  const managedBinary = getManagedEngineBinary(engineId, commandOptions);
+  const manifest = readEngineManifest(engineId, commandOptions);
   const resolvedBinary = resolveCommand(ENGINE.command, commandOptions);
 
   return {
     id: engineId,
     command: ENGINE.command,
-    platform: getEnginePlatformKey(options),
-    cacheDir: getCacheDir(options, settings),
+    platform: getEnginePlatformKey(commandOptions),
+    cacheDir: getCacheDir(commandOptions),
     managedDir,
     managedBinary,
     managedInstalled: fs.existsSync(managedBinary),
     manifest,
     resolvedBinary,
-    source: engineSource(resolvedBinary, managedBinary, options),
+    source: engineSource(resolvedBinary, managedBinary, commandOptions),
   };
 }
 
+function summarizeProbeOutput(output) {
+  return String(output || "").replace(/\s+/g, " ").trim().slice(0, 240);
+}
+
+function engineProbeMessage(message) {
+  const text = summarizeProbeOutput(message);
+  if (/\b(MSVCP140|VCOMP140|VCRUNTIME140|VCRUNTIME140_1|api-ms-win-crt)\b/i.test(text)) {
+    return `${text}; Windows VC++ runtime dependency is missing`;
+  }
+  return text || "unknown probe failure";
+}
+
 export async function probeEngine(engineId = ENGINE.id, binaryPath, options = {}) {
   if (engineId !== ENGINE.id) throw new Error(`Unsupported engine: ${engineId}`);
   if (!binaryPath) return { ok: false, message: "missing binary" };
 
   return new Promise((resolve) => {
     let output = "";
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
     const localLib = path.join(os.homedir(), ".local", "lib");
     const env = {
       ...process.env,
@@ -112,11 +137,11 @@ export async function probeEngine(engineId = ENGINE.id, binaryPath, options = {}
       ...options.env,
     };
     const proc = spawn(binaryPath, ENGINE.probeArgs, { stdio: ["ignore", "pipe", "pipe"], env });
-    const timer = setTimeout(() => {
+    timer = setTimeout(() => {
       try {
         proc.kill("SIGKILL");
       } catch {}
-      resolve({ ok: false, message: "probe timed out" });
+      finish({ ok: false, message: "probe timed out" });
     }, options.timeoutMs || 10000);
 
     proc.stdout.on("data", (chunk) => {
@@ -126,13 +151,12 @@ export async function probeEngine(engineId = ENGINE.id, binaryPath, options = {}
       output += chunk.toString();
     });
     proc.on("error", (error) => {
-      clearTimeout(timer);
-      resolve({ ok: false, message: error.message });
+      finish({ ok: false, message: engineProbeMessage(error.message) });
     });
-    proc.on("exit", () => {
-      clearTimeout(timer);
+    proc.on("exit", (code, signal) => {
       const ok = ENGINE.probeContains.every((item) => output.includes(item));
-      resolve({ ok, message: ok ? "ok" : "unexpected whisper-cli help output" });
+      const detail = summarizeProbeOutput(output) || `exit ${code ?? signal ?? "unknown"}`;
+      finish({ ok, message: ok ? "ok" : engineProbeMessage(`unexpected whisper-cli help output: ${detail}`) });
     });
   });
 }
@@ -150,6 +174,14 @@ async function fetchWithTimeout(url, init = {}, timeoutMs = 60000) {
   }
 }
 
+function engineDownloadTimeoutMs(options = {}, hooks = {}) {
+  return Number(options.engineDownloadTimeoutMs || options.downloadTimeoutMs || hooks.timeoutMs || DEFAULT_ENGINE_DOWNLOAD_TIMEOUT_MS);
+}
+
+function engineDownloadTimeoutError(url, timeoutMs) {
+  return new Error(`Engine download stalled after ${Math.round(timeoutMs / 1000)}s: ${url}`);
+}
+
 async function readJsonUrl(url, options = {}) {
   if (url.startsWith("file://")) return JSON.parse(await fs.promises.readFile(new URL(url), "utf8"));
   if (!/^https?:\/\//.test(url)) return JSON.parse(await fs.promises.readFile(path.resolve(url), "utf8"));
@@ -201,7 +233,8 @@ async function downloadAsset(asset, compressedFile, hooks = {}, attempt = 1, att
     return;
   }
 
-  const response = await fetchWithTimeout(asset.url, {}, Number(options.downloadTimeoutMs || hooks.timeoutMs || 120000));
+  const timeoutMs = engineDownloadTimeoutMs(options, hooks);
+  const response = await fetchWithTimeout(asset.url, {}, timeoutMs);
   if (!response.ok) throw new Error(`Engine download failed: HTTP ${response.status}`);
 
   const contentLength = Number(response.headers.get("content-length") || asset.size || 0);
@@ -211,15 +244,31 @@ async function downloadAsset(asset, compressedFile, hooks = {}, attempt = 1, att
   const body = response.body?.getReader ? Readable.fromWeb(response.body) : response.body;
   if (!body) throw new Error("Engine download failed: empty response body");
 
+  const controller = new AbortController();
+  let stallTimer;
+  const resetStallTimer = () => {
+    clearTimeout(stallTimer);
+    stallTimer = setTimeout(() => controller.abort(), timeoutMs);
+  };
+
   const progress = new Transform({
     transform(chunk, _encoding, callback) {
+      resetStallTimer();
       downloaded += chunk.length ?? chunk.byteLength ?? 0;
       hooks.onProgress?.({ state: "downloading", downloaded, total: contentLength, percent: contentLength ? (downloaded / contentLength) * 100 : 0, attempt, attempts });
       callback(null, chunk);
     },
   });
 
-  await pipeline(body, progress, fs.createWriteStream(compressedFile));
+  resetStallTimer();
+  try {
+    await pipeline(body, progress, fs.createWriteStream(compressedFile), { signal: controller.signal });
+  } catch (error) {
+    if (error?.name === "AbortError") throw engineDownloadTimeoutError(asset.url, timeoutMs);
+    throw error;
+  } finally {
+    clearTimeout(stallTimer);
+  }
 }
 
 async function writeManifest(engineId, managedBinary, source, options = {}) {
@@ -244,29 +293,30 @@ async function writeManifest(engineId, managedBinary, source, options = {}) {
 export async function installManagedEngine(engineId = ENGINE.id, options = {}, settings = {}, hooks = {}) {
   if (engineId !== ENGINE.id) throw new Error(`Unsupported engine: ${engineId}`);
 
-  const managedDir = getManagedEngineDir(engineId, options, settings);
-  const managedBinary = getManagedEngineBinary(engineId, options, settings);
+  const commandOptions = withDownloadDir(options, settings);
+  const managedDir = getManagedEngineDir(engineId, commandOptions);
+  const managedBinary = getManagedEngineBinary(engineId, commandOptions);
   if (!hooks.force && fs.existsSync(managedBinary)) {
     const probe = await probeEngine(engineId, managedBinary);
-    if (probe.ok) return { manifest: readEngineManifest(engineId, options, settings), managedBinary, skipped: true };
+    if (probe.ok) return { manifest: readEngineManifest(engineId, commandOptions), managedBinary, skipped: true };
   }
 
   hooks.onProgress?.({ state: "registry", downloaded: 0, total: 0, percent: 0, attempt: 1, attempts: 1 });
-  const { url: registryUrl, registry } = await loadEngineRegistry(options);
-  const platform = getEnginePlatformKey(options);
+  const { url: registryUrl, registry } = await loadEngineRegistry(commandOptions);
+  const platform = getEnginePlatformKey(commandOptions);
   const { engine, asset } = selectEngineAsset(registry, engineId, platform);
 
   await ensureDir(managedDir);
   const compressedFile = path.join(managedDir, `${path.basename(asset.url || `${platform}.gz`)}.download`);
   const tmpBinary = temporaryBinaryPath(managedBinary);
-  const attempts = Number(options.engineDownloadRetries || hooks.retries || DEFAULT_ENGINE_DOWNLOAD_RETRIES);
+  const attempts = Number(commandOptions.engineDownloadRetries || hooks.retries || DEFAULT_ENGINE_DOWNLOAD_RETRIES);
   let lastError;
 
   for (let attempt = 1; attempt <= attempts; attempt++) {
     try {
       await fs.promises.unlink(compressedFile).catch(() => {});
       await fs.promises.unlink(tmpBinary).catch(() => {});
-      await downloadAsset(asset, compressedFile, hooks, attempt, attempts, options);
+      await downloadAsset(asset, compressedFile, hooks, attempt, attempts, commandOptions);
 
       hooks.onProgress?.({ state: "verifying", downloaded: asset.size || 0, total: asset.size || 0, percent: 100, attempt, attempts });
       if (asset.sha256 && (await sha256(compressedFile)) !== asset.sha256) throw new Error("Engine archive SHA256 mismatch");
@@ -294,7 +344,7 @@ export async function installManagedEngine(engineId = ENGINE.id, options = {}, s
           version: engine.version || registry.version || "registry",
           upstream: engine.upstream,
         },
-        options,
+        commandOptions,
       );
       hooks.onProgress?.({ state: "done", downloaded: asset.binary?.size || asset.size || 0, total: asset.binary?.size || asset.size || 0, percent: 100, attempt, attempts });
       return { manifest, managedBinary, skipped: false };
@@ -318,8 +368,9 @@ export async function importManagedEngine(engineId = ENGINE.id, sourcePath, opti
   const stat = await fs.promises.stat(source).catch(() => null);
   if (!stat?.isFile()) throw new Error(`Engine binary not found: ${source}`);
 
-  const managedDir = getManagedEngineDir(engineId, options, settings);
-  const managedBinary = getManagedEngineBinary(engineId, options, settings);
+  const commandOptions = withDownloadDir(options, settings);
+  const managedDir = getManagedEngineDir(engineId, commandOptions);
+  const managedBinary = getManagedEngineBinary(engineId, commandOptions);
   const tmp = temporaryBinaryPath(managedBinary);
   await ensureDir(managedDir);
   await fs.promises.copyFile(source, tmp);
@@ -332,7 +383,7 @@ export async function importManagedEngine(engineId = ENGINE.id, sourcePath, opti
   }
 
   await replaceFile(tmp, managedBinary);
-  const manifest = await writeManifest(engineId, managedBinary, { type: "local-file", path: source }, options);
+  const manifest = await writeManifest(engineId, managedBinary, { type: "local-file", path: source }, commandOptions);
   return { manifest, managedBinary };
 }
 

package/package.json

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