@inetafrica/open-claudia 2.15.0 → 3.0.0

package/test-provider-fixture.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const fixture = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-provider-fixture-"));
+const activeChildren = new Set();
+let sequence = 0;
+
+function fixturePath(label) {
+  sequence += 1;
+  return path.join(tmp, `${String(sequence).padStart(2, "0")}-${label}.json`);
+}
+
+function minimalChildEnv(controls) {
+  const env = {};
+  for (const key of ["PATH", "TMPDIR", "TMP", "TEMP", "SystemRoot", "COMSPEC", "PATHEXT"]) {
+    if (process.env[key] != null) env[key] = process.env[key];
+  }
+  env.HOME = tmp;
+  return { ...env, ...controls };
+}
+
+function runFixture({ kind, args = [], controls = {}, onSpawn, direct = false, timeoutMs = 3000 } = {}) {
+  const capturePath = controls.FAKE_AGENT_CAPTURE || fixturePath(`${kind || "unknown"}-capture`);
+  const env = minimalChildEnv({
+    FAKE_AGENT_KIND: kind,
+    FAKE_AGENT_CAPTURE: capturePath,
+    ...controls,
+  });
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(direct ? fixture : process.execPath, direct ? args : [fixture, ...args], {
+      cwd: __dirname,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    activeChildren.add(child);
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let settled = false;
+    let forceTimer = null;
+    const deadline = setTimeout(() => {
+      child.kill("SIGTERM");
+      forceTimer = setTimeout(() => child.kill("SIGKILL"), 100);
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
+    child.stderr.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      if (forceTimer) clearTimeout(forceTimer);
+      activeChildren.delete(child);
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      if (forceTimer) clearTimeout(forceTimer);
+      activeChildren.delete(child);
+      resolve({
+        code,
+        signal,
+        closedAt: Date.now(),
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stdoutChunks,
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        capturePath,
+        capture: fs.existsSync(capturePath)
+          ? JSON.parse(fs.readFileSync(capturePath, "utf8"))
+          : null,
+      });
+    });
+    if (onSpawn) {
+      try {
+        onSpawn(child, stdoutChunks);
+      } catch (error) {
+        child.kill("SIGKILL");
+        reject(error);
+      }
+    }
+  });
+}
+
+function cleanup() {
+  for (const child of activeChildren) child.kill("SIGKILL");
+  activeChildren.clear();
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+function parseJsonLines(text) {
+  return text
+    .split(/\r?\n/)
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line));
+}
+
+function waitForFile(filePath, timeoutMs = 1000) {
+  const started = Date.now();
+  return new Promise((resolve, reject) => {
+    const poll = () => {
+      if (fs.existsSync(filePath)) return resolve();
+      if (Date.now() - started >= timeoutMs) {
+        return reject(new Error(`timed out waiting for ${path.basename(filePath)}`));
+      }
+      setTimeout(poll, 5);
+    };
+    poll();
+  });
+}
+
+async function main() {
+  assert.ok(fs.existsSync(fixture), "fake provider CLI fixture must exist");
+  if (process.platform !== "win32") {
+    fs.accessSync(fixture, fs.constants.X_OK);
+  }
+
+  // Capture argv exactly, but reduce all requested environment inspection to
+  // boolean key presence. Credential values must never reach the capture file.
+  const secretValues = ["claude-secret-value", "openai-secret-value"];
+  const captured = await runFixture({
+    kind: "claude",
+    args: ["-p", "--resume", "claude-resume-1", "hello"],
+    controls: {
+      FAKE_AGENT_ENV_KEYS: "CLAUDE_CODE_OAUTH_TOKEN,OPENAI_API_KEY,ABSENT_PROVIDER_KEY",
+      CLAUDE_CODE_OAUTH_TOKEN: secretValues[0],
+      OPENAI_API_KEY: secretValues[1],
+    },
+    direct: process.platform !== "win32",
+  });
+  assert.strictEqual(captured.code, 0);
+  assert.deepStrictEqual(captured.capture.argv, ["-p", "--resume", "claude-resume-1", "hello"]);
+  assert.deepStrictEqual(captured.capture.envPresence, {
+    ABSENT_PROVIDER_KEY: false,
+    CLAUDE_CODE_OAUTH_TOKEN: true,
+    OPENAI_API_KEY: true,
+  });
+  const captureText = fs.readFileSync(captured.capturePath, "utf8");
+  for (const secret of secretValues) {
+    assert.ok(!captureText.includes(secret), "capture must never contain environment values");
+  }
+
+  // Claude success includes a fresh session, tool start/end, usage, and result.
+  const claude = await runFixture({
+    kind: "claude",
+    controls: {
+      FAKE_AGENT_TOOL: "1",
+      FAKE_AGENT_SESSION_ID: "claude-fresh-1",
+      FAKE_AGENT_TEXT: "fixture says café 👋",
+    },
+  });
+  const claudeEvents = parseJsonLines(claude.stdout);
+  assert.strictEqual(claudeEvents[0].type, "system");
+  assert.strictEqual(claudeEvents[0].session_id, "claude-fresh-1");
+  assert.ok(claudeEvents.some((event) => event.type === "assistant"
+    && event.message.content.some((block) => block.type === "tool_use")));
+  assert.ok(claudeEvents.some((event) => event.type === "user"
+    && event.message.content.some((block) => block.type === "tool_result")));
+  const claudeResult = claudeEvents.find((event) => event.type === "result");
+  assert.strictEqual(claudeResult.session_id, "claude-fresh-1");
+  assert.strictEqual(claudeResult.result, "fixture says café 👋");
+  assert.deepStrictEqual(claudeResult.usage, {
+    input_tokens: 12,
+    cache_read_input_tokens: 3,
+    cache_creation_input_tokens: 2,
+    output_tokens: 7,
+  });
+
+  // Codex success uses its native JSONL vocabulary and keeps a resumed thread id.
+  const codex = await runFixture({
+    kind: "codex",
+    args: ["exec", "resume", "codex-resume-1", "hello"],
+    controls: {
+      FAKE_AGENT_TOOL: "1",
+      FAKE_AGENT_SESSION_ID: "codex-resume-1",
+      FAKE_AGENT_TEXT: "codex fixture result",
+    },
+  });
+  const codexEvents = parseJsonLines(codex.stdout);
+  assert.deepStrictEqual(codexEvents[0], { type: "thread.started", thread_id: "codex-resume-1" });
+  assert.ok(codexEvents.some((event) => event.type === "item.started"
+    && event.item.type === "command_execution"));
+  assert.ok(codexEvents.some((event) => event.type === "item.completed"
+    && event.item.type === "command_execution" && event.item.exit_code === 0));
+  assert.ok(codexEvents.some((event) => event.type === "item.completed"
+    && event.item.type === "agent_message" && event.item.text === "codex fixture result"));
+  assert.deepStrictEqual(codexEvents.at(-1), {
+    type: "turn.completed",
+    usage: { input_tokens: 12, cached_input_tokens: 3, output_tokens: 7 },
+  });
+
+  // Resume parsing remains valid when Codex configuration overrides precede
+  // its positional thread id (the supported shape introduced in Task 7).
+  const optionAwareResume = await runFixture({
+    kind: "codex",
+    args: ["exec", "resume", "-c", 'sandbox_mode="read-only"', "codex-option-resume-1", "hello"],
+  });
+  assert.deepStrictEqual(parseJsonLines(optionAwareResume.stdout)[0], {
+    type: "thread.started",
+    thread_id: "codex-option-resume-1",
+  });
+
+  // Transport controls cover a byte split inside a multibyte character,
+  // coalesced JSONL, CRLF, and both trailing-newline states.
+  const split = await runFixture({
+    kind: "claude",
+    controls: {
+      FAKE_AGENT_TEXT: "split 👋 event",
+      FAKE_AGENT_CHUNK_MODE: "split",
+      FAKE_AGENT_CHUNK_DELAY_MS: "20",
+    },
+  });
+  assert.strictEqual(split.capture.writePlan.mode, "split");
+  assert.strictEqual(split.capture.writePlan.writes.length, 2);
+  assert.strictEqual(split.capture.writePlan.splitInsideUtf8, true,
+    "split mode must cut inside the multibyte marker");
+  assert.strictEqual(split.capture.writePlan.writes[0], split.capture.writePlan.splitOffset);
+  assert.strictEqual(parseJsonLines(split.stdout).find((event) => event.type === "result").result, "split 👋 event");
+
+  const coalesced = await runFixture({
+    kind: "codex",
+    controls: {
+      FAKE_AGENT_CHUNK_MODE: "coalesce",
+      FAKE_AGENT_LINE_ENDING: "crlf",
+      FAKE_AGENT_FINAL_NEWLINE: "0",
+    },
+  });
+  assert.ok(coalesced.stdout.includes("\r\n"), "CRLF mode must use CRLF framing");
+  assert.ok(!coalesced.stdout.endsWith("\n"), "final-newline control must omit the last newline");
+  assert.ok(parseJsonLines(coalesced.stdout).length >= 3, "coalesced mode must carry several JSONL records");
+  assert.strictEqual(coalesced.capture.writePlan.writes.length, 1,
+    "coalesced mode must perform one stdout write");
+  assert.strictEqual(coalesced.capture.writePlan.lineEnding, "crlf");
+  assert.strictEqual(coalesced.capture.writePlan.finalNewline, false);
+
+  const newline = await runFixture({
+    kind: "claude",
+    controls: { FAKE_AGENT_FINAL_NEWLINE: "1" },
+  });
+  assert.ok(newline.stdout.endsWith("\n"), "fixture must also support a final newline");
+
+  // Provider-auth failures and arbitrary non-zero exits are deterministic.
+  for (const kind of ["claude", "codex"]) {
+    const auth = await runFixture({
+      kind,
+      controls: { FAKE_AGENT_SCENARIO: "auth-failure" },
+    });
+    assert.strictEqual(auth.code, 1);
+    assert.match(auth.stderr, /authentication failed/i);
+    const authEvents = parseJsonLines(auth.stdout);
+    if (kind === "claude") {
+      assert.ok(authEvents.some((event) => event.type === "result"
+        && event.subtype === "error_during_execution" && event.is_error === true));
+      assert.ok(!authEvents.some((event) => event.subtype === "success"));
+    } else {
+      assert.ok(authEvents.some((event) => event.type === "error"
+        && /authentication failed/i.test(event.message)));
+      assert.ok(authEvents.some((event) => event.type === "turn.failed"));
+      assert.ok(!authEvents.some((event) => event.type === "turn.completed"));
+    }
+  }
+
+  const nonZero = await runFixture({
+    kind: "claude",
+    controls: {
+      FAKE_AGENT_SCENARIO: "non-zero",
+      FAKE_AGENT_EXIT_CODE: "23",
+    },
+  });
+  assert.strictEqual(nonZero.code, 23);
+
+  // A terminal event can precede child close; lifecycle tests depend on this.
+  let terminalAt = null;
+  let eofAt = null;
+  let aliveAtTerminal = false;
+  const delayed = await runFixture({
+    kind: "codex",
+    controls: { FAKE_AGENT_CLOSE_DELAY_MS: "80" },
+    onSpawn(child) {
+      let observed = "";
+      child.stdout.once("end", () => { eofAt = Date.now(); });
+      child.stdout.on("data", (chunk) => {
+        observed += chunk.toString("utf8");
+        if (terminalAt == null && observed.includes('"type":"turn.completed"')) {
+          terminalAt = Date.now();
+          aliveAtTerminal = child.exitCode === null && child.signalCode === null;
+        }
+      });
+    },
+  });
+  assert.strictEqual(delayed.code, 0);
+  assert.ok(terminalAt, "delayed-close scenario must emit a terminal event");
+  assert.ok(eofAt, "delayed-close scenario must explicitly close stdout before process close");
+  assert.strictEqual(aliveAtTerminal, true, "child must still be alive when terminal output arrives");
+  assert.ok(eofAt >= terminalAt, "stdout EOF must follow the terminal event");
+  assert.ok(delayed.closedAt - eofAt >= 65, "delayed-close control must hold after stdout EOF");
+
+  // Forced termination waits after output, records only the signal name, and
+  // then re-raises it so callers observe a genuinely signalled child.
+  const signalPath = fixturePath("signal");
+  let signalChild;
+  const forcedPromise = runFixture({
+    kind: "claude",
+    controls: {
+      FAKE_AGENT_SCENARIO: "forced-termination",
+      FAKE_AGENT_SIGNAL_CAPTURE: signalPath,
+    },
+    onSpawn(child) {
+      signalChild = child;
+      child.stdout.once("data", () => child.kill("SIGTERM"));
+    },
+  });
+  const forced = await forcedPromise;
+  assert.strictEqual(forced.code, null);
+  assert.strictEqual(forced.signal, "SIGTERM");
+  await waitForFile(signalPath);
+  assert.deepStrictEqual(JSON.parse(fs.readFileSync(signalPath, "utf8")), { signal: "SIGTERM" });
+  assert.ok(signalChild.pid > 0);
+
+  console.log("provider fixture OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(cleanup);