@hajimism/dek 0.3.3 → 0.5.0

package/src/video/mux.ts

@@ -1,3 +1,4 @@
+// biome-ignore lint/style/noRestrictedImports: mkdtempSync, rmSync, and writeFileSync, for ffmpeg's frame list in a folder of its own in the system's temp folder.
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -5,16 +6,39 @@ import { DekError } from "../core/error.ts";
 import { runPiped, workerCommand } from "../core/spawn.ts";
 import type { VideoFrame } from "./recorder.ts";
 
-export function ffmpegResolved(): boolean {
+/** `ffmpeg -version` prints and exits at once; one that takes longer is stuck. */
+const FFMPEG_PROBE_TIMEOUT_MS = 10_000;
+
+/**
+ * True when ffmpeg is there to run: DEK_FFMPEG names one, or `ffmpeg -version` on PATH exits 0.
+ * An ffmpeg that does not answer within `timeoutMs` is killed, and is an error that says so.
+ */
+export function ffmpegResolved(timeoutMs = FFMPEG_PROBE_TIMEOUT_MS): boolean {
   if (process.env.DEK_FFMPEG) {
     return true;
   }
+  let result: Bun.SyncSubprocess<"ignore", "ignore">;
   try {
-    const result = Bun.spawnSync(["ffmpeg", "-version"], { stdout: "pipe", stderr: "pipe" });
-    return result.exitCode === 0;
+    // The environment as it is now, as runPiped passes it: left out, Bun passes the one dek
+    // started with. Nothing is piped, so a process it leaves behind cannot hold dek.
+    // biome-ignore lint/nursery/noJsRestrictedProperties: ffmpegResolved is synchronous, for tests too; the probe has its own timeout and SIGKILL, and the encode runs through runPiped.
+    result = Bun.spawnSync(["ffmpeg", "-version"], {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      env: process.env,
+      timeout: timeoutMs,
+      killSignal: "SIGKILL",
+    });
   } catch {
     return false;
   }
+  if (result.exitedDueToTimeout) {
+    throw new DekError(`ffmpeg did not answer \`ffmpeg -version\` within ${timeoutMs / 1000}s`, {
+      hint: "check the ffmpeg on PATH, or set DEK_FFMPEG to an ffmpeg that runs, then run the command again",
+    });
+  }
+  return result.exitCode === 0;
 }
 
 function ffmpegCommand(args: string[]): string[] {

package/src/video/recorder.ts

@@ -1,7 +1,8 @@
 import { DekError } from "../core/error.ts";
 import { moduleFilePath } from "../core/path.ts";
 import { playwrightResolved } from "../core/playwright.ts";
-import { runJsonWorker, workerCommand } from "../core/spawn.ts";
+import { runDrawingWorker } from "../core/sandbox.ts";
+import { workerCommand } from "../core/spawn.ts";
 import type { Position } from "../core/step.ts";
 import { playbackSchedule, type Timeline } from "../core/timeline.ts";
 
@@ -85,7 +86,7 @@ function spawnVideoRunner(
   request: VideoCaptureRequest,
   options: { timeoutMs?: number },
 ): Promise<VideoCaptureResponse> {
-  return runJsonWorker(workerCommand(bin), request, parseVideoResponse, {
+  return runDrawingWorker(workerCommand(bin), request, parseVideoResponse, {
     label: "video capture failed",
     hint: "install Playwright or set DEK_VIDEO",
     ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),

package/src/video/worker.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+// biome-ignore lint/style/noRestrictedImports: mkdirSync, in a worker, for the folder its parent made with outputDir, which Chromium writes into.
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import type { Browser } from "playwright";

package/src/voice/engine.ts

@@ -37,41 +37,78 @@ export function engineBaseUrl(engine: string): string {
   return `http://127.0.0.1:${resolved}`;
 }
 
-export async function fetchSpeakers(baseUrl: string): Promise<VoiceSpeaker[]> {
-  const res = await engineFetch(baseUrl, "/speakers");
-  return (await res.json()) as VoiceSpeaker[];
+export type EngineOptions = {
+  /** Covers the whole call, from connecting to the last byte of the answer. */
+  timeoutMs?: number;
+};
+
+/** /speakers and /version answer from what the engine has loaded; a stall this long is a hang. */
+const PROBE_TIMEOUT_MS = 10 * 1000;
+
+/** Reading a sentence's accents takes well under a second; this leaves room for a busy machine. */
+const QUERY_TIMEOUT_MS = 60 * 1000;
+
+/** Synthesis on a CPU can take longer than the sentence lasts; a long one fits inside this. */
+const SYNTHESIS_TIMEOUT_MS = 5 * 60 * 1000;
+
+export async function fetchSpeakers(
+  baseUrl: string,
+  options: EngineOptions = {},
+): Promise<VoiceSpeaker[]> {
+  return engineFetch(
+    baseUrl,
+    "/speakers",
+    options.timeoutMs ?? PROBE_TIMEOUT_MS,
+    (res) => res.json() as Promise<VoiceSpeaker[]>,
+  );
 }
 
-export async function fetchEngineVersion(baseUrl: string): Promise<string> {
-  const res = await engineFetch(baseUrl, "/version");
-  const text = (await res.text()).trim();
-  return text.replace(/^"|"$/g, "");
+export async function fetchEngineVersion(
+  baseUrl: string,
+  options: EngineOptions = {},
+): Promise<string> {
+  const text = await engineFetch(
+    baseUrl,
+    "/version",
+    options.timeoutMs ?? PROBE_TIMEOUT_MS,
+    (res) => res.text(),
+  );
+  return text.trim().replace(/^"|"$/g, "");
 }
 
 export async function fetchAudioQuery(
   baseUrl: string,
   text: string,
   speaker: number,
+  options: EngineOptions = {},
 ): Promise<AudioQuery> {
-  const res = await engineFetch(
+  return engineFetch(
     baseUrl,
     `/audio_query?text=${encodeURIComponent(text)}&speaker=${speaker}`,
+    options.timeoutMs ?? QUERY_TIMEOUT_MS,
+    (res) => res.json() as Promise<AudioQuery>,
     { method: "POST" },
   );
-  return (await res.json()) as AudioQuery;
 }
 
 export async function fetchSynthesis(
   baseUrl: string,
   query: AudioQuery,
   speaker: number,
+  options: EngineOptions = {},
 ): Promise<Buffer> {
-  const res = await engineFetch(baseUrl, `/synthesis?speaker=${speaker}`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(query),
-  });
-  return Buffer.from(await res.arrayBuffer());
+  const body = await engineFetch(
+    baseUrl,
+    `/synthesis?speaker=${speaker}`,
+    options.timeoutMs ?? SYNTHESIS_TIMEOUT_MS,
+    (res) => res.arrayBuffer(),
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(query),
+    },
+  );
+  return Buffer.from(body);
 }
 
 export function resolveStyleId(speakers: VoiceSpeaker[], speaker: string): number {
@@ -161,11 +198,30 @@ export async function withEngine<T>(
   }
 }
 
-async function engineFetch(baseUrl: string, path: string, init?: RequestInit): Promise<Response> {
+/**
+ * What the engine answers at `path`, read by `read` within `timeoutMs`. An engine that cannot be
+ * reached is missing; one that is reached but does not answer in time is stuck, and says so.
+ */
+async function engineFetch<T>(
+  baseUrl: string,
+  path: string,
+  timeoutMs: number,
+  read: (res: Response) => Promise<T>,
+  init?: RequestInit,
+): Promise<T> {
+  const signal = AbortSignal.timeout(timeoutMs);
+  const timedOut = () =>
+    new DekError(`voice engine did not answer ${path.split("?")[0]} within ${timeoutMs / 1000}s`, {
+      hint: "check the engine log, and restart the engine if it is stuck, then run the command again",
+    });
   let res: Response;
   try {
-    res = await fetch(`${baseUrl}${path}`, init);
+    // biome-ignore lint/style/noRestrictedGlobals: signal, an AbortSignal.timeout, bounds the request and read(res).
+    res = await fetch(`${baseUrl}${path}`, { ...init, signal });
   } catch {
+    if (signal.aborted) {
+      throw timedOut();
+    }
     throw engineMissingError(engineNameForUrl(baseUrl) ?? "voice engine", baseUrl);
   }
   if (!res.ok) {
@@ -173,5 +229,12 @@ async function engineFetch(baseUrl: string, path: string, init?: RequestInit): P
       hint: "check the engine log",
     });
   }
-  return res;
+  try {
+    return await read(res);
+  } catch (error) {
+    if (signal.aborted) {
+      throw timedOut();
+    }
+    throw error;
+  }
 }