硬化 Codex stdio backend 错误观测

2026-05-29 11:47:03 +08:00
parent a240122039
commit 843112ebff
8 changed files with 556 additions and 130 deletions
@@ -1,6 +1,7 @@
 import * as readline from "node:readline";

 const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+const mode = process.env.AGENTRUN_FAKE_CODEX_MODE ?? "success";
 let threadCounter = 0;
 let turnCounter = 0;

@@ -9,6 +10,10 @@ for await (const line of rl) {
  if (trimmed.length === 0) continue;
  const message = JSON.parse(trimmed) as { id?: number; method?: string; params?: Record<string, unknown> };
  if (message.method === "initialize") {
+    if (mode === "invalid-json") {
+      process.stdout.write('{"token":"test-token-material"\n');
+      process.exit(0);
+    }
    respond(message.id, { serverInfo: { name: "fake-codex-app-server", version: "self-test" } });
    continue;
  }
@@ -26,6 +31,17 @@ for await (const line of rl) {
    continue;
  }
  if (message.method === "turn/start") {
+    if (mode === "missing-turn-result") {
+      respond(message.id, {});
+      continue;
+    }
+    if (mode === "missing-terminal") {
+      turnCounter += 1;
+      const turn = { id: `turn_selftest_${turnCounter}`, status: "running" };
+      notify("turn/started", { turn });
+      respond(message.id, { turn });
+      continue;
+    }
    turnCounter += 1;
    const turn = { id: `turn_selftest_${turnCounter}`, status: "completed" };
    notify("turn/started", { turn });
@@ -7,6 +7,7 @@ import { startManagerServer } from "../mgr/server.js";
 import { ManagerClient } from "../mgr/client.js";
 import { runOnce } from "../runner/run-once.js";
 import { redactText } from "../common/redaction.js";
+import type { FailureKind, JsonRecord, TerminalStatus } from "../common/types.js";

 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const tmp = await mkdtemp(path.join(os.tmpdir(), "agentrun-selftest-"));
@@ -21,45 +22,133 @@ try {
  await writeFile(path.join(workspace, "README.md"), "self-test workspace\n");

  assert.equal(redactText("Authorization: Bearer abc123"), "Authorization: Bearer REDACTED");
+  assert.equal(redactText('{"token":"test-token-material"}').includes("test-token-material"), false);

  const server = await startManagerServer({ port: 0, host: "127.0.0.1", sourceCommit: "self-test" });
  try {
    const client = new ManagerClient(server.baseUrl);
    const health = await client.get("/health/readiness") as { database?: { adapter?: string } };
    assert.equal(health.database?.adapter, "memory-self-test");
-    const run = await client.post("/api/v1/runs", {
-      tenantId: "unidesk",
-      projectId: "pikasTech/unidesk",
-      workspaceRef: { kind: "host-path", path: workspace },
-      providerId: "G14",
-      backendProfile: "codex",
-      executionPolicy: {
-        sandbox: "workspace-write",
-        approval: "never",
-        timeoutMs: 15_000,
-        network: "default",
-        secretScope: { allowCredentialEcho: false, providerCredentials: [{ profile: "codex", secretRef: { name: "agentrun-v01-provider-codex", keys: ["auth.json", "config.toml"], mountPath: codexHome } }] },
-      },
-      traceSink: null,
-    }) as { id: string };
-    const command = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt: "hello" }, idempotencyKey: "selftest-turn" }) as { id: string };
-    const duplicate = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt: "hello" }, idempotencyKey: "selftest-turn" }) as { id: string };
-    assert.equal(duplicate.id, command.id);
    const fakePath = path.join(root, "src/selftest/fake-codex-app-server.ts");
    const fakeCommand = process.env.AGENTRUN_SELFTEST_CODEX_COMMAND ?? process.execPath;
    const fakeArgs = process.env.AGENTRUN_SELFTEST_CODEX_ARGS ? JSON.parse(process.env.AGENTRUN_SELFTEST_CODEX_ARGS) as string[] : [fakePath];
-    const result = await runOnce({ managerUrl: server.baseUrl, runId: run.id, codexCommand: fakeCommand, codexArgs: fakeArgs, codexHome, env: { CODEX_HOME: codexHome } });
+
+    const happy = await createRunWithCommand(client, workspace, codexHome, "hello", "selftest-turn", 15_000);
+    const result = await runOnce({ managerUrl: server.baseUrl, runId: happy.runId, codexCommand: fakeCommand, codexArgs: fakeArgs, codexHome, env: { CODEX_HOME: codexHome } });
    assert.equal(result.terminalStatus, "completed");
-    const events = await client.get(`/api/v1/runs/${run.id}/events?afterSeq=0&limit=100`) as { items?: Array<{ type: string; payload: unknown }> };
+    const events = await client.get(`/api/v1/runs/${happy.runId}/events?afterSeq=0&limit=100`) as { items?: Array<{ type: string; payload: unknown }> };
    assert.ok(events.items?.some((event) => event.type === "assistant_message"));
-    assert.equal(JSON.stringify(events).includes("test-token-material"), false);
-    assert.equal(JSON.stringify(events).includes("Bearer test-token"), false);
-    const finalRun = await client.get(`/api/v1/runs/${run.id}`) as { terminalStatus?: string };
+    assertNoSecretLeak(events);
+    const finalRun = await client.get(`/api/v1/runs/${happy.runId}`) as { terminalStatus?: string };
    assert.equal(finalRun.terminalStatus, "completed");
