@spinabot/brigade 0.1.0

package/dist/cli/config-cmd.js

@@ -0,0 +1,132 @@
+/**
+ * `brigade config` — read & write `~/.brigade/config.json`.
+ *
+ *   brigade config list                — print all keys
+ *   brigade config get <key>           — print one value
+ *   brigade config set <key> <value>   — set one value (merges, doesn't overwrite)
+ *   brigade config unset <key>         — remove one key
+ *
+ * Keys are dotted paths but the schema is flat in v1, so the only valid keys
+ * are top-level: defaultProvider, defaultModelId, thinkingLevel,
+ * fallbackProvider, fallbackModelId, installedAt. Unknown keys are rejected
+ * to keep the file from accumulating typos that silently do nothing.
+ */
+import process from "node:process";
+import chalk from "chalk";
+import { loadConfig, saveConfig } from "../core/config.js";
+/** Whitelist of known keys. Keep in sync with BrigadeConfig in core/config.ts. */
+const KNOWN_KEYS = [
+    "defaultProvider",
+    "defaultModelId",
+    "thinkingLevel",
+    "fallbackProvider",
+    "fallbackModelId",
+    "installedAt",
+];
+/**
+ * Dispatch one config subcommand. Splits parsing from I/O so tests can
+ * exercise the same logic without spawning a subprocess.
+ */
+export async function runConfigCommand(args) {
+    const sub = args[0];
+    switch (sub) {
+        case "list":
+        case undefined:
+            return listConfig();
+        case "get":
+            return getConfig(args[1]);
+        case "set":
+            return setConfig(args[1], args[2]);
+        case "unset":
+            return unsetConfig(args[1]);
+        default:
+            process.stderr.write(chalk.red(`unknown config subcommand: ${sub}\n`) +
+                chalk.dim("usage: brigade config [list|get <key>|set <key> <value>|unset <key>]\n"));
+            return { exitCode: 2 };
+    }
+}
+async function listConfig() {
+    const cfg = await loadConfig();
+    if (Object.keys(cfg).length === 0) {
+        process.stderr.write(chalk.dim("(empty — run `brigade onboard` to set up)\n"));
+        return { exitCode: 0 };
+    }
+    for (const key of KNOWN_KEYS) {
+        const v = cfg[key];
+        if (v === undefined || v === null)
+            continue;
+        process.stdout.write(`${key}=${String(v)}\n`);
+    }
+    return { exitCode: 0 };
+}
+async function getConfig(key) {
+    if (!key) {
+        process.stderr.write(chalk.red("usage: brigade config get <key>\n"));
+        return { exitCode: 2 };
+    }
+    if (!KNOWN_KEYS.includes(key)) {
+        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
+            chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
+        return { exitCode: 2 };
+    }
+    const cfg = await loadConfig();
+    const v = cfg[key];
+    if (v === undefined) {
+        // Empty stdout, exit 1 — matches `git config` semantics for missing keys.
+        return { exitCode: 1 };
+    }
+    process.stdout.write(`${String(v)}\n`);
+    return { exitCode: 0 };
+}
+async function setConfig(key, value) {
+    if (!key || value === undefined) {
+        process.stderr.write(chalk.red("usage: brigade config set <key> <value>\n"));
+        return { exitCode: 2 };
+    }
+    if (!KNOWN_KEYS.includes(key)) {
+        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
+            chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
+        return { exitCode: 2 };
+    }
+    // saveConfig MERGES, so passing a single key preserves the rest. Cast through
+    // Partial<BrigadeConfig> so unknown extra keys can't sneak in via this path.
+    const partial = { [key]: value };
+    await saveConfig(partial);
+    process.stderr.write(chalk.green(`set ${key}\n`));
+    return { exitCode: 0 };
+}
+async function unsetConfig(key) {
+    if (!key) {
+        process.stderr.write(chalk.red("usage: brigade config unset <key>\n"));
+        return { exitCode: 2 };
+    }
+    if (!KNOWN_KEYS.includes(key)) {
+        process.stderr.write(chalk.red(`unknown key: ${key}\n`) +
+            chalk.dim(`valid keys: ${KNOWN_KEYS.join(", ")}\n`));
+        return { exitCode: 2 };
+    }
+    const existing = await loadConfig();
+    if (!(key in existing)) {
+        // Nothing to do, but report it so scripts can detect.
+        process.stderr.write(chalk.dim(`${key} was not set\n`));
+        return { exitCode: 0 };
+    }
+    // saveConfig only merges set fields — to delete one we have to write the
+    // remainder explicitly. Read-modify-write through the same merge path so
+    // we keep the installedAt-preservation behavior.
+    const remainder = { ...existing };
+    delete remainder[key];
+    // Force overwrite by going through fs directly here would skip the merge
+    // guard. Easier path: write the whole remainder via saveConfig — since
+    // saveConfig merges, this replaces all fields with the post-delete values,
+    // AND any field already absent stays absent. The only edge: installedAt
+    // is preserved by saveConfig's defaulting behavior.
+    const fsP = await import("node:fs/promises");
+    const path = await import("node:path");
+    const os = await import("node:os");
+    const file = path.join(os.homedir(), ".brigade", "config.json");
+    await fsP.writeFile(file, JSON.stringify(remainder, null, 2), "utf8");
+    process.stderr.write(chalk.green(`unset ${key}\n`));
+    return { exitCode: 0 };
+}
+//# sourceMappingURL=config-cmd.js.map

