@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/bot/runnable.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Can this Mac run the bot HQ has under this cloud record?
+ *
+ * One predicate, asked in every place that decides: `hq bot restore`, `hq bot
+ * adopt` and `hq bot list --remote`. They used to ask a weaker question than
+ * the runtime did — restore filtered on `computeMode` alone while
+ * `hq bot run`'s preflight compares BOTH `computeMode` and `botKind` against
+ * the bot.json it is about to run (`run.ts`, "is not a <kind> local bot") — so
+ * the two disagreed by construction.
+ *
+ * A real account showed what that cost: a company bot came back through
+ * `hq bot restore`, was counted as restored with `failed: 0` and `ok: true`,
+ * and then failed at every start, forever, with a LaunchAgent relaunching it
+ * at each login. Machine credentials, a state directory and a synced memory
+ * folder were created for a bot that could never run.
+ *
+ * The rule here is the runtime's rule, asked before anything is written: the
+ * bot must run on a computer (`computeMode: "local"`), and the kind this
+ * installation would run it as — from the settings the cloud kept for it — must
+ * be the kind the cloud record says it is. A company bot whose saved settings
+ * do not say "company" (the case above: no saved settings at all, so the adopt
+ * defaults to personal) is exactly the bot the runtime refuses, and it is now
+ * refused here instead, before it costs anything.
+ */
+import type { MyLocalBot } from "./api.js";
+/**
+ * Why a bot HQ lists for this account cannot run on this computer. Contract:
+ * the desktop app and the `--json` consumers switch on these values.
+ *
+ *   cloud-compute  the record runs in HQ Cloud, not on any computer
+ *   company-bot    it acts as a company member, and nothing here can run it
+ *                  as one — the runtime would refuse it at every start
+ *   kind-mismatch  anything else the runtime's identity preflight would refuse
+ */
+export type BotNotRunnableReason = "cloud-compute" | "company-bot" | "kind-mismatch";
+export interface RemoteBotRunnability {
+    runnable: boolean;
+    reason: BotNotRunnableReason | null;
+    /** One plain sentence for a person, naming no `agt_` uid. Null when runnable. */
+    message: string | null;
+}
+/** The record fields the decision reads — nothing else is consulted. */
+export type RemoteBotRunnabilityInput = Pick<MyLocalBot, "botKind" | "computeMode" | "localConfig">;
+/**
+ * The one answer restore, adopt and `list --remote` all use. `name` only
+ * shapes the sentence; the decision itself reads the record.
+ */
+export declare function remoteBotRunnability(bot: RemoteBotRunnabilityInput, name?: string): RemoteBotRunnability;
+/** True when this cloud record is a bot this computer can actually run. */
+export declare function isRemoteBotRunnableHere(bot: RemoteBotRunnabilityInput): boolean;
+//# sourceMappingURL=runnable.d.ts.map

package/dist/lib/bot/runnable.js

