feat: 补齐 HWLAB 手动调度能力

src/runner/run-once.ts

@@ -1,5 +1,6 @@
 import { RunnerManagerApi, failureKindFromError, terminalStatusForFailure, errorMessage } from "./manager-api.js";
 import { runBackendTurn, type BackendAdapterOptions } from "../backend/adapter.js";
+import { materializeResourceBundle } from "./resource-bundle.js";
 import type { BackendProfile, JsonRecord, RunRecord, RunnerRecord } from "../common/types.js";
 import { AgentRunError } from "../common/errors.js";
 
@@ -21,6 +22,7 @@ export interface RunnerOnceOptions extends BackendAdapterOptions {
 export async function runOnce(options: RunnerOnceOptions): Promise<JsonRecord> {
   const api = new RunnerManagerApi(options.managerUrl);
   const targetRun = await api.client.get(`/api/v1/runs/${encodeURIComponent(options.runId)}`) as RunRecord;
+  if (isTerminalRun(targetRun)) return { terminalStatus: targetRun.terminalStatus, failureKind: targetRun.failureKind, run: targetRun, skipped: "run-terminal" } as JsonRecord;
   if (options.backendProfile && options.backendProfile !== targetRun.backendProfile) {
     throw new AgentRunError("schema-invalid", `runner backendProfile ${options.backendProfile} does not match run backendProfile ${targetRun.backendProfile}`, { httpStatus: 400 });
   }
@@ -55,9 +57,60 @@ export async function runOnce(options: RunnerOnceOptions): Promise<JsonRecord> {
     return { runner, claimed, terminalStatus: "blocked", failureKind: "schema-invalid", polledCommands: commandsResponse.items.length };
   }
   await api.ackCommand(command.id);
-  const result = await runBackendTurn(claimed, command, options);
-  for (const event of result.events) await api.appendEvent(options.runId, event);
-  await api.reportCommandStatus(command.id, { terminalStatus: result.terminalStatus, failureKind: result.failureKind, failureMessage: result.failureMessage });
-  const finalRun = await api.reportStatus(options.runId, { terminalStatus: result.terminalStatus, failureKind: result.failureKind, failureMessage: result.failureMessage }) as RunRecord;
-  return { runner, commandId: command.id, terminalStatus: result.terminalStatus, failureKind: result.failureKind, run: finalRun } as JsonRecord;
+  const acked = await api.getCommand(options.runId, command.id);
+  if (acked.state === "cancelled") return await reportCancelled(api, options.runId, command.id, runner, claimed, "command cancelled before backend start");
+  await assertNotCancelled(api, options.runId, command.id);
+  const abortController = new AbortController();
+  const stopCancelWatch = watchCancellation(api, options.runId, command.id, abortController);
+  let workspacePath: string | undefined;
+  try {
+    const materialized = await materializeResourceBundle(claimed.resourceBundleRef ?? null, options.env ?? process.env);
+    if (materialized) {
+      workspacePath = materialized.workspacePath;
+      await api.appendEvent(options.runId, { type: "backend_status", payload: materialized.event });
+    }
+    await assertNotCancelled(api, options.runId, command.id);
+    const result = await runBackendTurn(claimed, command, { ...options, ...(workspacePath ? { workspacePath } : {}), abortSignal: abortController.signal });
+    for (const event of result.events) await api.appendEvent(options.runId, event);
+    await api.reportCommandStatus(command.id, { terminalStatus: result.terminalStatus, failureKind: result.failureKind, failureMessage: result.failureMessage });
+    const finalRun = await api.reportStatus(options.runId, { terminalStatus: result.terminalStatus, failureKind: result.failureKind, failureMessage: result.failureMessage, ...(result.threadId ? { threadId: result.threadId } : {}), ...(result.turnId ? { turnId: result.turnId } : {}) }) as RunRecord;
+    return { runner, commandId: command.id, terminalStatus: result.terminalStatus, failureKind: result.failureKind, run: finalRun } as JsonRecord;
+  } finally {
+    stopCancelWatch();
+  }
+}
+
+function isTerminalRun(run: RunRecord): boolean {
+  return run.status === "completed" || run.status === "failed" || run.status === "blocked" || run.status === "cancelled";
+}
+
+async function assertNotCancelled(api: RunnerManagerApi, runId: string, commandId: string): Promise<void> {
+  const [run, command] = await Promise.all([api.getRun(runId), api.getCommand(runId, commandId)]);
+  if (run.status === "cancelled" || command.state === "cancelled") throw new AgentRunError("cancelled", "run or command was cancelled", { httpStatus: 409 });
+}
+
+function watchCancellation(api: RunnerManagerApi, runId: string, commandId: string, controller: AbortController): () => void {
+  let stopped = false;
+  const check = async (): Promise<void> => {
+    if (stopped || controller.signal.aborted) return;
+    try {
+      const [run, command] = await Promise.all([api.getRun(runId), api.getCommand(runId, commandId)]);
+      if (run.status === "cancelled" || command.state === "cancelled") controller.abort();
+    } catch {
+      // Cancellation polling must not hide the backend's own terminal result.
+    }
+  };
+  const timer = setInterval(() => { void check(); }, 2_000);
+  void check();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
+async function reportCancelled(api: RunnerManagerApi, runId: string, commandId: string, runner: RunnerRecord, claimed: RunRecord, message: string): Promise<JsonRecord> {
+  await api.appendEvent(runId, { type: "terminal_status", payload: { terminalStatus: "cancelled", failureKind: "cancelled", message } });
+  await api.reportCommandStatus(commandId, { terminalStatus: "cancelled", failureKind: "cancelled", failureMessage: message });
+  const finalRun = await api.reportStatus(runId, { terminalStatus: "cancelled", failureKind: "cancelled", failureMessage: message });
+  return { runner, commandId, claimed, terminalStatus: "cancelled", failureKind: "cancelled", run: finalRun };
 }