-    console.log(JSON.stringify({ ok: true, tests: ["manager-memory-lifecycle", "codex-stdio-fake-turn", "redaction"], runId: run.id }));
+
+    await runFailureCase({
+      client,
+      managerUrl: server.baseUrl,
+      workspace,
+      codexHome,
+      fakeCommand,
+      fakeArgs,
+      mode: "missing-turn-result",
+      expectedStatus: "failed",
+      expectedFailureKind: "backend-response-invalid",
+    });
+    await runFailureCase({
+      client,
+      managerUrl: server.baseUrl,
+      workspace,
+      codexHome,
+      fakeCommand,
+      fakeArgs,
+      mode: "invalid-json",
+      expectedStatus: "failed",
+      expectedFailureKind: "backend-json-parse-error",
+    });
+    await runFailureCase({
+      client,
+      managerUrl: server.baseUrl,
+      workspace,
+      codexHome,
+      fakeCommand,
+      fakeArgs,
+      mode: "missing-terminal",
+      expectedStatus: "failed",
+      expectedFailureKind: "backend-timeout",
+      timeoutMs: 500,
+    });
+    await runSpawnFailureCase({
+      client,
+      managerUrl: server.baseUrl,
+      workspace,
+      codexHome,
+    });
+
+    console.log(JSON.stringify({ ok: true, tests: ["manager-memory-lifecycle", "codex-stdio-fake-turn", "codex-stdio-missing-turn-result", "codex-stdio-invalid-json", "codex-stdio-timeout", "codex-stdio-spawn-failure", "redaction"], runId: happy.runId }));
  } finally {
    await new Promise<void>((resolve) => server.server.close(() => resolve()));
  }
 } finally {
  await rm(tmp, { recursive: true, force: true });
 }
+
+async function createRunWithCommand(client: ManagerClient, workspace: string, codexHome: string, prompt: string, idempotencyKey: string, timeoutMs: number): Promise<{ runId: string; commandId: string }> {
+  const run = await client.post("/api/v1/runs", {
+    tenantId: "unidesk",
+    projectId: "pikasTech/unidesk",
+    workspaceRef: { kind: "host-path", path: workspace },
+    providerId: "G14",
+    backendProfile: "codex",
+    executionPolicy: {
+      sandbox: "workspace-write",
+      approval: "never",
+      timeoutMs,
+      network: "default",
+      secretScope: { allowCredentialEcho: false, providerCredentials: [{ profile: "codex", secretRef: { name: "agentrun-v01-provider-codex", keys: ["auth.json", "config.toml"], mountPath: codexHome } }] },
+    },
+    traceSink: null,
+  }) as { id: string };
+  const command = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt }, idempotencyKey }) as { id: string };
+  const duplicate = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt }, idempotencyKey }) as { id: string };
+  assert.equal(duplicate.id, command.id);
+  return { runId: run.id, commandId: command.id };
+}
+
+async function runFailureCase(options: { client: ManagerClient; managerUrl: string; workspace: string; codexHome: string; fakeCommand: string; fakeArgs: string[]; mode: string; expectedStatus: TerminalStatus; expectedFailureKind: FailureKind; timeoutMs?: number }): Promise<void> {
+  const item = await createRunWithCommand(options.client, options.workspace, options.codexHome, `failure ${options.mode}`, `selftest-${options.mode}`, options.timeoutMs ?? 3_000);
+  const result = await runOnce({
+    managerUrl: options.managerUrl,
+    runId: item.runId,
+    codexCommand: options.fakeCommand,
+    codexArgs: options.fakeArgs,
+    codexHome: options.codexHome,
+    env: { CODEX_HOME: options.codexHome, AGENTRUN_FAKE_CODEX_MODE: options.mode },
+  }) as JsonRecord;
+  assert.equal(result.terminalStatus, options.expectedStatus, options.mode);
+  assert.equal(result.failureKind, options.expectedFailureKind, options.mode);
+  const events = await options.client.get(`/api/v1/runs/${item.runId}/events?afterSeq=0&limit=100`) as { items?: Array<{ type: string; payload: unknown }> };
+  assert.ok(events.items?.some((event) => event.type === "error"), options.mode);
+  assertNoSecretLeak(events);
+}
+
+async function runSpawnFailureCase(options: { client: ManagerClient; managerUrl: string; workspace: string; codexHome: string }): Promise<void> {
+  const item = await createRunWithCommand(options.client, options.workspace, options.codexHome, "failure spawn", "selftest-spawn-failure", 3_000);
+  const result = await runOnce({
+    managerUrl: options.managerUrl,
+    runId: item.runId,
+    codexCommand: path.join(os.tmpdir(), `agentrun-missing-codex-${process.pid}`),
+    codexArgs: [],
+    codexHome: options.codexHome,
+    env: { CODEX_HOME: options.codexHome },
+  }) as JsonRecord;
+  assert.equal(result.terminalStatus, "failed", "spawn failure");
+  assert.equal(result.failureKind, "backend-spawn-failed", "spawn failure");
+  const events = await options.client.get(`/api/v1/runs/${item.runId}/events?afterSeq=0&limit=100`) as { items?: Array<{ type: string; payload: unknown }> };
+  assert.ok(events.items?.some((event) => event.type === "error"), "spawn failure");
+  assertNoSecretLeak(events);
+}
+
+function assertNoSecretLeak(value: unknown): void {
+  const text = JSON.stringify(value);
+  assert.equal(text.includes("test-token-material"), false);
+  assert.equal(text.includes("Bearer test-token"), false);
+}