@@ -0,0 +1,65 @@
+/**
+ * Can this Mac run the bot HQ has under this cloud record?
+ *
+ * One predicate, asked in every place that decides: `hq bot restore`, `hq bot
+ * adopt` and `hq bot list --remote`. They used to ask a weaker question than
+ * the runtime did — restore filtered on `computeMode` alone while
+ * `hq bot run`'s preflight compares BOTH `computeMode` and `botKind` against
+ * the bot.json it is about to run (`run.ts`, "is not a <kind> local bot") — so
+ * the two disagreed by construction.
+ *
+ * A real account showed what that cost: a company bot came back through
+ * `hq bot restore`, was counted as restored with `failed: 0` and `ok: true`,
+ * and then failed at every start, forever, with a LaunchAgent relaunching it
+ * at each login. Machine credentials, a state directory and a synced memory
+ * folder were created for a bot that could never run.
+ *
+ * The rule here is the runtime's rule, asked before anything is written: the
+ * bot must run on a computer (`computeMode: "local"`), and the kind this
+ * installation would run it as — from the settings the cloud kept for it — must
+ * be the kind the cloud record says it is. A company bot whose saved settings
+ * do not say "company" (the case above: no saved settings at all, so the adopt
+ * defaults to personal) is exactly the bot the runtime refuses, and it is now
+ * refused here instead, before it costs anything.
+ */
+import { effectiveBotKind } from "./config.js";
+import { parseBotLocalConfig } from "./local-config.js";
+import { BOT_RESTORE_DEFAULTS } from "./local-config.js";
+/** The kind this installation would run the bot as, from the settings the cloud kept. */
+function kindHere(bot) {
+    const local = parseBotLocalConfig(bot.localConfig);
+    return effectiveBotKind({
+        kind: local?.kind ?? BOT_RESTORE_DEFAULTS.kind,
+        ...(local?.workerId ? { workerId: local.workerId } : {}),
+    });
+}
+function sentence(reason, name) {
+    const subject = name ? `"${name}"` : "That bot";
+    if (reason === "cloud-compute")
+        return `${subject} runs in the cloud, not on a computer, so there is nothing to bring back here.`;
+    if (reason === "company-bot") {
+        return `${subject} is a company bot: it runs in HQ Cloud for its company, not on this Mac, so there is nothing to bring back here.`;
+    }
+    return `${subject} is not set up as the kind of bot this computer can run, so there is nothing to bring back here.`;
+}
+/**
+ * The one answer restore, adopt and `list --remote` all use. `name` only
+ * shapes the sentence; the decision itself reads the record.
+ */
+export function remoteBotRunnability(bot, name) {
+    if ((bot.computeMode ?? "local") !== "local") {
+        return { runnable: false, reason: "cloud-compute", message: sentence("cloud-compute", name) };
+    }
+    const record = bot.botKind === "company" ? "company" : "personal";
+    const here = kindHere(bot);
+    if (record !== here) {
+        const reason = record === "company" ? "company-bot" : "kind-mismatch";
+        return { runnable: false, reason, message: sentence(reason, name) };
+    }
+    return { runnable: true, reason: null, message: null };
+}
+/** True when this cloud record is a bot this computer can actually run. */
+export function isRemoteBotRunnableHere(bot) {
+    return remoteBotRunnability(bot).runnable;
+}
+//# sourceMappingURL=runnable.js.map

package/dist/lib/bot/runtime/claude.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Claude Code headless adapter.
+ *
+ *   claude -p <prompt> --output-format stream-json --verbose --permission-mode <mode>
+ *   (<mode> = bypassPermissions by default — verified headless in HQ on
+ *   2026-09-11: `hq --version` ran without a prompt in 3.9 s; acceptEdits
+ *   when the bot's autoApprove is false; HQ_BOT_CLAUDE_PERMISSION_MODE
+ *   overrides both)
+ *          --append-system-prompt-file <file> --effort <level> [--model m]
+ *          [--add-dir <hqRoot>] [--add-dir <attachments dir>]
+ *          (--session-id <uuid> | --resume <uuid>)
+ *
+ * stdout is NDJSON (see messages-stream.ts): each finished assistant message
+ * is posted as progress while the turn runs; the closing `result` event
+ * carries the final text and session_id.
+ * Verified against Claude Code 2.1.258 on 2026-09-12 (fixtures/claude-stream.ndjson).
+ */
+import type { BotRuntime } from "./types.js";
+export declare const CLAUDE_PERMISSION_MODE_ENV = "HQ_BOT_CLAUDE_PERMISSION_MODE";
+export declare const DEFAULT_CLAUDE_PERMISSION_MODE = "bypassPermissions";
+export declare const GATED_CLAUDE_PERMISSION_MODE = "acceptEdits";
+/** No-prompt mode that works even where bypassPermissions is disabled by policy:
+ *  Claude Code's own classifier approves routine tool calls. */
+export declare const FALLBACK_CLAUDE_PERMISSION_MODE = "auto";
+/** Bots think at medium effort: chat replies stay quick without dropping
+ *  HQ's hooks or context. HQ_BOT_CLAUDE_EFFORT overrides it. */
+export declare const CLAUDE_EFFORT_ENV = "HQ_BOT_CLAUDE_EFFORT";
+export declare const DEFAULT_CLAUDE_EFFORT = "medium";
+export declare function claudeEffort(env?: NodeJS.ProcessEnv): string;
+export declare function claudePermissionMode(env?: NodeJS.ProcessEnv, autoApprove?: boolean, explicit?: string): string;
+/**
+ * True when Claude Code refused to start because bypassPermissions is turned
+ * off for this user (managed/enterprise settings: disableBypassPermissionsMode).
+ * Matched loosely on purpose — the wording has changed across releases.
+ */
+export declare function isClaudeBypassDisabled(text: string): boolean;
+/** True when `name` is an executable file in one of PATH's directories. */
+export declare function onPath(name: string, env: NodeJS.ProcessEnv): boolean;
+/**
+ * The Claude desktop app keeps its own Claude Code under
+ * ~/Library/Application Support/Claude/claude-code/<version>/. A Mac that only
+ * has the desktop app has no `claude` on PATH, yet the HQ app counts it as
+ * installed, so a bot must be able to use it too. Newest verified version wins
+ * (versions compare numerically; unverified or half-downloaded ones are
+ * skipped), matching the HQ desktop app's own lookup.
+ */
+export declare function bundledClaudeBin(homeDir?: string): string | null;
+export declare function resolveClaudeBinary(env: NodeJS.ProcessEnv, homeDir?: string, platform?: NodeJS.Platform, cwd?: string): string;
+export declare function createClaudeRuntime(env?: NodeJS.ProcessEnv): BotRuntime;
+//# sourceMappingURL=claude.d.ts.map

