httpcat-cli 0.0.9 → 0.0.10

package/dist/commands/chat.js

@@ -3,16 +3,58 @@ import WebSocket from "ws";
 import chalk from "chalk";
 // @ts-ignore - neo-blessed doesn't have types, but @types/blessed provides compatible types
 import blessed from "neo-blessed";
-import { formatAddress } from "../utils/formatting.js";
+import { formatAddress, formatTokenAmount, formatCurrency } from "../utils/formatting.js";
 import { handleError } from "../utils/errors.js";
 import { config } from "../config.js";
 import { printCat } from "../interactive/art.js";
 import { resolveTokenId } from "../utils/token-resolver.js";
 import { privateKeyToAccount } from "viem/accounts";
+import { buyToken } from "./buy.js";
+import { sellToken, parseTokenAmount } from "./sell.js";
+import { getTokenInfo } from "./info.js";
 const CHAT_JOIN_ENTRYPOINT = "chat_join";
 const CHAT_MESSAGE_ENTRYPOINT = "chat_message";
 const CHAT_RENEW_LEASE_ENTRYPOINT = "chat_renew_lease";
 const LEASE_DURATION_MS = 10 * 60 * 1000; // 10 minutes
+/**
+ * Normalize WebSocket URL based on agent URL
+ * - Converts protocol (ws:// <-> wss://) to match agent URL
+ * - Replaces hostname with agent URL's hostname (handles localhost URLs from backend)
+ * - Preserves path and query parameters from WebSocket URL
+ */
+function normalizeWebSocketUrl(wsUrl, agentUrl) {
+    try {
+        const agentUrlObj = new URL(agentUrl);
+        const wsUrlObj = new URL(wsUrl);
+        // Determine correct protocol based on agent URL
+        const shouldUseWss = agentUrlObj.protocol === "https:";
+        const shouldUseWs = agentUrlObj.protocol === "http:";
+        // Replace hostname with agent URL's hostname
+        // This handles cases where backend returns localhost URLs
+        wsUrlObj.hostname = agentUrlObj.hostname;
+        // Use agent URL's port if it's explicitly set, otherwise use default for protocol
+        if (agentUrlObj.port) {
+            wsUrlObj.port = agentUrlObj.port;
+        }
+        else {
+            // Remove port to use default (80 for ws, 443 for wss)
+            wsUrlObj.port = "";
+        }
+        // Convert protocol to match agent URL
+        if (shouldUseWss) {
+            wsUrlObj.protocol = "wss:";
+        }
+        else if (shouldUseWs) {
+            wsUrlObj.protocol = "ws:";
+        }
+        return wsUrlObj.toString();
+    }
+    catch (error) {
+        // If URL parsing fails, return original
+        // This is safer than trying to guess
+        return wsUrl;
+    }
+}
 export async function joinChat(client, tokenIdentifier, silent = false) {
     let tokenId;
     // If token identifier provided, resolve it to tokenId
@@ -128,14 +170,42 @@ function formatTimeRemaining(expiresAt) {
     }
     return `${seconds}s`;
 }
