negotium 0.5.0 → 0.5.2

package/dist/media.js

@@ -0,0 +1,547 @@
+// @bun
+// ../../packages/core/src/media/text-extractor.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { readFile } from "fs/promises";
+import { extname, join as join2 } from "path";
+import { promisify } from "util";
+
+// ../../packages/core/src/platform/config.ts
+import { execFileSync } from "child_process";
+import { randomBytes } from "crypto";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/core/src/platform/config-helpers.ts
+function readEnvText(env, key) {
+  const value = env[key]?.trim();
+  return value || undefined;
+}
+function parseRuntimePort(value, fallback) {
+  if (!value)
+    return fallback;
+  const port = Number.parseInt(value, 10);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
+}
+
+// ../../packages/core/src/platform/logger.ts
+import pino from "pino";
+function createStdioLogger(options = {}) {
+  const development = options.development ?? true;
+  return pino({
+    level: options.level ?? process.env.LOG_LEVEL ?? "info",
+    transport: development ? {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:yyyy-mm-dd HH:MM:ss",
+        destination: 2
+      }
+    } : undefined
+  }, pino.destination(2));
+}
+var logger = createStdioLogger();
+
+// ../../packages/core/src/types.ts
+var SUPPORTED_AGENTS = ["maestro", "claude", "codex"];
+function isAgentKind(value) {
+  return typeof value === "string" && SUPPORTED_AGENTS.includes(value);
+}
+
+// ../../packages/core/src/platform/config.ts
+function envText(envKey) {
+  return readEnvText(process.env, envKey);
+}
+function resolveAgentEnv(envKey, fallback, legacyEnvKey) {
+  const value = envText(envKey) ?? (legacyEnvKey ? envText(legacyEnvKey) : undefined);
+  return isAgentKind(value) ? value : fallback;
+}
+var HOME = homedir();
+function resolveProjectRoot() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const packagedRuntime = resolve(moduleDir, "runtime");
+  if (existsSync(resolve(packagedRuntime, "src")))
+    return packagedRuntime;
+  return resolve(moduleDir, "../..");
+}
+var PROJECT_ROOT = resolveProjectRoot();
+function resolveDependencyBin(name) {
+  let dir = PROJECT_ROOT;
+  while (true) {
+    const candidate = resolve(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return candidate;
+    dir = parent;
+  }
+}
+var STATE_DIR_ENV = envText("NEGOTIUM_STATE_DIR");
+var STATE_DIR = STATE_DIR_ENV ? resolve(STATE_DIR_ENV) : resolve(HOME, ".negotium");
+function resolveLocalStateDir(envKey, stateName) {
+  const envValue = envText(envKey);
+  if (envValue)
+    return resolve(envValue);
+  return resolve(STATE_DIR, stateName);
+}
+function parsePortEnv(envValue, fallback) {
+  return parseRuntimePort(envValue, fallback);
+}
+var WORKSPACE_DIR = resolveLocalStateDir("NEGOTIUM_WORKSPACE_DIR", "workspace");
+var TOPIC_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "topics");
+var SHARED_WIKI_DIR = resolve(WORKSPACE_DIR, "wiki");
+var CRON_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "cron");
+var BROWSER_DIR = resolveLocalStateDir("NEGOTIUM_BROWSER_DIR", "browser");
+var BROWSER_PROFILES_DIR = resolve(BROWSER_DIR, "profiles");
+var BINARIES_DIR = resolve(STATE_DIR, "binaries");
+var SECRETS_DIR = resolve(STATE_DIR, "secrets");
+var DM_WORKSPACE_DIR = resolve(STATE_DIR, "data", "dm");
+var SESSION_WORKSPACE_DIR = resolve(STATE_DIR, "data", "sessions");
+var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
+var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
+var BROWSER_RS_VERSION = "v0.1.23";
+var BROWSER_RS_MIN_SECURE_VERSION = "0.1.15";
+function versionAtLeast(actualVersion, minimumVersion) {
+  const actual = actualVersion.split(".").map(Number);
+  const minimum = minimumVersion.split(".").map(Number);
+  if (actual.some(Number.isNaN) || minimum.some(Number.isNaN))
+    return false;
+  for (let index = 0;index < minimum.length; index += 1) {
+    if ((actual[index] ?? 0) > (minimum[index] ?? 0))
+      return true;
+    if ((actual[index] ?? 0) < (minimum[index] ?? 0))
+      return false;
+  }
+  return true;
+}
+var BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000;
+function browserRsMeetsMinimumVersion(candidate) {
+  try {
+    const output = execFileSync(candidate, ["--version"], {
+      encoding: "utf8",
+      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+      return false;
+    return versionAtLeast(match.slice(1).join("."), BROWSER_RS_MIN_SECURE_VERSION);
+  } catch {
+    return false;
+  }
+}
+function resolveBrowserRsBin(envValue) {
+  const override = envValue?.trim();
+  if (!override && !versionAtLeast(BROWSER_RS_VERSION.replace(/^v/, ""), BROWSER_RS_MIN_SECURE_VERSION)) {
+    return;
+  }
+  const candidate = override ? resolve(override) : resolve(BINARIES_DIR, "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+  try {
+    accessSync(candidate, constants.X_OK);
+    return browserRsMeetsMinimumVersion(candidate) ? candidate : undefined;
+  } catch {
+    return;
+  }
+}
+var SNIPPETS_API_URL = (envText("NEGOTIUM_SNIPPETS_API_URL") ?? envText("SNIPPETS_API_URL") ?? "").replace(/\/+$/, "");
+var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
+var BASH_RS_VERSION = "v0.1.7";
+function resolveBashRsBin(envValue) {
+  const override = envValue?.trim();
+  const candidate = override ? resolve(override) : resolve(BINARIES_DIR, "bash-rs", BASH_RS_VERSION, "bash-rs");
+  try {
+    accessSync(candidate, constants.X_OK);
+    return candidate;
+  } catch {
+    return;
+  }
+}
+var BASH_RS_BIN = resolveBashRsBin(envText("NEGOTIUM_BASH_RS_BIN"));
+function resolveBrowserMcpBin(envValue) {
+  const override = envValue?.trim();
+  if (override)
+    return resolve(override);
+  return BROWSER_RS_BIN ?? resolve(BINARIES_DIR, "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+}
+var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
+var TSX_BIN = resolveDependencyBin("tsx");
+var TSX_LOADER = createRequire(import.meta.url).resolve("tsx");
+var TSCONFIG_PATH = resolve(PROJECT_ROOT, "tsconfig.json");
+var SESSION_COMM_SERVER = resolve(PROJECT_ROOT, "src/mcp/session-comm/server.ts");
+var TASK_SERVER = resolve(PROJECT_ROOT, "src/mcp/task-server.ts");
+var DECISION_SERVER = resolve(PROJECT_ROOT, "src/mcp/decision-server.ts");
+var CANONICAL_MCP_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/canonical-proxy-server.ts");
+var WIKI_SERVER = resolve(PROJECT_ROOT, "src/mcp/wiki-server.ts");
+var TOKEN_STATS_SERVER = resolve(PROJECT_ROOT, "src/mcp/token-stats-server.ts");
+var COMPACTION_LOG_SERVER = resolve(PROJECT_ROOT, "src/mcp/compaction-log-server.ts");
+var SYSTEM_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/system-health-server.ts");
+var AGENT_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/agent-health-server.ts");
+var VAULT_SERVER = resolve(PROJECT_ROOT, "src/mcp/vault-server.ts");
+var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
+var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
+function loadOrCreateLocalSecret(envKey, filename, options = {}) {
+  const envValue = envText(envKey);
+  const secretFile = resolve(SECRETS_DIR, filename);
+  mkdirSync(dirname(secretFile), { recursive: true });
+  if (envValue) {
+    if (options.persistEnvValue) {
+      writeFileSync(secretFile, `${envValue}
+`, { mode: 384 });
+      chmodSync(secretFile, 384);
+    }
+    return envValue;
+  }
+  if (existsSync(secretFile)) {
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (stored) {
+      chmodSync(secretFile, 384);
+      return stored;
+    }
+  }
+  const secret = randomBytes(32).toString("base64url");
+  try {
+    writeFileSync(secretFile, `${secret}
+`, { mode: 384, flag: "wx" });
+    return secret;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (!stored)
+      throw new Error(`Secret file exists but is empty: ${secretFile}`);
+    chmodSync(secretFile, 384);
+    return stored;
+  }
+}
+var RUNTIME_MCP_SECRET = loadOrCreateLocalSecret("RUNTIME_MCP_SECRET", "runtime-mcp-secret");
+var NODE_CONTROL_TOKEN = loadOrCreateLocalSecret("NEGOTIUM_CONTROL_TOKEN", "node-control-token");
+var NODE_ID = loadOrCreateLocalSecret("NEGOTIUM_NODE_ID", "node-id");
+var VAULT_MASTER_KEY = loadOrCreateLocalSecret("NEGOTIUM_VAULT_MASTER_KEY", "vault-master-key", { persistEnvValue: true });
+delete process.env.NEGOTIUM_VAULT_MASTER_KEY;
+var NEGOTIUM_PORT = parseInt(process.env.NEGOTIUM_PORT || "7777", 10);
+var hostname = process.env.HOSTNAME || "127.0.0.1";
+var DATA_DIR = resolveLocalStateDir("NEGOTIUM_DATA_DIR", "data");
+var LOG_DIR = resolveLocalStateDir("NEGOTIUM_LOG_DIR", "logs");
+var UPLOADS_DIR = resolve(DATA_DIR, "uploads");
+var VAULT_DIR = resolve(DATA_DIR, "vault");
+var SESSIONS_DB = process.env.SESSIONS_DB_PATH ? resolve(process.env.SESSIONS_DB_PATH) : resolve(DATA_DIR, "sessions.db");
+var DEBUG_FILE = resolve(DATA_DIR, "debug-users.json");
+var USERS_LOG_DIR = resolve(DATA_DIR, "users");
+var RUN_DIR = resolveLocalStateDir("NEGOTIUM_RUN_DIR", "runtime");
+var PROGRESS_DIR = resolve(RUN_DIR, "progress");
+var DM_CMD_DIR = resolve(RUN_DIR, "dm-commands");
+var DM_RESP_DIR = resolve(RUN_DIR, "dm-responses");
+var SESSION_INBOX_DIR = resolve(RUN_DIR, "session-inbox");
+var SESSION_ASKS_DIR = resolve(RUN_DIR, "session-asks");
+var BASHRS_SPILL_ROOT = resolve(RUN_DIR, "bashrs");
+var PLAYWRIGHT_BASE_PORT = parsePortEnv(process.env.PLAYWRIGHT_BASE_PORT, 9100);
+var PLAYWRIGHT_MAX_PORT = parsePortEnv(process.env.PLAYWRIGHT_MAX_PORT, 9499);
+var PLAYWRIGHT_PORTS_DIR = resolve(RUN_DIR, "playwright-ports");
+mkdirSync(STATE_DIR, { recursive: true });
+mkdirSync(DATA_DIR, { recursive: true });
+mkdirSync(UPLOADS_DIR, { recursive: true });
+mkdirSync(VAULT_DIR, { recursive: true, mode: 448 });
+mkdirSync(LOG_DIR, { recursive: true });
+mkdirSync(PROGRESS_DIR, { recursive: true });
+mkdirSync(DM_CMD_DIR, { recursive: true });
+mkdirSync(DM_RESP_DIR, { recursive: true });
+mkdirSync(SESSION_INBOX_DIR, { recursive: true });
+mkdirSync(SESSION_ASKS_DIR, { recursive: true });
+mkdirSync(PLAYWRIGHT_PORTS_DIR, { recursive: true });
+mkdirSync(WORKSPACE_DIR, { recursive: true });
+mkdirSync(TOPIC_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SHARED_WIKI_DIR, { recursive: true });
+mkdirSync(CRON_WORKSPACE_DIR, { recursive: true });
+mkdirSync(DM_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SESSION_WORKSPACE_DIR, { recursive: true });
+mkdirSync(BROWSER_DIR, { recursive: true });
+mkdirSync(BROWSER_PROFILES_DIR, { recursive: true });
+mkdirSync(BINARIES_DIR, { recursive: true });
+mkdirSync(SECRETS_DIR, { recursive: true, mode: 448 });
+var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
+var AGENTS_PROMPTS_DIR = resolve(PROJECT_ROOT, "src/prompts/agents");
+var RESOURCES_DIR = resolve(PROJECT_ROOT, "src/resources");
+var FALLBACK_AGENT = resolveAgentEnv("FALLBACK_AGENT", "maestro", "DEFAULT_AGENT");
+var SESSION_AGENT = resolveAgentEnv("SESSION_AGENT", FALLBACK_AGENT);
+var GATEWAY_AGENT = resolveAgentEnv("GATEWAY_AGENT", FALLBACK_AGENT);
+var FALLBACK_MODEL = envText("FALLBACK_MODEL") ?? envText("DEFAULT_MODEL");
+function resolveModelEnv(envKey, agentConst) {
+  return envText(envKey) ?? (agentConst === FALLBACK_AGENT ? FALLBACK_MODEL : undefined);
+}
+var SESSION_MODEL = resolveModelEnv("SESSION_MODEL", SESSION_AGENT);
+var GATEWAY_MODEL = resolveModelEnv("GATEWAY_MODEL", GATEWAY_AGENT);
+var FFMPEG_BIN = envText("FFMPEG_BIN");
+var FFPROBE_BIN = envText("FFPROBE_BIN");
+var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
+var FASTER_WHISPER_WRAPPER = envText("FASTER_WHISPER_WRAPPER") ?? resolve(PROJECT_ROOT, "scripts/faster-whisper-wrapper.py");
+var WHISPER_MODEL = envText("WHISPER_MODEL_FILE") ?? "turbo";
+var TESSERACT_BIN = envText("TESSERACT_BIN") ?? "tesseract";
+var PDFTOTEXT_BIN = envText("PDFTOTEXT_BIN") ?? "pdftotext";
+function resolveWhisperBackend() {
+  return envText("WHISPER_BACKEND") === "mlx-whisper" ? "mlx-whisper" : "faster-whisper";
+}
+var WHISPER_BACKEND = resolveWhisperBackend();
+var MLX_WHISPER_BIN = envText("MLX_WHISPER_BIN");
+var WHISPER_MODEL_MLX = envText("WHISPER_MODEL_MLX") ?? "mlx-community/whisper-large-v3-turbo";
+var _envMaxTellDepth = Number.parseInt(process.env.MAX_TELL_DEPTH ?? "", 10);
+var MAX_TELL_DEPTH = Number.isInteger(_envMaxTellDepth) && _envMaxTellDepth > 0 ? _envMaxTellDepth : 20;
+
+// ../../packages/core/src/platform/error.ts
+function errMsg(e, fallback) {
+  if (e instanceof Error)
+    return e.message;
+  return fallback ?? String(e);
+}
+
+// ../../packages/core/src/media/text-extractor.ts
+var execFileAsync = promisify(execFile);
+var FFMPEG_BIN2 = FFMPEG_BIN;
+var TEXT_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".csv",
+  ".tsv",
+  ".json",
+  ".jsonl",
+  ".xml",
+  ".html",
+  ".htm",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".log",
+  ".env",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".py",
+  ".rb",
+  ".go",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".rs",
+  ".swift",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".sql",
+  ".graphql",
+  ".proto",
+  ".css",
+  ".scss",
+  ".less",
+  ".sass",
+  ".r",
+  ".R",
+  ".m",
+  ".pl",
+  ".lua",
+  ".dart"
+]);
+var IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".webp"]);
+async function extractText(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (TEXT_EXTENSIONS.has(ext)) {
+    return extractFromTextFile(filePath);
+  }
+  if (ext === ".pdf") {
+    return extractFromPdf(filePath);
+  }
+  if (IMAGE_EXTENSIONS.has(ext)) {
+    return extractFromImage(filePath);
+  }
+  if ([
+    ".mp3",
+    ".wav",
+    ".ogg",
+    ".m4a",
+    ".flac",
+    ".aac",
+    ".wma",
+    ".mp4",
+    ".webm",
+    ".mkv",
+    ".avi",
+    ".mov"
+  ].includes(ext)) {
+    return extractFromAudio(filePath);
+  }
+  try {
+    const buf = await readFile(filePath);
+    if (buf.length === 0) {
+      return { text: null, method: "unsupported", error: "Empty file" };
+    }
+    const sample = buf.subarray(0, 8192);
+    let nonPrintable = 0;
+    for (let i = 0;i < sample.length; i++) {
+      const b = sample[i];
+      if (b < 32 && b !== 9 && b !== 10 && b !== 13)
+        nonPrintable++;
+    }
+    if (nonPrintable / sample.length > 0.1) {
+      return { text: null, method: "unsupported", error: "Binary file, cannot extract text" };
+    }
+    return { text: buf.toString("utf-8"), method: "text-read" };
+  } catch (e) {
+    logger.warn({ err: e, filePath, ext }, "Text extraction failed");
+    return { text: null, method: "unsupported", error: `Unsupported file type: ${ext}` };
+  }
+}
+function extractFromTextFile(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return { text: content, method: "text-read" };
+  } catch (e) {
+    return {
+      text: null,
+      method: "text-read",
+      error: `Failed to read: ${errMsg(e)}`
+    };
+  }
+}
+async function extractFromPdf(filePath) {
+  try {
+    const { stdout } = await execFileAsync(PDFTOTEXT_BIN, ["-layout", filePath, "-"], {
+      timeout: 30000
+    });
+    const text = stdout.trim();
+    if (!text) {
+      return {
+        text: null,
+        method: "pdf",
+        error: "PDF contains no extractable text (may be image-based)"
+      };
+    }
+    return { text, method: "pdf" };
+  } catch (e) {
+    logger.debug({ err: e, filePath }, "pdftotext failed");
+    return {
+      text: null,
+      method: "pdf",
+      error: `pdftotext failed: ${errMsg(e)}`
+    };
+  }
+}
+async function extractFromImage(filePath) {
+  try {
+    const { stdout } = await execFileAsync(TESSERACT_BIN, [filePath, "stdout", "-l", "kor+eng", "--psm", "3"], { timeout: 60000 });
+    const text = stdout.trim();
+    if (!text) {
+      return { text: null, method: "ocr", error: "OCR produced no text" };
+    }
+    return { text, method: "ocr" };
+  } catch (e) {
+    logger.debug({ err: e, filePath }, "tesseract OCR failed");
+    return {
+      text: null,
+      method: "ocr",
+      error: `OCR failed: ${errMsg(e)}`
+    };
+  }
+}
+function isTranscriptionConfigured(opts = {}) {
+  const ffmpeg = opts.ffmpegBin ?? FFMPEG_BIN;
+  if (!ffmpeg)
+    return false;
+  const backend = opts.backend ?? WHISPER_BACKEND;
+  if (backend === "mlx-whisper") {
+    return Boolean(opts.mlxWhisperBin ?? MLX_WHISPER_BIN);
+  }
+  const wrapper = opts.wrapperPath ?? FASTER_WHISPER_WRAPPER;
+  return existsSync2(wrapper);
+}
+async function transcribeAudio(filePath, opts = {}) {
+  if (!isTranscriptionConfigured(opts))
+    return null;
+  const result = await extractFromAudio(filePath, opts);
+  return result.text;
+}
+async function extractFromAudio(filePath, opts = {}) {
+  const tmpDir = `${filePath}_whisper_tmp`;
+  const backend = opts.backend ?? WHISPER_BACKEND;
+  try {
+    mkdirSync2(tmpDir, { recursive: true });
+    const mp3Path = join2(tmpDir, "audio.mp3");
+    await execFileAsync(opts.ffmpegBin ?? FFMPEG_BIN2, [
+      "-y",
+      "-i",
+      filePath,
+      "-acodec",
+      "libmp3lame",
+      "-q:a",
+      "4",
+      "-ac",
+      "1",
+      "-ar",
+      "16000",
+      mp3Path
+    ], { timeout: 60000 });
+    const whisperArgs = [
+      mp3Path,
+      "--model",
+      opts.model ?? (backend === "mlx-whisper" ? WHISPER_MODEL_MLX : WHISPER_MODEL),
+      "--language",
+      opts.language ?? "ko",
+      "--output-dir",
+      tmpDir,
+      "--output-format",
+      "txt"
+    ];
+    if (backend === "mlx-whisper") {
+      const mlxWhisperBin = opts.mlxWhisperBin ?? MLX_WHISPER_BIN;
+      if (!mlxWhisperBin) {
+        return { text: null, method: "whisper", error: "MLX_WHISPER_BIN not configured" };
+      }
+      await execFileAsync(mlxWhisperBin, whisperArgs, { timeout: 300000 });
+    } else {
+      await execFileAsync(opts.pythonBin ?? PYTHON_BIN, [opts.wrapperPath ?? FASTER_WHISPER_WRAPPER, ...whisperArgs], { timeout: 120000 });
+    }
+    const txtPath = join2(tmpDir, "audio.txt");
+    const text = existsSync2(txtPath) ? readFileSync2(txtPath, "utf-8").trim() : null;
+    if (!text) {
+      return { text: null, method: "whisper", error: "Whisper produced no text" };
+    }
+    return { text, method: "whisper" };
+  } catch (e) {
+    logger.debug({ err: e, filePath, backend }, "whisper extraction failed");
+    return {
+      text: null,
+      method: "whisper",
+      error: `Whisper failed: ${errMsg(e)}`
+    };
+  } finally {
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch (e) {
+      logger.warn({ err: e, tmpDir }, "Failed to cleanup whisper tmpDir");
+    }
+  }
+}
+export {
+  transcribeAudio,
+  isTranscriptionConfigured,
+  extractText
+};
+
+//# debugId=B9109C711A55200264756E2164756E21