httpcat-cli 0.2.13 → 0.3.0

package/dist/interactive/shell.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 // @ts-ignore - neo-blessed doesn't have types, but @types/blessed provides compatible types
 import blessed from "neo-blessed";
+import { HttpcatClient } from "../client.js";
 import { config } from "../config.js";
 import { printCat } from "./art.js";
 import { validateAmount } from "../utils/validation.js";
@@ -23,7 +24,6 @@ import { getAccountInfo, switchAccount, addAccount, } from "../commands/account.
 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")
@@ -646,7 +646,8 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
                 return;
             }
             const [identifier, amountInput] = args;
-            const isTestMode = client.getNetwork().includes("sepolia");
+            const network = client.getNetwork();
+            const isTestMode = network === "eip155:84532" || network === "eip155:11155111" || network.includes("sepolia");
             const validAmounts = isTestMode ? TEST_AMOUNTS : PROD_AMOUNTS;
             // Parse flags
             const repeatCount = extractFlag(args, "--repeat")
@@ -675,10 +676,61 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
                 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);
+                        // Retry logic: try up to 10 times with exponential backoff on 402 errors
+                        // Client is recreated on each attempt to ensure fresh signature for new nonce
+                        let result = null;
+                        let lastError = null;
+                        const maxRetries = 10;
+                        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                            try {
+                                if (attempt === 1) {
+                                    log(chalk.blue(`Buy ${i}/${repeatCount}...`));
+                                }
+                                else {
+                                    log(chalk.yellow(`  Retrying buy ${i}/${repeatCount} (attempt ${attempt}/${maxRetries})...`));
+                                }
+                                screen.render();
+                                // Recreate client inside the operation to ensure fresh signature
+                                // for each attempt (including retries). This fixes the issue where x402-fetch
+                                // generates a new nonce but reuses the same signature, causing subsequent buys to fail
+                                result = await (async () => {
+                                    // Recreate client for each attempt to ensure fresh signature for new nonce
+                                    const client = await HttpcatClient.create(privateKey);
+                                    return buyToken(client, identifier, amount, isTestMode, true, // silent=true to avoid console.log interference
+                                    privateKey);
+                                })();
+                                // Success! Break out of retry loop
+                                break;
+                            }
+                            catch (error) {
+                                lastError = error;
+                                // Only retry on 402 errors (payment required)
+                                const is402Error = error?.message?.includes("402") ||
+                                    error?.status === 402 ||
+                                    (typeof error === "string" && error.includes("402"));
+                                if (is402Error && attempt < maxRetries) {
+                                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s, 64s, 128s, 256s, 512s (capped at 10s)
+                                    const backoffMs = Math.min(Math.pow(2, attempt - 1) * 1000, 10000);
+                                    log(chalk.yellow(`  ⚠️  Payment required (attempt ${attempt}/${maxRetries}), retrying in ${backoffMs / 1000}s...`));
+                                    screen.render();
+                                    await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                                    continue; // Retry
+                                }
+                                else {
+                                    // Not a 402 error, or max retries reached - throw the error
+                                    throw error;
+                                }
+                            }
+                        }
+                        // If we exhausted retries, throw the last error
+                        if (!result) {
+                            if (lastError) {
+                                throw lastError;
+                            }
+                            else {
+                                throw new Error(`Failed to complete buy ${i}/${repeatCount} after ${maxRetries} attempts`);
+                            }
+                        }
                         results.push(result);
                         totalSpent += parseFloat(result.amountSpent);
                         // Display compact result
@@ -690,9 +742,63 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
                             log(chalk.green("🎓 Token has graduated! Stopping buy loop."));
                             break;
                         }
