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

package/dist/orchestrator/opencode-jsonl-extractor.js

@@ -0,0 +1,228 @@
+import { vmLog } from "../vm/log.js";
+import { extractResetTimestampFromTexts, matchesBillingPatterns, } from "./billing-detect.js";
+import { TOOL_DETAIL_EXTRACTORS } from "./stream-json-extractor.js";
+/**
+ * Maps OpenCode's lowercase built-in tool names to the display names the
+ * Cloud UI already knows from Claude Code, with per-tool detail extraction.
+ */
+const OPENCODE_TOOL_MAP = {
+    bash: { name: "Bash", detail: (i) => firstLine(i.command, 80) },
+    read: { name: "Read", detail: (i) => truncatePath(i.filePath, 60) },
+    edit: { name: "Edit", detail: (i) => truncatePath(i.filePath, 60) },
+    write: { name: "Write", detail: (i) => truncatePath(i.filePath, 60) },
+    patch: { name: "Edit", detail: (i) => truncatePath(i.filePath, 60) },
+    grep: { name: "Grep", detail: (i) => truncate(i.pattern, 40) },
+    glob: { name: "Glob", detail: (i) => truncate(i.pattern, 60) },
+    webfetch: { name: "WebFetch", detail: (i) => truncate(i.url, 60) },
+    websearch: { name: "WebSearch", detail: (i) => truncate(i.query, 60) },
+    task: { name: "Agent", detail: (i) => truncate(i.description, 60) },
+};
+/**
+ * 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 class OpenCodeJsonlExtractor {
+    onText;
+    lineBuf = "";
+    /** Emitted text length per text part id (suffix dedup across re-emits). */
+    emittedTextLengths = new Map();
+    /** Tool call ids already reported as activity. */
+    emittedCallIds = new Set();
+    hasEmittedText = false;
+    turnIndex = 0;
+    lastError = null;
+    /** OpenCode session id (ses_...) — usable with `opencode run --session`. */
+    openCodeSessionId = null;
+    inputTokens = 0;
+    outputTokens = 0;
+    onToolActivity;
+    onTokenUsage;
+    sessionId;
+    constructor(onText, _onQuestion, onToolActivity, onTokenUsage, sessionId) {
+        this.onText = onText;
+        this.onToolActivity = onToolActivity;
+        this.onTokenUsage = onTokenUsage;
+        this.sessionId = sessionId;
+    }
+    write(data) {
+        this.lineBuf += data;
+        let newlineIdx;
+        while ((newlineIdx = this.lineBuf.indexOf("\n")) !== -1) {
+            const line = this.lineBuf.slice(0, newlineIdx).trim();
+            this.lineBuf = this.lineBuf.slice(newlineIdx + 1);
+            if (line)
+                this.parseLine(line);
+        }
+    }
+    flush() {
+        const line = this.lineBuf.trim();
+        this.lineBuf = "";
+        if (line)
+            this.parseLine(line);
+    }
+    parseLine(line) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            vmLog.dim("opencode-jsonl", "Non-JSON line skipped", this.sessionId);
+            return;
+        }
+        if (typeof obj.sessionID === "string" && !this.openCodeSessionId) {
+            this.openCodeSessionId = obj.sessionID;
+        }
+        const part = obj.part;
+        switch (obj.type) {
+            case "step_start":
+                this.turnIndex++;
+                break;
+            case "text":
+                this.handleText(part);
+                break;
+            case "tool_use":
+                this.handleToolUse(part);
+                break;
+            case "step_finish":
+                this.handleTokens(part);
+                break;
+            case "error":
+                this.captureError(obj);
+                break;
+        }
+    }
+    handleText(part) {
+        if (!part || typeof part.text !== "string")
+            return;
+        const partId = typeof part.id === "string" ? part.id : "__single__";
+        const emitted = this.emittedTextLengths.get(partId) ?? 0;
+        if (part.text.length <= emitted)
+            return;
+        const delta = part.text.slice(emitted);
+        this.emittedTextLengths.set(partId, part.text.length);
+        // Separate consecutive text parts with a blank line
+        const prefix = emitted === 0 && this.hasEmittedText ? "\n\n" : "";
+        this.hasEmittedText = true;
+        this.onText(prefix + delta);
+    }
+    handleToolUse(part) {
+        if (!this.onToolActivity || !part)
+            return;
+        const callId = typeof part.callID === "string"
+            ? part.callID
+            : typeof part.id === "string"
+                ? part.id
+                : null;
+        if (!callId || this.emittedCallIds.has(callId))
+            return;
+        const tool = typeof part.tool === "string" ? part.tool : null;
+        if (!tool)
+            return;
+        const state = part.state;
+        const status = state?.status;
+        // Emit as soon as the tool is running (or completed if we only see that)
+        if (status !== undefined && status === "pending")
+            return;
+        const input = (state?.input ?? {});
+        const mapped = OPENCODE_TOOL_MAP[tool];
+        if (mapped) {
+            this.emittedCallIds.add(callId);
+            this.onToolActivity({
+                toolName: mapped.name,
+                toolDetail: mapped.detail(input) ?? mapped.name,
+            });
+            return;
+        }
+        // MCP tools surface under their exposed name, possibly prefixed with the
+        // server name (e.g. "forgeai_forge_create_task"). Try the forge_* detail
+        // extractors after stripping a server prefix.
+        const bareName = tool.startsWith("forgeai_")
+            ? tool.slice("forgeai_".length)
+            : tool;
+        const extractor = TOOL_DETAIL_EXTRACTORS[bareName];
+        this.emittedCallIds.add(callId);
+        this.onToolActivity({
+            toolName: bareName,
+            toolDetail: (extractor ? extractor(input) : null) ?? bareName,
+        });
+    }
+    handleTokens(part) {
+        if (!this.onTokenUsage || !part)
+            return;
+        const tokens = part.tokens;
+        if (!tokens)
+            return;
+        const cache = (tokens.cache ?? {});
+        const input = num(tokens.input) + num(cache.read) + num(cache.write);
+        const output = num(tokens.output) + num(tokens.reasoning);
+        if (input === 0 && output === 0)
+            return;
+        this.inputTokens += input;
+        this.outputTokens += output;
+        this.onTokenUsage({
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+        });
+    }
+    captureError(obj) {
+        const error = obj.error ?? obj.part ?? obj;
+        if (typeof error === "string") {
+            this.lastError = error;
+            return;
+        }
+        if (error && typeof error === "object") {
+            const rec = error;
+            if (typeof rec.message === "string") {
+                this.lastError = rec.message;
+                return;
+            }
+            const data = rec.data;
+            if (data && typeof data.message === "string") {
+                this.lastError = data.message;
+                return;
+            }
+            this.lastError = JSON.stringify(rec).slice(0, 1000);
+        }
+    }
+    isBillingError(extraText) {
+        return matchesBillingPatterns([this.lastError, extraText]);
+    }
+    extractResetTimestamp(extraText) {
+        return extractResetTimestampFromTexts([this.lastError, extraText]);
+    }
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function firstLine(value, maxLen) {
+    if (typeof value !== "string" || !value)
+        return null;
+    const line = value.split("\n")[0] ?? value;
+    return line.length > maxLen ? line.slice(0, maxLen - 3) + "..." : line;
+}
+function truncate(value, maxLen) {
+    if (typeof value !== "string" || !value)
+        return null;
+    return value.length > maxLen ? value.slice(0, maxLen - 3) + "..." : value;
+}
+function truncatePath(value, maxLen) {
+    if (typeof value !== "string" || !value)
+        return null;
+    if (value.length <= maxLen)
+        return value;
+    return "..." + value.slice(-(maxLen - 3));
+}
+//# sourceMappingURL=opencode-jsonl-extractor.js.map

