httpcat-cli 0.2.11 → 0.2.12

package/dist/interactive/shell.js

@@ -10,69 +10,258 @@ 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 } 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 { checkBalance } from "../commands/balances.js";
+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";
+// 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) {
-    // Create blessed screen
+    // Auto-detect terminal background and set default theme
+    const detectedBg = detectTerminalBackground();
+    let currentTheme = detectedBg === "dark" ? "dark" : "win95";
+    // Create blessed screen with optimized settings
     const screen = blessed.screen({
         smartCSR: true,
         title: "httpcat Interactive Shell",
         fullUnicode: true,
+        fastCSR: false, // Disable fast CSR to prevent rendering issues
+        cursor: {
+            artificial: true,
+            shape: "line",
+            blink: true,
+            color: "green",
+        },
+        // Ensure cursor is always visible
+        forceUnicode: false,
     });
     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
     const headerBox = blessed.box({
         top: 0,
         left: 0,
         width: "100%",
-        height: 8,
+        height: 16,
         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,
+            left: 0,
             right: 1,
+            top: 1,
+            bottom: 1,
         },
+        border: {
+            type: "line",
+            fg: themeColors.border,
+            ch: "═", // Double line for thicker border
+        },
+    });
+    // Helper function to build welcome content with account info
+    const buildWelcomeContent = async (theme) => {
+        const welcomeLines = [];
+        const colorTag = theme === "dark" ? "green-fg" : "black-fg";
+        // Old-school pattern in top bar
+        const pattern = "═" + "─".repeat(78) + "═";
+        welcomeLines.push(`{${colorTag}}${pattern}{/${colorTag}}`);
+        // Single cat ASCII art
+        welcomeLines.push(`{${colorTag}}     /\\_/\\{/${colorTag}}`);
+        welcomeLines.push(`{${colorTag}}    ( ^.^ ){/${colorTag}}`);
+        welcomeLines.push(`{${colorTag}}     > ^ <{/${colorTag}}`);
+        welcomeLines.push(`{${colorTag}}    /   \\{/${colorTag}}`);
+        welcomeLines.push("");
+        // 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
+        }
+        // Playful cat-like greetings with account info
+        const greetings = [
+            `{green-fg}Meow! Welcome to httpcat!{/green-fg}`,
+            `{green-fg}*purrs* Ready to play with some tokens?{/green-fg}`,
+            `{green-fg}Connected to: {cyan-fg}${network}{/cyan-fg}{/green-fg}`,
+        ];
+        // Add account information
+        if (accountInfo) {
+            const { account, balance } = accountInfo;
+            const accountType = account.type === "custom" ? "Custom" : "Seed-Derived";
+            const accountLabel = account.label ? ` (${account.label})` : "";
+            greetings.push("");
+            greetings.push(`{cyan-fg}Account #{green-fg}${account.index}{/green-fg} | {green-fg}${accountType}${accountLabel}{/green-fg}{/cyan-fg}`);
+            if (balance) {
+                const ethDisplay = balance.ethFormatted || balance.ethBalance || "0 ETH";
+                const usdcDisplay = balance.usdcFormatted || balance.usdcBalance || "$0.00";
+                greetings.push(`{cyan-fg}Balance: {yellow-fg}${ethDisplay}{/yellow-fg} | {green-fg}${usdcDisplay}{/green-fg}{/cyan-fg}`);
+            }
+        }
+        greetings.push("");
+        greetings.push(`{yellow-fg}Pssst... type {bold}help{/bold} if you want to see what I can do!{/yellow-fg}`);
+        greetings.push(`{yellow-fg}Or just start playing - I'm curious like a cat!{/yellow-fg}`);
+        welcomeLines.push(...greetings);
+        return welcomeLines.join("\n");
+    };
+    // Set initial header content
+    buildWelcomeContent(currentTheme).then((content) => {
+        headerBox.setContent(content);
+        screen.render();
     });
-    // 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)
+    // Create output log box (scrollable) with thick borders, transparent background
     const outputBox = blessed.log({
-        top: 8,
+        top: 16,
         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 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,
+        },
     });
-    // Create input box at bottom
+    // 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 +269,82 @@ export async function startInteractiveShell(client) {
         height: 3,
         inputOnFocus: true,
         keys: true,