+                        // Wait for transaction confirmations if present
+                        // This ensures both the buy transaction and payment transaction are confirmed
+                        // before the next buy, preventing nonce/signature conflicts
+                        if (i < repeatCount) {
+                            const { createPublicClient, http } = await import("viem");
+                            const { baseSepolia } = await import("viem/chains");
+                            const publicClient = createPublicClient({
+                                chain: baseSepolia,
+                                transport: http(config.getRpcUrl()),
+                            });
+                            // Wait for payment transaction first (if present)
+                            // This is critical to ensure the payment nonce is consumed before next request
+                            if (result.paymentTxHash) {
+                                log(chalk.dim(`  Waiting for payment transaction confirmation...`));
+                                screen.render();
+                                try {
+                                    await publicClient.waitForTransactionReceipt({
+                                        hash: result.paymentTxHash,
+                                    });
+                                    log(chalk.dim(`  ✅ Payment transaction confirmed`));
+                                    screen.render();
+                                }
+                                catch (txError) {
+                                    log(chalk.yellow(`  ⚠️  Could not confirm payment transaction, proceeding...`));
+                                    screen.render();
+                                }
+                            }
+                            // Wait for buy transaction (if present)
+                            if (result.txHash) {
+                                log(chalk.dim(`  Waiting for buy transaction confirmation...`));
+                                screen.render();
+                                try {
+                                    await publicClient.waitForTransactionReceipt({
+                                        hash: result.txHash,
+                                    });
+                                    log(chalk.dim(`  ✅ Buy transaction confirmed`));
+                                    screen.render();
+                                }
+                                catch (txError) {
+                                    log(chalk.yellow(`  ⚠️  Could not confirm buy transaction, proceeding...`));
+                                    screen.render();
+                                }
+                            }
+                        }
                         // Apply delay between iterations (except after the last one)
-                        if (i < repeatCount && delayMs > 0) {
-                            await new Promise((resolve) => setTimeout(resolve, delayMs));
+                        // For bonding curve buys, we need a minimum delay to allow backend
+                        // to process the transaction and update balance state
+                        if (i < repeatCount) {
+                            const MIN_DELAY_MS = 2000; // 2 seconds minimum for backend processing
+                            const totalDelay = Math.max(delayMs, MIN_DELAY_MS);
+                            if (totalDelay > 0) {
+                                if (totalDelay === MIN_DELAY_MS && delayMs === 0) {
+                                    log(chalk.dim(`  Waiting ${totalDelay / 1000}s for backend to process...`));
+                                    screen.render();
+                                }
+                                await new Promise((resolve) => setTimeout(resolve, totalDelay));
+                            }
                         }
                     }
                     catch (error) {
@@ -1117,7 +1223,7 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
                     log(chalk.red("Usage: env add <name> <agentUrl> [--network <network>]"));
                     return;
                 }
-                const network = extractFlag(args, "--network") || "base-sepolia";
+                const network = extractFlag(args, "--network") || "eip155:84532";
                 config.addEnvironment(args[1], args[2], network);
                 log(chalk.green(`✅ Added environment: ${args[1]}`));
                 log(chalk.dim(`   Agent URL: ${args[2]}`));
@@ -1128,7 +1234,7 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
                     log(chalk.red("Usage: env update <name> <agentUrl> [--network <network>]"));
                     return;
                 }
-                const network = extractFlag(args, "--network") || "base-sepolia";
+                const network = extractFlag(args, "--network") || "eip155:84532";
                 config.updateEnvironment(args[1], args[2], network);
                 log(chalk.green(`✅ Updated environment: ${args[1]}`));
                 log(chalk.dim(`   Agent URL: ${args[2]}`));
@@ -1142,94 +1248,10 @@ async function handleCommand(client, command, args, log, logLines, logLinesSmoot
         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("");
-            }
+            log("");
+            log(chalk.yellow("⚠️  Agent command is only available in CLI mode"));
+            log(chalk.dim("Run 'httpcat cat' from the command line to start agent mode."));
+            log("");
             break;
         }
         default:
