feat: add v0.1 runtime skeleton

src/selftest/fake-codex-app-server.ts

@@ -0,0 +1,48 @@
+import * as readline from "node:readline";
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+let threadCounter = 0;
+let turnCounter = 0;
+
+for await (const line of rl) {
+  const trimmed = String(line).trim();
+  if (trimmed.length === 0) continue;
+  const message = JSON.parse(trimmed) as { id?: number; method?: string; params?: Record<string, unknown> };
+  if (message.method === "initialize") {
+    respond(message.id, { serverInfo: { name: "fake-codex-app-server", version: "self-test" } });
+    continue;
+  }
+  if (message.method === "thread/start") {
+    threadCounter += 1;
+    const thread = { id: `thread_selftest_${threadCounter}` };
+    notify("thread/started", { thread });
+    respond(message.id, { thread });
+    continue;
+  }
+  if (message.method === "thread/resume") {
+    const thread = { id: String(message.params?.threadId ?? "thread_selftest_resumed") };
+    notify("thread/started", { thread });
+    respond(message.id, { thread });
+    continue;
+  }
+  if (message.method === "turn/start") {
+    turnCounter += 1;
+    const turn = { id: `turn_selftest_${turnCounter}`, status: "completed" };
+    notify("turn/started", { turn });
+    notify("item/agentMessage/delta", { itemId: "msg_selftest", delta: "fake codex stdio reply" });
+    notify("item/commandExecution/outputDelta", { itemId: "cmd_selftest", delta: "Authorization: Bearer test-token\n" });
+    notify("turn/completed", { turn });
+    respond(message.id, { turn });
+    continue;
+  }
+  respond(message.id, null, { code: -32601, message: `unsupported fake method ${message.method ?? "unknown"}` });
+}
+
+function respond(id: number | undefined, result: unknown, error?: unknown): void {
+  if (id === undefined) return;
+  process.stdout.write(`${JSON.stringify(error ? { id, error } : { id, result })}\n`);
+}
+
+function notify(method: string, params: unknown): void {
+  process.stdout.write(`${JSON.stringify({ method, params })}\n`);
+}

src/selftest/run.ts

@@ -0,0 +1,65 @@
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+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";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const tmp = await mkdtemp(path.join(os.tmpdir(), "agentrun-selftest-"));
+
+try {
+  const codexHome = path.join(tmp, "codex-home");
+  const workspace = path.join(tmp, "workspace");
+  await mkdir(codexHome, { recursive: true });
+  await mkdir(workspace, { recursive: true });
+  await writeFile(path.join(codexHome, "auth.json"), JSON.stringify({ token: "test-token-material" }));
+  await writeFile(path.join(codexHome, "config.toml"), "model = \"gpt-test\"\n");
+  await writeFile(path.join(workspace, "README.md"), "self-test workspace\n");
+
+  assert.equal(redactText("Authorization: Bearer abc123"), "Authorization: Bearer REDACTED");
+
+  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 } });
+    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 }> };
+    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 };
+    assert.equal(finalRun.terminalStatus, "completed");
+    console.log(JSON.stringify({ ok: true, tests: ["manager-memory-lifecycle", "codex-stdio-fake-turn", "redaction"], runId: run.id }));
+  } finally {
+    await new Promise<void>((resolve) => server.server.close(() => resolve()));
+  }
+} finally {
+  await rm(tmp, { recursive: true, force: true });
+}