httpcat-cli 0.2.12 → 0.2.13-rc.1

package/dist/index.js

@@ -8,12 +8,14 @@ import { formatAddress, formatCurrency } from "./utils/formatting.js";
 import { HttpcatClient, HttpcatError } from "./client.js";
 import { handleError, getExitCode } from "./utils/errors.js";
 import { startInteractiveShell } from "./interactive/shell.js";
+import { runCatSpinAnimation } from "./interactive/cat-spin.js";
 import { outputJson, outputError } from "./headless/json-output.js";
 import { promptForPrivateKey } from "./utils/privateKeyPrompt.js";
 import { withLoading } from "./utils/loading.js";
-import { readFileSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, statSync, unlinkSync, readlinkSync, } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { tmpdir } from "os";
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -22,7 +24,7 @@ const VERSION = packageJson.version;
 const require = createRequire(import.meta.url);
 const { version: PACKAGE_VERSION } = require("../package.json");
 // Import commands
-import { createToken, displayCreateResult } from "./commands/create.js";
+import { createToken, displayCreateResult, processPhotoUrl, isFilePath, } from "./commands/create.js";
 import { buyToken, displayBuyResult, displayBuyResultCompact, } from "./commands/buy.js";
 import { sellToken, displaySellResult, parseTokenAmount, } from "./commands/sell.js";
 import { getTokenInfo, displayTokenInfo } from "./commands/info.js";
@@ -273,18 +275,31 @@ program
     .description("Create a new token")
     .argument("<name>", 'Token name (e.g., "My Token")')
     .argument("<symbol>", 'Token symbol/ticker (e.g., "MTK", 3-10 characters)')
