httpcat-cli 0.3.0 → 0.3.1

package/dist/commands/portfolio.js

@@ -0,0 +1,679 @@
+import { Command } from "commander";
+import { HttpcatClient } from "../client.js";
+import { config } from "../config.js";
+import { privateKeyToAccount } from "viem/accounts";
+// Import command functions
+import { checkBalance, displayBalance } from "./balances.js";
+import { getPositions, displayPositions } from "./positions.js";
+import { getTransactions, displayTransactions } from "./transactions.js";
+// Import utilities
+import { withLoading } from "../utils/loading.js";
+import { outputJson, outputError } from "../headless/json-output.js";
+import { handleError, getExitCode } from "../utils/errors.js";
+import { promptForPrivateKey } from "../utils/privateKeyPrompt.js";
+// ============================================================================
+// Shared Utilities (duplicated from index.ts to avoid circular dependencies)
+// ============================================================================
+function getPrivateKey(cliPrivateKey, accountIndex) {
+    if (cliPrivateKey)
+        return cliPrivateKey;
+    const envKey = process.env.HTTPCAT_PRIVATE_KEY;
+    if (envKey)
+        return envKey;
+    // Use account system
+    try {
+        const index = accountIndex !== undefined
+            ? accountIndex
+            : config.getActiveAccountIndex();
+        return config.getAccountPrivateKey(index);
+    }
+    catch (error) {
+        // Fall back to legacy format if account system not set up
+        return config.get("privateKey");
+    }
+}
+function isConfigured(cliPrivateKey) {
+    if (cliPrivateKey)
+        return true;
+    return config.isConfigured();
+}
+async function ensureWalletUnlocked() {
+    const password = config.getPassword();
+    if (!password) {
+        // No password required - ensure session is initialized
+        config.ensureSessionValid();
+        return;
+    }
+    if (!config.isSessionValid()) {
+        // Need to prompt for password
+        const inquirer = (await import("inquirer")).default;
+        const answers = await inquirer.prompt([
+            {
+                type: "password",
+                name: "password",
+                message: "Enter password to unlock wallet:",
+                mask: "•",
+            },
+        ]);
+        await config.unlockSession(answers.password);
+    }
+}
+// ============================================================================
+// Portfolio Command Group
+// ============================================================================
+export function createPortfolioCommand() {
+    const portfolioCommand = new Command("portfolio")
+        .description("Portfolio & history management")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio balances
+  httpcat portfolio positions
+  httpcat portfolio transactions
+    `);
+    // Balances subcommand
+    portfolioCommand
+        .command("balances")
+        .alias("bal")
+        .description("Check wallet balances (FREE)")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio balances
+  httpcat portfolio balances --json
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const silent = globalOpts.json || globalOpts.quiet;
+            const result = await withLoading(() => checkBalance(privateKey, silent), {
+                message: "Fetching balances...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("balances", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayBalance(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("balances", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Positions subcommand
+    portfolioCommand
+        .command("positions")
+        .alias("pos")
+        .description("Get all positions across products (FREE)")
+        .option("--active", "Show only active (non-graduated) positions")
+        .option("--graduated", "Show only graduated positions")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio positions
+  httpcat portfolio positions --active
+  httpcat portfolio positions --graduated
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Derive user address from private key
+            const account = privateKeyToAccount(privateKey);
+            const userAddress = account.address;
+            let result = await withLoading(() => getPositions(client, userAddress), {
+                message: "Fetching positions...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            // Determine filter
+            const filter = options.active
+                ? "active"
+                : options.graduated
+                    ? "graduated"
+                    : "all";
+            // Filter results for JSON output
+            if (globalOpts.json && filter !== "all") {
+                const filteredPositions = result.positions.filter((p) => filter === "active"
+                    ? p.token.status !== "graduated"
+                    : p.token.status === "graduated");
+                result = {
+                    ...result,
+                    positions: filteredPositions,
+                    total: filteredPositions.length,
+                };
+                outputJson("positions", result);
+            }
+            else if (globalOpts.json) {
+                outputJson("positions", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayPositions(result, filter);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("positions", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Summary subcommand
+    portfolioCommand
+        .command("summary")
+        .description("Get portfolio summary ($0.001)")
+        .option("--wallet <address>", "Wallet address (defaults to active account)")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio summary
+  httpcat portfolio summary --wallet 0x...
+  httpcat portfolio summary --json
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Derive wallet address if not provided
+            let walletAddress = options.wallet;
+            if (!walletAddress) {
+                const account = privateKeyToAccount(privateKey);
+                walletAddress = account.address;
+            }
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/portfolio/summary?wallet=${walletAddress}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("portfolio/summary", {
+                        wallet: walletAddress,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching portfolio summary...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("summary", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayPortfolioSummary(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("summary", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // PnL subcommand
+    portfolioCommand
+        .command("pnl")
+        .description("Get portfolio P&L ($0.001)")
+        .option("--wallet <address>", "Wallet address (defaults to active account)")
+        .option("--timeframe <timeframe>", "Timeframe: 1d, 7d, 30d, all (default: all)")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio pnl
+  httpcat portfolio pnl --timeframe 7d
+  httpcat portfolio pnl --wallet 0x... --json
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Derive wallet address if not provided
+            let walletAddress = options.wallet;
+            if (!walletAddress) {
+                const account = privateKeyToAccount(privateKey);
+                walletAddress = account.address;
+            }
+            const result = await withLoading(async () => {
+                const params = new URLSearchParams({
+                    wallet: walletAddress,
+                });
+                if (options.timeframe) {
+                    params.append("timeframe", options.timeframe);
+                }
+                try {
+                    const data = await client.get(`/portfolio/pnl?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("portfolio/pnl", {
+                        wallet: walletAddress,
+                        timeframe: options.timeframe || "all",
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching portfolio P&L...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("pnl", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayPortfolioPnl(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("pnl", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Trades subcommand
+    portfolioCommand
+        .command("trades")
+        .description("Get trade history ($0.001)")
+        .option("--wallet <address>", "Wallet address (defaults to active account)")
+        .option("--limit <number>", "Limit results (default: 50)", "50")
+        .option("--offset <number>", "Pagination offset (default: 0)", "0")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio trades
+  httpcat portfolio trades --limit 100
+  httpcat portfolio trades --wallet 0x...
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Derive wallet address if not provided
+            let walletAddress = options.wallet;
+            if (!walletAddress) {
+                const account = privateKeyToAccount(privateKey);
+                walletAddress = account.address;
+            }
+            const result = await withLoading(async () => {
+                const params = new URLSearchParams({
+                    wallet: walletAddress,
+                    limit: options.limit || "50",
+                    offset: options.offset || "0",
+                });
+                try {
+                    const data = await client.get(`/history/trades?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("history/trades", {
+                        wallet: walletAddress,
+                        limit: parseInt(options.limit || "50"),
+                        offset: parseInt(options.offset || "0"),
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching trade history...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("trades", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayTradeHistory(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("trades", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Transactions subcommand
+    portfolioCommand
+        .command("transactions")
+        .alias("txs")
+        .description("Get transaction history ($0.001)")
+        .option("--wallet <address>", "Wallet address (defaults to active account)")
+        .option("--limit <number>", "Limit results (default: 50)", "50")
+        .option("--offset <number>", "Pagination offset (default: 0)", "0")
+        .addHelpText("after", `
+Examples:
+  httpcat portfolio transactions
+  httpcat portfolio transactions --limit 100
+  httpcat portfolio transactions --wallet 0x...
+    `)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Derive wallet address if not provided
+            let walletAddress = options.wallet;
+            if (!walletAddress) {
+                const account = privateKeyToAccount(privateKey);
+                walletAddress = account.address;
+            }
+            const result = await withLoading(async () => {
+                // Try new endpoint first, fallback to old endpoint
+                const params = new URLSearchParams({
+                    wallet: walletAddress,
+                    limit: options.limit || "50",
+                    offset: options.offset || "0",
+                });
+                try {
+                    const data = await client.get(`/history/transactions?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    // Fallback to old endpoint for backward compatibility
+                    try {
+                        const { data } = await client.invoke("history/transactions", {
+                            wallet: walletAddress,
+                            limit: parseInt(options.limit || "50"),
+                            offset: parseInt(options.offset || "0"),
+                        });
+                        return data;
+                    }
+                    catch {
+                        // Final fallback to tokens/transactions
+                        return await getTransactions(client, {
+                            userAddress: walletAddress,
+                            limit: parseInt(options.limit || "50"),
+                            offset: parseInt(options.offset || "0"),
+                        });
+                    }
+                }
+            }, {
+                message: "Fetching transactions...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("transactions", result);
+            }
+            else if (!globalOpts.quiet) {
+                // Use appropriate display function based on response structure
+                if (result.transactions && Array.isArray(result.transactions)) {
+                    if (result.transactions[0]?.txHash) {
+                        // New format from /history/transactions
+                        displayTransactionHistory(result);
+                    }
+                    else {
+                        // Old format from /tokens/transactions
+                        displayTransactions(result);
+                    }
+                }
+                else {
+                    displayTransactionHistory(result);
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("transactions", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    return portfolioCommand;
+}
+// Display functions for portfolio commands
+function displayPortfolioSummary(summary) {
+    const chalk = require("chalk");
+    const { printBox, formatCurrency } = require("../utils/formatting.js");
+    console.log();
+    console.log(chalk.magenta.bold("📊 Portfolio Summary"));
+    console.log();
+    const boxData = {};
+    if (summary.wallet) {
+        boxData["Wallet"] = chalk.cyan(summary.wallet);
+    }
+    if (summary.totalValue !== undefined) {
+        boxData["Total Value"] = chalk.green.bold(formatCurrency(summary.totalValue));
+    }
+    if (summary.totalInvested !== undefined) {
+        boxData["Total Invested"] = chalk.cyan(formatCurrency(summary.totalInvested));
+    }
+    if (summary.totalPnl !== undefined) {
+        const pnlColor = parseFloat(summary.totalPnl) >= 0 ? chalk.green : chalk.red;
+        boxData["Total P&L"] = pnlColor(formatCurrency(summary.totalPnl));
+    }
+    if (summary.totalPnlPercentage !== undefined) {
+        const pnlPctColor = summary.totalPnlPercentage >= 0 ? chalk.green : chalk.red;
+        const sign = summary.totalPnlPercentage >= 0 ? "+" : "";
+        boxData["P&L %"] = pnlPctColor(`${sign}${summary.totalPnlPercentage.toFixed(2)}%`);
+    }
+    if (summary.positions !== undefined) {
+        boxData["Positions"] = chalk.cyan(summary.positions.toString());
+    }
+    if (summary.tokens !== undefined) {
+        boxData["Tokens"] = chalk.cyan(summary.tokens.toString());
+    }
+    printBox("Portfolio Summary", boxData);
+    console.log();
+}
+function displayPortfolioPnl(pnl) {
+    const chalk = require("chalk");
+    const { printBox, formatCurrency, createTable } = require("../utils/formatting.js");
+    console.log();
+    console.log(chalk.magenta.bold("💰 Portfolio P&L"));
+    console.log();
+    const boxData = {};
+    if (pnl.wallet) {
+        boxData["Wallet"] = chalk.cyan(pnl.wallet);
+    }
+    if (pnl.timeframe) {
+        boxData["Timeframe"] = chalk.cyan(pnl.timeframe.toUpperCase());
+    }
+    if (pnl.pnl !== undefined) {
+        const pnlColor = parseFloat(pnl.pnl) >= 0 ? chalk.green : chalk.red;
+        boxData["P&L"] = pnlColor(formatCurrency(pnl.pnl));
+    }
+    if (pnl.pnlPercentage !== undefined) {
+        const pnlPctColor = pnl.pnlPercentage >= 0 ? chalk.green : chalk.red;
+        const sign = pnl.pnlPercentage >= 0 ? "+" : "";
+        boxData["P&L %"] = pnlPctColor(`${sign}${pnl.pnlPercentage.toFixed(2)}%`);
+    }
+    printBox("Portfolio P&L", boxData);
+    if (pnl.breakdown && Array.isArray(pnl.breakdown) && pnl.breakdown.length > 0) {
+        console.log();
+        console.log(chalk.cyan.bold("Breakdown by Token:"));
+        console.log();
+        const table = createTable({
+            head: ["Token", "P&L", "P&L %"],
+            colWidths: [30, 20, 15],
+        });
+        for (const item of pnl.breakdown) {
+            const pnlColor = parseFloat(item.pnl) >= 0 ? chalk.green : chalk.red;
+            const pnlPctColor = item.pnlPercentage >= 0 ? chalk.green : chalk.red;
+            const sign = item.pnlPercentage >= 0 ? "+" : "";
+            table.push([
+                item.token || "N/A",
+                pnlColor(formatCurrency(item.pnl)),
+                pnlPctColor(`${sign}${item.pnlPercentage.toFixed(2)}%`),
+            ]);
+        }
+        console.log(table.toString());
+    }
+    console.log();
+}
+function displayTradeHistory(trades) {
+    const chalk = require("chalk");
+    const { formatAddress, formatCurrency, formatTokenAmount, createTable } = require("../utils/formatting.js");
+    console.log();
+    console.log(chalk.magenta.bold(`📈 Trade History (${trades.total || trades.trades?.length || 0} total)`));
+    console.log();
+    if (!trades.trades || trades.trades.length === 0) {
+        console.log(chalk.yellow("No trades found."));
+        console.log();
+        return;
+    }
+    const table = createTable({
+        head: ["Date", "Type", "Token In", "Token Out", "Amount In", "Amount Out", "TX"],
+        colWidths: [20, 10, 15, 15, 20, 20, 15],
+    });
+    for (const trade of trades.trades) {
+        const date = trade.timestamp
+            ? new Date(trade.timestamp).toLocaleString()
+            : "N/A";
+        const typeColor = trade.type === "buy"
+            ? chalk.green
+            : trade.type === "sell"
+                ? chalk.red
+                : chalk.cyan;
+        table.push([
+            chalk.dim(date),
+            typeColor(trade.type?.toUpperCase() || "N/A"),
+            trade.tokenIn ? formatAddress(trade.tokenIn, 8) : "N/A",
+            trade.tokenOut ? formatAddress(trade.tokenOut, 8) : "N/A",
+            trade.amountIn
+                ? formatTokenAmount(trade.amountIn)
+                : "N/A",
+            trade.amountOut
+                ? formatTokenAmount(trade.amountOut)
+                : "N/A",
+            trade.txHash ? formatAddress(trade.txHash, 8) : "N/A",
+        ]);
+    }
+    console.log(table.toString());
+    console.log();
+}
+function displayTransactionHistory(transactions) {
+    const chalk = require("chalk");
+    const { formatAddress, createTable } = require("../utils/formatting.js");
+    console.log();
+    console.log(chalk.magenta.bold(`📜 Transaction History (${transactions.total || transactions.transactions?.length || 0} total)`));
+    console.log();
+    if (!transactions.transactions || transactions.transactions.length === 0) {
+        console.log(chalk.yellow("No transactions found."));
+        console.log();
+        return;
+    }
+    const table = createTable({
+        head: ["Date", "Type", "Status", "Gas Used", "TX Hash"],
+        colWidths: [20, 15, 12, 15, 20],
+    });
+    for (const tx of transactions.transactions) {
+        const date = tx.timestamp
+            ? new Date(tx.timestamp).toLocaleString()
+            : "N/A";
+        const statusColor = tx.status === "success" || tx.status === "confirmed"
+            ? chalk.green
+            : tx.status === "pending"
+                ? chalk.yellow
+                : chalk.red;
+        table.push([
+            chalk.dim(date),
+            chalk.cyan(tx.type || "N/A"),
+            statusColor(tx.status?.toUpperCase() || "N/A"),
+            tx.gasUsed || "N/A",
+            tx.txHash ? formatAddress(tx.txHash, 10) : "N/A",
+        ]);
+    }
+    console.log(table.toString());
+    console.log();
+}
+//# sourceMappingURL=portfolio.js.map