package/dist/orchestrator/resume-handler.js

@@ -105,6 +105,7 @@ export async function handleResume(payload, ctx) {
             mcpConfigPath: "/workspace/.claude/mcp_config.json",
             skillName: skill?.name ?? resumeSkillName,
             prompt: validatedPayload.taskCommand,
+            agentType: ctx.agentType,
             repoUrl: payload.repoUrl,
             taskBranch,
             skill: skill ? { name: skill.name, files: skill.files } : undefined,
@@ -149,6 +150,7 @@ export async function handleResume(payload, ctx) {
             spawnAgentFn: boundSpawnAgent,
             label: "resume",
             agentSlots: ctx.agentSlots,
+            agentType: ctx.agentType,
         });
     }
     catch (err) {

package/dist/orchestrator/stream-json-extractor.d.ts

@@ -20,6 +20,44 @@ export type TokenUsageData = {
     inputTokens: number;
     outputTokens: number;
 };
+/**
+ * Common surface every agent stream extractor exposes to the spawner.
+ * StreamJsonExtractor (Claude Code), CodexJsonlExtractor and
+ * OpenCodeJsonlExtractor all satisfy this shape, so the spawn pipeline is
+ * agnostic to which agent engine produced the stdout stream.
+ */
+export type AgentStreamExtractor = {
+    /** Groups text chunks from the same API turn. */
+    turnIndex: number;
+    /** Error text captured from the agent's terminal error event, if any. */
+    lastError: string | null;
+    write(data: string): void;
+    /** Flush any remaining partial line on process exit. */
+    flush(): void;
+    isBillingError(extraText?: string): boolean;
+    extractResetTimestamp(extraText?: string): string | null;
+};
+/**
+ * Extracts text deltas from Claude Code's `--output-format stream-json` output.
+ *
+ * With `--include-partial-messages`, Claude emits newline-delimited JSON objects.
+ * Text tokens arrive as `stream_event` objects with `event.delta.type === "text_delta"`.
+ *
+ * Official filter pattern (from docs):
+ *   select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text
+ *
+ * This extractor also handles:
+ * - `assistant` snapshot messages containing AskUserQuestion tool_use blocks:
+ *   extracts the question text and emits it so the wizard chat user can see it.
+ *   When `onQuestion` is provided, emits structured data instead of formatted text.
+ * - Ignores: thinking, other tool_use, system events, rate limits, etc.
+ */
+/**
+ * Tools we extract activity from, with their detail extractor.
+ * Exported so the Codex/OpenCode extractors reuse the forge_* MCP entries
+ * (the ForgeAI MCP tool names are identical across host agents).
+ */
+export declare const TOOL_DETAIL_EXTRACTORS: Record<string, (input: Record<string, unknown>) => string | null>;
 export declare class StreamJsonExtractor {
     private readonly onText;
     private lineBuf;
@@ -72,7 +110,6 @@ export declare class StreamJsonExtractor {
     private formatOptionLine;
     private formatQuestionOptions;
     private formatQuestions;
-    private static readonly BILLING_PATTERNS;
     /**
      * Check if the captured error (from result event or accumulated stderr)
      * indicates a billing/token exhaustion issue.
@@ -81,17 +118,8 @@ export declare class StreamJsonExtractor {
     isBillingError(extraText?: string): boolean;
     /**
      * Extract the usage-limit reset timestamp from error text.
-     * Handles multiple formats:
-     *   - "reset at 2026-03-08T15:00:00+00:00" (ISO datetime)
-     *   - "resets 7pm (Europe/Paris)" (time + timezone)
-     *   - "resets in 2 hours" (relative duration)
      * Returns an ISO string if a valid future timestamp is found, otherwise null.
      */
     extractResetTimestamp(extraText?: string): string | null;
-    /**
-     * Resolve a time-of-day (e.g. "7pm") in a named timezone to an ISO string.
-     * Uses Intl.DateTimeFormat to avoid external dependencies.
-     */
-    private static resolveTimeInTimezone;
 }
 //# sourceMappingURL=stream-json-extractor.d.ts.map

package/dist/orchestrator/stream-json-extractor.js

@@ -1,4 +1,5 @@
 import { vmLog } from "../vm/log.js";
+import { extractResetTimestampFromTexts, matchesBillingPatterns, } from "./billing-detect.js";
 /**
  * Extracts text deltas from Claude Code's `--output-format stream-json` output.
  *
@@ -14,8 +15,12 @@ import { vmLog } from "../vm/log.js";
  *   When `onQuestion` is provided, emits structured data instead of formatted text.
  * - Ignores: thinking, other tool_use, system events, rate limits, etc.
  */
-/** Tools we extract activity from, with their detail extractor. */
-const TOOL_DETAIL_EXTRACTORS = {
+/**
+ * Tools we extract activity from, with their detail extractor.
+ * Exported so the Codex/OpenCode extractors reuse the forge_* MCP entries
+ * (the ForgeAI MCP tool names are identical across host agents).
+ */
+export const TOOL_DETAIL_EXTRACTORS = {
     Read: (input) => truncateEnd(input.file_path, 60),
     Edit: (input) => truncateEnd(input.file_path, 60),
     Write: (input) => truncateEnd(input.file_path, 60),
@@ -459,121 +464,21 @@ export class StreamJsonExtractor {
         }
         return parts.length > 0 ? "\n" + parts.join("\n") + "\n" : "";
     }
-    // --- Billing / token error detection ---
-    static BILLING_PATTERNS = [
-        /credit.{0,20}balance/i,
-        /insufficient.{0,20}(?:credit|fund|balance|quota)/i,
-        /exceed.{0,20}(?:quota|budget|limit)/i,
-        /usage.{0,20}limit.{0,20}reached/i,
-        /limit.{0,20}(?:will )?reset/i,
-        /(?:hit|reached).{0,10}(?:your )?limit/i,
-        /billing/i,
-        /payment.{0,20}(?:required|failed|method)/i,
-        /account.{0,20}(?:suspended|deactivated)/i,
-        /out of (?:credit|token)/i,
-    ];
+    // --- Billing / token error detection (shared with other extractors) ---
     /**
      * Check if the captured error (from result event or accumulated stderr)
      * indicates a billing/token exhaustion issue.
      * Optionally accepts extra text (e.g. stderr buffer) to scan.
      */
     isBillingError(extraText) {
-        const texts = [this.lastError, extraText].filter(Boolean);
-        return texts.some((text) => StreamJsonExtractor.BILLING_PATTERNS.some((re) => re.test(text)));
+        return matchesBillingPatterns([this.lastError, extraText]);
     }
     /**
      * Extract the usage-limit reset timestamp from error text.
-     * Handles multiple formats:
-     *   - "reset at 2026-03-08T15:00:00+00:00" (ISO datetime)
-     *   - "resets 7pm (Europe/Paris)" (time + timezone)
-     *   - "resets in 2 hours" (relative duration)
      * Returns an ISO string if a valid future timestamp is found, otherwise null.
      */
     extractResetTimestamp(extraText) {
-        const texts = [this.lastError, extraText].filter(Boolean);
-        for (const text of texts) {
-            // Pattern 1: "reset at <ISO datetime>"
-            const isoMatch = /reset\s+at\s+(.+?)(?:\.|$)/i.exec(text);
-            if (isoMatch) {
-                const dateStr = isoMatch[1].trim();
-                const parsed = new Date(dateStr);
-                if (!Number.isNaN(parsed.getTime()) && parsed.getTime() > Date.now()) {
-                    return parsed.toISOString();
-                }
-            }
-            // Pattern 2: "resets 7pm (Europe/Paris)" or "resets 19:00 (Europe/Paris)"
-            const tzMatch = /resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(([^)]+)\)/i.exec(text);
-            if (tzMatch) {
-                const result = StreamJsonExtractor.resolveTimeInTimezone(tzMatch[1], tzMatch[2], tzMatch[3], tzMatch[4]);
-                if (result)
-                    return result;
-            }
-            // Pattern 3: "resets in 2 hours" or "resets in 30 minutes"
-            const relMatch = /resets?\s+in\s+(\d+)\s*(hour|hr|minute|min)s?/i.exec(text);
-            if (relMatch) {
-                const amount = parseInt(relMatch[1], 10);
-                const unit = relMatch[2].toLowerCase();
-                const ms = unit.startsWith("hour") || unit === "hr"
-                    ? amount * 3600_000
-                    : amount * 60_000;
-                const future = new Date(Date.now() + ms);
-                return future.toISOString();
-            }
-        }
-        return null;
-    }
-    /**
-     * Resolve a time-of-day (e.g. "7pm") in a named timezone to an ISO string.
-     * Uses Intl.DateTimeFormat to avoid external dependencies.
-     */
-    static resolveTimeInTimezone(hourStr, minuteStr, ampm, timezone) {
-        try {
-            let hour = parseInt(hourStr, 10);
-            const minute = minuteStr ? parseInt(minuteStr, 10) : 0;
-            if (ampm) {
-                const isPm = ampm.toLowerCase() === "pm";
-                if (isPm && hour < 12)
-                    hour += 12;
-                if (!isPm && hour === 12)
-                    hour = 0;
-            }
-            // Get current date in the target timezone
-            const now = new Date();
-            const formatter = new Intl.DateTimeFormat("en-US", {
-                timeZone: timezone,
-                year: "numeric",
-                month: "2-digit",
-                day: "2-digit",
-                hour: "2-digit",
-                minute: "2-digit",
-                hour12: false,
-            });
-            const parts = formatter.formatToParts(now);
-            const get = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? "0", 10);
-            const tzYear = get("year");
-            const tzMonth = get("month");
-            const tzDay = get("day");
-            const tzHour = get("hour");
-            const tzMinute = get("minute");
-            // Build target time in the timezone's "local" frame
-            // Then compute the UTC offset to convert to absolute time
-            const localNowMs = Date.UTC(tzYear, tzMonth - 1, tzDay, tzHour, tzMinute);
-            const offsetMs = localNowMs - now.getTime();
-            // Target time today in timezone-local frame
-            let targetLocalMs = Date.UTC(tzYear, tzMonth - 1, tzDay, hour, minute);
-            // If already past, try tomorrow
-            if (targetLocalMs - offsetMs <= now.getTime()) {
-                targetLocalMs += 86_400_000;
-            }
-            const result = new Date(targetLocalMs - offsetMs);
-            if (result.getTime() > Date.now()) {
-                return result.toISOString();
-            }
-        }
-        catch {
-            // Invalid timezone or parse error — fall through
-        }
-        return null;
+        return extractResetTimestampFromTexts([this.lastError, extraText]);
     }
 }
 //# sourceMappingURL=stream-json-extractor.js.map

