@inetafrica/open-claudia 2.14.8 → 3.0.0

package/core/providers/codex-hook.js

@@ -0,0 +1,280 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { buildDenyGateCommand, shellQuote } = require("./hook-command");
+
+const HOOK_TIMEOUT_SECONDS = 10;
+const REQUIRED_EXEC_FLAGS = Object.freeze([
+  "--config",
+  "--strict-config",
+  "--ignore-user-config",
+  "--dangerously-bypass-hook-trust",
+]);
+
+let compatibilityCaches = new WeakMap();
+
+function hookError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "ToolHookInitializationError";
+  error.code = code;
+  error.details = details;
+  return error;
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function normalizedCwd(cwd) {
+  return path.resolve(String(cwd || process.cwd()));
+}
+
+function buildCodexHookOverrides({ cwd, nodePath, cliPath } = {}) {
+  const command = buildDenyGateCommand({ nodePath, cliPath });
+  const project = normalizedCwd(cwd);
+  return Object.freeze({
+    featuresHooks: "features.hooks=true",
+    featuresPlugins: "features.plugins=false",
+    featuresUnifiedExec: "features.unified_exec=false",
+    // A path is a dynamic TOML map key. Current Codex `-c` parsing rejects a
+    // quoted path inside dotted-key notation, so replace the isolated projects
+    // table with one explicit inline table (user config is ignored below).
+    projectTrust: `projects={${tomlString(project)}={ trust_level=${tomlString("untrusted")} }}`,
+    preToolUse: "hooks.PreToolUse=[{ matcher = \"^Bash$\", hooks = [{ type = \"command\", "
+      + `command = ${tomlString(command)}, timeout = ${HOOK_TIMEOUT_SECONDS}, statusMessage = \"Checking Open Claudia tool policy\" }] }]`,
+  });
+}
+
+function hookArgs(overrides) {
+  return [
+    "--ignore-user-config",
+    "--strict-config",
+    "-c", overrides.featuresHooks,
+    "-c", overrides.featuresPlugins,
+    "-c", overrides.featuresUnifiedExec,
+    "-c", overrides.projectTrust,
+    "-c", overrides.preToolUse,
+    "--dangerously-bypass-hook-trust",
+  ];
+}
+
+function fingerprint(args) {
+  return crypto.createHash("sha256").update(JSON.stringify(args)).digest("hex");
+}
+
+function prepareCodexHook(options = {}) {
+  const cwd = normalizedCwd(options.cwd);
+  const overrides = buildCodexHookOverrides({ ...options, cwd });
+  const args = Object.freeze(hookArgs(overrides));
+  return Object.freeze({
+    providerId: "codex",
+    cwd,
+    overrides,
+    args,
+    fingerprint: fingerprint(args),
+  });
+}
+
+function verifyPreparedCodexHook(prepared) {
+  if (!prepared || prepared.providerId !== "codex" || !Array.isArray(prepared.args)) return false;
+  let expected;
+  try { expected = prepareCodexHook({ cwd: prepared.cwd }); }
+  catch (_) { return false; }
+  return prepared.fingerprint === expected.fingerprint
+    && prepared.args.length === expected.args.length
+    && prepared.args.every((value, index) => value === expected.args[index]);
+}
+
+function commandResult(runner, binary, args, options) {
+  try {
+    const result = runner(binary, args, options);
+    return result && typeof result === "object"
+      ? result
+      : { ok: false, output: "", code: 1 };
+  } catch (error) {
+    return { ok: false, output: "", code: 1, error };
+  }
+}
+
+function featureState(output, name, expected) {
+  const line = String(output || "").split(/\r?\n/).find((entry) => entry.trim().startsWith(`${name} `));
+  if (!line) return false;
+  return line.trim().split(/\s+/).at(-1) === String(expected);
+}
+
+function compatibilityCache(runner) {
+  let cache = compatibilityCaches.get(runner);
+  if (!cache) {
+    cache = new Map();
+    compatibilityCaches.set(runner, cache);
+  }
+  return cache;
+}
+
+function checkCodexHookCompatibility({ binary, runCommand, env, cwd, prepared = prepareCodexHook({ cwd }), cache = true } = {}) {
+  if (typeof binary !== "string" || !binary || typeof runCommand !== "function") {
+    return { ok: false, code: "MANDATORY_TOOL_HOOK_UNAVAILABLE", reason: "Codex hook compatibility could not be probed" };
+  }
+  if (!verifyPreparedCodexHook(prepared)) {
+    return { ok: false, code: "TOOL_HOOK_CONFIG_UNVERIFIED", reason: "Open Claudia's generated Codex hook configuration failed verification" };
+  }
+  const key = `${binary}\0${prepared.fingerprint}`;
+  const values = compatibilityCache(runCommand);
+  if (cache && values.has(key)) return values.get(key);
+
+  const opts = { env, cwd: prepared.cwd, timeout: 10000 };
+  const execHelp = commandResult(runCommand, binary, ["exec", "--help"], opts);
+  const resumeHelp = commandResult(runCommand, binary, ["exec", "resume", "--help"], opts);
+  const missing = [];
+  for (const flag of REQUIRED_EXEC_FLAGS) {
+    if (!execHelp.ok || !String(execHelp.output || "").includes(flag)) missing.push(`exec ${flag}`);
+    if (!resumeHelp.ok || !String(resumeHelp.output || "").includes(flag)) missing.push(`resume ${flag}`);
+  }
+  let result;
+  if (missing.length) {
+    result = {
+      ok: false,
+      code: "MANDATORY_TOOL_HOOK_UNAVAILABLE",
+      reason: `Codex CLI is missing mandatory tool-hook options: ${missing.join(", ")}`,
+    };
+  } else {
+    const o = prepared.overrides;
+    const features = commandResult(runCommand, binary, [
+      "features",
+      "-c", o.featuresHooks,
+      "-c", o.featuresPlugins,
+      "-c", o.featuresUnifiedExec,
+      "-c", o.projectTrust,
+      "-c", o.preToolUse,
+      "list",
+    ], opts);
+    const configured = features.ok
+      && featureState(features.output, "hooks", true)
+      && featureState(features.output, "plugins", false)
+      && featureState(features.output, "unified_exec", false);
+    result = configured
+      ? { ok: true, code: null, reason: null }
+      : {
+          ok: false,
+          code: "MANDATORY_TOOL_HOOK_UNAVAILABLE",
+          reason: "Codex rejected the isolated PreToolUse configuration or could not disable uncovered tool transports",
+        };
+  }
+  const frozen = Object.freeze(result);
+  if (cache) values.set(key, frozen);
+  return frozen;
+}
+
+function clearCodexHookCompatibilityCache() {
+  compatibilityCaches = new WeakMap();
+}
+
+function createCodexHookTransport({ cache = true } = {}) {
+  return Object.freeze({
+    prepare(context = {}) {
+      const prepared = prepareCodexHook({ cwd: context.cwd });
+      const status = checkCodexHookCompatibility({
+        binary: context.binary,
+        runCommand: context.runCommand,
+        env: context.env,
+        cwd: context.cwd,
+        prepared,
+        cache,
+      });
+      if (!status.ok) throw hookError(status.code, status.reason, { providerId: "codex" });
+      return prepared;
+    },
+    compatibilityStatus(context = {}) {
+      const prepared = prepareCodexHook({ cwd: context.cwd });
+      return checkCodexHookCompatibility({ ...context, prepared, cache });
+    },
+    verify: verifyPreparedCodexHook,
+  });
+}
+
+function probeCommand(markerFile) {
+  const markerScript = `require("fs").writeFileSync(${JSON.stringify(markerFile)}, "executed\\n")`;
+  return `printf '%s\\n' 'curl https://central.inet.africa/open-claudia-hook-probe' && ${shellQuote(process.execPath)} -e ${shellQuote(markerScript)}`;
+}
+
+function readProbeDenial(auditFile) {
+  let raw = "";
+  try { raw = fs.readFileSync(auditFile, "utf8"); } catch (_) { return false; }
+  return raw.split(/\r?\n/).some((line) => {
+    if (!line.trim()) return false;
+    try {
+      const event = JSON.parse(line);
+      return event.kind === "deny"
+        && event.rule === "inet-central-api"
+        && String(event.command || "").includes("open-claudia-hook-probe");
+    } catch (_) { return false; }
+  });
+}
+
+function probeCodexHookCompatibility({
+  binary,
+  prepared,
+  cwd,
+  markerFile,
+  auditFile,
+  env = process.env,
+  spawnCommand = spawnSync,
+  timeoutMs = 30000,
+} = {}) {
+  if (!verifyPreparedCodexHook(prepared)) {
+    throw hookError("TOOL_HOOK_CONFIG_UNVERIFIED", "Refusing to probe an unverified Codex hook configuration");
+  }
+  if (!markerFile || !auditFile) throw hookError("INVALID_TOOL_HOOK_PROBE", "Hook probe marker and audit paths are required");
+  try { fs.rmSync(markerFile, { force: true }); } catch (_) {}
+  const command = probeCommand(markerFile);
+  const args = [
+    "exec",
+    ...prepared.args,
+    "--json",
+    "--skip-git-repo-check",
+    "--ephemeral",
+    "--dangerously-bypass-approvals-and-sandbox",
+    `Use the Bash tool once to run this exact harmless compatibility command, then stop:\n${command}`,
+  ];
+  const result = spawnCommand(binary, args, {
+    cwd: normalizedCwd(cwd || prepared.cwd),
+    env: {
+      ...env,
+      FAKE_AGENT_SCENARIO: env.FAKE_AGENT_SCENARIO || "hook-probe",
+      OPEN_CLAUDIA_HOOK_PROBE_COMMAND: command,
+      OPEN_CLAUDIA_HOOK_PROBE_MARKER: markerFile,
+      TOOL_GUARD_LOG: auditFile,
+    },
+    input: "",
+    encoding: "utf8",
+    timeout: timeoutMs,
+  });
+  const markerExecuted = fs.existsSync(markerFile);
+  const denyObserved = readProbeDenial(auditFile);
+  const status = Number.isInteger(result?.status) ? result.status : 1;
+  const ok = status === 0 && denyObserved && !markerExecuted;
+  return {
+    ok,
+    status,
+    denyObserved,
+    markerExecuted,
+    diagnostic: ok
+      ? null
+      : `Codex tool-hook probe failed (status=${status}, denyObserved=${denyObserved}, markerExecuted=${markerExecuted})`,
+  };
+}
+
+module.exports = {
+  HOOK_TIMEOUT_SECONDS,
+  REQUIRED_EXEC_FLAGS,
+  buildCodexHookOverrides,
+  checkCodexHookCompatibility,
+  clearCodexHookCompatibilityCache,
+  createCodexHookTransport,
+  prepareCodexHook,
+  probeCodexHookCompatibility,
+  verifyPreparedCodexHook,
+};

