Codex
109 lines
9.0 KiB
TypeScript
109 lines
9.0 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { access } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import os from "node:os";
|
|
import { startManagerServer } from "../../mgr/server.js";
|
|
import { MemoryAgentRunStore } from "../../mgr/store.js";
|
|
import { ManagerClient } from "../../mgr/client.js";
|
|
import { runOnce } from "../../runner/run-once.js";
|
|
import type { FailureKind, JsonRecord, TerminalStatus } from "../../common/types.js";
|
|
import { assertNoSecretLeak, createRunWithCommand, type SelfTestCase, type SelfTestContext } from "../harness.js";
|
|
|
|
const selfTest: SelfTestCase = async (context) => {
|
|
const server = await startManagerServer({ port: 0, host: "127.0.0.1", sourceCommit: "self-test", store: new MemoryAgentRunStore() });
|
|
try {
|
|
const client = new ManagerClient(server.baseUrl);
|
|
const happy = await createRunWithCommand(client, context, "hello", "selftest-turn", 15_000);
|
|
const result = await runOnce({ managerUrl: server.baseUrl, runId: happy.runId, codexCommand: context.fakeCodexCommand, codexArgs: context.fakeCodexArgs, codexHome: context.codexHome, env: { CODEX_HOME: context.codexHome } });
|
|
assert.equal(result.terminalStatus, "completed");
|
|
assert.equal(typeof (result.runner as { id?: unknown }).id, "string");
|
|
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.ok(events.items?.some((event) => event.type === "backend_status" && JSON.stringify(event.payload).includes("run-claimed")));
|
|
assertNoSecretLeak(events);
|
|
const finalRun = await client.get(`/api/v1/runs/${happy.runId}`) as { terminalStatus?: string };
|
|
assert.equal(finalRun.terminalStatus, "completed");
|
|
const finalCommand = await client.get(`/api/v1/runs/${happy.runId}/commands/${happy.commandId}`) as { state?: string };
|
|
assert.equal(finalCommand.state, "completed");
|
|
|
|
const projectedHome = path.join(context.tmp, "runtime-codex-home");
|
|
const projected = await createRunWithCommand(client, { workspace: context.workspace, codexHome: projectedHome }, "hello projected", "selftest-projected-codex-home", 15_000);
|
|
const projectedResult = await runOnce({ managerUrl: server.baseUrl, runId: projected.runId, codexCommand: context.fakeCodexCommand, codexArgs: context.fakeCodexArgs, codexHome: projectedHome, env: { CODEX_HOME: projectedHome, AGENTRUN_CODEX_SECRET_HOME: context.codexHome } });
|
|
assert.equal(projectedResult.terminalStatus, "completed");
|
|
await access(path.join(projectedHome, "auth.json"));
|
|
await access(path.join(projectedHome, "config.toml"));
|
|
|
|
const configModel = await createRunWithCommand(client, context, "hello config model", "selftest-config-model", 15_000);
|
|
const configModelResult = await runOnce({ managerUrl: server.baseUrl, runId: configModel.runId, codexCommand: context.fakeCodexCommand, codexArgs: context.fakeCodexArgs, codexHome: context.codexHome, env: { CODEX_HOME: context.codexHome, AGENTRUN_FAKE_CODEX_MODE: "reject-unexpected-model" } });
|
|
assert.equal(configModelResult.terminalStatus, "completed", "unspecified model should be omitted so Codex config.toml remains authoritative");
|
|
|
|
const explicitModel = await createRunWithCommand(client, context, "hello explicit model placeholder", "selftest-explicit-model-placeholder", 15_000);
|
|
const explicitCommand = await client.post(`/api/v1/runs/${explicitModel.runId}/commands`, { type: "turn", payload: { prompt: "hello explicit model", model: "gpt-5.5" }, idempotencyKey: "selftest-explicit-model-command" }) as { id: string };
|
|
const explicitModelResult = await runOnce({ managerUrl: server.baseUrl, runId: explicitModel.runId, commandId: explicitCommand.id, codexCommand: context.fakeCodexCommand, codexArgs: context.fakeCodexArgs, codexHome: context.codexHome, env: { CODEX_HOME: context.codexHome, AGENTRUN_FAKE_CODEX_MODE: "require-explicit-model" } });
|
|
assert.equal(explicitModelResult.terminalStatus, "completed", "explicit command payload model should still be forwarded");
|
|
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "missing-turn-result", expectedStatus: "failed", expectedFailureKind: "backend-response-invalid" });
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-rpc-error", expectedStatus: "failed", expectedFailureKind: "provider-unavailable" });
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-terminal", expectedStatus: "failed", expectedFailureKind: "provider-unavailable" });
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-retry-event", expectedStatus: "failed", expectedFailureKind: "provider-unavailable", expectRetryError: true });
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "invalid-json", expectedStatus: "failed", expectedFailureKind: "backend-json-parse-error" });
|
|
await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "missing-terminal", expectedStatus: "failed", expectedFailureKind: "backend-timeout", timeoutMs: 500 });
|
|
await runSpawnFailureCase({ client, managerUrl: server.baseUrl, context });
|
|
|
|
return { name: "codex-stdio", tests: ["runner-lease-heartbeat", "codex-stdio-fake-turn", "codex-stdio-projected-writable-home", "codex-stdio-config-model-authoritative", "codex-stdio-explicit-model-forwarded", "codex-stdio-missing-turn-result", "codex-stdio-provider-503-rpc-error", "codex-stdio-provider-503-terminal", "codex-stdio-provider-503-retry-event", "codex-stdio-invalid-json", "codex-stdio-timeout", "codex-stdio-spawn-failure"] };
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.server.close(() => resolve()));
|
|
}
|
|
};
|
|
|
|
async function runFailureCase(options: { client: ManagerClient; managerUrl: string; context: SelfTestContext; mode: string; expectedStatus: TerminalStatus; expectedFailureKind: FailureKind; timeoutMs?: number; expectRetryError?: boolean }): Promise<void> {
|
|
const item = await createRunWithCommand(options.client, options.context, `failure ${options.mode}`, `selftest-${options.mode}`, options.timeoutMs ?? 3_000);
|
|
const result = await runOnce({
|
|
managerUrl: options.managerUrl,
|
|
runId: item.runId,
|
|
codexCommand: options.context.fakeCodexCommand,
|
|
codexArgs: options.context.fakeCodexArgs,
|
|
codexHome: options.context.codexHome,
|
|
env: { CODEX_HOME: options.context.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);
|
|
assert.ok(events.items?.some((event) => event.type === "error" && eventPayload(event).failureKind === options.expectedFailureKind), `${options.mode} expected error event failureKind ${options.expectedFailureKind}`);
|
|
if (options.expectRetryError) {
|
|
assert.ok(events.items?.some((event) => {
|
|
const payload = eventPayload(event);
|
|
return event.type === "error" && payload.willRetry === true && payload.failureKind === options.expectedFailureKind;
|
|
}), `${options.mode} expected retry error event failureKind ${options.expectedFailureKind}`);
|
|
}
|
|
const command = await options.client.get(`/api/v1/runs/${item.runId}/commands/${item.commandId}`) as { state?: string };
|
|
assert.equal(command.state, "failed", options.mode);
|
|
assertNoSecretLeak(events);
|
|
}
|
|
|
|
function eventPayload(event: { payload: unknown }): JsonRecord {
|
|
return typeof event.payload === "object" && event.payload !== null && !Array.isArray(event.payload) ? event.payload as JsonRecord : {};
|
|
}
|
|
|
|
async function runSpawnFailureCase(options: { client: ManagerClient; managerUrl: string; context: SelfTestContext }): Promise<void> {
|
|
const item = await createRunWithCommand(options.client, options.context, "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.context.codexHome,
|
|
env: { CODEX_HOME: options.context.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");
|
|
const command = await options.client.get(`/api/v1/runs/${item.runId}/commands/${item.commandId}`) as { state?: string };
|
|
assert.equal(command.state, "failed", "spawn failure");
|
|
assertNoSecretLeak(events);
|
|
}
|
|
|
|
export default selfTest;
|