@@ -1941,6 +1963,7 @@ async function startChatInShell(client, tokenIdentifier, log, logLines, screen,
             leaseId: joinResult.leaseId,
             leaseExpiresAt: new Date(joinResult.leaseExpiresAt),
         };
+        const tokenAddress = joinResult.tokenAddress; // Store token address from response
         // Update header with lease info
         await updateChatHeader(false);
         // Display last messages
@@ -2108,7 +2131,7 @@ async function startChatInShell(client, tokenIdentifier, log, logLines, screen,
             }
             try {
                 // Send message - it will appear via WebSocket when received
-                await sendChatMessage(client, trimmed, leaseInfo.leaseId, userAddress);
+                await sendChatMessage(client, trimmed, leaseInfo.leaseId, userAddress, tokenAddress);
                 // Re-attach handler for next message
                 inputBox.removeAllListeners("submit");
                 inputBox.once("submit", chatInputHandler);
@@ -2157,6 +2180,386 @@ async function startChatInShell(client, tokenIdentifier, log, logLines, screen,
         screen.render();
     }
 }
+/**
+ * Start agent interactive mode (standalone, called from CLI)
+ * This looks identical to the regular shell but starts in agent chat mode
+ */
+export async function startAgentInteractiveMode(client) {
+    // 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 Agent Mode",
+        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();
+    // 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: 6, // Reduced to save vertical space
+        content: "",
+        tags: true,
+        style: {
+            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
+        },
+    });
+    // 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: 6, // Adjusted to match new header height
+        left: 0,
+        width: "100%",
+        bottom: 4, // Leave space for input box at bottom
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: " ",
+            inverse: currentTheme !== "dark",
+        },
+        style: {
+            fg: themeColors.fg,
+            bg: "default", // Transparent
+            border: {
+                fg: themeColors.border,
+                bold: true,
+            },
+        },
+        padding: {
+            left: 0,
+            right: 1,
+        },
+        mouse: true, // Enable mouse scrolling
+        border: {
+            type: "line",
+            fg: themeColors.border,
+            ch: "═", // Double line for thicker border
+        },
+    });
+    // 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,
+        width: "100%",
+        height: 3,
+        inputOnFocus: true,
+        keys: true,
+        vi: false, // Disabled to prevent double input issues in agent mode
+        secret: false,
+        tags: true,
+        alwaysScroll: false,
+        scrollable: false,
+        padding: {
+            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",
+        },
+        style: {
+            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
+        },
+    });
+    // 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);
+        screen.render();
+    };
+    // Helper to log multiple lines
+    const logLines = (lines) => {
+        lines.forEach((line) => outputBox.log(line));
+        outputBox.setScrollPerc(100);
+        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;
+    // 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);
+    // Start agent chat mode
+    await startAgentChatMode(client, log, logLines, screen, inputBox, headerBox, buildWelcomeContent, currentTheme, catFaces, currentCatIndex);
+}
 /**
  * Start agent chat mode (similar to startChatInShell)
  */
@@ -2217,17 +2620,10 @@ async function startAgentChatMode(client, log, logLines, screen, inputBox, heade
             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();
+                    screen.destroy();
+                    printCat("sleeping");
+                    console.log(chalk.cyan("Goodbye! 👋"));
+                    process.exit(0);
                     return;
                 case "/help":
                     log(chalk.cyan("Cat commands: /exit, /quit, /help"));
@@ -2245,9 +2641,13 @@ async function startAgentChatMode(client, log, logLines, screen, inputBox, heade
         }
         // Send to agent
         try {
+            // Get account address for session ID
+            const privateKey = config.getPrivateKey();
+            const account = privateKeyToAccount(privateKey);
+            const sessionId = account.address;
             log(chalk.blue("🐱 Cat thinking..."));
             screen.render();
-            const response = await chatWithAgent(agent, llm, trimmed);
+            const response = await chatWithAgent(agent, llm, trimmed, sessionId);
             log(chalk.green("🐱 Cat:"));
             log(response);
             log("");