feat: 打通 v0.1 runner job 正式路径

src/selftest/cases/20-runner-k8s-job.ts

@@ -1,4 +1,6 @@
 import assert from "node:assert/strict";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
 import { startManagerServer } from "../../mgr/server.js";
 import { MemoryAgentRunStore } from "../../mgr/store.js";
 import { ManagerClient } from "../../mgr/client.js";
@@ -23,7 +25,41 @@ const selfTest: SelfTestCase = async (context) => {
     assert.equal(rendered.mutation, false);
     assert.equal((rendered.jobIdentity as { serviceAccountName?: string }).serviceAccountName, "agentrun-v01-runner");
     assertNoSecretLeak(rendered);
-    return { name: "runner-k8s-job", tests: ["runner-k8s-job-dry-run"] };
+
+    const fakeKubectl = path.join(context.tmp, "fake-kubectl.js");
+    const createdManifest = path.join(context.tmp, "created-runner-job.json");
+    await writeFile(fakeKubectl, `#!/usr/bin/env bun
+const chunks = [];
+for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
+const text = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString("utf8");
+await Bun.write(${JSON.stringify(createdManifest)}, text);
+const manifest = JSON.parse(text);
+console.log(JSON.stringify({ apiVersion: manifest.apiVersion, kind: manifest.kind, metadata: { uid: "job-uid-selftest", resourceVersion: "1", name: manifest.metadata.name, namespace: manifest.metadata.namespace } }));
+`);
+    await chmod(fakeKubectl, 0o755);
+    await mkdir(path.dirname(fakeKubectl), { recursive: true });
+    const serverWithKubectl = await startManagerServer({
+      port: 0,
+      host: "127.0.0.1",
+      sourceCommit: "self-test",
+      store: new MemoryAgentRunStore(),
+      runnerJobDefaults: {
+        namespace: "agentrun-v01",
+        managerUrl: "http://agentrun-mgr.agentrun-v01.svc.cluster.local:8080",
+        image: "127.0.0.1:5000/agentrun/agentrun-mgr@sha256:1111111111111111111111111111111111111111111111111111111111111111",
+        kubectlCommand: fakeKubectl,
+      },
+    });
+    try {
+      const jobClient = new ManagerClient(serverWithKubectl.baseUrl);
+      const jobItem = await createRunWithCommand(jobClient, context, "job create smoke", "selftest-job-create", 15_000);
+      const created = await jobClient.post(`/api/v1/runs/${jobItem.runId}/runner-jobs`, { commandId: jobItem.commandId, attemptId: "attempt_selftest_create" });
+      assert.equal((created as { mutation?: unknown }).mutation, true);
+      assertNoSecretLeak(created);
+    } finally {
+      await new Promise<void>((resolve) => serverWithKubectl.server.close(() => resolve()));
+    }
+    return { name: "runner-k8s-job", tests: ["runner-k8s-job-dry-run", "runner-k8s-job-create-api"] };
   } finally {
     await new Promise<void>((resolve) => server.server.close(() => resolve()));
   }

src/selftest/cases/30-codex-stdio.ts

@@ -22,6 +22,8 @@ const selfTest: SelfTestCase = async (context) => {
     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");
 
     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: "invalid-json", expectedStatus: "failed", expectedFailureKind: "backend-json-parse-error" });
@@ -48,6 +50,8 @@ async function runFailureCase(options: { client: ManagerClient; managerUrl: stri
   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);
+  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);
 }
 
@@ -65,6 +69,8 @@ async function runSpawnFailureCase(options: { client: ManagerClient; managerUrl:
   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);
 }