+/**
+ * Format buy result compactly for chat log
+ */
+function formatBuyResultCompact(result) {
+    const graduationStatus = result.graduationReached
+        ? "✅ GRADUATED!"
+        : `${result.graduationProgress.toFixed(2)}%`;
+    return chalk.green("✅ Buy successful! ") +
+        `Received ${chalk.cyan(formatTokenAmount(result.tokensReceived))} tokens, ` +
+        `spent ${chalk.yellow(formatCurrency(result.amountSpent))}, ` +
+        `new price ${chalk.cyan(formatCurrency(result.newPrice))}, ` +
+        `graduation ${chalk.magenta(graduationStatus)}`;
+}
+/**
+ * Format sell result compactly for chat log
+ */
+function formatSellResultCompact(result) {
+    return chalk.green("✅ Sell successful! ") +
+        `Sold ${chalk.cyan(formatTokenAmount(result.tokensSold))} tokens, ` +
+        `received ${chalk.yellow(formatCurrency(result.usdcReceived))}, ` +
+        `new price ${chalk.cyan(formatCurrency(result.newPrice))}, ` +
+        `graduation ${chalk.magenta(result.graduationProgress.toFixed(2) + "%")}`;
+}
 function updateHeaderBox(headerBox, leaseInfo, tokenName, isConnected = false) {
     const title = tokenName
         ? `💬 httpcat Chat: ${tokenName}`
         : "💬 httpcat Chat Stream";
     // Get terminal width, default to 80 if not available
-    const width = process.stdout.columns || 80;
-    const separator = "═".repeat(Math.max(20, width - 2));
-    const lineSeparator = "─".repeat(Math.max(20, width - 2));
+    // Account for padding (left + right = 2)
+    const terminalWidth = process.stdout.columns || 80;
+    const boxWidth = headerBox.width;
+    const availableWidth = typeof boxWidth === "number" ? boxWidth - 2 : terminalWidth - 2;
+    const separatorWidth = Math.max(20, Math.min(availableWidth, terminalWidth - 2));
+    // Use safe separator that won't overflow
+    const separator = "═".repeat(separatorWidth);
+    const lineSeparator = "─".repeat(separatorWidth);
     // Build content line by line - use plain text (blessed will handle wrapping)
     const lines = [];
     lines.push(title);
@@ -157,8 +227,13 @@ function updateHeaderBox(headerBox, leaseInfo, tokenName, isConnected = false) {
     lines.push("💡 Type your message and press Enter to send");
     lines.push("💡 Type /exit or Ctrl+C to quit");
     lines.push("💡 Type /renew to renew your lease");
+    if (tokenName) {
+        lines.push("💡 Type /buy <amount> to buy tokens");
+        lines.push("💡 Type /sell <amount> to sell tokens");
+    }
     lines.push("");
     lines.push(lineSeparator);
+    // Clear and set content to prevent overlapping
     headerBox.setContent(lines.join("\n"));
 }
 async function ensureLeaseValid(client, leaseInfo, messageLogBox, screen) {
@@ -244,9 +319,16 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
         if (!leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
             throw new Error("Lease is invalid or expired. Please try again.");
         }
-        // Small delay to ensure database transaction commits before WebSocket connection
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const wsUrlObj = new URL(joinResult.wsUrl);
+        // Adjust delay based on whether agent is remote or local
+        // Remote servers may need more time for database replication/consistency
+        const agentUrl = client.getAgentUrl();
+        const isLocalhost = agentUrl.includes("localhost") || agentUrl.includes("127.0.0.1");
+        const delay = isLocalhost ? 500 : 1500; // 500ms for local, 1.5s for remote
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        // Normalize WebSocket URL protocol (ws:// vs wss://) based on agent URL
+        // Replaces hostname with agent URL's hostname and converts protocol
+        const normalizedWsUrl = normalizeWebSocketUrl(joinResult.wsUrl, agentUrl);
+        const wsUrlObj = new URL(normalizedWsUrl);
         wsUrlObj.searchParams.set("leaseId", joinResult.leaseId);
         wsUrl = wsUrlObj.toString();
         // Helper function to attach websocket handlers
@@ -317,8 +399,9 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                                     process.stdout.write("\r\x1b[K");
                                 }
                                 // Display the message (only if not already displayed)
+                                // In JSON mode, displayMessage should never be called, but add explicit check
                                 if (!displayedMessageIds.has(msg.messageId)) {
-                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, jsonMode ? undefined : (rl || undefined));
                                 }
                                 // Re-enable input - clear the input line completely
                                 isSending = false;
@@ -338,8 +421,9 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                             }
                             else {
                                 // Not our message, just display it normally
+                                // In JSON mode, displayMessage should never be called, but add explicit check
                                 if (!displayedMessageIds.has(msg.messageId)) {
-                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, jsonMode ? undefined : (rl || undefined));
                                 }
                             }
                         }
@@ -596,112 +680,40 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
         if (!connected) {
             throw new Error("Failed to establish WebSocket connection");
         }
