clawdbot 2026.1.4-1

package/dist/tui/tui.js

@@ -0,0 +1,708 @@
+import { CombinedAutocompleteProvider, Container, ProcessTerminal, Text, TUI, } from "@mariozechner/pi-tui";
+import { loadConfig } from "../config/config.js";
+import { getSlashCommands, helpText, parseCommand } from "./commands.js";
+import { ChatLog } from "./components/chat-log.js";
+import { CustomEditor } from "./components/custom-editor.js";
+import { createSelectList, createSettingsList, } from "./components/selectors.js";
+import { GatewayChatClient } from "./gateway-chat.js";
+import { editorTheme, theme } from "./theme/theme.js";
+function extractTextBlocks(content, opts) {
+    if (typeof content === "string")
+        return content.trim();
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const record = block;
+        if (record.type === "text" && typeof record.text === "string") {
+            parts.push(record.text);
+        }
+        if (opts?.includeThinking &&
+            record.type === "thinking" &&
+            typeof record.thinking === "string") {
+            parts.push(`[thinking]\n${record.thinking}`);
+        }
+    }
+    return parts.join("\n").trim();
+}
+function extractTextFromMessage(message, opts) {
+    if (!message || typeof message !== "object")
+        return "";
+    const record = message;
+    return extractTextBlocks(record.content, opts);
+}
+function formatTokens(total, context) {
+    if (!total && !context)
+        return "tokens ?";
+    if (!context)
+        return `tokens ${total ?? 0}`;
+    const pct = typeof total === "number" && context > 0
+        ? Math.min(999, Math.round((total / context) * 100))
+        : null;
+    return `tokens ${total ?? 0}/${context}${pct !== null ? ` (${pct}%)` : ""}`;
+}
+function asString(value, fallback = "") {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return fallback;
+}
+export async function runTui(opts) {
+    const config = loadConfig();
+    const defaultSession = (opts.session ?? config.session?.mainKey ?? "main").trim() || "main";
+    let currentSessionKey = defaultSession;
+    let currentSessionId = null;
+    let activeChatRunId = null;
+    const finalizedRuns = new Map();
+    let historyLoaded = false;
+    let isConnected = false;
+    let toolsExpanded = false;
+    let showThinking = false;
+    let deliverDefault = Boolean(opts.deliver);
+    let sessionInfo = {};
+    let lastCtrlCAt = 0;
+    const client = new GatewayChatClient({
+        url: opts.url,
+        token: opts.token,
+        password: opts.password,
+    });
+    const header = new Text("", 1, 0);
+    const status = new Text("", 1, 0);
+    const footer = new Text("", 1, 0);
+    const chatLog = new ChatLog();
+    const editor = new CustomEditor(editorTheme);
+    const overlay = new Container();
+    const root = new Container();
+    root.addChild(header);
+    root.addChild(overlay);
+    root.addChild(chatLog);
+    root.addChild(status);
+    root.addChild(footer);
+    root.addChild(editor);
+    const tui = new TUI(new ProcessTerminal());
+    tui.addChild(root);
+    tui.setFocus(editor);
+    const updateHeader = () => {
+        header.setText(theme.header(`clawdbot tui - ${client.connection.url} - session ${currentSessionKey}`));
+    };
+    const setStatus = (text) => {
+        status.setText(theme.dim(text));
+    };
+    const updateFooter = () => {
+        const connection = isConnected ? "connected" : "disconnected";
+        const sessionLabel = sessionInfo.displayName
+            ? `${currentSessionKey} (${sessionInfo.displayName})`
+            : currentSessionKey;
+        const modelLabel = sessionInfo.model ?? "unknown";
+        const tokens = formatTokens(sessionInfo.totalTokens ?? null, sessionInfo.contextTokens ?? null);
+        const think = sessionInfo.thinkingLevel ?? "off";
+        const verbose = sessionInfo.verboseLevel ?? "off";
+        const deliver = deliverDefault ? "on" : "off";
+        footer.setText(theme.dim(`${connection} | session ${sessionLabel} | model ${modelLabel} | think ${think} | verbose ${verbose} | ${tokens} | deliver ${deliver}`));
+    };
+    const closeOverlay = () => {
+        overlay.clear();
+        tui.setFocus(editor);
+    };
+    const openOverlay = (component) => {
+        overlay.clear();
+        overlay.addChild(component);
+        tui.setFocus(component);
+    };
+    const refreshSessionInfo = async () => {
+        try {
+            const result = await client.listSessions({
+                includeGlobal: false,
+                includeUnknown: false,
+            });
+            const entry = result.sessions.find((row) => row.key === currentSessionKey);
+            sessionInfo = {
+                thinkingLevel: entry?.thinkingLevel,
+                verboseLevel: entry?.verboseLevel,
+                model: entry?.model ?? result.defaults?.model ?? undefined,
+                contextTokens: entry?.contextTokens ?? result.defaults?.contextTokens,
+                totalTokens: entry?.totalTokens ?? null,
+                updatedAt: entry?.updatedAt ?? null,
+                displayName: entry?.displayName,
+            };
+        }
+        catch (err) {
+            chatLog.addSystem(`sessions list failed: ${String(err)}`);
+        }
+        updateFooter();
+        tui.requestRender();
+    };
+    const loadHistory = async () => {
+        try {
+            const history = await client.loadHistory({
+                sessionKey: currentSessionKey,
+                limit: opts.historyLimit ?? 200,
+            });
+            const record = history;
+            currentSessionId =
+                typeof record.sessionId === "string" ? record.sessionId : null;
+            sessionInfo.thinkingLevel =
+                record.thinkingLevel ?? sessionInfo.thinkingLevel;
+            chatLog.clearAll();
+            chatLog.addSystem(`session ${currentSessionKey}`);
+            for (const entry of record.messages ?? []) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const message = entry;
+                if (message.role === "user") {
+                    const text = extractTextFromMessage(message);
+                    if (text)
+                        chatLog.addUser(text);
+                    continue;
+                }
+                if (message.role === "assistant") {
+                    const text = extractTextFromMessage(message, {
+                        includeThinking: showThinking,
+                    });
+                    if (text)
+                        chatLog.finalizeAssistant(text);
+                    continue;
+                }
+                if (message.role === "toolResult") {
+                    const toolCallId = asString(message.toolCallId, "");
+                    const toolName = asString(message.toolName, "tool");
+                    const component = chatLog.startTool(toolCallId, toolName, {});
+                    component.setResult({
+                        content: Array.isArray(message.content)
+                            ? message.content
+                            : [],
+                        details: typeof message.details === "object" && message.details
+                            ? message.details
+                            : undefined,
+                    }, { isError: Boolean(message.isError) });
+                }
+            }
+            historyLoaded = true;
+        }
+        catch (err) {
+            chatLog.addSystem(`history failed: ${String(err)}`);
+        }
+        await refreshSessionInfo();
+        tui.requestRender();
+    };
+    const setSession = async (key) => {
+        currentSessionKey = key;
+        activeChatRunId = null;
+        currentSessionId = null;
+        historyLoaded = false;
+        updateHeader();
+        await loadHistory();
+    };
+    const abortActive = async () => {
+        if (!activeChatRunId) {
+            chatLog.addSystem("no active run");
+            tui.requestRender();
+            return;
+        }
+        try {
+            await client.abortChat({
+                sessionKey: currentSessionKey,
+                runId: activeChatRunId,
+            });
+            setStatus("aborted");
+        }
+        catch (err) {
+            chatLog.addSystem(`abort failed: ${String(err)}`);
+            setStatus("abort failed");
+        }
+        tui.requestRender();
+    };
+    const noteFinalizedRun = (runId) => {
+        finalizedRuns.set(runId, Date.now());
+        if (finalizedRuns.size <= 200)
+            return;
+        const keepUntil = Date.now() - 10 * 60 * 1000;
+        for (const [key, ts] of finalizedRuns) {
+            if (finalizedRuns.size <= 150)
+                break;
+            if (ts < keepUntil)
+                finalizedRuns.delete(key);
+        }
+        if (finalizedRuns.size > 200) {
+            for (const key of finalizedRuns.keys()) {
+                finalizedRuns.delete(key);
+                if (finalizedRuns.size <= 150)
+                    break;
+            }
+        }
+    };
+    const handleChatEvent = (payload) => {
+        if (!payload || typeof payload !== "object")
+            return;
+        const evt = payload;
+        if (evt.sessionKey !== currentSessionKey)
+            return;
+        if (finalizedRuns.has(evt.runId)) {
+            if (evt.state === "delta")
+                return;
+            if (evt.state === "final")
+                return;
+        }
+        if (evt.state === "delta") {
+            const text = extractTextFromMessage(evt.message, {
+                includeThinking: showThinking,
+            });
+            if (!text)
+                return;
+            chatLog.updateAssistant(text, evt.runId);
+            setStatus("streaming");
+        }
+        if (evt.state === "final") {
+            const text = extractTextFromMessage(evt.message, {
+                includeThinking: showThinking,
+            });
+            chatLog.finalizeAssistant(text || "(no output)", evt.runId);
+            noteFinalizedRun(evt.runId);
+            activeChatRunId = null;
+            setStatus("idle");
+        }
+        if (evt.state === "aborted") {
+            chatLog.addSystem("run aborted");
+            activeChatRunId = null;
+            setStatus("aborted");
+        }
+        if (evt.state === "error") {
+            chatLog.addSystem(`run error: ${evt.errorMessage ?? "unknown"}`);
+            activeChatRunId = null;
+            setStatus("error");
+        }
+        tui.requestRender();
+    };
+    const handleAgentEvent = (payload) => {
+        if (!payload || typeof payload !== "object")
+            return;
+        const evt = payload;
+        if (!currentSessionId || evt.runId !== currentSessionId)
+            return;
+        if (evt.stream === "tool") {
+            const data = evt.data ?? {};
+            const phase = asString(data.phase, "");
+            const toolCallId = asString(data.toolCallId, "");
+            const toolName = asString(data.name, "tool");
+            if (!toolCallId)
+                return;
+            if (phase === "start") {
+                chatLog.startTool(toolCallId, toolName, data.args);
+            }
+            else if (phase === "update") {
+                chatLog.updateToolResult(toolCallId, data.partialResult, {
+                    partial: true,
+                });
+            }
+            else if (phase === "result") {
+                chatLog.updateToolResult(toolCallId, data.result, {
+                    isError: Boolean(data.isError),
+                });
+            }
+            tui.requestRender();
+            return;
+        }
+        if (evt.stream === "job") {
+            const state = typeof evt.data?.state === "string" ? evt.data.state : "";
+            if (state === "started")
+                setStatus("running");
+            if (state === "done")
+                setStatus("idle");
+            if (state === "error")
+                setStatus("error");
+            tui.requestRender();
+        }
+    };
+    const openModelSelector = async () => {
+        try {
+            const models = await client.listModels();
+            if (models.length === 0) {
+                chatLog.addSystem("no models available");
+                tui.requestRender();
+                return;
+            }
+            const items = models.map((model) => ({
+                value: `${model.provider}/${model.id}`,
+                label: `${model.provider}/${model.id}`,
+                description: model.name && model.name !== model.id ? model.name : "",
+            }));
+            const selector = createSelectList(items, 9);
+            selector.onSelect = (item) => {
+                void (async () => {
+                    try {
+                        await client.patchSession({
+                            key: currentSessionKey,
+                            model: item.value,
+                        });
+                        chatLog.addSystem(`model set to ${item.value}`);
+                        await refreshSessionInfo();
+                    }
+                    catch (err) {
+                        chatLog.addSystem(`model set failed: ${String(err)}`);
+                    }
+                    closeOverlay();
+                    tui.requestRender();
+                })();
+            };
+            selector.onCancel = () => {
+                closeOverlay();
+                tui.requestRender();
+            };
+            openOverlay(selector);
+            tui.requestRender();
+        }
+        catch (err) {
+            chatLog.addSystem(`model list failed: ${String(err)}`);
+            tui.requestRender();
+        }
+    };
+    const openSessionSelector = async () => {
+        try {
+            const result = await client.listSessions({
+                includeGlobal: false,
+                includeUnknown: false,
+            });
+            const items = result.sessions.map((session) => ({
+                value: session.key,
+                label: session.displayName ?? session.key,
+                description: session.updatedAt
+                    ? new Date(session.updatedAt).toLocaleString()
+                    : "",
+            }));
+            const selector = createSelectList(items, 9);
+            selector.onSelect = (item) => {
+                void (async () => {
+                    closeOverlay();
+                    await setSession(item.value);
+                    tui.requestRender();
+                })();
+            };
+            selector.onCancel = () => {
+                closeOverlay();
+                tui.requestRender();
+            };
+            openOverlay(selector);
+            tui.requestRender();
+        }
+        catch (err) {
+            chatLog.addSystem(`sessions list failed: ${String(err)}`);
+            tui.requestRender();
+        }
+    };
+    const openSettings = () => {
+        const items = [
+            {
+                id: "deliver",
+                label: "Deliver replies",
+                currentValue: deliverDefault ? "on" : "off",
+                values: ["off", "on"],
+            },
+            {
+                id: "tools",
+                label: "Tool output",
+                currentValue: toolsExpanded ? "expanded" : "collapsed",
+                values: ["collapsed", "expanded"],
+            },
+            {
+                id: "thinking",
+                label: "Show thinking",
+                currentValue: showThinking ? "on" : "off",
+                values: ["off", "on"],
+            },
+        ];
+        const settings = createSettingsList(items, (id, value) => {
+            if (id === "deliver") {
+                deliverDefault = value === "on";
+                updateFooter();
+            }
+            if (id === "tools") {
+                toolsExpanded = value === "expanded";
+                chatLog.setToolsExpanded(toolsExpanded);
+            }
+            if (id === "thinking") {
+                showThinking = value === "on";
+                void loadHistory();
+            }
+            tui.requestRender();
+        }, () => {
+            closeOverlay();
+            tui.requestRender();
+        });
+        openOverlay(settings);
+        tui.requestRender();
+    };
+    const handleCommand = async (raw) => {
+        const { name, args } = parseCommand(raw);
+        if (!name)
+            return;
+        switch (name) {
+            case "help":
+                chatLog.addSystem(helpText());
+                break;
+            case "status":
+                try {
+                    const status = await client.getStatus();
+                    chatLog.addSystem(typeof status === "string"
+                        ? status
+                        : JSON.stringify(status, null, 2));
+                }
+                catch (err) {
+                    chatLog.addSystem(`status failed: ${String(err)}`);
+                }
+                break;
+            case "session":
+                if (!args) {
+                    await openSessionSelector();
+                }
+                else {
+                    await setSession(args);
+                }
+                break;
+            case "sessions":
+                await openSessionSelector();
+                break;
+            case "model":
+                if (!args) {
+                    await openModelSelector();
+                }
+                else {
+                    try {
+                        await client.patchSession({
+                            key: currentSessionKey,
+                            model: args,
+                        });
+                        chatLog.addSystem(`model set to ${args}`);
+                        await refreshSessionInfo();
+                    }
+                    catch (err) {
+                        chatLog.addSystem(`model set failed: ${String(err)}`);
+                    }
+                }
+                break;
+            case "models":
+                await openModelSelector();
+                break;
+            case "think":
+                if (!args) {
+                    chatLog.addSystem("usage: /think <off|minimal|low|medium|high>");
+                    break;
+                }
+                try {
+                    await client.patchSession({
+                        key: currentSessionKey,
+                        thinkingLevel: args,
+                    });
+                    chatLog.addSystem(`thinking set to ${args}`);
+                    await refreshSessionInfo();
+                }
+                catch (err) {
+                    chatLog.addSystem(`think failed: ${String(err)}`);
+                }
+                break;
+            case "verbose":
+                if (!args) {
+                    chatLog.addSystem("usage: /verbose <on|off>");
+                    break;
+                }
+                try {
+                    await client.patchSession({
+                        key: currentSessionKey,
+                        verboseLevel: args,
+                    });
+                    chatLog.addSystem(`verbose set to ${args}`);
+                    await refreshSessionInfo();
+                }
+                catch (err) {
+                    chatLog.addSystem(`verbose failed: ${String(err)}`);
+                }
+                break;
+            case "elevated":
+                if (!args) {
+                    chatLog.addSystem("usage: /elevated <on|off>");
+                    break;
+                }
+                try {
+                    await client.patchSession({
+                        key: currentSessionKey,
+                        elevatedLevel: args,
+                    });
+                    chatLog.addSystem(`elevated set to ${args}`);
+                    await refreshSessionInfo();
+                }
+                catch (err) {
+                    chatLog.addSystem(`elevated failed: ${String(err)}`);
+                }
+                break;
+            case "activation":
+                if (!args) {
+                    chatLog.addSystem("usage: /activation <mention|always>");
+                    break;
+                }
+                try {
+                    await client.patchSession({
+                        key: currentSessionKey,
+                        groupActivation: args === "always" ? "always" : "mention",
+                    });
+                    chatLog.addSystem(`activation set to ${args}`);
+                    await refreshSessionInfo();
+                }
+                catch (err) {
+                    chatLog.addSystem(`activation failed: ${String(err)}`);
+                }
+                break;
+            case "deliver":
+                if (!args) {
+                    chatLog.addSystem("usage: /deliver <on|off>");
+                    break;
+                }
+                deliverDefault = args === "on";
+                updateFooter();
+                chatLog.addSystem(`deliver ${deliverDefault ? "on" : "off"}`);
+                break;
+            case "new":
+            case "reset":
+                try {
+                    await client.resetSession(currentSessionKey);
+                    chatLog.addSystem(`session ${currentSessionKey} reset`);
+                    await loadHistory();
+                }
+                catch (err) {
+                    chatLog.addSystem(`reset failed: ${String(err)}`);
+                }
+                break;
+            case "abort":
+                await abortActive();
+                break;
+            case "settings":
+                openSettings();
+                break;
+            case "exit":
+            case "quit":
+                client.stop();
+                tui.stop();
+                process.exit(0);
+                break;
+            default:
+                chatLog.addSystem(`unknown command: /${name}`);
+                break;
+        }
+        tui.requestRender();
+    };
+    const sendMessage = async (text) => {
+        try {
+            chatLog.addUser(text);
+            tui.requestRender();
+            setStatus("sending");
+            const { runId } = await client.sendChat({
+                sessionKey: currentSessionKey,
+                message: text,
+                thinking: opts.thinking,
+                deliver: deliverDefault,
+                timeoutMs: opts.timeoutMs,
+            });
+            activeChatRunId = runId;
+            setStatus("waiting");
+        }
+        catch (err) {
+            chatLog.addSystem(`send failed: ${String(err)}`);
+            setStatus("error");
+        }
+        tui.requestRender();
+    };
+    editor.setAutocompleteProvider(new CombinedAutocompleteProvider(getSlashCommands(), process.cwd()));
+    editor.onSubmit = (text) => {
+        const value = text.trim();
+        editor.setText("");
+        if (!value)
+            return;
+        if (value.startsWith("/")) {
+            void handleCommand(value);
+            return;
+        }
+        void sendMessage(value);
+    };
+    editor.onEscape = () => {
+        void abortActive();
+    };
+    editor.onCtrlC = () => {
+        const now = Date.now();
+        if (editor.getText().trim().length > 0) {
+            editor.setText("");
+            setStatus("cleared input");
+            tui.requestRender();
+            return;
+        }
+        if (now - lastCtrlCAt < 1000) {
+            client.stop();
+            tui.stop();
+            process.exit(0);
+        }
+        lastCtrlCAt = now;
+        setStatus("press ctrl+c again to exit");
+        tui.requestRender();
+    };
+    editor.onCtrlD = () => {
+        client.stop();
+        tui.stop();
+        process.exit(0);
+    };
+    editor.onCtrlO = () => {
+        toolsExpanded = !toolsExpanded;
+        chatLog.setToolsExpanded(toolsExpanded);
+        setStatus(toolsExpanded ? "tools expanded" : "tools collapsed");
+        tui.requestRender();
+    };
+    editor.onCtrlL = () => {
+        void openModelSelector();
+    };
+    editor.onCtrlP = () => {
+        void openSessionSelector();
+    };
+    editor.onCtrlT = () => {
+        showThinking = !showThinking;
+        void loadHistory();
+    };
+    client.onEvent = (evt) => {
+        if (evt.event === "chat")
+            handleChatEvent(evt.payload);
+        if (evt.event === "agent")
+            handleAgentEvent(evt.payload);
+    };
+    client.onConnected = () => {
+        isConnected = true;
+        setStatus("connected");
+        updateHeader();
+        if (!historyLoaded) {
+            void loadHistory().then(() => {
+                chatLog.addSystem("gateway connected");
+                tui.requestRender();
+            });
+        }
+        else {
+            chatLog.addSystem("gateway reconnected");
+        }
+        updateFooter();
+        tui.requestRender();
+    };
+    client.onDisconnected = (reason) => {
+        isConnected = false;
+        chatLog.addSystem(`gateway disconnected: ${reason || "closed"}`);
+        setStatus("disconnected");
+        updateFooter();
+        tui.requestRender();
+    };
+    client.onGap = (info) => {
+        chatLog.addSystem(`event gap: expected ${info.expected}, got ${info.received}`);
+        tui.requestRender();
+    };
+    updateHeader();
+    setStatus("connecting");
+    updateFooter();
+    chatLog.addSystem("connecting...");
+    tui.start();
+    client.start();
+}