package/core/providers/codex.js

@@ -0,0 +1,286 @@
+"use strict";
+
+const config = require("../config");
+const auth = require("../auth-flow");
+const { createJsonlDecoder } = require("./events");
+const { createCodexParserState, normalizeCodexEvent } = require("./codex-events");
+const { createCodexHookTransport } = require("./codex-hook");
+
+const CODEX_MODELS = Object.freeze(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"]);
+const CODEX_EFFORT_VALUES = Object.freeze(["minimal", "low", "medium", "high", "xhigh"]);
+const REQUIRED_EXEC_HELP_FLAGS = Object.freeze(["--config", "--json", "--sandbox", "--image", "--model", "--skip-git-repo-check"]);
+const REQUIRED_RESUME_HELP_FLAGS = Object.freeze(["--config", "--json", "--image", "--model", "--skip-git-repo-check"]);
+
+const capabilities = Object.freeze({
+  resume: { support: "native", reason: null },
+  readOnlyMode: { support: "native", reason: null },
+  effort: { support: "native", values: [...CODEX_EFFORT_VALUES], reason: null },
+  budget: { support: "unsupported", reason: "Codex exec has no per-run monetary budget flag" },
+  worktree: { support: "unsupported", reason: "Codex exec does not create provider-managed worktrees" },
+  partialStreaming: { support: "unsupported", reason: "Codex JSONL does not expose the Claude-style partial message stream" },
+  maxTurns: { support: "unsupported", reason: "Codex exec has no max-turns option" },
+  imageFlag: { support: "native", reason: null },
+  persistentUtilityStream: { support: "unsupported", reason: "Codex utility calls run as bounded ephemeral exec processes" },
+  preToolHook: { support: "native", reason: null },
+});
+
+function providerError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "ProviderInvocationError";
+  error.code = code;
+  error.details = details;
+  return error;
+}
+
+function settingsOf(context) {
+  return context.providerSettings || context.settings || {};
+}
+
+function preparedPrompt(context) {
+  const userPrompt = typeof context.userPrompt === "string"
+    ? context.userPrompt
+    : (typeof context.prompt === "string" ? context.prompt : null);
+  if (userPrompt === null) throw providerError("INVALID_PROVIDER_CONTEXT", "userPrompt must be a string");
+  const dynamic = typeof context.dynamicContext === "string" ? context.dynamicContext : "";
+  return dynamic ? `${dynamic}\n\n${userPrompt}` : userPrompt;
+}
+
+function coreInstructionsOf(context) {
+  if (typeof context.coreInstructions !== "string" || !context.coreInstructions.trim()) {
+    throw providerError("MISSING_CORE_INSTRUCTIONS", "coreInstructions are required");
+  }
+  return context.coreInstructions;
+}
+
+function sessionFor(context) {
+  if (context.fresh) return null;
+  if (context.resumeSessionId) return String(context.resumeSessionId);
+  if (context.continueSession) {
+    if (!context.sessionId) throw providerError("INVALID_PROVIDER_CONTEXT", "continueSession requires a captured Codex sessionId");
+    return String(context.sessionId);
+  }
+  return context.sessionId ? String(context.sessionId) : null;
+}
+
+function imagePathsOf(context) {
+  const paths = context.imagePaths || context.images || [];
+  if (!Array.isArray(paths) || paths.some((item) => typeof item !== "string" || !item.trim())) {
+    throw providerError("INVALID_PROVIDER_CONTEXT", "imagePaths must be an array of non-empty strings");
+  }
+  return paths;
+}
+
+function createCodexProvider(options = {}) {
+  const resolveExecutable = options.resolveExecutable || (() => config.discoverProviderExecutable("codex"));
+  const defaultModel = options.defaultModel ?? config.config.CODEX_MODEL ?? null;
+  const buildEnv = options.buildEnv || auth.codexSubprocessEnv;
+  const getAuthStatus = options.getAuthStatus || ((binary) => auth.codexProviderAuthStatus({ binary }));
+  const runCommand = options.runCommand || auth.runCommand;
+  // Factories are safe by default. `false` is reserved for hermetic argv tests
+  // that do not launch a real provider process.
+  const hookTransport = options.hookTransport === false
+    ? null
+    : (options.hookTransport || createCodexHookTransport());
+
+  function executable() {
+    return resolveExecutable() || null;
+  }
+
+  function requireExecutable() {
+    const binary = executable();
+    if (!binary) throw providerError("NO_AVAILABLE_PROVIDER", "OpenAI Codex is not configured or installed", { providerId: "codex" });
+    return binary;
+  }
+
+  function assertSupportedContext(context) {
+    const settings = settingsOf(context);
+    const budget = context.budget ?? settings.budget ?? null;
+    if (budget !== null) throw providerError("UNSUPPORTED_PROVIDER_SETTING", capabilities.budget.reason, { setting: "budget" });
+    if (context.worktree ?? settings.worktree ?? false) {
+      throw providerError("UNSUPPORTED_PROVIDER_SETTING", capabilities.worktree.reason, { setting: "worktree" });
+    }
+    if (context.maxTurns !== undefined && context.maxTurns !== null) {
+      throw providerError("UNSUPPORTED_PROVIDER_SETTING", capabilities.maxTurns.reason, { setting: "maxTurns" });
+    }
+    if (context.voiceStream) {
+      throw providerError("UNSUPPORTED_PROVIDER_CAPABILITY", capabilities.partialStreaming.reason, { capability: "partialStreaming" });
+    }
+    if (context.toolHookSettings) {
+      throw providerError("INVALID_PROVIDER_CONTEXT", "Codex tool hooks must use Open Claudia's generated transient configuration", { capability: "preToolHook" });
+    }
+    if (context.allowedTools !== undefined || context.disallowedTools !== undefined) {
+      throw providerError("UNSUPPORTED_PROVIDER_CAPABILITY", "Codex tool allow/deny lists are not available through this adapter", { capability: "toolLists" });
+    }
+    if (context.outputSchema && !context.outputSchemaPath) {
+      throw providerError("INVALID_PROVIDER_CONTEXT", "Codex outputSchema requires a prepared outputSchemaPath");
+    }
+  }
+
+  function buildInvocation(context, utility) {
+    if (!context || typeof context !== "object") throw providerError("INVALID_PROVIDER_CONTEXT", "provider context must be an object");
+    assertSupportedContext(context);
+    const coreInstructions = coreInstructionsOf(context);
+    const resumeId = utility ? null : sessionFor(context);
+    const settings = settingsOf(context);
+    const binary = requireExecutable();
+    const env = { ...buildEnv() };
+    const readOnlyModes = new Set(["plan", "ask"]);
+    const readOnly = !!context.readOnly
+      || readOnlyModes.has(settings.permissionMode)
+      || readOnlyModes.has(context.permissionMode);
+    let preparedHook = null;
+    let warnings = null;
+    if (hookTransport) {
+      try {
+        preparedHook = hookTransport.prepare({
+          binary,
+          env,
+          cwd: context.cwd || process.cwd(),
+          runCommand,
+          readOnly,
+        });
+        if (!hookTransport.verify(preparedHook)) {
+          throw providerError("TOOL_HOOK_CONFIG_UNVERIFIED", "Open Claudia's generated Codex hook configuration failed verification");
+        }
+      } catch (error) {
+        if (readOnly && context.allowReadOnlyWithoutToolHook === true) {
+          warnings = [{
+            code: "READ_ONLY_TOOL_HOOK_UNAVAILABLE",
+            message: "Codex is continuing in read-only sandbox mode because the mandatory tool hook is unavailable; unrestricted execution remains blocked.",
+          }];
+        } else {
+          throw providerError(
+            "MANDATORY_TOOL_HOOK_UNAVAILABLE",
+            error?.message || "Codex's mandatory tool hook could not be initialized",
+            { providerId: "codex", causeCode: error?.code || null },
+          );
+        }
+      }
+    }
+    const args = ["exec"];
+    if (resumeId) args.push("resume");
+    if (preparedHook) args.push(...preparedHook.args);
+
+    args.push("-c", `developer_instructions=${JSON.stringify(coreInstructions)}`);
+
+    const effort = context.effort || settings.effort || null;
+    if (effort) {
+      if (!CODEX_EFFORT_VALUES.includes(effort)) {
+        throw providerError("UNSUPPORTED_PROVIDER_SETTING", `Unsupported Codex effort: ${effort}`, { setting: "effort", value: effort });
+      }
+      args.push("-c", `model_reasoning_effort=${JSON.stringify(effort)}`);
+    }
+
+    if (resumeId && readOnly) args.push("-c", `sandbox_mode=${JSON.stringify("read-only")}`);
+
+    const imagePaths = imagePathsOf(context);
+    if (imagePaths.length) {
+      if (resumeId) {
+        for (const imagePath of imagePaths) args.push("--image", imagePath);
+      } else {
+        args.push("--image", ...imagePaths);
+      }
+    }
+
+    args.push("--json", "--skip-git-repo-check");
+    if (!resumeId && readOnly) args.push("--sandbox", "read-only");
+    else if (!readOnly) args.push("--dangerously-bypass-approvals-and-sandbox");
+
+    const model = context.model || settings.model || (utility && context.tier ? provider.tierModel(context.tier) : defaultModel);
+    if (model) args.push("--model", String(model));
+    if (context.outputSchemaPath) args.push("--output-schema", String(context.outputSchemaPath));
+    if (utility) args.push("--ephemeral");
+
+    if (resumeId) args.push(resumeId);
+    const prompt = preparedPrompt(context);
+    // `codex exec -` consumes the prompt from stdin. Utility payloads often
+    // contain private memory or guardrail mandates and must not be exposed in
+    // argv/process listings.
+    args.push(utility ? "-" : prompt);
+
+    return {
+      binary,
+      args,
+      env,
+      stdin: utility ? prompt : null,
+      parserState: createCodexParserState(),
+      ...(warnings ? { warnings } : {}),
+    };
+  }
+
+  const provider = {
+    id: "codex",
+    label: "OpenAI Codex",
+    capabilities,
+
+    isAvailable: () => !!executable(),
+    executable,
+    defaultModel: () => defaultModel,
+    modelChoices: () => [...CODEX_MODELS],
+
+    compatibilityStatus() {
+      const binary = executable();
+      if (!binary) return { state: "not_checked", version: null, reason: "Codex CLI not found" };
+      const versionResult = runCommand(binary, ["--version"], { env: buildEnv(), timeout: 10000 });
+      if (!versionResult.ok) return { state: "unknown", version: null, reason: "Codex version probe failed" };
+      const version = (String(versionResult.output).match(/\b(\d+\.\d+\.\d+)\b/) || [null, null])[1];
+      const execHelp = runCommand(binary, ["exec", "--help"], { env: buildEnv(), timeout: 10000 });
+      const resumeHelp = runCommand(binary, ["exec", "resume", "--help"], { env: buildEnv(), timeout: 10000 });
+      if (!execHelp.ok || !resumeHelp.ok) return { state: "unknown", version, reason: "Codex compatibility probe failed" };
+      const missing = [
+        ...REQUIRED_EXEC_HELP_FLAGS.filter((flag) => !String(execHelp.output).includes(flag)).map((flag) => `exec ${flag}`),
+        ...REQUIRED_RESUME_HELP_FLAGS.filter((flag) => !String(resumeHelp.output).includes(flag)).map((flag) => `resume ${flag}`),
+      ];
+      if (missing.length) return { state: "incompatible", version, reason: `Codex CLI is missing required options: ${missing.join(", ")}` };
+      if (hookTransport) {
+        const hookStatus = hookTransport.compatibilityStatus({ binary, runCommand, env: buildEnv(), cwd: process.cwd() });
+        if (!hookStatus.ok) return { state: "incompatible", version, reason: hookStatus.reason };
+      }
+      return { state: "compatible", version, reason: null };
+    },
+
+    buildMainInvocation: (context) => buildInvocation(context, false),
+    buildCompactionInvocation(context) {
+      if (!context?.fresh || !context.readOnly || !context.outputSchemaPath || context.maxTurns != null) {
+        throw providerError("INVALID_PROVIDER_CONTEXT", "Codex compaction seed requires a fresh read-only output contract without maxTurns");
+      }
+      // Deliberately persistent: buildUtilityInvocation adds --ephemeral, which
+      // would make the successful seed impossible to resume.
+      return buildInvocation({ ...context, permissionMode: "plan" }, false);
+    },
+    buildUtilityInvocation: (context) => buildInvocation({ ...context, fresh: true }, true),
+    createEventDecoder: (decoderOptions) => createJsonlDecoder(decoderOptions),
+    normalizeEvent: normalizeCodexEvent,
+    authStatus: () => getAuthStatus(executable()),
+    authHelp: () => auth.codexAuthHelp(),
+    preflightAuth() {
+      const status = provider.authStatus();
+      if (status.state !== "unauthenticated") return null;
+      return {
+        code: "PROVIDER_UNAUTHENTICATED",
+        providerId: "codex",
+        message: auth.codexAuthHelp(status.reason || "Codex authentication failed"),
+      };
+    },
+    nativeToolsNote: "Codex exposes its native exec tools; Open Claudia capability checks and approval policy remain authoritative.",
+    tierModel(tier) {
+      if (tier === "low") return "gpt-5.4-mini";
+      if (tier === "medium") return "gpt-5.3-codex";
+      return defaultModel || "gpt-5.5";
+    },
+  };
+
+  return provider;
+}
+
+const codexProvider = createCodexProvider();
+
+module.exports = {
+  CODEX_EFFORT_VALUES,
+  CODEX_MODELS,
+  REQUIRED_EXEC_HELP_FLAGS,
+  REQUIRED_RESUME_HELP_FLAGS,
+  capabilities,
+  codexProvider,
+  createCodexProvider,
+};