@inetafrica/open-claudia 2.14.8 → 3.0.0

package/core/config.js

@@ -3,21 +3,17 @@
 
 const fs = require("fs");
 const path = require("path");
-const { execFileSync } = require("child_process");
-const CONFIG_DIR = require("../config-dir");
+const { resolveConfigDir, ensureConfigDir } = require("./config-dir");
+const { atomicWriteFileSync } = require("./fsutil");
 const { truthy: configTruthy } = require("../project-transcripts");
 
 const BOT_DIR = path.resolve(__dirname, "..");
+const CONFIG_DIR = resolveConfigDir();
 const ENV_PATH = path.join(CONFIG_DIR, ".env");
 
-function loadEnv() {
-  if (!fs.existsSync(ENV_PATH)) {
-    if (process.env.OPEN_CLAUDIA_TEST === "1") return { ...process.env };
-    console.error("No .env file found. Run: node setup.js");
-    process.exit(1);
-  }
-  const lines = fs.readFileSync(ENV_PATH, "utf-8").split("\n");
-  const env = { ...process.env };
+function parseEnvText(text) {
+  const env = {};
+  const lines = String(text || "").split(/\r?\n/);
   for (const line of lines) {
     const idx = line.indexOf("=");
     if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
@@ -25,8 +21,16 @@ function loadEnv() {
   return env;
 }
 
+function loadEnv(envPath = ENV_PATH, processEnvironment = process.env) {
+  const fileEnv = fs.existsSync(envPath)
+    ? parseEnvText(fs.readFileSync(envPath, "utf-8"))
+    : {};
+  return { ...processEnvironment, ...fileEnv };
+}
+
 function saveEnvKey(key, value) {
-  const content = fs.readFileSync(ENV_PATH, "utf-8");
+  ensureConfigDir(CONFIG_DIR);
+  const content = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, "utf-8") : "";
   const lines = content.split("\n");
   let found = false;
   const updated = lines.map((line) => {
@@ -34,7 +38,7 @@ function saveEnvKey(key, value) {
     return line;
   });
   if (!found) updated.push(`${key}=${value}`);
-  fs.writeFileSync(ENV_PATH, updated.join("\n"));
+  atomicWriteFileSync(ENV_PATH, updated.join("\n"), { backup: true, mode: 0o600 });
 }
 
 const config = loadEnv();
@@ -43,42 +47,73 @@ function hasPathSeparator(value) {
   return value.includes("/") || value.includes("\\");
 }
 
-function which(command) {
-  const lookup = process.platform === "win32" ? "where" : "which";
-  return execFileSync(lookup, [command], { encoding: "utf-8" })
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)[0] || null;
+const PROVIDER_COMMANDS = Object.freeze({ claude: "claude", codex: "codex" });
+const DEFAULT_PROVIDER = String(config.DEFAULT_PROVIDER || "").trim().toLowerCase() || null;
+const UTILITY_PROVIDER = String(config.UTILITY_PROVIDER || "active").trim().toLowerCase() || "active";
+const PROVIDER_FALLBACKS = Object.freeze(String(config.PROVIDER_FALLBACKS || "")
+  .split(",")
+  .map((value) => value.trim().toLowerCase())
+  .filter(Boolean));
+const UTILITY_PURPOSE_PROVIDERS = Object.freeze({
+  dream: String(config.DREAM_PROVIDER || "").trim().toLowerCase() || null,
+  introspection: String(config.DREAM_PROVIDER || "").trim().toLowerCase() || null,
+  review: String(config.MEMORY_PROVIDER || "").trim().toLowerCase() || null,
+  recall: String(config.RECALL_PROVIDER || "").trim().toLowerCase() || null,
+  enforcer: String(config.ENFORCER_PROVIDER || "").trim().toLowerCase() || null,
+  subagent: String(config.SUBAGENT_PROVIDER || "").trim().toLowerCase() || null,
+});
+
+function configuredProviderPath(providerId) {
+  if (providerId === "claude") return String(config.CLAUDE_PATH || "").trim() || null;
+  if (providerId === "codex") return String(config.CODEX_PATH || "").trim() || null;
+  throw Object.assign(new Error(`Unknown provider: ${providerId}`), { code: "UNKNOWN_PROVIDER" });
 }
 
-function resolveExecutablePath(configured, fallbackCommand, label, opts = {}) {
-  const raw = (configured || fallbackCommand || "").trim();
-  if (!raw) {
-    if (opts.required) {
-      console.error(`${label} not set`);
-      process.exit(1);
+function executableCandidate(command, env = process.env) {
+  if (!command) return null;
+  if (path.isAbsolute(command) || hasPathSeparator(command)) {
+    try {
+      fs.accessSync(command, fs.constants.X_OK);
+      return path.resolve(command);
+    } catch (error) {
+      return null;
     }
-    return null;
   }
-
-  if (path.isAbsolute(raw) || hasPathSeparator(raw)) {
-    if (fs.existsSync(raw)) return raw;
-    if (opts.required) {
-      console.error(`${label} not found at: ${raw}`);
-      process.exit(1);
+  const suffixes = process.platform === "win32"
+    ? String(env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")
+    : [""];
+  for (const directory of String(env.PATH || "").split(path.delimiter).filter(Boolean)) {
+    for (const suffix of suffixes) {
+      const candidate = path.join(directory, process.platform === "win32" ? command + suffix : command);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch (error) { /* continue */ }
     }
-    return null;
   }
+  return null;
+}
 
-  try {
-    return which(raw);
-  } catch (e) {
-    if (opts.required) {
-      console.error(`${label} not found on PATH: ${raw}`);
-      process.exit(1);
-    }
-    return null;
+function resolveExecutablePath(configured, fallbackCommand, _label, _opts = {}) {
+  const raw = (configured || fallbackCommand || "").trim();
+  return raw ? executableCandidate(raw) : null;
+}
+
+function discoverProviderExecutable(providerId, env = process.env) {
+  const configured = configuredProviderPath(providerId);
+  return executableCandidate(configured || PROVIDER_COMMANDS[providerId], env);
+}
+
+function providerExecutableStatus(providerId, env = process.env) {
+  const configured = configuredProviderPath(providerId);
+  const executable = discoverProviderExecutable(providerId, env);
+  if (executable) {
+    return { state: "available", executable, configured: !!configured, reason: null };
+  }
+  if (configured) {
+    return { state: "missing", executable: null, configured: true, reason: `Configured ${providerId} executable was not found` };
   }
+  return { state: "unconfigured", executable: null, configured: false, reason: `${providerId} is not configured or installed` };
 }
 
 // Telegram (kept for backwards compat — channels list defaults to telegram)
@@ -86,11 +121,9 @@ const TOKEN = config.TELEGRAM_BOT_TOKEN;
 const CHAT_IDS = (config.TELEGRAM_CHAT_ID || "").split(",").map((s) => s.trim()).filter(Boolean);
 const CHAT_ID = CHAT_IDS[0];
 
-const WORKSPACE = config.WORKSPACE;
-const CLAUDE_PATH = resolveExecutablePath(config.CLAUDE_PATH, null, "Claude CLI", { required: true });
-const CURSOR_PATH = config.CURSOR_PATH || null;
+const WORKSPACE = config.WORKSPACE || null;
+const CLAUDE_PATH = configuredProviderPath("claude");
 const CODEX_PATH = config.CODEX_PATH || null;
-const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-opus-4-8";
 const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "380000", 10);
 const MIN_COMPACT_INTERVAL_MS = parseInt(config.MIN_COMPACT_INTERVAL_MS || process.env.MIN_COMPACT_INTERVAL_MS || "1800000", 10);
 const PROJECT_TRANSCRIPTS = configTruthy(config.PROJECT_TRANSCRIPTS || process.env.PROJECT_TRANSCRIPTS, true);
@@ -129,31 +162,22 @@ const MAX_VOICE_SIZE = 10 * 1024 * 1024;
 const MAX_PROCESS_TIMEOUT = 360 * 60 * 1000;
 const COMPACT_SUMMARY_TIMEOUT = 10 * 60 * 1000;
 
-if (!WORKSPACE) { console.error("WORKSPACE not set"); process.exit(1); }
+// Compatibility values for the pre-registry runner. They contain only an
+// explicitly configured command; fallback PATH discovery remains lazy through
+// discoverProviderExecutable().
+const resolvedCodexPath = CODEX_PATH;
 
-if (!fs.existsSync(WORKSPACE)) {
-  try {
-    fs.mkdirSync(WORKSPACE, { recursive: true });
-    console.error(`Created workspace: ${WORKSPACE}`);
-  } catch (e) {
-    console.error(`Failed to create workspace: ${e.message}`);
-    process.exit(1);
+function ensureRuntimeDirectories() {
+  ensureConfigDir(CONFIG_DIR);
+  for (const directory of [WORKSPACE, TEMP_DIR, FILES_DIR]) {
+    if (directory) fs.mkdirSync(directory, { recursive: true });
   }
+  return { configDir: CONFIG_DIR, workspace: WORKSPACE, tempDir: TEMP_DIR, filesDir: FILES_DIR };
 }
 
-let resolvedCursorPath = resolveExecutablePath(CURSOR_PATH, "agent", "Cursor Agent CLI");
-if (resolvedCursorPath) console.error(`Cursor Agent CLI: ${resolvedCursorPath}`);
-
-let resolvedCodexPath = resolveExecutablePath(CODEX_PATH, "codex", "Codex CLI");
-if (resolvedCodexPath) console.error(`Codex CLI: ${resolvedCodexPath}`);
-
-if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
-if (!fs.existsSync(FILES_DIR)) fs.mkdirSync(FILES_DIR, { recursive: true });
-
 const FULL_PATH = [
-  path.dirname(CLAUDE_PATH),
-  resolvedCursorPath ? path.dirname(resolvedCursorPath) : null,
-  resolvedCodexPath ? path.dirname(resolvedCodexPath) : null,
+  CLAUDE_PATH && hasPathSeparator(CLAUDE_PATH) ? path.dirname(CLAUDE_PATH) : null,
+  resolvedCodexPath && hasPathSeparator(resolvedCodexPath) ? path.dirname(resolvedCodexPath) : null,
   path.dirname(process.execPath),
   FFMPEG ? path.dirname(FFMPEG) : null,
   WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
@@ -161,7 +185,8 @@ const FULL_PATH = [
     ? [process.env.APPDATA, process.env.LOCALAPPDATA].filter(Boolean).map((p) => path.join(p, "npm"))
     : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
   ),
-].filter(Boolean).join(path.delimiter);
+  ...String(process.env.PATH || "").split(path.delimiter),
+].filter(Boolean).filter((value, index, values) => values.indexOf(value) === index).join(path.delimiter);
 
 // Kazee runs on one fixed host — like Telegram's api.telegram.org it's
 // infrastructure, not a per-user setting. Hard-coded so onboarding only asks
@@ -229,30 +254,63 @@ function loadChannels() {
   return channels;
 }
 
+// The bot's own control-plane secrets. No subprocess the bot spawns — the
+// Claude/Codex CLIs, sub-agents, the recall walker, tools, and auth flows —
+// ever needs these: the model CLI is authed via CLAUDE_CODE_OAUTH_TOKEN (added
+// on top by claudeSubprocessEnv) or its own API key, and `open-claudia` CLI
+// invocations re-read the .env file from disk. Stripping them from the ambient
+// subprocess env closes the easiest exfil path — a prompt-injected agent (or any
+// child) dumping its own environment can no longer read the bot's Telegram/Kazee
+// tokens or the web control token.
+const CONFINED_SECRET_KEYS = ["TELEGRAM_BOT_TOKEN", "KAZEE_BOT_TOKEN", "BOT_CONTROL_TOKEN"];
+
 function botSubprocessEnv() {
   // Credential confinement (5b): the operational keyring is deliberately NOT
   // merged here. Agent shells, sub-agents, and every other bot subprocess run
   // cred-free; keyring values enter ONLY tool-run subprocesses (tools.runEnv —
   // the keys a tool declares via --requires) and the logged escape hatch
   // (`keyring exec --reason`). See core/tool-guard.js for the deny-gate half.
-  return { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+  const env = { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+  for (const k of CONFINED_SECRET_KEYS) delete env[k];
+  return env;
+}
+
+// Source material for provider-specific allowlist builders. This may contain
+// sensitive config values; core/providers/env.js always reduces and scrubs it
+// before a provider process receives anything.
+function agentEnvSource() {
+  return {
+    ...process.env,
+    ...config,
+    PATH: FULL_PATH,
+    HOME: process.env.HOME || require("os").homedir(),
+  };
 }
 
 module.exports = {
   config,
+  parseEnvText,
+  loadEnv,
   saveEnvKey,
   loadChannels,
   botSubprocessEnv,
+  agentEnvSource,
+  configuredProviderPath,
+  discoverProviderExecutable,
+  providerExecutableStatus,
+  resolveExecutablePath,
+  DEFAULT_PROVIDER,
+  UTILITY_PROVIDER,
+  PROVIDER_FALLBACKS,
+  UTILITY_PURPOSE_PROVIDERS,
+  ensureRuntimeDirectories,
   KAZEE_DEFAULT_URL,
   BOT_DIR,
   CONFIG_DIR,
   TOKEN, CHAT_IDS, CHAT_ID,
   WORKSPACE,
   CLAUDE_PATH,
-  DEFAULT_CLAUDE_MODEL,
-  CURSOR_PATH,
   CODEX_PATH,
-  resolvedCursorPath,
   resolvedCodexPath,
   AUTO_COMPACT_TOKENS,
   MIN_COMPACT_INTERVAL_MS,

package/core/doctor.js

@@ -2,40 +2,21 @@
 // before the user spends time on a task that's going to fail anyway.
 
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
-const { execSync } = require("child_process");
+const { execFileSync } = require("child_process");
 const {
-  CLAUDE_PATH, CURSOR_PATH, CODEX_PATH, resolvedCursorPath, resolvedCodexPath,
   WHISPER_CLI, WHISPER_MODEL, FFMPEG, WORKSPACE, CONFIG_DIR,
   botSubprocessEnv,
 } = require("./config");
-const { redactSensitive, stripTerminalControls } = require("./redact");
-const { isClaudeAuthErrorText, isCodexAuthErrorText, claudeSubprocessEnv } = require("./auth-flow");
-
-function shellQuote(value) {
-  return `"${String(value).replace(/"/g, '\\"')}"`;
-}
-
-function runCommandForDoctor(command, args = [], opts = {}) {
-  try {
-    const out = execSync([command, ...args].map(shellQuote).join(" "), {
-      cwd: opts.cwd || process.env.HOME || require("os").homedir(),
-      env: opts.env || botSubprocessEnv(),
-      encoding: "utf-8",
-      timeout: opts.timeout || 10000,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    return { ok: true, output: out.trim(), code: 0 };
-  } catch (e) {
-    return { ok: false, output: `${e.stdout || ""}\n${e.stderr || ""}\n${e.message || ""}`.trim(), code: e.status ?? 1 };
-  }
-}
+const { redactSensitive } = require("./redact");
+const { inspectProviderConfiguration } = require("./provider-status");
 
 function binaryCheck(binPath, name) {
   if (!binPath) return { ok: false, label: name, detail: "not configured/found" };
   try {
     if (fs.existsSync(binPath)) fs.accessSync(binPath, fs.constants.X_OK);
-    else execSync(process.platform === "win32" ? `where ${shellQuote(binPath)}` : `which ${shellQuote(binPath)}`, { stdio: "ignore", env: botSubprocessEnv() });
+    else execFileSync(process.platform === "win32" ? "where" : "which", [String(binPath)], { stdio: "ignore", env: botSubprocessEnv() });
     return { ok: true, label: name, detail: binPath };
   } catch (e) {
     return { ok: false, label: name, detail: `not executable: ${binPath}` };
@@ -55,46 +36,119 @@ function checkWritableDir(dirPath, label) {
   }
 }
 
-function summarize(output, ok) {
-  const clean = redactSensitive(stripTerminalControls(output || "")).replace(/\s+/g, " ").trim();
-  if (!clean) return ok ? "ok" : "no output";
-  return clean.length > 160 ? clean.slice(0, 157) + "..." : clean;
+function defaultCodexHookProbe({ binary }) {
+  const { prepareCodexHook, probeCodexHookCompatibility } = require("./providers/codex-hook");
+  const { codexSubprocessEnv } = require("./auth-flow");
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-hook-probe-"));
+  try {
+    return probeCodexHookCompatibility({
+      binary,
+      prepared: prepareCodexHook({ cwd: temp }),
+      cwd: temp,
+      markerFile: path.join(temp, "probe.marker"),
+      auditFile: path.join(temp, "probe-audit.jsonl"),
+      env: codexSubprocessEnv(),
+      // A real model turn, not a fixture: allow for slow first-token latency.
+      timeoutMs: 45000,
+    });
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
 }
 
-function runDoctorChecks() {
+function codexHookEnforcementCheck(providerSummary, options) {
+  const label = "Codex tool-hook enforcement (live probe)";
+  const codex = providerSummary.providers.find((provider) => provider.id === "codex");
+  const ready = codex
+    && codex.availability.state === "available"
+    && codex.compatibility.state === "compatible"
+    && codex.auth.state === "authenticated";
+  if (!ready) {
+    return {
+      ok: true,
+      warn: true,
+      label,
+      detail: codex
+        ? `skipped — codex not ready (${codex.availability.state}/${codex.compatibility.state}/${codex.auth.state})`
+        : "skipped — codex is not registered",
+      action: "",
+    };
+  }
+  const runProbe = options.runCodexHookProbe || defaultCodexHookProbe;
+  try {
+    const probe = runProbe({ binary: codex.availability.executable });
+    return probe.ok
+      ? { ok: true, label, detail: "deny rule enforced end-to-end against the real CLI" }
+      : {
+          ok: false,
+          label,
+          detail: redactSensitive(probe.diagnostic || "probe failed"),
+          action: "Do not run Codex tasks until this passes — update the Codex CLI and re-run /doctor.",
+        };
+  } catch (e) {
+    return {
+      ok: false,
+      label,
+      detail: redactSensitive(e.message),
+      action: "Do not run Codex tasks until this passes — update the Codex CLI and re-run /doctor.",
+    };
+  }
+}
+
+function runDoctorChecks(options = {}) {
   const checks = [];
   const nodeMajor = parseInt(process.version.slice(1).split(".")[0], 10);
   checks.push({ ok: nodeMajor >= 18, label: "Node.js", detail: process.version, action: nodeMajor >= 18 ? "" : "Install Node.js 18+." });
 
-  const claudeBin = binaryCheck(CLAUDE_PATH, "Claude CLI");
-  if (claudeBin.ok) {
-    const ver = runCommandForDoctor(CLAUDE_PATH, ["--version"]);
-    const auth = runCommandForDoctor(CLAUDE_PATH, ["auth", "status"], { env: claudeSubprocessEnv(), timeout: 12000 });
-    checks.push({ ok: ver.ok, label: "Claude version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CLAUDE_PATH." });
-    checks.push({ ok: auth.ok && !isClaudeAuthErrorText(auth.output), label: "Claude auth", detail: summarize(auth.output, auth.ok), action: auth.ok && !isClaudeAuthErrorText(auth.output) ? "" : "Run /auth_status then /setup_token or /login." });
-  } else checks.push({ ...claudeBin, action: "Install @anthropic-ai/claude-code or fix CLAUDE_PATH." });
-
-  if (CURSOR_PATH || resolvedCursorPath) {
-    const cursorPath = resolvedCursorPath || CURSOR_PATH;
-    const cursorBin = binaryCheck(cursorPath, "Cursor Agent");
-    if (cursorBin.ok) {
-      const ver = runCommandForDoctor(cursorPath, ["--version"]);
-      const status = runCommandForDoctor(cursorPath, ["status"], { timeout: 12000 });
-      checks.push({ ok: ver.ok, label: "Cursor version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CURSOR_PATH." });
-      checks.push({ ok: status.ok, label: "Cursor auth/status", detail: summarize(status.output, status.ok), action: status.ok ? "" : "Run `agent login` on this host." });
-    } else checks.push({ ...cursorBin, action: "Install Cursor Agent or fix CURSOR_PATH." });
-  } else checks.push({ ok: true, warn: true, label: "Cursor Agent", detail: "not configured/found (optional)", action: "Install only if you want /cursor." });
+  const providerSummary = inspectProviderConfiguration({
+    registry: options.registry,
+    executableStatus: options.executableStatus,
+    probeAuth: options.probeAuth !== false,
+  });
+  for (const provider of providerSummary.providers) {
+    const available = provider.availability.state === "available";
+    const compatible = provider.compatibility.state === "compatible";
+    const authenticated = provider.auth.state === "authenticated";
+    checks.push({
+      ok: available,
+      warn: !available,
+      label: `${provider.label} availability`,
+      detail: available ? provider.availability.executable : provider.availability.state,
+      action: available ? "" : provider.recovery,
+    });
+    checks.push({
+      ok: available && compatible,
+      warn: !available || !compatible,
+      label: `${provider.label} compatibility`,
+      detail: provider.compatibility.version
+        ? `${provider.compatibility.state} (${provider.compatibility.version})`
+        : provider.compatibility.state,
+      action: available && !compatible ? provider.recovery : "",
+    });
+    checks.push({
+      ok: available && compatible && authenticated,
+      warn: !available || !compatible || !authenticated,
+      label: `${provider.label} auth`,
+      detail: provider.auth.state,
+      action: available && compatible && !authenticated ? provider.recovery : "",
+    });
+  }
+  // The live hook probe drives a real `codex exec` model turn (tokens,
+  // seconds), so it is strictly opt-in: only user-invoked /doctor passes it.
+  // Boot, health, and setup surfaces must never spawn a model prompt.
+  if (options.probeCodexHook === true) {
+    checks.push(codexHookEnforcementCheck(providerSummary, options));
+  }
 
-  if (CODEX_PATH || resolvedCodexPath) {
-    const codexPath = resolvedCodexPath || CODEX_PATH;
-    const codexBin = binaryCheck(codexPath, "Codex CLI");
-    if (codexBin.ok) {
-      const ver = runCommandForDoctor(codexPath, ["--version"]);
-      const status = runCommandForDoctor(codexPath, ["login", "status"], { timeout: 12000 });
-      checks.push({ ok: ver.ok, label: "Codex version", detail: summarize(ver.output, ver.ok), action: ver.ok ? "" : "Check CODEX_PATH." });
-      checks.push({ ok: status.ok && !isCodexAuthErrorText(status.output), label: "Codex auth", detail: summarize(status.output, status.ok), action: status.ok && !isCodexAuthErrorText(status.output) ? "" : "Run /codex_login or /codex_setup_token." });
-    } else checks.push({ ...codexBin, action: "Install @openai/codex or fix CODEX_PATH." });
-  } else checks.push({ ok: true, warn: true, label: "Codex CLI", detail: "not configured/found (optional)", action: "Install only if you want /codex." });
+  checks.push({
+    ok: !!providerSummary.defaultProvider.providerId,
+    warn: !providerSummary.defaultProvider.providerId,
+    label: "Default provider",
+    detail: providerSummary.defaultProvider.label
+      ? `${providerSummary.defaultProvider.label} (${providerSummary.defaultProvider.source})`
+      : "none",
+    action: providerSummary.defaultProvider.providerId ? "" : providerSummary.defaultProvider.reason,
+  });
 
   if (FFMPEG || WHISPER_CLI || WHISPER_MODEL) {
     const ff = binaryCheck(FFMPEG || "ffmpeg", "ffmpeg");