@skill-harness/adapters 0.30.0 → 0.31.0

package/dist/pi-json.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionTraceV1, ModelRef, RunMode } from "@skill-harness/core";
+import type { ExecutionTraceV1, ModelRef, RunMode, ProcessObservation } from "@skill-harness/core";
 /**
  * Run `pi --mode json` and build an execution trace, **streaming**.
  *
@@ -9,10 +9,10 @@ import type { ExecutionTraceV1, ModelRef, RunMode } from "@skill-harness/core";
  * into a string (which is what the shared `exec()` helper does) would exhaust
  * memory partway through a long wave, taking the whole run with it.
  *
- * So this deliberately does NOT reuse `exec()`. The two quadratic event types are
+ * The lifecycle is shared with `exec()`, but capture is streaming. Quadratic events are
  * dropped as each line arrives, so the giant ones are never retained; the
- * remainder — a few KB of terminal events — is held until `close` and parsed
- * once. What this bounds is the 52 MB, not the residue.
+ * remainder is bounded by both bytes and record count. Oversized lines or retained
+ * evidence terminate the owned process and report an infrastructure error.
  */
 /**
  * The two quadratic event types, matched at the head of the object where pi
@@ -37,6 +37,11 @@ export interface PiJsonRunOptions {
      * as "inherit", so the control arm (which never sets this) is unaffected.
      */
     env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    maxLineBytes?: number;
