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

package/dist/cli.js

@@ -20,6 +20,7 @@ import { sessionRespondAction } from "./commands/session-respond.js";
 import { taskOpenAction } from "./commands/task-open.js";
 import { workflowOpenAction } from "./commands/workflow-open.js";
 import { vmInitAction, vmStatusAction, vmCleanupAction, vmStopAllAction, setupClaudeTokenAction, } from "./commands/vm.js";
+import { setupCodexAuthAction, setupOpenCodeAuthAction, } from "./commands/auth-setup-agent.js";
 const program = new Command();
 program
     .name("forge")
@@ -46,6 +47,14 @@ authCmd
     .command("setup-claude")
     .description("Obtain a long-lived Claude Code OAuth token")
     .action(() => setupClaudeTokenAction());
+authCmd
+    .command("setup-codex")
+    .description("Store Codex credentials (import codex login or OpenAI API key)")
+    .action(() => setupCodexAuthAction());
+authCmd
+    .command("setup-opencode")
+    .description("Store OpenCode credentials (import opencode login or provider API key)")
+    .action(() => setupOpenCodeAuthAction());
 program
     .command("connect")
     .description("Connect to ForgeAI Cloud (spawns background daemon by default)")
@@ -114,7 +123,7 @@ const configSetCmd = configCmd
     .description("Set a configuration value");
 configSetCmd
     .command("agent-type <value>")
-    .description("Set agent type (CLAUDE_CODE or OPENCODE)")
+    .description("Set agent type (CLAUDE_CODE, CODEX or OPENCODE)")
     .action((value) => configSetAgentTypeAction(value));
 configSetCmd
     .command("agent-slots <value>")

package/dist/commands/auth-setup-agent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * forge auth setup-codex / setup-opencode — store credentials for the Codex
+ * and OpenCode agent engines.
+ *
+ * Two paths per engine:
+ *   - Import the auth.json produced by the engine's own login flow on this
+ *     machine (ChatGPT-plan login for Codex, OAuth/Pro-Max for OpenCode).
+ *   - Paste a provider API key.
+ *
+ * Credentials are stored via agent-auth-manager (Keychain on macOS,
+ * encrypted file elsewhere) and injected into agent containers at spawn.
+ */
+export declare function setupCodexAuthAction(): Promise<void>;
+export declare function setupOpenCodeAuthAction(): Promise<void>;
+//# sourceMappingURL=auth-setup-agent.d.ts.map

package/dist/commands/auth-setup-agent.js