package/dist/cli/connect-cmd.js

@@ -0,0 +1,447 @@
+/**
+ * `brigade connect` — TUI that talks to a running `brigade gateway`.
+ *
+ * This is the thin client. The gateway owns the Pi session, runs the full
+ * 6-layer wrapper composition, and broadcasts every Pi event back to us.
+ * Our job is only to render and to forward the user's input as typed
+ * requests over the WebSocket.
+ *
+ * Feature parity with `brigade chat` for the common path (send a message,
+ * stream the reply, see tool calls, abort with Ctrl+C, switch model, set
+ * thinking level, compact, exit). Inline `/provider` onboarding is NOT
+ * available from connect mode in v1 — onboarding writes to the gateway's
+ * filesystem and is out-of-band; the user runs `brigade onboard` against
+ * the gateway machine instead.
+ */
+import process from "node:process";
+import { ProcessTerminal, TUI, Text, Markdown, CancellableLoader, Editor } from "@mariozechner/pi-tui";
+import chalk from "chalk";
+import { renderBrandHeader } from "../ui/brand.js";
+import { brand, editorTheme, markdownTheme } from "../ui/theme.js";
+import { BrigadeClient } from "../tui/client.js";
+/**
+ * Boot the connect TUI. Establishes the WebSocket connection FIRST so the
+ * user gets a clear "couldn't reach gateway" error instead of a blank chat.
+ */
+export async function runConnectCommand(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? 7777;
+    const url = `ws://${host}:${port}`;
+    const tui = new TUI(new ProcessTerminal());
+    tui.start();
+    // Wire SIGINT BEFORE the connect attempt so Ctrl+C during a slow connect
+    // exits cleanly instead of hanging on the open promise. Re-arm via
+    // process.once after each turn-abort so handlers never stack across
+    // re-invocations within the same process.
+    let chatHandle = null;
+    const onSigint = () => {
+        if (chatHandle) {
+            const wasRunning = chatHandle.abort();
+            if (!wasRunning) {
+                void chatHandle.close().then(() => {
+                    tui.stop();
+                    process.exit(0);
+                });
+                return;
+            }
+            process.once("SIGINT", onSigint); // re-arm for the next Ctrl+C
+            return;
+        }
+        tui.stop();
+        process.exit(130);
+    };
+    process.once("SIGINT", onSigint);
+    const client = new BrigadeClient({
+        url,
+        requestTimeoutMs: opts.requestTimeoutMs ?? 60_000,
+    });
+    try {
+        await client.connect();
+    }
+    catch (err) {
+        tui.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        const isRefused = /ECONNREFUSED|connect.*refused/i.test(msg);
+        const isTimeout = /ETIMEDOUT|timed?\s*out/i.test(msg);
+        console.error(chalk.red(`✗ Couldn't reach the Brigade gateway at ${url}: ${msg}`));
+        // Differentiate the most common failure modes so users don't waste
+        // time debugging the wrong cause.
+        if (isRefused) {
+            console.error(chalk.dim(`  Likely cause: no gateway is running on port ${port}.`));
+            console.error(chalk.dim(`  Either start one:           brigade gateway --port ${port}`));
+            console.error(chalk.dim(`  Or, if it's on another port: brigade connect --port <that-port>`));
+        }
+        else if (isTimeout) {
+            console.error(chalk.dim(`  Likely cause: gateway is reachable but slow to handshake.`));
+            console.error(chalk.dim(`  Check that ${host} resolves and the port isn't blocked by a firewall.`));
+        }
+        else {
+            console.error(chalk.dim(`  Start the gateway first:        brigade gateway --port ${port}`));
+            console.error(chalk.dim(`  Or check the host/port flags:   brigade connect --host ${host} --port ${port}`));
+        }
+        process.exit(1);
+    }
+    chatHandle = await wireConnectUi(tui, client);
+    return chatHandle;
+}
+/**
+ * Build the live chat UI on top of an already-connected client. Split out so
+ * tests can inject a pre-connected client without going through CLI flag
+ * parsing or process.exit.
+ */
+export async function wireConnectUi(tui, client) {
+    renderBrandHeader(tui);
+    const header = new Text("", 0, 0);
+    tui.addChild(header);
+    const divider = new Text(brand.dim("─".repeat(80)), 0, 0);
+    tui.addChild(divider);
+    // Cumulative usage — accumulated from state snapshots so a reconnect picks
+    // up where we left off instead of zeroing the totals on the user's screen.
+    let lastSnapshot = null;
+    let isAgentRunning = false;
+    let activeAssistant = null;
+    let activeLoader = null;
+    const pendingTools = new Map();
+    const updateHeader = (extra) => {
+        const provider = lastSnapshot?.provider ?? "?";
+        const modelId = lastSnapshot?.modelId ?? "?";
+        const tokens = lastSnapshot && (lastSnapshot.totalTokensIn + lastSnapshot.totalTokensOut) > 0
+            ? ` · ${(lastSnapshot.totalTokensIn + lastSnapshot.totalTokensOut).toLocaleString()} tok`
+            : "";
+        const cost = lastSnapshot && lastSnapshot.totalCostUsd > 0
+            ? ` · $${lastSnapshot.totalCostUsd.toFixed(4)}`
+            : "";
+        const usage = lastSnapshot?.contextUsagePercent ?? null;
+        let usageStr = "";
+        if (usage != null && usage >= 50) {
+            const pct = Math.round(usage);
+            const colored = pct >= 75 ? brand.amber(`${pct}% ctx`) : brand.dim(`${pct}% ctx`);
+            usageStr = ` · ${colored}`;
+        }
+        const tail = extra ? ` · ${extra}` : "";
+        const dot = isAgentRunning ? brand.amber("●") : brand.dim("○");
+        header.setText(`  ${dot} ${brand.white("Brigade")}  ${brand.dim(`${provider} · ${modelId}${tokens}${cost}`)}${usageStr}${brand.dim(tail)}`);
+    };
+    updateHeader();
+    const editor = new Editor(tui, editorTheme);
+    tui.addChild(editor);
+    tui.setFocus(editor);
+    tui.addChild(new Text(brand.dim("  Enter to send · Ctrl+C abort · Ctrl+D quit · /model /thinking /compact /help"), 0, 0));
+    const insertBeforeEditor = (component) => {
+        const children = tui.children;
+        const editorIdx = children.indexOf(editor);
+        if (editorIdx < 0) {
+            tui.addChild(component);
+        }
+        else {
+            children.splice(editorIdx, 0, component);
+            tui.requestRender();
+        }
+    };
+    const removeChild = (component) => {
+        try {
+            tui.removeChild(component);
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    const extractAssistantText = (message) => {
+        if (!message || !Array.isArray(message.content))
+            return "";
+        return message.content
+            .filter((b) => b && b.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("");
+    };
+    // State snapshots from the gateway — every mutation pushes one.
+    client.on("state", (snap) => {
+        lastSnapshot = snap;
+        isAgentRunning = snap.isAgentRunning;
+        updateHeader();
+    });
+    // Server-side warnings/info (e.g. "primary failed, trying fallback") — the
+    // gateway emits these via the wrapper-chain callbacks. Mirror to the TUI
+    // so the user sees the same context they would in `brigade chat`.
+    client.on("log", (entry) => {
+        const tone = entry.level === "error"
+            ? brand.error(`✗ ${entry.message}`)
+            : entry.level === "warn"
+                ? brand.dim(`⚠ ${entry.message}`)
+                : brand.dim(`↻ ${entry.message}`);
+        insertBeforeEditor(new Text(`  ${tone}`, 0, 0));
+    });
+    // Pi events are forwarded as `{ event: <pi event> }`. Same render logic
+    // as src/ui/chat.ts but stripped of in-process state mutations.
+    client.on("pi", ({ event }) => {
+        switch (event?.type) {
+            case "agent_start": {
+                isAgentRunning = true;
+                editor.disableSubmit = true;
+                updateHeader("thinking…");
+                activeLoader = new CancellableLoader(tui, (s) => brand.amber(s), (s) => brand.dim(s), "thinking");
+                insertBeforeEditor(activeLoader);
+                break;
+            }
+            case "message_update":
+            case "message_end": {
+                const msg = event.message;
+                if (!msg || msg.role !== "assistant")
+                    break;
+                const text = extractAssistantText(msg);
+                if (!text)
+                    break;
+                if (activeLoader) {
+                    removeChild(activeLoader);
+                    activeLoader = null;
+                }
+                if (!activeAssistant) {
+                    activeAssistant = new Markdown(`${brand.agent("brigade")}  ${text}`, 1, 0, markdownTheme);
+                    insertBeforeEditor(activeAssistant);
+                }
+                else {
+                    activeAssistant.setText(`${brand.agent("brigade")}  ${text}`);
+                    tui.requestRender();
+                }
+                break;
+            }
+            case "tool_execution_start": {
+                if (activeLoader) {
+                    removeChild(activeLoader);
+                    activeLoader = null;
+                }
+                const indicator = new Text(`  ${brand.tool("⚡")} ${brand.tool(event.toolName)}`, 0, 0);
+                pendingTools.set(event.toolCallId, indicator);
+                insertBeforeEditor(indicator);
+                break;
+            }
+            case "tool_execution_end": {
+                const indicator = pendingTools.get(event.toolCallId);
+                if (indicator) {
+                    const mark = event.isError ? brand.error("✗") : brand.tool("✓");
+                    indicator.setText(`  ${mark} ${brand.tool(event.toolName)}`);
+                    tui.requestRender();
+                    pendingTools.delete(event.toolCallId);
+                }
+                break;
+            }
+            case "turn_end": {
+                // Intentionally a no-op. Token totals (totalTokensIn / Out /
+                // CostUsd) are accumulated SERVER-SIDE in server.ts:156-163
+                // on every turn_end, then pushed to us via the very next
+                // `state` event at server.ts:165. Our `state` handler above
+                // stores that into `lastSnapshot` and calls updateHeader(),
+                // which reads the totals from `lastSnapshot`. Doing the
+                // accumulation HERE too would double-count.
+                //
+                // Kept as a labelled case so any future connect-only logic
+                // (e.g. per-turn flash UI, telemetry hook) has a place to
+                // land — and so the next audit doesn't flag this as missing.
+                break;
+            }
+            case "compaction_start": {
+                const pct = lastSnapshot?.contextUsagePercent != null
+                    ? `${Math.round(lastSnapshot.contextUsagePercent)}%`
+                    : "high";
+                insertBeforeEditor(new Text(`  ${brand.dim(`⚡ compacting context (was ${pct})…`)}`, 0, 0));
+                break;
+            }
+            case "compaction_end": {
+                if (event.aborted) {
+                    insertBeforeEditor(new Text(`  ${brand.dim("compaction aborted")}`, 0, 0));
+                }
+                else {
+                    // Pi's getContextUsage returns null right after compaction by
+                    // design — token estimates need a fresh LLM response. Show
+                    // that explicitly via the snapshot's percent (server pushes
+                    // a fresh snapshot post-compact).
+                    const after = lastSnapshot?.contextUsagePercent;
+                    const afterStr = after != null
+                        ? `usage now ${Math.round(after)}%`
+                        : "usage refreshes after your next message";
+                    insertBeforeEditor(new Text(`  ${brand.amber("✓")} ${brand.dim(`compacted · ${afterStr}`)}`, 0, 0));
+                }
+                break;
+            }
+            case "auto_retry_start": {
+                // Pi auto-retries transient provider errors (rate limit, 5xx,
+                // connection drop). Tell the user it's happening — without this,
+                // a slow retry looks like the connection is just hanging.
+                const attempt = event.attempt ?? 1;
+                const max = event.maxAttempts ?? 1;
+                const waitS = Math.round((event.delayMs ?? 0) / 100) / 10;
+                insertBeforeEditor(new Text(`  ${brand.dim(`↻ retrying (attempt ${attempt}/${max}, waiting ${waitS}s)…`)}`, 0, 0));
+                break;
+            }
+            case "auto_retry_end": {
+                if (event.success === false) {
+                    insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(`gave up after ${event.attempt} attempts`)}`, 0, 0));
+                }
+                break;
+            }
+            case "agent_end": {
+                isAgentRunning = false;
+                editor.disableSubmit = false;
+                activeAssistant = null;
+                if (activeLoader) {
+                    removeChild(activeLoader);
+                    activeLoader = null;
+                }
+                updateHeader();
+                break;
+            }
+        }
+    });
+    // Reconnect notifications — let the user know what just happened so a
+    // dropped/restored gateway doesn't look like phantom output.
+    client.on("reconnected", () => {
+        insertBeforeEditor(new Text(`  ${brand.dim("↻ reconnected to gateway")}`, 0, 0));
+    });
+    // Slash command + send wiring.
+    editor.onSubmit = async (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        // Local commands first — never reach the gateway.
+        if (trimmed === "/exit" || trimmed === "/quit") {
+            client.close();
+            tui.stop();
+            process.exit(0);
+        }
+        if (trimmed === "/help") {
+            editor.setText("");
+            insertBeforeEditor(new Markdown(`${brand.dim("commands")}\n` +
+                `- ${chalk.bold("/exit")} or ${chalk.bold("/quit")} — disconnect & quit\n` +
+                `- ${chalk.bold("/help")} — this list\n` +
+                `- ${chalk.bold("/model <id>")} — switch to a configured model on the gateway\n` +
+                `- ${chalk.bold("/thinking <level>")} — set reasoning effort (off|minimal|low|medium|high|xhigh)\n` +
+                `- ${chalk.bold("/compact")} — summarize older turns to free up context\n` +
+                `- ${chalk.bold("Ctrl+C")} — abort the current turn\n` +
+                `- ${chalk.bold("Ctrl+D")} — quit\n\n` +
+                brand.dim("To add a new provider, run `brigade onboard` on the gateway machine."), 1, 0, markdownTheme));
+            return;
+        }
+        // Mid-turn submit → STEER. The gateway has the same Pi semantics; queueing
+        // the message lets the model see it on the next iteration without abort.
+        if (isAgentRunning) {
+            editor.setText("");
+            try {
+                await client.request("steer", { text: trimmed });
+                insertBeforeEditor(new Markdown(`${brand.user("you")}  ${trimmed}`, 1, 0, markdownTheme));
+                insertBeforeEditor(new Text(`  ${brand.dim("↳ queued — the model will see this on its next turn")}`, 0, 0));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(msg)}`, 0, 0));
+            }
+            return;
+        }
+        // /compact — same long-run rationale as `prompt` above; compaction
+        // can take a while on a big transcript, beyond the default 60s.
+        if (trimmed === "/compact") {
+            editor.setText("");
+            insertBeforeEditor(new Text(`  ${brand.dim("Compacting…")}`, 0, 0));
+            try {
+                await client.request("compact", undefined, { timeoutMs: 0 });
+                insertBeforeEditor(new Text(`  ${brand.amber("✓")} ${brand.dim("Compacted")}`, 0, 0));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(`Compaction failed: ${msg}`)}`, 0, 0));
+            }
+            return;
+        }
+        // /model <id>  — switch by id (the gateway resolves provider via its registry)
+        if (trimmed === "/model" || trimmed.startsWith("/model ")) {
+            editor.setText("");
+            let models;
+            try {
+                models = await client.request("list-models");
+            }
+            catch (err) {
+                insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(err instanceof Error ? err.message : String(err))}`, 0, 0));
+                return;
+            }
+            const arg = trimmed === "/model" ? "" : trimmed.slice("/model ".length).trim();
+            if (!arg) {
+                const list = models
+                    .map((m) => `  ${brand.dim(m.provider)}  ${brand.white(m.id)}`)
+                    .join("\n");
+                insertBeforeEditor(new Markdown(`${brand.dim("configured models on the gateway:")}\n${list}\n\n${brand.dim("usage: /model <id>")}`, 1, 0, markdownTheme));
+                return;
+            }
+            // Prefer current provider on tie.
+            const currentProvider = lastSnapshot?.provider;
+            const matches = models.filter((m) => m.id === arg);
+            const target = matches.find((m) => m.provider === currentProvider) ?? matches[0];
+            if (!target) {
+                insertBeforeEditor(new Text(`  ${brand.error(`✗ no model with id "${arg}" on the gateway.`)}`, 0, 0));
+                return;
+            }
+            try {
+                await client.request("set-model", { provider: target.provider, modelId: target.id });
+                insertBeforeEditor(new Text(`  ${brand.amber("✓")} ${brand.dim("switched to")} ${brand.white(`${target.provider} · ${target.id}`)}`, 0, 0));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(msg)}`, 0, 0));
+            }
+            return;
+        }
+        // /thinking [level]
+        if (trimmed === "/thinking" || trimmed.startsWith("/thinking ")) {
+            editor.setText("");
+            const arg = trimmed === "/thinking" ? "" : trimmed.slice("/thinking ".length).trim().toLowerCase();
+            if (!arg) {
+                const cur = lastSnapshot?.thinkingLevel ?? "?";
+                const avail = lastSnapshot?.availableThinkingLevels ?? [];
+                insertBeforeEditor(new Text(`  ${brand.dim("thinking is")} ${brand.amber(cur)} ${brand.dim("· available:")} ${brand.dim(avail.join(" "))}`, 0, 0));
+                return;
+            }
+            try {
+                await client.request("set-thinking", { level: arg });
+                insertBeforeEditor(new Text(`  ${brand.amber("✓")} ${brand.dim("thinking set to")} ${brand.amber(arg)}`, 0, 0));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(msg)}`, 0, 0));
+            }
+            return;
+        }
+        // Default — send as a prompt. Override timeout to 0 (disabled): the
+        // SERVER bounds turn duration via the 6-layer wrapper chain (heartbeat,
+        // stream-timeout, length-continuation). A client-side 60s cap would
+        // reject WHILE the server keeps processing, producing silent state
+        // desync — next user message would interleave with the in-flight reply.
+        insertBeforeEditor(new Markdown(`${brand.user("you")}  ${trimmed}`, 1, 0, markdownTheme));
+        editor.setText("");
+        try {
+            await client.request("prompt", { text: trimmed }, { timeoutMs: 0 });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.error(msg)}`, 0, 0));
+        }
+    };
+    tui.requestRender();
+    return {
+        abort: () => {
+            if (!isAgentRunning)
+                return false;
+            void client.request("abort").catch(() => { });
+            isAgentRunning = false;
+            editor.disableSubmit = false;
+            if (activeLoader) {
+                removeChild(activeLoader);
+                activeLoader = null;
+            }
+            insertBeforeEditor(new Text(`  ${brand.error("✗")} ${brand.dim("aborted")}`, 0, 0));
+            updateHeader();
+            return true;
+        },
+        close: async () => {
+            client.close();
+        },
+    };
+}
+//# sourceMappingURL=connect-cmd.js.map