httpcat-cli 0.2.11 → 0.2.12-rc.1

package/dist/interactive/shell.js

@@ -5,74 +5,288 @@ import { config } from "../config.js";
 import { printCat } from "./art.js";
 import { validateAmount } from "../utils/validation.js";
 // Import commands
-import { createToken } from "../commands/create.js";
-import { buyToken, TEST_AMOUNTS, PROD_AMOUNTS } from "../commands/buy.js";
+import { createToken, processPhotoUrl, isFilePath, } from "../commands/create.js";
+import { buyToken, TEST_AMOUNTS, PROD_AMOUNTS, } from "../commands/buy.js";
 import { sellToken, parseTokenAmount } from "../commands/sell.js";
 import { getTokenInfo } from "../commands/info.js";
 import { listTokens } from "../commands/list.js";
+import { formatCurrency, formatTokenAmount, formatAddress, } from "../utils/formatting.js";
 import { getPositions } from "../commands/positions.js";
 import { privateKeyToAccount } from "viem/accounts";
 import { checkHealth } from "../commands/health.js";
-import { startChatStream } from "../commands/chat.js";
+import { joinChat, sendChatMessage, renewLease, normalizeWebSocketUrl, } from "../commands/chat.js";
+import WebSocket from "ws";
 import { checkBalance } from "../commands/balances.js";
-export async function startInteractiveShell(client) {
-    // Create blessed screen
+import { viewFees, claimFees } from "../commands/claim.js";
+import { getTransactions } from "../commands/transactions.js";
+import { getAccountInfo, switchAccount, addAccount, } from "../commands/account.js";
+import { HttpcatError } from "../client.js";
+import { createHttpcatAgent, chatWithAgent } from "../agent/ax-agent.js";
+import { createLLM } from "../agent/llm-factory.js";
+import { setupAIAgentWizard } from "../agent/setup-wizard.js";
+// Detect terminal background color
+function detectTerminalBackground() {
+    // Check COLORFGBG (format: "foreground;background")
+    // Background values: 0-7 are dark, 8-15 are light
+    const colorfgbg = process.env.COLORFGBG;
+    if (colorfgbg) {
+        const parts = colorfgbg.split(";");
+        if (parts.length >= 2) {
+            const bg = parseInt(parts[1], 10);
+            if (!isNaN(bg)) {
+                // 0-7 are dark backgrounds, 8-15 are light
+                return bg < 8 ? "dark" : "light";
+            }
+        }
+    }
+    // Check TERM_PROGRAM for common terminals
+    const termProgram = process.env.TERM_PROGRAM?.toLowerCase();
+    if (termProgram) {
+        // These terminals often have dark backgrounds by default
+        if (["iterm2", "vscode", "hyper", "alacritty", "kitty"].includes(termProgram)) {
+            return "dark";
+        }
+        // These often have light backgrounds
+        if (["apple_terminal"].includes(termProgram)) {
+            return "light";
+        }
+    }
+    // Check for common dark terminal indicators
+    const term = process.env.TERM?.toLowerCase() || "";
+    if (term.includes("256") || term.includes("xterm")) {
+        // Most modern terminals default to dark
+        return "dark";
+    }
+    // Default to dark (safer assumption for modern terminals)
+    return "dark";
+}
+export async function startInteractiveShell(client, autoChatToken) {
+    // Auto-detect terminal background and set default theme
+    const detectedBg = detectTerminalBackground();
+    let currentTheme = detectedBg === "dark" ? "dark" : "win95";
+    // Helper function to get theme-appropriate cyan/blue color for blessed tags
+    // For dark theme, use lighter colors (light-cyan-fg) for better visibility on black
+    const getCyanColor = (theme) => theme === "dark" ? "light-cyan-fg" : "cyan-fg";
+    const getBlueColor = (theme) => theme === "dark" ? "light-blue-fg" : "blue-fg";
+    // Create blessed screen with optimized settings
     const screen = blessed.screen({
         smartCSR: true,
         title: "httpcat Interactive Shell",
-        fullUnicode: true,
+        fullUnicode: true, // Support double-width/surrogate/combining chars (emojis)
+        fastCSR: false, // Disable fast CSR to prevent rendering issues
+        cursor: {
+            artificial: true,
+            shape: "line",
+            blink: true,
+            color: "green",
+        },
+        // Force Unicode support for emojis
+        forceUnicode: true,
     });
     const network = client.getNetwork();
-    // Create header box
+    // Theme colors - no backgrounds, just borders
+    const getThemeColors = (theme) => {
+        switch (theme) {
+            case "light":
+                return {
+                    bg: "default", // Transparent/default
+                    fg: "black",
+                    border: "black",
+                    inputBg: "default",
+                    inputFg: "black", // Explicit black for visibility
+                    inputFocusBg: "default",
+                    inputFocusFg: "black",
+                };
+            case "win95":
+                return {
+                    bg: "default",
+                    fg: "black",
+                    border: "black",
+                    inputBg: "default",
+                    inputFg: "black", // Explicit black for visibility
+                    inputFocusBg: "default",
+                    inputFocusFg: "black",
+                };
+            default: // dark
+                return {
+                    bg: "default",
+                    fg: "green",
+                    border: "green",
+                    inputBg: "default",
+                    inputFg: "green", // Explicit green for visibility
+                    inputFocusBg: "default",
+                    inputFocusFg: "green",
+                };
+        }
+    };
+    let themeColors = getThemeColors(currentTheme);
+    // Create header box with thick borders, transparent background - more compact
     const headerBox = blessed.box({
         top: 0,
         left: 0,
         width: "100%",
-        height: 8,
+        height: 6, // Reduced to save vertical space
         content: "",
-        tags: false,
+        tags: true,
         style: {
-            fg: "white",
-            bg: "black",
+            fg: themeColors.fg,
+            bg: "default", // Transparent
+            bold: false,
+            border: {
+                fg: themeColors.border,
+                bold: true,
+            },
         },
         padding: {
             left: 1,
             right: 1,
+            top: 0,
+            bottom: 0,
+        },
+        border: {
+            type: "line",
+            fg: themeColors.border,
+            ch: "═", // Double line for thicker border
         },
     });
-    // Build welcome content
-    const welcomeLines = [];
-    welcomeLines.push("  /\\_/\\");
-    welcomeLines.push(" ( ^.^ )");
-    welcomeLines.push("  > ^ <");
-    welcomeLines.push("");
-    welcomeLines.push("Welcome to httpcat!");
-    welcomeLines.push(`Connected to: ${network}`);
-    welcomeLines.push('Type "help" for available commands or "exit" to quit');
-    headerBox.setContent(welcomeLines.join("\n"));
-    // Create output log box (scrollable)
+    // Cat face variants for animation
+    const catFaces = [
+        { name: "Sleepy", face: "[=^ -.- ^=]" },
+        { name: "Smug", face: "[=^‿^=]" },
+        { name: "Unhinged", face: "[=^◉_◉^=]" },
+        { name: "Judgy", face: "[=^ಠ‿ಠ^=]" },
+        { name: "Cute", face: "[=^｡^=]" },
+        { name: "Menacing", face: "[=^>_<^=]" },
+        { name: "Loaf Mode", face: "[=^___^=]" },
+        { name: "Cosmic", face: "[=^✧_✧^=]" },
+    ];
+    let currentCatIndex = 0;
+    let catAnimationInterval = null;
+    // Helper function to build welcome content with account info - more compact
+    const buildWelcomeContent = async (theme, catFace) => {
+        const welcomeLines = [];
+        const colorTag = theme === "dark" ? "green-fg" : "black-fg";
+        const cyanColor = getCyanColor(theme);
+        // Use provided cat face or current one
+        const displayCatFace = catFace || catFaces[currentCatIndex].face;
+        // Cat face with breathing room, compact info below
+        welcomeLines.push(`{${colorTag}}${displayCatFace}{/${colorTag}}`);
+        welcomeLines.push(`{green-fg}🐱 Welcome to httpcat!{/green-fg} | {green-fg}🌐 {${cyanColor}}${network}{/${cyanColor}}{/green-fg}`);
+        // Get account info
+        let accountInfo = null;
+        try {
+            const accounts = config.getAllAccounts();
+            const activeIndex = config.getActiveAccountIndex();
+            const account = accounts.find((acc) => acc.index === activeIndex);
+            if (account) {
+                // Get balance info
+                try {
+                    const privateKey = config.getAccountPrivateKey(activeIndex);
+                    const balance = await checkBalance(privateKey, true); // silent mode
+                    accountInfo = {
+                        account,
+                        balance,
+                    };
+                }
+                catch (error) {
+                    // If balance check fails, just show account info without balance
+                    accountInfo = { account };
+                }
+            }
+        }
+        catch (error) {
+            // If account info fails, continue without it
+        }
+        // Compact account info - combined on fewer lines
+        if (accountInfo) {
+            const { account, balance } = accountInfo;
+            const accountType = account.type === "custom" ? "Custom" : "Seed-Derived";
+            const accountLabel = account.label ? ` (${account.label})` : "";
+            if (balance) {
+                const ethDisplay = balance.ethFormatted || balance.ethBalance || "0 ETH";
+                const usdcDisplay = balance.usdcFormatted || balance.usdcBalance || "$0.00";
+                // Combine account and balance on one line to save space
+                welcomeLines.push(`{${cyanColor}}👤 Account #{green-fg}${account.index}{/green-fg} | {green-fg}${accountType}${accountLabel}{/green-fg} | 💰 {yellow-fg}${ethDisplay}{/yellow-fg} | {green-fg}${usdcDisplay}{/green-fg}{/${cyanColor}}`);
+            }
+            else {
+                welcomeLines.push(`{${cyanColor}}👤 Account #{green-fg}${account.index}{/green-fg} | {green-fg}${accountType}${accountLabel}{/green-fg}{/${cyanColor}}`);
+            }
+        }
+        return welcomeLines.join("\n");
+    };
+    // Set initial header content
+    buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face).then((content) => {
+        headerBox.setContent(content);
+        screen.render();
+    });
+    // Start cat face animation (cycle through every minute)
+    const startCatAnimation = () => {
+        if (catAnimationInterval) {
+            clearInterval(catAnimationInterval);
+        }
+        catAnimationInterval = setInterval(() => {
+            currentCatIndex = (currentCatIndex + 1) % catFaces.length;
+            buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face).then((content) => {
+                headerBox.setContent(content);
+                screen.render();
+            });
+        }, 60000); // Change every minute (60 seconds)
+    };
+    // Start animation
+    startCatAnimation();
+    // Create output log box (scrollable) with thick borders, transparent background
     const outputBox = blessed.log({
-        top: 8,
+        top: 6, // Adjusted to match new header height
         left: 0,
         width: "100%",
-        height: "100%-11",
+        bottom: 4, // Leave space for input box at bottom
         tags: true,
         scrollable: true,
         alwaysScroll: true,
         scrollbar: {
             ch: " ",
-            inverse: true,
+            inverse: currentTheme !== "dark",
         },
         style: {
-            fg: "white",
-            bg: "black",
+            fg: themeColors.fg,
+            bg: "default", // Transparent
+            border: {
+                fg: themeColors.border,
+                bold: true,
+            },
         },
         padding: {
-            left: 1,
+            left: 0,
             right: 1,
         },
+        mouse: true, // Enable mouse scrolling
+        border: {
+            type: "line",
+            fg: themeColors.border,
+            ch: "═", // Double line for thicker border
+        },
     });
