@bubblebrain-ai/bubble 0.0.1 → 0.0.2

package/dist/agent.d.ts

@@ -4,6 +4,9 @@
  */
 import type { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry } from "./types.js";
 import { type TurnHooks } from "./orchestrator/hooks.js";
+export declare class AgentAbortError extends Error {
+    constructor(message?: string);
+}
 export interface AgentOptions {
     provider: Provider;
     sessionID?: string;
@@ -57,6 +60,7 @@ export declare class Agent {
     /** Whether a given tool is deferred and not yet unlocked. */
     isDeferredAndLocked(name: string): boolean;
     injectSystemReminder(content: string): void;
+    injectModeReminder(): void;
     get model(): string;
     set model(value: string);
     get providerId(): string;
@@ -67,6 +71,7 @@ export declare class Agent {
         model?: string;
         temperature?: number;
         thinkingLevel?: ThinkingLevel;
+        abortSignal?: AbortSignal;
     }): Promise<string>;
     get thinking(): ThinkingLevel;
     set thinking(value: ThinkingLevel);
@@ -82,7 +87,9 @@ export declare class Agent {
     /** Internal: snapshot counter that bumps on every setTodos. Used by run loop to detect mutations. */
     get todosVersion(): number;
     setSystemPrompt(prompt: string): void;
-    run(userInput: string | ContentPart[], cwd: string): AsyncIterable<AgentEvent>;
+    run(userInput: string | ContentPart[], cwd: string, options?: {
+        abortSignal?: AbortSignal;
+    }): AsyncIterable<AgentEvent>;
     private recoverFromOverflow;
     compactResidentHistory(): void;
     runSubtask(input: string | ContentPart[], cwd: string, options?: {

package/dist/agent.js

@@ -8,7 +8,7 @@ import { getContextBudget } from "./context/budget.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { projectMessages } from "./context/projector.js";
 import { aggressivePruneMessages } from "./context/prune.js";
-import { buildDeferredToolsReminder, buildToolFreezeReminder, reminderForMode } from "./prompt/reminders.js";
+import { buildDeferredToolsReminder, buildToolFreezeReminder, isPermissionModeReminder, reminderForMode } from "./prompt/reminders.js";
 import { HookBus } from "./orchestrator/hooks.js";
 import { createDefaultHooks } from "./orchestrator/default-hooks.js";
 import { filterToolsForSubtask, getSubtaskPolicy } from "./agent/subtask-policy.js";
@@ -19,6 +19,12 @@ const RESIDENT_HISTORY_CHAR_SOFT_LIMIT = 256 * 1024;
 const RESIDENT_HISTORY_CHAR_HARD_LIMIT = 512 * 1024;
 const RESIDENT_HISTORY_HEAP_SOFT_LIMIT = 512 * 1024 * 1024;
 const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
+export class AgentAbortError extends Error {
+    constructor(message = "Agent run cancelled.") {
+        super(message);
+        this.name = "AgentAbortError";
+    }
+}
 export class Agent {
     messages = [];
     provider;
@@ -67,7 +73,7 @@ export class Agent {
         // If the agent boots in a non-default mode, inject the corresponding reminder so the
         // model sees the active rules on its very first turn. Default mode needs no reminder.
         if (this._mode !== "default") {
-            this.injectSystemReminder(reminderForMode(this._mode));
+            this.injectModeReminder();
         }
         // Advertise any deferred tools so the model knows they exist and how to
         // reach them. Keeps the per-turn tool list small; schemas load on demand.
@@ -97,6 +103,12 @@ export class Agent {
     injectSystemReminder(content) {
         this.appendMessage({ role: "user", content, isMeta: true });
     }
+    injectModeReminder() {
+        this.messages = this.messages.filter((message) => !(message.role === "user"
+            && message.isMeta
+            && isPermissionModeReminder(message.content)));
+        this.injectSystemReminder(reminderForMode(this._mode));
+    }
     get model() {
         return this._model;
     }
@@ -123,6 +135,7 @@ export class Agent {
             model: options?.model ?? this.apiModel,
             temperature: options?.temperature ?? this.temperature,
             thinkingLevel: options?.thinkingLevel ?? this.thinkingLevel,
+            abortSignal: options?.abortSignal,
         });
     }
     get thinking() {
@@ -148,7 +161,7 @@ export class Agent {
             return;
         this._mode = value;
         this._modeVersion += 1;
-        this.injectSystemReminder(reminderForMode(value));
+        this.injectModeReminder();
         this.onModeUpdate?.(value);
     }
     /** Internal: snapshot counter that bumps on every mode change. Used by run loop. */
@@ -175,7 +188,9 @@ export class Agent {
         }
         this.messages.unshift(systemMessage);
     }
-    async *run(userInput, cwd) {
+    async *run(userInput, cwd, options = {}) {
+        const abortSignal = options.abortSignal;
+        throwIfAborted(abortSignal);
         const hookBus = new HookBus();
         for (const hooks of createDefaultHooks()) {
             hookBus.register(hooks);
@@ -210,6 +225,7 @@ export class Agent {
         let consecutiveOverflowRecoveries = 0;
         let step = 0;
         while (true) {
+            throwIfAborted(abortSignal);
             flushGovernorReminders();
             yield { type: "turn_start" };
             step += 1;
@@ -253,6 +269,9 @@ export class Agent {
             };
             await hookBus.runBeforeModelCall(beforeModelCallCtx);
             toolEntries = beforeModelCallCtx.toolEntries;
+            if (this._mode !== "plan") {
+                toolEntries = toolEntries.filter((t) => t.name !== "exit_plan_mode");
+            }
             flushGovernorReminders();
             const toolDefinitions = ((hookState.forceTextOnlyReason ? [] : toolEntries))
                 .map((t) => ({
@@ -273,8 +292,10 @@ export class Agent {
                     tools: toolDefinitions,
                     temperature: this.temperature,
                     thinkingLevel: this.thinkingLevel,
+                    abortSignal,
                 });
                 for await (const chunk of stream) {
+                    throwIfAborted(abortSignal);
                     switch (chunk.type) {
                         case "text":
                             assistantMsg.content += chunk.content;
@@ -346,6 +367,7 @@ export class Agent {
                 }
                 const executedResults = [];
                 for (let index = 0; index < parsedCalls.length; index++) {
+                    throwIfAborted(abortSignal);
                     let tc = parsedCalls[index];
                     let blockedResult;
                     await hookBus.runBeforeToolCall({
@@ -373,7 +395,8 @@ export class Agent {
                     yield { type: "tool_start", id: tc.id, name: tc.name, args: tc.parsedArgs };
                     const todosVersionBefore = this._todosVersion;
                     const modeVersionBefore = this._modeVersion;
-                    let result = blockedResult ?? await this.executeTool(tc, cwd);
+                    let result = blockedResult ?? await this.executeTool(tc, cwd, abortSignal);
+                    throwIfAborted(abortSignal);
                     await hookBus.runAfterToolCall({
                         agent: this,
                         cwd,
@@ -581,7 +604,14 @@ export class Agent {
         this.messages.push(message);
         this.onMessageAppend?.(message);
     }
-    async executeTool(toolCall, cwd) {
+    async executeTool(toolCall, cwd, abortSignal) {
+        throwIfAborted(abortSignal);
+        if (toolCall.name === "exit_plan_mode" && this._mode !== "plan") {
+            return {
+                content: "Ignored exit_plan_mode because plan mode is not active. " +
+                    "Continue with the user's request directly using the regular tools.",
+            };
+        }
         const tool = this.tools.get(toolCall.name);
         if (!tool) {
             return {
@@ -608,6 +638,7 @@ export class Agent {
             return await tool.execute(toolCall.parsedArgs, {
                 cwd,
                 sessionID: this.sessionID,
+                abortSignal,
                 toolCall: { id: toolCall.id, name: toolCall.name },
                 agent: this,
             });
@@ -651,6 +682,14 @@ function estimateResidentChars(messages) {
     }
     return total;
 }
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        throw reason;
+    throw new AgentAbortError(typeof reason === "string" ? reason : undefined);
+}
 function estimateToolPayloadChars(messages) {
     return messages.reduce((sum, message) => {
         if (message.role !== "tool") {

package/dist/approval/controller.d.ts

@@ -28,12 +28,12 @@ export interface ApprovalControllerOptions {
  * Default ApprovalController. Decision tree:
  *
  *   deny rule match              → reject (applies even under bypassPermissions)
- *   bypassPermissions / dontAsk  → auto-approve, no prompt
- *   acceptEdits + edit|write     → auto-approve
+ *   bypassPermissions            → auto-approve, no prompt
+ *   default + edit|write         → auto-approve
  *   plan                         → reject with instructions to use exit_plan_mode
  *   allow rule match             → auto-approve
  *   bash in session allowlist    → auto-approve
- *   default / other              → delegate to UI; if no UI, reject
+ *   bash / other                 → delegate to UI; if no UI, reject
  *
  * Deny rules sit at the top as a hard ceiling: bypassPermissions is a trust
  * escalation, not a policy override. Users who want to permit a currently-

package/dist/approval/controller.js

@@ -3,12 +3,12 @@ import { checkPermission } from "../permissions/rule.js";
  * Default ApprovalController. Decision tree:
  *
  *   deny rule match              → reject (applies even under bypassPermissions)
- *   bypassPermissions / dontAsk  → auto-approve, no prompt
- *   acceptEdits + edit|write     → auto-approve
+ *   bypassPermissions            → auto-approve, no prompt
+ *   default + edit|write         → auto-approve
  *   plan                         → reject with instructions to use exit_plan_mode
  *   allow rule match             → auto-approve
  *   bash in session allowlist    → auto-approve
- *   default / other              → delegate to UI; if no UI, reject
+ *   bash / other                 → delegate to UI; if no UI, reject
  *
  * Deny rules sit at the top as a hard ceiling: bypassPermissions is a trust
  * escalation, not a policy override. Users who want to permit a currently-
@@ -35,10 +35,10 @@ export class PermissionAwareApprovalController {
             };
         }
         const mode = this.options.getMode();
-        if (mode === "bypassPermissions" || mode === "dontAsk") {
+        if (mode === "bypassPermissions") {
             return { action: "approve" };
         }
-        if (mode === "acceptEdits" && (req.type === "edit" || req.type === "write")) {
+        if (mode === "default" && (req.type === "edit" || req.type === "write")) {
             return { action: "approve" };
         }
         if (mode === "plan") {

package/dist/cli.d.ts

@@ -12,8 +12,6 @@ export interface CliArgs {
     prompt?: string;
     thinkingLevel?: ThinkingLevel;
     mode?: PermissionMode;
-    /** When true, --dangerously-skip-permissions was passed; bypassPermissions is reachable via the mode cycle and auto-approves every tool. */
-    bypassEnabled?: boolean;
 }
 export declare function parseArgs(argv: string[]): CliArgs;
 export declare function printHelp(): void;

package/dist/cli.js

@@ -45,10 +45,10 @@ export function parseArgs(argv) {
                 args.mode = "plan";
                 break;
             case "--accept-edits":
-                args.mode = "acceptEdits";
+                // Backward-compatible no-op: Build mode now includes edit/write auto-approval.
+                args.mode = "default";
                 break;
             case "--dangerously-skip-permissions":
-                args.bypassEnabled = true;
                 args.mode = "bypassPermissions";
                 break;
             default:
@@ -73,7 +73,6 @@ Options:
   --reasoning              Enable reasoning mode at medium effort
   --reasoning-effort <l>   Set reasoning effort: off|minimal|low|medium|high|xhigh|max
   --plan                   Start in plan mode (read-only investigation; propose before executing)
-  --accept-edits           Start with edits/writes auto-approved (bash still prompts)
   --dangerously-skip-permissions
                            Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)
   -p, --print              Non-interactive mode (single prompt)

package/dist/main.js

@@ -284,8 +284,7 @@ async function main() {
             // Reassigning agent.messages drops any <system-reminder> we injected during
             // construction. Re-inject if the agent is starting in plan mode.
             if (agent.mode === "plan") {
-                const { PLAN_MODE_ENTER_REMINDER } = await import("./prompt/reminders.js");
-                agent.injectSystemReminder(PLAN_MODE_ENTER_REMINDER);
+                agent.injectModeReminder();
             }
             console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
@@ -326,7 +325,6 @@ async function main() {
         settingsManager,
         lspService,
         mcpManager,
-        bypassEnabled: args.bypassEnabled,
         theme: userConfig.getTheme(),
         flushMemory,
         runMemoryCompaction,

package/dist/permission/mode.d.ts

@@ -13,11 +13,7 @@ export interface PermissionModeInfo {
 }
 export declare const PERMISSION_MODE_INFO: Record<PermissionMode, PermissionModeInfo>;
 /**
- * Cycle order for the interactive mode keybind. This intentionally mirrors
- * opencode's primary-agent switch: the keybind toggles Build and Plan only.
- * Permission presets like acceptEdits/bypassPermissions remain opt-in through
- * flags or commands and are never reached accidentally from Tab.
+ * Cycle order for the interactive mode keybind. The visible TUI loop keeps the
+ * mental model simple: Build -> Plan -> Bypass -> Build.
  */
-export declare function getNextPermissionMode(current: PermissionMode, _options?: {
-    bypassEnabled?: boolean;
-}): PermissionMode;
+export declare function getNextPermissionMode(current: PermissionMode): PermissionMode;

package/dist/permission/mode.js

@@ -1,20 +1,16 @@
 export const PERMISSION_MODE_INFO = {
     default: { title: "Default", shortTitle: "default", symbol: "", color: "muted" },
-    acceptEdits: { title: "Accept edits", shortTitle: "accept edits", symbol: "⏵⏵", color: "success" },
     plan: { title: "Plan", shortTitle: "plan", symbol: "⏸", color: "accent" },
     bypassPermissions: { title: "Bypass permissions", shortTitle: "bypass", symbol: "⏵⏵", color: "error" },
-    dontAsk: { title: "Do not ask", shortTitle: "silent", symbol: "·", color: "warning" },
 };
 /**
- * Cycle order for the interactive mode keybind. This intentionally mirrors
- * opencode's primary-agent switch: the keybind toggles Build and Plan only.
- * Permission presets like acceptEdits/bypassPermissions remain opt-in through
- * flags or commands and are never reached accidentally from Tab.
+ * Cycle order for the interactive mode keybind. The visible TUI loop keeps the
+ * mental model simple: Build -> Plan -> Bypass -> Build.
  */
-export function getNextPermissionMode(current, _options = {}) {
+export function getNextPermissionMode(current) {
+    if (current === "default")
+        return "plan";
     if (current === "plan")
-        return "default";
-    if (current === "bypassPermissions" || current === "dontAsk")
-        return "default";
-    return "plan";
+        return "bypassPermissions";
+    return "default";
 }

package/dist/permissions/settings.js

@@ -21,10 +21,8 @@ import { normalizeLspConfig } from "../lsp/config.js";
 import { parseRules } from "./rule.js";
 const KNOWN_MODES = new Set([
     "default",
-    "acceptEdits",
     "plan",
     "bypassPermissions",
-    "dontAsk",
 ]);
 export class SettingsManager {
     cwd;
@@ -83,8 +81,9 @@ export class SettingsManager {
                 continue;
             const perms = data.permissions;
             if (typeof perms.defaultMode === "string") {
-                if (KNOWN_MODES.has(perms.defaultMode)) {
-                    defaultMode = perms.defaultMode;
+                const rawMode = perms.defaultMode === "acceptEdits" ? "default" : perms.defaultMode;
+                if (KNOWN_MODES.has(rawMode)) {
+                    defaultMode = rawMode;
                 }
                 else {
                     diagnostics.push({

package/dist/prompt/reminders.d.ts

@@ -8,6 +8,7 @@
  */
 import type { PermissionMode } from "../types.js";
 export declare function wrapInSystemReminder(content: string): string;
+export declare function isPermissionModeReminder(content: unknown): boolean;
 /** Picks the correct reminder text for a transition TO a given mode. */
 export declare function reminderForMode(mode: PermissionMode): string;
 export declare const PLAN_MODE_ENTER_REMINDER: string;

package/dist/prompt/reminders.js

@@ -9,6 +9,13 @@
 export function wrapInSystemReminder(content) {
     return `<system-reminder>\n${content.trim()}\n</system-reminder>`;
 }
+export function isPermissionModeReminder(content) {
+    if (typeof content !== "string")
+        return false;
+    return content.includes("Plan mode is now ACTIVE")
+        || content.includes("Permission mode is now: bypassPermissions")
+        || content.includes("Permission mode is now: default Build mode");
+}
 const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
 
@@ -21,12 +28,6 @@ Rules while in plan mode:
 - The user will approve, edit, or reject your plan. On approval the harness switches back to default mode and you may execute.
 - On rejection, remain in plan mode and iterate.
 `;
-const ACCEPT_EDITS_ENTER = `
-Permission mode is now: acceptEdits.
-
-The user has granted blanket approval for file edits and writes in this session.
-Bash commands still require explicit approval. Other tool safety rules are unchanged.
-`;
 const BYPASS_ENTER = `
 Permission mode is now: bypassPermissions.
 
@@ -34,25 +35,18 @@ ALL tool calls auto-approve with no user confirmation. The user has explicitly o
 Proceed with extra care — explain risky actions in the chat BEFORE performing them, and
 prefer reversible operations when possible.
 `;
-const DONT_ASK_ENTER = `
-Permission mode is now: dontAsk.
-
-All tool calls auto-approve silently. Minimise narration; execute and report results tersely.
-`;
 const DEFAULT_ENTER = `
-Permission mode is now: default. Each destructive tool call will be confirmed by the user.
+Permission mode is now: default Build mode.
+
+File edits and writes auto-approve. Bash commands and other destructive tools still require explicit approval unless allowed by rules.
 `;
 /** Picks the correct reminder text for a transition TO a given mode. */
 export function reminderForMode(mode) {
     switch (mode) {
         case "plan":
             return wrapInSystemReminder(PLAN_MODE_ENTER);
-        case "acceptEdits":
-            return wrapInSystemReminder(ACCEPT_EDITS_ENTER);
         case "bypassPermissions":
             return wrapInSystemReminder(BYPASS_ENTER);
-        case "dontAsk":
-            return wrapInSystemReminder(DONT_ASK_ENTER);
         case "default":
         default:
             return wrapInSystemReminder(DEFAULT_ENTER);

package/dist/provider-openai-codex.js

@@ -44,6 +44,7 @@ export function createOpenAICodexProvider(options) {
         const response = await fetch(resolveCodexUrl(options.baseURL), {
             method: "POST",
             headers: buildSseHeaders(options.apiKey, accountId, sessionId),
+            signal: chatOptions.abortSignal,
             body: JSON.stringify(buildRequestBody(messages, {
                 model: chatOptions.model,
                 tools: chatOptions.tools,
@@ -181,6 +182,7 @@ export function createOpenAICodexProvider(options) {
             model: chatOptions?.model ?? "gpt-5.4",
             temperature: chatOptions?.temperature,
             thinkingLevel: chatOptions?.thinkingLevel,
+            abortSignal: chatOptions?.abortSignal,
         })) {
             if (chunk.type === "text") {
                 content += chunk.content;

package/dist/provider.js

@@ -87,7 +87,9 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
-        const stream = (await client.chat.completions.create(body));
+        const stream = (await client.chat.completions.create(body, {
+            signal: chatOptions.abortSignal,
+        }));
         yield* translateOpenAIStream(stream);
         yield { type: "done" };
     }
@@ -108,7 +110,9 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
-        const response = await client.chat.completions.create(body);
+        const response = await client.chat.completions.create(body, {
+            signal: chatOptions?.abortSignal,
+        });
         return response.choices[0]?.message?.content ?? "";
     }
     return { streamChat, complete };

package/dist/slash-commands/commands.js

@@ -227,30 +227,9 @@ function parseKeyArgs(args, ctx) {
 const builtinSlashCommandEntries = [
     {
         name: "skills",
-        description: "List available skills and any skill diagnostics",
+        description: "Open the searchable skills picker",
         async handler(args, ctx) {
-            const skills = ctx.skillRegistry.summaries();
-            const diagnostics = ctx.skillRegistry.getDiagnostics();
-            const lines = [];
-            if (skills.length === 0) {
-                lines.push("No skills available.");
-            }
-            else {
-                lines.push("Available skills:");
-                for (const skill of skills) {
-                    const tagSuffix = skill.tags && skill.tags.length > 0 ? ` [tags: ${skill.tags.join(", ")}]` : "";
-                    lines.push(`- ${skill.name}: ${skill.description}${tagSuffix}`);
-                }
-            }
-            if (diagnostics.length > 0) {
-                lines.push("", "Skill diagnostics:");
-                for (const diagnostic of diagnostics) {
-                    const prefix = diagnostic.level === "error" ? "ERROR" : "WARN";
-                    const target = diagnostic.skillName ?? diagnostic.filePath ?? "skills";
-                    lines.push(`- ${prefix} ${target}: ${diagnostic.message}`);
-                }
-            }
-            return lines.join("\n");
+            ctx.openPicker("skill");
         },
     },
     {

package/dist/slash-commands/types.d.ts

@@ -16,7 +16,7 @@ export interface SlashCommandContext {
     exit: () => void;
     sessionManager?: SessionManager;
     createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
-    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout", providerId?: string) => void;
+    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill", providerId?: string) => void;
     registry: ProviderRegistry;
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;

package/dist/tools/bash.js

@@ -20,7 +20,7 @@ export function createBashTool(cwd, approval) {
             },
             required: ["command"],
         },
-        async execute(args) {
+        async execute(args, ctx) {
             if (!existsSync(cwd)) {
                 return { content: `Error: Working directory does not exist: ${cwd}`, isError: true };
             }
@@ -52,11 +52,21 @@ export function createBashTool(cwd, approval) {
                 let stdout = "";
                 let stderr = "";
                 let timedOut = false;
-                const timeoutHandle = setTimeout(() => {
-                    timedOut = true;
+                let aborted = false;
+                const abortChild = () => {
+                    if (aborted)
+                        return;
+                    aborted = true;
                     child.kill("SIGTERM");
                     setTimeout(() => child.kill("SIGKILL"), 5000);
+                };
+                const timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    abortChild();
                 }, timeoutSec * 1000);
+                if (ctx.abortSignal?.aborted)
+                    abortChild();
+                ctx.abortSignal?.addEventListener("abort", abortChild, { once: true });
                 child.stdout?.on("data", (data) => {
                     stdout += data.toString();
                 });
@@ -65,10 +75,12 @@ export function createBashTool(cwd, approval) {
                 });
                 child.on("error", (err) => {
                     clearTimeout(timeoutHandle);
+                    ctx.abortSignal?.removeEventListener("abort", abortChild);
                     resolve({ content: `Error: ${err.message}`, isError: true });
                 });
                 child.on("close", (code) => {
                     clearTimeout(timeoutHandle);
+                    ctx.abortSignal?.removeEventListener("abort", abortChild);
                     let output = "";
                     if (stdout)
                         output += `stdout:\n${stdout}\n`;
@@ -90,6 +102,21 @@ export function createBashTool(cwd, approval) {
                         });
                         return;
                     }
+                    if (aborted || ctx.abortSignal?.aborted) {
+                        output += "[Command cancelled]";
+                        resolve({
+                            content: output.trim(),
+                            isError: true,
+                            status: "blocked",
+                            metadata: {
+                                kind: parsedSearch ? "search" : "shell",
+                                pattern: parsedSearch?.pattern,
+                                path: parsedSearch?.path,
+                                reason: "cancelled",
+                            },
+                        });
+                        return;
+                    }
                     if (Buffer.byteLength(output, "utf-8") > MAX_OUTPUT) {
                         output = Buffer.from(output, "utf-8").subarray(0, MAX_OUTPUT).toString("utf-8");
                         output += "\n[Output truncated]";

package/dist/tui/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/tui/clipboard.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+export async function copyTextToClipboard(text) {
+    if (process.platform === "darwin") {
+        await writeToProcess("pbcopy", [], text);
+        return;
+    }
+    if (process.platform === "win32") {
+        await writeToProcess("powershell", [
+            "-NoProfile",
+            "-Command",
+            "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ], text);
+        return;
+    }
+    const candidates = [
+        ["wl-copy", []],
+        ["xclip", ["-selection", "clipboard"]],
+        ["xsel", ["--clipboard", "--input"]],
+    ];
+    let lastError;
+    for (const [command, args] of candidates) {
+        try {
+            await writeToProcess(command, args, text);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("No clipboard command available");
+}
+function writeToProcess(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["pipe", "ignore", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `${command} exited with code ${code}`));
+        });
+        child.stdin.end(input);
+    });
+}

package/dist/tui/global-key-router.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeKeyName(name?: string): string;
+export declare function keyNameFromSequence(sequence?: string): string;
+export declare function keyNameFromEvent(event: any): string;