@inetafrica/open-claudia 2.15.0 → 3.0.1

package/core/approvals.js

@@ -18,9 +18,15 @@ const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
 const CONFIG_DIR = require("../config-dir");
+const { atomicWriteFileSync } = require("./fsutil");
 
 const APPROVALS_DIR = process.env.APPROVALS_DIR || path.join(CONFIG_DIR, "approvals");
 const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const LOCK_STALE_MS = 30 * 1000;
+const LOCK_WAIT = new Int32Array(new SharedArrayBuffer(4));
+// Both approval UIs render the complete command. Keeping this comfortably
+// below chat message limits prevents an unseen suffix from being approved.
+const MAX_COMMAND_BYTES = 512;
 
 function fileOf(id) {
   const base = path.basename(String(id || "").trim());
@@ -28,13 +34,71 @@ function fileOf(id) {
   return path.join(APPROVALS_DIR, `${base}.json`);
 }
 
+function commandHash(command) {
+  return crypto.createHash("sha256").update(String(command || "")).digest("hex");
+}
+
+function approvedCommand(command) {
+  const value = String(command || "");
+  if (Buffer.byteLength(value) > MAX_COMMAND_BYTES) {
+    const error = new Error(`approval command exceeds ${MAX_COMMAND_BYTES} bytes`);
+    error.code = "APPROVAL_PAYLOAD_TOO_LARGE";
+    throw error;
+  }
+  return value;
+}
+
+function quoteArg(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'"'"'`)}'`;
+}
+
+function formatApprovedCommand(argv) {
+  if (!Array.isArray(argv) || argv.some((arg) => typeof arg !== "string")) {
+    const error = new TypeError("approved command argv must be an array of strings");
+    error.code = "INVALID_APPROVAL_COMMAND";
+    throw error;
+  }
+  return argv.map(quoteArg).join(" ");
+}
+
+function writeRecord(rec) {
+  atomicWriteFileSync(fileOf(rec.id), `${JSON.stringify(rec, null, 2)}\n`, { mode: 0o600 });
+}
+
+function acquireRecordLock(id) {
+  let lock;
+  try { lock = `${fileOf(id)}.lock`; } catch (_) { return null; }
+  for (let attempt = 0; attempt < 21; attempt += 1) {
+    try { return { fd: fs.openSync(lock, "wx", 0o600), lock }; }
+    catch (error) {
+      if (error.code !== "EEXIST") return null;
+      try {
+        if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+          fs.rmSync(lock, { force: true });
+          continue;
+        }
+      } catch (_) { continue; }
+      Atomics.wait(LOCK_WAIT, 0, 0, 5);
+    }
+  }
+  return null;
+}
+
+function releaseRecordLock(held) {
+  if (!held) return;
+  try { fs.closeSync(held.fd); } catch (_) {}
+  try { fs.rmSync(held.lock, { force: true }); } catch (_) {}
+}
+
 // Best-effort GC so decided/expired records don't accumulate forever.
 function prune() {
   let entries;
   try { entries = fs.readdirSync(APPROVALS_DIR); } catch (e) { return; }
   const cutoff = Date.now() - MAX_AGE_MS;
   for (const f of entries) {
-    if (!f.endsWith(".json")) continue;
+    if (!f.endsWith(".json") && !f.endsWith(".lock")) continue;
     const p = path.join(APPROVALS_DIR, f);
     try { if (fs.statSync(p).mtimeMs < cutoff) fs.rmSync(p, { force: true }); } catch (e) {}
   }
@@ -49,6 +113,8 @@ function prune() {
 // `target*` external channel, and person/entity pointers for Always-allow.
 function create({
   tool, verb = "", tier = "destructive", command = "", channelId = "", adapter = "",
+  canonicalUserId = "", userId = "", provider = "", providerSettings = {},
+  project = "", projectDir = "", sessionId = "", previousSessionId = "", originRunId = "",
   kind = "tool", approverAdapter = "", approverChannel = "",
   payloadText = "", targetAdapter = "", targetChannel = "",
   personName = "", personId = "", entitySlug = "",
@@ -56,11 +122,18 @@ function create({
   fs.mkdirSync(APPROVALS_DIR, { recursive: true, mode: 0o700 });
   prune();
   const id = `apr_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+  const exactCommand = approvedCommand(command);
   const rec = {
     id, status: "pending",
     tool: String(tool || ""), verb: String(verb || ""), tier: String(tier || ""),
-    command: String(command || "").slice(0, 1000),
+    command: exactCommand,
+    commandHash: commandHash(exactCommand),
     channelId: String(channelId || ""), adapter: String(adapter || ""),
+    canonicalUserId: String(canonicalUserId || ""), userId: String(userId || ""),
+    provider: String(provider || ""), providerSettings: providerSettings && typeof providerSettings === "object" ? structuredClone(providerSettings) : {},
+    project: String(project || ""), projectDir: String(projectDir || ""),
+    sessionId: String(sessionId || ""), previousSessionId: String(previousSessionId || ""),
+    originRunId: String(originRunId || ""),
     kind: String(kind || "tool"),
     approverAdapter: String(approverAdapter || ""), approverChannel: String(approverChannel || ""),
     payloadText: String(payloadText || "").slice(0, 4000),
@@ -68,7 +141,7 @@ function create({
     personName: String(personName || ""), personId: String(personId || ""), entitySlug: String(entitySlug || ""),
     requestedAt: new Date().toISOString(),
   };
-  fs.writeFileSync(fileOf(id), JSON.stringify(rec, null, 2), { mode: 0o600 });
+  writeRecord(rec);
   return rec;
 }
 
@@ -80,14 +153,18 @@ function read(id) {
 // Flip a pending record. Idempotence guard: a second button press on the same
 // message must not overturn the first decision.
 function decide(id, status, by = "") {
-  const rec = read(id);
-  if (!rec) return null;
-  if (rec.status !== "pending") return rec;
-  rec.status = status === "approved" ? "approved" : "denied";
-  rec.decidedAt = new Date().toISOString();
-  if (by) rec.decidedBy = String(by);
-  fs.writeFileSync(fileOf(id), JSON.stringify(rec, null, 2), { mode: 0o600 });
-  return rec;
+  const held = acquireRecordLock(id);
+  if (!held) return read(id);
+  try {
+    const rec = read(id);
+    if (!rec) return null;
+    if (rec.status !== "pending") return rec;
+    rec.status = status === "approved" ? "approved" : "denied";
+    rec.decidedAt = new Date().toISOString();
+    if (by) rec.decidedBy = String(by);
+    writeRecord(rec);
+    return rec;
+  } finally { releaseRecordLock(held); }
 }
 
 // Poll until decided or timeout. Timeout resolves as "timeout" — the caller
@@ -107,29 +184,59 @@ async function waitForDecision(id, { timeoutMs = 90000, pollMs = 1500 } = {}) {
 // actions.js uses this flag to know a later button press must wake the agent
 // (an attached waiter reacts by itself, a detached one cannot).
 function detach(id) {
-  const rec = read(id);
-  if (!rec || rec.status !== "pending") return rec;
-  rec.detached = true;
-  rec.detachedAt = new Date().toISOString();
-  fs.writeFileSync(fileOf(id), JSON.stringify(rec, null, 2), { mode: 0o600 });
-  return rec;
+  const held = acquireRecordLock(id);
+  if (!held) return read(id);
+  try {
+    const rec = read(id);
+    if (!rec || rec.status !== "pending") return rec;
+    rec.detached = true;
+    rec.detachedAt = new Date().toISOString();
+    writeRecord(rec);
+    return rec;
+  } finally { releaseRecordLock(held); }
 }
 
 // One-shot token redemption for the async path. Fail-closed on every branch:
 // only an approved, un-consumed, un-expired record whose stored command is
 // byte-identical to what is about to run can be consumed — and only once.
 function consume(id, commandLine) {
-  const rec = read(id);
-  if (!rec) return { ok: false, reason: "unknown or expired approval id" };
-  if (rec.status !== "approved") return { ok: false, reason: `approval is ${rec.status}, not approved` };
-  if (rec.consumedAt) return { ok: false, reason: "approval already consumed (single use)" };
-  if (Date.now() - Date.parse(rec.requestedAt) > MAX_AGE_MS) return { ok: false, reason: "approval expired (24h)" };
-  if (String(commandLine || "").slice(0, 1000) !== rec.command) {
-    return { ok: false, reason: "command does not match the approved payload" };
-  }
-  rec.consumedAt = new Date().toISOString();
-  fs.writeFileSync(fileOf(id), JSON.stringify(rec, null, 2), { mode: 0o600 });
-  return { ok: true, record: rec };
+  try { fileOf(id); }
+  catch (_) { return { ok: false, reason: "unknown or expired approval id" }; }
+  const held = acquireRecordLock(id);
+  if (!held) return { ok: false, reason: "approval redemption could not be locked" };
+  try {
+    const rec = read(id);
+    if (!rec) return { ok: false, reason: "unknown or expired approval id" };
+    if (rec.status !== "approved") return { ok: false, reason: `approval is ${rec.status}, not approved` };
+    if (rec.consumedAt) return { ok: false, reason: "approval already consumed (single use)" };
+    if (Date.now() - Date.parse(rec.requestedAt) > MAX_AGE_MS) return { ok: false, reason: "approval expired (24h)" };
+    let candidate;
+    try { candidate = approvedCommand(commandLine); }
+    catch (_) { return { ok: false, reason: "command does not match the approved payload" }; }
+    // Records created before commandHash was introduced remain redeemable only
+    // when their stored payload is fully byte-identical and small enough to
+    // have been displayed in full. Longer legacy records safely require a new
+    // approval instead of accepting a hidden or previously truncated suffix.
+    const matches = rec.commandHash
+      ? candidate === rec.command && commandHash(candidate) === rec.commandHash
+      : Buffer.byteLength(String(rec.command || "")) <= MAX_COMMAND_BYTES
+        && candidate === String(rec.command || "");
+    if (!matches) return { ok: false, reason: "command does not match the approved payload" };
+    rec.consumedAt = new Date().toISOString();
+    writeRecord(rec);
+    return { ok: true, record: rec };
+  } finally { releaseRecordLock(held); }
 }
 
-module.exports = { APPROVALS_DIR, create, read, decide, waitForDecision, detach, consume };
+module.exports = {
+  APPROVALS_DIR,
+  MAX_COMMAND_BYTES,
+  commandHash,
+  consume,
+  create,
+  decide,
+  detach,
+  formatApprovedCommand,
+  read,
+  waitForDecision,
+};

package/core/auth-flow.js

@@ -3,12 +3,13 @@
 // core/handlers; this module owns the heavy lifting they call into.
 
 const fs = require("fs");
-const { spawn, execSync } = require("child_process");
+const { spawn, execFileSync } = require("child_process");
 const {
   config, saveEnvKey,
-  CLAUDE_PATH, resolvedCodexPath,
-  botSubprocessEnv,
+  discoverProviderExecutable,
+  botSubprocessEnv, agentEnvSource,
 } = require("./config");
+const { claudeAgentEnv, codexAgentEnv } = require("./providers/env");
 const { vault } = require("./vault-store");
 const { redactSensitive, stripTerminalControls, extractUrls } = require("./redact");
 const { send } = require("./io");
@@ -28,10 +29,27 @@ function getClaudeOAuthToken() {
 }
 
 function claudeSubprocessEnv() {
-  const env = botSubprocessEnv();
   const token = getClaudeOAuthToken().value;
-  if (token) env.CLAUDE_CODE_OAUTH_TOKEN = token;
-  return env;
+  return claudeAgentEnv(agentEnvSource(), {
+    CLAUDE_CODE_OAUTH_TOKEN: token,
+    ANTHROPIC_API_KEY: config.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY,
+    CLAUDE_CONFIG_DIR: config.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR,
+  });
+}
+
+function codexSubprocessEnv() {
+  return codexAgentEnv(agentEnvSource(), {
+    OPENAI_API_KEY: config.OPENAI_API_KEY || process.env.OPENAI_API_KEY,
+    CODEX_HOME: config.CODEX_HOME || process.env.CODEX_HOME,
+  });
+}
+
+function codexExecutable() {
+  return discoverProviderExecutable("codex");
+}
+
+function claudeExecutable() {
+  return discoverProviderExecutable("claude");
 }
 
 function saveClaudeOAuthToken(token) {
@@ -179,8 +197,10 @@ function claudeUsageLimitMessage(details = "") {
 }
 
 function runClaudeAuthStatusDiagnostic() {
+  const binary = claudeExecutable();
+  if (!binary) return "Claude CLI not found";
   try {
-    const output = execSync(`"${CLAUDE_PATH}" auth status`, {
+    const output = execFileSync(binary, ["auth", "status"], {
       cwd: process.env.HOME || require("os").homedir(),
       env: claudeSubprocessEnv(),
       encoding: "utf8",
@@ -193,6 +213,25 @@ function runClaudeAuthStatusDiagnostic() {
   }
 }
 
+function claudeProviderAuthStatus(options = {}) {
+  const binary = options.binary || claudeExecutable();
+  if (!binary) return { state: "not_checked", reason: "Claude CLI not found" };
+  const tokenInfo = getClaudeOAuthToken();
+  if (tokenInfo.value) {
+    return { state: "authenticated", reason: null, method: "oauth_token", source: tokenInfo.source };
+  }
+  const runner = options.runCommand || runCommand;
+  const result = runner(binary, ["auth", "status"], {
+    env: claudeSubprocessEnv(),
+    timeout: 12000,
+  });
+  if (isClaudeAuthErrorText(result.output)) {
+    return { state: "unauthenticated", reason: summarizeAuthOutput(result.output, false) };
+  }
+  if (result.ok) return { state: "authenticated", reason: null, method: "cli_store", source: null };
+  return { state: "unknown", reason: summarizeAuthOutput(result.output, false) };
+}
+
 async function sendClaudeAuthStatusSummary(prefix = "Claude auth status") {
   const output = runClaudeAuthStatusDiagnostic();
   const tokenInfo = getClaudeOAuthToken();
@@ -219,8 +258,13 @@ async function runClaudeAuthCommand(args, label, opts = {}) {
     await send(`Another Claude auth flow is already running (${state.pendingClaudeAuthLabel}). Send the requested code/token or wait for it to finish.`);
     return;
   }
+  const binary = claudeExecutable();
+  if (!binary) {
+    await send("Claude CLI not found. Install it or configure CLAUDE_PATH.");
+    return;
+  }
   await send(`${label} started...`);
-  const proc = spawn(CLAUDE_PATH, args, {
+  const proc = spawn(binary, args, {
     cwd: process.env.HOME || require("os").homedir(),
     env: claudeSubprocessEnv(),
     stdio: ["pipe", "pipe", "pipe"],
@@ -298,7 +342,7 @@ function clearPendingCodexAuth(state = currentState()) {
 
 function runCommand(command, args = [], opts = {}) {
   try {
-    const out = execSync([command, ...args].map((v) => `"${String(v).replace(/"/g, '\\"')}"`).join(" "), {
+    const out = execFileSync(command, args.map(String), {
       cwd: opts.cwd || process.env.HOME || require("os").homedir(),
       env: opts.env || botSubprocessEnv(),
       encoding: "utf-8",
@@ -312,28 +356,61 @@ function runCommand(command, args = [], opts = {}) {
 }
 
 function runCodexLoginStatus() {
-  if (!resolvedCodexPath) return { ok: false, code: 1, output: "Codex CLI not found" };
-  const result = runCommand(resolvedCodexPath, ["login", "status"], { timeout: 12000 });
+  const binary = codexExecutable();
+  if (!binary) return { ok: false, code: 1, output: "Codex CLI not found" };
+  const result = runCommand(binary, ["login", "status"], { timeout: 12000, env: codexSubprocessEnv() });
   return { ...result, ok: result.ok && !isCodexAuthErrorText(result.output) };
 }
 
+function codexProviderAuthStatus(options = {}) {
+  const binary = options.binary || codexExecutable();
+  if (!binary) return { state: "not_checked", reason: "Codex CLI not found" };
+  const runner = options.runCommand || runCommand;
+  const result = runner(binary, ["login", "status"], {
+    env: codexSubprocessEnv(),
+    timeout: 12000,
+  });
+  if (result.ok && !isCodexAuthErrorText(result.output)) {
+    return { state: "authenticated", reason: null, method: "cli_store" };
+  }
+  if (isCodexAuthErrorText(result.output)) {
+    return { state: "unauthenticated", reason: summarizeAuthOutput(result.output, false) };
+  }
+  return { state: "unknown", reason: summarizeAuthOutput(result.output, false) };
+}
+
+function codexAuthHelp(reason = "Codex authentication failed") {
+  return [
+    `Codex authentication needs attention: ${redactSensitive(reason)}`,
+    "",
+    "Try one of these from chat:",
+    "1. /codex_auth_status — check the local Codex login state",
+    "2. /codex_login — start device-code login",
+    "3. /codex_setup_token — store an existing OpenAI API key through the Codex CLI",
+    "",
+    "Or run `codex login` in a terminal on the bot host.",
+  ].join("\n");
+}
+
 // Quick "is this provider usable non-interactively" check for the unified
 // /login model picker. Claude is cheap (token presence is what the bot relies
 // on). Codex spawns `codex login status` once — fine for a setup screen.
 function providerAuthStatus() {
+  const binary = codexExecutable();
   return {
     claude: !!getClaudeOAuthToken().value,
-    codex: resolvedCodexPath ? runCodexLoginStatus().ok : false,
+    codex: binary ? runCodexLoginStatus().ok : false,
   };
 }
 
 async function sendCodexAuthStatusSummary(prefix = "Codex auth status") {
+  const binary = codexExecutable();
   const status = runCodexLoginStatus();
-  const version = resolvedCodexPath ? runCommand(resolvedCodexPath, ["--version"]) : { ok: false, output: "not found" };
+  const version = binary ? runCommand(binary, ["--version"], { env: codexSubprocessEnv() }) : { ok: false, output: "not found" };
   await send([
     prefix,
     "",
-    `CLI: ${resolvedCodexPath ? "found" : "not found"}`,
+    `CLI: ${binary ? "found" : "not found"}`,
     `Version: ${summarizeAuthOutput(version.output, version.ok)}`,
     `Logged in: ${status.ok ? "yes" : "no/unknown"}`,
     `Status: ${summarizeAuthOutput(status.output, status.ok)}`,
@@ -342,10 +419,12 @@ async function sendCodexAuthStatusSummary(prefix = "Codex auth status") {
 }
 
 async function saveCodexApiKeyWithCli(apiKey) {
+  const binary = codexExecutable();
+  if (!binary) return { ok: false, code: 1, output: "Codex CLI not found" };
   return new Promise((resolve) => {
-    const proc = spawn(resolvedCodexPath, ["login", "--with-api-key"], {
+    const proc = spawn(binary, ["login", "--with-api-key"], {
       cwd: process.env.HOME || require("os").homedir(),
-      env: botSubprocessEnv(),
+      env: codexSubprocessEnv(),
       stdio: ["pipe", "pipe", "pipe"],
     });
     let output = "";
@@ -360,12 +439,13 @@ async function saveCodexApiKeyWithCli(apiKey) {
 
 async function runCodexDeviceLogin() {
   const state = currentState();
-  if (!resolvedCodexPath) return send("Codex CLI not found. Install: npm install -g @openai/codex");
+  const binary = codexExecutable();
+  if (!binary) return send("Codex CLI not found. Install: npm install -g @openai/codex");
   if (state.pendingCodexAuthProcess) return send(`Another Codex auth flow is already running (${state.pendingCodexAuthLabel}). Send /cancel_codex_auth to cancel.`);
   await send("Codex device login started. I'll send the URL/code if the CLI prints one.");
-  const proc = spawn(resolvedCodexPath, ["login", "--device-auth"], {
+  const proc = spawn(binary, ["login", "--device-auth"], {
     cwd: process.env.HOME || require("os").homedir(),
-    env: botSubprocessEnv(),
+    env: codexSubprocessEnv(),
     stdio: ["pipe", "pipe", "pipe"],
   });
   state.pendingCodexAuthProcess = proc;
@@ -416,6 +496,8 @@ module.exports = {
   CLAUDE_OAUTH_TOKEN_KEY, CLAUDE_OAUTH_VAULT_KEY,
   getClaudeOAuthToken,
   claudeSubprocessEnv,
+  claudeProviderAuthStatus,
+  codexSubprocessEnv,
   saveClaudeOAuthToken,
   clearClaudeOAuthToken,
   extractClaudeToken,
@@ -437,6 +519,8 @@ module.exports = {
   clearPendingCodexAuth,
   runCommand,
   runCodexLoginStatus,
+  codexProviderAuthStatus,
+  codexAuthHelp,
   providerAuthStatus,
   sendCodexAuthStatusSummary,
   saveCodexApiKeyWithCli,

package/core/config-dir.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function resolveConfigDir(env = process.env) {
+  const configured = String(env.OPEN_CLAUDIA_CONFIG_DIR || "").trim();
+  if (configured) return path.resolve(configured);
+  const home = String(env.HOME || os.homedir()).trim();
+  return path.resolve(home, ".open-claudia");
+}
+
+function ensureConfigDir(configDir = resolveConfigDir()) {
+  fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  return configDir;
+}
+
+module.exports = { resolveConfigDir, ensureConfigDir };