-    .option("-p, --photo <url>", "Photo URL for token logo")
-    .option("-b, --banner <url>", "Banner image URL")
+    .option("-p, --photo <url|path>", "Photo URL or file path for token logo")
     .option("-w, --website <url>", "Website URL")
     .addHelpText("after", `
 Examples:
   httpcat create "My Token" "MTK"
   httpcat create "Moon Cat" "MOON" --website https://mooncat.io
-  httpcat create "Test" "TEST" --photo https://example.com/logo.png --banner https://example.com/banner.png
+  httpcat create "Test" "TEST" --photo https://example.com/logo.png
+  httpcat create "Test" "TEST" --photo ./logo.png
   httpcat --json create "AI Token" "AI"
   `)
     .action(async (name, symbol, options, command) => {
     try {
+        // Fallback: get arguments from command object if not provided as parameters
+        // This handles cases where Commander.js doesn't parse arguments correctly
+        // In Commander.js v9+, use processedArgs; fallback to args for older versions
+        const args = command.processedArgs || command.args || [];
+        const actualName = name || args[0];
+        const actualSymbol = symbol || args[1];
+        // Validate required arguments
+        if (!actualName || typeof actualName !== "string") {
+            throw new Error("Token name is required. Usage: httpcat create <name> <symbol> [options]");
+        }
+        if (!actualSymbol || typeof actualSymbol !== "string") {
+            throw new Error("Token symbol is required. Usage: httpcat create <name> <symbol> [options]");
+        }
         const globalOpts = command.parent?.opts() || {};
         const accountIndex = globalOpts.account;
         // Ensure wallet is unlocked
@@ -300,11 +315,21 @@ Examples:
             privateKey = await promptForPrivateKey();
         }
         const client = await HttpcatClient.create(privateKey);
+        // Process photo if it's a file path (show loading state)
+        let processedPhotoUrl = options.photo;
+        if (options.photo && isFilePath(options.photo)) {
+            processedPhotoUrl = await withLoading(async () => processPhotoUrl(options.photo), {
+                message: "Uploading image...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+            });
+        }
+        // Create token (show loading state)
         const result = await withLoading(() => createToken(client, {
-            name,
-            symbol,
-            photoUrl: options.photo,
-            bannerUrl: options.banner,
+            name: actualName.trim(),
+            symbol: actualSymbol.trim(),
+            photoUrl: processedPhotoUrl,
             websiteUrl: options.website,
         }), {
             message: "Creating token...",
@@ -401,16 +426,66 @@ Examples:
             let stopReason = "";
             for (let i = 1; i <= repeatCount; i++) {
                 try {
-                    // Show progress for non-JSON mode
-                    if (!globalOpts.json && !globalOpts.quiet) {
-                        console.log(chalk.dim(`Buy ${i}/${repeatCount}...`));
+                    // Retry logic: try up to 10 times with exponential backoff on 402 errors
+                    // Client is recreated on each attempt to ensure fresh signature for new nonce
+                    let result = null;
+                    let lastError = null;
+                    const maxRetries = 10;
+                    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                        try {
+                            // Show progress for non-JSON mode
+                            if (!globalOpts.json && !globalOpts.quiet) {
+                                if (attempt === 1) {
+                                    console.log(chalk.dim(`Buy ${i}/${repeatCount}...`));
+                                }
+                                else {
+                                    console.log(chalk.yellow(`  Retrying buy ${i}/${repeatCount} (attempt ${attempt}/${maxRetries})...`));
+                                }
+                            }
+                            // Recreate client inside the operation function to ensure fresh signature
+                            // for each attempt (including retries). This fixes the issue where x402-fetch
+                            // generates a new nonce but reuses the same signature, causing subsequent buys to fail
+                            result = await withLoading(async () => {
+                                // Recreate client for each attempt to ensure fresh signature for new nonce
+                                const client = await HttpcatClient.create(privateKey);
+                                return buyToken(client, tokenId, finalAmount, isTestMode, silent || i > 1, privateKey);
+                            }, {
+                                message: `Buying tokens (${i}/${repeatCount})...`,
+                                json: globalOpts.json,
+                                quiet: globalOpts.quiet || i > 1,
+                                spinner: "cat",
+                            });
+                            // Success! Break out of retry loop
+                            break;
+                        }
+                        catch (error) {
+                            lastError = error;
+                            // Only retry on 402 errors (payment required)
+                            const is402Error = error instanceof HttpcatError && error.status === 402;
+                            if (is402Error && attempt < maxRetries) {
+                                // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s, 64s, 128s, 256s, 512s (capped at 10s)
+                                const backoffMs = Math.min(Math.pow(2, attempt - 1) * 1000, 10000);
+                                if (!globalOpts.json && !globalOpts.quiet) {
+                                    console.log(chalk.yellow(`  ⚠️  Payment required (attempt ${attempt}/${maxRetries}), retrying in ${backoffMs / 1000}s...`));
+                                }
+                                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                                continue; // Retry
+                            }
+                            else {
+                                // Not a 402 error, or max retries reached - throw the error
+                                throw error;
+                            }
+                        }
+                    }
+                    // If we exhausted retries, throw the last error
+                    if (!result) {
+                        if (lastError) {
+                            throw lastError;
+                        }
+                        else {
+                            throw new Error(`Failed to complete buy ${i}/${repeatCount} after ${maxRetries} attempts`);
+                        }
                     }
-                    const result = await withLoading(() => buyToken(client, tokenId, finalAmount, isTestMode, silent || i > 1, privateKey), {
-                        message: `Buying tokens (${i}/${repeatCount})...`,
-                        json: globalOpts.json,
-                        quiet: globalOpts.quiet || i > 1,
-                        spinner: "cat",
-                    });
                     results.push(result);
                     totalSpent += parseFloat(result.amountSpent);
                     // Display compact result for each buy
@@ -431,23 +506,68 @@ Examples:
                         }
                         break;
                     }
+                    // Wait for transaction confirmations if present
+                    // This ensures both the buy transaction and payment transaction are confirmed
+                    // before the next buy, preventing nonce/signature conflicts
+                    if (i < repeatCount) {
+                        const { createPublicClient, http } = await import("viem");
+                        const { baseSepolia } = await import("viem/chains");
+                        const publicClient = createPublicClient({
+                            chain: baseSepolia,
+                            transport: http(config.getRpcUrl()),
+                        });
+                        // Wait for payment transaction first (if present)
+                        // This is critical to ensure the payment nonce is consumed before next request
+                        if (result.paymentTxHash) {
+                            if (!globalOpts.json && !globalOpts.quiet) {
+                                console.log(chalk.dim(`  Waiting for payment transaction confirmation...`));
+                            }
+                            try {
+                                await publicClient.waitForTransactionReceipt({
+                                    hash: result.paymentTxHash,
+                                });
+                                if (!globalOpts.json && !globalOpts.quiet) {
+                                    console.log(chalk.dim(`  ✅ Payment transaction confirmed`));
+                                }
+                            }
+                            catch (txError) {
+                                // If we can't wait for confirmation, log but continue
+                                if (!globalOpts.json && !globalOpts.quiet) {
+                                    console.log(chalk.yellow(`  ⚠️  Could not confirm payment transaction, proceeding...`));
+                                }
+                            }
+                        }
+                        // Wait for buy transaction (if present)
+                        if (result.txHash) {
+                            if (!globalOpts.json && !globalOpts.quiet) {
+                                console.log(chalk.dim(`  Waiting for buy transaction confirmation...`));
+                            }
+                            try {
+                                await publicClient.waitForTransactionReceipt({
+                                    hash: result.txHash,
+                                });
+                                if (!globalOpts.json && !globalOpts.quiet) {
+                                    console.log(chalk.dim(`  ✅ Buy transaction confirmed`));
+                                }
+                            }
+                            catch (txError) {
+                                // If we can't wait for confirmation, log but continue
+                                if (!globalOpts.json && !globalOpts.quiet) {
+                                    console.log(chalk.yellow(`  ⚠️  Could not confirm buy transaction, proceeding...`));
+                                }
+                            }
+                        }
+                    }
                     // Apply delay between iterations (except after the last one)
                     if (i < repeatCount && delayMs > 0) {
                         await new Promise((resolve) => setTimeout(resolve, delayMs));
                     }
                 }
                 catch (error) {
-                    // Handle insufficient funds (402) gracefully
-                    if (error instanceof HttpcatError && error.status === 402) {
-                        stoppedEarly = true;
-                        stopReason = "Insufficient funds";
-                        if (!globalOpts.json && !globalOpts.quiet) {
-                            console.log();
-                            console.log(chalk.yellow("💡 Insufficient funds. Stopping buy loop."));
-                        }
-                        break;
-                    }
-                    // For other errors, re-throw to be handled by outer catch
+                    // Don't catch 402 errors - x402-fetch handles payment automatically
+                    // 402 is the normal payment flow on first call, not an error
+                    // Let withLoading and x402-fetch handle payment retries
+                    // Only re-throw to let outer handler deal with persistent errors
                     throw error;
                 }
             }
@@ -565,7 +685,7 @@ Examples:
                     const { baseSepolia } = await import("viem/chains");
                     const publicClient = createPublicClient({
                         chain: baseSepolia,
-                        transport: http(),
+                        transport: http(config.getRpcUrl()),
                     });
                     const ERC20_ABI = parseAbi([
                         "function balanceOf(address owner) view returns (uint256)",
@@ -606,7 +726,7 @@ Examples:
                 const { baseSepolia } = await import("viem/chains");
                 const publicClient = createPublicClient({
                     chain: baseSepolia,
-                    transport: http(),
+                    transport: http(config.getRpcUrl()),
                 });
                 const ERC20_ABI = parseAbi([
                     "function balanceOf(address owner) view returns (uint256)",
@@ -1276,10 +1396,16 @@ Examples:
             privateKey = await promptForPrivateKey();
         }
         const client = await HttpcatClient.create(privateKey);
-        const inputFormat = globalOpts.json
-            ? chatOpts.inputFormat || "text"
-            : "text";
-        await startChatStream(client, globalOpts.json || false, tokenIdentifier || undefined, inputFormat);
+        // If JSON mode, use the original chat stream (for non-interactive usage)
+        if (globalOpts.json) {
+            const inputFormat = chatOpts.inputFormat || "text";
+            await startChatStream(client, true, // jsonMode
+            tokenIdentifier || undefined, inputFormat);
+        }
+        else {
+            // Interactive mode: launch shell and auto-enter chat
+            await startInteractiveShell(client, tokenIdentifier || undefined);
+        }
     }
     catch (error) {
         const globalOpts = command.parent?.opts() || {};
@@ -1292,6 +1418,108 @@ Examples:
         process.exit(getExitCode(error));
     }
 });
+// Agent setup command
+program
+    .command("agent")
+    .description("Configure AI agent for trading assistance")
+    .option("-s, --setup", "Run setup wizard to configure API key")
+    .addHelpText("after", `
+Examples:
+  httpcat agent --setup               # Configure AI agent
+
+The AI agent helps you:
+  • Trade tokens using natural language
+  • Check balances and positions
+  • Get market information
+  • Execute commands hands-free
+
+Use 'httpcat cat' to start interactive agent mode.
+  `)
+    .action(async (options) => {
+    try {
+        const { setupAIAgentWizard } = await import("./agent/setup-wizard.js");
+        if (options.setup) {
+            await setupAIAgentWizard();
+            process.exit(0);
+        }
+        else {
+            // Show help for agent command
+            console.log();
+            console.log(chalk.cyan.bold("🐱 AI Agent Setup"));
+            console.log();
+            console.log(chalk.bold("To configure:"));
+            console.log(chalk.dim("  httpcat agent --setup"));
+            console.log();
+            console.log(chalk.bold("To start agent mode:"));
+            console.log(chalk.dim("  httpcat cat"));
+            console.log();
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        handleError(error, program.opts().verbose);
+        process.exit(getExitCode(error));
+    }
+});
+// Cat command - starts agent interactive mode
+program
+    .command("cat")
+    .description("Start interactive AI agent mode")
+    .addHelpText("after", `
+Examples:
+  httpcat cat                        # Start interactive agent mode
+
+The AI agent helps you:
+  • Trade tokens using natural language
+  • Check balances and positions
+  • Get market information
+  • Execute commands hands-free
+
+Type /exit to quit agent mode.
+  `)
+    .action(async (options, command) => {
+    try {
+        const globalOpts = command.parent?.opts() || {};
+        const accountIndex = globalOpts.account;
+        // Ensure wallet is unlocked
+        await ensureWalletUnlocked();
+        let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+        // If not configured and not in JSON mode, prompt interactively
+        if (!isConfigured(globalOpts.privateKey)) {
+            if (globalOpts.json) {
+                console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                process.exit(2);
+            }
+            // Interactive prompt for private key
+            privateKey = await promptForPrivateKey();
+        }
+        const client = await HttpcatClient.create(privateKey);
+        // Check if agent is configured
+        const agentConfig = config.getAIAgentConfig();
+        if (!agentConfig) {
+            console.log();
+            console.log(chalk.yellow("⚠️  Agent not configured"));
+            console.log(chalk.dim("Run 'httpcat agent --setup' to configure the AI agent."));
+            console.log();
+            process.exit(1);
+        }
+        const apiKey = config.getAIAgentApiKey();
+        if (!apiKey) {
+            console.log();
+            console.log(chalk.red("❌ Failed to get API key"));
+            console.log(chalk.dim("Run 'httpcat agent --setup' to configure the API key."));
+            console.log();
+            process.exit(1);
+        }
+        // Start agent interactive mode
+        const { startAgentInteractiveMode } = await import("./interactive/shell.js");
+        await startAgentInteractiveMode(client);
+    }
+    catch (error) {
+        handleError(error, program.opts().verbose);
+        process.exit(getExitCode(error));
+    }
+});
 // MCP Server command
 program
     .command("mcp-server")
@@ -1305,7 +1533,7 @@ The server communicates via stdio and can be used with MCP clients like Cursor o
 
 Configuration:
   Add to your MCP client config (e.g., Cursor settings):
-  
+
   {
     "mcpServers": {
       "httpcat": {
@@ -1321,14 +1549,182 @@ Configuration:
     .action(async () => {
     await runMcpServer();
 });
+// Custom help formatting with grouped commands
+function displayGroupedHelp(program) {
+    console.log();
+    console.log(chalk.cyan.bold("httpcat - CLI tool for interacting with httpcat agent"));
+    console.log();
+    console.log(chalk.bold("Usage:"));
+    console.log(chalk.dim("  httpcat [options] <command>"));
+    console.log();
+    console.log(chalk.bold("Global Options:"));
+    program.options.forEach((opt) => {
+        const flags = opt.flags;
+        const description = opt.description || "";
+        console.log(`  ${chalk.green(flags.padEnd(30))} ${chalk.dim(description)}`);
+    });
+    console.log();
+    // Group commands
+    const commandGroups = {
+        "Token Operations": ["create", "buy", "sell", "claim"],
+        "Token Information": ["info", "list"],
+        Portfolio: ["positions", "transactions", "balances"],
+        "Account Management": ["account", "env"],
+        "AI & Social": ["agent", "chat"],
+        System: ["health", "config", "mcp-server"],
+    };
+    // Display grouped commands
+    for (const [groupName, commandNames] of Object.entries(commandGroups)) {
+        const commands = program.commands.filter((cmd) => commandNames.includes(cmd.name()));
+        if (commands.length > 0) {
+            console.log(chalk.bold(chalk.cyan(`${groupName}:`)));
+            commands.forEach((cmd) => {
+                // Build usage string from command name and arguments
+                const args = cmd.registeredArguments
+                    .map((arg) => {
+                    const nameOut = arg.name() + (arg.variadic ? "..." : "");
+                    return arg.required ? `<${nameOut}>` : `[${nameOut}]`;
+                })
+                    .join(" ");
+                const usage = args ? `${cmd.name()} ${args}` : cmd.name();
+                const description = cmd.description() || "";
+                console.log(`  ${chalk.green(usage.padEnd(30))} ${chalk.dim(description)}`);
+            });
+            console.log();
+        }
+    }
+    // Show subcommands for account and env
+    const accountCmd = program.commands.find((c) => c.name() === "account");
+    if (accountCmd) {
+        const subcommands = accountCmd.commands;
+        if (subcommands.length > 0) {
+            console.log(chalk.bold(chalk.cyan("Account Subcommands:")));
+            subcommands.forEach((cmd) => {
+                const args = cmd.registeredArguments
+                    .map((arg) => {
+                    const nameOut = arg.name() + (arg.variadic ? "..." : "");
+                    return arg.required ? `<${nameOut}>` : `[${nameOut}]`;
+                })
+                    .join(" ");
+                const usage = args
+                    ? `account ${cmd.name()} ${args}`
+                    : `account ${cmd.name()}`;
+                const description = cmd.description() || "";
+                console.log(`  ${chalk.green(usage.padEnd(30))} ${chalk.dim(description)}`);
+            });
+            console.log();
+        }
+    }
+    const envCmd = program.commands.find((c) => c.name() === "env");
+    if (envCmd) {
+        const subcommands = envCmd.commands;
+        if (subcommands.length > 0) {
+            console.log(chalk.bold(chalk.cyan("Environment Subcommands:")));
+            subcommands.forEach((cmd) => {
+                const args = cmd.registeredArguments
+                    .map((arg) => {
+                    const nameOut = arg.name() + (arg.variadic ? "..." : "");
+                    return arg.required ? `<${nameOut}>` : `[${nameOut}]`;
+                })
+                    .join(" ");
+                const usage = args ? `env ${cmd.name()} ${args}` : `env ${cmd.name()}`;
+                const description = cmd.description() || "";
+                console.log(`  ${chalk.green(usage.padEnd(30))} ${chalk.dim(description)}`);
+            });
+            console.log();
+        }
+    }
+    console.log(chalk.dim("Run 'httpcat <command> --help' for more information on a command."));
+    console.log();
+}
+// Override the default help output using configureHelp
+program.configureHelp({
+    commandUsage: (cmd) => {
+        const name = cmd.name();
+        const args = cmd.registeredArguments
+            .map((arg) => {
+            const nameOut = arg.name() + (arg.variadic ? "..." : "");
+            return arg.required ? `<${nameOut}>` : `[${nameOut}]`;
+        })
+            .join(" ");
+        return `${cmd.parent?.name() || "httpcat"} ${name}${args ? ` ${args}` : ""}`;
+    },
+    subcommandTerm: (cmd) => cmd.name(),
+});
 // Help command
 program
     .command("help")
     .description("Display help for httpcat")
     .action(() => {
-    program.outputHelp();
+    displayGroupedHelp(program);
     process.exit(0);
 });
+// Helper function to get a unique terminal session identifier
+function getTerminalSessionId() {
+    // Try to get terminal TTY device (most unique per terminal window)
+    // This works on Linux/Unix systems
+    try {
+        if (process.stdin.isTTY && process.stdin.fd !== undefined) {
+            const ttyPath = readlinkSync(`/proc/self/fd/${process.stdin.fd}`).replace(/^\/dev\//, "");
+            if (ttyPath && ttyPath !== "stdin") {
+                return `${process.env.USER || "default"}-${ttyPath}`;
+            }
+        }
+    }
+    catch {
+        // Fall through to other methods (e.g., on macOS or if /proc doesn't exist)
+    }
+    // Fall back to environment variables or user/term combination
+    return (process.env.TERM_SESSION_ID ||
+        process.env.SESSION_ID ||
+        `${process.env.USER || "default"}-${process.env.TERM || "unknown"}`);
+}
+// Helper function to check if animation has been shown in this terminal session
+function hasAnimationBeenShown() {
+    // Check environment variable first (user can set this manually)
+    if (process.env.HTTPCAT_ANIMATION_SHOWN === "1") {
+        return true;
+    }
+    // Check for marker file in temp directory
+    const sessionId = getTerminalSessionId();
+    const markerFile = join(tmpdir(), `httpcat-animation-${sessionId.replace(/[^a-zA-Z0-9]/g, "-")}.marker`);
+    if (existsSync(markerFile)) {
+        // Check if file is recent (within last hour) to handle stale files
+        try {
+            const stats = statSync(markerFile);
+            const ageMs = Date.now() - stats.mtimeMs;
+            const oneHour = 60 * 60 * 1000;
+            if (ageMs < oneHour) {
+                return true;
+            }
+            // File is stale, remove it
+            try {
+                unlinkSync(markerFile);
+            }
+            catch {
+                // Ignore errors when removing stale file
+            }
+        }
+        catch {
+            // If we can't read the file, assume animation hasn't been shown
+        }
+    }
+    return false;
+}
+// Helper function to mark animation as shown
+function markAnimationAsShown() {
+    // Set environment variable for current process
+    process.env.HTTPCAT_ANIMATION_SHOWN = "1";
+    // Create marker file for terminal session persistence
+    try {
+        const sessionId = getTerminalSessionId();
+        const markerFile = join(tmpdir(), `httpcat-animation-${sessionId.replace(/[^a-zA-Z0-9]/g, "-")}.marker`);
+        writeFileSync(markerFile, Date.now().toString(), { flag: "w" });
+    }
+    catch {
+        // If we can't write the marker file, that's okay - env var will still work for this process
+    }
+}
 // Interactive shell (default when no command)
 program.action(async (options) => {
     try {
@@ -1343,6 +1739,28 @@ program.action(async (options) => {
             await config.runSetupWizard();
             console.log();
         }
+        // Run cat spin animation if conditions are met
+        // Only show animation once per terminal session
+        const animationShown = hasAnimationBeenShown();
+        const shouldShowAnimation = !animationShown &&
+            isConfigured(options.privateKey) &&
+            options.art !== false &&
+            !options.json &&
+            !options.quiet;
+        if (shouldShowAnimation) {
+            const prefs = config.get("preferences");
+            if (prefs?.enableAsciiArt !== false) {
+                try {
+                    await runCatSpinAnimation();
+                    // Mark animation as shown for this terminal session
+                    markAnimationAsShown();
+                }
+                catch (error) {
+                    // If animation is interrupted or fails, continue to shell
+                    // Don't show error to user, just proceed
+                }
+            }
+        }
         const client = await HttpcatClient.create(privateKey);
         await startInteractiveShell(client);
     }