package/dist/lib/bot/runtime/claude.js

@@ -0,0 +1,170 @@
+/**
+ * Claude Code headless adapter.
+ *
+ *   claude -p <prompt> --output-format stream-json --verbose --permission-mode <mode>
+ *   (<mode> = bypassPermissions by default — verified headless in HQ on
+ *   2026-09-11: `hq --version` ran without a prompt in 3.9 s; acceptEdits
+ *   when the bot's autoApprove is false; HQ_BOT_CLAUDE_PERMISSION_MODE
+ *   overrides both)
+ *          --append-system-prompt-file <file> --effort <level> [--model m]
+ *          [--add-dir <hqRoot>] [--add-dir <attachments dir>]
+ *          (--session-id <uuid> | --resume <uuid>)
+ *
+ * stdout is NDJSON (see messages-stream.ts): each finished assistant message
+ * is posted as progress while the turn runs; the closing `result` event
+ * carries the final text and session_id.
+ * Verified against Claude Code 2.1.258 on 2026-09-12 (fixtures/claude-stream.ndjson).
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { messagesStreamEvents, messagesStreamFailure, messagesStreamResult } from "./messages-stream.js";
+import { resolveRuntimeBinary } from "./windows.js";
+export const CLAUDE_PERMISSION_MODE_ENV = "HQ_BOT_CLAUDE_PERMISSION_MODE";
+export const DEFAULT_CLAUDE_PERMISSION_MODE = "bypassPermissions";
+export const GATED_CLAUDE_PERMISSION_MODE = "acceptEdits";
+/** No-prompt mode that works even where bypassPermissions is disabled by policy:
+ *  Claude Code's own classifier approves routine tool calls. */
+export const FALLBACK_CLAUDE_PERMISSION_MODE = "auto";
+/** Bots think at medium effort: chat replies stay quick without dropping
+ *  HQ's hooks or context. HQ_BOT_CLAUDE_EFFORT overrides it. */
+export const CLAUDE_EFFORT_ENV = "HQ_BOT_CLAUDE_EFFORT";
+export const DEFAULT_CLAUDE_EFFORT = "medium";
+export function claudeEffort(env = process.env) {
+    return env[CLAUDE_EFFORT_ENV]?.trim() || DEFAULT_CLAUDE_EFFORT;
+}
+export function claudePermissionMode(env = process.env, autoApprove = true, explicit) {
+    const raw = env[CLAUDE_PERMISSION_MODE_ENV]?.trim();
+    if (raw)
+        return raw;
+    if (explicit?.trim())
+        return explicit.trim();
+    return autoApprove ? DEFAULT_CLAUDE_PERMISSION_MODE : GATED_CLAUDE_PERMISSION_MODE;
+}
+/**
+ * True when Claude Code refused to start because bypassPermissions is turned
+ * off for this user (managed/enterprise settings: disableBypassPermissionsMode).
+ * Matched loosely on purpose — the wording has changed across releases.
+ */
+export function isClaudeBypassDisabled(text) {
+    const t = text.toLowerCase();
+    if (!/bypass ?permissions|disablebypasspermissionsmode|skip.permissions/.test(t))
+        return false;
+    return /disabled|not (allowed|permitted|enabled|available)|policy|managed|forbidden|cannot be used/.test(t);
+}
+/** True when `name` is an executable file in one of PATH's directories. */
+export function onPath(name, env) {
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        try {
+            fs.accessSync(path.join(dir, name), fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            /* keep looking */
+        }
+    }
+    return false;
+}
+/**
+ * The Claude desktop app keeps its own Claude Code under
+ * ~/Library/Application Support/Claude/claude-code/<version>/. A Mac that only
+ * has the desktop app has no `claude` on PATH, yet the HQ app counts it as
+ * installed, so a bot must be able to use it too. Newest verified version wins
+ * (versions compare numerically; unverified or half-downloaded ones are
+ * skipped), matching the HQ desktop app's own lookup.
+ */
+export function bundledClaudeBin(homeDir = os.homedir()) {
+    const managed = path.join(homeDir, "Library", "Application Support", "Claude", "claude-code");
+    let names;
+    try {
+        names = fs.readdirSync(managed);
+    }
+    catch {
+        return null;
+    }
+    const candidates = [];
+    for (const name of names) {
+        if (!/^\d+(\.\d+)*$/.test(name))
+            continue;
+        const dir = path.join(managed, name);
+        const bin = path.join(dir, "claude.app", "Contents", "MacOS", "claude");
+        if (!fs.existsSync(path.join(dir, ".verified")) || !fs.existsSync(bin))
+            continue;
+        candidates.push({ version: name.split(".").map(Number), bin });
+    }
+    candidates.sort((a, b) => {
+        for (let i = 0; i < Math.max(a.version.length, b.version.length); i++) {
+            const d = (a.version[i] ?? 0) - (b.version[i] ?? 0);
+            if (d !== 0)
+                return d;
+        }
+        return 0;
+    });
+    return candidates.at(-1)?.bin ?? null;
+}
+export function resolveClaudeBinary(env, homeDir, platform = process.platform, cwd = process.cwd()) {
+    if (platform === "win32")
+        return resolveRuntimeBinary("claude", env, platform, fs.existsSync, cwd);
+    if (onPath("claude", env))
+        return "claude";
+    return bundledClaudeBin(homeDir ?? env.HOME ?? os.homedir()) ?? "claude";
+}
+export function createClaudeRuntime(env = process.env) {
+    return {
+        id: "claude",
+        binary: "claude",
+        resolveBinary: (turnEnv, cwd, platform) => resolveClaudeBinary(turnEnv, undefined, platform ?? process.platform, cwd),
+        buildArgs(input, scratch) {
+            const usesWindowsStdin = input.platform === "win32";
+            const args = [
+                "-p",
+                ...(usesWindowsStdin ? [] : [input.prompt]),
+                "--output-format",
+                "stream-json",
+                ...(usesWindowsStdin ? ["--input-format", "stream-json"] : []),
+                "--verbose",
+                "--permission-mode",
+                claudePermissionMode(env, input.autoApprove !== false, input.permissionMode),
+                "--append-system-prompt-file",
+                input.systemPromptFile,
+                "--effort",
+                input.effort?.trim() || claudeEffort(env),
+            ];
+            // Keep the HQ tree writable even if a caller runs the turn elsewhere.
+            if (input.hqRoot && input.hqRoot !== input.cwd)
+                args.push("--add-dir", input.hqRoot);
+            // Downloaded attachments live in the bot's own dir, outside the HQ tree.
+            for (const d of input.readDirs ?? []) {
+                if (d && d !== input.cwd && d !== input.hqRoot)
+                    args.push("--add-dir", d);
+            }
+            if (input.model)
+                args.push("--model", input.model);
+            if (input.sessionId)
+                args.push("--resume", input.sessionId);
+            else
+                args.push("--session-id", scratch.newSessionId);
+            return args;
+        },
+        stdinInput(input) {
+            return input.platform === "win32"
+                ? JSON.stringify({
+                    type: "user",
+                    message: { role: "user", content: [{ type: "text", text: input.prompt }] },
+                }) + "\n"
+                : undefined;
+        },
+        parseOutput(stdout) {
+            return messagesStreamResult(stdout, "claude");
+        },
+        parseStreamLine(line) {
+            return messagesStreamEvents(line);
+        },
+        failureReason(stdout) {
+            return messagesStreamFailure(stdout);
+        },
+    };
+}
+//# sourceMappingURL=claude.js.map

