@hyperframes/engine 0.6.118 → 0.6.120

package/src/utils/runFfmpeg.test.ts

@@ -1,102 +0,0 @@
-import { EventEmitter } from "node:events";
-import { resolve } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { formatFfmpegError } from "./runFfmpeg.js";
-
-describe("formatFfmpegError", () => {
-  const originalPlatform = process.platform;
-
-  afterEach(() => {
-    Object.defineProperty(process, "platform", { value: originalPlatform, configurable: true });
-  });
-
-  it("reports exit code alone when stderr is empty", () => {
-    expect(formatFfmpegError(-22, "")).toBe("FFmpeg exited with code -22");
-  });
-
-  it("appends stderr tail when present", () => {
-    const stderr =
-      "ffmpeg version 8.1\nbuilt with gcc 13.2.0\n" +
-      "[h264_nvenc @ 0x7f] Error applying encoder options: Invalid argument\n" +
-      "Error while opening encoder\n";
-    const message = formatFfmpegError(-22, stderr);
-    expect(message).toContain("FFmpeg exited with code -22");
-    expect(message).toContain("ffmpeg stderr (tail):");
-    expect(message).toContain("Error applying encoder options: Invalid argument");
-    expect(message).toContain("Error while opening encoder");
-  });
-
-  it("keeps only the last N non-empty lines in the tail", () => {
-    const lines = Array.from({ length: 30 }, (_, i) => `line-${i}`).join("\n");
-    const message = formatFfmpegError(1, lines, 5);
-    expect(message).toContain("line-29");
-    expect(message).toContain("line-25");
-    expect(message).not.toContain("line-24");
-  });
-
-  it("strips blank lines from the tail so real signal isn't hidden", () => {
-    const stderr = "\n\nError applying encoder options: Invalid argument\n\n\n";
-    const message = formatFfmpegError(-22, stderr);
-    expect(message).toContain("Error applying encoder options: Invalid argument");
-    // Only one non-empty stderr line should appear in the tail.
-    const tailPart = message.split("ffmpeg stderr (tail):\n")[1] ?? "";
-    expect(tailPart.trim().split(/\r?\n/).length).toBe(1);
-  });
-
-  it("falls back to a process-error string when exit code is null and stderr is empty", () => {
-    expect(formatFfmpegError(null, "")).toBe("[FFmpeg] process error");
-  });
-
-  it("wraps stderr in [FFmpeg] prefix when exit code is null (spawn failure)", () => {
-    expect(formatFfmpegError(null, "spawn ffmpeg ENOENT")).toBe("[FFmpeg] spawn ffmpeg ENOENT");
-  });
-
-  it("maps Windows invalid-image exit codes to an actionable architecture hint", () => {
-    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
-
-    expect(formatFfmpegError(3221225595, "")).toContain("wrong architecture");
-  });
-});
-
-function createSpawnSpy() {
-  const calls: Array<{ command: string; args: string[] }> = [];
-  const spawn = vi.fn((command: string, args: string[]) => {
-    calls.push({ command, args });
-    const proc = new EventEmitter() as EventEmitter & {
-      stderr: EventEmitter;
-      kill: ReturnType<typeof vi.fn>;
-      killed: boolean;
-    };
-    proc.stderr = new EventEmitter();
-    proc.kill = vi.fn();
-    proc.killed = false;
-    process.nextTick(() => proc.emit("close", 0));
-    return proc;
-  });
-  return { spawn, calls };
-}
-
-describe("runFfmpeg binary resolution", () => {
-  const originalFfmpegPath = process.env.HYPERFRAMES_FFMPEG_PATH;
-
-  afterEach(() => {
-    vi.resetModules();
-    vi.doUnmock("child_process");
-    if (originalFfmpegPath === undefined) delete process.env.HYPERFRAMES_FFMPEG_PATH;
-    else process.env.HYPERFRAMES_FFMPEG_PATH = originalFfmpegPath;
-  });
-
-  it("spawns the configured absolute FFmpeg path when HYPERFRAMES_FFMPEG_PATH is set", async () => {
-    process.env.HYPERFRAMES_FFMPEG_PATH = "/tools/ffmpeg.exe";
-    const { spawn, calls } = createSpawnSpy();
-    vi.resetModules();
-    vi.doMock("child_process", () => ({ spawn }));
-
-    const { runFfmpeg } = await import("./runFfmpeg.js");
-    const result = await runFfmpeg(["-version"]);
-
-    expect(result.success).toBe(true);
-    expect(calls[0]).toEqual({ command: resolve("/tools/ffmpeg.exe"), args: ["-version"] });
-  });
-});

package/src/utils/runFfmpeg.ts

