httpcat-cli 0.3.0 → 0.3.1

package/dist/utils/llm-cli-config.js

@@ -0,0 +1,963 @@
+/**
+ * LLM CLI Configuration Writers
+ *
+ * This module provides configuration functions for each supported LLM CLI tool.
+ * Each function handles the specific configuration format and location for its tool.
+ *
+ * Configuration Strategy:
+ * 1. For tools with CLI commands (Codex, Gemini, MCP-Use): Try CLI command first, fall back to file
+ * 2. For file-only tools (Claude Desktop, Cursor): Direct file modification
+ * 3. All functions update existing MCP server configs if they already exist
+ * 4. Private key is always passed via HTTPCAT_PRIVATE_KEY environment variable
+ *
+ * Supported Configuration Formats:
+ * - JSON: Most tools (Claude Desktop, Cursor, LLM Tools, MCP Client)
+ * - TOML: Codex CLI (requires custom parser/stringifier)
+ * - Extension JSON: Gemini CLI (extension-based architecture)
+ *
+ * Error Handling:
+ * - All functions return boolean (true = success, false = failure)
+ * - Errors are logged but don't throw (graceful degradation)
+ * - Invalid config files are backed up and recreated
+ */
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+/**
+ * Check if httpcat is globally installed
+ *
+ * Determines whether to use "httpcat" directly or "npx httpcat-cli".
+ * This affects the command and args in MCP server configurations.
+ *
+ * @returns true if httpcat command exists in PATH, false otherwise
+ */
+function isHttpcatGlobal() {
+    try {
+        execSync("which httpcat", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get standardized MCP server configuration
+ *
+ * Creates a consistent MCP server config object that can be used across all LLM tools.
+ * The configuration includes:
+ * - command: "httpcat" (if global) or "npx" (if npm package)
+ * - args: Appropriate arguments for the installation method
+ * - Note: No HTTPCAT_PRIVATE_KEY in env - server reads from config file instead
+ *
+ * This ensures all tools use the same MCP server setup, just in different formats.
+ *
+ * @returns MCP server configuration object
+ */
+function getMcpServerConfig() {
+    const isGlobal = isHttpcatGlobal();
+    return {
+        command: isGlobal ? "httpcat" : "npx",
+        args: isGlobal ? ["mcp", "start"] : ["-y", "httpcat-cli", "mcp", "start"],
+        // No env vars - private key is read from ~/.config/httpcat/config.json by MCP server
+    };
+}
+/**
+ * Configure Claude Desktop
+ *
+ * Claude Desktop is a desktop application (no CLI). Configuration is done via JSON file:
+ * - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
+ * - Windows: %APPDATA%/Claude/claude_desktop_config.json
+ * - Linux: ~/.config/Claude/claude_desktop_config.json
+ *
+ * Configuration format: Standard MCP JSON format with mcpServers object.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to claude_desktop_config.json
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureClaudeDesktop(configPath) {
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+            }
+            catch {
+                // Invalid JSON - create new config (old one may be corrupted)
+                config = {};
+            }
+        }
+        // Ensure mcpServers object exists
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Add or update httpcat server configuration
+        config.mcpServers.httpcat = getMcpServerConfig();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure Claude Desktop: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure Cursor IDE
+ *
+ * Cursor is a code editor with MCP support. Configuration can be:
+ * - Global: ~/.cursor/mcp.json (applies to all projects)
+ * - Workspace: .cursor/mcp.json (project-specific)
+ *
+ * The detector prioritizes global config, but this function works with either.
+ * Configuration format: Standard MCP JSON format.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to mcp.json (global or workspace)
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureCursor(configPath) {
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+            }
+            catch {
+                // Invalid JSON - create new config
+                config = {};
+            }
+        }
+        // Ensure mcpServers object exists
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Add or update httpcat server configuration
+        config.mcpServers.httpcat = getMcpServerConfig();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure Cursor: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure LLM Tools MCP
+ *
+ * LLM Tools MCP is a plugin for Simon Willison's "llm" CLI tool.
+ * Requires: "llm" CLI installed AND "llm-tools-mcp" plugin installed.
+ *
+ * Configuration location: ~/.llm-tools-mcp/mcp.json
+ * Configuration format: Standard MCP JSON format.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to ~/.llm-tools-mcp/mcp.json
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureLlmToolsMcp(configPath) {
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+            }
+            catch {
+                // Invalid JSON - create new config
+                config = {};
+            }
+        }
+        // Ensure mcpServers object exists
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Add or update httpcat server configuration
+        config.mcpServers.httpcat = getMcpServerConfig();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure LLM Tools MCP: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure MCP-Use CLI
+ *
+ * MCP-Use is a standalone MCP client CLI tool. It supports both:
+ * 1. CLI commands: "mcp-use server add" (preferred method)
+ * 2. File-based config: ~/.mcp-use/config.json (fallback)
+ *
+ * Strategy: Try CLI command first, fall back to file if CLI fails.
+ * This ensures we use the official CLI interface when available.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureMcpUse() {
+    try {
+        // Try CLI command first (preferred method)
+        const isGlobal = isHttpcatGlobal();
+        const command = isGlobal ? "httpcat" : "npx -y httpcat-cli";
+        const args = isGlobal ? "mcp start" : "mcp start";
+        try {
+            // Execute CLI command to add MCP server
+            execSync(`mcp-use server add httpcat --command "${command}" --args "${args}"`, { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            // CLI command failed (tool may not support this command or not installed)
+            // Fall back to file-based configuration
+            const configPath = path.join(process.env.HOME || "", ".mcp-use", "config.json");
+            const configDir = path.dirname(configPath);
+            fs.mkdirSync(configDir, { recursive: true });
+            // Read existing config or start with empty object
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, "utf-8");
+                try {
+                    config = JSON.parse(content);
+                }
+                catch {
+                    config = {};
+                }
+            }
+            // Ensure mcpServers object exists
+            if (!config.mcpServers) {
+                config.mcpServers = {};
+            }
+            // Add or update httpcat server configuration
+            config.mcpServers.httpcat = getMcpServerConfig();
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+            return true;
+        }
+    }
+    catch (error) {
+        console.error(`Failed to configure MCP-Use: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure MCP Client CLI
+ *
+ * MCP Client CLI is another MCP client implementation.
+ * Configuration location: ~/.llm/config.json
+ * Configuration format: Standard MCP JSON format.
+ *
+ * Note: This shares the same config directory as other LLM tools,
+ * so we're careful to merge rather than overwrite.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to ~/.llm/config.json
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureMcpClient(configPath) {
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+            }
+            catch {
+                // Invalid JSON - create new config
+                config = {};
+            }
+        }
+        // Ensure mcpServers object exists
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Add or update httpcat server configuration
+        config.mcpServers.httpcat = getMcpServerConfig();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure MCP Client: ${error}`);
+        return false;
+    }
+}
+/**
+ * Parse TOML file (simplified parser for Codex config)
+ *
+ * This is a simplified TOML parser that handles the subset of TOML syntax
+ * needed for Codex CLI configuration. It supports:
+ * - Section headers: [section.name]
+ * - String values: key = "value"
+ * - Arrays: key = ["value1", "value2"]
+ * - Inline tables: key = { k1 = "v1", k2 = "v2" }
+ * - Comments: Lines starting with #
+ *
+ * Note: This is NOT a full TOML parser. It's designed specifically for
+ * the Codex config format. For more complex TOML files, consider using
+ * a proper TOML library like @iarna/toml.
+ *
+ * @param content - TOML file content as string
+ * @returns Parsed TOML as JavaScript object
+ */
+function parseToml(content) {
+    const result = {};
+    const lines = content.split("\n");
+    let currentSection = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        // Parse section header: [section.name]
+        const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            if (!result[currentSection]) {
+                result[currentSection] = {};
+            }
+            continue;
+        }
+        // Parse key = value pairs
+        const keyValueMatch = trimmed.match(/^([^=]+)\s*=\s*(.+)$/);
+        if (keyValueMatch && currentSection) {
+            const key = keyValueMatch[1].trim();
+            let value = keyValueMatch[2].trim();
+            // Remove quotes from string values
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            // Parse arrays: ["value1", "value2"]
+            else if (value.startsWith("[") && value.endsWith("]")) {
+                value = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
+            }
+            // Parse inline tables: { key1 = "value1", key2 = "value2" }
+            else if (value.startsWith("{") && value.endsWith("}")) {
+                const tableContent = value.slice(1, -1);
+                value = {};
+                tableContent.split(",").forEach((pair) => {
+                    const [k, v] = pair.split("=").map((s) => s.trim());
+                    if (k && v) {
+                        // Remove quotes from table values
+                        value[k] = v.replace(/^["']|["']$/g, "");
+                    }
+                });
+            }
+            result[currentSection][key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Stringify TOML (simplified stringifier for Codex config)
+ *
+ * Converts a JavaScript object back to TOML format. Handles:
+ * - Sections: [section.name]
+ * - Strings: key = "value"
+ * - Arrays: key = ["value1", "value2"]
+ * - Inline tables: key = { k1 = "v1", k2 = "v2" }
+ *
+ * This is the inverse of parseToml() and is designed for the Codex config format.
+ *
+ * @param obj - JavaScript object to convert to TOML
+ * @returns TOML-formatted string
+ */
+function stringifyToml(obj) {
+    const lines = [];
+    for (const [section, content] of Object.entries(obj)) {
+        if (typeof content === "object" && content !== null) {
+            // Write section header
+            lines.push(`[${section}]`);
+            // Write key-value pairs in this section
+            for (const [key, value] of Object.entries(content)) {
+                if (typeof value === "string") {
+                    // String value: key = "value"
+                    lines.push(`${key} = "${value}"`);
+                }
+                else if (Array.isArray(value)) {
+                    // Array value: key = ["value1", "value2"]
+                    lines.push(`${key} = [${value.map((v) => `"${v}"`).join(", ")}]`);
+                }
+                else if (typeof value === "object" && value !== null) {
+                    // Inline table: key = { k1 = "v1", k2 = "v2" }
+                    // Used for nested objects like env = { HTTPCAT_PRIVATE_KEY = "0x..." }
+                    const tableEntries = Object.entries(value)
+                        .map(([k, v]) => `${k} = "${String(v)}"`)
+                        .join(", ");
+                    lines.push(`${key} = { ${tableEntries} }`);
+                }
+            }
+            // Add blank line after each section for readability
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Configure Codex CLI (OpenAI)
+ *
+ * Codex CLI supports both CLI commands and TOML file configuration:
+ * 1. CLI: "codex mcp add httpcat -- npx -y httpcat-cli mcp start" (preferred)
+ * 2. File: ~/.codex/config.toml (fallback)
+ *
+ * Configuration format: TOML (not JSON like most other tools)
+ * Section format: [mcp_servers.httpcat] (uses underscores, not camelCase)
+ *
+ * Strategy: Try CLI command first, fall back to TOML file modification.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to ~/.codex/config.toml
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureCodex(configPath) {
+    try {
+        // Try CLI command first (preferred method)
+        if (commandExists("codex")) {
+            try {
+                const isGlobal = isHttpcatGlobal();
+                const command = isGlobal ? "httpcat" : "npx";
+                const args = isGlobal ? "mcp start" : "-y httpcat-cli mcp start";
+                // Execute CLI command to add MCP server
+                execSync(`codex mcp add httpcat -- ${command} ${args}`, { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // CLI command failed - fall back to file-based configuration
+            }
+        }
+        // File-based configuration (TOML format)
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing TOML config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = parseToml(content);
+            }
+            catch {
+                // Invalid TOML - create new config
+                config = {};
+            }
+        }
+        // Ensure mcp_servers section exists (Codex uses underscores, not camelCase)
+        if (!config.mcp_servers) {
+            config.mcp_servers = {};
+        }
+        // Add or update httpcat server configuration
+        const mcpConfig = getMcpServerConfig();
+        // Store in TOML format (mcp_servers.httpcat section)
+        config.mcp_servers.httpcat = {
+            command: mcpConfig.command,
+            args: mcpConfig.args,
+            // No env vars - private key is read from config file
+        };
+        // Write back as TOML
+        fs.writeFileSync(configPath, stringifyToml(config), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure Codex: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure Gemini CLI (Google)
+ *
+ * Gemini CLI uses an extension-based architecture. It supports both:
+ * 1. CLI: "gemini mcp add httpcat --command ... --args ..." (preferred)
+ * 2. Extension file: ~/.gemini/extensions/httpcat/gemini-extension.json (fallback)
+ *
+ * Extension format: JSON file with name, version, and mcpServers object.
+ * This is different from standard MCP config - it's wrapped in an extension structure.
+ *
+ * Strategy: Try CLI command first, fall back to creating extension JSON file.
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param extensionPath - Full path to extension JSON file
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureGemini(extensionPath) {
+    try {
+        // Try CLI command first (preferred method)
+        if (commandExists("gemini")) {
+            try {
+                const isGlobal = isHttpcatGlobal();
+                const command = isGlobal ? "httpcat" : "npx";
+                const args = isGlobal ? "mcp start" : "-y httpcat-cli mcp start";
+                // Execute CLI command to add MCP server
+                execSync(`gemini mcp add httpcat --command "${command}" --args "${args}"`, { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // CLI command failed - fall back to file-based configuration
+            }
+        }
+        // File-based configuration (extension JSON format)
+        // Ensure extension directory exists
+        const extensionDir = path.dirname(extensionPath);
+        fs.mkdirSync(extensionDir, { recursive: true });
+        // Build extension config structure (Gemini-specific format)
+        const mcpConfig = getMcpServerConfig();
+        const extensionConfig = {
+            name: "httpcat",
+            version: "1.0.0",
+            mcpServers: {
+                httpcat: mcpConfig,
+            },
+        };
+        // Add or update extension file
+        fs.writeFileSync(extensionPath, JSON.stringify(extensionConfig, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure Gemini: ${error}`);
+        return false;
+    }
+}
+/**
+ * Check if a command exists in PATH
+ *
+ * Helper function used by configuration functions to check if CLI tools are available.
+ *
+ * @param command - Command name to check (e.g., "codex", "gemini")
+ * @returns true if command exists in PATH, false otherwise
+ */
+function commandExists(command) {
+    try {
+        execSync(`which ${command}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Configure Claude CLI (Anthropic)
+ *
+ * Claude CLI is Anthropic's command-line tool for Claude.
+ * Configuration location: ~/.claude/config.json
+ * Configuration format: Standard MCP JSON format.
+ *
+ * Note: Private key is NOT included - MCP server reads from config file instead.
+ *
+ * @param configPath - Full path to ~/.claude/config.json
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureClaudeCli(configPath) {
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(configPath);
+        fs.mkdirSync(configDir, { recursive: true });
+        // Read existing config or start with empty object
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            try {
+                config = JSON.parse(content);
+            }
+            catch {
+                // Invalid JSON - create new config
+                config = {};
+            }
+        }
+        // Ensure mcpServers object exists
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        // Add or update httpcat server configuration
+        config.mcpServers.httpcat = getMcpServerConfig();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to configure Claude CLI: ${error}`);
+        return false;
+    }
+}
+/**
+ * Configure LLM based on detected LLM info
+ *
+ * Main router function that dispatches to the appropriate configuration function
+ * based on the detected LLM tool. This is called by the wizard after the user
+ * selects which LLM tools to configure.
+ *
+ * Note: Private key is NOT passed - MCP server reads from config file instead.
+ *
+ * @param llm - Detected LLM tool information from detector
+ * @returns true if configuration succeeded, false otherwise
+ */
+export async function configureLLM(llm) {
+    // Route to appropriate configuration function based on LLM ID
+    switch (llm.id) {
+        case "claude-desktop":
+            return await configureClaudeDesktop(llm.configPath);
+        case "claude-cli":
+            return await configureClaudeCli(llm.configPath);
+        case "cursor":
+            return await configureCursor(llm.configPath);
+        case "llm-tools-mcp":
+            return await configureLlmToolsMcp(llm.configPath);
+        case "mcp-use":
+            return await configureMcpUse();
+        case "mcp-client":
+            return await configureMcpClient(llm.configPath);
+        case "codex":
+            return await configureCodex(llm.configPath);
+        case "gemini":
+            return await configureGemini(llm.configPath);
+        default:
+            // Unknown LLM ID - return false
+            return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from JSON-based config file
+ *
+ * @param configPath - Path to JSON config file
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeFromJsonConfig(configPath) {
+    try {
+        if (!fs.existsSync(configPath)) {
+            return true; // Already removed or doesn't exist
+        }
+        const content = fs.readFileSync(configPath, "utf-8");
+        let config = {};
+        try {
+            config = JSON.parse(content);
+        }
+        catch {
+            // Invalid JSON - nothing to remove
+            return true;
+        }
+        // Remove httpcat from mcpServers if it exists
+        if (config.mcpServers && config.mcpServers.httpcat) {
+            delete config.mcpServers.httpcat;
+            // If mcpServers is now empty, remove it
+            if (Object.keys(config.mcpServers).length === 0) {
+                delete config.mcpServers;
+            }
+            // Write back the updated config
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from TOML-based config file (Codex)
+ *
+ * @param configPath - Path to TOML config file
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeFromTomlConfig(configPath) {
+    try {
+        if (!fs.existsSync(configPath)) {
+            return true; // Already removed or doesn't exist
+        }
+        const content = fs.readFileSync(configPath, "utf-8");
+        let config = {};
+        try {
+            config = parseToml(content);
+        }
+        catch {
+            // Invalid TOML - nothing to remove
+            return true;
+        }
+        // Remove httpcat from mcp_servers if it exists
+        if (config.mcp_servers && config.mcp_servers.httpcat) {
+            delete config.mcp_servers.httpcat;
+            // If mcp_servers is now empty, remove it
+            if (Object.keys(config.mcp_servers).length === 0) {
+                delete config.mcp_servers;
+            }
+            // Write back the updated TOML
+            fs.writeFileSync(configPath, stringifyToml(config), "utf-8");
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat extension from Gemini CLI
+ *
+ * @param extensionPath - Path to Gemini extension JSON file
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeGeminiExtension(extensionPath) {
+    try {
+        if (fs.existsSync(extensionPath)) {
+            fs.unlinkSync(extensionPath);
+            // Also try to remove the directory if it's empty
+            const extensionDir = path.dirname(extensionPath);
+            try {
+                const files = fs.readdirSync(extensionDir);
+                if (files.length === 0) {
+                    fs.rmdirSync(extensionDir);
+                }
+            }
+            catch {
+                // Ignore errors removing directory
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from MCP-Use CLI (try CLI first, fallback to file)
+ *
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeFromMcpUse() {
+    try {
+        // Try CLI command first
+        if (commandExists("mcp-use")) {
+            try {
+                execSync("mcp-use server remove httpcat", { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // CLI failed, try file-based removal
+            }
+        }
+        // Fallback to file-based removal
+        const configPath = path.join(process.env.HOME || "", ".mcp-use", "config.json");
+        return removeFromJsonConfig(configPath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from Codex CLI (try CLI first, fallback to file)
+ *
+ * @param configPath - Path to Codex TOML config file
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeFromCodex(configPath) {
+    try {
+        // Try CLI command first
+        if (commandExists("codex")) {
+            try {
+                execSync("codex mcp remove httpcat", { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // CLI failed, try file-based removal
+            }
+        }
+        // Fallback to file-based removal
+        return removeFromTomlConfig(configPath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from Gemini CLI (try CLI first, fallback to file)
+ *
+ * @param extensionPath - Path to Gemini extension JSON file
+ * @returns true if removal succeeded, false otherwise
+ */
+function removeFromGemini(extensionPath) {
+    try {
+        // Try CLI command first
+        if (commandExists("gemini")) {
+            try {
+                execSync("gemini mcp remove httpcat", { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // CLI failed, try file-based removal
+            }
+        }
+        // Fallback to file-based removal
+        return removeGeminiExtension(extensionPath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Remove httpcat MCP server from a specific LLM tool
+ *
+ * @param llm - Detected LLM tool information
+ * @returns true if removal succeeded, false otherwise
+ */
+export async function removeMcpFromLLM(llm) {
+    switch (llm.id) {
+        case "claude-desktop":
+        case "cursor":
+        case "llm-tools-mcp":
+        case "mcp-client":
+            return removeFromJsonConfig(llm.configPath);
+        case "mcp-use":
+            return removeFromMcpUse();
+        case "codex":
+            return removeFromCodex(llm.configPath);
+        case "gemini":
+            return removeFromGemini(llm.configPath);
+        default:
+            return false;
+    }
+}
+/**
+ * Get platform-specific Claude Desktop config path
+ *
+ * @returns Platform-appropriate config file path
+ */
+function getClaudeDesktopConfigPath() {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        return path.join(process.env.HOME || "", "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    else if (platform === "win32") {
+        return path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+    }
+    else {
+        return path.join(process.env.HOME || "", ".config", "Claude", "claude_desktop_config.json");
+    }
+}
+/**
+ * Remove httpcat MCP configurations from all detected LLM tools
+ *
+ * This function scans for all LLM tools that have httpcat MCP configured
+ * and removes the httpcat server from their configurations.
+ * It also checks known config paths directly to ensure cleanup even if
+ * tools weren't detected.
+ *
+ * @returns Array of results showing which tools were cleaned up
+ */
+export async function removeAllMcpConfigurations() {
+    const { detectInstalledLlms } = await import("./llm-cli-detector.js");
+    const detectedLlms = await detectInstalledLlms();
+    const results = [];
+    // Remove from each detected LLM tool
+    for (const llm of detectedLlms) {
+        try {
+            const success = await removeMcpFromLLM(llm);
+            results.push({
+                name: llm.name,
+                success,
+            });
+        }
+        catch (error) {
+            results.push({
+                name: llm.name,
+                success: false,
+            });
+        }
+    }
+    // Also check known config paths directly (in case they weren't detected)
+    // This ensures we clean up even if detection missed them
+    const knownConfigs = [
+        {
+            name: "Claude Desktop",
+            path: getClaudeDesktopConfigPath(),
+            type: "json",
+        },
+        {
+            name: "Cursor IDE",
+            path: path.join(process.env.HOME || "", ".cursor", "mcp.json"),
+            type: "json",
+        },
+        {
+            name: "LLM Tools MCP",
+            path: path.join(process.env.HOME || "", ".llm-tools-mcp", "mcp.json"),
+            type: "json",
+        },
+        {
+            name: "MCP Client",
+            path: path.join(process.env.HOME || "", ".llm", "config.json"),
+            type: "json",
+        },
+        {
+            name: "MCP-Use",
+            path: path.join(process.env.HOME || "", ".mcp-use", "config.json"),
+            type: "json",
+        },
+        {
+            name: "Codex CLI",
+            path: path.join(process.env.HOME || "", ".codex", "config.toml"),
+            type: "toml",
+        },
+        {
+            name: "Gemini CLI",
+            path: path.join(process.env.HOME || "", ".gemini", "extensions", "httpcat", "gemini-extension.json"),
+            type: "extension",
+        },
+    ];
+    // Check each known config path and clean up if it exists
+    for (const knownConfig of knownConfigs) {
+        // Skip if we already processed it via detection
+        const alreadyProcessed = detectedLlms.some((llm) => llm.configPath === knownConfig.path);
+        if (!alreadyProcessed && fs.existsSync(knownConfig.path)) {
+            try {
+                let success = false;
+                if (knownConfig.type === "json") {
+                    success = removeFromJsonConfig(knownConfig.path);
+                }
+                else if (knownConfig.type === "toml") {
+                    success = removeFromTomlConfig(knownConfig.path);
+                }
+                else if (knownConfig.type === "extension") {
+                    success = removeGeminiExtension(knownConfig.path);
+                }
+                results.push({
+                    name: knownConfig.name,
+                    success,
+                });
+            }
+            catch (error) {
+                results.push({
+                    name: knownConfig.name,
+                    success: false,
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Remove the base httpcat MCP config file
+ *
+ * Removes ~/.config/httpcat/mcp.json if it exists.
+ *
+ * @returns true if removal succeeded or file doesn't exist, false on error
+ */
+export function removeBaseMcpConfig() {
+    try {
+        const mcpConfigPath = path.join(process.env.HOME || "", ".config", "httpcat", "mcp.json");
+        if (fs.existsSync(mcpConfigPath)) {
+            fs.unlinkSync(mcpConfigPath);
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+//# sourceMappingURL=llm-cli-config.js.map