+        // Check lease expiration every 30 seconds (works for both JSON and interactive modes)
+        leaseCheckInterval = setInterval(() => {
+            if (leaseInfo && leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
+                if (jsonMode) {
+                    console.log(JSON.stringify({
+                        type: 'lease_expired',
+                        message: 'Your lease has expired. Use /renew to continue chatting.',
+                    }));
+                }
+                else if (messageLogBox) {
+                    messageLogBox.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                    messageLogBox.setScrollPerc(100);
+                    screen?.render();
+                }
+                else if (rl) {
+                    console.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                }
+                leaseInfo = null;
+                if (headerBox) {
+                    updateHeaderBox(headerBox, null, tokenIdentifier, true);
+                    screen?.render();
+                }
+            }
+        }, 30000);
         // Set up blessed UI or readline interface (only in interactive mode)
         if (!jsonMode) {
             let useBlessed = true;
-            // Try to create blessed screen with error handling
-            try {
-                // Check if terminal supports blessed (basic compatibility check)
-                if (!process.stdout.isTTY) {
-                    throw new Error("Not a TTY - falling back to readline");
-                }
-                // Create blessed screen and widgets
-                screen = blessed.screen({
-                    smartCSR: true,
-                    title: "httpcat Chat",
-                    fullUnicode: true,
-                    // Add error handling for terminal compatibility
-                    fastCSR: false, // Disable fast CSR to avoid rendering issues
-                });
-                // Calculate header height (approximately 10 lines)
-                const headerHeight = 10;
-                const inputHeight = 3;
-                // Create header box (fixed at top)
-                headerBox = blessed.box({
-                    top: 0,
-                    left: 0,
-                    width: "100%",
-                    height: headerHeight,
-                    content: "",
-                    tags: false, // Disable tags to avoid rendering issues
-                    wrap: true,
-                    scrollable: false,
-                    alwaysScroll: false,
-                    padding: {
-                        left: 1,
-                        right: 1,
-                    },
-                    style: {
-                        fg: "white",
-                        bg: "black",
-                    },
-                });
-                // Create message log box (scrollable, middle section)
-                messageLogBox = blessed.log({
-                    top: headerHeight,
-                    left: 0,
-                    width: "100%",
-                    height: `100%-${headerHeight + inputHeight}`,
-                    tags: true,
-                    scrollable: true,
-                    alwaysScroll: true,
-                    scrollbar: {
-                        ch: " ",
-                        inverse: true,
-                    },
-                    style: {
-                        fg: "white",
-                        bg: "black",
-                    },
-                });
-                // Create input box (fixed at bottom)
-                inputBox = blessed.textbox({
-                    bottom: 0,
-                    left: 0,
-                    width: "100%",
-                    height: inputHeight,
-                    content: "",
-                    inputOnFocus: true,
-                    tags: true,
-                    keys: true,
-                    style: {
-                        fg: "cyan",
-                        bg: "black",
-                        focus: {
-                            fg: "white",
-                            bg: "blue",
-                        },
-                    },
-                });
-                // Append widgets to screen
-                screen.append(headerBox);
-                screen.append(messageLogBox);
-                screen.append(inputBox);
-                // Test render to catch early errors
-                screen.render();
-                // Initial header update
-                updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, false);
-                screen.render();
-            }
-            catch (blessedError) {
-                // Blessed failed - fallback to readline
+            // Check if terminal supports blessed (basic compatibility check)
+            // If not a TTY, silently fall back to readline
+            if (!process.stdout.isTTY) {
                 useBlessed = false;
-                console.error(chalk.yellow("⚠️  Blessed UI initialization failed, falling back to readline interface"));
-                console.error(chalk.dim(`   Error: ${blessedError instanceof Error ? blessedError.message : String(blessedError)}`));
-                // Clean up any partial blessed setup
-                if (screen) {
-                    try {
-                        screen.destroy();
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                    screen = null;
-                    headerBox = null;
-                    messageLogBox = null;
-                    inputBox = null;
-                }
-                // Create readline interface as fallback
+            }
+            // Helper function to set up readline interface
+            const setupReadline = () => {
                 rl = createInterface({
                     input: process.stdin,
                     output: process.stdout,
@@ -725,8 +737,123 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                 console.log(chalk.dim("💡 Type your message and press Enter to send"));
                 console.log(chalk.dim("💡 Type /exit or Ctrl+C to quit"));
                 console.log(chalk.dim("💡 Type /renew to renew your lease"));
+                if (tokenIdentifier) {
+                    console.log(chalk.dim("💡 Type /buy <amount> to buy tokens"));
+                    console.log(chalk.dim("💡 Type /sell <amount> to sell tokens"));
+                }
                 console.log(chalk.cyan("─".repeat(80)));
                 console.log();
+            };
+            // Try to create blessed screen with error handling
+            if (useBlessed) {
+                try {
+                    // Create blessed screen and widgets
+                    screen = blessed.screen({
+                        smartCSR: true,
+                        title: "httpcat Chat",
+                        fullUnicode: true,
+                        // Add error handling for terminal compatibility
+                        fastCSR: false, // Disable fast CSR to avoid rendering issues
+                    });
+                    // Calculate header height (approximately 10 lines)
+                    const headerHeight = 10;
+                    const inputHeight = 3;
+                    // Create header box (fixed at top)
+                    headerBox = blessed.box({
+                        top: 0,
+                        left: 0,
+                        width: "100%",
+                        height: headerHeight,
+                        content: "",
+                        tags: false, // Disable tags to avoid rendering issues
+                        wrap: true,
+                        scrollable: false,
+                        alwaysScroll: false,
+                        padding: {
+                            left: 1,
+                            right: 1,
+                            top: 0,
+                            bottom: 0,
+                        },
+                        style: {
+                            fg: "white",
+                            bg: "black",
+                        },
+                    });
+                    // Create message log box (scrollable, middle section)
+                    messageLogBox = blessed.log({
+                        top: headerHeight,
+                        left: 0,
+                        width: "100%",
+                        height: `100%-${headerHeight + inputHeight}`,
+                        tags: true,
+                        scrollable: true,
+                        alwaysScroll: true,
+                        scrollbar: {
+                            ch: " ",
+                            inverse: true,
+                        },
+                        style: {
+                            fg: "white",
+                            bg: "black",
+                        },
+                    });
+                    // Create input box (fixed at bottom)
+                    inputBox = blessed.textbox({
+                        bottom: 0,
+                        left: 0,
+                        width: "100%",
+                        height: inputHeight,
+                        content: "",
+                        inputOnFocus: true,
+                        tags: true,
+                        keys: true,
+                        style: {
+                            fg: "cyan",
+                            bg: "black",
+                            focus: {
+                                fg: "white",
+                                bg: "blue",
+                            },
+                        },
+                    });
+                    // Append widgets to screen
+                    screen.append(headerBox);
+                    screen.append(messageLogBox);
+                    screen.append(inputBox);
+                    // Test render to catch early errors
+                    screen.render();
+                    // Initial header update
+                    updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, false);
+                    screen.render();
+                }
+                catch (blessedError) {
+                    // Blessed failed - fallback to readline
+                    useBlessed = false;
+                    // Only show error if it's not a TTY issue (which we already handled silently)
+                    if (process.stdout.isTTY) {
+                        console.error(chalk.yellow("⚠️  Blessed UI initialization failed, falling back to readline interface"));
+                        console.error(chalk.dim(`   Error: ${blessedError instanceof Error ? blessedError.message : String(blessedError)}`));
+                    }
+                    // Clean up any partial blessed setup
+                    if (screen) {
+                        try {
+                            screen.destroy();
+                        }
+                        catch {
+                            // Ignore cleanup errors
+                        }
+                        screen = null;
+                        headerBox = null;
+                        messageLogBox = null;
+                        inputBox = null;
+                    }
+                    setupReadline();
+                }
+            }
+            else {
+                // Not a TTY or blessed disabled - use readline directly
+                setupReadline();
             }
             // Display last messages
             if (joinResult.lastMessages.length > 0) {
@@ -738,7 +865,8 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                 sortedMessages.forEach((msg) => {
                     displayedMessageIds.add(msg.messageId);
                     const isOwn = msg.author === userAddress;
-                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                    // This is inside !jsonMode block, but add explicit check for safety
+                    displayMessage(msg, isOwn, false, messageLogBox || undefined, jsonMode ? undefined : (rl || undefined));
                 });
             }
             // Only set up blessed-specific handlers if using blessed
@@ -749,30 +877,12 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                 });
                 // Update header with lease countdown every second
                 headerUpdateInterval = setInterval(() => {
-                    if (leaseInfo && headerBox) {
+                    if (leaseInfo && headerBox && screen && !isExiting) {
                         updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, true);
-                        screen?.render();
+                        screen.render();
                     }
                 }, 1000);
             }