@@ -1,136 +0,0 @@
-// fallow-ignore-file code-duplication
-/**
- * Shared FFmpeg process runner.
- *
- * Extracts the repeated spawn-stderr-timeout-abort-close-error pattern
- * that appears across audioMixer and chunkEncoder into a single helper.
- */
-
-import { spawn } from "child_process";
-import { getFfmpegBinary } from "./ffmpegBinaries.js";
-import { trackChildProcess } from "./processTracker.js";
-
-export interface RunFfmpegOptions {
-  signal?: AbortSignal;
-  timeout?: number;
-  onStderr?: (line: string) => void;
-}
-
-export interface RunFfmpegResult {
-  success: boolean;
-  exitCode: number | null;
-  stderr: string;
-  durationMs: number;
-}
-
-const DEFAULT_TIMEOUT = 300_000;
-
-const DEFAULT_STDERR_TAIL_LINES = 15;
-
-function formatWindowsFfmpegExit(exitCode: number | null): string | undefined {
-  if (process.platform !== "win32" || exitCode === null) return undefined;
-  if (exitCode === 3221225595 || exitCode === -1073741701) {
-    return (
-      "[FFmpeg] Windows could not start ffmpeg.exe (STATUS_INVALID_IMAGE_FORMAT). " +
-      "The binary may be corrupted or the wrong architecture. Reinstall a 64-bit Windows FFmpeg build."
-    );
-  }
-  if (exitCode === 3221225794 || exitCode === -1073741502) {
-    return (
-      "[FFmpeg] Windows failed while initializing ffmpeg.exe. " +
-      "The binary may be corrupted, blocked, or missing runtime DLLs. Reinstall a 64-bit Windows FFmpeg build."
-    );
-  }
-  return undefined;
-}
-
-/**
- * Build a user-facing error message for a failed ffmpeg invocation.
- *
- * Historically we reported only `FFmpeg exited with code N`, which is useless
- * for diagnosing encoder-options failures — a rejected `-preset` surfaces as a
- * bare `code -22` with no hint at which argument ffmpeg objected to. Including
- * the tail of stderr turns those into a one-line signal (e.g.
- * `Error applying encoder options: Invalid argument`) that tells the caller
- * exactly which option to fix.
- */
-export function formatFfmpegError(
-  exitCode: number | null,
-  stderr: string,
-  tailLines: number = DEFAULT_STDERR_TAIL_LINES,
-): string {
-  const tail = (stderr ?? "")
-    .split(/\r?\n/)
-    .filter((line) => line.length > 0)
-    .slice(-tailLines)
-    .join("\n");
-  if (exitCode === null) {
-    return tail ? `[FFmpeg] ${tail}` : "[FFmpeg] process error";
-  }
-  const windowsMessage = formatWindowsFfmpegExit(exitCode);
-  if (windowsMessage) {
-    return tail ? `${windowsMessage}\nffmpeg stderr (tail):\n${tail}` : windowsMessage;
-  }
-  return tail
-    ? `FFmpeg exited with code ${exitCode}\nffmpeg stderr (tail):\n${tail}`
-    : `FFmpeg exited with code ${exitCode}`;
-}
-
-export async function runFfmpeg(args: string[], opts?: RunFfmpegOptions): Promise<RunFfmpegResult> {
-  const startMs = Date.now();
-  const signal = opts?.signal;
-  const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
-  const onStderr = opts?.onStderr;
-
-  return new Promise<RunFfmpegResult>((resolve) => {
-    const ffmpeg = spawn(getFfmpegBinary(), args);
-    trackChildProcess(ffmpeg);
-    let stderr = "";
-
-    const onAbort = () => {
-      ffmpeg.kill("SIGTERM");
-    };
-
-    if (signal) {
-      if (signal.aborted) {
-        ffmpeg.kill("SIGTERM");
-      } else {
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-    }
-
-    const timer = setTimeout(() => {
-      ffmpeg.kill("SIGTERM");
-    }, timeout);
-
-    ffmpeg.stderr.on("data", (data: Buffer) => {
-      const chunk = data.toString();
-      stderr += chunk;
-      if (onStderr) {
-        onStderr(chunk);
-      }
-    });
-
-    ffmpeg.on("close", (code) => {
-      clearTimeout(timer);
-      if (signal) signal.removeEventListener("abort", onAbort);
-      resolve({
-        success: !signal?.aborted && code === 0,
-        exitCode: code,
-        stderr,
-        durationMs: Date.now() - startMs,
-      });
-    });
-
-    ffmpeg.on("error", (err) => {
-      clearTimeout(timer);
-      if (signal) signal.removeEventListener("abort", onAbort);
-      resolve({
-        success: false,
-        exitCode: null,
-        stderr: err.message,
-        durationMs: Date.now() - startMs,
-      });
-    });
-  });
-}