+    maxRetainedBytes?: number;
+    maxRecords?: number;
+    maxOutputBytes?: number;
 }
 export interface PiJsonRunResult {
     trace: ExecutionTraceV1;
@@ -51,5 +56,6 @@ export interface PiJsonRunResult {
      * verdict.
      */
     providerFailure: string | null;
+    observation?: ProcessObservation;
 }
 export declare function runPiJson(opts: PiJsonRunOptions): Promise<PiJsonRunResult>;

package/dist/pi-json.js

@@ -1,6 +1,4 @@
-import { spawn } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
-import { parseTrace, providerFailureFromJsonLine } from "@skill-harness/core";
+import { BoundedCapture, ProcessOutputLimitError, runProcess, parseTrace, providerFailureFromJsonLine } from "@skill-harness/core";
 /**
  * Run `pi --mode json` and build an execution trace, **streaming**.
  *
@@ -11,10 +9,10 @@ import { parseTrace, providerFailureFromJsonLine } from "@skill-harness/core";
  * into a string (which is what the shared `exec()` helper does) would exhaust
  * memory partway through a long wave, taking the whole run with it.
  *
- * So this deliberately does NOT reuse `exec()`. The two quadratic event types are
+ * The lifecycle is shared with `exec()`, but capture is streaming. Quadratic events are
  * dropped as each line arrives, so the giant ones are never retained; the
- * remainder — a few KB of terminal events — is held until `close` and parsed
- * once. What this bounds is the 52 MB, not the residue.
+ * remainder is bounded by both bytes and record count. Oversized lines or retained
+ * evidence terminate the owned process and report an infrastructure error.
  */
 /**
  * The two quadratic event types, matched at the head of the object where pi
@@ -24,105 +22,99 @@ import { parseTrace, providerFailureFromJsonLine } from "@skill-harness/core";
 export const SKIPPED_TYPE_RE = /^\s*\{\s*"type"\s*:\s*"(?:message_update|tool_execution_update)"/;
 /** How much stderr to retain — enough to diagnose, bounded so a loop cannot blow up. */
 const MAX_STDERR_CHARS = 8000;
-export function runPiJson(opts) {
-    return new Promise((resolve, reject) => {
-        const child = spawn("pi", opts.args, {
-            cwd: opts.cwd,
-            env: opts.env,
-            // stdin from /dev/null: pi hangs waiting on it otherwise, and a hang in a
-            // wave is indistinguishable from a slow model until the timeout fires.
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const kept = [];
-        let stderr = "";
-        let providerFailure = null;
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            child.kill("SIGKILL");
-            reject(new Error(`pi --mode json timed out after ${opts.timeoutMs}ms`));
-        }, opts.timeoutMs);
-        const acceptLine = (line) => {
-            // Prefilter before the full parse: the events skipped here are both the
-            // overwhelming majority of lines and by far the largest.
-            //
-            // Anchored on the `type` field, NOT a substring of the whole line. A raw
-            // `line.includes('"message_update"')` also matched any event whose
-            // ARGUMENTS contained that text — so a `tool_execution_start` for, say,
-            // `grep '"message_update"' logs/` was dropped before parsing, and a
-            // dropped start means the call never enters the trace at all. A
-            // `forbid_calls` gate on that tool then passed for want of the evidence.
-            if (!line.trim())
-                return;
-            if (SKIPPED_TYPE_RE.test(line)) {
-                // Validate but never retain the quadratic payload. Otherwise a malformed
-                // update could disappear and make an incomplete capture look successful.
-                try {
-                    const event = JSON.parse(line);
-                    // A late update invalidates an earlier final/settlement. Consecutive
-                    // updates need only one small state marker, not their accumulated text.
-                    if (event.type === "message_update" && kept.at(-1) !== '{"type":"message_update"}') {
-                        kept.push('{"type":"message_update"}');
-                    }
-                }
-                catch {
-                    kept.push("null"); // one parser-owned malformed-record error per bad line
-                }
+export async function runPiJson(opts) {
+    const kept = [];
+    const stderr = new BoundedCapture(MAX_STDERR_CHARS);
+    const maxLine = opts.maxLineBytes ?? 8 * 1024 * 1024;
+    const maxRetained = opts.maxRetainedBytes ?? 16 * 1024 * 1024;
+    const maxRecords = opts.maxRecords ?? 50_000;
+    for (const limit of [maxLine, maxRetained, maxRecords])
+        if (!Number.isSafeInteger(limit) || limit < 1)
+            throw new Error("Invalid Pi capture limit");
+    let retainedBytes = 0;
+    let providerFailure = null;
+    const keep = (line) => {
+        const size = Buffer.byteLength(line, "utf8");
+        if (retainedBytes + size > maxRetained || kept.length >= maxRecords)
+            throw new ProcessOutputLimitError("Pi retained JSON evidence limit exceeded");
+        kept.push(line);
+        retainedBytes += size;
+    };
+    const acceptLine = (line) => {
+        // Prefilter before the full parse: the events skipped here are both the
+        // overwhelming majority of lines and by far the largest.
+        //
+        // Anchored on the `type` field, NOT a substring of the whole line. A raw
+        // `line.includes('"message_update"')` also matched any event whose
+        // ARGUMENTS contained that text — so a `tool_execution_start` for, say,
+        // `grep '"message_update"' logs/` was dropped before parsing, and a
+        // dropped start means the call never enters the trace at all. A
+        // `forbid_calls` gate on that tool then passed for want of the evidence.
+        if (!line.trim())
+            return;
+        if (SKIPPED_TYPE_RE.test(line)) {
+            // Validate but never retain the quadratic payload. Otherwise a malformed
+            // update could disappear and make an incomplete capture look successful.
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                keep("null"); // one parser-owned malformed-record error per bad line
                 return;
             }
-            kept.push(line);
-            if (providerFailure === null)
-                providerFailure = providerFailureFromJsonLine(line);
-        };
-        // JSONL is LF-framed. readline also splits legal Unicode string separators
-        // on newer Node runtimes, turning valid model text into malformed records.
-        const decoder = new StringDecoder("utf8");
-        let pending = "";
-        child.stdout.on("data", (chunk) => {
-            pending += decoder.write(chunk);
+            // A late update invalidates an earlier final/settlement. Consecutive
+            // updates need only one small state marker, not their accumulated text.
+            if (event.type === "message_update" && kept.at(-1) !== '{"type":"message_update"}')
+                keep('{"type":"message_update"}');
+            return;
+        }
+        keep(line);
+        if (providerFailure === null)
+            providerFailure = providerFailureFromJsonLine(line);
+    };
+    // Frame bytes at LF, so split UTF-8 and legal Unicode separators stay intact.
+    // Enforce the bound before decoding or parsing an unterminated giant line.
+    let pending = new BoundedCapture(maxLine);
+    const append = (chunk) => {
+        pending.push(chunk);
+        if (pending.truncated)
+            throw new ProcessOutputLimitError("Pi JSON line byte limit exceeded");
+    };
+    const flush = () => {
+        if (pending.bytes)
+            acceptLine(pending.text());
+        pending = new BoundedCapture(maxLine);
+    };
+    const result = await runProcess("pi", opts.args, { cwd: opts.cwd, env: opts.env,
+        timeoutMs: opts.timeoutMs, signal: opts.signal, maxOutputBytes: opts.maxOutputBytes,
+        onStdout(chunk) {
             let start = 0, end;
-            while ((end = pending.indexOf("\n", start)) >= 0) {
-                acceptLine(pending.slice(start, end));
+            while ((end = chunk.indexOf(10, start)) >= 0) {
+                append(chunk.subarray(start, end));
+                flush();
                 start = end + 1;
             }
-            pending = pending.slice(start);
-        });
-        child.stdout.on("end", () => {
-            pending += decoder.end();
-            if (pending)
-                acceptLine(pending);
-            pending = "";
-        });
-        child.stderr.on("data", (chunk) => {
-            if (stderr.length < MAX_STDERR_CHARS)
-                stderr += chunk.toString("utf8");
-        });
-        child.on("error", (err) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject(err);
-        });
-        child.on("close", (code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            const parsed = parseTrace(kept, {
-                piVersion: opts.piVersion,
-                subject: opts.subject,
-                scenarioId: opts.scenarioId,
-                mode: opts.mode,
-                rep: opts.rep,
-                turn: opts.turn,
-                changedPaths: opts.changedPaths,
-                homeDir: opts.homeDir,
-            });
-            resolve({ ...parsed, code, stderr: stderr.slice(0, MAX_STDERR_CHARS), providerFailure });
-        });
+            if (start < chunk.length)
+                append(chunk.subarray(start));
+        },
+        onStderr(chunk) { stderr.push(chunk); },
+        onStdoutEnd: flush, });
+    if (result.error) {
+        if (result.observation.reason === "timeout")
+            throw new Error(`pi --mode json timed out after ${opts.timeoutMs}ms`);
+        throw result.error;
+    }
+    const parsed = parseTrace(kept, {
+        piVersion: opts.piVersion,
+        subject: opts.subject,
+        scenarioId: opts.scenarioId,
+        mode: opts.mode,
+        rep: opts.rep,
+        turn: opts.turn,
+        changedPaths: opts.changedPaths,
+        homeDir: opts.homeDir,
     });
+    return { ...parsed, code: result.code, stderr: stderr.text(), providerFailure, observation: result.observation };
 }
 //# sourceMappingURL=pi-json.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/adapters",
-    "version": "0.30.0",
+    "version": "0.31.0",
     "description": "skill-harness Pi runner and judge adapter (internal API)",
     "type": "module",
     "license": "MIT",
@@ -42,6 +42,6 @@
         "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "@skill-harness/core": "0.30.0"
+        "@skill-harness/core": "0.31.0"
     }
 }