-            // Check lease expiration every 30 seconds (works for both blessed and readline)
-            leaseCheckInterval = setInterval(() => {
-                if (leaseInfo && leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
-                    if (messageLogBox) {
-                        messageLogBox.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
-                        messageLogBox.setScrollPerc(100);
-                        screen?.render();
-                    }
-                    else if (rl) {
-                        console.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
-                    }
-                    leaseInfo = null;
-                    if (headerBox) {
-                        updateHeaderBox(headerBox, null, tokenIdentifier, true);
-                        screen?.render();
-                    }
-                }
-            }, 30000);
             // Handle input submission
             if (useBlessed && inputBox) {
                 // Blessed input handling
@@ -841,7 +951,10 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                                     await new Promise((resolve) => setTimeout(resolve, 2000));
                                     // Reconnect with new lease - with retry logic
                                     if (wsUrl) {
-                                        const wsUrlObj = new URL(wsUrl);
+                                        // Normalize WebSocket URL protocol based on agent URL
+                                        const agentUrl = client.getAgentUrl();
+                                        const normalizedWsUrl = normalizeWebSocketUrl(wsUrl, agentUrl);
+                                        const wsUrlObj = new URL(normalizedWsUrl);
                                         wsUrlObj.searchParams.set("leaseId", leaseInfo.leaseId);
                                         wsUrl = wsUrlObj.toString(); // Update stored URL
                                         // Retry logic with exponential backoff
@@ -952,9 +1065,130 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                                 }
                                 return;
                             }
