@akira-tl/forgerelay 0.8.8 → 0.8.9

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

@@ -1,53 +1,94 @@
-import { spawnSync } from "node:child_process";
-import { directString, linkedAbortController, requireFinalResponse } from "../shared.js";
+import { runExternalCommand, } from "../runtime/external-command.js";
+import { removeForgeRelayNodeModulesBinFromPath } from "../path.js";
+import { asRecord, directString, requireFinalResponse } from "../shared.js";
 export class ClaudeSubagentAdapter {
+    runner;
+    env;
     provider = "claude";
+    constructor(runner = runExternalCommand, env = process.env) {
+        this.runner = runner;
+        this.env = env;
+    }
     async run(input) {
-        const { query } = await import("@anthropic-ai/claude-agent-sdk");
-        const claudeExecutable = process.env.CLAUDE_COMMAND ?? resolveExecutable("claude");
-        const linkedAbort = linkedAbortController(input.signal);
-        try {
-            const messages = query({
-                prompt: input.prompt,
-                options: {
-                    cwd: input.workspace,
-                    model: input.model,
-                    ...(input.thinking ? { thinking: { type: "adaptive" }, effort: input.thinking } : {}),
-                    resume: input.providerSessionId,
-                    permissionMode: "bypassPermissions",
-                    allowDangerouslySkipPermissions: true,
-                    env: claudeCommandEnvironment(process.env),
-                    ...(linkedAbort.controller ? { abortController: linkedAbort.controller } : {}),
-                    ...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
-                },
-            });
-            let providerSessionId = input.providerSessionId ?? null;
-            let finalResponse = "";
-            for await (const message of messages) {
-                const record = message;
-                if (typeof record.session_id === "string")
-                    providerSessionId = record.session_id;
-                if (record.type === "result" && typeof record.result === "string") {
-                    const resultError = claudeResultError(record);
-                    if (resultError)
-                        throw new Error(resultError);
-                    finalResponse = record.result;
-                }
-            }
-            finalResponse = requireFinalResponse("Claude", finalResponse);
-            return {
-                provider: this.provider,
-                providerSessionId,
-                finalResponse,
-            };
+        const command = this.env.CLAUDE_COMMAND?.trim() || "claude";
+        const result = await this.runner({
+            command,
+            args: claudeCommandArgs(input),
+            cwd: input.workspace,
+            env: claudeCommandEnvironment(this.env),
+            signal: input.signal,
+            stdin: input.prompt,
+            label: "Claude",
+        });
+        const parsed = parseClaudeJsonOutput(result.stdout);
+        if (parsed.error)
+            throw new Error(parsed.error);
+        return {
+            provider: this.provider,
+            providerSessionId: parsed.providerSessionId ?? input.providerSessionId ?? null,
+            finalResponse: requireFinalResponse("Claude", parsed.finalResponse),
+        };
+    }
+}
+export function claudeCommandArgs(input) {
+    const args = [
+        "--print",
+        "--output-format",
+        "json",
+        "--dangerously-skip-permissions",
+    ];
+    if (input.model)
+        args.push("--model", input.model);
+    if (input.thinking)
+        args.push("--effort", input.thinking);
+    if (input.providerSessionId)
+        args.push("--resume", input.providerSessionId);
+    return args;
+}
+export function parseClaudeJsonOutput(output) {
+    const records = parseJsonRecords(output);
+    let providerSessionId;
+    let finalResponse = "";
+    let error;
+    for (const record of records) {
+        providerSessionId = directString(record.session_id) ?? providerSessionId;
+        const resultError = claudeResultError(record);
+        if (resultError)
+            error = resultError;
+        if (typeof record.result === "string")
+            finalResponse = record.result;
+    }
+    return { providerSessionId, finalResponse, error };
+}
+function parseJsonRecords(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed.map(asRecord).filter((record) => Boolean(record));
         }
-        finally {
-            linkedAbort.dispose();
+        const record = asRecord(parsed);
+        return record ? [record] : [];
+    }
+    catch {
+        const records = [];
+        for (const line of trimmed.split(/\r?\n/)) {
+            try {
+                const record = asRecord(JSON.parse(line));
+                if (record)
+                    records.push(record);
+            }
+            catch {
+                // Ignore non-JSON diagnostic lines; the command runner preserves stderr separately.
+            }
         }
+        return records;
     }
 }
 function claudeResultError(record) {
-    const subtype = typeof record.subtype === "string" ? record.subtype : undefined;
+    const subtype = directString(record.subtype);
     const isError = record.is_error === true || subtype?.startsWith("error");
     if (!isError)
         return undefined;
@@ -58,16 +99,6 @@ function claudeResultError(record) {
         "Claude returned an error result.";
     return `Claude returned an error result: ${message}`;
 }
-function resolveExecutable(command) {
-    const result = spawnSync(process.platform === "win32" ? "where.exe" : "command", [
-        ...(process.platform === "win32" ? [command] : ["-v", command]),
-    ], {
-        encoding: "utf8",
-        shell: process.platform !== "win32",
-    });
-    const executable = result.stdout?.split(/\r?\n/).find((line) => line.trim());
-    return executable?.trim() || undefined;
-}
 export function claudeCommandEnvironment(env) {
     const next = { ...env };
     for (const key of [
@@ -78,5 +109,8 @@ export function claudeCommandEnvironment(env) {
     ]) {
         delete next[key];
     }
+    if (!env.CLAUDE_COMMAND && next.PATH) {
+        next.PATH = removeForgeRelayNodeModulesBinFromPath(next.PATH);
+    }
     return next;
 }

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

@@ -1,4 +1,61 @@
-function sandboxModeFor(writeMode) {
+import { runExternalCommand, } from "../runtime/external-command.js";
+import { removeForgeRelayNodeModulesBinFromPath } from "../path.js";
+import { asRecord, directString, requireFinalResponse } from "../shared.js";
+export class CodexSubagentAdapter {
+    runner;
+    env;
+    provider = "codex";
+    constructor(runner = runExternalCommand, env = process.env) {
+        this.runner = runner;
+        this.env = env;
+    }
+    async run(input) {
+        const command = this.env.CODEX_COMMAND?.trim() || "codex";
+        const result = await this.runner({
+            command,
+            args: codexCommandArgs(input),
+            cwd: input.workspace,
+            env: codexCommandEnvironment(this.env),
+            signal: input.signal,
+            stdin: input.prompt,
+            label: "Codex",
+        });
+        const parsed = parseCodexJsonLines(result.stdout);
+        if (parsed.error)
+            throw new Error(`Codex returned an error: ${parsed.error}`);
+        if (input.providerSessionId &&
+            parsed.providerSessionId &&
+            parsed.providerSessionId !== input.providerSessionId) {
+            throw new Error(`Codex resume returned a different session id (${parsed.providerSessionId}) than requested (${input.providerSessionId}).`);
+        }
+        return {
+            provider: this.provider,
+            providerSessionId: parsed.providerSessionId ?? input.providerSessionId ?? null,
+            finalResponse: requireFinalResponse("Codex", parsed.finalResponse),
+        };
+    }
+}
+export function codexCommandArgs(input) {
+    const args = [
+        "exec",
+        "--json",
+        "--sandbox",
+        codexSandboxMode(input.writeMode),
+        "--cd",
+        input.workspace,
+        "--config",
+        'approval_policy="never"',
+    ];
+    if (input.model)
+        args.push("--model", input.model);
+    if (input.thinking) {
+        args.push("--config", `model_reasoning_effort=${JSON.stringify(input.thinking)}`);
+    }
+    if (input.providerSessionId)
+        args.push("resume", input.providerSessionId);
+    return args;
+}
+function codexSandboxMode(writeMode) {
     switch (writeMode) {
         case "allowed":
             return "workspace-write";
@@ -9,46 +66,53 @@ function sandboxModeFor(writeMode) {
             return "read-only";
     }
 }
-function threadOptionsFor(input) {
+export function codexCommandEnvironment(env) {
+    if (env.CODEX_COMMAND || !env.PATH)
+        return { ...env };
     return {
-        workingDirectory: input.workspace,
-        sandboxMode: sandboxModeFor(input.writeMode),
-        approvalPolicy: "never",
-        model: input.model,
-        modelReasoningEffort: input.thinking,
+        ...env,
+        PATH: removeForgeRelayNodeModulesBinFromPath(env.PATH),
     };
 }
-export class CodexSdkSubagentRuntime {
-    provider = "codex";
-    codex;
-    constructor(codex) {
-        this.codex = codex;
-    }
-    async run(input) {
-        const options = threadOptionsFor(input);
-        const thread = input.providerSessionId
-            ? this.codex.resumeThread(input.providerSessionId, options)
-            : this.codex.startThread(options);
-        const turn = await thread.run(input.prompt, { signal: input.signal });
-        return {
-            provider: this.provider,
-            providerSessionId: thread.id,
-            finalResponse: turn.finalResponse,
-        };
-    }
-}
-export async function createCodexSdkSubagentRuntime(options, codexFactory) {
-    const factory = codexFactory ?? (await defaultCodexFactory());
-    return new CodexSdkSubagentRuntime(factory(options));
-}
-export class CodexSubagentAdapter {
-    provider = "codex";
-    async run(input) {
-        const runtime = await createCodexSdkSubagentRuntime();
-        return runtime.run(input);
+export function parseCodexJsonLines(output) {
+    let providerSessionId;
+    let finalResponse = "";
+    let error;
+    for (const line of output.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let event;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const record = asRecord(parsed);
+            if (!record)
+                continue;
+            event = record;
+        }
+        catch {
+            continue;
+        }
+        if (event.type === "thread.started") {
+            providerSessionId = directString(event.thread_id) ?? providerSessionId;
+            continue;
+        }
+        if (event.type === "item.completed") {
+            const item = asRecord(event.item);
+            if (item?.type === "agent_message") {
+                finalResponse = directString(item.text) ?? finalResponse;
+            }
+            continue;
+        }
+        if (event.type === "turn.failed") {
+            const failure = asRecord(event.error);
+            error = directString(failure?.message) ?? directString(event.message) ?? error;
+            continue;
+        }
+        if (event.type === "error") {
+            const nested = asRecord(event.error);
+            error = directString(event.message) ?? directString(nested?.message) ?? error;
+        }
     }
-}
-async function defaultCodexFactory() {
-    const module = await import("@openai/codex-sdk");
-    return (options) => new module.Codex(options);
+    return { providerSessionId, finalResponse, error };
 }

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

@@ -1,102 +1,132 @@
-import { asRecord, readArray, readNestedString, requireFinalResponse, unwrapProviderPayload, } from "../shared.js";
+import { runExternalCommand, } from "../runtime/external-command.js";
+import { removeForgeRelayNodeModulesBinFromPath } from "../path.js";
+import { asRecord, directString, readArray, requireFinalResponse, unwrapProviderPayload, } from "../shared.js";
 export class OpencodeSubagentAdapter {
+    runner;
+    env;
     provider = "opencode";
+    constructor(runner = runExternalCommand, env = process.env) {
+        this.runner = runner;
+        this.env = env;
+    }
     async run(input) {
-        const { createOpencode } = await import("@opencode-ai/sdk/v2");
-        const { client, server } = await createOpencode();
-        try {
-            const sessionId = input.providerSessionId ?? await createOpencodeSession(client, input);
-            let abortPromise;
-            const abort = () => {
-                abortPromise ??= abortOpencodeSession(client, sessionId, input.workspace);
-            };
-            if (input.signal?.aborted)
-                abort();
-            else
-                input.signal?.addEventListener("abort", abort, { once: true });
-            try {
-                input.signal?.throwIfAborted();
-                const promptResult = await promptOpencodeSession(client, sessionId, input);
-                await waitForOpencodeSession(client, sessionId, input.signal);
-                const messages = await readOpencodeMessages(client, sessionId, input.signal);
-                const finalResponse = requireFinalResponse("OpenCode", extractOpenCodeFinalResponse(messages) || extractOpenCodeFinalResponse(promptResult));
-                return {
-                    provider: this.provider,
-                    providerSessionId: sessionId,
-                    finalResponse,
-                };
-            }
-            finally {
-                input.signal?.removeEventListener("abort", abort);
-                if (abortPromise)
-                    await abortPromise;
-            }
-        }
-        finally {
-            server.close();
+        const command = this.env.OPENCODE_COMMAND?.trim() || "opencode";
+        const commandEnv = opencodeCommandEnvironment(this.env);
+        const result = await this.runner({
+            command,
+            args: opencodeCommandArgs(input),
+            cwd: input.workspace,
+            env: commandEnv,
+            signal: input.signal,
+            stdin: input.prompt,
+            label: "OpenCode",
+        });
+        const streamed = parseOpenCodeJsonLines(result.stdout);
+        const providerSessionId = streamed.providerSessionId ?? input.providerSessionId ?? null;
+        let finalResponse = streamed.finalResponse;
+        if (!finalResponse && providerSessionId) {
+            const exported = await this.runner({
+                command,
+                args: ["export", providerSessionId],
+                cwd: input.workspace,
+                env: commandEnv,
+                signal: input.signal,
+                label: "OpenCode export",
+            });
+            finalResponse = extractOpenCodeExportFinalResponse(exported.stdout);
         }
+        return {
+            provider: this.provider,
+            providerSessionId,
+            finalResponse: requireFinalResponse("OpenCode", finalResponse),
+        };
     }
 }
-async function createOpencodeSession(client, input) {
-    const sessionClient = client;
-    const result = await sessionClient.session.create({
-        directory: input.workspace,
-        location: { directory: input.workspace },
-        ...(input.model ? { model: parseOpencodeModel(input.model) } : {}),
-    }, { throwOnError: true, signal: input.signal });
-    const id = readNestedString(result, ["id"]) ??
-        readNestedString(result, ["data", "id"]) ??
-        readNestedString(result, ["session", "id"]) ??
-        readNestedString(result, ["data", "session", "id"]);
-    if (typeof id !== "string") {
-        throw new Error("OpenCode did not return a session id.");
-    }
-    return id;
+export function opencodeCommandArgs(input) {
+    const args = [
+        "run",
+        "--format",
+        "json",
+        "--dir",
+        input.workspace,
+        "--dangerously-skip-permissions",
+    ];
+    if (input.model)
+        args.push("--model", input.model);
+    if (input.thinking)
+        args.push("--variant", input.thinking);
+    if (input.providerSessionId)
+        args.push("--session", input.providerSessionId);
+    return args;
 }
-async function promptOpencodeSession(client, sessionId, input) {
-    const session = client.session;
-    const promptInput = {
-        sessionID: sessionId,
-        directory: input.workspace,
-        prompt: { parts: [{ type: "text", text: input.prompt }] },
-        parts: [{ type: "text", text: input.prompt }],
-        ...(input.model ? { model: parseOpencodeModel(input.model) } : {}),
-        ...(input.thinking ? { variant: input.thinking } : {}),
+export function opencodeCommandEnvironment(env) {
+    if (env.OPENCODE_COMMAND || !env.PATH)
+        return { ...env };
+    return {
+        ...env,
+        PATH: removeForgeRelayNodeModulesBinFromPath(env.PATH),
     };
-    return session.prompt(promptInput, { throwOnError: true, signal: input.signal });
-}
-async function waitForOpencodeSession(client, sessionId, signal) {
-    const session = client.session;
-    if (!session?.wait)
-        return;
-    await session.wait({ sessionID: sessionId }, { throwOnError: true, signal });
 }
-async function readOpencodeMessages(client, sessionId, signal) {
-    const session = client.session;
-    if (!session?.messages)
-        return undefined;
-    return session.messages({ sessionID: sessionId, order: "asc", limit: 100 }, { throwOnError: true, signal });
+export function parseOpenCodeJsonLines(output) {
+    let providerSessionId;
+    const textByMessage = new Map();
+    const messageOrder = [];
+    let fallback = "";
+    let anonymousIndex = 0;
+    for (const line of output.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            const parsed = asRecord(JSON.parse(trimmed));
+            if (!parsed)
+                continue;
+            record = parsed;
+        }
+        catch {
+            continue;
+        }
+        providerSessionId =
+            directString(record.sessionID) ??
+                directString(record.sessionId) ??
+                providerSessionId;
+        if (record.type === "text") {
+            const part = asRecord(record.part);
+            const text = typeof part?.text === "string" ? part.text : undefined;
+            if (!text)
+                continue;
+            const messageId = directString(part?.messageID) ??
+                directString(part?.messageId) ??
+                `anonymous-${anonymousIndex++}`;
+            if (!textByMessage.has(messageId)) {
+                textByMessage.set(messageId, []);
+                messageOrder.push(messageId);
+            }
+            textByMessage.get(messageId).push(text);
+            continue;
+        }
+        const extracted = extractOpenCodeFinalResponse(record);
+        if (extracted)
+            fallback = extracted;
+    }
+    const lastMessageId = messageOrder.at(-1);
+    const finalResponse = lastMessageId
+        ? (textByMessage.get(lastMessageId) ?? []).join("").trim()
+        : fallback;
+    return { providerSessionId, finalResponse };
 }
-async function abortOpencodeSession(client, sessionId, workspace) {
-    const session = client.session;
-    if (!session?.abort)
-        return;
+function extractOpenCodeExportFinalResponse(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return "";
     try {
-        await session.abort({ sessionID: sessionId, directory: workspace }, { throwOnError: true });
+        return extractOpenCodeFinalResponse(JSON.parse(trimmed));
     }
     catch {
-        // The prompt request may already have observed the AbortSignal and closed the local server.
+        return "";
     }
 }
-function parseOpencodeModel(model) {
-    const separator = model.indexOf("/");
-    if (separator === -1)
-        return { providerID: "opencode", modelID: model };
-    return {
-        providerID: model.slice(0, separator),
-        modelID: model.slice(separator + 1),
-    };
-}
 export function extractOpenCodeFinalResponse(value) {
     const root = unwrapProviderPayload(value);
     const messages = Array.isArray(root) ? root : readArray(root, "messages");