@poolzin/pool-bot 2026.3.9 → 2026.3.10

package/dist/tui/theme/theme-detection.js

@@ -0,0 +1,226 @@
+/**
+ * Theme detection and light/dark mode utilities
+ *
+ * Features:
+ * - Automatic light/dark detection via environment variables
+ * - WCAG contrast ratio calculation
+ * - COLORFGBG parsing
+ * - Manual theme override via POOLBOT_THEME
+ */
+import { createSubsystemLogger } from "../../logging/subsystem.js";
+const themeLog = createSubsystemLogger("theme");
+/**
+ * Detect theme mode from environment
+ *
+ * Detection order:
+ * 1. POOLBOT_THEME environment variable
+ * 2. COLORFGBG environment variable (terminal background color)
+ * 3. Default to "dark"
+ */
+export function detectThemeMode() {
+    // Check for explicit theme override
+    const envTheme = process.env.POOLBOT_THEME?.toLowerCase();
+    if (envTheme === "light" || envTheme === "dark") {
+        themeLog.debug(`Theme set via POOLBOT_THEME: ${envTheme}`);
+        return envTheme;
+    }
+    // Try to detect from COLORFGBG
+    const colorFgbg = process.env.COLORFGBG;
+    if (colorFgbg) {
+        const detected = parseColorFgbg(colorFgbg);
+        if (detected) {
+            themeLog.debug(`Theme detected from COLORFGBG: ${detected}`);
+            return detected;
+        }
+    }
+    // Default to dark mode
+    themeLog.debug("Theme detection: defaulting to dark");
+    return "dark";
+}
+/**
+ * Parse COLORFGBG environment variable
+ *
+ * Format: "fg;bg" or "fg:bg" where colors are 0-15 or RGB hex
+ * Examples:
+ *   "0;15" - black on white (light mode)
+ *   "15;0" - white on black (dark mode)
+ *   "rgb:0000/0000/0000;rgb:ffff/ffff/ffff" - RGB values
+ */
+export function parseColorFgbg(colorFgbg) {
+    try {
+        // Split by semicolon or colon
+        const parts = colorFgbg.split(/[;:]/);
+        if (parts.length < 2)
+            return null;
+        const bgPart = parts[1] ?? "";
+        // Check for RGB format: rgb:R/G/B
+        if (bgPart.startsWith("rgb:")) {
+            const rgb = parseRgbHex(bgPart);
+            if (rgb) {
+                return isLightColor(rgb) ? "light" : "dark";
+            }
+            return null;
+        }
+        // Check for numeric color (0-15)
+        const colorNum = parseInt(bgPart, 10);
+        if (!isNaN(colorNum)) {
+            // Standard 16-color palette:
+            // 0-7: dark colors, 8-15: light colors
+            if (colorNum >= 0 && colorNum <= 7) {
+                return "dark";
+            }
+            if (colorNum >= 8 && colorNum <= 15) {
+                return "light";
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse RGB hex format: rgb:RRRR/GGGG/BBBB or rgb:RR/GG/BB
+ */
+export function parseRgbHex(rgbStr) {
+    try {
+        // Remove "rgb:" prefix
+        const parts = rgbStr.replace("rgb:", "").split("/");
+        if (parts.length !== 3)
+            return null;
+        // Parse each component
+        const parseComponent = (hex) => {
+            const len = hex.length;
+            if (len === 2) {
+                // 8-bit color
+                return parseInt(hex, 16);
+            }
+            if (len === 4) {
+                // 16-bit color, take high byte
+                return parseInt(hex.slice(0, 2), 16);
+            }
+            return 0;
+        };
+        return {
+            r: parseComponent(parts[0] ?? "0"),
+            g: parseComponent(parts[1] ?? "0"),
+            b: parseComponent(parts[2] ?? "0"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate relative luminance of an RGB color (WCAG formula)
+ * https://www.w3.org/TR/WCAG20/#relativeluminancedef
+ */
+export function relativeLuminance(rgb) {
+    // Normalize to 0-1
+    const rsRGB = rgb.r / 255;
+    const gsRGB = rgb.g / 255;
+    const bsRGB = rgb.b / 255;
+    // Apply gamma correction
+    const r = rsRGB <= 0.03928 ? rsRGB / 12.92 : Math.pow((rsRGB + 0.055) / 1.055, 2.4);
+    const g = gsRGB <= 0.03928 ? gsRGB / 12.92 : Math.pow((gsRGB + 0.055) / 1.055, 2.4);
+    const b = bsRGB <= 0.03928 ? bsRGB / 12.92 : Math.pow((bsRGB + 0.055) / 1.055, 2.4);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+/**
+ * Calculate contrast ratio between two colors (WCAG formula)
+ * https://www.w3.org/TR/WCAG20/#contrast-ratiodef
+ */
+export function contrastRatio(color1, color2) {
+    const lum1 = relativeLuminance(color1);
+    const lum2 = relativeLuminance(color2);
+    const lighter = Math.max(lum1, lum2);
+    const darker = Math.min(lum1, lum2);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+/**
+ * Determine if a color is "light" based on its luminance
+ * Uses threshold of 0.5 (midpoint between black and white)
+ */
+export function isLightColor(rgb) {
+    const luminance = relativeLuminance(rgb);
+    return luminance > 0.5;
+}
+/**
+ * Check if contrast ratio meets WCAG AA standards
+ * AA requires 4.5:1 for normal text, 3:1 for large text
+ */
+export function meetsContrastStandard(fg, bg, level = "AA", largeText = false) {
+    const ratio = contrastRatio(fg, bg);
+    if (level === "AAA") {
+        return largeText ? ratio >= 4.5 : ratio >= 7;
+    }
+    // AA level
+    return largeText ? ratio >= 3 : ratio >= 4.5;
+}
+/**
+ * Light theme color palette
+ */
+export const lightThemePalette = {
+    // Backgrounds
+    bg: { r: 250, g: 250, b: 250 }, // Very light gray
+    userBg: { r: 230, g: 245, b: 255 }, // Light blue
+    dimBg: { r: 240, g: 240, b: 240 }, // Light gray
+    // Foregrounds
+    fg: { r: 30, g: 30, b: 30 }, // Near black
+    dim: { r: 100, g: 100, b: 100 }, // Gray
+    muted: { r: 120, g: 120, b: 120 }, // Medium gray
+    // Accents
+    accent: { r: 0, g: 100, b: 200 }, // Blue
+    accentText: { r: 0, g: 80, b: 160 }, // Darker blue
+    userText: { r: 0, g: 60, b: 120 }, // Dark blue
+    // Semantic
+    error: { r: 200, g: 0, b: 0 }, // Red
+    success: { r: 0, g: 150, b: 0 }, // Green
+    warning: { r: 200, g: 150, b: 0 }, // Orange
+    // Assistant text (uses terminal default)
+    assistantText: { r: 30, g: 30, b: 30 },
+};
+/**
+ * Dark theme color palette (current default)
+ */
+export const darkThemePalette = {
+    // Backgrounds
+    bg: { r: 20, g: 20, b: 20 }, // Very dark gray
+    userBg: { r: 40, g: 60, b: 80 }, // Dark blue
+    dimBg: { r: 40, g: 40, b: 40 }, // Dark gray
+    // Foregrounds
+    fg: { r: 230, g: 230, b: 230 }, // Near white
+    dim: { r: 150, g: 150, b: 150 }, // Gray
+    muted: { r: 120, g: 120, b: 120 }, // Medium gray
+    // Accents
+    accent: { r: 100, g: 180, b: 255 }, // Light blue
+    accentText: { r: 100, g: 200, b: 255 }, // Cyan
+    userText: { r: 150, g: 220, b: 255 }, // Light cyan
+    // Semantic
+    error: { r: 255, g: 100, b: 100 }, // Light red
+    success: { r: 100, g: 255, b: 100 }, // Light green
+    warning: { r: 255, g: 200, b: 100 }, // Light orange
+    // Assistant text (uses terminal default)
+    assistantText: { r: 230, g: 230, b: 230 },
+};
+/**
+ * Get the appropriate color palette for the current theme
+ */
+export function getThemePalette(mode = detectThemeMode()) {
+    return mode === "light" ? lightThemePalette : darkThemePalette;
+}
+/**
+ * Convert RGB to ANSI color code (approximate)
+ * This is a simplified version - for exact colors, terminals support true color
+ */
+export function rgbToAnsi(rgb, foreground = true) {
+    // Use 24-bit true color if terminal supports it
+    const prefix = foreground ? "38" : "48";
+    return `\x1b[${prefix};2;${rgb.r};${rgb.g};${rgb.b}m`;
+}
+/**
+ * Reset ANSI colors
+ */
+export function resetAnsi() {
+    return "\x1b[0m";
+}

package/dist/tui/tui-command-handlers.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { formatThinkingLevels, normalizeUsageDisplay, resolveResponseUsageMode, } from "../auto-reply/thinking.js";
 import { formatRelativeTimestamp } from "../infra/format-time/format-relative.js";
 import { normalizeAgentId } from "../routing/session-key.js";
@@ -364,6 +365,25 @@ export function createCommandHandlers(context) {
                 }
                 break;
             case "new":
+                try {
+                    // Create a new isolated session with unique key
+                    const newSessionKey = `tui-${randomUUID()}`;
+                    // Clear token counts
+                    state.sessionInfo.inputTokens = null;
+                    state.sessionInfo.outputTokens = null;
+                    state.sessionInfo.totalTokens = null;
+                    state.sessionInfo.updatedAt = null; // Reset freshness timestamp
+                    tui.requestRender();
+                    // Switch to new session
+                    await setSession(newSessionKey);
+                    chatLog.addSystem(`created new session: ${newSessionKey}`);
+                    chatLog.clear(); // Clear chat log for fresh session
+                    await loadHistory();
+                }
+                catch (err) {
+                    chatLog.addSystem(`failed to create new session: ${String(err)}`);
+                }
+                break;
             case "reset":
                 try {
                     // Clear token counts immediately to avoid stale display (#1523)

package/dist/tui/tui-formatters.js

@@ -1,5 +1,6 @@
 import { formatTokenCount } from "../utils/usage-format.js";
 import { formatRawAssistantErrorForUi } from "../agents/pi-embedded-helpers.js";
+import { sanitizeRenderableText } from "./utils/text-sanitization.js";
 export function resolveFinalAssistantText(params) {
     const finalText = params.finalText ?? "";
     if (finalText.trim())
@@ -61,7 +62,7 @@ export function extractContentFromMessage(message) {
         const stopReason = typeof record.stopReason === "string" ? record.stopReason : "";
         if (stopReason === "error") {
             const errorMessage = typeof record.errorMessage === "string" ? record.errorMessage : "";
-            return formatRawAssistantErrorForUi(errorMessage);
+            return sanitizeRenderableText(formatRawAssistantErrorForUi(errorMessage));
         }
         return "";
     }
@@ -79,7 +80,7 @@ export function extractContentFromMessage(message) {
         const stopReason = typeof record.stopReason === "string" ? record.stopReason : "";
         if (stopReason === "error") {
             const errorMessage = typeof record.errorMessage === "string" ? record.errorMessage : "";
-            return formatRawAssistantErrorForUi(errorMessage);
+            return sanitizeRenderableText(formatRawAssistantErrorForUi(errorMessage));
         }
     }
     return parts.join("\n").trim();
@@ -121,7 +122,7 @@ export function extractTextFromMessage(message, opts) {
     if (stopReason !== "error")
         return "";
     const errorMessage = typeof record.errorMessage === "string" ? record.errorMessage : "";
-    return formatRawAssistantErrorForUi(errorMessage);
+    return sanitizeRenderableText(formatRawAssistantErrorForUi(errorMessage));
 }
 export function isCommandMessage(message) {
     if (!message || typeof message !== "object")

package/dist/tui/utils/ctrl-c-handler.js

@@ -0,0 +1,67 @@
+/**
+ * Ctrl+C handling utilities with state machine
+ *
+ * States:
+ * - "clear": Clear input if text present
+ * - "warn": Show warning on first Ctrl+C with empty input
+ * - "exit": Exit on second Ctrl+C within timeout
+ */
+/**
+ * Create a new Ctrl+C state machine
+ */
+export function createCtrlCStateMachine(timeoutMs = 1000) {
+    return {
+        state: "clear",
+        lastCtrlCAt: 0,
+        timeoutMs,
+    };
+}
+/**
+ * Process Ctrl+C event and determine action
+ *
+ * @param machine - State machine instance
+ * @param hasInput - Whether there's text in the input
+ * @returns The action to take: "clear", "warn", or "exit"
+ */
+export function processCtrlC(machine, hasInput) {
+    const now = Date.now();
+    // If has input, always clear
+    if (hasInput) {
+        machine.state = "clear";
+        machine.lastCtrlCAt = now;
+        return "clear";
+    }
+    // Check if within double-press timeout
+    const withinTimeout = now - machine.lastCtrlCAt < machine.timeoutMs;
+    if (machine.state === "warn" && withinTimeout) {
+        // Second press within timeout -> exit
+        machine.state = "exit";
+        return "exit";
+    }
+    // First press or timeout expired -> warn
+    machine.state = "warn";
+    machine.lastCtrlCAt = now;
+    return "warn";
+}
+/**
+ * Format status message based on Ctrl+C state
+ */
+export function getCtrlCStatusMessage(state, timeoutMs) {
+    switch (state) {
+        case "clear":
+            return "cleared input";
+        case "warn":
+            return `press ctrl+c again within ${Math.ceil(timeoutMs / 1000)}s to exit`;
+        case "exit":
+            return "exiting...";
+        default:
+            return "";
+    }
+}
+/**
+ * Reset state machine
+ */
+export function resetCtrlCState(machine) {
+    machine.state = "clear";
+    machine.lastCtrlCAt = 0;
+}

package/dist/tui/utils/osc8-hyperlinks.js

@@ -0,0 +1,208 @@
+/**
+ * OSC 8 Hyperlink utilities for clickable terminal URLs
+ *
+ * OSC 8 is a terminal escape sequence that makes URLs clickable.
+ * Supported terminals: iTerm2, Windows Terminal, GNOME Terminal,
+ * VS Code terminal, Hyper, and most modern terminals.
+ *
+ * Format: \e]8;;URL\e\\TEXT\e]8;;\e\\
+ *         ^^^^^ start    ^^^^^^ end
+ *
+ * Features:
+ * - Automatic URL detection in text
+ * - OSC 8 hyperlink generation
+ * - Terminal capability detection
+ * - Graceful fallback for unsupported terminals
+ */
+/**
+ * OSC 8 escape sequences
+ */
+const OSC8_START = "\x1b]8;;";
+const OSC8_END = "\x1b\\";
+const OSC8_ST = "\x07"; // Alternative terminator (Bell)
+/**
+ * URL pattern for detection
+ * Matches http://, https://, file://, and other common schemes
+ */
+const URL_REGEX = /(https?:\/\/|file:\/\/|ftp:\/\/|mailto:|ssh:|sftp:)[^\s<>"{}|\\^`[\]]+/gi;
+/**
+ * Check if terminal supports OSC 8 hyperlinks
+ *
+ * Detection methods:
+ * 1. Check for known supporting terminals via TERM or TERM_PROGRAM
+ * 2. Check for explicit HYPERLINK_SUPPORT env var
+ * 3. Check for VTE_VERSION (VTE-based terminals)
+ */
+export function isOsc8Supported() {
+    const env = process.env;
+    // Explicit opt-in/opt-out
+    if (env.HYPERLINK_SUPPORT === "1" || env.HYPERLINK_SUPPORT === "true") {
+        return true;
+    }
+    if (env.HYPERLINK_SUPPORT === "0" || env.HYPERLINK_SUPPORT === "false") {
+        return false;
+    }
+    const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+    const term = (env.TERM ?? "").toLowerCase();
+    // Known supporting terminals
+    const supportingPrograms = [
+        "iterm",
+        "iterm2",
+        "vscode",
+        "code",
+        "hyper",
+        "alacritty",
+        "wezterm",
+        "tabby",
+        "warp",
+        "rio",
+        "rio-terminal",
+    ];
+    for (const program of supportingPrograms) {
+        if (termProgram.includes(program)) {
+            return true;
+        }
+    }
+    // VTE-based terminals (GNOME Terminal, Tilix, etc.)
+    if (env.VTE_VERSION) {
+        return true;
+    }
+    // Windows Terminal (new)
+    if (env.WT_SESSION || env.WT_PROFILE_ID) {
+        return true;
+    }
+    // Konsole (KDE terminal)
+    if (env.KONSOLE_VERSION) {
+        return true;
+    }
+    // Screen/Tmux might support it if the outer terminal does
+    if (term.includes("screen") || term.includes("tmux")) {
+        // Check if we're in a supported outer terminal
+        if (env.TMUX || env.STY) {
+            // Conservative: assume supported if in tmux/screen
+            return true;
+        }
+    }
+    // Default: assume modern terminals support it
+    // This can be overridden with HYPERLINK_SUPPORT env var
+    return true;
+}
+/**
+ * Create an OSC 8 hyperlink
+ *
+ * @param url - The URL to link to
+ * @param text - The visible text
+ * @param params - Optional parameters (id, etc.)
+ * @returns Formatted hyperlink string
+ */
+export function createHyperlink(url, text, params) {
+    if (!isOsc8Supported()) {
+        return text;
+    }
+    // Validate URL
+    try {
+        new URL(url);
+    }
+    catch {
+        // Invalid URL, return plain text
+        return text;
+    }
+    const terminator = params?.useSt ? OSC8_ST : OSC8_END;
+    const idPart = params?.id ? `id=${params.id}:` : "";
+    return `${OSC8_START}${idPart}${url}${terminator}${text}${OSC8_START}${terminator}`;
+}
+/**
+ * Convert plain URLs in text to OSC 8 hyperlinks
+ *
+ * @param text - Input text containing URLs
+ * @returns Text with URLs converted to hyperlinks
+ */
+export function hyperlinkUrls(text) {
+    if (!isOsc8Supported()) {
+        return text;
+    }
+    return text.replace(URL_REGEX, (url) => {
+        return createHyperlink(url, url);
+    });
+}
+/**
+ * Strip OSC 8 sequences from text
+ * Useful for getting plain text or for length calculations
+ *
+ * @param text - Text that may contain OSC 8 sequences
+ * @returns Text with OSC 8 sequences removed
+ */
+export function stripOsc8(text) {
+    // Match OSC 8 start sequences: ESC]8;;params:urlESC\ or ESC]8;;params:urlBEL
+    // Match OSC 8 end sequences: ESC]8;;ESC\ or ESC]8;;BEL
+    // eslint-disable-next-line no-control-regex
+    const osc8Regex = /\x1b\]8;;[^\x07\x1b]*(?:\x1b\\|\x07)/g;
+    return text.replace(osc8Regex, "");
+}
+/**
+ * Get the visible length of text (excluding OSC 8 sequences)
+ *
+ * @param text - Text that may contain OSC 8 sequences
+ * @returns Visible character count
+ */
+export function getVisibleLength(text) {
+    return stripOsc8(text).length;
+}
+/**
+ * Truncate text with OSC 8 support
+ * Preserves hyperlinks when truncating
+ *
+ * @param text - Text to truncate
+ * @param maxLength - Maximum visible length
+ * @returns Truncated text
+ */
+export function truncateWithHyperlinks(text, maxLength) {
+    if (getVisibleLength(text) <= maxLength) {
+        return text;
+    }
+    // Simple approach: strip OSC 8, truncate, return plain text
+    // A more sophisticated approach would preserve partial hyperlinks
+    const plain = stripOsc8(text);
+    return plain.slice(0, maxLength - 3) + "...";
+}
+/**
+ * Detect URLs in text and return their positions
+ *
+ * @param text - Input text
+ * @returns Array of URL matches with positions
+ */
+export function detectUrls(text) {
+    const matches = [];
+    let match;
+    // Reset regex lastIndex
+    URL_REGEX.lastIndex = 0;
+    while ((match = URL_REGEX.exec(text)) !== null) {
+        matches.push({
+            url: match[0],
+            start: match.index,
+            end: match.index + match[0].length,
+        });
+    }
+    return matches;
+}
+/**
+ * Create a hyperlink with display text different from URL
+ * Example: createNamedHyperlink("https://example.com", "Click here")
+ *
+ * @param url - The target URL
+ * @param displayText - The visible text
+ * @returns Hyperlink string
+ */
+export function createNamedHyperlink(url, displayText) {
+    return createHyperlink(url, displayText);
+}
+/**
+ * Wrap a URL in OSC 8 sequence
+ * Shorthand for createHyperlink(url, url)
+ *
+ * @param url - URL to wrap
+ * @returns Hyperlink string
+ */
+export function wrapUrl(url) {
+    return createHyperlink(url, url);
+}