@indigoai-us/hq-cli 5.313.0 → 5.314.0

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

@@ -1,51 +0,0 @@
-/**
- * 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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,50 +0,0 @@
-/**
- * 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

@@ -1,170 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,153 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-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