@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/tui/tui-local-shell.js

@@ -9,10 +9,12 @@ export function createLocalShellRunner(deps) {
     const env = deps.env ?? process.env;
     const maxChars = deps.maxOutputChars ?? 40_000;
     const ensureLocalExecAllowed = async () => {
-        if (localExecAllowed)
+        if (localExecAllowed) {
             return true;
-        if (localExecAsked)
+        }
+        if (localExecAsked) {
             return false;
+        }
         localExecAsked = true;
         return await new Promise((resolve) => {
             deps.chatLog.addSystem("Allow local shell commands for this session?");
@@ -49,20 +51,28 @@ export function createLocalShellRunner(deps) {
         const cmd = line.slice(1);
         // NOTE: A lone '!' is handled by the submit handler as a normal message.
         // Keep this guard anyway in case this is called directly.
-        if (cmd === "")
+        if (cmd === "") {
             return;
+        }
         if (localExecAsked && !localExecAllowed) {
             deps.chatLog.addSystem("local shell: not enabled for this session");
             deps.tui.requestRender();
             return;
         }
         const allowed = await ensureLocalExecAllowed();
-        if (!allowed)
+        if (!allowed) {
             return;
+        }
         deps.chatLog.addSystem(`[local] $ ${cmd}`);
         deps.tui.requestRender();
+        const appendWithCap = (text, chunk) => {
+            const combined = text + chunk;
+            return combined.length > maxChars ? combined.slice(-maxChars) : combined;
+        };
         await new Promise((resolve) => {
             const child = spawnCommand(cmd, {
+                // Intentionally a shell: this is an operator-only local TUI feature (prefixed with `!`)
+                // and is gated behind an explicit in-session approval prompt.
                 shell: true,
                 cwd: getCwd(),
                 env,
@@ -70,10 +80,10 @@ export function createLocalShellRunner(deps) {
             let stdout = "";
             let stderr = "";
             child.stdout.on("data", (buf) => {
-                stdout += buf.toString("utf8");
+                stdout = appendWithCap(stdout, buf.toString("utf8"));
             });
             child.stderr.on("data", (buf) => {
-                stderr += buf.toString("utf8");
+                stderr = appendWithCap(stderr, buf.toString("utf8"));
             });
             child.on("close", (code, signal) => {
                 const combined = (stdout + (stderr ? (stdout ? "\n" : "") + stderr : ""))

package/dist/tui/tui.js

@@ -1,4 +1,4 @@
-import { CombinedAutocompleteProvider, Container, Loader, ProcessTerminal, Text, TUI, truncateToWidth, } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Key, Loader, matchesKey, ProcessTerminal, Text, TUI, } from "@mariozechner/pi-tui";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { loadConfig } from "../config/config.js";
 import { buildAgentMainSessionKey, normalizeAgentId, normalizeMainKey, parseAgentSessionKey, } from "../routing/session-key.js";
@@ -11,9 +11,9 @@ import { createCommandHandlers } from "./tui-command-handlers.js";
 import { createEventHandlers } from "./tui-event-handlers.js";
 import { formatTokens } from "./tui-formatters.js";
 import { createLocalShellRunner } from "./tui-local-shell.js";
-import { buildWaitingStatusMessage, defaultWaitingPhrases } from "./tui-waiting.js";
 import { createOverlayHandlers } from "./tui-overlays.js";
 import { createSessionActions } from "./tui-session-actions.js";
+import { buildWaitingStatusMessage, defaultWaitingPhrases } from "./tui-waiting.js";
 export { resolveFinalAssistantText } from "./tui-formatters.js";
 export function createEditorSubmitHandler(params) {
     return (text) => {
@@ -21,8 +21,9 @@ export function createEditorSubmitHandler(params) {
         const value = raw.trim();
         params.editor.setText("");
         // Keep previous behavior: ignore empty/whitespace-only submissions.
-        if (!value)
+        if (!value) {
             return;
+        }
         // Bash mode: only if the very first character is '!' and it's not just '!'.
         // IMPORTANT: use the raw (untrimmed) text so leading spaces do NOT trigger.
         // Per requirement: a lone '!' should be treated as a normal message.
@@ -40,6 +41,140 @@ export function createEditorSubmitHandler(params) {
         void params.sendMessage(value);
     };
 }
+export function shouldEnableWindowsGitBashPasteFallback(params) {
+    const platform = params?.platform ?? process.platform;
+    const env = params?.env ?? process.env;
+    const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+    // Some macOS terminals emit multiline paste as rapid single-line submits.
+    // Enable burst coalescing so pasted blocks stay as one user message.
+    if (platform === "darwin") {
+        if (termProgram.includes("iterm") || termProgram.includes("apple_terminal")) {
+            return true;
+        }
+        return false;
+    }
+    if (platform !== "win32") {
+        return false;
+    }
+    const msystem = (env.MSYSTEM ?? "").toUpperCase();
+    const shell = env.SHELL ?? "";
+    if (msystem.startsWith("MINGW") || msystem.startsWith("MSYS")) {
+        return true;
+    }
+    if (shell.toLowerCase().includes("bash")) {
+        return true;
+    }
+    return termProgram.includes("mintty");
+}
+export function createSubmitBurstCoalescer(params) {
+    const windowMs = Math.max(1, params.burstWindowMs ?? 50);
+    const now = params.now ?? (() => Date.now());
+    const setTimer = params.setTimer ?? setTimeout;
+    const clearTimer = params.clearTimer ?? clearTimeout;
+    let pending = null;
+    let pendingAt = 0;
+    let flushTimer = null;
+    const clearFlushTimer = () => {
+        if (!flushTimer) {
+            return;
+        }
+        clearTimer(flushTimer);
+        flushTimer = null;
+    };
+    const flushPending = () => {
+        if (pending === null) {
+            return;
+        }
+        const value = pending;
+        pending = null;
+        pendingAt = 0;
+        clearFlushTimer();
+        params.submit(value);
+    };
+    const scheduleFlush = () => {
+        clearFlushTimer();
+        flushTimer = setTimer(() => {
+            flushPending();
+        }, windowMs);
+    };
+    return (value) => {
+        if (!params.enabled) {
+            params.submit(value);
+            return;
+        }
+        if (value.includes("\n")) {
+            flushPending();
+            params.submit(value);
+            return;
+        }
+        const ts = now();
+        if (pending === null) {
+            pending = value;
+            pendingAt = ts;
+            scheduleFlush();
+            return;
+        }
+        if (ts - pendingAt <= windowMs) {
+            pending = `${pending}\n${value}`;
+            pendingAt = ts;
+            scheduleFlush();
+            return;
+        }
+        flushPending();
+        pending = value;
+        pendingAt = ts;
+        scheduleFlush();
+    };
+}
+export function resolveTuiSessionKey(params) {
+    const trimmed = (params.raw ?? "").trim();
+    if (!trimmed) {
+        if (params.sessionScope === "global") {
+            return "global";
+        }
+        return buildAgentMainSessionKey({
+            agentId: params.currentAgentId,
+            mainKey: params.sessionMainKey,
+        });
+    }
+    if (trimmed === "global" || trimmed === "unknown") {
+        return trimmed;
+    }
+    if (trimmed.startsWith("agent:")) {
+        return trimmed;
+    }
+    return `agent:${params.currentAgentId}:${trimmed}`;
+}
+export function resolveGatewayDisconnectState(reason) {
+    const reasonLabel = reason?.trim() ? reason.trim() : "closed";
+    if (/pairing required/i.test(reasonLabel)) {
+        return {
+            connectionStatus: `gateway disconnected: ${reasonLabel}`,
+            activityStatus: "pairing required: run poolbot devices list",
+            pairingHint: "Pairing required. Run `poolbot devices list`, approve your request ID, then reconnect.",
+        };
+    }
+    return {
+        connectionStatus: `gateway disconnected: ${reasonLabel}`,
+        activityStatus: "idle",
+    };
+}
+export function createBackspaceDeduper(params) {
+    const dedupeWindowMs = Math.max(0, Math.floor(params?.dedupeWindowMs ?? 8));
+    const now = params?.now ?? (() => Date.now());
+    let lastBackspaceAt = -1;
+    return (data) => {
+        if (!matchesKey(data, Key.backspace)) {
+            return data;
+        }
+        const ts = now();
+        if (lastBackspaceAt >= 0 && ts - lastBackspaceAt <= dedupeWindowMs) {
+            return "";
+        }
+        lastBackspaceAt = ts;
+        return data;
+    };
+}
 export async function runTui(opts) {
     const config = loadConfig();
     const initialSessionInput = (opts.session ?? "").trim();
@@ -58,6 +193,8 @@ export async function runTui(opts) {
     let wasDisconnected = false;
     let toolsExpanded = false;
     let showThinking = false;
+    let pairingHintShown = false;
+    const localRunIds = new Set();
     const deliverDefault = opts.deliver ?? false;
     const autoMessage = opts.message?.trim();
     let autoMessageSent = false;
@@ -185,12 +322,39 @@ export async function runTui(opts) {
             lastCtrlCAt = value;
         },
     };
+    const noteLocalRunId = (runId) => {
+        if (!runId) {
+            return;
+        }
+        localRunIds.add(runId);
+        if (localRunIds.size > 200) {
+            const [first] = localRunIds;
+            if (first) {
+                localRunIds.delete(first);
+            }
+        }
+    };
+    const forgetLocalRunId = (runId) => {
+        localRunIds.delete(runId);
+    };
+    const isLocalRunId = (runId) => localRunIds.has(runId);
+    const clearLocalRunIds = () => {
+        localRunIds.clear();
+    };
     const client = new GatewayChatClient({
         url: opts.url,
         token: opts.token,
         password: opts.password,
     });
     const tui = new TUI(new ProcessTerminal());
+    const dedupeBackspace = createBackspaceDeduper();
+    tui.addInputListener((data) => {
+        const next = dedupeBackspace(data);
+        if (next.length === 0) {
+            return { consume: true };
+        }
+        return { data: next };
+    });
     const header = new Text("", 1, 0);
     const statusContainer = new Container();
     const footer = new Text("", 1, 0);
@@ -212,8 +376,9 @@ export async function runTui(opts) {
     tui.addChild(root);
     tui.setFocus(editor);
     const formatSessionKey = (key) => {
-        if (key === "global" || key === "unknown")
+        if (key === "global" || key === "unknown") {
             return key;
+        }
         const parsed = parseAgentSessionKey(key);
         return parsed?.rest ?? key;
     };
@@ -222,43 +387,35 @@ export async function runTui(opts) {
         return name ? `${id} (${name})` : id;
     };
     const resolveSessionKey = (raw) => {
-        const trimmed = (raw ?? "").trim();
-        if (sessionScope === "global")
-            return "global";
-        if (!trimmed) {
-            return buildAgentMainSessionKey({
-                agentId: currentAgentId,
-                mainKey: sessionMainKey,
-            });
-        }
-        if (trimmed === "global" || trimmed === "unknown")
-            return trimmed;
-        if (trimmed.startsWith("agent:"))
-            return trimmed;
-        return `agent:${currentAgentId}:${trimmed}`;
+        return resolveTuiSessionKey({
+            raw,
+            sessionScope,
+            currentAgentId,
+            sessionMainKey,
+        });
     };
     currentSessionKey = resolveSessionKey(initialSessionInput);
-    const getContentWidth = () => Math.max(20, (tui.terminal.columns ?? 80) - 2); // paddingX=1 each side
     const updateHeader = () => {
         const sessionLabel = formatSessionKey(currentSessionKey);
         const agentLabel = formatAgentLabel(currentAgentId);
-        const raw = `poolbot tui - ${client.connection.url} - agent ${agentLabel} - session ${sessionLabel}`;
-        header.setText(theme.header(truncateToWidth(raw, getContentWidth())));
+        header.setText(theme.header(`poolbot tui - ${client.connection.url} - agent ${agentLabel} - session ${sessionLabel}`));
     };
     const busyStates = new Set(["sending", "waiting", "streaming", "running"]);
     let statusText = null;
     let statusLoader = null;
     const formatElapsed = (startMs) => {
         const totalSeconds = Math.max(0, Math.floor((Date.now() - startMs) / 1000));
-        if (totalSeconds < 60)
+        if (totalSeconds < 60) {
             return `${totalSeconds}s`;
+        }
         const minutes = Math.floor(totalSeconds / 60);
         const seconds = totalSeconds % 60;
         return `${minutes}m ${seconds}s`;
     };
     const ensureStatusText = () => {
-        if (statusText)
+        if (statusText) {
             return;
+        }
         statusContainer.clear();
         statusLoader?.stop();
         statusLoader = null;
@@ -266,8 +423,9 @@ export async function runTui(opts) {
         statusContainer.addChild(statusText);
     };
     const ensureStatusLoader = () => {
-        if (statusLoader)
+        if (statusLoader) {
             return;
+        }
         statusContainer.clear();
         statusText = null;
         statusLoader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.bold(theme.accentSoft(text)), "");
@@ -277,44 +435,45 @@ export async function runTui(opts) {
     let waitingTimer = null;
     let waitingPhrase = null;
     const updateBusyStatusMessage = () => {
-        if (!statusLoader || !statusStartedAt)
+        if (!statusLoader || !statusStartedAt) {
             return;
+        }
         const elapsed = formatElapsed(statusStartedAt);
-        // Truncate status messages to terminal width to prevent TUI crash
-        // (Loader adds spinner + space = 2 visible chars before the message)
-        const maxMsgWidth = Math.max(10, getContentWidth() - 4);
         if (activityStatus === "waiting") {
             waitingTick++;
-            const msg = buildWaitingStatusMessage({
+            statusLoader.setMessage(buildWaitingStatusMessage({
                 theme,
                 tick: waitingTick,
                 elapsed,
                 connectionStatus,
                 phrases: waitingPhrase ? [waitingPhrase] : undefined,
-            });
-            statusLoader.setMessage(truncateToWidth(msg, maxMsgWidth));
+            }));
             return;
         }
-        statusLoader.setMessage(truncateToWidth(`${activityStatus} • ${elapsed} | ${connectionStatus}`, maxMsgWidth));
+        statusLoader.setMessage(`${activityStatus} • ${elapsed} | ${connectionStatus}`);
     };
     const startStatusTimer = () => {
-        if (statusTimer)
+        if (statusTimer) {
             return;
+        }
         statusTimer = setInterval(() => {
-            if (!busyStates.has(activityStatus))
+            if (!busyStates.has(activityStatus)) {
                 return;
+            }
             updateBusyStatusMessage();
         }, 1000);
     };
     const stopStatusTimer = () => {
-        if (!statusTimer)
+        if (!statusTimer) {
             return;
+        }
         clearInterval(statusTimer);
         statusTimer = null;
     };
     const startWaitingTimer = () => {
-        if (waitingTimer)
+        if (waitingTimer) {
             return;
+        }
         // Pick a phrase once per waiting session.
         if (!waitingPhrase) {
             const idx = Math.floor(Math.random() * defaultWaitingPhrases.length);
@@ -322,14 +481,16 @@ export async function runTui(opts) {
         }
         waitingTick = 0;
         waitingTimer = setInterval(() => {
-            if (activityStatus !== "waiting")
+            if (activityStatus !== "waiting") {
                 return;
+            }
             updateBusyStatusMessage();
         }, 120);
     };
     const stopWaitingTimer = () => {
-        if (!waitingTimer)
+        if (!waitingTimer) {
             return;
+        }
         clearInterval(waitingTimer);
         waitingTimer = null;
         waitingPhrase = null;
@@ -366,8 +527,9 @@ export async function runTui(opts) {
     const setConnectionStatus = (text, ttlMs) => {
         connectionStatus = text;
         renderStatus();
-        if (statusTimeout)
+        if (statusTimeout) {
             clearTimeout(statusTimeout);
+        }
         if (ttlMs && ttlMs > 0) {
             statusTimeout = setTimeout(() => {
                 connectionStatus = isConnected ? "connected" : "disconnected";
@@ -404,12 +566,13 @@ export async function runTui(opts) {
             reasoningLabel,
             tokens,
         ].filter(Boolean);
-        footer.setText(theme.dim(truncateToWidth(footerParts.join(" | "), getContentWidth())));
+        footer.setText(theme.dim(footerParts.join(" | ")));
     };
     const { openOverlay, closeOverlay } = createOverlayHandlers(tui, editor);
     const initialSessionAgentId = (() => {
-        if (!initialSessionInput)
+        if (!initialSessionInput) {
             return null;
+        }
         const parsed = parseAgentSessionKey(initialSessionInput);
         return parsed ? normalizeAgentId(parsed.agentId) : null;
     })();
@@ -427,14 +590,19 @@ export async function runTui(opts) {
         updateFooter,
         updateAutocompleteProvider,
         setActivityStatus,
+        clearLocalRunIds,
     });
-    const { refreshAgents, refreshSessionInfo, loadHistory, setSession, abortActive } = sessionActions;
+    const { refreshAgents, refreshSessionInfo, applySessionInfoFromPatch, loadHistory, setSession, abortActive, } = sessionActions;
     const { handleChatEvent, handleAgentEvent } = createEventHandlers({
         chatLog,
         tui,
         state,
         setActivityStatus,
         refreshSessionInfo,
+        loadHistory,
+        isLocalRunId,
+        forgetLocalRunId,
+        clearLocalRunIds,
     });
     const { handleCommand, sendMessage, openModelSelector, openAgentSelector, openSessionSelector } = createCommandHandlers({
         client,
@@ -446,12 +614,15 @@ export async function runTui(opts) {
         openOverlay,
         closeOverlay,
         refreshSessionInfo,
+        applySessionInfoFromPatch,
         loadHistory,
         setSession,
         refreshAgents,
         abortActive,
         setActivityStatus,
         formatSessionKey,
+        noteLocalRunId,
+        forgetLocalRunId,
     });
     const { runLocalShellLine } = createLocalShellRunner({
         chatLog,
@@ -460,12 +631,16 @@ export async function runTui(opts) {
         closeOverlay,
     });
     updateAutocompleteProvider();
-    editor.onSubmit = createEditorSubmitHandler({
+    const submitHandler = createEditorSubmitHandler({
         editor,
         handleCommand,
         sendMessage,
         handleBangLine: runLocalShellLine,
     });
+    editor.onSubmit = createSubmitBurstCoalescer({
+        submit: submitHandler,
+        enabled: shouldEnableWindowsGitBashPasteFallback(),
+    });
     editor.onEscape = () => {
         void abortActive();
     };
@@ -511,13 +686,16 @@ export async function runTui(opts) {
         void loadHistory();
     };
     client.onEvent = (evt) => {
-        if (evt.event === "chat")
+        if (evt.event === "chat") {
             handleChatEvent(evt.payload);
-        if (evt.event === "agent")
+        }
+        if (evt.event === "agent") {
             handleAgentEvent(evt.payload);
+        }
     };
     client.onConnected = () => {
         isConnected = true;
+        pairingHintShown = false;
         const reconnected = wasDisconnected;
         wasDisconnected = false;
         setConnectionStatus("connected");
@@ -539,9 +717,13 @@ export async function runTui(opts) {
         isConnected = false;
         wasDisconnected = true;
         historyLoaded = false;
-        const reasonLabel = reason?.trim() ? reason.trim() : "closed";
-        setConnectionStatus(`gateway disconnected: ${reasonLabel}`, 5000);
-        setActivityStatus("idle");
+        const disconnectState = resolveGatewayDisconnectState(reason);
+        setConnectionStatus(disconnectState.connectionStatus, 5000);
+        setActivityStatus(disconnectState.activityStatus);
+        if (disconnectState.pairingHint && !pairingHintShown) {
+            pairingHintShown = true;
+            chatLog.addSystem(disconnectState.pairingHint);
+        }
         updateFooter();
         tui.requestRender();
     };
@@ -554,4 +736,10 @@ export async function runTui(opts) {
     updateFooter();
     tui.start();
     client.start();
+    await new Promise((resolve) => {
+        const finish = () => resolve();
+        process.once("exit", finish);
+        process.once("SIGINT", finish);
+        process.once("SIGTERM", finish);
+    });
 }

package/dist/utils/account-id.js

@@ -1,6 +1,4 @@
+import { normalizeOptionalAccountId } from "../routing/account-id.js";
 export function normalizeAccountId(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed || undefined;
+    return normalizeOptionalAccountId(value);
 }

package/dist/utils/boolean.js

@@ -3,20 +3,25 @@ const DEFAULT_FALSY = ["false", "0", "no", "off"];
 const DEFAULT_TRUTHY_SET = new Set(DEFAULT_TRUTHY);
 const DEFAULT_FALSY_SET = new Set(DEFAULT_FALSY);
 export function parseBooleanValue(value, options = {}) {
-    if (typeof value === "boolean")
+    if (typeof value === "boolean") {
         return value;
-    if (typeof value !== "string")
+    }
+    if (typeof value !== "string") {
         return undefined;
+    }
     const normalized = value.trim().toLowerCase();
-    if (!normalized)
+    if (!normalized) {
         return undefined;
+    }
     const truthy = options.truthy ?? DEFAULT_TRUTHY;
     const falsy = options.falsy ?? DEFAULT_FALSY;
     const truthySet = truthy === DEFAULT_TRUTHY ? DEFAULT_TRUTHY_SET : new Set(truthy);
     const falsySet = falsy === DEFAULT_FALSY ? DEFAULT_FALSY_SET : new Set(falsy);
-    if (truthySet.has(normalized))
+    if (truthySet.has(normalized)) {
         return true;
-    if (falsySet.has(normalized))
+    }
+    if (falsySet.has(normalized)) {
         return false;
+    }
     return undefined;
 }

package/dist/utils/directive-tags.js

@@ -6,6 +6,17 @@ function normalizeDirectiveWhitespace(text) {
         .replace(/[ \t]*\n[ \t]*/g, "\n")
         .trim();
 }
+export function stripInlineDirectiveTagsForDisplay(text) {
+    if (!text) {
+        return { text, changed: false };
+    }
+    const withoutAudio = text.replace(AUDIO_TAG_RE, "");
+    const stripped = withoutAudio.replace(REPLY_TAG_RE, "");
+    return {
+        text: stripped,
+        changed: stripped !== text,
+    };
+}
 export function parseInlineDirectives(text, options = {}) {
     const { currentMessageId, stripAudioTag = true, stripReplyTags = true } = options;
     if (!text) {

package/dist/utils/mask-api-key.js

@@ -0,0 +1,10 @@
+export const maskApiKey = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "missing";
+    }
+    if (trimmed.length <= 16) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, 8)}...${trimmed.slice(-8)}`;
+};