package/dist/lib/bot/runtime/codex.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Codex CLI headless adapter.
+ *
+ *   codex exec --json --skip-git-repo-check -C <cwd> -o <file> [-m m] <prompt>
+ *   codex exec resume --json --skip-git-repo-check -o <file> [-m m] <sid> <prompt>
+ *
+ * stdout is JSONL: {"type":"thread.started","thread_id"}, then
+ * {"type":"item.completed","item":{"type":"agent_message","text"}} …
+ * The final agent message is also written to `-o <file>` (authoritative).
+ * Each `agent_message` item is posted as progress while the turn runs.
+ * The system prompt rides as a preamble in the prompt (codex exec has no
+ * system-prompt flag); it is small and stable across turns.
+ * Verified against Codex CLI on 2026-09-10 (event names; the model itself
+ * cannot run under this machine's account).
+ */
+import { type BotRuntime, type RuntimeStreamEvent, type RuntimeTurnInput } from "./types.js";
+/** Progress events in one codex JSONL line: finished agent messages and tool starts. */
+export declare function codexStreamEvents(line: string): RuntimeStreamEvent[];
+export declare function codexPrompt(input: RuntimeTurnInput): string;
+/**
+ * Pull the real failure out of codex's JSONL. `turn.failed` / `error` events
+ * carry the API error, sometimes as a JSON string
+ * ({"error":{"message":"You've hit your usage limit…"}}); unwrap it. Setup
+ * warnings (`item.completed` with `item.type === "error"`) are not failures.
+ */
+export declare function codexFailureReason(stdout: string): string | undefined;
+export declare function createCodexRuntime(): BotRuntime;
+//# sourceMappingURL=codex.d.ts.map

package/dist/lib/bot/runtime/codex.js

@@ -0,0 +1,153 @@
+/**
+ * Codex CLI headless adapter.
+ *
+ *   codex exec --json --skip-git-repo-check -C <cwd> -o <file> [-m m] <prompt>
+ *   codex exec resume --json --skip-git-repo-check -o <file> [-m m] <sid> <prompt>
+ *
+ * stdout is JSONL: {"type":"thread.started","thread_id"}, then
+ * {"type":"item.completed","item":{"type":"agent_message","text"}} …
+ * The final agent message is also written to `-o <file>` (authoritative).
+ * Each `agent_message` item is posted as progress while the turn runs.
+ * The system prompt rides as a preamble in the prompt (codex exec has no
+ * system-prompt flag); it is small and stable across turns.
+ * Verified against Codex CLI on 2026-09-10 (event names; the model itself
+ * cannot run under this machine's account).
+ */
+import { parseJsonLine, RuntimeError } from "./types.js";
+import { resolveRuntimeBinary } from "./windows.js";
+/** Progress events in one codex JSONL line: finished agent messages and tool starts. */
+export function codexStreamEvents(line) {
+    const ev = parseJsonLine(line);
+    if (!ev || !ev.item || typeof ev.item !== "object")
+        return [];
+    const item = ev.item;
+    if (ev.type === "item.completed" && item.type === "agent_message" && typeof item.text === "string" && item.text.trim()) {
+        return [{ kind: "message", text: item.text.trim() }];
+    }
+    if (ev.type === "item.started" && typeof item.type === "string" && /command|tool|mcp/.test(item.type)) {
+        return [{ kind: "tool", name: item.type }];
+    }
+    return [];
+}
+export function codexPrompt(input) {
+    if (input.sessionId)
+        return input.prompt;
+    return `${input.systemPrompt}\n\n---\n\nMessage from your owner:\n\n${input.prompt}`;
+}
+/**
+ * Pull the real failure out of codex's JSONL. `turn.failed` / `error` events
+ * carry the API error, sometimes as a JSON string
+ * ({"error":{"message":"You've hit your usage limit…"}}); unwrap it. Setup
+ * warnings (`item.completed` with `item.type === "error"`) are not failures.
+ */
+export function codexFailureReason(stdout) {
+    let reason;
+    for (const line of stdout.split("\n")) {
+        const t = line.trim();
+        if (!t.startsWith("{"))
+            continue;
+        let ev;
+        try {
+            ev = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (ev.type !== "turn.failed" && ev.type !== "error")
+            continue;
+        const err = ev.error && typeof ev.error === "object" ? ev.error : undefined;
+        const raw = typeof err?.message === "string" ? err.message : typeof ev.message === "string" ? ev.message : undefined;
+        if (raw)
+            reason = unwrapApiError(raw);
+    }
+    return reason?.trim() || undefined;
+}
+function unwrapApiError(raw) {
+    const t = raw.trim();
+    if (!t.startsWith("{"))
+        return t;
+    try {
+        const obj = JSON.parse(t);
+        const inner = obj.error && typeof obj.error === "object" ? obj.error : undefined;
+        if (typeof inner?.message === "string")
+            return inner.message;
+        if (typeof obj.message === "string")
+            return obj.message;
+    }
+    catch {
+        /* not JSON */
+    }
+    return t;
+}
+export function createCodexRuntime() {
+    return {
+        id: "codex",
+        binary: "codex",
+        resolveBinary: (env, cwd, platform) => resolveRuntimeBinary("codex", env, platform ?? process.platform, undefined, cwd),
+        buildArgs(input, scratch) {
+            const promptArg = input.platform === "win32" ? "-" : codexPrompt(input);
+            const common = ["--json", "--skip-git-repo-check", "-o", scratch.outputFile];
+            if (input.autoApprove !== false) {
+                // Headless: nobody can answer an approval prompt, so a gated command
+                // would just fail. The bot runs with the owner's permissions by design.
+                common.push("--dangerously-bypass-approvals-and-sandbox");
+            }
+            else if (input.hqRoot && input.hqRoot !== input.cwd) {
+                common.push("-c", `sandbox_workspace_write.writable_roots=[${JSON.stringify(input.hqRoot)}]`);
+            }
+            if (input.model)
+                common.push("-m", input.model);
+            common.push("-c", `model_reasoning_effort=${JSON.stringify(input.effort?.trim() || "medium")}`);
+            if (input.sessionId) {
+                return ["exec", "resume", ...common, input.sessionId, promptArg];
+            }
+            return ["exec", ...common, "-C", input.cwd, promptArg];
+        },
+        stdinInput(input) {
+            return input.platform === "win32" ? codexPrompt(input) : undefined;
+        },
+        parseOutput(stdout, extra) {
+            let sessionId;
+            let lastMessage;
+            let errorMessage;
+            for (const line of stdout.split("\n")) {
+                const t = line.trim();
+                if (!t.startsWith("{"))
+                    continue;
+                let ev;
+                try {
+                    ev = JSON.parse(t);
+                }
+                catch {
+                    continue;
+                }
+                if (ev.type === "thread.started" && typeof ev.thread_id === "string")
+                    sessionId = ev.thread_id;
+                if (ev.type === "item.completed" && ev.item && typeof ev.item === "object") {
+                    const item = ev.item;
+                    if (item.type === "agent_message" && typeof item.text === "string")
+                        lastMessage = item.text;
+                    if (item.type === "error" && typeof item.message === "string")
+                        errorMessage = item.message;
+                }
+                if (ev.type === "turn.failed" || ev.type === "error") {
+                    const msg = typeof ev.message === "string" ? ev.message : JSON.stringify(ev).slice(0, 200);
+                    errorMessage = msg;
+                }
+            }
+            const fromFile = extra.outputFileText?.trim();
+            const text = (fromFile || lastMessage || "").trim();
+            if (!text) {
+                throw new RuntimeError(`codex produced no reply${errorMessage ? `: ${errorMessage.slice(0, 200)}` : ""}`, (errorMessage ?? stdout.slice(-400)).slice(0, 400), null);
+            }
+            return { text, sessionId };
+        },
+        parseStreamLine(line) {
+            return codexStreamEvents(line);
+        },
+        failureReason(stdout) {
+            return codexFailureReason(stdout);
+        },
+    };
+}
+//# sourceMappingURL=codex.js.map

package/dist/lib/bot/runtime/grok-acp.d.ts

@@ -0,0 +1,40 @@
+export interface GrokAcpClientOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    prompt: string;
+    sessionId?: string;
+    send: (message: Record<string, unknown>) => void;
+    onText: (line: string) => void;
+    onComplete: (sessionId: string, text: string) => void;
+    onFailure: (message: string) => void;
+}
+/** A minimal ACP client for Grok's documented stdio runtime. */
+export declare class GrokAcpClient {
+    private readonly options;
+    private nextId;
+    private readonly pending;
+    private readonly terminals;
+    private sessionId;
+    private text;
+    private finished;
+    constructor(options: GrokAcpClientOptions);
+    start(): void;
+    receive(line: string): void;
+    private request;
+    private notify;
+    private authenticate;
+    private openSession;
+    private prompt;
+    private receiveUpdate;
+    private complete;
+    private fail;
+    private receiveRequest;
+    private handleClientRequest;
+    private createTerminal;
+    private getTerminal;
+    private terminalOutput;
+    private waitForTerminal;
+    private killTerminal;
+    private releaseTerminal;
+}
+//# sourceMappingURL=grok-acp.d.ts.map