+                            case "/buy": {
+                                // Only allow in token-specific chats
+                                if (!tokenIdentifier) {
+                                    if (messageLogBox) {
+                                        messageLogBox.log(chalk.yellow("⚠️  /buy command only works in token-specific chats"));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                    return;
+                                }
+                                try {
+                                    const parts = trimmed.split(" ");
+                                    if (parts.length < 2) {
+                                        if (messageLogBox) {
+                                            messageLogBox.log(chalk.yellow("⚠️  Usage: /buy <amount> (e.g., /buy 0.05)"));
+                                            messageLogBox.setScrollPerc(100);
+                                            screen?.render();
+                                        }
+                                        inputBox?.clearValue();
+                                        inputBox?.focus();
+                                        screen?.render();
+                                        return;
+                                    }
+                                    const amount = parts[1];
+                                    inputBox?.setValue(`💰 Buying tokens...`);
+                                    screen?.render();
+                                    const isTestMode = client.getNetwork().includes("sepolia");
+                                    const result = await buyToken(client, tokenIdentifier, amount, isTestMode, true // silent mode
+                                    );
+                                    if (messageLogBox) {
+                                        messageLogBox.log(formatBuyResultCompact(result));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    if (messageLogBox) {
+                                        messageLogBox.log(chalk.red(`❌ Buy failed: ${errorMsg}`));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                }
+                                return;
+                            }
+                            case "/sell": {
+                                // Only allow in token-specific chats
+                                if (!tokenIdentifier) {
+                                    if (messageLogBox) {
+                                        messageLogBox.log(chalk.yellow("⚠️  /sell command only works in token-specific chats"));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                    return;
+                                }
+                                try {
+                                    const parts = trimmed.split(" ");
+                                    if (parts.length < 2) {
+                                        if (messageLogBox) {
+                                            messageLogBox.log(chalk.yellow("⚠️  Usage: /sell <amount|all|percentage> (e.g., /sell 0.05, /sell all, /sell 50%)"));
+                                            messageLogBox.setScrollPerc(100);
+                                            screen?.render();
+                                        }
+                                        inputBox?.clearValue();
+                                        inputBox?.focus();
+                                        screen?.render();
+                                        return;
+                                    }
+                                    const amountStr = parts[1];
+                                    inputBox?.setValue(`💸 Selling tokens...`);
+                                    screen?.render();
+                                    // Get token info to check balance
+                                    if (!userAddress) {
+                                        throw new Error("User address not available");
+                                    }
+                                    const tokenInfo = await getTokenInfo(client, tokenIdentifier, userAddress, true // silent mode
+                                    );
+                                    if (!tokenInfo.userPosition || tokenInfo.userPosition.tokensOwned === "0") {
+                                        throw new Error("You do not own any of this token");
+                                    }
+                                    // Parse sell amount
+                                    const tokenAmount = parseTokenAmount(amountStr, tokenInfo.userPosition.tokensOwned);
+                                    const result = await sellToken(client, tokenIdentifier, tokenAmount, true // silent mode
+                                    );
+                                    if (messageLogBox) {
+                                        messageLogBox.log(formatSellResultCompact(result));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    if (messageLogBox) {
+                                        messageLogBox.log(chalk.red(`❌ Sell failed: ${errorMsg}`));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                }
+                                return;
+                            }
                             case "/help":
                                 if (messageLogBox) {
-                                    messageLogBox.log(chalk.dim("Commands: /exit, /quit, /renew, /help"));
+                                    const helpText = tokenIdentifier
+                                        ? chalk.dim("Commands: /exit, /quit, /renew, /buy, /sell, /help")
+                                        : chalk.dim("Commands: /exit, /quit, /renew, /help");
+                                    messageLogBox.log(helpText);
                                     messageLogBox.setScrollPerc(100);
                                     screen?.render();
                                 }
@@ -1116,7 +1350,10 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                                     await new Promise((resolve) => setTimeout(resolve, 2000));
                                     // Reconnect with new lease
                                     if (wsUrl) {
-                                        const wsUrlObj = new URL(wsUrl);
+                                        // Normalize WebSocket URL protocol based on agent URL
+                                        const agentUrl = client.getAgentUrl();
+                                        const normalizedWsUrl = normalizeWebSocketUrl(wsUrl, agentUrl);
+                                        const wsUrlObj = new URL(normalizedWsUrl);
                                         wsUrlObj.searchParams.set("leaseId", leaseInfo.leaseId);
                                         wsUrl = wsUrlObj.toString();
                                         // Retry logic
@@ -1200,8 +1437,87 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
                                 }
                                 return;
                             }
+                            case "/buy": {
+                                // Only allow in token-specific chats
+                                if (!tokenIdentifier) {
+                                    console.log(chalk.yellow("⚠️  /buy command only works in token-specific chats"));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                    return;
+                                }
+                                try {
+                                    const parts = trimmed.split(" ");
+                                    if (parts.length < 2) {
+                                        console.log(chalk.yellow("⚠️  Usage: /buy <amount> (e.g., /buy 0.05)"));
+                                        if (readlineInterface)
+                                            readlineInterface.prompt();
+                                        return;
+                                    }
+                                    const amount = parts[1];
+                                    console.log(chalk.yellow("💰 Buying tokens..."));
+                                    const isTestMode = client.getNetwork().includes("sepolia");
+                                    const result = await buyToken(client, tokenIdentifier, amount, isTestMode, true // silent mode
+                                    );
+                                    console.log(formatBuyResultCompact(result));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    console.log(chalk.red(`❌ Buy failed: ${errorMsg}`));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                return;
+                            }
+                            case "/sell": {
+                                // Only allow in token-specific chats
+                                if (!tokenIdentifier) {
+                                    console.log(chalk.yellow("⚠️  /sell command only works in token-specific chats"));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                    return;
+                                }
+                                try {
+                                    const parts = trimmed.split(" ");
+                                    if (parts.length < 2) {
+                                        console.log(chalk.yellow("⚠️  Usage: /sell <amount|all|percentage> (e.g., /sell 0.05, /sell all, /sell 50%)"));
+                                        if (readlineInterface)
+                                            readlineInterface.prompt();
+                                        return;
+                                    }
+                                    const amountStr = parts[1];
+                                    console.log(chalk.yellow("💸 Selling tokens..."));
+                                    // Get token info to check balance
+                                    if (!userAddress) {
+                                        throw new Error("User address not available");
+                                    }
+                                    const tokenInfo = await getTokenInfo(client, tokenIdentifier, userAddress, true // silent mode
+                                    );
+                                    if (!tokenInfo.userPosition || tokenInfo.userPosition.tokensOwned === "0") {
+                                        throw new Error("You do not own any of this token");
+                                    }
+                                    // Parse sell amount
+                                    const tokenAmount = parseTokenAmount(amountStr, tokenInfo.userPosition.tokensOwned);
+                                    const result = await sellToken(client, tokenIdentifier, tokenAmount, true // silent mode
+                                    );
+                                    console.log(formatSellResultCompact(result));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    console.log(chalk.red(`❌ Sell failed: ${errorMsg}`));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                return;
+                            }
                             case "/help":
-                                console.log(chalk.dim("Commands: /exit, /quit, /renew, /help"));
+                                const helpText = tokenIdentifier
+                                    ? chalk.dim("Commands: /exit, /quit, /renew, /buy, /sell, /help")
+                                    : chalk.dim("Commands: /exit, /quit, /renew, /help");
+                                console.log(helpText);
                                 if (readlineInterface)
                                     readlineInterface.prompt();
                                 return;
@@ -1306,11 +1622,241 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
             }
         }
         else {
-            // JSON mode: keep process alive and stream messages
+            // JSON mode: read messages from stdin and output JSON to stdout
+            // Set up stdin reading for non-interactive mode
+            process.stdin.setEncoding('utf8');
+            process.stdin.setRawMode(false);
+            process.stdin.resume();
+            let stdinBuffer = '';
+            process.stdin.on('data', async (chunk) => {
+                stdinBuffer += chunk.toString();
+                const lines = stdinBuffer.split('\n');
+                stdinBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    // Handle commands
+                    if (trimmed.startsWith('/')) {
+                        const [cmd] = trimmed.split(' ');
+                        switch (cmd) {
+                            case '/exit':
+                            case '/quit':
+                                isExiting = true;
+                                if (leaseCheckInterval)
+                                    clearInterval(leaseCheckInterval);
+                                if (headerUpdateInterval)
+                                    clearInterval(headerUpdateInterval);
+                                if (ws)
+                                    ws.close();
+                                console.log(JSON.stringify({ type: 'exiting' }));
+                                process.exit(0);
+                                return;
+                            case '/renew': {
+                                try {
+                                    console.log(JSON.stringify({ type: 'renewing_lease' }));
+                                    const renewal = await renewLease(client, leaseInfo?.leaseId);
+                                    leaseInfo = {
+                                        leaseId: renewal.leaseId,
+                                        leaseExpiresAt: new Date(renewal.leaseExpiresAt),
+                                    };
+                                    console.log(JSON.stringify({
+                                        type: 'lease_renewed',
+                                        leaseId: renewal.leaseId,
+                                        leaseExpiresAt: renewal.leaseExpiresAt,
+                                    }));
+                                    // Close old connection
+                                    if (ws) {
+                                        ws.removeAllListeners();
+                                        if (ws.readyState === 1 || ws.readyState === 0) {
+                                            ws.close();
+                                        }
+                                        ws = null;
+                                    }
+                                    // Wait for database transaction
+                                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                                    // Reconnect with new lease
+                                    if (wsUrl) {
+                                        const agentUrl = client.getAgentUrl();
+                                        const normalizedWsUrl = normalizeWebSocketUrl(wsUrl, agentUrl);
+                                        const wsUrlObj = new URL(normalizedWsUrl);
+                                        wsUrlObj.searchParams.set("leaseId", leaseInfo.leaseId);
+                                        wsUrl = wsUrlObj.toString();
+                                        // Retry logic
+                                        let retryCount = 0;
+                                        const maxRetries = 3;
+                                        let connected = false;
+                                        while (!connected && retryCount < maxRetries) {
+                                            try {
+                                                if (retryCount > 0) {
+                                                    const backoffDelay = Math.min(1000 * Math.pow(2, retryCount - 1), 5000);
+                                                    await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+                                                }
+                                                await new Promise((resolve, reject) => {
+                                                    const newWs = new WebSocket(wsUrl);
+                                                    attachWebSocketHandlers(newWs);
+                                                    let timeout = null;
+                                                    let openHandler = null;
+                                                    let closeHandler = null;
+                                                    let errorHandler = null;
+                                                    const cleanup = () => {
+                                                        if (timeout)
+                                                            clearTimeout(timeout);
+                                                        if (openHandler)
+                                                            newWs.removeListener("open", openHandler);
+                                                        if (closeHandler)
+                                                            newWs.removeListener("close", closeHandler);
+                                                        if (errorHandler)
+                                                            newWs.removeListener("error", errorHandler);
+                                                    };
+                                                    timeout = setTimeout(() => {
+                                                        cleanup();
+                                                        newWs.close();
+                                                        reject(new Error("Connection timeout"));
+                                                    }, 10000);
+                                                    openHandler = () => {
+                                                        cleanup();
+                                                        ws = newWs;
+                                                        resolve();
+                                                    };
+                                                    closeHandler = (code, reason) => {
+                                                        cleanup();
+                                                        const reasonStr = reason.toString();
+                                                        if (code === 1008 && reasonStr.includes("lease")) {
+                                                            reject(new Error("Lease validation failed"));
+                                                        }
+                                                        else {
+                                                            reject(new Error(`Connection closed: ${code} - ${reasonStr}`));
+                                                        }
+                                                    };
+                                                    errorHandler = (error) => {
+                                                        cleanup();
+                                                        reject(error);
+                                                    };
+                                                    newWs.once("open", openHandler);
+                                                    newWs.once("close", closeHandler);
+                                                    newWs.once("error", errorHandler);
+                                                });
+                                                connected = true;
+                                                console.log(JSON.stringify({ type: 'reconnected' }));
+                                            }
+                                            catch (error) {
+                                                retryCount++;
+                                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                                if (retryCount >= maxRetries) {
+                                                    console.log(JSON.stringify({
+                                                        type: 'error',
+                                                        error: `Failed to reconnect after ${maxRetries} attempts: ${errorMsg}`,
+                                                    }));
+                                                    return;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    console.log(JSON.stringify({
+                                        type: 'error',
+                                        error: errorMsg,
+                                    }));
+                                }
+                                return;
+                            }
+                            default:
+                                console.log(JSON.stringify({
+                                    type: 'error',
+                                    error: `Unknown command: ${cmd}. Supported commands: /exit, /renew`,
+                                }));
+                                return;
+                        }
+                    }
+                    // Send message
+                    if (isSending) {
+                        console.log(JSON.stringify({
+                            type: 'error',
+                            error: 'Please wait for the previous message to be sent',
+                        }));
+                        return;
+                    }
+                    // Check if websocket is connected
+                    if (!ws || ws.readyState !== 1) {
+                        console.log(JSON.stringify({
+                            type: 'error',
+                            error: 'WebSocket is not connected. Please wait for connection or use /renew.',
+                        }));
+                        return;
+                    }
+                    // Check if lease is valid
+                    if (!leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
+                        console.log(JSON.stringify({
+                            type: 'error',
+                            error: 'Lease has expired. Use /renew to continue chatting.',
+                        }));
+                        return;
+                    }
+                    // Send message
+                    isSending = true;
+                    try {
+                        leaseInfo = await ensureLeaseValid(client, leaseInfo, undefined, undefined);
+                        if (!ws || ws.readyState !== 1) {
+                            throw new Error("WebSocket connection lost. Please wait for reconnection.");
+                        }
+                        const result = await sendChatMessage(client, trimmed, leaseInfo.leaseId);
+                        userAddress = result.author;
+                        // Track this message
+                        const tempMessageId = `pending-${Date.now()}-${Math.random()}`;
+                        pendingMessages.set(result.messageId, tempMessageId);
+                        pendingMessages.set(`text:${trimmed}`, tempMessageId);
+                        // Message sent - will be displayed when received via WebSocket
+                        console.log(JSON.stringify({
+                            type: 'message_sent',
+                            messageId: result.messageId,
+                        }));
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        console.log(JSON.stringify({
+                            type: 'error',
+                            error: errorMsg,
+                        }));
+                    }
+                    finally {
+                        isSending = false;
+                    }
+                }
+            });
+            process.stdin.on('end', () => {
+                // Stdin closed - this is normal in JSON mode when input pipe ends
+                isExiting = true;
+                if (leaseCheckInterval)
+                    clearInterval(leaseCheckInterval);
+                if (headerUpdateInterval)
+                    clearInterval(headerUpdateInterval);
+                if (ws)
+                    ws.close();
+                // Don't try to use readline in JSON mode - it should never exist
+                process.exit(0);
+            });
+            process.stdin.on('error', (error) => {
+                // Handle stdin errors gracefully in JSON mode
+                if (!isExiting) {
+                    console.log(JSON.stringify({
+                        type: 'error',
+                        error: `Stdin error: ${error.message}`,
+                    }));
+                }
+            });
             process.on("SIGINT", () => {
                 isExiting = true;
+                if (leaseCheckInterval)
+                    clearInterval(leaseCheckInterval);
+                if (headerUpdateInterval)
+                    clearInterval(headerUpdateInterval);
                 if (ws)
                     ws.close();
+                // Don't try to use readline in JSON mode - it should never exist
+                console.log(JSON.stringify({ type: 'exiting' }));
                 process.exit(0);
             });
         }
@@ -1340,7 +1886,8 @@ export async function startChatStream(client, jsonMode = false, tokenIdentifier)
             if (screen) {
                 screen.destroy();
             }
-            if (rl) {
+            // Only close readline if not in JSON mode (readline should never exist in JSON mode)
+            if (rl && !jsonMode) {
                 rl.close();
             }
         }