package/dist/vm/agent-auth-manager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Auth storage for Codex and OpenCode agent engines.
+ * (Claude Code keeps its dedicated claude-token-manager.ts.)
+ *
+ * Two credential kinds:
+ *   - "api_key": a provider API key. For Codex it is fed to
+ *     `codex login --with-api-key` inside the container; for OpenCode it is
+ *     injected as the provider's standard env var (envVar) at agent spawn.
+ *   - "auth_json": a full auth.json file content imported from the host
+ *     (ChatGPT-plan login for Codex, OAuth/Pro-Max login for OpenCode),
+ *     written into the container home before spawning.
+ *
+ * Storage: macOS Keychain / encrypted file via secure-store.ts. The payload
+ * is stored as a JSON string.
+ */
+export type AuthAgent = "CODEX" | "OPENCODE";
+export type AgentAuthPayload = {
+    kind: "api_key";
+    value: string;
+    envVar?: string;
+} | {
+    kind: "auth_json";
+    value: string;
+};
+/** Container path where each engine expects its auth.json. */
+export declare const AGENT_AUTH_JSON_PATHS: Record<AuthAgent, string>;
+/** Host path each engine's own CLI stores its auth.json at (for import). */
+export declare function getHostAuthJsonPath(agent: AuthAgent): string;
+export declare function saveAgentAuth(agent: AuthAgent, payload: AgentAuthPayload): Promise<void>;
+export declare function loadAgentAuth(agent: AuthAgent): Promise<AgentAuthPayload | null>;
+export declare function hasAgentAuth(agent: AuthAgent): Promise<boolean>;
+//# sourceMappingURL=agent-auth-manager.d.ts.map

