httpcat-cli 0.0.7 → 0.0.9

package/dist/commands/chat.js

@@ -0,0 +1,1369 @@
+import { createInterface } from "readline";
+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 { 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";
+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
+export async function joinChat(client, tokenIdentifier, silent = false) {
+    let tokenId;
+    // If token identifier provided, resolve it to tokenId
+    if (tokenIdentifier) {
+        // Check if it's an Ethereum address (starts with 0x and is 42 chars)
+        const isAddress = /^0x[a-fA-F0-9]{40}$/.test(tokenIdentifier);
+        if (isAddress) {
+            // Pass address directly - backend should handle it
+            tokenId = tokenIdentifier;
+        }
+        else {
+            // Resolve symbol/name/ticker to tokenId
+            tokenId = await resolveTokenId(tokenIdentifier, client, silent);
+        }
+    }
+    const input = tokenId ? { tokenId } : {};
+    const { data } = await client.invoke(CHAT_JOIN_ENTRYPOINT, input);
+    // Format author addresses for last messages
+    data.lastMessages = data.lastMessages.map((msg) => ({
+        ...msg,
+        authorShort: formatAddress(msg.author, 6),
+    }));
+    return data;
+}
+export async function sendChatMessage(client, message, leaseId) {
+    if (!message.trim()) {
+        throw new Error("Message cannot be empty");
+    }
+    const input = { message, leaseId };
+    const { data } = await client.invoke(CHAT_MESSAGE_ENTRYPOINT, input);
+    return data;
+}
+export async function renewLease(client, leaseId) {
+    const input = leaseId ? { leaseId } : {};
+    const { data } = await client.invoke(CHAT_RENEW_LEASE_ENTRYPOINT, input);
+    return data;
+}
+function formatTimestamp(timestamp) {
+    try {
+        const date = new Date(timestamp);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffSec = Math.floor(diffMs / 1000);
+        const diffMin = Math.floor(diffSec / 60);
+        const diffHour = Math.floor(diffMin / 60);
+        if (diffSec < 60) {
+            return "just now";
+        }
+        else if (diffMin < 60) {
+            return `${diffMin}m ago`;
+        }
+        else if (diffHour < 24) {
+            return `${diffHour}h ago`;
+        }
+        else {
+            return date.toLocaleTimeString("en-US", {
+                hour: "2-digit",
+                minute: "2-digit",
+            });
+        }
+    }
+    catch {
+        return "";
+    }
+}
+// Track displayed messages to avoid duplicates
+const displayedMessageIds = new Set();
+function formatMessageText(msg, isOwn = false) {
+    const timeStr = formatTimestamp(msg.timestamp);
+    const authorColor = isOwn ? chalk.green : chalk.cyan;
+    const messageColor = isOwn ? chalk.white : chalk.gray;
+    const authorShort = msg.authorShort || formatAddress(msg.author, 6);
+    return `${chalk.dim(`[${timeStr}]`)} ${authorColor(authorShort)}: ${messageColor(msg.message)}`;
+}
+function displayMessage(msg, isOwn = false, isPending = false, messageLogBox, rl) {
+    // Skip if we've already displayed this message
+    if (displayedMessageIds.has(msg.messageId)) {
+        return;
+    }
+    displayedMessageIds.add(msg.messageId);
+    const messageText = formatMessageText(msg, isOwn);
+    if (messageLogBox) {
+        // Use blessed log box - automatically handles scrolling
+        messageLogBox.log(messageText);
+        messageLogBox.setScrollPerc(100); // Auto-scroll to bottom
+    }
+    else if (rl) {
+        // Fallback to readline approach (for JSON mode or edge cases)
+        process.stdout.write("\r\x1b[K");
+        process.stdout.write(messageText);
+        process.stdout.write("\n");
+        if (rl)
+            rl.prompt(true);
+    }
+    else {
+        // Simple console.log when no UI active
+        console.log(messageText);
+    }
+}
+function clearLine() {
+    process.stdout.write("\r\x1b[K");
+}
+function formatTimeRemaining(expiresAt) {
+    const now = new Date();
+    const diffMs = expiresAt.getTime() - now.getTime();
+    if (diffMs <= 0) {
+        return "expired";
+    }
+    const minutes = Math.floor(diffMs / 60000);
+    const seconds = Math.floor((diffMs % 60000) / 1000);
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+}
+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));
+    // Build content line by line - use plain text (blessed will handle wrapping)
+    const lines = [];
+    lines.push(title);
+    lines.push(separator);
+    lines.push("");
+    if (isConnected) {
+        lines.push("✅ Connected to chat stream");
+        lines.push("");
+    }
+    lines.push("💰 Entry fee: $0.01 USDC (10 min lease)");
+    lines.push("💬 Per message: $0.01 USDC");
+    if (leaseInfo) {
+        const timeRemaining = formatTimeRemaining(leaseInfo.leaseExpiresAt);
+        const isExpired = leaseInfo.leaseExpiresAt.getTime() <= Date.now();
+        const timePrefix = isExpired ? "⚠️  " : "⏱️  ";
+        lines.push(`${timePrefix}Lease expires in: ${timeRemaining}`);
+    }
+    lines.push("");
+    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");
+    lines.push("");
+    lines.push(lineSeparator);
+    headerBox.setContent(lines.join("\n"));
+}
+async function ensureLeaseValid(client, leaseInfo, messageLogBox, screen) {
+    if (!leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
+        // Lease expired or doesn't exist, renew it
+        if (messageLogBox) {
+            messageLogBox.log(chalk.yellow("⏱️  Lease expired. Renewing..."));
+            messageLogBox.setScrollPerc(100);
+            screen?.render();
+        }
+        else {
+            clearLine();
+            console.log(chalk.yellow("⏱️  Lease expired. Renewing..."));
+        }
+        const renewal = await renewLease(client, leaseInfo?.leaseId);
+        return {
+            leaseId: renewal.leaseId,
+            leaseExpiresAt: new Date(renewal.leaseExpiresAt),
+        };
+    }
+    return leaseInfo;
+}
+export async function startChatStream(client, jsonMode = false, tokenIdentifier) {
+    let leaseInfo = null;
+    let userAddress;
+    let ws = null;
+    let wsUrl = null; // Store websocket URL for reconnection
+    let rl = null;
+    let leaseCheckInterval = null;
+    let headerUpdateInterval = null;
+    let isExiting = false;
+    let isSending = false; // Track sending state across handlers
+    let currentInput = ""; // Track current input across handlers
+    let pendingMessages = new Map(); // messageId -> tempMessageId (shared between send and receive)
+    let pulseIntervals = new Map(); // tempMessageId -> interval
+    let isCleaningUp = false; // Flag to prevent intervals from writing during cleanup
+    let messageCount = 0; // Track number of messages displayed (for positioning)
+    // Blessed UI components (only used in non-JSON mode)
+    let screen = null;
+    let headerBox = null;
+    let messageLogBox = null;
+    let inputBox = null;
+    // Join chat
+    try {
+        if (!jsonMode) {
+            if (tokenIdentifier) {
+                console.log(chalk.dim(`Joining chat room for token: ${tokenIdentifier}...`));
+            }
+            else {
+                console.log(chalk.dim("Joining general chat room..."));
+            }
+        }
+        const joinResult = await joinChat(client, tokenIdentifier, jsonMode);
+        leaseInfo = {
+            leaseId: joinResult.leaseId,
+            leaseExpiresAt: new Date(joinResult.leaseExpiresAt),
+        };
+        // Initialize userAddress from config if available (fallback until first message)
+        if (!userAddress) {
+            try {
+                const privateKey = config.getPrivateKey();
+                if (privateKey) {
+                    const account = privateKeyToAccount(privateKey);
+                    userAddress = account.address;
+                }
+            }
+            catch (error) {
+                // Ignore - will be set from first message send
+            }
+        }
+        if (jsonMode) {
+            // JSON mode: output join result and stream messages as JSON
+            console.log(JSON.stringify({
+                type: "joined",
+                leaseId: joinResult.leaseId,
+                leaseExpiresAt: joinResult.leaseExpiresAt,
+                tokenId: tokenIdentifier || null,
+                lastMessages: joinResult.lastMessages,
+            }));
+        }
+        // Connect to WebSocket
+        // Ensure we have a valid lease before connecting
+        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);
+        wsUrlObj.searchParams.set("leaseId", joinResult.leaseId);
+        wsUrl = wsUrlObj.toString();
+        // Helper function to attach websocket handlers
+        const attachWebSocketHandlers = (websocket) => {
+            websocket.on("open", () => {
+                // Connection established - update header if using blessed UI
+                if (!jsonMode && headerBox) {
+                    updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, true);
+                    screen?.render();
+                }
+            });
+            websocket.on("message", async (data) => {
+                try {
+                    const event = JSON.parse(data.toString());
+                    if (event.type === "message" && event.data) {
+                        const msg = {
+                            ...event.data,
+                            authorShort: formatAddress(event.data.author, 6),
+                        };
+                        if (jsonMode) {
+                            console.log(JSON.stringify({
+                                type: "message",
+                                data: msg,
+                            }));
+                        }
+                        else {
+                            // Normalize addresses to lowercase for case-insensitive comparison
+                            const normalizedAuthor = msg.author?.toLowerCase();
+                            const normalizedUserAddress = userAddress?.toLowerCase();
+                            const isOwn = normalizedAuthor === normalizedUserAddress;
+                            // Check if this is a message we just sent
+                            // Method 1: Check if messageId is in pendingMessages (most reliable)
+                            const hasPendingId = pendingMessages.has(msg.messageId);
+                            // Method 2: Check if message text is in pendingMessages (fallback if messageId doesn't match)
+                            const hasPendingText = pendingMessages.has(`text:${msg.message}`);
+                            // Method 3: Check if author matches AND we're currently sending (fallback)
+                            const isAuthorMatch = isOwn && isSending;
+                            // Combine all methods
+                            const isOurPendingMessage = hasPendingId || hasPendingText || isAuthorMatch;
+                            if (isOurPendingMessage) {
+                                // Set cleanup flag to prevent intervals from writing
+                                isCleaningUp = true;
+                                // FIRST: Stop ALL pulsing animations immediately (before anything else)
+                                // This prevents the interval from overwriting our clear
+                                pulseIntervals.forEach((interval, id) => {
+                                    clearInterval(interval);
+                                });
+                                pulseIntervals.clear(); // Clear the map completely
+                                // Clean up tracking FIRST (so intervals know to stop)
+                                if (pendingMessages.has(msg.messageId)) {
+                                    pendingMessages.delete(msg.messageId);
+                                }
+                                // Also clean up text-based tracking
+                                if (pendingMessages.has(`text:${msg.message}`)) {
+                                    pendingMessages.delete(`text:${msg.message}`);
+                                }
+                                // Small delay to ensure intervals have stopped
+                                await new Promise((resolve) => setTimeout(resolve, 20));
+                                // Stop pulsing and clear the grey pulsing input line
+                                if (inputBox) {
+                                    // Clear input box
+                                    inputBox.clearValue();
+                                    screen?.render();
+                                }
+                                else if (rl) {
+                                    // Fallback to readline
+                                    process.stdout.write("\n");
+                                    process.stdout.write("\r\x1b[K");
+                                }
+                                // Display the message (only if not already displayed)
+                                if (!displayedMessageIds.has(msg.messageId)) {
+                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                                }
+                                // Re-enable input - clear the input line completely
+                                isSending = false;
+                                currentInput = "";
+                                isCleaningUp = false; // Clear cleanup flag
+                                if (inputBox && screen) {
+                                    // Clear input box and refocus
+                                    inputBox.clearValue();
+                                    inputBox.focus();
+                                    screen.render();
+                                }
+                                else if (rl) {
+                                    // Fallback to readline
+                                    process.stdout.write("\r\x1b[K");
+                                    rl.prompt();
+                                }
+                            }
+                            else {
+                                // Not our message, just display it normally
+                                if (!displayedMessageIds.has(msg.messageId)) {
+                                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                                }
+                            }
+                        }
+                    }
+                    else if (event.type === "lease_expired") {
+                        if (jsonMode) {
+                            console.log(JSON.stringify({
+                                type: "lease_expired",
+                            }));
+                        }
+                        else {
+                            if (messageLogBox) {
+                                messageLogBox.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                                messageLogBox.setScrollPerc(100);
+                                screen?.render();
+                            }
+                            else if (rl) {
+                                process.stdout.write("\r\x1b[K");
+                                console.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                                rl.prompt(true);
+                            }
+                            else {
+                                console.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                            }
+                        }
+                        leaseInfo = null;
+                        if (headerBox) {
+                            updateHeaderBox(headerBox, null, tokenIdentifier, true);
+                            screen?.render();
+                        }
+                    }
+                    else if (event.type === "error") {
+                        if (jsonMode) {
+                            console.log(JSON.stringify({
+                                type: "error",
+                                error: event.error,
+                            }));
+                        }
+                        else {
+                            if (messageLogBox) {
+                                messageLogBox.log(chalk.red(`❌ Error: ${event.error || "Unknown error"}`));
+                                messageLogBox.setScrollPerc(100);
+                                screen?.render();
+                            }
+                            else if (rl) {
+                                process.stdout.write("\r\x1b[K");
+                                console.log(chalk.red(`❌ Error: ${event.error || "Unknown error"}`));
+                                rl.prompt(true);
+                            }
+                            else {
+                                console.log(chalk.red(`❌ Error: ${event.error || "Unknown error"}`));
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignore parse errors
+                }
+            });
+            websocket.on("error", (error) => {
+                // Only log errors if not exiting and connection is still relevant
+                if (isExiting)
+                    return;
+                if (jsonMode) {
+                    console.log(JSON.stringify({
+                        type: "error",
+                        error: error.message,
+                    }));
+                }
+                else {
+                    const errorMsg = error.message || "Unknown WebSocket error";
+                    if (messageLogBox) {
+                        messageLogBox.log(chalk.red(`❌ WebSocket error: ${errorMsg}`));
+                        messageLogBox.setScrollPerc(100);
+                        screen?.render();
+                    }
+                    else if (rl) {
+                        process.stdout.write("\r\x1b[K");
+                        console.log(chalk.red(`❌ WebSocket error: ${errorMsg}`));
+                        rl.prompt(true);
+                    }
+                    else {
+                        console.log(chalk.red(`❌ WebSocket error: ${errorMsg}`));
+                    }
+                }
+            });
+            websocket.on("close", (code, reason) => {
+                // Only show warning for unexpected closes (not normal closure or going away)
+                // Code 1000 = Normal Closure
+                // Code 1001 = Going Away (server restart, etc.)
+                // Code 1006 = Abnormal Closure (connection lost)
+                // Code 1008 = Policy Violation (e.g., invalid/expired lease)
+                const isNormalClose = code === 1000 || code === 1001;
+                const shouldShowWarning = !isExiting && !jsonMode && !isNormalClose;
+                if (shouldShowWarning) {
+                    const reasonStr = reason.toString() || "Connection lost";
+                    let message = `⚠️  WebSocket connection closed`;
+                    // Special handling for lease-related errors
+                    if (code === 1008 && reasonStr.toLowerCase().includes("lease")) {
+                        // Check if lease is actually expired or if this might be a timing issue
+                        const isLeaseExpired = !leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now();
+                        if (isLeaseExpired) {
+                            message = `⏱️  Your lease has expired. Type /renew to continue chatting.`;
+                        }
+                        else {
+                            // Lease should still be valid - this might be a server-side issue
+                            message = `⚠️  Lease validation failed on server. Your lease appears valid. Type /renew to get a fresh lease.`;
+                        }
+                        leaseInfo = null; // Mark lease as invalid
+                        if (headerBox) {
+                            updateHeaderBox(headerBox, null, tokenIdentifier, false);
+                            screen?.render();
+                        }
+                    }
+                    else if (code === 1006) {
+                        message = `⚠️  Connection lost. Type /renew to reconnect.`;
+                    }
+                    else {
+                        message = `⚠️  WebSocket connection closed (code: ${code}): ${reasonStr}`;
+                    }
+                    if (messageLogBox) {
+                        messageLogBox.log(chalk.yellow(message));
+                        messageLogBox.setScrollPerc(100);
+                        screen?.render();
+                    }
+                    else if (rl) {
+                        process.stdout.write("\r\x1b[K");
+                        console.log(chalk.yellow(message));
+                        rl.prompt(true);
+                    }
+                    else {
+                        console.log(chalk.yellow(message));
+                    }
+                }
+            });
+        };
+        // Connect to WebSocket with retry logic for timing issues
+        if (!wsUrl) {
+            throw new Error("WebSocket URL is not available");
+        }
+        let retryCount = 0;
+        const maxRetries = 3;
+        let connected = false;
+        while (!connected && retryCount < maxRetries) {
+            try {
+                if (retryCount > 0) {
+                    // Exponential backoff: 500ms, 1000ms, 2000ms
+                    const backoffDelay = Math.min(500 * Math.pow(2, retryCount - 1), 2000);
+                    if (!jsonMode) {
+                        if (messageLogBox) {
+                            messageLogBox.log(chalk.yellow(`🔄 Retrying WebSocket connection (attempt ${retryCount + 1}/${maxRetries})...`));
+                            messageLogBox.setScrollPerc(100);
+                            screen?.render();
+                        }
+                        else if (rl) {
+                            console.log(chalk.yellow(`🔄 Retrying WebSocket connection (attempt ${retryCount + 1}/${maxRetries})...`));
+                        }
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+                }
+                // Create WebSocket connection and wait for it to open or fail
+                await new Promise((resolve, reject) => {
+                    const newWs = new WebSocket(wsUrl);
+                    // Attach permanent handlers FIRST (before temporary handlers)
+                    attachWebSocketHandlers(newWs);
+                    // Set up temporary handlers for connection establishment
+                    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 - lease may not be ready yet"));
+                    }, 10000);
+                    openHandler = () => {
+                        cleanup();
+                        ws = newWs; // Assign to outer variable only after successful connection
+                        resolve();
+                    };
+                    closeHandler = (code, reason) => {
+                        cleanup();
+                        const reasonStr = reason.toString();
+                        // Only retry on code 1008 (lease validation) errors
+                        if (code === 1008 && reasonStr.toLowerCase().includes("lease")) {
+                            reject(new Error("Lease validation failed - may need more time to commit"));
+                        }
+                        else {
+                            reject(new Error(`Connection closed: ${code} - ${reasonStr}`));
+                        }
+                    };
+                    errorHandler = (error) => {
+                        cleanup();
+                        reject(error);
+                    };
+                    // Attach temporary handlers AFTER permanent handlers
+                    newWs.once("open", openHandler);
+                    newWs.once("close", closeHandler);
+                    newWs.once("error", errorHandler);
+                });
+                connected = true;
+                // Connection established successfully
+                if (!jsonMode && messageLogBox && retryCount > 0) {
+                    messageLogBox.log(chalk.green("✅ WebSocket connected successfully"));
+                    messageLogBox.setScrollPerc(100);
+                    screen?.render();
+                }
+            }
+            catch (error) {
+                retryCount++;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                // Check if this is a retryable error (lease validation timing issue)
+                const isRetryable = errorMsg.includes("Lease validation failed") ||
+                    errorMsg.includes("lease may not be ready");
+                if (retryCount >= maxRetries || !isRetryable) {
+                    // Final failure or non-retryable error
+                    const finalError = `Failed to connect after ${retryCount} attempts: ${errorMsg}`;
+                    if (jsonMode) {
+                        console.log(JSON.stringify({
+                            type: "error",
+                            error: finalError,
+                        }));
+                    }
+                    else {
+                        if (messageLogBox) {
+                            messageLogBox.log(chalk.red(`❌ ${finalError}`));
+                            messageLogBox.log(chalk.yellow("💡 Try typing /renew to get a fresh lease"));
+                            messageLogBox.setScrollPerc(100);
+                            screen?.render();
+                        }
+                        else if (rl) {
+                            console.log(chalk.red(`❌ ${finalError}`));
+                            console.log(chalk.yellow("💡 Try typing /renew to get a fresh lease"));
+                        }
+                        else {
+                            console.log(chalk.red(`❌ ${finalError}`));
+                        }
+                    }
+                    throw new Error(finalError);
+                }
+                // Will retry on next iteration
+            }
+        }
+        if (!connected) {
+            throw new Error("Failed to establish WebSocket connection");
+        }
+        // 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
+                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
+                rl = createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                    prompt: "",
+                });
+                // Display header information via console
+                console.log();
+                console.log(chalk.cyan("═".repeat(80)));
+                console.log(chalk.cyan("💬 httpcat Chat Stream"));
+                console.log(chalk.cyan("═".repeat(80)));
+                console.log();
+                console.log(chalk.green("✅ Connected to chat stream"));
+                console.log();
+                console.log(chalk.dim("💰 Entry fee: $0.01 USDC (10 min lease)"));
+                console.log(chalk.dim("💬 Per message: $0.01 USDC"));
+                if (leaseInfo) {
+                    const timeRemaining = formatTimeRemaining(leaseInfo.leaseExpiresAt);
+                    console.log(chalk.dim(`⏱️  Lease expires in: ${timeRemaining}`));
+                }
+                console.log();
+                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"));
+                console.log(chalk.cyan("─".repeat(80)));
+                console.log();
+            }
+            // Display last messages
+            if (joinResult.lastMessages.length > 0) {
+                const sortedMessages = [...joinResult.lastMessages].sort((a, b) => {
+                    const timeA = new Date(a.timestamp).getTime();
+                    const timeB = new Date(b.timestamp).getTime();
+                    return timeA - timeB; // Oldest first
+                });
+                sortedMessages.forEach((msg) => {
+                    displayedMessageIds.add(msg.messageId);
+                    const isOwn = msg.author === userAddress;
+                    displayMessage(msg, isOwn, false, messageLogBox || undefined, rl || undefined);
+                });
+            }
+            // Only set up blessed-specific handlers if using blessed
+            if (useBlessed && screen) {
+                // Handle terminal resize
+                screen.on("resize", () => {
+                    screen?.render();
+                });
+                // Update header with lease countdown every second
+                headerUpdateInterval = setInterval(() => {
+                    if (leaseInfo && headerBox) {
+                        updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, true);
+                        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
+                inputBox.on("submit", async (value) => {
+                    const trimmed = value.trim();
+                    // Ignore input while sending
+                    if (isSending || !trimmed) {
+                        inputBox?.clearValue();
+                        inputBox?.focus();
+                        screen?.render();
+                        return;
+                    }
+                    // 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();
+                                screen?.destroy();
+                                console.log();
+                                printCat("sleeping");
+                                console.log(chalk.cyan("Chat disconnected. Goodbye! 👋"));
+                                process.exit(0);
+                                return;
+                            case "/renew": {
+                                try {
+                                    inputBox?.setValue("⏱️  Renewing lease...");
+                                    screen?.render();
+                                    const renewal = await renewLease(client, leaseInfo?.leaseId);
+                                    leaseInfo = {
+                                        leaseId: renewal.leaseId,
+                                        leaseExpiresAt: new Date(renewal.leaseExpiresAt),
+                                    };
+                                    // Update header first
+                                    if (headerBox) {
+                                        updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, false);
+                                    }
+                                    if (messageLogBox) {
+                                        messageLogBox.log(chalk.green(`✅ Lease renewed! Expires in ${formatTimeRemaining(leaseInfo.leaseExpiresAt)}`));
+                                        messageLogBox.log(chalk.yellow("🔄 Reconnecting to chat stream..."));
+                                        messageLogBox.setScrollPerc(100);
+                                        screen?.render();
+                                    }
+                                    // Close old connection properly
+                                    if (ws) {
+                                        // Remove all listeners to prevent conflicts
+                                        ws.removeAllListeners();
+                                        // Ensure connection is fully closed
+                                        // WebSocket.OPEN = 1, WebSocket.CONNECTING = 0
+                                        if (ws.readyState === 1 || ws.readyState === 0) {
+                                            ws.close();
+                                        }
+                                        ws = null;
+                                    }
+                                    // Wait for database transaction to commit and old connection to fully close
+                                    // The server validates the lease in the open handler, so we need to ensure
+                                    // the database update is visible before connecting
+                                    // Increased delay to 2 seconds for better database consistency
+                                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                                    // Reconnect with new lease - with retry logic
+                                    if (wsUrl) {
+                                        const wsUrlObj = new URL(wsUrl);
+                                        wsUrlObj.searchParams.set("leaseId", leaseInfo.leaseId);
+                                        wsUrl = wsUrlObj.toString(); // Update stored URL
+                                        // Retry logic with exponential backoff
+                                        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);
+                                                    if (messageLogBox) {
+                                                        messageLogBox.log(chalk.yellow(`🔄 Retry ${retryCount}/${maxRetries} in ${backoffDelay}ms...`));
+                                                        messageLogBox.setScrollPerc(100);
+                                                        screen?.render();
+                                                    }
+                                                    await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+                                                }
+                                                // Create new connection and wait for it to open
+                                                const newWsUrl = wsUrl; // TypeScript: ensure it's not null
+                                                await new Promise((resolve, reject) => {
+                                                    const newWs = new WebSocket(newWsUrl);
+                                                    // Attach permanent handlers FIRST (before temporary handlers)
+                                                    attachWebSocketHandlers(newWs);
+                                                    // Set up temporary handlers for connection establishment
+                                                    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 - lease may not be ready yet"));
+                                                    }, 10000);
+                                                    openHandler = () => {
+                                                        cleanup();
+                                                        ws = newWs; // Assign to outer variable only after successful connection
+                                                        resolve();
+                                                    };
+                                                    closeHandler = (code, reason) => {
+                                                        cleanup();
+                                                        const reasonStr = reason.toString();
+                                                        if (code === 1008 && reasonStr.includes("lease")) {
+                                                            reject(new Error("Lease validation failed - please try /renew again"));
+                                                        }
+                                                        else {
+                                                            reject(new Error(`Connection closed: ${code} - ${reasonStr}`));
+                                                        }
+                                                    };
+                                                    errorHandler = (error) => {
+                                                        cleanup();
+                                                        reject(error);
+                                                    };
+                                                    // Attach temporary handlers AFTER permanent handlers
+                                                    newWs.once("open", openHandler);
+                                                    newWs.once("close", closeHandler);
+                                                    newWs.once("error", errorHandler);
+                                                });
+                                                connected = true;
+                                                // Connection established
+                                                if (headerBox) {
+                                                    updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, true);
+                                                }
+                                                if (messageLogBox) {
+                                                    messageLogBox.log(chalk.green("✅ Reconnected to chat stream"));
+                                                    messageLogBox.setScrollPerc(100);
+                                                }
+                                                screen?.render();
+                                            }
+                                            catch (error) {
+                                                retryCount++;
+                                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                                if (retryCount >= maxRetries) {
+                                                    // Final failure
+                                                    throw new Error(`Failed to reconnect after ${maxRetries} attempts: ${errorMsg}`);
+                                                }
+                                                // Log retry attempt
+                                                if (messageLogBox) {
+                                                    messageLogBox.log(chalk.yellow(`⚠️  Connection attempt ${retryCount} failed: ${errorMsg}`));
+                                                    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(`❌ ${errorMsg}`));
+                                        messageLogBox.setScrollPerc(100);
+                                    }
+                                    inputBox?.clearValue();
+                                    inputBox?.focus();
+                                    screen?.render();
+                                }
+                                return;
+                            }
+                            case "/help":
+                                if (messageLogBox) {
+                                    messageLogBox.log(chalk.dim("Commands: /exit, /quit, /renew, /help"));
+                                    messageLogBox.setScrollPerc(100);
+                                    screen?.render();
+                                }
+                                inputBox?.clearValue();
+                                inputBox?.focus();
+                                screen?.render();
+                                return;
+                            default:
+                                if (messageLogBox) {
+                                    messageLogBox.log(chalk.yellow(`Unknown command: ${cmd}. Type /help for commands.`));
+                                    messageLogBox.setScrollPerc(100);
+                                    screen?.render();
+                                }
+                                inputBox?.clearValue();
+                                inputBox?.focus();
+                                screen?.render();
+                                return;
+                        }
+                    }
+                    // Check if websocket is still connected
+                    // WebSocket.OPEN = 1
+                    if (!ws || ws.readyState !== 1) {
+                        const stateMsg = ws
+                            ? ws.readyState === 0 ? "connecting"
+                                : ws.readyState === 2 ? "closing"
+                                    : ws.readyState === 3 ? "closed"
+                                        : "unknown"
+                            : "not initialized";
+                        if (messageLogBox) {
+                            messageLogBox.log(chalk.red(`❌ WebSocket is not connected (state: ${stateMsg}). Please wait for connection or type /renew.`));
+                            messageLogBox.setScrollPerc(100);
+                            screen?.render();
+                        }
+                        inputBox?.clearValue();
+                        inputBox?.focus();
+                        screen?.render();
+                        return;
+                    }
+                    // Check if lease is valid
+                    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();
+                        }
+                        inputBox?.clearValue();
+                        inputBox?.focus();
+                        screen?.render();
+                        return;
+                    }
+                    // Send message
+                    isSending = true;
+                    currentInput = trimmed;
+                    // Show pulsing animation in input box
+                    let pulseCount = 0;
+                    let pulseInterval = null;
+                    const tempMessageId = `pending-${Date.now()}-${Math.random()}`;
+                    const updatePulse = () => {
+                        if (!inputBox || isCleaningUp)
+                            return;
+                        pulseCount++;
+                        const pulseChar = pulseCount % 2 === 0 ? "●" : "○";
+                        inputBox.setValue(`${trimmed} ${pulseChar}`);
+                        screen?.render();
+                    };
+                    // Initial pulse
+                    updatePulse();
+                    pulseInterval = setInterval(updatePulse, 500);
+                    pulseIntervals.set(tempMessageId, pulseInterval);
+                    try {
+                        // Ensure lease is valid before sending
+                        leaseInfo = await ensureLeaseValid(client, leaseInfo, messageLogBox || undefined, screen || undefined);
+                        if (headerBox) {
+                            updateHeaderBox(headerBox, leaseInfo, tokenIdentifier, true);
+                            screen?.render();
+                        }
+                        // Double-check websocket is still connected after lease renewal
+                        // WebSocket.OPEN = 1
+                        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
+                        pendingMessages.set(result.messageId, tempMessageId);
+                        pendingMessages.set(`text:${trimmed}`, tempMessageId);
+                        // Keep pulsing until WebSocket confirms
+                    }
+                    catch (error) {
+                        // Stop pulsing
+                        if (pulseInterval) {
+                            clearInterval(pulseInterval);
+                            pulseIntervals.delete(tempMessageId);
+                        }
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        if (messageLogBox) {
+                            messageLogBox.log(chalk.red(`❌ ${errorMsg}`));
+                            messageLogBox.setScrollPerc(100);
+                        }
+                        inputBox?.clearValue();
+                        inputBox?.focus();
+                        isSending = false;
+                        currentInput = "";
+                        screen?.render();
+                    }
+                });
+            }
+            else if (rl) {
+                // Readline input handling
+                const readlineInterface = rl; // Store reference for TypeScript
+                readlineInterface.setPrompt("");
+                readlineInterface.prompt();
+                readlineInterface.on("line", async (line) => {
+                    const trimmed = line.trim();
+                    // Ignore empty input
+                    if (!trimmed) {
+                        readlineInterface.prompt();
+                        return;
+                    }
+                    // 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();
+                                readlineInterface.close();
+                                console.log();
+                                printCat("sleeping");
+                                console.log(chalk.cyan("Chat disconnected. Goodbye! 👋"));
+                                process.exit(0);
+                                return;
+                            case "/renew": {
+                                try {
+                                    console.log(chalk.yellow("⏱️  Renewing lease..."));
+                                    const renewal = await renewLease(client, leaseInfo?.leaseId);
+                                    leaseInfo = {
+                                        leaseId: renewal.leaseId,
+                                        leaseExpiresAt: new Date(renewal.leaseExpiresAt),
+                                    };
+                                    console.log(chalk.green(`✅ Lease renewed! Expires in ${formatTimeRemaining(leaseInfo.leaseExpiresAt)}`));
+                                    console.log(chalk.yellow("🔄 Reconnecting to chat stream..."));
+                                    // Close old connection properly
+                                    if (ws) {
+                                        ws.removeAllListeners();
+                                        // WebSocket.OPEN = 1, WebSocket.CONNECTING = 0
+                                        if (ws.readyState === 1 || ws.readyState === 0) {
+                                            ws.close();
+                                        }
+                                        ws = null;
+                                    }
+                                    // Wait for database transaction to commit
+                                    await new Promise((resolve) => setTimeout(resolve, 2000));
+                                    // Reconnect with new lease
+                                    if (wsUrl) {
+                                        const wsUrlObj = new URL(wsUrl);
+                                        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);
+                                                    console.log(chalk.yellow(`🔄 Retry ${retryCount}/${maxRetries} in ${backoffDelay}ms...`));
+                                                    await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+                                                }
+                                                const newWsUrl = wsUrl;
+                                                await new Promise((resolve, reject) => {
+                                                    const newWs = new WebSocket(newWsUrl);
+                                                    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(chalk.green("✅ Reconnected to chat stream"));
+                                            }
+                                            catch (error) {
+                                                retryCount++;
+                                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                                if (retryCount >= maxRetries) {
+                                                    throw new Error(`Failed to reconnect after ${maxRetries} attempts: ${errorMsg}`);
+                                                }
+                                                console.log(chalk.yellow(`⚠️  Connection attempt ${retryCount} failed: ${errorMsg}`));
+                                            }
+                                        }
+                                    }
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    console.log(chalk.red(`❌ ${errorMsg}`));
+                                    if (readlineInterface)
+                                        readlineInterface.prompt();
+                                }
+                                return;
+                            }
+                            case "/help":
+                                console.log(chalk.dim("Commands: /exit, /quit, /renew, /help"));
+                                if (readlineInterface)
+                                    readlineInterface.prompt();
+                                return;
+                            default:
+                                console.log(chalk.yellow(`Unknown command: ${cmd}. Type /help for commands.`));
+                                if (readlineInterface)
+                                    readlineInterface.prompt();
+                                return;
+                        }
+                    }
+                    // Check if websocket is still connected
+                    if (!ws || ws.readyState !== 1) {
+                        const stateMsg = ws
+                            ? ws.readyState === 0 ? "connecting"
+                                : ws.readyState === 2 ? "closing"
+                                    : ws.readyState === 3 ? "closed"
+                                        : "unknown"
+                            : "not initialized";
+                        console.log(chalk.red(`❌ WebSocket is not connected (state: ${stateMsg}). Please wait for connection or type /renew.`));
+                        if (readlineInterface)
+                            readlineInterface.prompt();
+                        return;
+                    }
+                    // Check if lease is valid
+                    if (!leaseInfo || leaseInfo.leaseExpiresAt.getTime() <= Date.now()) {
+                        console.log(chalk.yellow("⏱️  Your lease has expired. Type /renew to continue chatting."));
+                        if (readlineInterface)
+                            readlineInterface.prompt();
+                        return;
+                    }
+                    // Send message
+                    isSending = true;
+                    currentInput = trimmed;
+                    try {
+                        // Ensure lease is valid before sending
+                        leaseInfo = await ensureLeaseValid(client, leaseInfo, undefined, undefined);
+                        // Double-check websocket is still connected
+                        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
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        console.log(chalk.red(`❌ ${errorMsg}`));
+                        isSending = false;
+                        currentInput = "";
+                    }
+                    if (readlineInterface)
+                        readlineInterface.prompt();
+                });
+                // Handle Ctrl+C for readline
+                readlineInterface.on("SIGINT", () => {
+                    isExiting = true;
+                    isSending = false;
+                    pulseIntervals.forEach((interval) => clearInterval(interval));
+                    pulseIntervals.clear();
+                    if (leaseCheckInterval)
+                        clearInterval(leaseCheckInterval);
+                    if (headerUpdateInterval)
+                        clearInterval(headerUpdateInterval);
+                    if (ws)
+                        ws.close();
+                    if (readlineInterface)
+                        readlineInterface.close();
+                    console.log();
+                    printCat("sleeping");
+                    console.log(chalk.cyan("Chat disconnected. Goodbye! 👋"));
+                    process.exit(0);
+                });
+            }
+            // Handle Ctrl+C (for blessed mode)
+            if (useBlessed && screen) {
+                screen.key(["C-c"], () => {
+                    isExiting = true;
+                    isSending = false;
+                    pulseIntervals.forEach((interval) => clearInterval(interval));
+                    pulseIntervals.clear();
+                    if (leaseCheckInterval)
+                        clearInterval(leaseCheckInterval);
+                    if (headerUpdateInterval)
+                        clearInterval(headerUpdateInterval);
+                    if (ws)
+                        ws.close();
+                    screen?.destroy();
+                    console.log();
+                    printCat("sleeping");
+                    console.log(chalk.cyan("Chat disconnected. Goodbye! 👋"));
+                    process.exit(0);
+                });
+                // Focus input box and render (only for blessed)
+                if (inputBox) {
+                    inputBox.focus();
+                    screen.render();
+                }
+            }
+        }
+        else {
+            // JSON mode: keep process alive and stream messages
+            process.on("SIGINT", () => {
+                isExiting = true;
+                if (ws)
+                    ws.close();
+                process.exit(0);
+            });
+        }
+    }
+    catch (error) {
+        // Cleanup on error
+        try {
+            if (leaseCheckInterval)
+                clearInterval(leaseCheckInterval);
+            if (headerUpdateInterval)
+                clearInterval(headerUpdateInterval);
+            pulseIntervals.forEach((interval) => clearInterval(interval));
+            pulseIntervals.clear();
+            if (ws !== null) {
+                try {
+                    ws.removeAllListeners();
+                    // WebSocket.OPEN = 1, WebSocket.CONNECTING = 0
+                    const wsState = ws.readyState;
+                    if (wsState === 1 || wsState === 0) {
+                        ws.close();
+                    }
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            if (screen) {
+                screen.destroy();
+            }
+            if (rl) {
+                rl.close();
+            }
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+        else {
+            handleError(error, config.get("preferences")?.verboseLogging);
+        }
+        process.exit(1);
+    }
+}
+export function displayChatResult(result) {
+    console.log();
+    console.log(chalk.green("✅ Message sent!"));
+    console.log(chalk.dim(`   ID: ${result.messageId}`));
+    console.log(chalk.dim(`   Time: ${new Date(result.timestamp).toLocaleString()}`));
+    console.log();
+}
+//# sourceMappingURL=chat.js.map