-    // Create input box at bottom
+    // Create prompt label with bold font (appears larger) - positioned inside input box
+    const promptLabel = blessed.text({
+        bottom: 1,
+        left: 2,
+        width: 8, // Exactly "httpcat>" (8 characters)
+        height: 1,
+        content: "",
+        tags: true,
+        style: {
+            fg: themeColors.fg,
+            bg: "default", // Transparent
+            bold: true,
+        },
+    });
+    // Helper to update prompt label content
+    const updatePromptLabel = (theme) => {
+        const colorTag = theme === "dark" ? "green-fg" : "black-fg";
+        promptLabel.content = `{${colorTag}}{bold}httpcat>{/bold}{/${colorTag}}`;
+    };
+    updatePromptLabel(currentTheme);
+    // Create input box with visible cursor and stylish border
     const inputBox = blessed.textbox({
         bottom: 0,
         left: 0,
@@ -80,35 +294,86 @@ export async function startInteractiveShell(client) {
         height: 3,
         inputOnFocus: true,
         keys: true,
-        style: {
-            fg: "cyan",
-            bg: "black",
-            focus: {
-                fg: "white",
-                bg: "blue",
-            },
-        },
+        vi: false, // Disabled to prevent double input issues in agent mode
+        secret: false,
+        tags: true,
+        alwaysScroll: false,
+        scrollable: false,
         padding: {
-            left: 1,
+            left: 10, // Space for "httpcat>" prompt (8 chars) + 2 for spacing
             right: 1,
+            top: 0,
+            bottom: 0,
+        },
+        cursor: {
+            artificial: true,
+            shape: "block", // Block cursor is more visible than line
+            blink: true,
+            color: currentTheme === "dark" ? "green" : "black",
         },
-    });
-    // Create a prompt label
-    const promptLabel = blessed.text({
-        bottom: 1,
-        left: 1,
-        content: "httpcat> ",
         style: {
-            fg: "cyan",
-            bg: "black",
+            fg: themeColors.fg,
+            bg: "default",
+            border: {
+                fg: themeColors.border,
+                bold: true,
+            },
+            focus: {
+                fg: themeColors.fg,
+                bg: "default",
+                border: {
+                    fg: themeColors.border,
+                    bold: true,
+                },
+            },
+        },
+        border: {
+            type: "line",
+            fg: themeColors.border,
+            ch: "─", // Single line border
         },
     });
-    // Append all widgets
-    screen.append(headerBox);
-    screen.append(outputBox);
-    screen.append(promptLabel);
-    screen.append(inputBox);
-    // Helper to log output
+    // Helper to update theme
+    const updateTheme = (newTheme) => {
+        currentTheme = newTheme;
+        themeColors = getThemeColors(currentTheme);
+        // Update screen cursor color
+        screen.cursor.color =
+            currentTheme === "dark" ? "green" : "black";
+        // Update header content with new theme colors (keep current cat face)
+        buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face).then((content) => {
+            headerBox.setContent(content);
+            screen.render();
+        });
+        // Update all widget styles
+        headerBox.style.fg = themeColors.fg;
+        headerBox.style.bg = "default"; // Transparent
+        headerBox.border = { type: "line", fg: themeColors.border, ch: "═" };
+        outputBox.style.fg = themeColors.fg;
+        outputBox.style.bg = "default"; // Transparent
+        outputBox.scrollbar.inverse = currentTheme !== "dark";
+        outputBox.border = { type: "line", fg: themeColors.border, ch: "═" };
+        updatePromptLabel(currentTheme);
+        promptLabel.style.fg = themeColors.fg;
+        promptLabel.style.bg = "default"; // Transparent
+        promptLabel.style.bold = true;
+        // Update input box cursor, style, and border
+        inputBox.style.fg = themeColors.fg;
+        inputBox.style.bg = "default";
+        inputBox.style.focus.fg = themeColors.fg;
+        inputBox.style.focus.bg = "default";
+        inputBox.style.border.fg = themeColors.border;
+        inputBox.style.focus.border.fg = themeColors.border;
+        inputBox.border = { type: "line", fg: themeColors.border, ch: "─" };
+        if (inputBox.cursor) {
+            inputBox.cursor.color =
+                currentTheme === "dark" ? "green" : "black";
+        }
+        screen.cursor.color =
+            currentTheme === "dark" ? "green" : "black";
+        screen.render();
+    };
+    // Helper to log output (define before use)
     const log = (text) => {
         outputBox.log(text);
         outputBox.setScrollPerc(100);
@@ -120,19 +385,166 @@ export async function startInteractiveShell(client) {
         outputBox.setScrollPerc(100);
         screen.render();
     };
+    // Helper to log multiple lines with smooth scrolling (for tables/lists)
+    const logLinesSmooth = async (lines, scrollToTop = false) => {
+        // Disable auto-scroll temporarily to batch output (prevents rapid scrolling)
+        const originalAlwaysScroll = outputBox.alwaysScroll;
+        outputBox.alwaysScroll = false;
+        // Get line count before adding new lines
+        const linesBefore = outputBox.lines?.length || 0;
+        // Add all lines at once (no rendering between lines = smooth, no rapid scrolling)
+        lines.forEach((line) => outputBox.log(line));
+        // Calculate scroll position after adding lines
+        const linesAfter = outputBox.lines?.length || 0;
+        const visibleHeight = outputBox.height || 20;
+        if (scrollToTop && linesAfter > visibleHeight) {
+            // Scroll to show the beginning of the new content
+            // Calculate which line the new content starts at
+            const newContentStartLine = linesBefore;
+            // Calculate percentage to show that line near the top
+            // We want to show the new content starting from the top of visible area
+            const totalScrollable = Math.max(1, linesAfter - visibleHeight);
+            const scrollPerc = Math.max(0, Math.min(100, (newContentStartLine / totalScrollable) * 100));
+            try {
+                outputBox.setScrollPerc(scrollPerc);
+            }
+            catch (e) {
+                // Fallback if method doesn't exist
+                outputBox.setScrollPerc(0);
+            }
+        }
+        else {
+            // Scroll to bottom
+            outputBox.setScrollPerc(100);
+        }
+        // Re-enable auto-scroll
+        outputBox.alwaysScroll = originalAlwaysScroll;
+        screen.render();
+    };
+    // Wrap toggleTheme to also log
+    const toggleThemeWithLog = () => {
+        const themes = ["win95", "dark", "light"];
+        const currentIndex = themes.indexOf(currentTheme);
+        const nextTheme = themes[(currentIndex + 1) % themes.length];
+        updateTheme(nextTheme);
+        log(chalk.blue(`Theme switched to: ${nextTheme}`));
+    };
+    // Append all widgets in correct z-order (last appended is on top)
+    screen.append(headerBox);
+    screen.append(outputBox);
+    screen.append(inputBox);
+    screen.append(promptLabel); // Prompt label on top so it's always visible
+    // Handle F1 for theme toggle
+    screen.key(["f1"], () => {
+        toggleThemeWithLog();
+    });
+    // Store toggle function for command handler
+    screen.toggleTheme = toggleThemeWithLog;
+    screen.updateTheme = updateTheme;
+    // Command history
+    const commandHistory = [];
+    let historyIndex = -1; // -1 means not navigating history (showing current input)
+    let currentInputBeforeHistory = ""; // Store current input when starting to navigate history
+    // Handle up arrow - navigate to previous command in history
+    inputBox.key(["up"], () => {
+        if (commandHistory.length === 0) {
+            return;
+        }
+        // If we're not currently navigating history, save the current input
+        if (historyIndex === -1) {
+            currentInputBeforeHistory = inputBox.getValue();
+            historyIndex = commandHistory.length - 1; // Start at the most recent command
+        }
+        else {
+            // Move to previous command (earlier in history)
+            if (historyIndex > 0) {
+                historyIndex--;
+            }
+        }
+        // Set the input to the command at current history index
+        inputBox.setValue(commandHistory[historyIndex]);
+        screen.render();
+    });
+    // Handle down arrow - navigate to next command in history (or back to current input)
+    inputBox.key(["down"], () => {
+        if (commandHistory.length === 0 || historyIndex === -1) {
+            return;
+        }
+        // Move to next command (more recent in history)
+        if (historyIndex < commandHistory.length - 1) {
+            historyIndex++;
+            inputBox.setValue(commandHistory[historyIndex]);
+        }
+        else {
+            // We're at the most recent command, go back to the input that was there before
+            historyIndex = -1;
+            inputBox.setValue(currentInputBeforeHistory);
+            currentInputBeforeHistory = "";
+        }
+        screen.render();
+    });
+    // Handle left arrow - move cursor left within input
+    // Only intercept if we're not navigating history (blessed handles cursor movement automatically with vi: true)
+    inputBox.key(["left"], () => {
+        // Reset history navigation when user starts editing with arrow keys
+        if (historyIndex !== -1) {
+            historyIndex = -1;
+            currentInputBeforeHistory = "";
+        }
+        // Blessed will handle cursor movement automatically with vi: true
+        screen.render();
+    });
+    // Handle right arrow - move cursor right within input
+    inputBox.key(["right"], () => {
+        // Reset history navigation when user starts editing with arrow keys
+        if (historyIndex !== -1) {
+            historyIndex = -1;
+            currentInputBeforeHistory = "";
+        }
+        // Blessed will handle cursor movement automatically with vi: true
+        screen.render();
+    });
+    // Handle Home key - move cursor to beginning of line
+    inputBox.key(["home"], () => {
+        if (historyIndex === -1) {
+            // Blessed handles this automatically with vi: true
+            screen.render();
+        }
+    });
+    // Handle End key - move cursor to end of line
+    inputBox.key(["end"], () => {
+        if (historyIndex === -1) {
+            // Blessed handles this automatically with vi: true
+            screen.render();
+        }
+    });
     // Handle input submission
     inputBox.on("submit", async (value) => {
         const trimmed = value.trim();
         inputBox.clearValue();
+        screen.render(); // Clear input immediately
+        // Reset history navigation
+        historyIndex = -1;
+        currentInputBeforeHistory = "";
         if (!trimmed) {
             inputBox.focus();
             screen.render();
             return;
         }
-        log(`httpcat> ${trimmed}`);
+        // Add to history (avoid duplicates - don't add if same as last command)
+        if (commandHistory.length === 0 ||
+            commandHistory[commandHistory.length - 1] !== trimmed) {
+            commandHistory.push(trimmed);
+            // Limit history size to prevent memory issues (keep last 100 commands)
+            if (commandHistory.length > 100) {
+                commandHistory.shift();
+            }
+        }
+        // Log the command with prompt
+        log(`{green-fg}httpcat>{/green-fg} ${trimmed}`);
         const [command, ...args] = trimmed.split(/\s+/);
         try {
-            await handleCommand(client, command.toLowerCase(), args, log, logLines, screen, inputBox);
+            await handleCommand(client, command.toLowerCase(), args, log, logLines, logLinesSmooth, screen, inputBox, currentTheme, buildWelcomeContent, headerBox, catFaces, currentCatIndex);
         }
         catch (error) {
             log(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
@@ -141,43 +553,86 @@ export async function startInteractiveShell(client) {
         inputBox.focus();
         screen.render();
     });
-    // Handle Ctrl+C
-    screen.key(["C-c"], () => {
-        screen.destroy();
-        printCat("sleeping");
-        console.log(chalk.cyan("Goodbye! 👋"));
-        process.exit(0);
-    });
     // Handle escape to clear input
     inputBox.key(["escape"], () => {
         inputBox.clearValue();
         screen.render();
     });
+    // Handle Ctrl+C - two-stage: first clears input if text exists, second quits
+    const handleCtrlC = () => {
+        const currentValue = inputBox.getValue();
+        // If there's text in the input, clear it instead of quitting
+        if (currentValue && currentValue.trim().length > 0) {
+            inputBox.clearValue();
+            screen.render();
+            return;
+        }
+        // No text in input, so quit
+        if (catAnimationInterval) {
+            clearInterval(catAnimationInterval);
+            catAnimationInterval = null;
+        }
+        screen.destroy();
+        printCat("sleeping");
+        console.log(chalk.cyan("Goodbye! 👋"));
+        process.exit(0);
+    };
+    // Handle Ctrl+C on screen level
+    screen.key(["C-c"], handleCtrlC);
+    // Handle Ctrl+C on input box level
+    inputBox.key(["C-c"], handleCtrlC);
     // Focus input and render
     inputBox.focus();
     screen.render();
+    // Show welcome message with key commands on load
+    displayWelcomeMessage(log, logLines, outputBox, screen, currentTheme);
+    // Auto-enter chat mode if token identifier provided
+    if (autoChatToken !== undefined) {
+        // Store original submit handler
+        const originalHandlers = inputBox.listeners("submit");
+        const originalSubmitHandler = originalHandlers[0];
+        // Remove original handler temporarily
+        inputBox.removeAllListeners("submit");
+        // Enter chat mode automatically
+        await startChatInShell(client, autoChatToken, log, logLines, screen, inputBox, originalSubmitHandler, headerBox, buildWelcomeContent, currentTheme, catFaces, currentCatIndex);
+    }
 }
-async function handleCommand(client, command, args, log, logLines, screen, inputBox) {
+async function handleCommand(client, command, args, log, logLines, logLinesSmooth, screen, inputBox, currentTheme, buildWelcomeContent, headerBox, catFaces, currentCatIndex) {
     switch (command) {
         case "help":
-            displayHelp(log, logLines);
+            // Get outputBox from screen children (it's the second child after headerBox)
+            const outputBox = screen.children.find((child) => child.type === "log");
+            displayHelp(log, logLines, outputBox, screen, currentTheme);
             break;
         case "create": {
             if (args.length < 2) {
-                log(chalk.red("Usage: create <name> <symbol> [--photo URL] [--banner URL] [--website URL]"));
+                log(chalk.red("Usage: create <name> <symbol> [--photo URL|path] [--website URL]"));
                 return;
             }
             const [name, symbol] = args;
-            const photoUrl = extractFlag(args, "--photo");
-            const bannerUrl = extractFlag(args, "--banner");
+            let photoUrl = extractFlag(args, "--photo");
             const websiteUrl = extractFlag(args, "--website");
-            log(chalk.dim("Creating token..."));
+            // Process photo if it's a file path (show loading state)
+            if (photoUrl && isFilePath(photoUrl)) {
+                log(chalk.blue("Uploading image..."));
+                screen.render();
+                try {
+                    photoUrl = processPhotoUrl(photoUrl);
+                    log(chalk.green("✓ Image uploaded"));
+                    screen.render();
+                }
+                catch (error) {
+                    log(chalk.red(`Failed to upload image: ${error instanceof Error ? error.message : String(error)}`));
+                    screen.render();
+                    return;
+                }
+            }
+            log(chalk.blue("Creating token..."));
             screen.render();
             const result = await createToken(client, {
                 name,
                 symbol,
                 photoUrl,
-                bannerUrl,
                 websiteUrl,
             });
             displayCreateResultToLog(result, log, logLines);
@@ -185,14 +640,21 @@ async function handleCommand(client, command, args, log, logLines, screen, input
         }
         case "buy": {
             if (args.length < 2) {
-                log(chalk.red("Usage: buy <address|name|symbol> <amount>"));
+                log(chalk.red("Usage: buy <address|name|symbol> <amount> [--repeat <count>] [--delay <ms>]"));
                 log(chalk.dim("  amount: 0.05, 0.10, or 0.20 (test mode) or 50, 100, 200 (production)"));
-                log(chalk.dim('  Examples: buy 0x1234... 0.20, buy "My Token" 0.10, buy MTK 0.05'));
+                log(chalk.dim('  Examples: buy 0x1234... 0.20, buy "My Token" 0.10, buy MTK 0.05 --repeat 10'));
                 return;
             }
             const [identifier, amountInput] = args;
             const isTestMode = client.getNetwork().includes("sepolia");
             const validAmounts = isTestMode ? TEST_AMOUNTS : PROD_AMOUNTS;
+            // Parse flags
+            const repeatCount = extractFlag(args, "--repeat")
+                ? parseInt(extractFlag(args, "--repeat") || "1", 10)
+                : undefined;
+            const delayMs = extractFlag(args, "--delay")
+                ? parseInt(extractFlag(args, "--delay") || "0", 10)
+                : 0;
             // Try to validate and normalize the amount
             let amount;
             try {
@@ -204,10 +666,105 @@ async function handleCommand(client, command, args, log, logLines, screen, input
                 log(chalk.dim(`Valid amounts: ${validAmounts.join(", ")}`));
                 return;
             }
-            log(chalk.dim("Buying tokens..."));
-            screen.render();
-            const result = await buyToken(client, identifier, amount, isTestMode, false);
-            displayBuyResultToLog(result, log, logLines);
+            const privateKey = config.getPrivateKey();
+            // Handle repeat mode
+            if (repeatCount && repeatCount > 0) {
+                const results = [];
+                let totalSpent = 0;
+                let stoppedEarly = false;
+                let stopReason = "";
+                for (let i = 1; i <= repeatCount; i++) {
+                    try {
+                        log(chalk.blue(`Buy ${i}/${repeatCount}...`));
+                        screen.render();
+                        const result = await buyToken(client, identifier, amount, isTestMode, true, // silent=true to avoid console.log interference
+                        privateKey);
+                        results.push(result);
+                        totalSpent += parseFloat(result.amountSpent);
+                        // Display compact result
+                        displayBuyResultToLog(result, log, logLines);
+                        // Check if token graduated
+                        if (result.graduationReached) {
+                            stoppedEarly = true;
+                            stopReason = "Token graduated";
+                            log(chalk.green("🎓 Token has graduated! Stopping buy loop."));
+                            break;
+                        }
+                        // Apply delay between iterations (except after the last one)
+                        if (i < repeatCount && delayMs > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, delayMs));
+                        }
+                    }
+                    catch (error) {
+                        // Handle insufficient funds (402) gracefully
+                        if (error instanceof HttpcatError && error.status === 402) {
+                            stoppedEarly = true;
+                            stopReason = "Insufficient funds";
+                            log(chalk.yellow("💡 Insufficient funds. Stopping buy loop."));
+                            log("");
+                            // Show current balance to help diagnose the issue
+                            try {
+                                const balance = await checkBalance(privateKey, true);
+                                log(chalk.cyan("💰 Current Wallet Balances:"));
+                                log(chalk.dim(`   ETH:  ${balance.ethFormatted}`));
+                                log(chalk.dim(`   USDC: ${balance.usdcFormatted}`));
+                                if (balance.cat402Formatted) {
+                                    log(chalk.dim(`   CAT:  ${balance.cat402Formatted}`));
+                                }
+                                log("");
+                                // Provide guidance based on what might be insufficient
+                                const usdcBalance = parseFloat(balance.usdcFormatted.replace("$", "").replace(",", ""));
+                                const ethBalance = parseFloat(balance.ethFormatted.replace(" ETH", "").replace(",", ""));
+                                const buyAmount = parseFloat(amount);
+                                log(chalk.yellow("💡 Possible issues:"));
+                                if (usdcBalance < buyAmount) {
+                                    log(chalk.dim(`   • Insufficient USDC for purchase: Need $${buyAmount.toFixed(6)}, have $${usdcBalance.toFixed(6)}`));
+                                }
+                                if (usdcBalance < 0.01) {
+                                    log(chalk.dim(`   • Low USDC for API payments: x402 protocol requires USDC for API calls`));
+                                }
+                                if (ethBalance < 0.001) {
+                                    log(chalk.dim(`   • Low ETH for gas: Need ETH to pay for transaction fees`));
+                                }
+                                log("");
+                                log(chalk.dim("   Check your balance with: balances"));
+                            }
+                            catch (balanceError) {
+                                // If we can't fetch balance, just show generic message
+                                log(chalk.dim("   Check your balance with: balances"));
+                            }
+                            break;
+                        }
+                        // For other errors, re-throw to be handled by outer catch
+                        throw error;
+                    }
+                }
+                // Show final summary
+                if (results.length > 0) {
+                    const lastResult = results[results.length - 1];
+                    const graduationStatus = lastResult.graduationReached
+                        ? "✅ GRADUATED!"
+                        : `${(lastResult.graduationProgress || 0).toFixed(2)}%`;
+                    log("");
+                    log(chalk.cyan.bold("📊 Repeat Buy Summary"));
+                    log(chalk.dim("─".repeat(50)));
+                    log(`Total buys completed: ${chalk.bold(results.length.toString())}${repeatCount ? `/${repeatCount}` : ""}`);
+                    log(`Total amount spent: ${chalk.bold(`$${totalSpent.toFixed(2)}`)}`);
+                    log(`Final token price: ${chalk.bold(lastResult.newPrice)}`);
+                    log(`Final graduation: ${chalk.bold(graduationStatus)}`);
+                    if (stoppedEarly) {
+                        log(`Stopped early: ${chalk.yellow(stopReason)}`);
+                    }
+                }
+            }
+            else {
+                // Normal single buy execution
+                log(chalk.blue("Buying tokens..."));
+                screen.render();
+                const result = await buyToken(client, identifier, amount, isTestMode, true, // silent=true to avoid console.log interference
+                privateKey);
+                displayBuyResultToLog(result, log, logLines);
+            }
             break;
         }
         case "sell": {
@@ -217,17 +774,21 @@ async function handleCommand(client, command, args, log, logLines, screen, input
                 return;
             }
             const [identifier, amountInput] = args;
-            log(chalk.dim("Checking token info..."));
+            // Get user address from private key for position checking
+            const privateKey = config.getPrivateKey();
+            const account = privateKeyToAccount(privateKey);
+            const userAddress = account.address;
+            log(chalk.blue("Checking token info..."));
             screen.render();
-            const info = await getTokenInfo(client, identifier);
+            const info = await getTokenInfo(client, identifier, userAddress, true); // silent=true to avoid console.log interference
             if (!info.userPosition || info.userPosition.tokensOwned === "0") {
                 log(chalk.yellow("You do not own any of this token."));
                 return;
             }
             const tokenAmount = parseTokenAmount(amountInput, info.userPosition.tokensOwned);
-            log(chalk.dim("Selling tokens..."));
+            log(chalk.blue("Selling tokens..."));
             screen.render();
-            const result = await sellToken(client, identifier, tokenAmount, false);
+            const result = await sellToken(client, identifier, tokenAmount, true, privateKey); // silent=true to avoid console.log interference
             displaySellResultToLog(result, log, logLines);
             break;
         }
@@ -242,9 +803,9 @@ async function handleCommand(client, command, args, log, logLines, screen, input
             const privateKey = config.getPrivateKey();
             const account = privateKeyToAccount(privateKey);
             const userAddress = account.address;
-            log(chalk.dim("Fetching token info..."));
+            log(chalk.blue("Fetching token info..."));
             screen.render();
-            const info = await getTokenInfo(client, identifier, userAddress);
+            const info = await getTokenInfo(client, identifier, userAddress, true); // silent=true to avoid console.log interference
             displayTokenInfoToLog(info, log, logLines);
             break;
         }
@@ -252,20 +813,34 @@ async function handleCommand(client, command, args, log, logLines, screen, input
             const page = parseInt(extractFlag(args, "--page") || "1");
             const limit = parseInt(extractFlag(args, "--limit") || "20");
             const sortBy = (extractFlag(args, "--sort") || "mcap");
-            log(chalk.dim("Fetching token list..."));
+            log(chalk.blue("Fetching token list..."));
             screen.render();
             const result = await listTokens(client, page, limit, sortBy);
-            displayTokenListToLog(result, log, logLines);
+            displayTokenListToLog(result, log, logLines, logLinesSmooth);
             break;
         }
         case "positions": {
             const privateKey = config.getPrivateKey();
             const account = privateKeyToAccount(privateKey);
             const userAddress = account.address;
-            log(chalk.dim("Fetching positions..."));
+            // Parse flags
+            const activeOnly = args.includes("--active");
+            const graduatedOnly = args.includes("--graduated");
+            log(chalk.blue("Fetching positions..."));
             screen.render();
             const result = await getPositions(client, userAddress);
-            displayPositionsToLog(result, log, logLines);
+            // Filter positions if flags are set
+            let filteredResult = result;
+            if (activeOnly || graduatedOnly) {
+                filteredResult = {
+                    ...result,
+                    positions: result.positions.filter((p) => activeOnly
+                        ? p.token.status !== "graduated"
+                        : p.token.status === "graduated"),
+                };
+                filteredResult.total = filteredResult.positions.length;
+            }
+            displayPositionsToLog(filteredResult, log, logLines);
             break;
         }
         case "health": {
@@ -278,15 +853,15 @@ async function handleCommand(client, command, args, log, logLines, screen, input
         case "balances": {
             try {
                 const privateKey = config.getPrivateKey();
-                log(chalk.dim("Checking balance..."));
+                log(chalk.blue("Checking balance..."));
                 screen.render();
-                const balance = await checkBalance(privateKey);
+                const balance = await checkBalance(privateKey, true); // silent mode
                 displayBalanceToLog(balance, log, logLines);
             }
             catch (error) {
-                log(chalk.dim("Checking balance..."));
+                log(chalk.blue("Checking balance..."));
                 screen.render();
-                const balance = await checkBalance();
+                const balance = await checkBalance(undefined, true); // silent mode
                 displayBalanceToLog(balance, log, logLines);
             }
             break;
@@ -309,17 +884,22 @@ async function handleCommand(client, command, args, log, logLines, screen, input
             break;
         }
         case "network": {
-            log(chalk.yellow("Current network: ") + chalk.cyan(config.get("network")));
-            log(chalk.dim("Note: Only base-sepolia (testnet) is currently supported"));
+            log(chalk.yellow("Current network: ") + chalk.green(config.get("network")));
+            log(chalk.blue("Note: Only base-sepolia (testnet) is currently supported"));
             break;
         }
         case "chat": {
-            // For chat, we need to exit the blessed shell and start chat stream
-            log(chalk.yellow("Starting chat mode..."));
-            screen.destroy();
-            const tokenIdentifier = args.length > 0 ? args[0] : undefined;
-            await startChatStream(client, false, tokenIdentifier);
-            process.exit(0);
+            const tokenIdentifier = args.length > 0 && !args[0].startsWith("--") ? args[0] : undefined;
+            log(chalk.yellow("💬 Entering chat mode..."));
+            log(chalk.dim("Type /exit to return to shell, or /help for chat commands"));
+            log("");
+            // Start chat mode within the shell
+            // Store original submit handler
+            const originalHandlers = inputBox.listeners("submit");
+            const originalSubmitHandler = originalHandlers[0];
+            // Remove original handler temporarily
+            inputBox.removeAllListeners("submit");
+            await startChatInShell(client, tokenIdentifier, log, logLines, screen, inputBox, originalSubmitHandler, headerBox, buildWelcomeContent, currentTheme, catFaces, currentCatIndex);
             break;
         }
         case "exit":
@@ -333,115 +913,737 @@ async function handleCommand(client, command, args, log, logLines, screen, input
             // Clear the output box
             screen.children[1].setContent("");
             screen.render();
+            // Show playful message with ASCII cat
+            const catArt = currentTheme === "dark"
+                ? `{green-fg}  /\\_/\\{/green-fg}
+{green-fg} ( ^.^ ){/green-fg}
+{green-fg}  > ^ <{/green-fg}`
+                : `{black-fg}  /\\_/\\{/black-fg}
+{black-fg} ( ^.^ ){/black-fg}
+{black-fg}  > ^ <{/black-fg}`;
+            log("");
+            log(catArt);
+            log(chalk.green.bold("Terminal cleared!"));
+            log("");
             break;
+        case "claim": {
+            if (args.length < 1) {
+                log(chalk.red("Usage: claim <address|name|symbol> [--execute] [--address <address>]"));
+                log(chalk.dim('  Examples: claim MTK, claim "My Token" --execute'));
+                return;
+            }
+            const [identifier] = args;
+            const execute = args.includes("--execute");
+            const callerAddress = extractFlag(args, "--address");
+            if (execute) {
+                const privateKey = config.getPrivateKey();
+                const account = privateKeyToAccount(privateKey);
+                const address = callerAddress || account.address;
+                log(chalk.blue("Claiming fees..."));
+                screen.render();
+                const result = await claimFees(client, identifier, address, true); // silent=true to avoid console.log interference
+                displayClaimResultToLog(result, log, logLines);
+            }
+            else {
+                log(chalk.blue("Fetching fee information..."));
+                screen.render();
+                const result = await viewFees(client, identifier, true); // silent=true to avoid console.log interference
+                displayFeesToLog(result, log, logLines);
+            }
+            break;
+        }
+        case "transactions": {
+            const privateKey = config.getPrivateKey();
+            const account = privateKeyToAccount(privateKey);
+            const userAddress = account.address;
+            const input = {};
+            if (extractFlag(args, "--user")) {
+                input.userAddress = extractFlag(args, "--user");
+            }
+            else {
+                input.userAddress = userAddress;
+            }
+            if (extractFlag(args, "--token")) {
+                input.tokenId = extractFlag(args, "--token");
+            }
+            if (extractFlag(args, "--type")) {
+                const type = extractFlag(args, "--type");
+                if (!["buy", "sell", "airdrop"].includes(type || "")) {
+                    log(chalk.red("Invalid type. Must be: buy, sell, or airdrop"));
+                    return;
+                }
+                input.type = type;
+            }
+            if (extractFlag(args, "--limit")) {
+                input.limit = parseInt(extractFlag(args, "--limit") || "50", 10);
+            }
+            else {
+                input.limit = 50;
+            }
+            if (extractFlag(args, "--offset")) {
+                input.offset = parseInt(extractFlag(args, "--offset") || "0", 10);
+            }
+            else {
+                input.offset = 0;
+            }
+            log(chalk.blue("Fetching transactions..."));
+            screen.render();
+            const result = await getTransactions(client, input);
+            displayTransactionsToLog(result, log, logLines);
+            break;
+        }
+        case "account": {
+            if (args.length === 0) {
+                // Show account info
+                log(chalk.blue("Fetching account information..."));
+                screen.render();
+                const result = await getAccountInfo();
+                displayAccountInfoToLog(result, log, logLines);
+            }
+            else if (args[0] === "list") {
+                // For list, we need to capture console output or recreate the display
+                const accounts = config.getAllAccounts();
+                const activeIndex = config.getActiveAccountIndex();
+                log("");
+                log(chalk.green.bold("📋 All Accounts"));
+                log("");
+                if (accounts.length === 0) {
+                    log(chalk.yellow("No accounts configured."));
+                    log(chalk.blue('Run "httpcat config" to set up your wallet.'));
+                    return;
+                }
+                for (const account of accounts) {
+                    const isActive = account.index === activeIndex;
+                    const status = isActive
+                        ? chalk.green("● Active")
+                        : chalk.blue("○ Inactive");
+                    const type = account.type === "custom" ? "Custom" : "Seed-Derived";
+                    const address = account.address.slice(0, 6) + "..." + account.address.slice(-4);
+                    log(`  ${chalk.green(account.index.toString().padEnd(5))} ${chalk.blue(type.padEnd(12))} ${chalk.green(address.padEnd(15))} ${status}`);
+                }
+                log("");
+                log(chalk.blue(`Active account: ${chalk.green(activeIndex.toString())}`));
+            }
+            else if (args[0] === "switch") {
+                if (args.length < 2) {
+                    log(chalk.red("Usage: account switch <index>"));
+                    return;
+                }
+                const index = parseInt(args[1], 10);
+                if (isNaN(index)) {
+                    log(chalk.red("Invalid account index"));
+                    return;
+                }
+                switchAccount(index);
+                const accounts = config.getAllAccounts();
+                const account = accounts.find((acc) => acc.index === index);
+                log(chalk.green(`✅ Switched to account ${index}`));
+                if (account) {
+                    log(chalk.blue(`   Address: ${account.address.slice(0, 6)}...${account.address.slice(-4)}`));
+                }
+                // Refresh header with new account info
+                buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face).then((content) => {
+                    headerBox.setContent(content);
+                    screen.render();
+                });
+            }
+            else if (args[0] === "add") {
+                log(chalk.blue("Adding new account..."));
+                screen.render();
+                await addAccount();
+                log(chalk.green("✅ Account added"));
+                // Refresh header with new account info
+                buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face).then((content) => {
+                    headerBox.setContent(content);
+                    screen.render();
+                });
+            }
+            else {
+                log(chalk.red("Usage: account [list|switch <index>|add]"));
+            }
+            break;
+        }
+        case "env": {
+            if (args.length === 0 || args[0] === "show") {
+                const current = config.getCurrentEnvironment();
+                if (!current) {
+                    log(chalk.yellow("No environment selected"));
+                    return;
+                }
+                const env = config.getEnvironmentConfig(current);
+                if (!env) {
+                    log(chalk.yellow(`Environment "${current}" not found`));
+                    return;
+                }
+                log(chalk.cyan.bold(`Current Environment: ${chalk.green(current)}`));
+                log(chalk.dim(`Agent URL: ${env.agentUrl}`));
+                log(chalk.dim(`Network: ${env.network}`));
+            }
+            else if (args[0] === "list") {
+                const envs = config.getEnvironments();
+                const current = config.getCurrentEnvironment();
+                log(chalk.cyan.bold("Available Environments:"));
+                log("");
+                for (const [name, env] of Object.entries(envs)) {
+                    const isCurrent = name === current;
+                    const prefix = isCurrent ? chalk.green("→ ") : "  ";
+                    const nameDisplay = isCurrent
+                        ? chalk.green.bold(name)
+                        : chalk.bold(name);
+                    log(`${prefix}${nameDisplay}`);
+                    log(chalk.dim(`    Agent URL: ${env.agentUrl}`));
+                    log(chalk.dim(`    Network: ${env.network}`));
+                    log("");
+                }
+                if (current) {
+                    log(chalk.dim(`Current environment: ${chalk.green(current)}`));
+                }
+            }
+            else if (args[0] === "use") {
+                if (args.length < 2) {
+                    log(chalk.red("Usage: env use <name>"));
+                    return;
+                }
+                config.setEnvironment(args[1]);
+                const env = config.getEnvironmentConfig(args[1]);
+                log(chalk.green(`✅ Switched to environment: ${args[1]}`));
+                if (env) {
+                    log(chalk.dim(`   Agent URL: ${env.agentUrl}`));
+                    log(chalk.dim(`   Network: ${env.network}`));
+                }
+            }
+            else if (args[0] === "add") {
+                if (args.length < 3) {
+                    log(chalk.red("Usage: env add <name> <agentUrl> [--network <network>]"));
+                    return;
+                }
+                const network = extractFlag(args, "--network") || "base-sepolia";
+                config.addEnvironment(args[1], args[2], network);
+                log(chalk.green(`✅ Added environment: ${args[1]}`));
+                log(chalk.dim(`   Agent URL: ${args[2]}`));
+                log(chalk.dim(`   Network: ${network}`));
+            }
+            else if (args[0] === "update") {
+                if (args.length < 3) {
+                    log(chalk.red("Usage: env update <name> <agentUrl> [--network <network>]"));
+                    return;
+                }
+                const network = extractFlag(args, "--network") || "base-sepolia";
+                config.updateEnvironment(args[1], args[2], network);
+                log(chalk.green(`✅ Updated environment: ${args[1]}`));
+                log(chalk.dim(`   Agent URL: ${args[2]}`));
+                log(chalk.dim(`   Network: ${network}`));
+            }
+            else {
+                log(chalk.red("Usage: env [list|use <name>|show|add <name> <url>|update <name> <url>]"));
+            }
+            break;
+        }
+        case "agent":
+        case "ai":
+        case "cat": {
+            // Check if --chat flag is provided (for future chat mode)
+            if (args[0] === "--chat") {
+                log(chalk.yellow("⚠️  Agent chat mode is currently disabled"));
+                log(chalk.dim("Use 'agent <query>' or 'cat <query>' to ask the cat directly."));
+                log("");
+                break;
+            }
+            // Check if --setup flag is provided
+            if (args[0] === "--setup") {
+                try {
+                    await setupAIAgentWizard();
+                    log(chalk.green("✅ Agent configuration updated!"));
+                    log("");
+                }
+                catch (error) {
+                    log(chalk.red(`❌ Setup failed: ${error.message || String(error)}`));
+                    log("");
+                }
+                break;
+            }
+            // Get the query text (everything after the command)
+            const query = args.join(" ").trim();
+            if (!query) {
+                log(chalk.yellow("Usage: agent <query>"));
+                log(chalk.dim("Example: agent 'buy 0.1 USDC worth of WHALE'"));
+                log(chalk.dim("Example: cat 'check my balance'"));
+                log("");
+                break;
+            }
+            // Check if agent is configured
+            const agentConfig = config.getAIAgentConfig();
+            if (!agentConfig) {
+                log(chalk.yellow("⚠️  Agent not configured"));
+                log(chalk.dim("Run 'agent --setup' to configure the AI agent."));
+                log("");
+                break;
+            }
+            const apiKey = config.getAIAgentApiKey();
+            if (!apiKey) {
+                log(chalk.red("❌ Failed to get API key"));
+                log(chalk.dim("Run 'agent --setup' to configure the API key."));
+                log("");
+                break;
+            }
+            try {
+                // Get account address for session ID
+                const privateKey = config.getPrivateKey();
+                const account = privateKeyToAccount(privateKey);
+                const sessionId = account.address;
+                // Show thinking indicator
+                log(chalk.blue("🐱 Cat thinking..."));
+                screen.render();
+                // Create LLM and agent
+                const llm = createLLM(agentConfig, apiKey);
+                const agent = createHttpcatAgent(client, llm);
+                // Chat with agent (pass session ID so it remembers)
+                const response = await chatWithAgent(agent, llm, query, sessionId);
+                // Display response
+                log("");
+                log(chalk.green("🐱 Cat:"));
+                log(chalk.white(response));
+                log("");
+            }
+            catch (error) {
+                // Enhanced error logging
+                if (process.env.HTTPCAT_DEBUG) {
+                    log(chalk.red(`❌ Error details: ${JSON.stringify(error, null, 2)}`));
+                    if (error.stack) {
+                        log(chalk.dim(error.stack));
+                    }
+                }
+                // Check for authentication errors
+                const errorMessage = error?.message || String(error);
+                if (errorMessage.includes("Authentication failed") ||
+                    errorMessage.includes("API key") ||
+                    errorMessage.includes("401") ||
+                    errorMessage.includes("403") ||
+                    errorMessage.includes("Unauthorized") ||
+                    errorMessage.includes("Invalid API key")) {
+                    log(chalk.red("❌ Authentication failed"));
+                    log(chalk.dim("Your API key may be invalid or expired."));
+                    log(chalk.dim("Run 'agent --setup' to reconfigure."));
+                }
+                else {
+                    log(chalk.red(`❌ Error: ${errorMessage}`));
+                }
+                log("");
+            }
+            break;
+        }
         default:
             log(chalk.red(`Unknown command: ${command}`));
             log(chalk.dim('Type "help" for available commands'));
     }
 }
-function displayHelp(log, logLines) {
-    log("");
-    log(chalk.cyan.bold("Available Commands:"));
-    log("");
-    const commands = [
-        ["create <name> <symbol>", "Create a new token"],
-        ["buy <address|name|symbol> <amount>", "Buy tokens ($0.05, $0.10, or $0.20)"],
-        ["sell <address|name|symbol> <amount|all>", "Sell tokens"],
-        ["info <address|name|symbol>", "Get token information"],
-        ["list [--sort mcap|created]", "List all tokens"],
-        ["positions", "Get all your positions with comprehensive info"],
-        ["balances", "Check wallet balances (ETH and USDC)"],
-        [
-            "chat [token]",
-            "Start streaming chat (optional: token symbol/name/address)",
-        ],
-        ["health", "Check agent health"],
-        ["config [--show|--set|--reset]", "Manage configuration"],
-        ["network", "Show current network"],
-        ["clear", "Clear the output"],
-        ["help", "Show this help message"],
-        ["exit", "Exit the shell"],
-    ];
-    for (const [cmd, desc] of commands) {
-        log(`  ${chalk.cyan(cmd.padEnd(30))} ${chalk.dim(desc)}`);
+function displayWelcomeMessage(log, logLines, outputBox, screen, theme = "dark") {
+    // Helper to get theme-appropriate colors
+    const getCyanColor = (t) => t === "dark" ? "light-cyan-fg" : "cyan-fg";
+    const getBlueColor = (t) => t === "dark" ? "light-blue-fg" : "blue-fg";
+    const cyanColor = getCyanColor(theme);
+    const blueColor = getBlueColor(theme);
+    // If we have outputBox, use blessed tags instead of chalk to avoid question marks
+    // Otherwise fall back to the log function with chalk
+    if (outputBox && screen) {
+        const welcomeLines = [
+            "",
+            `{bold}{${cyanColor}}🐱 Welcome to httpcat!{/${cyanColor}}{/bold}`,
+            "",
+            "{yellow-fg}✨ Here are some commands to get you started:{/yellow-fg}",
+            "",
+            "{green-fg}  📋 list{/green-fg} - Browse all available tokens",
+            "{green-fg}  ℹ️  info <token>{/green-fg} - Get detailed info about a token",
+            "{green-fg}  💰 buy <token> <amount>{/green-fg} - Buy tokens (e.g., buy MTK 0.10)",
+            "{green-fg}  💼 positions{/green-fg} - View your portfolio",
+            "{green-fg}  💵 balances{/green-fg} - Check your wallet balance",
+            "",
+            `{${blueColor}}💡 Type {bold}help{/bold} to see all available commands!{/${blueColor}}`,
+            "",
+        ];
+        // Log all welcome lines at once
+        welcomeLines.forEach((line) => outputBox.log(line));
+        // Scroll to top so welcome message is visible
+        outputBox.setScrollPerc(0);
+        screen.render();
+    }
+    else {
+        // Fallback to regular log function if outputBox not available
+        log("");
+        log(chalk.cyan.bold("🐱 Welcome to httpcat!"));
+        log("");
+        log(chalk.yellow("✨ Here are some commands to get you started:"));
+        log("");
+        log(chalk.green("  📋 list") +
+            chalk.dim("                    - Browse all available tokens"));
+        log(chalk.green("  ℹ️  info <token>") +
+            chalk.dim("            - Get detailed info about a token"));
+        log(chalk.green("  💰 buy <token> <amount>") +
+            chalk.dim("     - Buy tokens (e.g., buy MTK 0.10)"));
+        log(chalk.green("  💼 positions") +
+            chalk.dim("               - View your portfolio"));
+        log(chalk.green("  💵 balances") +
+            chalk.dim("                - Check your wallet balance"));
+        log("");
+        log(chalk.blue("💡 Type ") +
+            chalk.bold("help") +
+            chalk.blue(" to see all available commands!"));
+        log("");
+    }
+}
+function displayHelp(log, logLines, outputBox, screen, theme = "dark") {
+    // Helper to get theme-appropriate colors
+    const getCyanColor = (t) => t === "dark" ? "light-cyan-fg" : "cyan-fg";
+    const getBlueColor = (t) => t === "dark" ? "light-blue-fg" : "blue-fg";
+    const cyanColor = getCyanColor(theme);
+    const blueColor = getBlueColor(theme);
+    // If we have outputBox, use blessed tags instead of chalk to avoid question marks
+    // Otherwise fall back to the log function
+    if (outputBox && screen) {
+        // Get the line number where help will start (before logging)
+        const linesBeforeHelp = outputBox.lines?.length || 0;
+        // Collect all help lines using blessed tags
+        const helpLines = [
+            "",
+            `{${cyanColor}}{bold}Available Commands:{/bold}{/${cyanColor}}`,
+            "",
+            // Token Operations
+            `{${cyanColor}}{bold}Token Operations:{/bold}{/${cyanColor}}`,
+            "{green-fg}  create <name> <symbol>{/green-fg}",
+            "{green-fg}  buy <id> <amount> [--repeat N] [--delay MS]{/green-fg}",
+            "{green-fg}  sell <id> <amount|all>{/green-fg}",
+            "{green-fg}  claim <id> [--execute] [--address ADDR]{/green-fg}",
+            "",
+            // Token Information
+            `{${cyanColor}}{bold}Token Information:{/bold}{/${cyanColor}}`,
+            "{green-fg}  info <id>{/green-fg}",
+            "{green-fg}  list [--sort mcap|created|name] [--page N] [--limit N]{/green-fg}",
+            "",
+            // Portfolio
+            `{${cyanColor}}{bold}Portfolio:{/bold}{/${cyanColor}}`,
+            "{green-fg}  positions [--active|--graduated]{/green-fg}",
+            "{green-fg}  transactions [--user ADDR] [--token ID] [--type TYPE] [--limit N] [--offset N]{/green-fg}",
+            "{green-fg}  balances{/green-fg}",
+            "",
+            // Account Management
+            `{${cyanColor}}{bold}Account Management:{/bold}{/${cyanColor}}`,
+            "{green-fg}  account [list|switch <index>|add]{/green-fg}",
+            "{green-fg}  env [list|use <name>|show|add|update]{/green-fg}",
+            "",
+            // Social
+            `{${cyanColor}}{bold}Social:{/bold}{/${cyanColor}}`,
+            "{green-fg}  chat [token] [--input-format FORMAT]{/green-fg}",
+            "",
+            // Cat (agent and cat are synonyms)
+            `{${cyanColor}}{bold}Cat (or 'agent'):{/bold}{/${cyanColor}}`,
+            "{green-fg}  agent <query>{/green-fg} - Ask the cat to do something (or use 'cat')",
+            "{green-fg}  agent --chat{/green-fg} - Enter interactive chat mode (or 'cat --chat')",
+            "{green-fg}  agent --setup{/green-fg} - Configure API key/provider (or 'cat --setup')",
+            "",
+            // System
+            `{${cyanColor}}{bold}System:{/bold}{/${cyanColor}}`,
+            "{green-fg}  health{/green-fg}",
+            "{green-fg}  config [--show|--set|--reset]{/green-fg}",
+            "{green-fg}  network{/green-fg}",
+            "",
+            // Shell Commands
+            `{${cyanColor}}{bold}Shell Commands:{/bold}{/${cyanColor}}`,
+            "{green-fg}  clear{/green-fg}",
+            "{green-fg}  help{/green-fg}",
+            "{green-fg}  exit{/green-fg}",
+            "",
+            `{${blueColor}}Tip: Run any command without arguments to see detailed help{/${blueColor}}`,
+        ];
+        // Log all help lines at once
+        helpLines.forEach((line) => outputBox.log(line));
+        // Scroll to show "Available Commands" at the top of the visible area
+        // Get total lines after logging
+        const totalLines = outputBox.lines?.length || 0;
+        const visibleHeight = outputBox.height || 20;
+        if (totalLines > visibleHeight && linesBeforeHelp >= 0) {
+            // Calculate which line "Available Commands" is on (after the empty line)
+            const availableCommandsLine = linesBeforeHelp + 1;
+            // Calculate scroll percentage to show that line at the top
+            // Percentage = (line number / total lines) * 100
+            // But we want the line to be at the top, so we need to account for visible height
+            const scrollPerc = Math.max(0, Math.min(100, ((availableCommandsLine - 1) /
+                Math.max(1, totalLines - visibleHeight)) *
+                100));
+            outputBox.setScrollPerc(scrollPerc);
+        }
+        else {
+            // If all content fits in visible area or no previous content, scroll to top
+            outputBox.setScrollPerc(0);
+        }
+        screen.render();
+    }
+    else {
+        // Fallback to regular log function if outputBox not available
+        log("");
+        log(chalk.cyan.bold("Available Commands:"));
+        log("");
+        // Token Operations
+        log(chalk.bold(chalk.cyan("Token Operations:")));
+        log(chalk.green("  create <name> <symbol>"));
+        log(chalk.green("  buy <id> <amount> [--repeat N] [--delay MS]"));
+        log(chalk.green("  sell <id> <amount|all>"));
+        log(chalk.green("  claim <id> [--execute] [--address ADDR]"));
+        log("");
+        // Token Information
+        log(chalk.bold(chalk.cyan("Token Information:")));
+        log(chalk.green("  info <id>"));
+        log(chalk.green("  list [--sort mcap|created|name] [--page N] [--limit N]"));
+        log("");
+        // Portfolio
+        log(chalk.bold(chalk.cyan("Portfolio:")));
+        log(chalk.green("  positions [--active|--graduated]"));
+        log(chalk.green("  transactions [--user ADDR] [--token ID] [--type TYPE] [--limit N] [--offset N]"));
+        log(chalk.green("  balances"));
+        log("");
+        // Account Management
+        log(chalk.bold(chalk.cyan("Account Management:")));
+        log(chalk.green("  account [list|switch <index>|add]"));
+        log(chalk.green("  env [list|use <name>|show|add|update]"));
+        log("");
+        // Social
+        log(chalk.bold(chalk.cyan("Social:")));
+        log(chalk.green("  chat [token] [--input-format FORMAT]"));
+        log("");
+        // Cat (agent and cat are synonyms)
+        log(chalk.bold(chalk.cyan("Cat (or 'agent'):")));
+        log(chalk.green("  agent <query>") +
+            chalk.dim(" - Ask the cat to do something (or use 'cat')"));
+        log(chalk.green("  agent --chat") +
+            chalk.dim(" - Enter interactive chat mode (or 'cat --chat')"));
+        log(chalk.green("  agent --setup") +
+            chalk.dim(" - Configure API key/provider (or 'cat --setup')"));
+        log("");
+        // System
+        log(chalk.bold(chalk.cyan("System:")));
+        log(chalk.green("  health"));
+        log(chalk.green("  config [--show|--set|--reset]"));
+        log(chalk.green("  network"));
+        log("");
+        // Shell Commands
+        log(chalk.bold(chalk.cyan("Shell Commands:")));
+        log(chalk.green("  clear"));
+        log(chalk.green("  help"));
+        log(chalk.green("  exit"));
+        log("");
+        log(chalk.blue("Tip: Run any command without arguments to see detailed help"));
     }
-    log("");
-    log(chalk.dim("Examples:"));
-    log(chalk.dim('  create "My Token" "MTK"'));
-    log(chalk.dim("  buy 0x1234... 5"));
-    log(chalk.dim('  buy "My Token" 2'));
-    log(chalk.dim("  buy MTK 1"));
-    log(chalk.dim("  sell 0x1234... 50%"));
-    log(chalk.dim('  info "My Token"'));
-    log(chalk.dim("  list --sort mcap --limit 10"));
-    log(chalk.dim("  positions"));
 }
 function displayConfigToLog(log, logLines) {
     const cfg = config.getAll();
     log("");
-    log(chalk.cyan.bold("Current Configuration:"));
+    log(chalk.green.bold("Current Configuration:"));
     log("");
-    log(chalk.dim("Network: ") + chalk.cyan(cfg.network));
-    log(chalk.dim("Agent URL: ") + chalk.cyan(cfg.agentUrl));
-    log(chalk.dim("Facilitator: ") + chalk.cyan(cfg.facilitatorUrl));
-    log(chalk.dim("Max Payment: ") + chalk.cyan("$" + cfg.defaultMaxPayment));
-    log(chalk.dim("ASCII Art: ") +
-        chalk.cyan(cfg.preferences.enableAsciiArt ? "enabled" : "disabled"));
-    log(chalk.dim("Private Key: ") +
-        chalk.dim(cfg.privateKey ? "configured" : "not configured"));
+    log(chalk.blue("Network: ") + chalk.green(cfg.network));
+    log(chalk.blue("Agent URL: ") + chalk.green(cfg.agentUrl));
+    log(chalk.blue("Facilitator: ") + chalk.green(cfg.facilitatorUrl));
+    log(chalk.blue("Max Payment: ") + chalk.green("$" + cfg.defaultMaxPayment));
+    log(chalk.blue("ASCII Art: ") +
+        chalk.green(cfg.preferences.enableAsciiArt ? "enabled" : "disabled"));
+    log(chalk.blue("Private Key: ") +
+        chalk.blue(cfg.privateKey ? "configured" : "not configured"));
     log("");
-    log(chalk.dim(`Config file: ${config.getConfigPath()}`));
+    log(chalk.blue(`Config file: ${config.getConfigPath()}`));
 }
 // Simplified display functions that log to blessed output
 function displayCreateResultToLog(result, log, logLines) {
     log(chalk.green("Token created successfully!"));
-    log(chalk.dim("Name: ") + result.name);
-    log(chalk.dim("Symbol: ") + result.symbol);
+    log(chalk.blue("Name: ") + chalk.green(result.name));
+    log(chalk.blue("Symbol: ") + chalk.green(result.symbol));
     if (result.tokenAddress) {
-        log(chalk.dim("Address: ") + chalk.cyan(result.tokenAddress));
+        log(chalk.blue("Address: ") + chalk.green(result.tokenAddress));
     }
 }
 function displayBuyResultToLog(result, log, logLines) {
     log(chalk.green("Purchase successful!"));
-    log(chalk.dim("Tokens received: ") + chalk.cyan(result.tokensReceived));
-    log(chalk.dim("Amount spent: ") + chalk.yellow(result.amountSpent));
-    log(chalk.dim("New price: ") + chalk.cyan(result.newPrice));
-    log(chalk.dim("Graduation: ") +
+    log(chalk.blue("Tokens received: ") + chalk.green(result.tokensReceived));
+    log(chalk.blue("Amount spent: ") + chalk.yellow(result.amountSpent));
+    log(chalk.blue("New price: ") + chalk.green(result.newPrice));
+    log(chalk.blue("Graduation: ") +
         chalk.magenta(result.graduationProgress.toFixed(2) + "%"));
 }
 function displaySellResultToLog(result, log, logLines) {
     log(chalk.green("Sale successful!"));
-    log(chalk.dim("Tokens sold: ") + chalk.cyan(result.tokensSold));
-    log(chalk.dim("USDC received: ") + chalk.yellow(result.usdcReceived));
-    log(chalk.dim("New price: ") + chalk.cyan(result.newPrice));
-    log(chalk.dim("Graduation: ") +
-        chalk.magenta(result.graduationProgress.toFixed(2) + "%"));
+    log(chalk.blue("Tokens sold: ") +
+        chalk.green(formatTokenAmount(result.tokensSold || "0")));
+    log(chalk.blue("USDC received: ") +
+        chalk.yellow(formatCurrency(result.usdcReceived || "0", 6)));
+    if (result.fee) {
+        log(chalk.blue("Fee (1%): ") + chalk.yellow(formatCurrency(result.fee, 6)));
+    }
+    if (result.newPrice) {
+        log(chalk.blue("New price: ") + chalk.green(formatCurrency(result.newPrice)));
+    }
+    if (result.newMcap) {
+        log(chalk.blue("New market cap: ") +
+            chalk.yellow(formatCurrency(result.newMcap)));
+    }
+    if (result.graduationProgress !== undefined) {
+        log(chalk.blue("Graduation: ") +
+            chalk.magenta(result.graduationProgress.toFixed(2) + "%"));
+    }
+    if (result.txHash) {
+        log(chalk.blue("Transaction: ") + chalk.green(result.txHash));
+    }
+    else if (result.usdcTransferTx) {
+        log(chalk.blue("Transaction: ") + chalk.green(result.usdcTransferTx));
+    }
+    // Graduation progress bar
+    if (result.graduationProgress !== undefined) {
+        const barLength = 20;
+        const filled = Math.floor((result.graduationProgress / 100) * barLength);
+        const empty = barLength - filled;
+        const bar = "🐱" + "=".repeat(filled) + ">" + " ".repeat(empty);
+        log(chalk.yellow(`[${bar}] ${chalk.bold(result.graduationProgress.toFixed(2) + "%")} to moon!`));
+    }
+    // Display price impact warning for Uniswap swaps
+    if (result.source === "uniswap_v2" && result.priceImpact !== undefined) {
+        if (result.priceImpact < 0.5) {
+            log(chalk.green(`Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+        else if (result.priceImpact < 1) {
+            log(chalk.yellow(`Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+        else if (result.priceImpact < 3) {
+            log(chalk.red(`⚠️  HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+        else {
+            log(chalk.red(`🚨 VERY HIGH Price Impact: ${result.priceImpact.toFixed(2)}%`));
+        }
+    }
+    // Display route info for Uniswap swaps
+    if (result.source === "uniswap_v2" && result.route) {
+        const feePercent = result.routeFee
+            ? (result.routeFee / 10000).toFixed(2)
+            : "N/A";
+        log(chalk.cyan(`Route: ${result.route} (${feePercent}% fee)`));
+    }
 }
 function displayTokenInfoToLog(info, log, logLines) {
-    log(chalk.cyan.bold(info.name) + ` (${info.symbol})`);
-    if (info.tokenAddress) {
-        log(chalk.dim("Address: ") + info.tokenAddress);
-    }
-    log(chalk.dim("Price: ") + chalk.cyan(info.currentPrice));
-    log(chalk.dim("Market Cap: ") + chalk.yellow(info.marketCap));
-    log(chalk.dim("Supply: ") + info.totalSupply);
+    log("");
+    // Token header box
+    const priceDisplay = info.status === "graduated"
+        ? chalk.dim("--")
+        : info.price
+            ? formatCurrency(info.price)
+            : chalk.dim("N/A");
+    const mcapDisplay = info.status === "graduated"
+        ? chalk.dim("--")
+        : info.mcap
+            ? formatCurrency(info.mcap)
+            : chalk.dim("N/A");
+    // Create box-like display
+    log(chalk.green.bold(`📊 ${info.name} (${info.symbol})`));
+    log(chalk.dim("─".repeat(60)));
+    log(chalk.blue("Address: ") + chalk.green(formatAddress(info.address || "")));
+    log(chalk.blue("Status: ") + chalk.green(info.status || "unknown"));
+    log(chalk.blue("Price: ") + chalk.green(priceDisplay));
+    log(chalk.blue("Market Cap: ") + chalk.yellow(mcapDisplay));
+    log(chalk.blue("Total Supply: ") +
+        chalk.green(formatTokenAmount(info.totalSupply || "0")));
+    log(chalk.blue("Created: ") +
+        chalk.green(new Date(info.createdAt || Date.now()).toLocaleString()));
+    log("");
+    // Graduation progress
     if (info.graduationProgress !== undefined) {
-        log(chalk.dim("Graduation: ") +
-            chalk.magenta(info.graduationProgress.toFixed(2) + "%"));
+        const barLength = 20;
+        const filled = Math.floor((info.graduationProgress / 100) * barLength);
+        const empty = barLength - filled;
+        const bar = "🐱" + "=".repeat(filled) + ">" + " ".repeat(empty);
+        log(chalk.yellow(`[${bar}] ${chalk.bold(info.graduationProgress.toFixed(2) + "%")} to moon!`));
+        log("");
     }
+    // Position display
     if (info.userPosition && info.userPosition.tokensOwned !== "0") {
-        log(chalk.dim("Your position: ") +
-            chalk.green(info.userPosition.tokensOwned + " tokens"));
+        log(chalk.green.bold("💼 Your Position"));
+        log(chalk.dim("─".repeat(60)));
+        log(chalk.blue("Tokens Owned: ") +
+            chalk.green(formatTokenAmount(info.userPosition.tokensOwned)));
+        log(chalk.blue("Invested: ") +
+            chalk.green(formatCurrency(info.userPosition.usdcInvested || "0")));
+        if (info.userPosition.currentValue) {
+            log(chalk.blue("Current Value: ") +
+                chalk.green(formatCurrency(info.userPosition.currentValue)));
+        }
+        if (info.userPosition.pnl) {
+            const pnl = parseFloat(info.userPosition.pnl);
+            const pnlColor = pnl >= 0 ? chalk.green : chalk.red;
+            const pnlSign = pnl >= 0 ? "+" : "";
+            const pnlIcon = pnl >= 0 ? "🟢" : "🔴";
+            log(chalk.blue("P&L: ") +
+                `${pnlIcon} ${pnlColor(pnlSign + formatCurrency(info.userPosition.pnl))}`);
+        }
+        log("");
     }
 }
-function displayTokenListToLog(result, log, logLines) {
-    log(chalk.cyan.bold(`Tokens (${result.tokens.length} total):`));
-    log("");
-    for (const token of result.tokens.slice(0, 10)) {
-        log(`  ${chalk.cyan(token.symbol.padEnd(8))} ${token.name.padEnd(20)} ${chalk.yellow(token.marketCap || "N/A")}`);
+function displayTokenListToLog(result, log, logLines, logLinesSmooth) {
+    // Collect all lines first for smooth scrolling
+    const allLines = [];
+    allLines.push("");
+    allLines.push(chalk.green.bold(`Tokens (${result.total || result.tokens.length} total):`));
+    if (result.page && result.pages) {
+        allLines.push(chalk.dim(`Page ${result.page} of ${result.pages}`));
+    }
+    allLines.push("");
+    if (result.tokens.length === 0) {
+        allLines.push(chalk.yellow("No tokens found."));
+        // Use smooth scrolling if available, otherwise regular logLines
+        if (logLinesSmooth) {
+            logLinesSmooth(allLines, false);
+        }
+        else {
+            logLines(allLines);
+        }
+        return;
     }
-    if (result.tokens.length > 10) {
-        log(chalk.dim(`  ... and ${result.tokens.length - 10} more`));
+    // Show header
+    allLines.push(`  ${chalk.cyan.bold("Name".padEnd(20))} ${chalk.cyan.bold("Symbol".padEnd(10))} ${chalk.cyan.bold("Market Cap".padEnd(15))} ${chalk.cyan.bold("Price".padEnd(12))} ${chalk.cyan.bold("Graduation".padEnd(12))} ${chalk.cyan.bold("Status")}`);
+    allLines.push(chalk.dim("  " + "─".repeat(90)));
+    // Show tokens
+    for (const token of result.tokens) {
+        const graduationIcon = token.status === "graduated"
+            ? "[G]"
+            : token.graduationProgress >= 90
+                ? "[H]"
+                : token.graduationProgress >= 50
+                    ? "[M]"
+                    : "[L]";
+        const mcapDisplay = token.status === "graduated"
+            ? chalk.dim("--")
+            : formatCurrency(token.mcap || "0");
+        const priceDisplay = token.status === "graduated"
+            ? chalk.dim("--")
+            : formatCurrency(token.price || "0");
+        const graduationDisplay = `${graduationIcon} ${(token.graduationProgress || 0).toFixed(1)}%`;
+        const statusDisplay = token.status === "graduated"
+            ? chalk.green("✓ Graduated")
+            : chalk.yellow("Active");
+        allLines.push(`  ${chalk.bold(token.name.padEnd(20))} ${chalk.green(token.symbol.padEnd(10))} ${mcapDisplay.padEnd(15)} ${priceDisplay.padEnd(12)} ${graduationDisplay.padEnd(12)} ${statusDisplay}`);
+    }
+    allLines.push("");
+    if (result.page && result.pages && result.page < result.pages) {
+        allLines.push(chalk.dim(`Use --page ${result.page + 1} to see more tokens`));
+        allLines.push("");
+    }
+    // Show example commands
+    if (result.tokens.length > 0) {
+        const firstToken = result.tokens[0];
+        allLines.push(chalk.dim("Example commands:"));
+        allLines.push(chalk.dim(`   buy ${firstToken.symbol}`));
+        allLines.push(chalk.dim(`   sell ${firstToken.symbol}`));
+        allLines.push(chalk.dim(`   info ${firstToken.symbol}`));
+        allLines.push("");
+    }
+    // Use smooth scrolling if available (scrolls to show the list header), otherwise regular logLines
+    if (logLinesSmooth) {
+        logLinesSmooth(allLines, true); // scrollToTop=true to show the list header
+    }
+    else {
+        logLines(allLines);
     }
 }
 function displayPositionsToLog(result, log, logLines) {
@@ -449,27 +1651,61 @@ function displayPositionsToLog(result, log, logLines) {
         log(chalk.yellow("No positions found."));
         return;
     }
-    log(chalk.cyan.bold(`Your Positions (${result.positions.length}):`));
+    log(chalk.green.bold(`Your Positions (${result.positions.length}):`));
     log("");
     for (const pos of result.positions) {
-        log(`  ${chalk.cyan(pos.symbol || "???")} - ${chalk.green(pos.tokensOwned + " tokens")} @ ${chalk.yellow(pos.currentValue || "N/A")}`);
+        const tokenName = pos.token?.name || "???";
+        const tokenSymbol = pos.token?.symbol || "???";
+        const tokensDisplay = formatTokenAmount(pos.tokensOwned || "0");
+        const valueDisplay = pos.currentValue
+            ? formatCurrency(pos.currentValue)
+            : "N/A";
+        log(`  ${chalk.green.bold(`${tokenName} (${tokenSymbol})`)} - ${chalk.green(`${tokensDisplay} tokens`)} @ ${chalk.yellow(valueDisplay)}`);
     }
 }
 function displayHealthStatusToLog(health, log, logLines) {
-    const statusColor = health.status === "healthy" ? chalk.green : chalk.red;
+    const statusColor = health.status === "ok" || health.status === "healthy"
+        ? chalk.green
+        : chalk.red;
     log(statusColor(`Agent Status: ${health.status}`));
     if (health.version) {
-        log(chalk.dim("Version: ") + health.version);
+        log(chalk.blue("Version: ") + chalk.green(health.version));
     }
     if (health.uptime) {
-        log(chalk.dim("Uptime: ") + health.uptime);
+        log(chalk.blue("Uptime: ") + chalk.green(health.uptime));
     }
 }
 function displayBalanceToLog(balance, log, logLines) {
-    log(chalk.cyan.bold("Wallet Balance:"));
-    log(chalk.dim("Address: ") + chalk.cyan(balance.address));
-    log(chalk.dim("ETH: ") + chalk.yellow(balance.ethBalance));
-    log(chalk.dim("USDC: ") + chalk.green(balance.usdcBalance));
+    log("");
+    log(chalk.green.bold("Wallet Balance:"));
+    log(chalk.blue("Address: ") + chalk.green(balance.address));
+    log(chalk.blue("ETH: ") +
+        chalk.yellow(balance.ethFormatted || balance.ethBalance));
+    log(chalk.blue("USDC: ") +
+        chalk.green(balance.usdcFormatted || balance.usdcBalance));
+    if (balance.cat402Formatted) {
+        log(chalk.blue("CAT: ") + chalk.cyan(balance.cat402Formatted));
+    }
+    log("");
+    // Show warnings if balances are low
+    const ethNum = Number(balance.ethFormatted || balance.ethBalance);
+    const usdcNum = Number((balance.usdcFormatted || balance.usdcBalance)
+        .replace("$", "")
+        .replace(",", ""));
+    if (ethNum < 0.001 && usdcNum < 1) {
+        log(chalk.yellow("⚠️  Low balances detected!"));
+        log(chalk.dim("   You need Base Sepolia ETH for gas fees"));
+        log(chalk.dim("   You need Base Sepolia USDC for trading"));
+        log("");
+    }
+    else if (ethNum < 0.001) {
+        log(chalk.yellow("⚠️  Low ETH balance - you may not have enough for gas fees"));
+        log("");
+    }
+    else if (usdcNum < 1) {
+        log(chalk.yellow("⚠️  Low USDC balance - you may not have enough for trades"));
+        log("");
+    }
 }
 function extractFlag(args, flag) {
     const index = args.findIndex((arg) => arg === flag);
@@ -478,4 +1714,589 @@ function extractFlag(args, flag) {
     }
     return undefined;
 }
+function displayFeesToLog(fees, log, logLines) {
+    const hasFeesToken = BigInt(fees.feeToken || "0") > 0n;
+    const hasFeesPaired = BigInt(fees.feePaired || "0") > 0n;
+    const hasFees = hasFeesToken || hasFeesPaired;
+    log("");
+    log(chalk.green.bold(`💰 Accumulated Fees: ${fees.tokenName} (${fees.tokenSymbol})`));
+    log(chalk.blue("━".repeat(50)));
+    log(chalk.blue("Contract: ") + chalk.green(fees.tokenAddress));
+    log(chalk.blue("LP Status: ") +
+        chalk.green(fees.isLocked ? "🔒 Locked" : "❌ Not Locked"));
+    if (typeof fees.v4TickLower === "number" &&
+        typeof fees.v4TickUpper === "number" &&
+        typeof fees.v4TickCurrent === "number" &&
+        typeof fees.v4InRange === "boolean") {
+        log(chalk.blue("V4 Range: ") +
+            chalk.green(`[${fees.v4TickLower}, ${fees.v4TickUpper}) | Current: ${fees.v4TickCurrent} | In Range: ${fees.v4InRange ? "✅" : "❌"}`));
+    }
+    log("");
+    log(chalk.green("Total Fees:"));
+    log(chalk.blue("  Tokens: ") + chalk.green(hasFeesToken ? fees.feeToken : "0"));
+    log(chalk.blue("  USDC: ") +
+        chalk.green(hasFeesPaired ? fees.feePaired : "$0.00"));
+    log("");
+    log(chalk.green("Creator Share (80%):"));
+    log(chalk.blue("  Tokens: ") + chalk.green(fees.creatorToken || "0"));
+    log(chalk.blue("  USDC: ") + chalk.green(fees.creatorPaired || "$0.00"));
+    log("");
+    log(chalk.green("Platform Share (20%):"));
+    log(chalk.blue("  Tokens: ") + chalk.green(fees.platformToken || "0"));
+    log(chalk.blue("  USDC: ") + chalk.green(fees.platformPaired || "$0.00"));
+    log(chalk.blue("━".repeat(50)));
+    if (!hasFees) {
+        if (fees.v4InRange === false) {
+            log(chalk.yellow("\n⚠️  No fees accrued: position is out of range"));
+        }
+        else {
+            log(chalk.yellow("\n⚠️  No fees accumulated yet. Trade volume needed."));
+        }
+    }
+    else {
+        log(chalk.blue("\n💡 Run with --execute to claim fees"));
+    }
+}
+function displayClaimResultToLog(result, log, logLines) {
+    log(chalk.green("✅ Fees claimed successfully!"));
+    log(chalk.blue("Token: ") + chalk.green(result.tokenAddress));
+    log(chalk.blue("Transaction: ") + chalk.green(result.txHash));
+    log(chalk.blue("Claimed:"));
+    log(chalk.blue("  Tokens: ") + chalk.green(result.creatorToken || "0"));
+    log(chalk.blue("  USDC: ") + chalk.green(result.creatorPaired || "$0.00"));
+}
+function displayTransactionsToLog(result, log, logLines) {
+    log(chalk.green.bold(`📜 Transactions (${result.total} total)`));
+    log("");
+    if (result.transactions.length === 0) {
+        log(chalk.yellow("No transactions found."));
+        return;
+    }
+    for (let i = 0; i < result.transactions.length; i++) {
+        const tx = result.transactions[i];
+        const typeIcon = tx.type === "buy" ? "🟢" : tx.type === "sell" ? "🔴" : "🎁";
+        const statusIcon = tx.status === "success" ? "✅" : tx.status === "pending" ? "⏳" : "❌";
+        log(chalk.green.bold(`${i + 1}. ${typeIcon} ${tx.type.toUpperCase()} ${statusIcon} ${tx.status.toUpperCase()}`));
+        if (tx.token) {
+            log(chalk.blue(`   Token: ${tx.token.name} (${tx.token.symbol})`));
+        }
+        log(chalk.blue(`   Amount: ${tx.amount}`));
+        log(chalk.blue(`   Fee: ${tx.fee}`));
+        if (tx.txHash) {
+            log(chalk.blue(`   TX: ${tx.txHash}`));
+        }
+        log(chalk.blue(`   Date: ${new Date(tx.createdAt).toLocaleString()}`));
+        log("");
+    }
+    if (result.hasMore) {
+        log(chalk.blue(`Showing ${result.offset + 1}-${result.offset + result.transactions.length} of ${result.total}`));
+        log(chalk.blue(`Use --offset ${result.offset + result.limit} to see more`));
+    }
+}
+function displayAccountInfoToLog(data, log, logLines) {
+    const { account, balance } = data;
+    log("");
+    log(chalk.green.bold("👤 Account Information"));
+    log(chalk.blue("=".repeat(50)));
+    log("");
+    log(chalk.blue("Account Index: ") + chalk.green(account.index.toString()));
+    log(chalk.blue("Type: ") +
+        chalk.green(account.type === "custom" ? "Custom" : "Seed-Derived"));
+    log(chalk.blue("Address: ") + chalk.green(account.address));
+    if (account.label) {
+        log(chalk.blue("Label: ") + chalk.green(account.label));
+    }
+    log("");
+    log(chalk.green.bold("💰 Balances"));
+    log(chalk.blue("ETH: ") + chalk.yellow(balance.ethBalance));
+    log(chalk.blue("USDC: ") + chalk.green(balance.usdcBalance));
+    if (balance.cat402Formatted) {
+        log(chalk.blue("CAT: ") + chalk.green(balance.cat402Formatted));
+    }
+    log("");
+    if (data.positions && data.positions.positions.length > 0) {
+        log(chalk.green.bold("💼 Positions"));
+        log("");
+        displayPositionsToLog(data.positions, log, logLines);
+    }
+}
+// Helper function to format time remaining for lease
+function formatTimeRemaining(expiresAt) {
+    const now = new Date();
+    const diffMs = expiresAt.getTime() - now.getTime();
+    if (diffMs <= 0) {
+        return "expired";
+    }
+    const minutes = Math.floor(diffMs / 60000);
+    const seconds = Math.floor((diffMs % 60000) / 1000);
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+}
+// Helper function to build chat header content
+async function buildChatHeaderContent(theme, tokenInfo, tokenIdentifier, isConnected, leaseInfo, getCyanColor) {
+    const colorTag = theme === "dark" ? "green-fg" : "black-fg";
+    const cyanColor = getCyanColor(theme);
+    const lines = [];
+    // Title line
+    if (tokenInfo) {
+        lines.push(`{${colorTag}}💬 httpcat Chat: {${cyanColor}}${tokenInfo.name} (${tokenInfo.symbol}){/${cyanColor}}{/${colorTag}}`);
+    }
+    else if (tokenIdentifier) {
+        // Fallback to identifier if token lookup failed
+        const displayId = tokenIdentifier.length > 20
+            ? `${tokenIdentifier.slice(0, 10)}...${tokenIdentifier.slice(-6)}`
+            : tokenIdentifier;
+        lines.push(`{${colorTag}}💬 httpcat Chat: {${cyanColor}}${displayId}{/${cyanColor}}{/${colorTag}}`);
+    }
+    else {
+        lines.push(`{${colorTag}}💬 httpcat Chat: General{/${colorTag}}`);
+    }
+    lines.push(`{${colorTag}}${"═".repeat(60)}{/${colorTag}}`);
+    lines.push("");
+    // Connection status
+    if (isConnected) {
+        lines.push(`{green-fg}✅ Connected to chat stream{/green-fg}`);
+        lines.push("");
+    }
+    // Lease info
+    if (leaseInfo) {
+        const timeRemaining = formatTimeRemaining(leaseInfo.leaseExpiresAt);
+        const isExpired = leaseInfo.leaseExpiresAt.getTime() <= Date.now();
+        const timePrefix = isExpired ? "⚠️  " : "⏱️  ";
+        lines.push(`{yellow-fg}${timePrefix}Lease expires in: ${timeRemaining}{/yellow-fg}`);
+    }
+    lines.push("");
+    lines.push(`{${cyanColor}}💡 Type your message and press Enter to send{/${cyanColor}}`);
+    lines.push(`{${cyanColor}}💡 Type /exit to return to shell{/${cyanColor}}`);
+    lines.push(`{${cyanColor}}💡 Type /renew to renew your lease{/${cyanColor}}`);
+    if (tokenIdentifier) {
+        lines.push(`{${cyanColor}}💡 Type /buy <amount> to buy tokens{/${cyanColor}}`);
+        lines.push(`{${cyanColor}}💡 Type /sell <amount> to sell tokens{/${cyanColor}}`);
+    }
+    return lines.join("\n");
+}
+// Simplified chat mode that works within the shell
+async function startChatInShell(client, tokenIdentifier, log, logLines, screen, inputBox, originalSubmitHandler, headerBox, buildWelcomeContent, currentTheme, catFaces, currentCatIndex) {
+    const privateKey = config.getPrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    const userAddress = account.address;
+    let leaseInfo = null;
+    let ws = null;
+    let isInChatMode = true;
+    let isProcessing = false; // Flag to prevent duplicate processing
+    const displayedMessageIds = new Set();
+    // Helper to format chat messages
+    const formatChatMessage = (msg, isOwn = false) => {
+        const date = new Date(msg.timestamp);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffSec = Math.floor(diffMs / 1000);
+        const diffMin = Math.floor(diffSec / 60);
+        let timeStr = "just now";
+        if (diffSec >= 60) {
+            timeStr =
+                diffMin < 60
+                    ? `${diffMin}m ago`
+                    : date.toLocaleTimeString("en-US", {
+                        hour: "2-digit",
+                        minute: "2-digit",
+                    });
+        }
+        const authorColor = isOwn ? chalk.green : chalk.cyan;
+        const authorShort = msg.authorShort || formatAddress(msg.author, 6);
+        return `${chalk.dim(`[${timeStr}]`)} ${authorColor(authorShort)}: ${msg.message}`;
+    };
+    // Get token information if it's a token chat
+    let tokenInfo = null;
+    if (tokenIdentifier) {
+        try {
+            const info = await getTokenInfo(client, tokenIdentifier, userAddress, true);
+            tokenInfo = { name: info.name, symbol: info.symbol };
+        }
+        catch (error) {
+            // Token lookup failed - will use identifier in header
+            tokenInfo = null;
+        }
+    }
+    // Helper to get cyan color based on theme
+    const getCyanColor = (theme) => theme === "dark" ? "light-cyan-fg" : "cyan-fg";
+    // Helper to update header
+    const updateChatHeader = async (isConnected = false) => {
+        const content = await buildChatHeaderContent(currentTheme, tokenInfo, tokenIdentifier, isConnected, leaseInfo, getCyanColor);
+        headerBox.setContent(content);
+        screen.render();
+    };
+    // Update header to show chat mode
+    await updateChatHeader(false);
+    // Set up header update interval for lease countdown
+    let headerUpdateInterval = null;
+    try {
+        // Join chat
+        log(chalk.blue("Joining chat..."));
+        screen.render();
+        const joinResult = await joinChat(client, userAddress, tokenIdentifier, true);
+        leaseInfo = {
+            leaseId: joinResult.leaseId,
+            leaseExpiresAt: new Date(joinResult.leaseExpiresAt),
+        };
+        // Update header with lease info
+        await updateChatHeader(false);
+        // Display last messages
+        if (joinResult.lastMessages.length > 0) {
+            log(chalk.dim("─".repeat(60)));
+            log(chalk.cyan.bold("Recent messages:"));
+            for (const msg of joinResult.lastMessages) {
+                displayedMessageIds.add(msg.messageId);
+                const isOwn = msg.author.toLowerCase() === userAddress.toLowerCase();
+                log(formatChatMessage(msg, isOwn));
+            }
+            log(chalk.dim("─".repeat(60)));
+        }
+        // Connect to WebSocket
+        const agentUrl = client.getAgentUrl();
+        const normalizedWsUrl = normalizeWebSocketUrl(joinResult.wsUrl, agentUrl);
+        const wsUrlObj = new URL(normalizedWsUrl);
+        wsUrlObj.searchParams.set("leaseId", joinResult.leaseId);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        ws = new WebSocket(wsUrlObj.toString());
+        ws.on("open", () => {
+            log(chalk.green("✅ Connected to chat stream"));
+            updateChatHeader(true);
+            screen.render();
+        });
+        ws.on("message", (data) => {
+            try {
+                const event = JSON.parse(data.toString());
+                if (event.type === "message" && event.data) {
+                    const msg = {
+                        ...event.data,
+                        authorShort: formatAddress(event.data.author, 6),
+                    };
+                    if (!displayedMessageIds.has(msg.messageId)) {
+                        displayedMessageIds.add(msg.messageId);
+                        const isOwn = msg.author.toLowerCase() === userAddress.toLowerCase();
+                        log(formatChatMessage(msg, isOwn));
+                        screen.render();
+                    }
+                }
+                else if (event.type === "lease_expired") {
+                    log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue."));
+                    leaseInfo = null;
+                    updateChatHeader(true);
+                    screen.render();
+                }
+            }
+            catch (error) {
+                // Ignore parse errors
+            }
+        });
+        ws.on("error", (error) => {
+            log(chalk.red(`❌ WebSocket error: ${error.message}`));
+            screen.render();
+        });
+        ws.on("close", () => {
+            if (isInChatMode) {
+                log(chalk.yellow("⚠️  WebSocket connection closed"));
+                updateChatHeader(false);
+                screen.render();
+            }
+        });
+        // Start header update interval
+        headerUpdateInterval = setInterval(async () => {
+            if (leaseInfo && isInChatMode) {
+                await updateChatHeader(true);
+            }
+        }, 1000);
+        // Wait for connection
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error("Connection timeout")), 10000);
+            ws.once("open", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            ws.once("error", (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+        // Set up chat input handler
+        const chatInputHandler = async (value) => {
+            const trimmed = value.trim();
+            // Clear input immediately
+            inputBox.clearValue();
+            screen.render();
+            if (!trimmed) {
+                isProcessing = false;
+                inputBox.focus();
+                screen.render();
+                return;
+            }
+            // Handle commands
+            if (trimmed.startsWith("/")) {
+                const [cmd, ...cmdArgs] = trimmed.split(" ");
+                switch (cmd) {
+                    case "/exit":
+                    case "/quit":
+                        isInChatMode = false;
+                        if (headerUpdateInterval) {
+                            clearInterval(headerUpdateInterval);
+                            headerUpdateInterval = null;
+                        }
+                        if (ws) {
+                            ws.close();
+                            ws = null;
+                        }
+                        log(chalk.yellow("Exited chat mode. Back to shell."));
+                        log("");
+                        // Restore original header
+                        const originalContent = await buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face);
+                        headerBox.setContent(originalContent);
+                        // Restore original input handler
+                        inputBox.removeAllListeners("submit");
+                        inputBox.on("submit", originalSubmitHandler);
+                        isProcessing = false;
+                        inputBox.focus();
+                        screen.render();
+                        return;
+                    case "/renew":
+                        try {
+                            log(chalk.blue("Renewing lease..."));
+                            screen.render();
+                            const renewal = await renewLease(client, userAddress, leaseInfo?.leaseId);
+                            leaseInfo = {
+                                leaseId: renewal.leaseId,
+                                leaseExpiresAt: new Date(renewal.leaseExpiresAt),
+                            };
+                            await updateChatHeader(true);
+                            log(chalk.green("✅ Lease renewed!"));
+                            screen.render();
+                        }
+                        catch (error) {
+                            log(chalk.red(`❌ Renew failed: ${error instanceof Error ? error.message : String(error)}`));
+                            screen.render();
+                        }
+                        isProcessing = false;
+                        inputBox.focus();
+                        screen.render();
+                        return;
+                    case "/help":
+                        log(chalk.cyan("Chat commands: /exit, /quit, /renew, /help"));
+                        screen.render();
+                        isProcessing = false;
+                        inputBox.focus();
+                        screen.render();
+                        return;
+                    default:
+                        log(chalk.yellow(`Unknown command: ${cmd}. Type /help for commands.`));
+                        screen.render();
+                        isProcessing = false;
+                        inputBox.focus();
+                        screen.render();
+                        return;
+                }
+            }
+            // Send message
+            if (!leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
+                log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue."));
+                screen.render();
+                isProcessing = false;
+                inputBox.focus();
+                screen.render();
+                return;
+            }
+            try {
+                // Send message - it will appear via WebSocket when received
+                await sendChatMessage(client, trimmed, leaseInfo.leaseId, userAddress);
+                // Re-attach handler for next message
+                inputBox.removeAllListeners("submit");
+                inputBox.once("submit", chatInputHandler);
+                isProcessing = false;
+                inputBox.focus();
+                screen.render();
+            }
+            catch (error) {
+                log(chalk.red(`❌ Send failed: ${error instanceof Error ? error.message : String(error)}`));
+                screen.render();
+                // Re-attach handler for next message
+                inputBox.removeAllListeners("submit");
+                inputBox.once("submit", chatInputHandler);
+                isProcessing = false;
+                inputBox.focus();
+                screen.render();
+            }
+        };
+        // Temporarily replace input handler
+        // Remove all listeners first to ensure clean state
+        inputBox.removeAllListeners("submit");
+        // Clear any existing input value to prevent state issues
+        inputBox.clearValue();
+        // Add the chat handler - only one handler should be active
+        inputBox.once("submit", chatInputHandler);
+        // Ensure input box has focus and is ready
+        inputBox.focus();
+        screen.render();
+    }
+    catch (error) {
+        log(chalk.red(`❌ Chat error: ${error instanceof Error ? error.message : String(error)}`));
+        if (headerUpdateInterval) {
+            clearInterval(headerUpdateInterval);
+            headerUpdateInterval = null;
+        }
+        if (ws)
+            ws.close();
+        // Restore original header on error
+        const originalContent = await buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face);
+        headerBox.setContent(originalContent);
+        // Restore original handler on error
+        inputBox.removeAllListeners("submit");
+        inputBox.on("submit", originalSubmitHandler);
+        screen.render();
+        inputBox.focus();
+        screen.render();
+    }
+}
+/**
+ * Start agent chat mode (similar to startChatInShell)
+ */
+async function startAgentChatMode(client, log, logLines, screen, inputBox, headerBox, buildWelcomeContent, currentTheme, catFaces, currentCatIndex) {
+    let isProcessing = false;
+    // Get agent config
+    const agentConfig = config.getAIAgentConfig();
+    if (!agentConfig) {
+        throw new Error("Cat not configured");
+    }
+    const apiKey = config.getAIAgentApiKey();
+    if (!apiKey) {
+        throw new Error("Failed to get API key");
+    }
+    // Create LLM and agent
+    const llm = createLLM(agentConfig, apiKey);
+    const agent = createHttpcatAgent(client, llm);
+    // Helper to update header
+    const updateAgentHeader = async () => {
+        const colorTag = currentTheme === "dark" ? "green-fg" : "black-fg";
+        const cyanColor = currentTheme === "dark" ? "light-cyan-fg" : "cyan-fg";
+        const lines = [];
+        lines.push(`{${colorTag}}🐱 Cat Chat Mode{/${colorTag}}`);
+        lines.push(`{${colorTag}}${"═".repeat(60)}{/${colorTag}}`);
+        lines.push("");
+        lines.push(`{${cyanColor}}💡 Ask me to buy tokens, check balances, list tokens, and more!{/${cyanColor}}`);
+        lines.push(`{${cyanColor}}💡 Type /exit to return to shell{/${cyanColor}}`);
+        lines.push("");
+        const content = lines.join("\n");
+        headerBox.setContent(content);
+        screen.render();
+    };
+    // Update header to show agent mode
+    await updateAgentHeader();
+    // Store original submit handler
+    const originalHandlers = inputBox.listeners("submit");
+    const originalSubmitHandler = originalHandlers[0];
+    // Set up agent input handler (similar to chat mode)
+    const agentInputHandler = async (value) => {
+        // Guard against double processing
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const trimmed = value.trim();
+        // Clear input immediately
+        inputBox.clearValue();
+        screen.render();
+        if (!trimmed) {
+            isProcessing = false;
+            inputBox.focus();
+            screen.render();
+            return;
+        }
+        // Handle commands
+        if (trimmed.startsWith("/")) {
+            const [cmd] = trimmed.split(" ");
+            switch (cmd) {
+                case "/exit":
+                case "/quit":
+                    log(chalk.yellow("Exited cat mode. Back to shell."));
+                    log("");
+                    // Restore original header
+                    const originalContent = await buildWelcomeContent(currentTheme, catFaces[currentCatIndex].face);
+                    headerBox.setContent(originalContent);
+                    // Restore original input handler
+                    inputBox.removeAllListeners("submit");
+                    inputBox.on("submit", originalSubmitHandler);
+                    isProcessing = false;
+                    inputBox.focus();
+                    screen.render();
+                    return;
+                case "/help":
+                    log(chalk.cyan("Cat commands: /exit, /quit, /help"));
+                    isProcessing = false;
+                    inputBox.focus();
+                    screen.render();
+                    return;
+                default:
+                    log(chalk.yellow(`Unknown command: ${cmd}. Type /help for commands.`));
+                    isProcessing = false;
+                    inputBox.focus();
+                    screen.render();
+                    return;
+            }
+        }
+        // Send to agent
+        try {
+            log(chalk.blue("🐱 Cat thinking..."));
+            screen.render();
+            const response = await chatWithAgent(agent, llm, trimmed);
+            log(chalk.green("🐱 Cat:"));
+            log(response);
+            log("");
+        }
+        catch (error) {
+            const errorMsg = error.message || String(error);
+            const errorStack = error.stack || "";
+            // Log full error details for debugging
+            if (process.env.HTTPCAT_DEBUG) {
+                log(chalk.dim(`Debug: Full error: ${JSON.stringify(error, null, 2)}`));
+                if (errorStack) {
+                    log(chalk.dim(`Debug: Stack trace: ${errorStack}`));
+                }
+            }
+            log(chalk.red(`❌ Agent error: ${errorMsg}`));
+            // Check for authentication errors
+            const isAuthError = errorMsg.includes("Authentication failed") ||
+                errorMsg.includes("API key") ||
+                errorMsg.includes("401") ||
+                errorMsg.includes("403") ||
+                errorMsg.includes("Unauthorized") ||
+                errorMsg.includes("Invalid API key") ||
+                errorMsg.includes("authentication") ||
+                errorMsg.includes("Invalid API Key") ||
+                errorStack.includes("401") ||
+                errorStack.includes("403");
+            if (isAuthError) {
+                log("");
+                log(chalk.yellow("🔑 Authentication Error Detected"));
+                log(chalk.dim("Your API key may be invalid, expired, or incorrectly configured."));
+                log(chalk.dim("Exit cat mode and run 'agent' (or 'cat') again to re-run the setup wizard."));
+            }
+            log("");
+        }
+        isProcessing = false;
+        inputBox.focus();
+        screen.render();
+    };
+    // Remove original handler and add agent handler
+    inputBox.removeAllListeners("submit");
+    inputBox.on("submit", agentInputHandler);
+    // Clear and focus input
+    inputBox.clearValue();
+    inputBox.focus();
+    screen.render();
+    // Show welcome message
+    log(chalk.green("🐱 Cat chat mode activated!"));
+    log(chalk.dim("Ask me anything about tokens, trading, or your portfolio."));
+    log(chalk.dim("Type /exit to return to shell."));
+    log("");
+}
 //# sourceMappingURL=shell.js.map