httpcat-cli 0.3.0 → 0.3.1

package/dist/config.js

@@ -4,25 +4,30 @@ import chalk from "chalk";
 import path from "path";
 import os from "os";
 import fs from "fs";
-import { decryptData, encryptData, seedPhraseToPrivateKey, getAddressFromPrivateKey } from "./utils/wallet.js";
+import { decryptData, encryptData, seedPhraseToPrivateKey, getAddressFromPrivateKey, } from "./utils/wallet.js";
 const DEFAULT_ENVIRONMENTS = {
     local: {
         name: "local",
         agentUrl: "http://localhost:8787",
         network: "eip155:84532",
     },
-    sepolia: {
-        name: "sepolia",
-        agentUrl: "https://agent.402.cat",
+    "base-sepolia": {
+        name: "base-sepolia",
+        agentUrl: "https://agent-test.402.cat",
         network: "eip155:84532",
     },
+    base: {
+        name: "base",
+        agentUrl: "https://agent-main.402.cat",
+        network: "eip155:8453",
+    },
 };
 const DEFAULT_CONFIG = {
-    network: "eip155:84532",
-    agentUrl: "https://agent.402.cat",
-    facilitatorUrl: "https://facilitators.x402scan.com",
+    network: "eip155:8453",
+    agentUrl: "https://agent-main.402.cat",
+    facilitatorUrl: "https://facilitator.402.cat",
     defaultMaxPayment: "10.00",
-    environment: "sepolia",
+    environment: "base",
     environments: DEFAULT_ENVIRONMENTS,
     preferences: {
         enableAsciiArt: true,
@@ -34,6 +39,8 @@ export class ConfigManager {
     store;
     session = null;
     configPath;
+    agentInfoCache = null;
+    AGENT_INFO_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
     constructor() {
         // Explicitly define where we want the config file
         const configDir = path.join(os.homedir(), ".config", "httpcat");
@@ -70,8 +77,57 @@ export class ConfigManager {
                 }
             }
         }
-        // Initialize Conf WITHOUT cwd - let it use default location, then we'll redirect
+        // Validate and fix corrupted config files BEFORE Conf initialization
         // Conf's default on macOS is ~/Library/Preferences/httpcat-nodejs/config.json
+        const defaultConfPath = path.join(os.homedir(), "Library", "Preferences", "httpcat-nodejs", "config.json");
+        if (fs.existsSync(defaultConfPath)) {
+            try {
+                const content = fs.readFileSync(defaultConfPath, "utf-8").trim();
+                if (content) {
+                    JSON.parse(content); // Validate JSON
+                }
+                else {
+                    // Empty file - delete it so Conf uses defaults
+                    fs.unlinkSync(defaultConfPath);
+                }
+            }
+            catch {
+                // Corrupted JSON - backup and delete it
+                try {
+                    const backupPath = `${defaultConfPath}.backup.${Date.now()}`;
+                    fs.copyFileSync(defaultConfPath, backupPath);
+                }
+                catch {
+                    // Ignore backup failure
+                }
+                fs.unlinkSync(defaultConfPath);
+            }
+        }
+        // Also validate our custom config path before Conf tries to read it
+        if (fs.existsSync(this.configPath)) {
+            try {
+                const configContent = fs.readFileSync(this.configPath, "utf-8").trim();
+                if (configContent) {
+                    JSON.parse(configContent); // Validate JSON
+                }
+                else {
+                    // Empty file - initialize with defaults
+                    fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+                }
+            }
+            catch {
+                // Corrupted - backup and recreate
+                try {
+                    const backupPath = `${this.configPath}.backup.${Date.now()}`;
+                    fs.copyFileSync(this.configPath, backupPath);
+                }
+                catch {
+                    // Ignore backup failure
+                }
+                fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+            }
+        }
+        // Initialize Conf WITHOUT cwd - let it use default location, then we'll redirect
         // But we want ~/.config/httpcat/config.json
         // So we'll initialize Conf normally, then manually sync to our desired location
         this.store = new Conf({
@@ -81,8 +137,33 @@ export class ConfigManager {
         });
         // Always sync from correct location to Conf's location on init
         // This ensures Conf reads the right data
+        // If config file doesn't exist, create it with defaults
+        if (!fs.existsSync(this.configPath)) {
+            // Ensure directory exists
+            fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+            // Write defaults to config file
+            fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+        }
         if (fs.existsSync(this.configPath)) {
             try {
+                // Validate JSON before copying
+                const configContent = fs.readFileSync(this.configPath, "utf-8").trim();
+                if (configContent) {
+                    // Try to parse JSON to validate it
+                    try {
+                        JSON.parse(configContent);
+                    }
+                    catch (parseError) {
+                        // Config file is corrupted - backup and recreate with defaults
+                        const backupPath = `${this.configPath}.backup.${Date.now()}`;
+                        fs.copyFileSync(this.configPath, backupPath);
+                        fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+                    }
+                }
+                else {
+                    // Empty file - initialize with defaults
+                    fs.writeFileSync(this.configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+                }
                 // Ensure Conf's directory exists
                 const confDir = path.dirname(this.store.path);
                 fs.mkdirSync(confDir, { recursive: true });
@@ -96,13 +177,38 @@ export class ConfigManager {
                 });
             }
             catch (error) {
-                // Silently fail
+                // If copying fails, try to initialize Conf with defaults
+                try {
+                    this.store = new Conf({
+                        projectName: "httpcat",
+                        defaults: DEFAULT_CONFIG,
+                    });
+                }
+                catch (fallbackError) {
+                    // Last resort: delete corrupted file and start fresh
+                    if (fs.existsSync(this.configPath)) {
+                        const backupPath = `${this.configPath}.backup.${Date.now()}`;
+                        try {
+                            fs.copyFileSync(this.configPath, backupPath);
+                        }
+                        catch {
+                            // Ignore backup failure
+                        }
+                        fs.unlinkSync(this.configPath);
+                    }
+                    this.store = new Conf({
+                        projectName: "httpcat",
+                        defaults: DEFAULT_CONFIG,
+                    });
+                }
             }
         }
         // Migrate old privateKey format on first access
         this.migrateLegacyPrivateKey();
         // Migrate network format from V1 to V2 (base-sepolia -> eip155:84532)
         this.migrateNetworkFormat();
+        // Migrate sepolia environment to base-sepolia
+        this.migrateSepoliaEnvironment();
     }
     /**
      * Migrate config from old location to new location (~/.config/httpcat)
@@ -122,7 +228,10 @@ export class ConfigManager {
             if (fs.existsSync(oldPath)) {
                 const oldData = oldStore.store;
                 const hasOldData = Object.keys(oldData).length > 0 &&
-                    (oldData.privateKey || oldData.accounts || oldData.encryptedPrivateKey || oldData.encryptedSeedPhrase);
+                    (oldData.privateKey ||
+                        oldData.accounts ||
+                        oldData.encryptedPrivateKey ||
+                        oldData.encryptedSeedPhrase);
                 // Check if new config already exists
                 const newConfigExists = fs.existsSync(newPath);
                 if (hasOldData && !newConfigExists) {
@@ -159,7 +268,8 @@ export class ConfigManager {
                 // Check if correct file is newer or Conf's file doesn't exist
                 const needsSync = !fs.existsSync(this.store.path) ||
                     (fs.existsSync(this.store.path) &&
-                        fs.statSync(this.configPath).mtimeMs > fs.statSync(this.store.path).mtimeMs);
+                        fs.statSync(this.configPath).mtimeMs >
+                            fs.statSync(this.store.path).mtimeMs);
                 if (needsSync) {
                     // Ensure Conf's directory exists
                     const confDir = path.dirname(this.store.path);
@@ -200,7 +310,8 @@ export class ConfigManager {
             try {
                 const needsSync = !fs.existsSync(this.store.path) ||
                     (fs.existsSync(this.store.path) &&
-                        fs.statSync(this.configPath).mtimeMs > fs.statSync(this.store.path).mtimeMs);
+                        fs.statSync(this.configPath).mtimeMs >
+                            fs.statSync(this.store.path).mtimeMs);
                 if (needsSync) {
                     const confDir = path.dirname(this.store.path);
                     fs.mkdirSync(confDir, { recursive: true });
@@ -225,6 +336,18 @@ export class ConfigManager {
     }
     clear() {
         this.store.clear();
+        // Sync the cleared state to the config file
+        if (this.store.path !== this.configPath && fs.existsSync(this.store.path)) {
+            try {
+                // Ensure directory exists
+                fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+                // Copy from Conf's location to correct location
+                fs.copyFileSync(this.store.path, this.configPath);
+            }
+            catch (error) {
+                // Silently fail sync - not critical
+            }
+        }
     }
     getConfigPath() {
         // Return the path we want to use (the correct one)
@@ -240,7 +363,9 @@ export class ConfigManager {
                 if (configData.accounts && configData.accounts.length > 0) {
                     return true;
                 }
-                if (configData.privateKey || configData.encryptedPrivateKey || configData.encryptedSeedPhrase) {
+                if (configData.privateKey ||
+                    configData.encryptedPrivateKey ||
+                    configData.encryptedSeedPhrase) {
                     return true;
                 }
             }
@@ -253,7 +378,8 @@ export class ConfigManager {
             try {
                 const needsSync = !fs.existsSync(this.store.path) ||
                     (fs.existsSync(this.store.path) &&
-                        fs.statSync(this.configPath).mtimeMs > fs.statSync(this.store.path).mtimeMs);
+                        fs.statSync(this.configPath).mtimeMs >
+                            fs.statSync(this.store.path).mtimeMs);
                 if (needsSync) {
                     const confDir = path.dirname(this.store.path);
                     fs.mkdirSync(confDir, { recursive: true });
@@ -306,15 +432,38 @@ export class ConfigManager {
             }
         }
     }
+    /**
+     * Migrate sepolia environment to base-sepolia
+     */
+    migrateSepoliaEnvironment() {
+        const envs = this.get("environments");
+        if (envs && envs.sepolia) {
+            // Rename sepolia environment to base-sepolia
+            const updatedEnvs = {};
+            for (const [name, env] of Object.entries(envs)) {
+                const envProfile = env;
+                if (name === "sepolia") {
+                    updatedEnvs["base-sepolia"] = { ...envProfile, name: "base-sepolia" };
+                }
+                else {
+                    updatedEnvs[name] = envProfile;
+                }
+            }
+            this.set("environments", updatedEnvs);
+        }
+        // Update current environment if it's sepolia
+        const currentEnv = this.get("environment");
+        if (currentEnv === "sepolia") {
+            this.set("environment", "base-sepolia");
+        }
+    }
     /**
      * Convert network name to CAIP-2 format
      */
     networkToCAIP2(network) {
         const mapping = {
             "base-sepolia": "eip155:84532",
-            "base": "eip155:8453",
-            "ethereum": "eip155:1",
-            "sepolia": "eip155:11155111",
+            base: "eip155:8453",
         };
         return mapping[network] || network; // Return as-is if already CAIP-2 or unknown
     }
@@ -325,8 +474,6 @@ export class ConfigManager {
         const mapping = {
             "eip155:84532": "base-sepolia",
             "eip155:8453": "base",
-            "eip155:1": "ethereum",
-            "eip155:11155111": "sepolia",
         };
         return mapping[caip2] || caip2; // Return as-is if not in mapping
     }
@@ -334,7 +481,9 @@ export class ConfigManager {
      * Check if network is a testnet
      */
     isTestnet(network) {
-        return network === "eip155:84532" || network === "eip155:11155111" || network.includes("sepolia");
+        return (network === "eip155:84532" ||
+            network === "eip155:11155111" ||
+            network.includes("sepolia"));
     }
     /**
      * Migrate legacy privateKey to new account format
@@ -380,17 +529,30 @@ export class ConfigManager {
         console.log(chalk.cyan("=".repeat(80)));
         console.log();
         if (!options.skipPrivateKey) {
-            // Use the nice wallet setup wizard instead of directly asking for private key
-            const { promptForPrivateKey } = await import("./utils/privateKeyPrompt.js");
-            await promptForPrivateKey();
-            console.log();
+            // Check if import mode is enabled via environment variable
+            if (process.env.HTTPCAT_IMPORT_MODE === "true") {
+                // Use the nice wallet setup wizard instead of directly asking for private key
+                const { promptForPrivateKey } = await import("./utils/privateKeyPrompt.js");
+                await promptForPrivateKey();
+                console.log();
+            }
+            else {
+                // Auto-generate seed phrase for new users
+                const { autoSetupWallet } = await import("./utils/autoSetup.js");
+                await autoSetupWallet();
+                console.log();
+            }
         }
         // Network selection
-        const network = "eip155:84532";
+        const network = "eip155:8453";
         this.set("network", network);
         console.log(chalk.green(`✅ Network set to: ${this.caip2ToNetwork(network)} (${network}) (testnet)\n`));
-        // Agent URL
-        const defaultUrl = "https://agent.402.cat";
+        // Agent URL - use correct default based on network
+        // base-sepolia (eip155:84532) -> testnet URL
+        // base (eip155:8453) -> mainnet URL
+        const defaultUrl = network === "eip155:8453"
+            ? "https://agent-main.402.cat"
+            : "https://agent-test.402.cat";
         const agentUrl = await this.prompt(`Agent URL [${defaultUrl}]: `, defaultUrl);
         this.set("agentUrl", agentUrl);
         console.log(chalk.green(`✅ Agent URL set to: ${agentUrl}\n`));
@@ -407,6 +569,68 @@ export class ConfigManager {
         console.log();
         console.log(chalk.dim(`Config saved to: ${this.getConfigPath()}`));
         console.log();
+        // Shell setup (completion and alias)
+        await this.promptShellSetup();
+    }
+    async promptShellSetup() {
+        try {
+            const { detectShell, installShellCompletion, installHcAlias } = await import("./utils/shell-setup.js");
+            const shell = detectShell();
+            if (shell === "unknown") {
+                console.log(chalk.yellow("⚠️  Could not detect shell type. Skipping shell setup."));
+                console.log();
+                return;
+            }
+            // Prompt for completion installation
+            const installCompletion = await this.prompt(`Install shell autocompletion for ${shell}? [Y/n]: `, "y");
+            if (installCompletion.toLowerCase() !== "n") {
+                console.log(chalk.cyan("Installing shell completion..."));
+                const success = installShellCompletion();
+                if (success) {
+                    console.log(chalk.green(`✅ Shell completion installed for ${shell}!`));
+                    console.log(chalk.dim("   Restart your terminal or run: source ~/." +
+                        (shell === "zsh" ? "zshrc" : "bashrc")));
+                }
+                else {
+                    console.log(chalk.yellow("⚠️  Failed to install shell completion. You can install it manually later with:"));
+                    console.log(chalk.dim(`   httpcat completion ${shell} >> ~/.${shell === "zsh" ? "zshrc" : "bashrc"}`));
+                }
+                console.log();
+            }
+            // Prompt for alias creation
+            const createAlias = await this.prompt("Create 'hc' alias for httpcat? [Y/n]: ", "y");
+            if (createAlias.toLowerCase() !== "n") {
+                console.log(chalk.cyan("Creating 'hc' alias..."));
+                const result = installHcAlias();
+                if (result.success) {
+                    if (result.method === "symlink") {
+                        console.log(chalk.green("✅ 'hc' alias created (symlink)!"));
+                        console.log(chalk.dim("   You can now use 'hc' instead of 'httpcat' immediately."));
+                    }
+                    else {
+                        console.log(chalk.green("✅ 'hc' alias created (shell alias)!"));
+                        console.log(chalk.dim("   You can now use 'hc' instead of 'httpcat'. Restart your terminal or run:"));
+                        if (shell === "zsh") {
+                            console.log(chalk.dim("   source ~/.zshrc"));
+                        }
+                        else {
+                            console.log(chalk.dim("   source ~/.bashrc"));
+                        }
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("⚠️  Failed to create 'hc' alias. You can create it manually with:"));
+                    console.log(chalk.dim(`   alias hc='httpcat'`));
+                    console.log(chalk.dim(`   Add this to your ~/.${shell === "zsh" ? "zshrc" : "bashrc"} file`));
+                }
+                console.log();
+            }
+        }
+        catch (error) {
+            // Non-fatal error - don't break the wizard
+            console.log(chalk.yellow("⚠️  Shell setup skipped due to error (non-fatal)"));
+            console.log();
+        }
     }
     prompt(question, defaultValue) {
         return new Promise((resolve) => {
@@ -448,18 +672,18 @@ export class ConfigManager {
         // Ensure session is valid
         this.ensureSessionValid();
         if (account.type === "custom") {
-            // Account 0 - use encrypted private key
-            const encrypted = this.get("encryptedPrivateKey");
+            // Custom account - get encrypted private key from account or fall back to global
+            const encrypted = account.encryptedPrivateKey || this.get("encryptedPrivateKey");
             if (!encrypted) {
-                throw new Error("Account 0 private key not found");
+                throw new Error(`Private key not found for account ${accountIndex}`);
             }
             const password = this.get("password") || "";
             if (password) {
-                // Decrypt using session
-                if (!this.session?.decryptedPrivateKey) {
+                // Decrypt on-demand
+                if (!this.isSessionValid()) {
                     throw new Error("Session expired. Please unlock your wallet.");
                 }
-                return this.session.decryptedPrivateKey;
+                return decryptData(encrypted, password);
             }
             else {
                 // No password - stored as plain (but in encryptedPrivateKey field)
@@ -684,7 +908,22 @@ export class ConfigManager {
             this.set("environments", DEFAULT_ENVIRONMENTS);
             return DEFAULT_ENVIRONMENTS;
         }
-        return envs;
+        // Merge in any missing default environments (but don't overwrite user-modified defaults)
+        let updated = false;
+        const mergedEnvs = { ...envs };
+        for (const [name, defaultEnv] of Object.entries(DEFAULT_ENVIRONMENTS)) {
+            if (!mergedEnvs[name]) {
+                // Add missing environment
+                mergedEnvs[name] = defaultEnv;
+                updated = true;
+            }
+            // Don't overwrite existing environments - user may have modified them
+            // Only add missing ones, never overwrite existing ones
+        }
+        if (updated) {
+            this.set("environments", mergedEnvs);
+        }
+        return mergedEnvs;
     }
     getCurrentEnvironment() {
         return this.get("environment");
@@ -704,8 +943,10 @@ export class ConfigManager {
         // Update agentUrl and network from environment
         this.set("agentUrl", env.agentUrl);
         this.set("network", env.network);
+        // Clear agent info cache since we switched environments
+        this.clearAgentInfoCache();
     }
-    addEnvironment(name, agentUrl, network = "eip155:84532") {
+    addEnvironment(name, agentUrl, network = "eip155:8453") {
         const envs = this.getEnvironments();
         if (envs[name]) {
             throw new Error(`Environment "${name}" already exists. Use a different name.`);
@@ -717,7 +958,7 @@ export class ConfigManager {
         };
         this.set("environments", envs);
     }
-    updateEnvironment(name, agentUrl, network = "eip155:84532") {
+    updateEnvironment(name, agentUrl, network = "eip155:8453") {
         const envs = this.getEnvironments();
         if (!envs[name]) {
             throw new Error(`Environment "${name}" does not exist. Use "httpcat env add" to create it.`);
@@ -752,6 +993,73 @@ export class ConfigManager {
         }
         return this.get("rpcUrl");
     }
+    getAlchemyApiKey() {
+        // Priority: Env var > Config
+        const envKey = process.env.HTTPCAT_ALCHEMY_API_KEY;
+        if (envKey) {
+            return envKey;
+        }
+        return this.get("alchemyApiKey");
+    }
+    /**
+     * Get public RPC URL for a given chain ID
+     */
+    getPublicRpcUrl(chainId) {
+        switch (chainId) {
+            case 84532: // Base Sepolia
+                return "https://sepolia.base.org";
+            case 8453: // Base Mainnet
+                return "https://mainnet.base.org";
+            default:
+                throw new Error(`Unsupported chain ID for public RPC: ${chainId}`);
+        }
+    }
+    /**
+     * Get Alchemy RPC URL for a given chain ID and API key
+     */
+    getAlchemyRpcUrl(chainId, apiKey) {
+        switch (chainId) {
+            case 84532: // Base Sepolia
+                return `https://base-sepolia.g.alchemy.com/v2/${apiKey}`;
+            case 8453: // Base Mainnet
+                return `https://base-mainnet.g.alchemy.com/v2/${apiKey}`;
+            default:
+                throw new Error(`Unsupported chain ID for Alchemy RPC: ${chainId}`);
+        }
+    }
+    getPlatformTokenAddress() {
+        // Get the CAT platform token address from environment variable
+        return process.env.HTTPCAT_PLATFORM_TOKEN_ADDRESS;
+    }
+    /**
+     * Fetch and cache agent info from the /info endpoint
+     * Returns cached data if available and not expired
+     */
+    async getAgentInfo() {
+        // Check if cached data is still valid
+        if (this.agentInfoCache) {
+            const age = Date.now() - this.agentInfoCache.timestamp;
+            if (age < this.AGENT_INFO_CACHE_TTL) {
+                return this.agentInfoCache.data;
+            }
+        }
+        // Fetch fresh data
+        const agentUrl = this.getAgentUrl();
+        const { fetchAgentInfo } = await import("./types/agent-info.js");
+        const data = await fetchAgentInfo(agentUrl);
+        // Cache the data
+        this.agentInfoCache = {
+            data,
+            timestamp: Date.now(),
+        };
+        return data;
+    }
+    /**
+     * Clear the agent info cache (useful when switching environments)
+     */
+    clearAgentInfoCache() {
+        this.agentInfoCache = null;
+    }
     /**
      * AI Agent configuration methods
      */
@@ -789,7 +1097,8 @@ export class ConfigManager {
         // OpenAI keys can start with "sk-" (legacy) or "sk-proj-" (newer project keys)
         // Newer keys are much longer, so we just check prefix and minimum length
         const trimmed = apiKey.trim();
-        return (trimmed.startsWith("sk-") || trimmed.startsWith("sk-proj-")) && trimmed.length >= 20;
+        return ((trimmed.startsWith("sk-") || trimmed.startsWith("sk-proj-")) &&
+            trimmed.length >= 20);
     }
     /**
      * Validate Anthropic API key format
@@ -824,11 +1133,13 @@ export class ConfigManager {
         apiKey = apiKey.trim();
         // Validate API key format based on provider
         if (apiKey && agentConfig.provider) {
-            if (agentConfig.provider === "openai" && !this.validateOpenAIApiKey(apiKey)) {
+            if (agentConfig.provider === "openai" &&
+                !this.validateOpenAIApiKey(apiKey)) {
                 throw new Error("Invalid OpenAI API key format. OpenAI keys should start with 'sk-'. " +
                     "Please run 'agent --setup' (or 'cat --setup') to reconfigure your API key.");
             }
-            if (agentConfig.provider === "anthropic" && !this.validateAnthropicApiKey(apiKey)) {
+            if (agentConfig.provider === "anthropic" &&
+                !this.validateAnthropicApiKey(apiKey)) {
                 throw new Error("Invalid Anthropic API key format. Anthropic keys should start with 'sk-ant-'. " +
                     "Please run 'agent --setup' (or 'cat --setup') to reconfigure your API key.");
             }