-        style: {
-            fg: "cyan",
-            bg: "black",
-            focus: {
-                fg: "white",
-                bg: "blue",
-            },
-        },
+        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
+        buildWelcomeContent(currentTheme).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 +356,41 @@ export async function startInteractiveShell(client) {
         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 input submission
     inputBox.on("submit", async (value) => {
         const trimmed = value.trim();
         inputBox.clearValue();
+        screen.render(); // Clear input immediately
         if (!trimmed) {
             inputBox.focus();
             screen.render();
             return;
         }
-        log(`httpcat> ${trimmed}`);
+        // 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, screen, inputBox, currentTheme, buildWelcomeContent, headerBox);
         }
         catch (error) {
             log(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
@@ -153,11 +411,20 @@ export async function startInteractiveShell(client) {
         inputBox.clearValue();
         screen.render();
     });
+    // Handle Ctrl+C to quit (also works from input box)
+    inputBox.key(["C-c"], () => {
+        screen.destroy();
+        printCat("sleeping");
+        console.log(chalk.cyan("Goodbye! 👋"));
+        process.exit(0);
+    });
     // Focus input and render
     inputBox.focus();
     screen.render();
+    // Show available commands on load
+    displayHelp(log, logLines);
 }
-async function handleCommand(client, command, args, log, logLines, screen, inputBox) {
+async function handleCommand(client, command, args, log, logLines, screen, inputBox, currentTheme, buildWelcomeContent, headerBox) {
     switch (command) {
         case "help":
             displayHelp(log, logLines);
@@ -171,7 +438,7 @@ async function handleCommand(client, command, args, log, logLines, screen, input
             const photoUrl = extractFlag(args, "--photo");
             const bannerUrl = extractFlag(args, "--banner");
             const websiteUrl = extractFlag(args, "--website");
-            log(chalk.dim("Creating token..."));
+            log(chalk.blue("Creating token..."));
             screen.render();
             const result = await createToken(client, {
                 name,
@@ -185,14 +452,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 +478,72 @@ 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, i > 1, // Silent after first buy
+                        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."));
+                            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, false, privateKey);
+                displayBuyResultToLog(result, log, logLines);
+            }
             break;
         }
         case "sell": {
@@ -217,7 +553,7 @@ async function handleCommand(client, command, args, log, logLines, screen, input
                 return;
             }
             const [identifier, amountInput] = args;
-            log(chalk.dim("Checking token info..."));
+            log(chalk.blue("Checking token info..."));
             screen.render();
             const info = await getTokenInfo(client, identifier);
             if (!info.userPosition || info.userPosition.tokensOwned === "0") {
@@ -225,7 +561,7 @@ async function handleCommand(client, command, args, log, logLines, screen, input
                 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);
             displaySellResultToLog(result, log, logLines);
@@ -242,7 +578,7 @@ 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);
             displayTokenInfoToLog(info, log, logLines);
@@ -252,7 +588,7 @@ 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);
@@ -262,10 +598,24 @@ 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 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 +628,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,16 +659,18 @@ 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);
+            const tokenIdentifier = args.length > 0 && !args[0].startsWith("--") ? args[0] : undefined;
+            const inputFormatRaw = extractFlag(args, "--input-format") || "text";
+            const inputFormat = (inputFormatRaw === "stream-json" ? "stream-json" : "text");
+            await startChatStream(client, false, tokenIdentifier, inputFormat);
             process.exit(0);
             break;
         }
@@ -333,7 +685,228 @@ 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, false);
+                displayClaimResultToLog(result, log, logLines);
+            }
+            else {
+                log(chalk.blue("Fetching fee information..."));
+                screen.render();
+                const result = await viewFees(client, identifier, false);
+                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).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).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;
+        }
         default:
             log(chalk.red(`Unknown command: ${command}`));
             log(chalk.dim('Type "help" for available commands'));
