@akira-tl/forgerelay 0.8.7 → 0.8.9

package/dist/subagents/providers/adapters/pi.js

@@ -2,6 +2,10 @@ import { spawn } from "node:child_process";
 import { removeForgeRelayNodeModulesBinFromPath } from "../path.js";
 import { asRecord, assertPipedChild, errorMessage, readArray, readNestedString, requireFinalResponse, terminateChildOnAbort, unwrapProviderPayload, } from "../shared.js";
 const PI_AGENT_TIMEOUT_MS = 120_000;
+const PI_RPC_MAX_LINE_BYTES = 8 * 1024 * 1024;
+const PI_RPC_STDERR_TAIL_BYTES = 128 * 1024;
+const PI_STREAMING_TEXT_MAX_BYTES = 8 * 1024 * 1024;
+const PI_ERROR_PREVIEW_BYTES = 4 * 1024;
 export class PiRpcSubagentAdapter {
     provider = "pi";
     async run(input) {
@@ -22,14 +26,23 @@ export class PiRpcSubagentAdapter {
         const detachAbort = terminateChildOnAbort(child, input.signal);
         const rpc = new JsonLineRpc(child);
         let streamingText = "";
+        let streamingTextBytes = 0;
         let streamingProviderError = "";
         rpc.onEvent((event) => {
             const text = extractPiStreamingText([event]);
-            if (text)
+            if (text) {
+                const nextBytes = streamingTextBytes + Buffer.byteLength(text, "utf8");
+                if (nextBytes > PI_STREAMING_TEXT_MAX_BYTES) {
+                    rpc.fail(new Error(`Pi streaming response exceeded ${PI_STREAMING_TEXT_MAX_BYTES} bytes.`));
+                    child.kill();
+                    return;
+                }
                 streamingText += text;
+                streamingTextBytes = nextBytes;
+            }
             const providerError = extractPiProviderError(event);
             if (providerError)
-                streamingProviderError = providerError;
+                streamingProviderError = boundedUtf8Tail(providerError, PI_RPC_STDERR_TAIL_BYTES);
         });
         try {
             const state = await rpc.request({ type: "get_state" });
@@ -72,11 +85,13 @@ export function piCommandEnvironment(env) {
         PATH: removeForgeRelayNodeModulesBinFromPath(path),
     };
 }
-class JsonLineRpc {
+export class JsonLineRpc {
     child;
     pending = new Map();
     eventSubscribers = new Set();
+    failureSubscribers = new Set();
     buffer = "";
+    bufferBytes = 0;
     nextId = 1;
     stderr = "";
     fatalError;
@@ -84,7 +99,7 @@ class JsonLineRpc {
         this.child = child;
         child.stdout.on("data", (chunk) => this.handleStdout(chunk.toString("utf8")));
         child.stderr.on("data", (chunk) => {
-            this.stderr += chunk.toString("utf8");
+            this.stderr = boundedUtf8Tail(`${this.stderr}${chunk.toString("utf8")}`, PI_RPC_STDERR_TAIL_BYTES);
         });
         child.on("exit", (code, signal) => {
             this.failAll(new Error(`Pi RPC process exited with code ${code ?? "null"} and signal ${signal ?? "null"}\n${this.stderr}`.trim()));
@@ -105,11 +120,15 @@ class JsonLineRpc {
         this.eventSubscribers.add(callback);
         return () => this.eventSubscribers.delete(callback);
     }
+    fail(error) {
+        this.failAll(error);
+    }
     waitForEvent(predicate, timeoutMs, signal) {
         return new Promise((resolve, reject) => {
             const finish = (callback) => {
                 clearTimeout(timer);
                 unsubscribe();
+                unsubscribeFailure();
                 signal?.removeEventListener("abort", abort);
                 callback();
             };
@@ -126,6 +145,7 @@ class JsonLineRpc {
                     return;
                 finish(() => resolve(event));
             });
+            const unsubscribeFailure = this.onFailure((error) => finish(() => reject(error)));
             if (signal?.aborted)
                 abort();
             else
@@ -134,21 +154,38 @@ class JsonLineRpc {
     }
     handleStdout(chunk) {
         this.buffer += chunk;
+        this.bufferBytes += Buffer.byteLength(chunk, "utf8");
         for (;;) {
             const newline = this.buffer.indexOf("\n");
-            if (newline === -1)
+            if (newline === -1) {
+                if (this.bufferBytes > PI_RPC_MAX_LINE_BYTES) {
+                    const error = new Error(`Pi RPC line exceeded ${PI_RPC_MAX_LINE_BYTES} bytes.`);
+                    this.failAll(error);
+                    this.child.kill();
+                }
                 return;
-            const line = this.buffer.slice(0, newline).trim();
+            }
+            const consumed = this.buffer.slice(0, newline + 1);
+            const line = consumed.slice(0, -1).trim();
             this.buffer = this.buffer.slice(newline + 1);
+            this.bufferBytes = Math.max(0, this.bufferBytes - Buffer.byteLength(consumed, "utf8"));
             if (!line)
                 continue;
+            if (Buffer.byteLength(line, "utf8") > PI_RPC_MAX_LINE_BYTES) {
+                const error = new Error(`Pi RPC line exceeded ${PI_RPC_MAX_LINE_BYTES} bytes.`);
+                this.failAll(error);
+                this.child.kill();
+                return;
+            }
             let message;
             try {
                 message = JSON.parse(line);
             }
             catch {
-                this.stderr += `${line}\n`;
-                this.failAll(new Error(`Pi RPC emitted malformed JSON on stdout: ${line}`));
+                const preview = boundedUtf8Tail(line, PI_ERROR_PREVIEW_BYTES);
+                this.stderr = boundedUtf8Tail(`${this.stderr}${preview}\n`, PI_RPC_STDERR_TAIL_BYTES);
+                this.failAll(new Error(`Pi RPC emitted malformed JSON on stdout: ${preview}`));
+                this.child.kill();
                 return;
             }
             if (message.type !== "response") {
@@ -171,14 +208,28 @@ class JsonLineRpc {
             }
         }
     }
+    onFailure(callback) {
+        this.failureSubscribers.add(callback);
+        return () => this.failureSubscribers.delete(callback);
+    }
     failAll(error) {
+        if (this.fatalError)
+            return;
         this.fatalError = error;
         for (const pending of this.pending.values()) {
             pending.reject(error);
         }
         this.pending.clear();
+        for (const subscriber of [...this.failureSubscribers])
+            subscriber(error);
     }
 }
+function boundedUtf8Tail(value, maxBytes) {
+    const bytes = Buffer.from(value, "utf8");
+    if (bytes.length <= maxBytes)
+        return value;
+    return bytes.subarray(bytes.length - maxBytes).toString("utf8");
+}
 export function extractPiFinalResponse(value) {
     const root = unwrapProviderPayload(value);
     const messages = Array.isArray(root) ? root : readArray(root, "messages");

package/dist/subagents/providers/availability.js

@@ -9,19 +9,25 @@ export function getSubagentProviderAvailabilitySnapshot(env = process.env) {
 export function checkSubagentProviderAvailability(provider, env = process.env) {
     switch (provider) {
         case "codex":
-            return packageAvailability(provider, "@openai/codex-sdk");
+            return commandAvailability(provider, env.CODEX_COMMAND ?? "codex", {
+                env: externalProviderEnvironment(env, "CODEX_COMMAND"),
+            });
         case "claude":
-            return packageAvailability(provider, "@anthropic-ai/claude-agent-sdk");
+            return commandAvailability(provider, env.CLAUDE_COMMAND ?? "claude", {
+                env: externalProviderEnvironment(env, "CLAUDE_COMMAND"),
+            });
         case "opencode":
-            return packageAvailability(provider, "@opencode-ai/sdk/v2");
+            return commandAvailability(provider, env.OPENCODE_COMMAND ?? "opencode", {
+                env: externalProviderEnvironment(env, "OPENCODE_COMMAND"),
+            });
         case "pi":
             return commandAvailability(provider, env.PI_COMMAND ?? "pi", {
-                env: piAvailabilityEnvironment(env),
+                env: externalProviderEnvironment(env, "PI_COMMAND"),
             });
         case "cursor":
-            return commandAvailability(provider, "cursor-agent");
+            return commandAvailability(provider, "cursor-agent", { env });
         case "copilot":
-            return commandAvailability(provider, "copilot");
+            return commandAvailability(provider, "copilot", { env });
     }
 }
 export function assertSubagentProviderAvailable(provider, env = process.env) {
@@ -45,24 +51,6 @@ export function formatSubagentProviderAvailabilitySummary(providers) {
         unavailable.length > 0 ? `unavailable: ${unavailable.join(", ")}` : undefined,
     ].filter(Boolean).join("; ");
 }
-function packageAvailability(provider, packageName) {
-    try {
-        import.meta.resolve(packageName);
-        return {
-            name: provider,
-            available: true,
-            continuationSupported: subagentProviderContinuationSupported(provider),
-        };
-    }
-    catch {
-        return {
-            name: provider,
-            available: false,
-            continuationSupported: subagentProviderContinuationSupported(provider),
-            reason: `${packageName} package not found`,
-        };
-    }
-}
 function commandAvailability(provider, command, options = {}) {
     const executable = resolveCommand(command, options.env);
     if (!executable) {
@@ -120,14 +108,11 @@ function executableExists(command, env) {
         : undefined;
     return code !== "ENOENT";
 }
-function piAvailabilityEnvironment(env) {
-    if (env.PI_COMMAND)
-        return env;
-    const path = env.PATH;
-    if (!path)
+function externalProviderEnvironment(env, explicitCommandKey) {
+    if (env[explicitCommandKey] || !env.PATH)
         return env;
     return {
         ...env,
-        PATH: removeForgeRelayNodeModulesBinFromPath(path),
+        PATH: removeForgeRelayNodeModulesBinFromPath(env.PATH),
     };
 }

package/dist/subagents/providers/runtime/external-command.js

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import { assertPipedChild, errorMessage, terminateChildOnAbort } from "../shared.js";
+export const runExternalCommand = async (request) => {
+    request.signal?.throwIfAborted();
+    const child = spawn(request.command, request.args, {
+        cwd: request.cwd,
+        env: request.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    assertPipedChild(child);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf8");
+    });
+    const detachAbort = terminateChildOnAbort(child, request.signal);
+    try {
+        const exitCode = await new Promise((resolve, reject) => {
+            child.once("error", (error) => reject(error));
+            child.once("exit", (code, signal) => {
+                if (request.signal?.aborted) {
+                    const aborted = new Error(`${request.label} command cancelled.`);
+                    aborted.name = "AbortError";
+                    reject(aborted);
+                    return;
+                }
+                if (signal) {
+                    reject(new Error(`${request.label} command terminated by ${signal}${stderr ? `\n${stderr.trim()}` : ""}`));
+                    return;
+                }
+                resolve(code ?? 0);
+            });
+        });
+        if (exitCode !== 0) {
+            throw new Error(`${request.label} command exited with code ${exitCode}${stderr ? `\n${stderr.trim()}` : ""}`);
+        }
+        return { stdout, stderr, exitCode };
+    }
+    catch (error) {
+        if (request.signal?.aborted && !(error instanceof Error && error.name === "AbortError")) {
+            const aborted = new Error(`${request.label} command cancelled: ${errorMessage(error)}`);
+            aborted.name = "AbortError";
+            throw aborted;
+        }
+        throw error;
+    }
+    finally {
+        detachAbort();
+        if (!child.killed && child.exitCode === null)
+            child.kill();
+    }
+};

package/dist/subagents/sessions/capability.js

@@ -1,4 +1,4 @@
-import { CapabilityError, } from "../../capability-registry.js";
+import { CapabilityError, } from "../../mcp/server/core/capability-registry.js";
 import { isSubagentProvider } from "../profiles.js";
 import { subagentProviderContinuationSupported } from "../providers/continuation.js";
 import { SubagentDeliveryMailbox } from "./delivery-mailbox.js";

package/dist/subagents/sessions/execution.js

@@ -1,4 +1,4 @@
-import { HookRunner } from "../../hooks.js";
+import { HookRunner } from "../../mcp/hooks/hooks.js";
 import { isSubagentProvider, loadSubagentProfiles, } from "../profiles.js";
 import { runSubagentProvider } from "../providers/registry.js";
 import { SubagentDeliveryMailbox } from "./delivery-mailbox.js";

package/dist/subagents/sessions/mcp/activity-audit-test-support.js

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { openDatabase } from "../../../runtime/state/db/client.js";
+export function readActivityAuditSnapshot(stateDir, auditStore) {
+    const database = openDatabase(stateDir);
+    try {
+        const rows = database.sqlite.prepare(`select activity_id, event_type, tool, request_json, result_json, error,
+              payload_file, payload_offset, payload_length
+       from activity_audit_events
+       order by rowid`).all();
+        for (const row of rows) {
+            assert.equal(row.request_json, null, "Activity request payload must not be stored in SQLite.");
+            assert.equal(row.result_json, null, "Activity result payload must not be stored in SQLite.");
+            assert.equal(row.error, null, "Activity error payload must not be stored in SQLite.");
+        }
+        const activityIds = [...new Set(rows.map((row) => row.activity_id))];
+        return {
+            rows,
+            events: activityIds.flatMap((activityId) => auditStore.listEvents(activityId)),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+export function activityEventsForTool(snapshot, tool) {
+    const activityIds = new Set(snapshot.rows
+        .filter((row) => row.tool === tool)
+        .map((row) => row.activity_id));
+    return snapshot.events.filter((event) => activityIds.has(event.activityId));
+}

package/dist/subagents/sessions/store.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { openDatabase } from "../../db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
 export class SubagentSessionStore {
     database;
     constructor(stateDir) {