package/dist/vm/agent-auth-manager.js

@@ -0,0 +1,68 @@
+/**
+ * Auth storage for Codex and OpenCode agent engines.
+ * (Claude Code keeps its dedicated claude-token-manager.ts.)
+ *
+ * Two credential kinds:
+ *   - "api_key": a provider API key. For Codex it is fed to
+ *     `codex login --with-api-key` inside the container; for OpenCode it is
+ *     injected as the provider's standard env var (envVar) at agent spawn.
+ *   - "auth_json": a full auth.json file content imported from the host
+ *     (ChatGPT-plan login for Codex, OAuth/Pro-Max login for OpenCode),
+ *     written into the container home before spawning.
+ *
+ * Storage: macOS Keychain / encrypted file via secure-store.ts. The payload
+ * is stored as a JSON string.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { vmLog } from "./log.js";
+import { loadSecret, saveSecret } from "./secure-store.js";
+const STORE_LOCATIONS = {
+    CODEX: {
+        keychainService: "ForgeAI-codex-auth",
+        keychainAccount: "codex-auth",
+        fileName: "codex-auth.json",
+        fileSalt: "forgeai-codex-auth-salt",
+    },
+    OPENCODE: {
+        keychainService: "ForgeAI-opencode-auth",
+        keychainAccount: "opencode-auth",
+        fileName: "opencode-auth.json",
+        fileSalt: "forgeai-opencode-auth-salt",
+    },
+};
+/** Container path where each engine expects its auth.json. */
+export const AGENT_AUTH_JSON_PATHS = {
+    CODEX: "/home/agent/.codex/auth.json",
+    OPENCODE: "/home/agent/.local/share/opencode/auth.json",
+};
+/** Host path each engine's own CLI stores its auth.json at (for import). */
+export function getHostAuthJsonPath(agent) {
+    return agent === "CODEX"
+        ? join(homedir(), ".codex", "auth.json")
+        : join(homedir(), ".local", "share", "opencode", "auth.json");
+}
+export async function saveAgentAuth(agent, payload) {
+    await saveSecret(STORE_LOCATIONS[agent], JSON.stringify(payload));
+    vmLog.info("agent-auth", `${agent} credentials stored securely (${payload.kind})`);
+}
+export async function loadAgentAuth(agent) {
+    const raw = await loadSecret(STORE_LOCATIONS[agent]);
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.kind !== "api_key" && parsed.kind !== "auth_json")
+            return null;
+        if (typeof parsed.value !== "string" || !parsed.value)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function hasAgentAuth(agent) {
+    return (await loadAgentAuth(agent)) !== null;
+}
+//# sourceMappingURL=agent-auth-manager.js.map