@@ -0,0 +1,98 @@
+/**
+ * forge auth setup-codex / setup-opencode — store credentials for the Codex
+ * and OpenCode agent engines.
+ *
+ * Two paths per engine:
+ *   - Import the auth.json produced by the engine's own login flow on this
+ *     machine (ChatGPT-plan login for Codex, OAuth/Pro-Max for OpenCode).
+ *   - Paste a provider API key.
+ *
+ * Credentials are stored via agent-auth-manager (Keychain on macOS,
+ * encrypted file elsewhere) and injected into agent containers at spawn.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { getHostAuthJsonPath, saveAgentAuth, } from "../vm/agent-auth-manager.js";
+import { setConfig } from "../config/config-manager.js";
+function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/** Offer to import the engine's own auth.json from the host. Returns true if imported. */
+async function tryImportHostAuthJson(agent) {
+    const hostPath = getHostAuthJsonPath(agent);
+    if (!existsSync(hostPath))
+        return false;
+    const answer = await ask(`Found existing credentials at ${hostPath}. Import them? [Y/n] `);
+    if (answer && !/^y(es)?$/i.test(answer))
+        return false;
+    const content = readFileSync(hostPath, "utf-8");
+    await saveAgentAuth(agent, { kind: "auth_json", value: content });
+    console.log(chalk.green("Credentials imported and stored securely."));
+    return true;
+}
+export async function setupCodexAuthAction() {
+    try {
+        if (await tryImportHostAuthJson("CODEX"))
+            return;
+        console.log(chalk.dim("No Codex login found to import. You can paste an OpenAI API key instead\n" +
+            "(or run `codex login` first, then re-run this command to import it)."));
+        const key = await ask("OpenAI API key (sk-...): ");
+        if (!key) {
+            console.error(chalk.red("No API key provided."));
+            process.exit(1);
+        }
+        if (!key.startsWith("sk-")) {
+            console.log(chalk.yellow("Warning: key does not start with 'sk-' — storing as-is."));
+        }
+        await saveAgentAuth("CODEX", { kind: "api_key", value: key });
+        console.log(chalk.green("Codex API key stored. Agents can now authenticate."));
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}
+const OPENCODE_PROVIDER_ENV_VARS = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+};
+export async function setupOpenCodeAuthAction() {
+    try {
+        const imported = await tryImportHostAuthJson("OPENCODE");
+        if (!imported) {
+            console.log(chalk.dim("No OpenCode login found to import. You can configure a provider API key instead\n" +
+                "(or run `opencode auth login` first, then re-run this command to import it)."));
+            const provider = (await ask("Provider (anthropic / openai / openrouter) [anthropic]: ")).toLowerCase() || "anthropic";
+            const envVar = OPENCODE_PROVIDER_ENV_VARS[provider];
+            if (!envVar) {
+                console.error(chalk.red(`Unknown provider "${provider}". Allowed: ${Object.keys(OPENCODE_PROVIDER_ENV_VARS).join(", ")}`));
+                process.exit(1);
+            }
+            const key = await ask(`${envVar} value: `);
+            if (!key) {
+                console.error(chalk.red("No API key provided."));
+                process.exit(1);
+            }
+            await saveAgentAuth("OPENCODE", { kind: "api_key", envVar, value: key });
+            console.log(chalk.green("OpenCode API key stored. Agents can now authenticate."));
+        }
+        const model = await ask("OpenCode model (provider/model, e.g. anthropic/claude-sonnet-4-5) — leave empty for OpenCode's default: ");
+        if (model) {
+            setConfig({ opencodeModel: model });
+            console.log(chalk.green(`OpenCode model set to ${model}.`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=auth-setup-agent.js.map

package/dist/commands/config-set.js

@@ -1,19 +1,27 @@
 import chalk from "chalk";
+import { AGENT_TYPE, isAgentType } from "@getforgeai/protocol";
 import { getConfig, setConfig } from "../config/config-manager.js";
 import { isDaemonRunning } from "../lib/daemon.js";
 import { DaemonNotRunningError, sendIpcCommand } from "../lib/ipc-client.js";
-const VALID_AGENT_TYPES = ["CLAUDE_CODE"];
 const VALID_OPENERS = ["terminal", "vscode", "finder"];
+const AGENT_AUTH_SETUP_HINTS = {
+    CODEX: "forge auth setup-codex",
+    OPENCODE: "forge auth setup-opencode",
+};
 export async function configSetAgentTypeAction(value) {
     const upper = value.toUpperCase();
-    if (!VALID_AGENT_TYPES.includes(upper)) {
-        console.error(chalk.red(`Invalid agent type "${value}". Allowed: ${VALID_AGENT_TYPES.join(", ")}`));
+    if (!isAgentType(upper)) {
+        console.error(chalk.red(`Invalid agent type "${value}". Allowed: ${AGENT_TYPE.join(", ")}`));
         process.exitCode = 1;
         return;
     }
     setConfig({ agentType: upper });
     const applied = await tryReRegister();
     console.log(chalk.green(`Agent type set to ${upper}. ${applied ? "(Applied immediately)" : "(Will apply on next connect)"}`));
+    const hint = AGENT_AUTH_SETUP_HINTS[upper];
+    if (hint) {
+        console.log(chalk.dim(`Make sure credentials are configured: ${hint}`));
+    }
 }
 export async function configSetAgentSlotsAction(value) {
     const num = Number.parseInt(value, 10);
@@ -40,6 +48,9 @@ export function configGetAction() {
     const config = getConfig();
     console.log(chalk.dim("Current configuration:"));
     console.log(`  Agent type:  ${config.agentType ?? "CLAUDE_CODE"}`);
+    if (config.agentType === "OPENCODE") {
+        console.log(`  OpenCode model: ${config.opencodeModel ?? "(OpenCode default)"}`);
+    }
     console.log(`  Agent slots: ${config.agentSlots ?? 5}`);
     console.log(`  Opener:      ${config.opener ?? "terminal"}`);
     console.log(`  Server URL:  ${config.serverUrl}`);

package/dist/commands/connect.js

@@ -122,14 +122,30 @@ async function connectForeground(options) {
     const ctx = resolveConnectContext(options);
     if (!ctx)
         return;
-    // Ensure Claude OAuth token is available for container authentication
-    try {
-        const { ensureClaudeToken } = await import("../vm/claude-token-manager.js");
-        await ensureClaudeToken();
+    // Ensure agent credentials are available for container authentication
+    if (ctx.agentType === "CODEX" || ctx.agentType === "OPENCODE") {
+        try {
+            const { hasAgentAuth } = await import("../vm/agent-auth-manager.js");
+            if (!(await hasAgentAuth(ctx.agentType))) {
+                const setupCmd = ctx.agentType === "CODEX"
+                    ? "forge auth setup-codex"
+                    : "forge auth setup-opencode";
+                console.warn(chalk.yellow(`[connect] No ${ctx.agentType} credentials stored. Agents may fail to authenticate. Run: ${setupCmd}`));
+            }
+        }
+        catch {
+            /* Non-fatal */
+        }
     }
-    catch (err) {
-        console.warn(chalk.yellow(`[connect] Claude token setup failed: ${err instanceof Error ? err.message : String(err)}`));
-        console.warn(chalk.yellow("[connect] Agents may fail to authenticate. Run: forge auth setup-claude"));
+    else {
+        try {
+            const { ensureClaudeToken } = await import("../vm/claude-token-manager.js");
+            await ensureClaudeToken();
+        }
+        catch (err) {
+            console.warn(chalk.yellow(`[connect] Claude token setup failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.warn(chalk.yellow("[connect] Agents may fail to authenticate. Run: forge auth setup-claude"));
+        }
     }
     // Initialize VM manager (helper process or direct addon)
     try {

package/dist/config/config-manager.d.ts

@@ -11,6 +11,8 @@ export type CliConfig = {
     cliId?: string;
     cliName?: string;
     agentType?: string;
+    /** OpenCode model in "provider/model" form (used when agentType is OPENCODE). */
+    opencodeModel?: string;
     agentSlots?: number;
     opener?: Opener;
     lastSyncCursor?: string;

package/dist/lib/connection-manager.d.ts

@@ -10,9 +10,20 @@ export type OrgConnection = {
     journal: EventJournal;
     emitter: ResilientEmitter;
     heartbeatInterval: ReturnType<typeof setInterval>;
+    /** Mutable context shared by this org's dispatch/resume handlers. */
+    spawnerCtx: {
+        agentType: string;
+        agentSlots: number;
+    };
 };
 /** Active connections keyed by orgId. */
 export declare const activeConnections: Map<string, OrgConnection>;
+/**
+ * Apply a new agent engine to every live org connection's spawner context, so
+ * already-registered dispatch/resume handlers pick it up without reconnecting.
+ * Called from the cli:config:updated handler and the daemon re-register IPC.
+ */
+export declare function applyAgentTypeToActiveConnections(agentType: string): void;
 export type ConnectOptions = {
     server?: string;
     org?: string;

package/dist/lib/connection-manager.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import chalk from "chalk";
+import { isAgentType } from "@getforgeai/protocol";
 import { getConfig, getServerUrl, setConfig, } from "../config/config-manager.js";
 import { loadToken, stableHostname } from "../config/token-manager.js";
 import { createRestClient, RestClientError } from "./rest-client.js";
@@ -19,6 +20,16 @@ let mcpReprobeTimer = null;
 let mcpProbeInFlight = false; // Prevent concurrent probe runs
 /** Active connections keyed by orgId. */
 export const activeConnections = new Map();
+/**
+ * Apply a new agent engine to every live org connection's spawner context, so
+ * already-registered dispatch/resume handlers pick it up without reconnecting.
+ * Called from the cli:config:updated handler and the daemon re-register IPC.
+ */
+export function applyAgentTypeToActiveConnections(agentType) {
+    for (const conn of activeConnections.values()) {
+        conn.spawnerCtx.agentType = agentType;
+    }
+}
 /**
  * Run MCP health probe and manage re-probe lifecycle.
  * Called once after connections are established.
@@ -190,40 +201,40 @@ export function establishConnections(ctx, append = false) {
         registerArtifactHandlers(client.socket, org.orgId);
         // Register branch handlers (Story 5c.1)
         registerBranchHandlers(client.socket, org.orgId);
-        // Register agent dispatch handler (Story 6.3, queue added Story 6.5)
-        const drainCtx = registerDispatchHandler(client.socket, org.orgId, {
+        // Single shared spawner context for all handlers of this org connection.
+        // Server-pushed config updates (agentType) mutate it so already-registered
+        // handlers pick up the change without re-registering.
+        const spawnerCtx = {
             restClient,
             socketClient: client,
             agentType: ctx.agentType,
             agentSlots: ctx.agentSlots,
             queue: dispatchQueue,
-        });
+        };
+        // Register agent dispatch handler (Story 6.3, queue added Story 6.5)
+        const drainCtx = registerDispatchHandler(client.socket, org.orgId, spawnerCtx);
         // Register agent resume handler (Story 6.4, queue added Story 6.5)
-        registerResumeHandler(client.socket, org.orgId, {
-            restClient,
-            socketClient: client,
-            agentType: ctx.agentType,
-            agentSlots: ctx.agentSlots,
-            queue: dispatchQueue,
-        });
+        registerResumeHandler(client.socket, org.orgId, spawnerCtx);
         // Register workflow step dispatch handler (Story 6b-7)
-        registerWorkflowStepDispatchHandler(client.socket, org.orgId, {
-            restClient,
-            socketClient: client,
-            agentType: ctx.agentType,
-            agentSlots: ctx.agentSlots,
-            queue: dispatchQueue,
-        });
+        registerWorkflowStepDispatchHandler(client.socket, org.orgId, spawnerCtx);
         // Register workflow agent dismiss handler (Story 6b-10)
-        registerWorkflowAgentDismissHandler(client.socket, {
-            restClient,
-            socketClient: client,
-            agentType: ctx.agentType,
-            agentSlots: ctx.agentSlots,
-            queue: dispatchQueue,
-        });
-        // Listen for server-pushed config updates (e.g., admin changed agentSlots in UI)
+        registerWorkflowAgentDismissHandler(client.socket, spawnerCtx);
+        // Listen for server-pushed config updates (e.g., admin changed agentSlots
+        // or the agent engine in the Cloud UI)
         client.socket.on("cli:config:updated", (payload) => {
+            if (payload.agentType && isAgentType(payload.agentType)) {
+                if (payload.agentType !== ctx.agentType) {
+                    const previousType = ctx.agentType;
+                    ctx.agentType = payload.agentType;
+                    // All orgs share one engine — update every live spawner context,
+                    // not only this org's.
+                    spawnerCtx.agentType = payload.agentType;
+                    applyAgentTypeToActiveConnections(payload.agentType);
+                    // Persist so future sessions start with the new engine
+                    setConfig({ agentType: payload.agentType });
+                    console.log(chalk.green(`${prefix(org.orgSlug)}Agent type updated by server: ${previousType} → ${payload.agentType}`));
+                }
+            }
             if (payload.agentSlots != null && payload.agentSlots !== ctx.agentSlots) {
                 const previous = ctx.agentSlots;
                 ctx.agentSlots = payload.agentSlots;
@@ -272,6 +283,17 @@ export function establishConnections(ctx, append = false) {
                     agentSlots: ctx.agentSlots,
                 });
                 console.log(chalk.green(`${prefix(org.orgSlug)}CLI registered as "${ctx.cliName}"`));
+                // The server is source of truth for agentType after first registration
+                // (a cockpit edit made while this CLI was offline must survive the
+                // reconnect). Adopt the returned value.
+                if (isAgentType(device.agentType) &&
+                    device.agentType !== ctx.agentType) {
+                    const previousType = ctx.agentType;
+                    ctx.agentType = device.agentType;
+                    applyAgentTypeToActiveConnections(device.agentType);
+                    setConfig({ agentType: device.agentType });
+                    console.log(chalk.green(`${prefix(org.orgSlug)}Agent type synced from server: ${previousType} → ${device.agentType}`));
+                }
                 // Join member room so we receive workflow:step:dispatch events
                 if (device.memberId) {
                     client.socket.emit("join:member", device.memberId);
@@ -364,6 +386,7 @@ export function establishConnections(ctx, append = false) {
             journal,
             emitter,
             heartbeatInterval,
+            spawnerCtx,
         });
     }
 }

package/dist/lib/daemon-entry.js

@@ -16,12 +16,24 @@ if (!ctx) {
     console.error("[daemon] Failed to resolve connection context — exiting");
     process.exit(1);
 }
-// Check Claude OAuth token availability
+// Check agent credential availability for the configured engine
 try {
-    const { loadClaudeToken } = await import("../vm/claude-token-manager.js");
-    if (!(await loadClaudeToken())) {
-        console.warn(chalk.yellow("[daemon] No Claude OAuth token stored — agents will fail to authenticate."));
-        console.warn(chalk.yellow("[daemon] Run: forge auth setup-claude"));
+    if (ctx.agentType === "CODEX" || ctx.agentType === "OPENCODE") {
+        const { hasAgentAuth } = await import("../vm/agent-auth-manager.js");
+        if (!(await hasAgentAuth(ctx.agentType))) {
+            const setupCmd = ctx.agentType === "CODEX"
+                ? "forge auth setup-codex"
+                : "forge auth setup-opencode";
+            console.warn(chalk.yellow(`[daemon] No ${ctx.agentType} credentials stored — agents will fail to authenticate.`));
+            console.warn(chalk.yellow(`[daemon] Run: ${setupCmd}`));
+        }
+    }
+    else {
+        const { loadClaudeToken } = await import("../vm/claude-token-manager.js");
+        if (!(await loadClaudeToken())) {
+            console.warn(chalk.yellow("[daemon] No Claude OAuth token stored — agents will fail to authenticate."));
+            console.warn(chalk.yellow("[daemon] Run: forge auth setup-claude"));
+        }
     }
 }
 catch {
@@ -153,8 +165,13 @@ async function handleReRegisterCommand() {
         };
     }
     ctx = freshCtxReg;
+    // Propagate the (possibly changed) engine to the live spawner contexts so
+    // `forge config set agent-type` applies to subsequent spawns immediately,
+    // not only after a daemon restart.
+    const { applyAgentTypeToActiveConnections } = await import("./connection-manager.js");
+    applyAgentTypeToActiveConnections(ctx.agentType);
     // Re-register on all active connections using PATCH to explicitly update config
-    // (PATCH includes agentSlots from the CLI config to sync with Cloud)
+    // (PATCH includes agentType/agentSlots from the CLI config to sync with Cloud)
     for (const conn of activeConnections.values()) {
         try {
             await conn.restClient.updateCliConfig({

package/dist/mcp/mcp-probe.d.ts

@@ -1,3 +1,23 @@
+/**
+ * Resolve the ForgeAI CLI binary to spawn for the MCP probe.
+ *
+ * This must point at the CLI entry point (dist/bin/forgeai.js), which is the
+ * only script that parses an `mcp` subcommand. It used to use
+ * `process.argv[1]`, which is correct when the probe runs from the CLI itself
+ * but WRONG in the case that actually matters: the probe normally runs inside
+ * the daemon, where argv[1] is dist/lib/daemon-entry.js. That entry point
+ * parses no arguments, so `daemon-entry.js mcp ...` silently started another
+ * daemon instead of an MCP server — the probe then timed out every time,
+ * `mcpHealthy` stayed false, and the Cloud skipped this CLI for dispatch
+ * (task-dispatch-engine skips CLIs reporting mcpHealthy === false), while each
+ * re-probe leaked one more detached daemon process.
+ *
+ * Resolve it from this module's own location instead: dist/mcp/ -> dist/bin/.
+ */
+export declare function resolveForgeBinary(): {
+    command: string;
+    prefixArgs: string[];
+};
 /**
  * Probe the MCP server to verify it can start and respond to JSON-RPC initialize.
  *

package/dist/mcp/mcp-probe.js

@@ -1,13 +1,33 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import chalk from "chalk";
 const PROBE_TIMEOUT_MS = 10_000;
 /**
- * Resolve the ForgeAI CLI binary for MCP probe.
- * Same logic as agent-spawner's resolveForgeBinary.
+ * Resolve the ForgeAI CLI binary to spawn for the MCP probe.
+ *
+ * This must point at the CLI entry point (dist/bin/forgeai.js), which is the
+ * only script that parses an `mcp` subcommand. It used to use
+ * `process.argv[1]`, which is correct when the probe runs from the CLI itself
+ * but WRONG in the case that actually matters: the probe normally runs inside
+ * the daemon, where argv[1] is dist/lib/daemon-entry.js. That entry point
+ * parses no arguments, so `daemon-entry.js mcp ...` silently started another
+ * daemon instead of an MCP server — the probe then timed out every time,
+ * `mcpHealthy` stayed false, and the Cloud skipped this CLI for dispatch
+ * (task-dispatch-engine skips CLIs reporting mcpHealthy === false), while each
+ * re-probe leaked one more detached daemon process.
+ *
+ * Resolve it from this module's own location instead: dist/mcp/ -> dist/bin/.
  */
-function resolveForgeBinary() {
+export function resolveForgeBinary() {
+    const binPath = join(import.meta.dirname, "..", "bin", "forgeai.js");
+    if (existsSync(binPath)) {
+        return { command: process.execPath, prefixArgs: [binPath] };
+    }
+    // Fallback for unusual layouts: use argv[1] only when it really is the CLI
+    // entry point, never the daemon entry.
     const scriptPath = process.argv[1];
-    if (scriptPath) {
+    if (scriptPath?.includes(join("bin", "forgeai"))) {
         return { command: process.execPath, prefixArgs: [scriptPath] };
     }
     return { command: "forgeai", prefixArgs: [] };

package/dist/orchestrator/agent-profiles.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Per-engine agent profiles: everything that differs between Claude Code,
+ * Codex CLI and OpenCode when running headless inside a ForgeAI Docker
+ * session. The rest of the pipeline (connector lifecycle, MCP bridge,
+ * StreamBatcher, Socket.io contract, snapshot transport) is engine-agnostic.
+ *
+ * | Engine      | Binary     | Config file                              | Resume       |
+ * |-------------|------------|------------------------------------------|--------------|
+ * | CLAUDE_CODE | claude     | /session/workspace/.claude/mcp_config.json (via --mcp-config) | --continue |
+ * | CODEX       | codex      | /home/agent/.codex/config.toml           | exec resume --last |
+ * | OPENCODE    | opencode   | /home/agent/.config/opencode/opencode.json | run --continue |
+ */
+import type { AgentType } from "@getforgeai/protocol";
+import type { AgentStreamExtractor, QuestionData, ToolActivityData, TokenUsageData } from "./stream-json-extractor.js";
+export type McpBridgeConfig = {
+    host: string;
+    port: number;
+    token: string;
+};
+export type AgentConfigOptions = {
+    /** OpenCode model in "provider/model" form (from CLI config, optional). */
+    model?: string;
+};
+export type AgentAuthErrorPatterns = {
+    /** Substrings matched against stderr only (avoids stdout false positives). */
+    stderr: string[];
+    /** Substrings matched against combined stderr + stdout tail. */
+    combined: string[];
+};
+export type AgentProfile = {
+    type: AgentType;
+    /** Binary name resolved via PATH inside the container. */
+    binary: string;
+    /**
+     * Container-absolute path where the generated agent config file (MCP wiring
+     * + permissions) is installed. The file is staged on the host volume as
+     * /session/mcp_config.json regardless of its actual format.
+     */
+    configTargetPath: string;
+    /** Build the agent config file content (JSON or TOML depending on engine). */
+    buildConfig(mcp: McpBridgeConfig, opts?: AgentConfigOptions): string;
+    /** argv for a fresh non-interactive run. */
+    buildArgs(prompt: string): string[];
+    /** argv to continue the latest on-disk session in the same home dir. */
+    buildContinueArgs(prompt: string): string[];
+    /** Non-secret env vars added to every agent spawn. */
+    spawnEnv: Record<string, string>;
+    /** Container dir holding the session state snapshotted for resume. */
+    stateDir: string;
+    /** tar --exclude patterns — credentials and cache junk never leave the container. */
+    snapshotExcludes: string[];
+    authErrorPatterns: AgentAuthErrorPatterns;
+    /** Command the user should run to (re-)configure auth for this engine. */
+    authSetupHint: string;
+};
+/** Narrow an arbitrary config/dispatch string to a supported AgentType. */
+export declare function resolveAgentType(value: string | undefined): AgentType;
+export declare function getAgentProfile(agentType: string | undefined): AgentProfile;
+/**
+ * Instantiate the stream extractor matching the agent engine.
+ * All three classes share the AgentStreamExtractor surface and an identical
+ * constructor signature, so spawn call sites stay engine-agnostic.
+ */
+export declare function createStreamExtractor(agentType: string | undefined, onText: (delta: string) => void, onQuestion?: (questions: QuestionData[]) => void, onToolActivity?: (activity: ToolActivityData) => void, onTokenUsage?: (usage: TokenUsageData) => void, sessionId?: string): AgentStreamExtractor;
+//# sourceMappingURL=agent-profiles.d.ts.map