@liy/agent-runner 0.1.0 → 0.2.1

package/README.md

@@ -191,8 +191,10 @@ pi --mode rpc --provider deepseek --model deepseek-v4-flash --thinking high --no
 ```
 
 The driver writes one Pi RPC `prompt` command to stdin, parses Pi stdout as
-byte-buffered JSONL, forwards Pi events as `task.progress`, and cancels with
-Pi `abort`, then `SIGTERM`, then `SIGKILL` after five seconds.
+byte-buffered JSONL, forwards native Pi records as `pi.event` or
+`pi.extension_ui_request`, routes malformed stdout/stderr as
+`harness.stdout`/`harness.stderr`, and cancels with Pi `abort`, then
+`SIGTERM`, then `SIGKILL` after five seconds.
 
 Direct DeepSeek token example:
 

package/dist/bin/agent-runner.d.ts

@@ -32,3 +32,11 @@ export declare function shouldPrintHelp(argv: string[]): boolean;
  * @returns Help text.
  */
 export declare function formatHelp(): string;
+/**
+ * Check whether this module is executing as the Node entrypoint.
+ *
+ * @param moduleUrl - Current module URL.
+ * @param argvPath - Process entrypoint path, defaulting to `process.argv[1]`.
+ * @returns Whether the module should run the CLI.
+ */
+export declare function isEntrypoint(moduleUrl: string, argvPath?: string | undefined): boolean;

package/dist/bin/agent-runner.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire as ___liy_agent_runnerCreateRequire } from "node:module";var require = ___liy_agent_runnerCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -6,6 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/bin/agent-runner.ts
+import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -15334,25 +15336,17 @@ function forwardJsonlByteStream(stream, onLine) {
     });
   });
 }
-function forwardHarnessLine(channel, line, streamName, sanitizer, driver) {
+function forwardHarnessLine(channel, taskId, harness, line, streamName, sanitizer) {
   const trimmed = sanitizer.redactText(line.trim());
   if (!trimmed) {
     return;
   }
-  try {
-    const parsed = JSON.parse(trimmed);
-    channel.send(createExecuteTaskRpcNotification("task.progress", {
-      ...driver ? { driver } : {},
-      stream: streamName,
-      event: sanitizer.redactJson(parsed)
-    }));
-  } catch {
-    channel.send(createExecuteTaskRpcNotification("task.log", {
-      ...driver ? { driver } : {},
-      stream: streamName,
-      message: trimmed
-    }));
-  }
+  channel.send(createExecuteTaskRpcNotification(`harness.${streamName}`, {
+    taskId,
+    harness,
+    stream: streamName,
+    message: trimmed
+  }));
 }
 function waitForChildClose(child) {
   return new Promise((resolve2, reject) => {
@@ -15432,10 +15426,10 @@ function startCodexJsonlHarness(input, spawnProcess) {
   let cleanupTermination = () => void 0;
   child.stdin.end(input.prompt);
   const stdoutDone = forwardHarnessLines(child.stdout, (line) => {
-    forwardHarnessLine(input.channel, line, "stdout", sanitizer);
+    forwardHarnessLine(input.channel, input.spec.taskId, "codex-jsonl", line, "stdout", sanitizer);
   });
   const stderrDone = forwardHarnessLines(child.stderr, (line) => {
-    forwardHarnessLine(input.channel, line, "stderr", sanitizer);
+    forwardHarnessLine(input.channel, input.spec.taskId, "codex-jsonl", line, "stderr", sanitizer);
   });
   const result = waitForChildClose(child).then(async (closeResult) => {
     cleanupTermination();
@@ -15512,6 +15506,7 @@ function buildPiRpcArgs(harness) {
     model,
     "--thinking",
     thinking,
+    "--no-session",
     "--no-extensions",
     "--no-prompt-templates",
     "--no-themes",
@@ -15585,11 +15580,11 @@ function startPiRpcHarness(input, spawnProcess) {
     cleanupTermination();
     await Promise.all([stdoutDone, stderrDone]);
     if (!agentEndReached && terminal.exitCode !== 0) {
-      input.channel.send(createExecuteTaskRpcNotification("task.log", {
-        driver: "pi-rpc",
-        stream: "stderr",
-        message: `pi-rpc process closed before agent_end with ${formatHarnessExit(terminal)}`
-      }));
+      forwardPiHarnessStreamLine(
+        input,
+        "stderr",
+        `pi-rpc process closed before agent_end with ${formatHarnessExit(terminal)}`
+      );
     }
     return terminal;
   })();
@@ -15611,37 +15606,57 @@ function handlePiRpcStdoutLine(input) {
   try {
     parsed = JSON.parse(trimmed);
   } catch {
-    input.input.channel.send(createExecuteTaskRpcNotification("task.log", {
-      driver: "pi-rpc",
-      stream: "stdout",
-      message: input.sanitizer.redactText(trimmed)
-    }));
+    forwardPiHarnessStreamLine(input.input, "stdout", input.sanitizer.redactText(trimmed));
     return;
   }
-  input.input.channel.send(createExecuteTaskRpcNotification("task.progress", {
-    driver: "pi-rpc",
-    stream: "stdout",
-    event: input.sanitizer.redactJson(parsed)
-  }));
-  if (parsed.type === "response" && parsed.command === "prompt" && parsed.success === false) {
-    input.onPromptRejected(new Error(`Pi RPC prompt was rejected: ${formatPiRpcError(parsed, input.sanitizer.redactText)}`));
+  if (isPiRpcResponse(parsed)) {
+    if (parsed.command === "prompt" && parsed.success === false) {
+      input.onPromptRejected(new Error(`Pi RPC prompt was rejected: ${formatPiRpcError(parsed, input.sanitizer.redactText)}`));
+    }
+    return;
+  }
+  if (isPiExtensionUiRequest(parsed)) {
+    forwardPiExtensionUiRequest(input.input, input.sanitizer.redactJson(parsed));
     return;
   }
+  forwardPiEvent(input.input, input.sanitizer.redactJson(parsed));
   if (parsed.type === "agent_end") {
     input.onAgentEnd();
   }
 }
-function forwardPiStderrLine(input, line, sanitizer) {
-  const trimmed = sanitizer.redactText(line.trim());
+function forwardPiEvent(input, event) {
+  input.channel.send(createExecuteTaskRpcNotification("pi.event", {
+    taskId: input.spec.taskId,
+    event
+  }));
+}
+function forwardPiExtensionUiRequest(input, request) {
+  input.channel.send(createExecuteTaskRpcNotification("pi.extension_ui_request", {
+    taskId: input.spec.taskId,
+    request
+  }));
+}
+function isPiRpcResponse(parsed) {
+  return parsed.type === "response" && typeof parsed.command === "string";
+}
+function isPiExtensionUiRequest(parsed) {
+  return parsed.type === "extension_ui_request" && typeof parsed.id === "string";
+}
+function forwardPiHarnessStreamLine(input, stream, message) {
+  const trimmed = message.trim();
   if (!trimmed) {
     return;
   }
-  input.channel.send(createExecuteTaskRpcNotification("task.log", {
-    driver: "pi-rpc",
-    stream: "stderr",
+  input.channel.send(createExecuteTaskRpcNotification(`harness.${stream}`, {
+    taskId: input.spec.taskId,
+    harness: "pi-rpc",
+    stream,
     message: trimmed
   }));
 }
+function forwardPiStderrLine(input, line, sanitizer) {
+  forwardPiHarnessStreamLine(input, "stderr", sanitizer.redactText(line));
+}
 function writePiRpcCommand(child, command) {
   child.stdin.write(`${JSON.stringify(command)}
 `);
@@ -15768,30 +15783,41 @@ async function runTaskAgentRunner(spec, options = {}) {
     const harness = resolveAgentRunnerHarness(config2, spec.agentRunner);
     const channel = await openControlChannel(spec.rpcUrl);
     try {
-      channel.send(createExecuteTaskRpcNotification("task.started", {
+      sendTaskStatus(channel, {
         taskId: spec.taskId,
-        workspaceDir: spec.workspaceDir
-      }));
+        status: "running"
+      });
       const completion = await runHarnessAndReadCompletion({
         spec,
         harness,
         channel,
+        ...spec.timeouts?.taskMs !== void 0 ? { timeoutMs: spec.timeouts.taskMs } : {},
         ...options.env ? { env: options.env } : {}
       });
-      channel.send(createExecuteTaskRpcNotification(`task.${completion.status}`, {
+      sendTaskStatus(channel, {
         taskId: spec.taskId,
         ...completion
-      }));
+      });
       return completion;
+    } catch (error48) {
+      const completion = createFailedCompletion(error48);
+      await writeTaskCompletion({
+        paths,
+        completion
+      }).catch(() => void 0);
+      try {
+        sendTaskStatus(channel, {
+          taskId: spec.taskId,
+          ...completion
+        });
+      } catch {
+      }
+      throw error48;
     } finally {
       channel.close();
     }
   } catch (error48) {
-    const completion = {
-      status: "failed",
-      summary: error48 instanceof Error ? error48.message : String(error48),
-      artifactIds: []
-    };
+    const completion = createFailedCompletion(error48);
     await writeTaskCompletion({
       paths,
       completion
@@ -15799,6 +15825,16 @@ async function runTaskAgentRunner(spec, options = {}) {
     throw error48;
   }
 }
+function sendTaskStatus(channel, params) {
+  channel.send(createExecuteTaskRpcNotification("task.status", params));
+}
+function createFailedCompletion(error48) {
+  return {
+    status: "failed",
+    summary: error48 instanceof Error ? error48.message : String(error48),
+    artifactIds: []
+  };
+}
 function createHarnessEnvironment(input) {
   const baseEnv = input.env ?? process.env;
   const harnessEnv = {};
@@ -15893,7 +15929,28 @@ async function runHarnessAndReadCompletion(input) {
       ...input.env ? { env: input.env } : {}
     })
   });
-  const result = await activeRun.result;
+  const result = await waitForHarnessResult({
+    run: activeRun,
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+  });
+  if (result === "timeout") {
+    activeRun.cancel();
+    await waitForHarnessCleanup(activeRun.result);
+    const recovered = await readTaskCompletion(paths).catch(() => void 0);
+    if (recovered) {
+      await validateTaskArtifactFiles({
+        paths,
+        completion: recovered
+      });
+      return recovered;
+    }
+    const completion2 = createTimeoutCompletion(input.timeoutMs);
+    await writeTaskCompletion({
+      paths,
+      completion: completion2
+    });
+    return completion2;
+  }
   if (cancelRequested) {
     const completion2 = {
       status: "cancelled",
@@ -15906,7 +15963,14 @@ async function runHarnessAndReadCompletion(input) {
     });
     return completion2;
   }
-  const completion = await readTaskCompletion(paths);
+  const completion = await readTaskCompletion(paths).catch(async (error48) => {
+    const fallback = createMissingCompletionFailure(error48);
+    await writeTaskCompletion({
+      paths,
+      completion: fallback
+    });
+    return fallback;
+  });
   await validateTaskArtifactFiles({
     paths,
     completion
@@ -15916,6 +15980,46 @@ async function runHarnessAndReadCompletion(input) {
   }
   return completion;
 }
+async function waitForHarnessResult(input) {
+  const timeoutMs = normalizeTimeoutMs(input.timeoutMs);
+  if (timeoutMs === void 0) {
+    return input.run.result;
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      input.run.result,
+      new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2("timeout"), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function waitForHarnessCleanup(result) {
+  await Promise.race([
+    result.catch(() => void 0),
+    sleep(1e4)
+  ]);
+}
+function createTimeoutCompletion(timeoutMs) {
+  return {
+    status: "failed",
+    summary: timeoutMs === void 0 ? "execute_task harness timed out" : `execute_task harness timed out after ${timeoutMs}ms`,
+    artifactIds: []
+  };
+}
+function createMissingCompletionFailure(error48) {
+  const detail = error48 instanceof Error ? error48.message : String(error48);
+  return {
+    status: "failed",
+    summary: `harness ended without writing state/completion.json: ${detail}`,
+    artifactIds: []
+  };
+}
 function validateRunnerSpec(spec) {
   if ("harness" in spec) {
     throw new Error("task spec harness is no longer supported; use task spec agentRunner");
@@ -15929,6 +16033,9 @@ function validateRunnerSpec(spec) {
   if (!spec.rpcUrl?.trim()) {
     throw new Error("task spec rpcUrl is required");
   }
+  if (spec.timeouts?.taskMs !== void 0 && normalizeTimeoutMs(spec.timeouts.taskMs) === void 0) {
+    throw new Error("task spec timeouts.taskMs must be a positive finite number");
+  }
   if (spec.agentRunner?.harness !== void 0 && typeof spec.agentRunner.harness !== "string") {
     throw new Error("task spec agentRunner.harness must be a string");
   }
@@ -15941,6 +16048,14 @@ function validateRunnerSpec(spec) {
   }
   assertNoForbiddenSpecKeys(spec);
 }
+function normalizeTimeoutMs(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
 async function openControlChannel(url2) {
   const WebSocketCtor = globalThis.WebSocket;
   if (!WebSocketCtor) {
@@ -16063,11 +16178,20 @@ if (isEntrypoint(import.meta.url)) {
     process.exitCode = 1;
   });
 }
-function isEntrypoint(moduleUrl) {
-  return process.argv[1] ? fileURLToPath(moduleUrl) === resolve(process.argv[1]) : false;
+function isEntrypoint(moduleUrl, argvPath = process.argv[1]) {
+  return argvPath ? realpathEntrypointPath(fileURLToPath(moduleUrl)) === realpathEntrypointPath(argvPath) : false;
+}
+function realpathEntrypointPath(path) {
+  const resolved = resolve(path);
+  try {
+    return realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
 }
 export {
   formatHelp,
+  isEntrypoint,
   main,
   readConfigPathArg,
   readTaskSpecArg,