codemaxxing 1.0.16 → 1.0.17

package/dist/ui/input-router.js

@@ -0,0 +1,657 @@
+import { PROVIDERS, openRouterOAuth, anthropicSetupToken, importCodexToken, importQwenToken, copilotDeviceFlow } from "../utils/auth.js";
+import { listInstalledSkills, installSkill, removeSkill, getRegistrySkills } from "../utils/skills.js";
+import { listThemes, getTheme, THEMES } from "../themes.js";
+import { getSession, loadMessages, deleteSession } from "../utils/sessions.js";
+import { deleteModel, stopOllama } from "../utils/ollama.js";
+import { loadConfig, saveConfig } from "../config.js";
+import { handleWizardScreen } from "./wizard.js";
+// ── Main router ──
+export function routeKeyPress(inputChar, key, ctx) {
+    if (handleSlashCommandNavigation(inputChar, key, ctx))
+        return true;
+    if (handleLoginMethodPicker(inputChar, key, ctx))
+        return true;
+    if (handleLoginPicker(inputChar, key, ctx))
+        return true;
+    if (handleSkillsPicker(inputChar, key, ctx))
+        return true;
+    if (handleModelPicker(inputChar, key, ctx))
+        return true;
+    if (handleOllamaDeletePicker(inputChar, key, ctx))
+        return true;
+    if (handleOllamaPullPicker(inputChar, key, ctx))
+        return true;
+    if (handleOllamaDeleteConfirm(inputChar, key, ctx))
+        return true;
+    if (handleOllamaExitPrompt(inputChar, key, ctx))
+        return true;
+    if (handleWizardScreen(inputChar, key, ctx))
+        return true;
+    if (handleThemePicker(inputChar, key, ctx))
+        return true;
+    if (handleSessionPicker(inputChar, key, ctx))
+        return true;
+    if (handleDeleteSessionConfirm(inputChar, key, ctx))
+        return true;
+    if (handleDeleteSessionPicker(inputChar, key, ctx))
+        return true;
+    if (handleBackspaceRemovesPasteChunk(inputChar, key, ctx))
+        return true;
+    if (handleApprovalPrompts(inputChar, key, ctx))
+        return true;
+    if (handleCtrlCExit(inputChar, key, ctx))
+        return true;
+    return false;
+}
+// ── Handlers ──
+function handleSlashCommandNavigation(_inputChar, key, ctx) {
+    if (!ctx.showSuggestionsRef.current)
+        return false;
+    const matches = ctx.cmdMatchesRef.current;
+    if (key.upArrow) {
+        ctx.setCmdIndex((prev) => (prev - 1 + matches.length) % matches.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setCmdIndex((prev) => (prev + 1) % matches.length);
+        return true;
+    }
+    if (key.tab) {
+        const selected = matches[ctx.cmdIndexRef.current];
+        if (selected) {
+            ctx.setInput(selected.cmd + (selected.cmd === "/commit" ? " " : ""));
+            ctx.setCmdIndex(() => 0);
+            ctx.setInputKey((k) => k + 1);
+        }
+        return true;
+    }
+    return false;
+}
+function handleLoginMethodPicker(inputChar, key, ctx) {
+    if (!ctx.loginMethodPicker)
+        return false;
+    const methods = ctx.loginMethodPicker.methods;
+    if (key.upArrow) {
+        ctx.setLoginMethodIndex((prev) => (prev - 1 + methods.length) % methods.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setLoginMethodIndex((prev) => (prev + 1) % methods.length);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setLoginMethodPicker(null);
+        ctx.setLoginPicker(true);
+        return true;
+    }
+    if (key.return) {
+        const method = methods[ctx.loginMethodIndex];
+        const providerId = ctx.loginMethodPicker.provider;
+        ctx.setLoginMethodPicker(null);
+        if (method === "oauth" && providerId === "openrouter") {
+            ctx.addMsg("info", "Starting OpenRouter OAuth — opening browser...");
+            ctx.setLoading(true);
+            ctx.setSpinnerMsg("Waiting for authorization...");
+            openRouterOAuth((msg) => ctx.addMsg("info", msg))
+                .then(() => {
+                ctx.addMsg("info", `✅ OpenRouter authenticated! Access to 200+ models.`);
+                ctx.setLoading(false);
+            })
+                .catch((err) => { ctx.addMsg("error", `OAuth failed: ${err.message}`); ctx.setLoading(false); });
+        }
+        else if (method === "setup-token") {
+            ctx.addMsg("info", "Starting setup-token flow — browser will open...");
+            ctx.setLoading(true);
+            ctx.setSpinnerMsg("Waiting for Claude Code auth...");
+            anthropicSetupToken((msg) => ctx.addMsg("info", msg))
+                .then((cred) => { ctx.addMsg("info", `✅ Anthropic authenticated! (${cred.label})`); ctx.setLoading(false); })
+                .catch((err) => { ctx.addMsg("error", `Auth failed: ${err.message}`); ctx.setLoading(false); });
+        }
+        else if (method === "cached-token" && providerId === "openai") {
+            const imported = importCodexToken((msg) => ctx.addMsg("info", msg));
+            if (imported) {
+                ctx.addMsg("info", `✅ Imported Codex credentials! (${imported.label})`);
+            }
+            else {
+                ctx.addMsg("info", "No Codex CLI found. Install Codex CLI and sign in first.");
+            }
+        }
+        else if (method === "cached-token" && providerId === "qwen") {
+            const imported = importQwenToken((msg) => ctx.addMsg("info", msg));
+            if (imported) {
+                ctx.addMsg("info", `✅ Imported Qwen credentials! (${imported.label})`);
+            }
+            else {
+                ctx.addMsg("info", "No Qwen CLI found. Install Qwen CLI and sign in first.");
+            }
+        }
+        else if (method === "device-flow") {
+            ctx.addMsg("info", "Starting GitHub Copilot device flow...");
+            ctx.setLoading(true);
+            ctx.setSpinnerMsg("Waiting for GitHub authorization...");
+            copilotDeviceFlow((msg) => ctx.addMsg("info", msg))
+                .then(() => { ctx.addMsg("info", `✅ GitHub Copilot authenticated!`); ctx.setLoading(false); })
+                .catch((err) => { ctx.addMsg("error", `Copilot auth failed: ${err.message}`); ctx.setLoading(false); });
+        }
+        else if (method === "api-key") {
+            const provider = PROVIDERS.find((p) => p.id === providerId);
+            ctx.addMsg("info", `Enter your API key via CLI:\n  codemaxxing auth api-key ${providerId} <your-key>\n  Get key at: ${provider?.consoleUrl ?? "your provider's dashboard"}`);
+        }
+        return true;
+    }
+    return true; // absorb all keys when picker is active
+}
+function handleLoginPicker(_inputChar, key, ctx) {
+    if (!ctx.loginPicker)
+        return false;
+    const loginProviders = PROVIDERS.filter((p) => p.id !== "local");
+    if (key.upArrow) {
+        ctx.setLoginPickerIndex((prev) => (prev - 1 + loginProviders.length) % loginProviders.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setLoginPickerIndex((prev) => (prev + 1) % loginProviders.length);
+        return true;
+    }
+    if (key.return) {
+        const selected = loginProviders[ctx.loginPickerIndex];
+        ctx.setLoginPicker(false);
+        const methods = selected.methods.filter((m) => m !== "none");
+        if (methods.length === 1) {
+            ctx.setLoginMethodPicker({ provider: selected.id, methods });
+            ctx.setLoginMethodIndex(() => 0);
+            if (methods[0] === "oauth" && selected.id === "openrouter") {
+                ctx.setLoginMethodPicker(null);
+                ctx.addMsg("info", "Starting OpenRouter OAuth — opening browser...");
+                ctx.setLoading(true);
+                ctx.setSpinnerMsg("Waiting for authorization...");
+                openRouterOAuth((msg) => ctx.addMsg("info", msg))
+                    .then(() => { ctx.addMsg("info", `✅ OpenRouter authenticated! Access to 200+ models.`); ctx.setLoading(false); })
+                    .catch((err) => { ctx.addMsg("error", `OAuth failed: ${err.message}`); ctx.setLoading(false); });
+            }
+            else if (methods[0] === "device-flow") {
+                ctx.setLoginMethodPicker(null);
+                ctx.addMsg("info", "Starting GitHub Copilot device flow...");
+                ctx.setLoading(true);
+                ctx.setSpinnerMsg("Waiting for GitHub authorization...");
+                copilotDeviceFlow((msg) => ctx.addMsg("info", msg))
+                    .then(() => { ctx.addMsg("info", `✅ GitHub Copilot authenticated!`); ctx.setLoading(false); })
+                    .catch((err) => { ctx.addMsg("error", `Copilot auth failed: ${err.message}`); ctx.setLoading(false); });
+            }
+            else if (methods[0] === "api-key") {
+                ctx.setLoginMethodPicker(null);
+                ctx.addMsg("info", `Enter your API key via CLI:\n  codemaxxing auth api-key ${selected.id} <your-key>\n  Get key at: ${selected.consoleUrl ?? "your provider's dashboard"}`);
+            }
+        }
+        else {
+            ctx.setLoginMethodPicker({ provider: selected.id, methods });
+            ctx.setLoginMethodIndex(() => 0);
+        }
+        return true;
+    }
+    if (key.escape) {
+        ctx.setLoginPicker(false);
+        return true;
+    }
+    return true; // absorb all keys when picker is active
+}
+function handleSkillsPicker(_inputChar, key, ctx) {
+    if (!ctx.skillsPicker)
+        return false;
+    if (ctx.skillsPicker === "menu") {
+        const menuItems = ["browse", "installed", "create", "remove"];
+        if (key.upArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev - 1 + menuItems.length) % menuItems.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev + 1) % menuItems.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setSkillsPicker(null);
+            return true;
+        }
+        if (key.return) {
+            const selected = menuItems[ctx.skillsPickerIndex];
+            if (selected === "browse") {
+                ctx.setSkillsPicker("browse");
+                ctx.setSkillsPickerIndex(() => 0);
+            }
+            else if (selected === "installed") {
+                ctx.setSkillsPicker("installed");
+                ctx.setSkillsPickerIndex(() => 0);
+            }
+            else if (selected === "create") {
+                ctx.setSkillsPicker(null);
+                ctx.setInput("/skills create ");
+                ctx.setInputKey((k) => k + 1);
+            }
+            else if (selected === "remove") {
+                const installed = listInstalledSkills();
+                if (installed.length === 0) {
+                    ctx.setSkillsPicker(null);
+                    ctx.addMsg("info", "No skills installed to remove.");
+                }
+                else {
+                    ctx.setSkillsPicker("remove");
+                    ctx.setSkillsPickerIndex(() => 0);
+                }
+            }
+            return true;
+        }
+        return true;
+    }
+    if (ctx.skillsPicker === "browse") {
+        const registry = getRegistrySkills();
+        if (key.upArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev - 1 + registry.length) % registry.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev + 1) % registry.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setSkillsPicker("menu");
+            ctx.setSkillsPickerIndex(() => 0);
+            return true;
+        }
+        if (key.return) {
+            const selected = registry[ctx.skillsPickerIndex];
+            if (selected) {
+                const result = installSkill(selected.name);
+                ctx.addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+            }
+            ctx.setSkillsPicker(null);
+            return true;
+        }
+        return true;
+    }
+    if (ctx.skillsPicker === "installed") {
+        const installed = listInstalledSkills();
+        if (installed.length === 0) {
+            ctx.setSkillsPicker("menu");
+            ctx.setSkillsPickerIndex(() => 0);
+            ctx.addMsg("info", "No skills installed.");
+            return true;
+        }
+        if (key.upArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev - 1 + installed.length) % installed.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev + 1) % installed.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setSkillsPicker("menu");
+            ctx.setSkillsPickerIndex(() => 0);
+            return true;
+        }
+        if (key.return) {
+            const selected = installed[ctx.skillsPickerIndex];
+            if (selected) {
+                const isDisabled = ctx.sessionDisabledSkills.has(selected.name);
+                if (isDisabled) {
+                    ctx.setSessionDisabledSkills((prev) => { const next = new Set(prev); next.delete(selected.name); return next; });
+                    if (ctx.agent)
+                        ctx.agent.enableSkill(selected.name);
+                    ctx.addMsg("info", `✅ Enabled: ${selected.name}`);
+                }
+                else {
+                    ctx.setSessionDisabledSkills((prev) => { const next = new Set(prev); next.add(selected.name); return next; });
+                    if (ctx.agent)
+                        ctx.agent.disableSkill(selected.name);
+                    ctx.addMsg("info", `✅ Disabled: ${selected.name} (session only)`);
+                }
+            }
+            ctx.setSkillsPicker(null);
+            return true;
+        }
+        return true;
+    }
+    if (ctx.skillsPicker === "remove") {
+        const installed = listInstalledSkills();
+        if (installed.length === 0) {
+            ctx.setSkillsPicker(null);
+            return true;
+        }
+        if (key.upArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev - 1 + installed.length) % installed.length);
+            return true;
+        }
+        if (key.downArrow) {
+            ctx.setSkillsPickerIndex((prev) => (prev + 1) % installed.length);
+            return true;
+        }
+        if (key.escape) {
+            ctx.setSkillsPicker("menu");
+            ctx.setSkillsPickerIndex(() => 0);
+            return true;
+        }
+        if (key.return) {
+            const selected = installed[ctx.skillsPickerIndex];
+            if (selected) {
+                const result = removeSkill(selected.name);
+                ctx.addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+            }
+            ctx.setSkillsPicker(null);
+            return true;
+        }
+        return true;
+    }
+    return true; // absorb all keys when skills picker is active
+}
+function handleModelPicker(_inputChar, key, ctx) {
+    if (!ctx.modelPicker)
+        return false;
+    if (key.upArrow) {
+        ctx.setModelPickerIndex((prev) => (prev - 1 + ctx.modelPicker.length) % ctx.modelPicker.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setModelPickerIndex((prev) => (prev + 1) % ctx.modelPicker.length);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setModelPicker(null);
+        return true;
+    }
+    if (key.return) {
+        const selected = ctx.modelPicker[ctx.modelPickerIndex];
+        if (selected && ctx.agent) {
+            ctx.agent.switchModel(selected);
+            ctx.setModelName(selected);
+            ctx.addMsg("info", `✅ Switched to: ${selected}`);
+            ctx.refreshConnectionBanner();
+        }
+        ctx.setModelPicker(null);
+        return true;
+    }
+    return true;
+}
+function handleOllamaDeletePicker(_inputChar, key, ctx) {
+    if (!ctx.ollamaDeletePicker)
+        return false;
+    if (key.upArrow) {
+        ctx.setOllamaDeletePickerIndex((prev) => (prev - 1 + ctx.ollamaDeletePicker.models.length) % ctx.ollamaDeletePicker.models.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setOllamaDeletePickerIndex((prev) => (prev + 1) % ctx.ollamaDeletePicker.models.length);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setOllamaDeletePicker(null);
+        return true;
+    }
+    if (key.return) {
+        const selected = ctx.ollamaDeletePicker.models[ctx.ollamaDeletePickerIndex];
+        if (selected) {
+            ctx.setOllamaDeletePicker(null);
+            ctx.setOllamaDeleteConfirm({ model: selected.name, size: selected.size });
+        }
+        return true;
+    }
+    return true;
+}
+function handleOllamaPullPicker(_inputChar, key, ctx) {
+    if (!ctx.ollamaPullPicker)
+        return false;
+    const pullModels = [
+        { id: "qwen2.5-coder:7b", name: "Qwen 2.5 Coder 7B", size: "5 GB", desc: "Best balance of speed & quality" },
+        { id: "qwen2.5-coder:14b", name: "Qwen 2.5 Coder 14B", size: "9 GB", desc: "Higher quality, needs 16GB+ RAM" },
+        { id: "qwen2.5-coder:3b", name: "Qwen 2.5 Coder 3B", size: "2 GB", desc: "\u26A0\uFE0F Basic \u2014 may struggle with tool calls" },
+        { id: "qwen2.5-coder:32b", name: "Qwen 2.5 Coder 32B", size: "20 GB", desc: "Premium quality, needs 48GB+" },
+        { id: "deepseek-coder-v2:16b", name: "DeepSeek Coder V2", size: "9 GB", desc: "Strong alternative" },
+        { id: "codellama:7b", name: "CodeLlama 7B", size: "4 GB", desc: "Meta's coding model" },
+        { id: "starcoder2:7b", name: "StarCoder2 7B", size: "4 GB", desc: "Code completion focused" },
+    ];
+    if (key.upArrow) {
+        ctx.setOllamaPullPickerIndex((prev) => (prev - 1 + pullModels.length) % pullModels.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setOllamaPullPickerIndex((prev) => (prev + 1) % pullModels.length);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setOllamaPullPicker(false);
+        return true;
+    }
+    if (key.return) {
+        const selected = pullModels[ctx.ollamaPullPickerIndex];
+        if (selected) {
+            ctx.setOllamaPullPicker(false);
+            ctx.setInput(`/ollama pull ${selected.id}`);
+            ctx.setInputKey((k) => k + 1);
+            setTimeout(() => {
+                const submitInput = `/ollama pull ${selected.id}`;
+                ctx.setInput("");
+                ctx.handleSubmit(submitInput);
+            }, 50);
+        }
+        return true;
+    }
+    return true;
+}
+function handleOllamaDeleteConfirm(inputChar, key, ctx) {
+    if (!ctx.ollamaDeleteConfirm)
+        return false;
+    if (inputChar === "y" || inputChar === "Y") {
+        const model = ctx.ollamaDeleteConfirm.model;
+        ctx.setOllamaDeleteConfirm(null);
+        const result = deleteModel(model);
+        ctx.addMsg(result.ok ? "info" : "error", result.ok ? `\u2705 ${result.message}` : `\u274C ${result.message}`);
+        return true;
+    }
+    if (inputChar === "n" || inputChar === "N" || key.escape) {
+        ctx.setOllamaDeleteConfirm(null);
+        ctx.addMsg("info", "Delete cancelled.");
+        return true;
+    }
+    return true;
+}
+function handleOllamaExitPrompt(inputChar, key, ctx) {
+    if (!ctx.ollamaExitPrompt)
+        return false;
+    if (inputChar === "y" || inputChar === "Y") {
+        ctx.setOllamaExitPrompt(false);
+        stopOllama().then(() => ctx.exit());
+        return true;
+    }
+    if (inputChar === "n" || inputChar === "N") {
+        ctx.setOllamaExitPrompt(false);
+        ctx.exit();
+        return true;
+    }
+    if (inputChar === "a" || inputChar === "A") {
+        ctx.setOllamaExitPrompt(false);
+        saveConfig({ defaults: { ...loadConfig().defaults, stopOllamaOnExit: true } });
+        ctx.addMsg("info", "Saved preference: always stop Ollama on exit.");
+        stopOllama().then(() => ctx.exit());
+        return true;
+    }
+    if (key.escape) {
+        ctx.setOllamaExitPrompt(false);
+        return true;
+    }
+    return true;
+}
+function handleThemePicker(_inputChar, key, ctx) {
+    if (!ctx.themePicker)
+        return false;
+    const themeKeys = listThemes();
+    if (key.upArrow) {
+        ctx.setThemePickerIndex((prev) => (prev - 1 + themeKeys.length) % themeKeys.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setThemePickerIndex((prev) => (prev + 1) % themeKeys.length);
+        return true;
+    }
+    if (key.return) {
+        const selected = themeKeys[ctx.themePickerIndex];
+        ctx.setTheme(getTheme(selected));
+        ctx.setThemePicker(false);
+        ctx.addMsg("info", `✅ Switched to theme: ${THEMES[selected].name}`);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setThemePicker(false);
+        return true;
+    }
+    return true;
+}
+function handleSessionPicker(_inputChar, key, ctx) {
+    if (!ctx.sessionPicker)
+        return false;
+    if (key.upArrow) {
+        ctx.setSessionPickerIndex((prev) => (prev - 1 + ctx.sessionPicker.length) % ctx.sessionPicker.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setSessionPickerIndex((prev) => (prev + 1) % ctx.sessionPicker.length);
+        return true;
+    }
+    if (key.return) {
+        const selected = ctx.sessionPicker[ctx.sessionPickerIndex];
+        if (selected && ctx.agent) {
+            const session = getSession(selected.id);
+            if (session) {
+                ctx.agent.resume(selected.id).then(() => {
+                    const dir = session.cwd.split("/").pop() || session.cwd;
+                    const msgs = loadMessages(selected.id);
+                    const lastUserMsg = [...msgs].reverse().find(m => m.role === "user");
+                    const lastText = lastUserMsg && typeof lastUserMsg.content === "string"
+                        ? lastUserMsg.content.slice(0, 80) + (lastUserMsg.content.length > 80 ? "..." : "")
+                        : null;
+                    let info = `✅ Resumed session ${selected.id} (${dir}/, ${session.message_count} messages)`;
+                    if (lastText)
+                        info += `\n  Last: "${lastText}"`;
+                    ctx.addMsg("info", info);
+                }).catch((e) => {
+                    ctx.addMsg("error", `Failed to resume: ${e.message}`);
+                });
+            }
+        }
+        ctx.setSessionPicker(null);
+        ctx.setSessionPickerIndex(() => 0);
+        return true;
+    }
+    if (key.escape) {
+        ctx.setSessionPicker(null);
+        ctx.setSessionPickerIndex(() => 0);
+        ctx.addMsg("info", "Resume cancelled.");
+        return true;
+    }
+    return true; // Ignore other keys during session picker
+}
+function handleDeleteSessionConfirm(inputChar, _key, ctx) {
+    if (!ctx.deleteSessionConfirm)
+        return false;
+    if (inputChar === "y" || inputChar === "Y") {
+        const deleted = deleteSession(ctx.deleteSessionConfirm.id);
+        if (deleted) {
+            ctx.addMsg("info", `✅ Deleted session ${ctx.deleteSessionConfirm.id}`);
+        }
+        else {
+            ctx.addMsg("error", `Failed to delete session ${ctx.deleteSessionConfirm.id}`);
+        }
+        ctx.setDeleteSessionConfirm(null);
+        return true;
+    }
+    if (inputChar === "n" || inputChar === "N" || _key.escape) {
+        ctx.addMsg("info", "Delete cancelled.");
+        ctx.setDeleteSessionConfirm(null);
+        return true;
+    }
+    return true;
+}
+function handleDeleteSessionPicker(_inputChar, key, ctx) {
+    if (!ctx.deleteSessionPicker)
+        return false;
+    if (key.upArrow) {
+        ctx.setDeleteSessionPickerIndex((prev) => (prev - 1 + ctx.deleteSessionPicker.length) % ctx.deleteSessionPicker.length);
+        return true;
+    }
+    if (key.downArrow) {
+        ctx.setDeleteSessionPickerIndex((prev) => (prev + 1) % ctx.deleteSessionPicker.length);
+        return true;
+    }
+    if (key.return) {
+        const selected = ctx.deleteSessionPicker[ctx.deleteSessionPickerIndex];
+        if (selected) {
+            ctx.setDeleteSessionPicker(null);
+            ctx.setDeleteSessionPickerIndex(() => 0);
+            ctx.setDeleteSessionConfirm(selected);
+        }
+        return true;
+    }
+    if (key.escape) {
+        ctx.setDeleteSessionPicker(null);
+        ctx.setDeleteSessionPickerIndex(() => 0);
+        ctx.addMsg("info", "Delete cancelled.");
+        return true;
+    }
+    return true;
+}
+function handleBackspaceRemovesPasteChunk(_inputChar, key, ctx) {
+    if (key.backspace || key.delete) {
+        if (ctx.input === "" && ctx.pastedChunksRef.current.length > 0) {
+            ctx.setPastedChunks((prev) => prev.slice(0, -1));
+            return true;
+        }
+    }
+    return false;
+}
+function handleApprovalPrompts(inputChar, _key, ctx) {
+    if (!ctx.approval)
+        return false;
+    if (inputChar === "y" || inputChar === "Y") {
+        const r = ctx.approval.resolve;
+        ctx.setApproval(null);
+        ctx.setLoading(true);
+        ctx.setSpinnerMsg("Executing...");
+        r("yes");
+        return true;
+    }
+    if (inputChar === "n" || inputChar === "N") {
+        const r = ctx.approval.resolve;
+        ctx.setApproval(null);
+        ctx.addMsg("info", "✗ Denied");
+        r("no");
+        return true;
+    }
+    if (inputChar === "a" || inputChar === "A") {
+        const r = ctx.approval.resolve;
+        ctx.setApproval(null);
+        ctx.setLoading(true);
+        ctx.setSpinnerMsg("Executing...");
+        ctx.addMsg("info", `✔ Always allow ${ctx.approval.tool} for this session`);
+        r("always");
+        return true;
+    }
+    return true; // Ignore other keys during approval
+}
+function handleCtrlCExit(inputChar, key, ctx) {
+    if (key.ctrl && inputChar === "c") {
+        if (ctx.ctrlCPressed) {
+            const config = loadConfig();
+            if (config.defaults.stopOllamaOnExit) {
+                stopOllama().finally(() => ctx.exit());
+            }
+            else {
+                ctx.exit();
+            }
+        }
+        else {
+            ctx.setCtrlCPressed(true);
+            ctx.addMsg("info", "Press Ctrl+C again to exit.");
+            setTimeout(() => ctx.setCtrlCPressed(false), 3000);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/ui/paste-interceptor.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from "events";
+export interface PasteEvent {
+    content: string;
+    lines: number;
+}
+export type PasteEventBus = EventEmitter;
+/**
+ * Sets up the full paste interception pipeline on process.stdin:
+ *
+ * - Enables bracketed paste mode on the terminal
+ * - Patches stdin emit('data') to intercept all incoming data
+ * - Detects multiline pastes via bracketed paste escape sequences
+ * - Falls back to burst buffering for terminals without bracketed paste
+ * - Strips paste marker artifacts from all chunks
+ * - Emits "paste" events on the returned EventEmitter for multiline content
+ * - Forwards short pastes (1-2 lines) as normal stdin data
+ * - Registers an exit handler to disable bracketed paste mode
+ *
+ * Returns the EventEmitter that fires "paste" events with { content, lines }.
+ */
+export declare function setupPasteInterceptor(): PasteEventBus;