@getforgeai/cli 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/orchestrator/connectors/docker-connector.js

@@ -15,6 +15,8 @@ import { startMcpBridge, stopMcpBridge } from "../../vm/mcp-bridge.js";
 import { getDockerBridgeGatewayIp } from "../../vm/docker-executor.js";
 import { activeConnections } from "../../lib/connection-manager.js";
 import { vmLog } from "../../vm/log.js";
+import { getConfig } from "../../config/config-manager.js";
+import { getAgentProfile } from "../agent-profiles.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -31,26 +33,44 @@ async function resolveMcpRelayHost() {
     return "host.docker.internal";
 }
 /**
- * Build MCP config JSON for the Docker container.
+ * Build the agent config file (MCP wiring + permissions) for the container.
  * The relay connects to the host MCP server via host.docker.internal.
- * Runs the relay staged in the session dir (always matches this CLI build)
+ * It runs the relay staged in the session dir (always matches this CLI build)
  * and authenticates to the bridge with the per-session secret.
+ * Format and install path depend on the agent engine (see agent-profiles.ts).
  */
-function buildMcpConfigJson(sessionIndex, mcpSecret, mcpHost) {
-    const mcpPort = 20000 + sessionIndex;
-    return JSON.stringify({
-        mcpServers: {
-            forgeai: {
-                command: "node",
-                args: ["/session/forge-mcp-relay.mjs"],
-                env: {
-                    FORGEAI_MCP_HOST: mcpHost,
-                    FORGEAI_MCP_PORT: String(mcpPort),
-                    FORGEAI_MCP_TOKEN: mcpSecret,
-                },
-            },
-        },
-    }, null, 2);
+function buildAgentConfig(profile, sessionIndex, mcpSecret, mcpHost) {
+    return profile.buildConfig({ host: mcpHost, port: 20000 + sessionIndex, token: mcpSecret }, { model: getConfig().opencodeModel });
+}
+/**
+ * Bash script installing the staged config + context files into the container.
+ * The config is staged on the host volume as /session/mcp_config.json
+ * regardless of its actual format (JSON or TOML).
+ */
+function buildConfigInstallScript(profile) {
+    const configDir = profile.configTargetPath.slice(0, profile.configTargetPath.lastIndexOf("/"));
+    return [
+        `mkdir -p /session/workspace/.forgeai ${configDir}`,
+        "cp /session/context.json /session/workspace/.forgeai/context.json",
+        `cp /session/mcp_config.json ${profile.configTargetPath}`,
+    ].join(" && ");
+}
+/**
+ * Fail fast with an actionable message when the engine's binary is missing
+ * from the agent image (images built before Codex/OpenCode support).
+ */
+async function assertAgentBinaryAvailable(sm, taskId, profile) {
+    if (profile.type === "CLAUDE_CODE")
+        return;
+    const result = await sm.exec(taskId, "bash", [
+        "-c",
+        `command -v ${profile.binary}`,
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Agent binary "${profile.binary}" not found in the agent image. ` +
+            `Update it with: docker pull getforgeai/agent:latest ` +
+            `(or remove the local image and run forge vm init to rebuild)`);
+    }
 }
 function buildDefaultPrompt(skillName) {
     return `You are a ForgeAI agent. Read and follow the ${skillName} skill in .claude/skills/${skillName}/SKILL.md to implement your assigned task.`;
@@ -69,35 +89,6 @@ function buildResumePrompt(basePrompt, ctx) {
     }
     return parts.join("\n");
 }
-/** Standard Claude CLI args for agent execution */
-function buildAgentArgs(mcpConfigPath, prompt) {
-    return [
-        "--dangerously-skip-permissions",
-        "--mcp-config",
-        mcpConfigPath,
-        "-p",
-        prompt,
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-    ];
-}
-/** Claude CLI args for --continue resume (requires -p for print/stream mode) */
-function buildContinueArgs(mcpConfigPath, prompt) {
-    return [
-        "--continue",
-        "--dangerously-skip-permissions",
-        "--mcp-config",
-        mcpConfigPath,
-        "-p",
-        prompt,
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-    ];
-}
 /**
  * Start the MCP bridge for a session.
  * Returns the MCP port used, or null if no active connection available.
@@ -126,82 +117,94 @@ async function startSessionMcpBridge(session, params) {
 // Connector
 // ---------------------------------------------------------------------------
 export const dockerConnector = {
-    name: "docker-claude-code",
+    name: "docker-agent",
     async start(params) {
         const sm = getVmManager();
+        const profile = getAgentProfile(params.agentType);
         // 1. Ensure Docker is ready + image available
         await sm.ensureVmRunning();
         // 2. Create session (container + host dirs)
         const sessionId = await sm.createSession(params.taskId);
         const session = sm.getSessionByTaskId(params.taskId);
-        // 3. Clone repo inside the container
-        await sm.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
-        // 4. Prepare workspace files on the host (volume-mounted at /session)
-        const skillFiles = [];
-        if (params.skill) {
-            for (const file of params.skill.files) {
-                skillFiles.push({
-                    relativePath: `${params.skill.name}/${file.path}`,
-                    content: file.content,
-                });
+        // From here on, a failure must not leak the freshly created container —
+        // there is no orphan sweep, only destroySession removes containers.
+        try {
+            // 3. Clone repo inside the container
+            await sm.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
+            // 4. Prepare workspace files on the host (volume-mounted at /session)
+            const skillFiles = [];
+            if (params.skill) {
+                for (const file of params.skill.files) {
+                    skillFiles.push({
+                        relativePath: `${params.skill.name}/${file.path}`,
+                        content: file.content,
+                    });
+                }
             }
-        }
-        sm.prepareWorkspace(sessionId, {
-            contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
-            mcpConfigJson: buildMcpConfigJson(session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
-            skillFiles,
-        });
-        // 5. Copy workspace files from volume mount into /workspace inside container
-        await sm.exec(params.taskId, "bash", [
-            "-c",
-            [
-                "mkdir -p /session/workspace/.forgeai /session/workspace/.claude",
-                "cp /session/context.json /session/workspace/.forgeai/context.json",
-                "cp /session/mcp_config.json /session/workspace/.claude/mcp_config.json",
-            ].join(" && "),
-        ]);
-        if (skillFiles.length > 0) {
+            sm.prepareWorkspace(sessionId, {
+                contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
+                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
+                skillFiles,
+            });
+            // 5. Copy workspace files from volume mount into place inside container
             await sm.exec(params.taskId, "bash", [
                 "-c",
-                [
-                    "mkdir -p /session/workspace/.claude/skills",
-                    "cp -r /session/skills/. /session/workspace/.claude/skills/",
-                ].join(" && "),
+                buildConfigInstallScript(profile),
             ]);
-        }
-        // 6. Start MCP bridge (TCP server on host for forge-mcp-relay in container)
-        await startSessionMcpBridge(session, params);
-        // 7. Spawn agent
-        const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
-        const agentArgs = buildAgentArgs("/session/workspace/.claude/mcp_config.json", prompt);
-        const env = {};
-        vmLog.magenta("docker-connector", `Spawning agent in container ${sessionId}`, sessionId);
-        const proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs, env);
-        // 8. Container lifecycle on agent exit — depends on workflow context
-        if (!params.workflowContext) {
-            // Board task: destroy container + MCP bridge immediately on exit
-            proxy.once("exit", () => {
-                stopMcpBridge(sessionId).catch(() => { });
-                sm.destroySession(params.taskId).catch((err) => {
-                    const message = err instanceof Error ? err.message : String(err);
-                    vmLog.warn("docker-connector", `Cleanup failed for ${sessionId}: ${message}`, sessionId);
+            if (skillFiles.length > 0) {
+                // Skills always live in .claude/skills: Claude Code and OpenCode read
+                // that directory natively, Codex is pointed at it via the prompt.
+                await sm.exec(params.taskId, "bash", [
+                    "-c",
+                    [
+                        "mkdir -p /session/workspace/.claude/skills",
+                        "cp -r /session/skills/. /session/workspace/.claude/skills/",
+                    ].join(" && "),
+                ]);
+            }
+            // 6. Install agent credentials inside the container when the engine
+            // reads them from disk (Codex auth.json, OpenCode auth.json)
+            await assertAgentBinaryAvailable(sm, params.taskId, profile);
+            await sm.materializeAgentAuth(params.taskId, profile.type);
+            // 7. Start MCP bridge (TCP server on host for forge-mcp-relay in container)
+            await startSessionMcpBridge(session, params);
+            // 8. Spawn agent
+            const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+            const agentArgs = profile.buildArgs(prompt);
+            const env = {};
+            vmLog.magenta("docker-connector", `Spawning ${profile.type} agent in container ${sessionId}`, sessionId);
+            const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, env, profile.type);
+            // 9. Container lifecycle on agent exit — depends on workflow context
+            if (!params.workflowContext) {
+                // Board task: destroy container + MCP bridge immediately on exit
+                proxy.once("exit", () => {
+                    stopMcpBridge(sessionId).catch(() => { });
+                    sm.destroySession(params.taskId).catch((err) => {
+                        const message = err instanceof Error ? err.message : String(err);
+                        vmLog.warn("docker-connector", `Cleanup failed for ${sessionId}: ${message}`, sessionId);
+                    });
                 });
-            });
+            }
+            else {
+                // Workflow step: keep container alive for idle window.
+                // Only stop MCP bridge — container stays for --continue resume.
+                // Destruction is handled by idle timeout / dismiss / error in agent-spawner.
+                proxy.once("exit", () => {
+                    stopMcpBridge(sessionId).catch(() => { });
+                    vmLog.dim("docker-connector", `Workflow agent exited — container ${sessionId} kept alive for idle window`, sessionId);
+                });
+            }
+            return {
+                pid: proxy.pid,
+                process: proxy,
+                vmId: sessionId,
+            };
         }
-        else {
-            // Workflow step: keep container alive for idle window.
-            // Only stop MCP bridge — container stays for --continue resume.
-            // Destruction is handled by idle timeout / dismiss / error in agent-spawner.
-            proxy.once("exit", () => {
-                stopMcpBridge(sessionId).catch(() => { });
-                vmLog.dim("docker-connector", `Workflow agent exited — container ${sessionId} kept alive for idle window`, sessionId);
-            });
+        catch (err) {
+            stopMcpBridge(sessionId).catch(() => { });
+            await sm.destroySession(params.taskId).catch(() => { });
+            throw err;
         }
-        return {
-            pid: proxy.pid,
-            process: proxy,
-            vmId: sessionId,
-        };
     },
     async stop(entry) {
         await stopAgentProcess(entry);
@@ -214,15 +217,23 @@ export const dockerConnector = {
         const sm = getVmManager();
         const session = sm.getSessionByTaskId(params.taskId);
         if (session && session.status === "RUNNING") {
-            vmLog.cyan("docker-connector", `Resuming in existing container ${session.id}`, session.id);
+            // Continue with the engine the container was provisioned for — its
+            // config, credentials and on-disk session belong to that engine, even
+            // if the CLI's configured engine changed since the session started.
+            const profile = getAgentProfile(session.agentType ?? params.agentType);
+            if (params.agentType && profile.type !== params.agentType) {
+                vmLog.warn("docker-connector", `Configured engine is ${params.agentType} but session ${session.id} was provisioned for ${profile.type} — continuing with ${profile.type}`, session.id);
+            }
+            vmLog.cyan("docker-connector", `Resuming ${profile.type} in existing container ${session.id}`, session.id);
             // Restart MCP bridge (stopped on previous agent exit)
             await startSessionMcpBridge(session, params);
-            // Use --continue for workflow resume in existing container (full context)
+            // Continue the on-disk session for workflow resume in the existing
+            // container (full context)
             if (params.workflowContext) {
                 const continuePrompt = params.prompt ??
                     "Continue your work from where you left off. Do not repeat completed work.";
-                const agentArgs = buildContinueArgs("/session/workspace/.claude/mcp_config.json", continuePrompt);
-                const proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs);
+                const agentArgs = profile.buildContinueArgs(continuePrompt);
+                const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, {}, profile.type);
                 // Keep container alive for next idle window cycle
                 proxy.once("exit", () => {
                     stopMcpBridge(session.id).catch(() => { });
@@ -234,11 +245,11 @@ export const dockerConnector = {
                     vmId: session.id,
                 };
             }
-            // Board task resume: use --continue with user's answer (container alive from ask-human)
+            // Board task resume: continue with user's answer (container alive from ask-human)
             const resumePrompt = ctx?.response ?? "Continue your work.";
             await startSessionMcpBridge(session, params);
-            const agentArgs = buildContinueArgs("/session/workspace/.claude/mcp_config.json", resumePrompt);
-            const proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs);
+            const agentArgs = profile.buildContinueArgs(resumePrompt);
+            const proxy = await sm.spawnAgent(params.taskId, profile.binary, agentArgs, {}, profile.type);
             return {
                 pid: proxy.pid,
                 process: proxy,
@@ -258,80 +269,86 @@ export const dockerConnector = {
     },
     /**
      * Resume a workflow step using a restored session snapshot.
-     * The snapshot has already been restored into the container by the caller.
-     * Uses `claude --continue` for full context restoration.
+     * Restores the engine's state dir into a fresh container, then launches the
+     * engine's continue command for full context restoration.
      */
     async resumeWithSnapshot(params) {
         const sm = getVmManager();
+        const profile = getAgentProfile(params.agentType);
         // 1. Ensure Docker is ready + image available
         await sm.ensureVmRunning();
         // 2. Create session (container + host dirs)
         const sessionId = await sm.createSession(params.taskId);
         const session = sm.getSessionByTaskId(params.taskId);
-        // 3. Clone repo (picks up auto-saved code from git push)
-        await sm.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
-        // 4. Prepare workspace files
-        const skillFiles = [];
-        if (params.skill) {
-            for (const file of params.skill.files) {
-                skillFiles.push({
-                    relativePath: `${params.skill.name}/${file.path}`,
-                    content: file.content,
-                });
+        // From here on, a failure must not leak the freshly created container.
+        try {
+            // 3. Clone repo (picks up auto-saved code from git push)
+            await sm.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
+            // 4. Prepare workspace files
+            const skillFiles = [];
+            if (params.skill) {
+                for (const file of params.skill.files) {
+                    skillFiles.push({
+                        relativePath: `${params.skill.name}/${file.path}`,
+                        content: file.content,
+                    });
+                }
             }
-        }
-        sm.prepareWorkspace(sessionId, {
-            contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
-            mcpConfigJson: buildMcpConfigJson(session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
-            skillFiles,
-        });
-        await sm.exec(params.taskId, "bash", [
-            "-c",
-            [
-                "mkdir -p /session/workspace/.forgeai /session/workspace/.claude",
-                "cp /session/context.json /session/workspace/.forgeai/context.json",
-                "cp /session/mcp_config.json /session/workspace/.claude/mcp_config.json",
-            ].join(" && "),
-        ]);
-        if (skillFiles.length > 0) {
+            sm.prepareWorkspace(sessionId, {
+                contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
+                mcpConfigJson: buildAgentConfig(profile, session.sessionIndex, session.mcpSecret, await resolveMcpRelayHost()),
+                skillFiles,
+            });
             await sm.exec(params.taskId, "bash", [
                 "-c",
-                [
-                    "mkdir -p /session/workspace/.claude/skills",
-                    "cp -r /session/skills/. /session/workspace/.claude/skills/",
-                ].join(" && "),
+                buildConfigInstallScript(profile),
             ]);
+            if (skillFiles.length > 0) {
+                await sm.exec(params.taskId, "bash", [
+                    "-c",
+                    [
+                        "mkdir -p /session/workspace/.claude/skills",
+                        "cp -r /session/skills/. /session/workspace/.claude/skills/",
+                    ].join(" && "),
+                ]);
+            }
+            // 5. Install agent credentials inside the fresh container
+            await assertAgentBinaryAvailable(sm, params.taskId, profile);
+            await sm.materializeAgentAuth(params.taskId, profile.type);
+            // 6. Restore the session snapshot (already written to sessionDir by caller)
+            const { restoreSessionSnapshot } = await import("../../vm/session-snapshot.js");
+            const snapshotRestored = await restoreSessionSnapshot(session, params.sessionSnapshotBase64, profile);
+            // 7. Start MCP bridge
+            await startSessionMcpBridge(session, params);
+            // 8. Spawn with the continue command if snapshot restored, otherwise fresh prompt
+            let proxy;
+            if (snapshotRestored) {
+                vmLog.cyan("docker-connector", `Spawning ${profile.type} continue (snapshot restored) in ${sessionId}`, sessionId);
+                const continuePrompt = params.prompt ??
+                    "Continue your work from where you left off. Do not repeat completed work.";
+                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildContinueArgs(continuePrompt), {}, profile.type);
+            }
+            else {
+                vmLog.warn("docker-connector", `Snapshot restore failed — falling back to prompt in ${sessionId}`, sessionId);
+                const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+                proxy = await sm.spawnAgent(params.taskId, profile.binary, profile.buildArgs(prompt), {}, profile.type);
+            }
+            // Workflow: keep container alive for idle window
+            proxy.once("exit", () => {
+                stopMcpBridge(sessionId).catch(() => { });
+                vmLog.dim("docker-connector", `Snapshot-resumed workflow agent exited — container ${sessionId} kept alive`, sessionId);
+            });
+            return {
+                pid: proxy.pid,
+                process: proxy,
+                vmId: sessionId,
+            };
         }
-        // 5. Restore the session snapshot (already written to sessionDir by caller)
-        const { restoreSessionSnapshot } = await import("../../vm/session-snapshot.js");
-        const snapshotRestored = await restoreSessionSnapshot(session, params.sessionSnapshotBase64);
-        // 6. Start MCP bridge
-        await startSessionMcpBridge(session, params);
-        // 7. Spawn with --continue if snapshot restored, otherwise -p prompt
-        let proxy;
-        if (snapshotRestored) {
-            vmLog.cyan("docker-connector", `Spawning with --continue (snapshot restored) in ${sessionId}`, sessionId);
-            const continuePrompt = params.prompt ??
-                "Continue your work from where you left off. Do not repeat completed work.";
-            const agentArgs = buildContinueArgs("/session/workspace/.claude/mcp_config.json", continuePrompt);
-            proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs);
-        }
-        else {
-            vmLog.warn("docker-connector", `Snapshot restore failed — falling back to prompt in ${sessionId}`, sessionId);
-            const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
-            const agentArgs = buildAgentArgs("/session/workspace/.claude/mcp_config.json", prompt);
-            proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs);
-        }
-        // Workflow: keep container alive for idle window
-        proxy.once("exit", () => {
+        catch (err) {
             stopMcpBridge(sessionId).catch(() => { });
-            vmLog.dim("docker-connector", `Snapshot-resumed workflow agent exited — container ${sessionId} kept alive`, sessionId);
-        });
-        return {
-            pid: proxy.pid,
-            process: proxy,
-            vmId: sessionId,
-        };
+            await sm.destroySession(params.taskId).catch(() => { });
+            throw err;
+        }
     },
 };
 //# sourceMappingURL=docker-connector.js.map

package/dist/orchestrator/opencode-jsonl-extractor.d.ts

@@ -0,0 +1,47 @@
+import type { AgentStreamExtractor, QuestionData, ToolActivityData, TokenUsageData } from "./stream-json-extractor.js";
+/**
+ * Extracts normalized events from OpenCode's `opencode run --format json`
+ * output.
+ *
+ * OpenCode emits newline-delimited JSON events, each carrying a `sessionID`
+ * and a `part` object:
+ *   {"type":"step_start","part":{...}}
+ *   {"type":"text","part":{"id":"prt_...","type":"text","text":"..."}}
+ *   {"type":"tool_use","part":{"callID":"...","tool":"bash","state":{"status":"completed","input":{...}}}}
+ *   {"type":"step_finish","part":{"tokens":{"input":N,"output":N,"reasoning":N,"cache":{"read":N,"write":N}}}}
+ *   {"type":"error",...}
+ *
+ * Exposes the same callback surface as StreamJsonExtractor so the spawn
+ * pipeline (StreamBatcher → Socket.io) is unchanged. OpenCode has no
+ * equivalent of Claude's AskUserQuestion tool — structured questions reach
+ * the Cloud via the forge_ask_human MCP tool instead.
+ */
+export declare class OpenCodeJsonlExtractor implements AgentStreamExtractor {
+    private readonly onText;
+    private lineBuf;
+    /** Emitted text length per text part id (suffix dedup across re-emits). */
+    private readonly emittedTextLengths;
+    /** Tool call ids already reported as activity. */
+    private readonly emittedCallIds;
+    private hasEmittedText;
+    turnIndex: number;
+    lastError: string | null;
+    /** OpenCode session id (ses_...) — usable with `opencode run --session`. */
+    openCodeSessionId: string | null;
+    private inputTokens;
+    private outputTokens;
+    private readonly onToolActivity?;
+    private readonly onTokenUsage?;
+    private readonly sessionId?;
+    constructor(onText: (delta: string) => void, _onQuestion?: (questions: QuestionData[]) => void, onToolActivity?: (activity: ToolActivityData) => void, onTokenUsage?: (usage: TokenUsageData) => void, sessionId?: string);
+    write(data: string): void;
+    flush(): void;
+    private parseLine;
+    private handleText;
+    private handleToolUse;
+    private handleTokens;
+    private captureError;
+    isBillingError(extraText?: string): boolean;
+    extractResetTimestamp(extraText?: string): string | null;
+}
+//# sourceMappingURL=opencode-jsonl-extractor.d.ts.map