@drakulavich/kesha-voice-kit 1.31.0 → 2.1.0

package/src/engine-health.ts

@@ -1,22 +1,14 @@
 import { existsSync } from "fs";
-import { errorMessage } from "./error-utils";
-import {
-  getDescribe,
-  getEngineBinPath,
-  spawnEngineProcess,
-  type EngineCapabilities,
-} from "./engine";
+import { ENGINE_PROBE_TIMEOUT_MS, getDescribe, getEngineBinPath, type EngineCapabilities } from "./engine";
 import { describeToCapabilities } from "./engine/describe";
 import { KeshaError } from "./engine/events";
-import { registerProcessTree } from "./process-tree";
+import { runEngineProcess } from "./engine/spawn";
 
 export type ExecutableHealth =
   | { status: "ok" }
   | { status: "missing" }
   | { status: "unusable"; detail: string };
 
-const PROBE_TIMEOUT_MS = 15_000;
-
 /**
  * Proves a downloaded binary actually executes — existence is not health (#770).
  *
@@ -28,39 +20,32 @@ const PROBE_TIMEOUT_MS = 15_000;
  * The timeout guards against a binary that starts but never exits; macOS Gatekeeper can take
  * several seconds to scan a freshly written binary on its first run, so it is generous.
  */
+/** Message plus hint, not the rendered error: a caller wrapping it would otherwise nest a second code line. */
+function spawnFailureDetail(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  return err instanceof KeshaError && err.hint ? `${err.message}; ${err.hint}` : err.message;
+}
+
 export async function probeExecutable(
   binPath: string,
   args: string[] = [],
 ): Promise<ExecutableHealth> {
   if (!existsSync(binPath)) return { status: "missing" };
 
-  let proc: ReturnType<typeof Bun.spawn>;
+  let run: Awaited<ReturnType<typeof runEngineProcess>>;
   try {
-    proc = spawnEngineProcess(binPath, args, ["ignore", "ignore", "ignore"]);
+    run = await runEngineProcess(binPath, args, {
+      stdio: ["ignore", "ignore", "ignore"],
+      signal: AbortSignal.timeout(ENGINE_PROBE_TIMEOUT_MS),
+    });
   } catch (err) {
-    return { status: "unusable", detail: errorMessage(err) };
-  }
-  const tree = registerProcessTree(proc);
-
-  let timedOut = false;
-  let forceKillTimer: Timer | undefined;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    tree.terminate();
-    forceKillTimer = tree.forceKillAfterGrace();
-  }, PROBE_TIMEOUT_MS);
-  try {
-    await proc.exited;
-  } finally {
-    clearTimeout(timer);
-    tree.dispose();
-    if (!timedOut && forceKillTimer) clearTimeout(forceKillTimer);
+    return { status: "unusable", detail: spawnFailureDetail(err) };
   }
 
-  if (timedOut) {
-    return { status: "unusable", detail: `no exit within ${PROBE_TIMEOUT_MS / 1000}s` };
+  if (run.aborted) {
+    return { status: "unusable", detail: `no exit within ${ENGINE_PROBE_TIMEOUT_MS / 1000}s` };
   }
-  if (proc.signalCode) return { status: "unusable", detail: `killed by ${proc.signalCode}` };
+  if (run.signalCode) return { status: "unusable", detail: `killed by ${run.signalCode}` };
   return { status: "ok" };
 }
 
@@ -73,36 +58,20 @@ export async function probeExecutable(
  */
 export async function readExecutableVersion(
   binPath: string,
-  timeoutMs = PROBE_TIMEOUT_MS,
+  timeoutMs = ENGINE_PROBE_TIMEOUT_MS,
 ): Promise<string | null> {
   if (!existsSync(binPath)) return null;
 
-  let proc: ReturnType<typeof Bun.spawn>;
+  let stdout: string;
   try {
-    proc = spawnEngineProcess(binPath, ["--version"], ["ignore", "pipe", "ignore"]);
+    ({ stdout } = await runEngineProcess(binPath, ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      readStdout: (stream) => new Response(stream).text(),
+      signal: AbortSignal.timeout(timeoutMs),
+    }));
   } catch {
     return null;
   }
-  const tree = registerProcessTree(proc);
-
-  let timedOut = false;
-  let forceKillTimer: Timer | undefined;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    tree.terminate();
-    forceKillTimer = tree.forceKillAfterGrace();
-  }, timeoutMs);
-  let stdout: string;
-  try {
-    [stdout] = await Promise.all([
-      new Response(proc.stdout as ReadableStream<Uint8Array>).text(),
-      proc.exited,
-    ]);
-  } finally {
-    clearTimeout(timer);
-    tree.dispose();
-    if (!timedOut && forceKillTimer) clearTimeout(forceKillTimer);
-  }
   return /(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)/.exec(stdout)?.[1] ?? null;
 }
 
@@ -132,7 +101,7 @@ const MUTE_DETAIL = "reports no capabilities";
  * that could not be made to answer (`unusable`), not one that answered nothing (`mute`).
  */
 export async function engineFunctionalHealth(
-  timeoutMs = PROBE_TIMEOUT_MS,
+  timeoutMs = ENGINE_PROBE_TIMEOUT_MS,
 ): Promise<EngineFunctionalHealth> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);