@@ -341,107 +914,135 @@ async function handleCommand(client, command, args, log, logLines, screen, input
 }
 function displayHelp(log, logLines) {
     log("");
-    log(chalk.cyan.bold("Available Commands:"));
+    log(chalk.green.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)}`);
-    }
+    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("  info <id>"));
+    log(chalk.green("  list [--sort mcap|created|name] [--page N] [--limit N]"));
+    log(chalk.green("  positions [--active|--graduated]"));
+    log(chalk.green("  balances"));
+    log(chalk.green("  claim <id> [--execute] [--address ADDR]"));
+    log(chalk.green("  transactions [--user ADDR] [--token ID] [--type TYPE] [--limit N] [--offset N]"));
+    log(chalk.green("  account [list|switch <index>|add]"));
+    log(chalk.green("  env [list|use <name>|show|add|update]"));
+    log(chalk.green("  chat [token] [--input-format FORMAT]"));
+    log(chalk.green("  health"));
+    log(chalk.green("  config [--show|--set|--reset]"));
+    log(chalk.green("  network"));
+    log(chalk.green("  clear"));
+    log(chalk.green("  help"));
+    log(chalk.green("  exit"));
     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"));
+    log(chalk.blue("Tip: Run any command without arguments to see detailed help"));
 }
 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: ") +
+    log(chalk.blue("Tokens sold: ") + chalk.green(result.tokensSold));
+    log(chalk.blue("USDC received: ") + chalk.yellow(result.usdcReceived));
+    log(chalk.blue("New price: ") + chalk.green(result.newPrice));
+    log(chalk.blue("Graduation: ") +
         chalk.magenta(result.graduationProgress.toFixed(2) + "%"));
 }
 function displayTokenInfoToLog(info, log, logLines) {
-    log(chalk.cyan.bold(info.name) + ` (${info.symbol})`);
+    log(chalk.green.bold(info.name) + ` (${info.symbol})`);
     if (info.tokenAddress) {
-        log(chalk.dim("Address: ") + info.tokenAddress);
+        log(chalk.blue("Address: ") + chalk.green(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(chalk.blue("Price: ") + chalk.green(info.currentPrice));
+    log(chalk.blue("Market Cap: ") + chalk.yellow(info.marketCap));
+    log(chalk.blue("Supply: ") + chalk.green(info.totalSupply));
     if (info.graduationProgress !== undefined) {
-        log(chalk.dim("Graduation: ") +
+        log(chalk.blue("Graduation: ") +
             chalk.magenta(info.graduationProgress.toFixed(2) + "%"));
     }
     if (info.userPosition && info.userPosition.tokensOwned !== "0") {
-        log(chalk.dim("Your position: ") +
+        log(chalk.blue("Your position: ") +
             chalk.green(info.userPosition.tokensOwned + " tokens"));
     }
 }
 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")}`);
+    log(chalk.green.bold(`Tokens (${result.total || result.tokens.length} total):`));
+    if (result.page && result.pages) {
+        log(chalk.dim(`Page ${result.page} of ${result.pages}`));
     }
-    if (result.tokens.length > 10) {
-        log(chalk.dim(`  ... and ${result.tokens.length - 10} more`));
+    log("");
+    if (result.tokens.length === 0) {
+        log(chalk.yellow("No tokens found."));
+        return;
+    }
+    // Show header
+    log(`  ${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")}`);
+    log(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");
+        log(`  ${chalk.bold(token.name.padEnd(20))} ${chalk.green(token.symbol.padEnd(10))} ${mcapDisplay.padEnd(15)} ${priceDisplay.padEnd(12)} ${graduationDisplay.padEnd(12)} ${statusDisplay}`);
+    }
+    log("");
+    if (result.page && result.pages && result.page < result.pages) {
+        log(chalk.dim(`Use --page ${result.page + 1} to see more tokens`));
+        log("");
+    }
+    // Show example commands
+    if (result.tokens.length > 0) {
+        const firstToken = result.tokens[0];
+        log(chalk.dim("Example commands:"));
+        log(chalk.dim(`   buy ${firstToken.symbol}`));
+        log(chalk.dim(`   sell ${firstToken.symbol}`));
+        log(chalk.dim(`   info ${firstToken.symbol}`));
+        log("");
     }
 }
 function displayPositionsToLog(result, log, logLines) {
@@ -449,27 +1050,49 @@ 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")}`);
+        log(`  ${chalk.green(pos.symbol || "???")} - ${chalk.green(pos.tokensOwned + " tokens")} @ ${chalk.yellow(pos.currentValue || "N/A")}`);
     }
 }
 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 +1101,107 @@ 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);
+    }
+}
 //# sourceMappingURL=shell.js.map