package/dist/vm/docker-process-proxy.d.ts

@@ -8,6 +8,7 @@
 import { EventEmitter } from "node:events";
 import { PassThrough } from "node:stream";
 import type { ChildProcess } from "node:child_process";
+import type { AgentAuthErrorPatterns } from "../orchestrator/agent-profiles.js";
 import type { AgentProcess } from "../orchestrator/connectors/connector.js";
 export declare class DockerProcessProxy extends EventEmitter implements AgentProcess {
     private readonly sessionId;
@@ -20,7 +21,7 @@ export declare class DockerProcessProxy extends EventEmitter implements AgentPro
     killed: boolean;
     /** Set to true when exit was caused by an authentication error */
     isAuthError: boolean;
-    constructor(sessionId: string, dockerExecProcess: ChildProcess, killFn: (signal?: string) => Promise<void>);
+    constructor(sessionId: string, dockerExecProcess: ChildProcess, killFn: (signal?: string) => Promise<void>, authPatterns?: AgentAuthErrorPatterns, authSetupHint?: string);
     /**
      * Kill the agent process via the injected kill function.
      * Returns true if the kill signal was sent, false if the process was already dead.

package/dist/vm/docker-process-proxy.js

@@ -8,6 +8,15 @@
 import { EventEmitter } from "node:events";
 import { PassThrough } from "node:stream";
 import { vmLog } from "./log.js";
+/** Fallback when no profile is supplied (historical Claude Code behavior). */
+const DEFAULT_AUTH_PATTERNS = {
+    stderr: [
+        "Not logged in",
+        "Invalid or expired token",
+        "CLAUDE_CODE_OAUTH_TOKEN",
+    ],
+    combined: ['"authentication_error"', "Failed to authenticate"],
+};
 export class DockerProcessProxy extends EventEmitter {
     sessionId;
     dockerExecProcess;
@@ -19,7 +28,7 @@ export class DockerProcessProxy extends EventEmitter {
     killed = false;
     /** Set to true when exit was caused by an authentication error */
     isAuthError = false;
-    constructor(sessionId, dockerExecProcess, killFn) {
+    constructor(sessionId, dockerExecProcess, killFn, authPatterns = DEFAULT_AUTH_PATTERNS, authSetupHint = "forge auth setup-claude") {
         super();
         this.sessionId = sessionId;
         this.dockerExecProcess = dockerExecProcess;
@@ -62,18 +71,16 @@ export class DockerProcessProxy extends EventEmitter {
                 if (combined) {
                     // Always log the actual error first for debugging
                     vmLog.error("agent-stderr", `Session ${sessionId} exit=${this.exitCode}: ${combined.slice(0, 500)}`, this.sessionId);
-                    // Flag as auth error on specific patterns:
-                    // - stderr: explicit auth failures from Claude Code CLI
-                    // - combined: authentication_error JSON from API (arrives via stdout stream-json)
+                    // Flag as auth error on the engine's specific patterns:
+                    // - stderr: explicit auth failures from the agent CLI itself
+                    // - combined: authentication errors from the provider API (arrive
+                    //   via the stdout JSON stream)
                     const stderrOnly = stderrBuffer.trim();
-                    const isAuthError = stderrOnly.includes("Not logged in") ||
-                        stderrOnly.includes("Invalid or expired token") ||
-                        stderrOnly.includes("CLAUDE_CODE_OAUTH_TOKEN") ||
-                        combined.includes('"authentication_error"') ||
-                        combined.includes("Failed to authenticate");
+                    const isAuthError = authPatterns.stderr.some((p) => stderrOnly.includes(p)) ||
+                        authPatterns.combined.some((p) => combined.includes(p));
                     if (isAuthError) {
                         this.isAuthError = true;
-                        vmLog.error("agent-auth", "Claude OAuth token expired or invalid. Run: forge auth setup-claude", this.sessionId);
+                        vmLog.error("agent-auth", `Agent credentials expired or invalid. Run: ${authSetupHint}`, this.sessionId);
                     }
                 }
                 else {

package/dist/vm/image-manager.js

@@ -5,7 +5,7 @@ import { promisify } from "node:util";
 import chalk from "chalk";
 const execFileAsync = promisify(execFile);
 /** Docker image name for ForgeAI agent containers */
-export const FORGEAI_IMAGE = process.env.FORGEAI_DOCKER_IMAGE ?? "forgeai/agent:latest";
+export const FORGEAI_IMAGE = process.env.FORGEAI_DOCKER_IMAGE ?? "getforgeai/agent:latest";
 /** Path to the Dockerfile for building the agent image */
 function getDockerfilePath() {
     // From dist/vm/ or src/vm/, go up to cli root, then rootfs/

package/dist/vm/secure-store.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generic secure secret storage, parameterized by Keychain service / file path.
+ *
+ * Same scheme as claude-token-manager.ts:
+ *   - macOS: Keychain via the `security` CLI
+ *   - Linux/Windows: AES-256-GCM file encrypted with a machine-identity key
+ *
+ * Used by agent-auth-manager.ts for Codex / OpenCode credentials.
+ */
+export type SecureStoreLocation = {
+    /** macOS Keychain service name (e.g. "ForgeAI-codex-auth"). */
+    keychainService: string;
+    /** macOS Keychain account name. */
+    keychainAccount: string;
+    /** Encrypted-file fallback name under ~/.forgeai/auth/ (Linux/Windows). */
+    fileName: string;
+    /** Per-store scrypt salt for the file encryption key. */
+    fileSalt: string;
+};
+/** Store a secret. Keychain on macOS, encrypted file elsewhere. */
+export declare function saveSecret(location: SecureStoreLocation, value: string): Promise<void>;
+/** Load a secret. Returns null if not found or unreadable. */
+export declare function loadSecret(location: SecureStoreLocation): Promise<string | null>;
+//# sourceMappingURL=secure-store.d.ts.map