@exulu/backend 1.60.0 → 1.61.1

package/dist/cli/start-whisper.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  getPackageRoot
+} from "../chunk-IDHS2BZO.js";
+
+// src/cli/start-whisper.ts
+import "dotenv/config";
+
+// src/exulu/transcription/supervisor.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+var MAX_CRASHES = 5;
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e4;
+var READY_TIMEOUT_MS = 30 * 6e4;
+var READY_POLL_INTERVAL_MS = 500;
+var SHUTDOWN_GRACE_MS = 5e3;
+var internal = {
+  child: void 0,
+  state: "idle",
+  crashCount: 0,
+  backoffMs: INITIAL_BACKOFF_MS,
+  readyPromise: void 0,
+  shutdownRequested: false
+};
+var resolveConfig = (packageRoot) => {
+  const host = process.env.WHISPER_HOST ?? "127.0.0.1";
+  const port = process.env.WHISPER_PORT ?? "9876";
+  const venvBin = resolve(packageRoot, "ee/python/.venv/bin");
+  const venvPython = resolve(venvBin, "python");
+  const cwd = resolve(packageRoot, "ee/python/transcription");
+  return { host, port, venvBin, venvPython, cwd };
+};
+var log = (line) => {
+  const text = line.startsWith("[EXULU-WHISPER]") ? line : `[EXULU-WHISPER] ${line}`;
+  console.log(text);
+};
+var pollHealth = async (host, port) => {
+  const url = `http://${host}:${port}/healthz`;
+  const deadline = Date.now() + READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { method: "GET" });
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, READY_POLL_INTERVAL_MS));
+  }
+  throw new Error(
+    `Whisper server did not become ready at ${url} within ${READY_TIMEOUT_MS}ms`
+  );
+};
+var spawnWhisper = (cfg) => {
+  log(
+    `Spawning: ${cfg.venvPython} -m uvicorn server:app --host ${cfg.host} --port ${cfg.port}`
+  );
+  const child = spawn(
+    cfg.venvPython,
+    [
+      "-m",
+      "uvicorn",
+      "server:app",
+      "--host",
+      cfg.host,
+      "--port",
+      cfg.port,
+      "--log-level",
+      "info"
+    ],
+    {
+      cwd: cfg.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    }
+  );
+  child.stdout?.on("data", (chunk) => {
+    chunk.toString().split("\n").filter((l) => l.length > 0).forEach((l) => log(l));
+  });
+  child.stderr?.on("data", (chunk) => {
+    chunk.toString().split("\n").filter((l) => l.length > 0).forEach((l) => log(`stderr: ${l}`));
+  });
+  return child;
+};
+var supervise = async (cfg) => {
+  while (!internal.shutdownRequested && internal.crashCount < MAX_CRASHES) {
+    internal.state = internal.crashCount === 0 ? "starting" : "respawning";
+    internal.child = spawnWhisper(cfg);
+    const exitPromise = new Promise((resolveFn) => {
+      internal.child.on("exit", (code2) => resolveFn(code2));
+    });
+    try {
+      await Promise.race([
+        pollHealth(cfg.host, cfg.port).then(() => "ready"),
+        exitPromise.then((code2) => ({ exited: code2 }))
+      ]);
+    } catch (err) {
+      log(`Readiness probe failed: ${err.message}`);
+      try {
+        internal.child?.kill("SIGTERM");
+      } catch {
+      }
+    }
+    if (!internal.child?.killed && internal.child?.exitCode === null) {
+      internal.state = "ready";
+      internal.crashCount = 0;
+      internal.backoffMs = INITIAL_BACKOFF_MS;
+      log("Whisper server is ready.");
+    }
+    const code = await exitPromise;
+    internal.state = "respawning";
+    internal.child = void 0;
+    if (internal.shutdownRequested) {
+      log("Child exited during shutdown; supervisor stopping.");
+      internal.state = "stopped";
+      return;
+    }
+    internal.crashCount += 1;
+    log(
+      `Whisper server exited (code=${code}). Crash ${internal.crashCount}/${MAX_CRASHES}. Respawning in ${internal.backoffMs}ms.`
+    );
+    if (internal.crashCount >= MAX_CRASHES) {
+      log(
+        "Whisper server keeps crashing \u2014 fix the install (try `npx @exulu/backend setup-python --force`) and re-run `npx @exulu/backend exulu-start-whisper`. Giving up."
+      );
+      internal.state = "given_up";
+      return;
+    }
+    await new Promise((r) => setTimeout(r, internal.backoffMs));
+    internal.backoffMs = Math.min(internal.backoffMs * 2, MAX_BACKOFF_MS);
+  }
+};
+var startWhisperSupervisor = async (options) => {
+  if (internal.readyPromise) {
+    return internal.readyPromise;
+  }
+  const cfg = resolveConfig(options.packageRoot);
+  if (!existsSync(cfg.venvPython)) {
+    throw new Error(
+      `Whisper supervisor: Python venv not found at ${cfg.venvPython}. Run \`npx @exulu/backend setup-python\` first.`
+    );
+  }
+  if (!existsSync(cfg.cwd)) {
+    throw new Error(
+      `Whisper supervisor: transcription scripts not found at ${cfg.cwd}. The @exulu/backend package may be corrupt; reinstall it.`
+    );
+  }
+  internal.readyPromise = (async () => {
+    supervise(cfg);
+    const deadline = Date.now() + READY_TIMEOUT_MS + 5e3;
+    while (Date.now() < deadline) {
+      if (internal.state === "ready") return;
+      if (internal.state === "given_up") {
+        throw new Error("Whisper supervisor gave up before becoming ready.");
+      }
+      await new Promise((r) => setTimeout(r, READY_POLL_INTERVAL_MS));
+    }
+    throw new Error("Timed out waiting for whisper supervisor readiness.");
+  })();
+  registerShutdownHandlers();
+  return internal.readyPromise;
+};
+var stopWhisper = (signal = "SIGTERM") => {
+  internal.shutdownRequested = true;
+  const child = internal.child;
+  if (!child) return;
+  try {
+    child.kill(signal);
+  } catch {
+  }
+  setTimeout(() => {
+    try {
+      if (!child.killed && child.exitCode === null) {
+        child.kill("SIGKILL");
+      }
+    } catch {
+    }
+  }, SHUTDOWN_GRACE_MS).unref();
+};
+var shutdownHandlersRegistered = false;
+var registerShutdownHandlers = () => {
+  if (shutdownHandlersRegistered) return;
+  shutdownHandlersRegistered = true;
+  process.on("SIGINT", () => stopWhisper("SIGTERM"));
+  process.on("SIGTERM", () => stopWhisper("SIGTERM"));
+  process.on("exit", () => stopWhisper("SIGTERM"));
+};
+
+// src/cli/start-whisper.ts
+var main = async () => {
+  const packageRoot = getPackageRoot();
+  try {
+    await startWhisperSupervisor({ packageRoot });
+  } catch (err) {
+    console.error(`[EXULU-WHISPER] ${err.message}`);
+    process.exit(1);
+  }
+  await new Promise(() => {
+  });
+};
+main().catch((err) => {
+  console.error(`[EXULU-WHISPER] Unexpected error: ${err.stack ?? err}`);
+  process.exit(1);
+});

package/dist/{convert-exulu-tools-to-ai-sdk-tools-PLLM2CJL.js → convert-exulu-tools-to-ai-sdk-tools-CULC37U6.js}

@@ -1,6 +1,6 @@
 import {
   convertExuluToolsToAiSdkTools
-} from "./chunk-23YNGK3V.js";
+} from "./chunk-MPV7HBV6.js";
 export {
   convertExuluToolsToAiSdkTools
 };