httpcat-cli 0.2.11 → 0.2.12-rc.2

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...",
@@ -444,6 +469,38 @@ Examples:
                         if (!globalOpts.json && !globalOpts.quiet) {
                             console.log();
                             console.log(chalk.yellow("💡 Insufficient funds. Stopping buy loop."));
+                            console.log();
+                            // Show current balance to help diagnose the issue
+                            try {
+                                const balance = await checkBalance(privateKey, true);
+                                console.log(chalk.cyan("💰 Current Wallet Balances:"));
+                                console.log(chalk.dim(`   ETH:  ${balance.ethFormatted}`));
+                                console.log(chalk.dim(`   USDC: ${balance.usdcFormatted}`));
+                                if (balance.cat402Formatted) {
+                                    console.log(chalk.dim(`   CAT:  ${balance.cat402Formatted}`));
+                                }
+                                console.log();
+                                // Provide guidance based on what might be insufficient
+                                const usdcBalance = parseFloat(balance.usdcFormatted.replace("$", "").replace(",", ""));
+                                const ethBalance = parseFloat(balance.ethFormatted.replace(" ETH", "").replace(",", ""));
+                                const buyAmount = parseFloat(finalAmount);
+                                console.log(chalk.yellow("💡 Possible issues:"));
+                                if (usdcBalance < buyAmount) {
+                                    console.log(chalk.dim(`   • Insufficient USDC for purchase: Need $${buyAmount.toFixed(6)}, have $${usdcBalance.toFixed(6)}`));
+                                }
+                                if (usdcBalance < 0.01) {
+                                    console.log(chalk.dim(`   • Low USDC for API payments: x402 protocol requires USDC for API calls`));
+                                }
+                                if (ethBalance < 0.001) {
+                                    console.log(chalk.dim(`   • Low ETH for gas: Need ETH to pay for transaction fees`));
+                                }
+                                console.log();
+                                console.log(chalk.dim("   Check your balance with: httpcat balances"));
+                            }
+                            catch (balanceError) {
+                                // If we can't fetch balance, just show generic message
+                                console.log(chalk.dim("   Check your balance with: httpcat balances"));
+                            }
                         }
                         break;
                     }
@@ -1276,10 +1333,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 +1355,54 @@ Examples:
         process.exit(getExitCode(error));
     }
 });
+// Agent command
+program
+    .command("agent")
+    .alias("cat")
+    .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
+  httpcat cat --setup                 # Same, using 'cat' alias
+
+The AI agent helps you:
+  • Trade tokens using natural language
+  • Check balances and positions
+  • Get market information
+  • Execute commands hands-free
+
+You can use 'agent' or 'cat' interchangeably.
+  `)
+    .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"));
+            console.log();
+            console.log(chalk.yellow("The AI agent feature is currently available only in interactive mode."));
+            console.log();
+            console.log(chalk.bold("To configure:"));
+            console.log(chalk.dim("  httpcat agent --setup"));
+            console.log();
+            console.log(chalk.bold("Note:"));
+            console.log(chalk.dim("  The agent command has been temporarily disabled in interactive mode."));
+            console.log(chalk.dim("  Use the CLI setup above to configure your API keys for future use."));
+            console.log();
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        handleError(error, program.opts().verbose);
+        process.exit(getExitCode(error));
+    }
+});
 // MCP Server command
 program
     .command("mcp-server")
@@ -1305,7 +1416,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 +1432,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 +1622,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);
     }