@insforge/install 0.0.50 → 0.0.52

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -1,33 +1,22 @@
 #!/usr/bin/env node
-import {
-    clientNames,
-    logger,
-    readConfig,
-    writeConfig
-  } from "./utils.js";
-  import { execSync } from 'child_process';
-  import os from 'os';
-  import path from 'path';
-
-  import yargs from "yargs";
-  import { hideBin } from "yargs/helpers";
-
-  import pc from "picocolors";
-  import select from "@inquirer/select";
-  var { green, red, yellow, cyan } = pc;
-
-  // Section header helper
-  const LINE = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
-  function printHeader(text) {
+import { clientNames, logger, readConfig, writeConfig } from "./utils.js";
+import { execSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import pc from "picocolors";
+import select from "@inquirer/select";
+const { green, red, yellow, cyan } = pc;
+const LINE = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
+function printHeader(text) {
     console.log();
     console.log(LINE);
     console.log(`  ${text}`);
     console.log(LINE);
     console.log();
-  }
-
-  // ASCII art logo for InsForge
-  const INSFORGE_LOGO = `
+}
+const INSFORGE_LOGO = `
 ██╗███╗   ██╗███████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗
 ██║████╗  ██║██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
 ██║██╔██╗ ██║███████╗█████╗  ██║   ██║██████╔╝██║  ███╗█████╗
@@ -35,9 +24,7 @@ import {
 ██║██║ ╚████║███████║██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
 ╚═╝╚═╝  ╚═══╝╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝
 `;
-
-  // Map client names to display names for better UX
-  const clientDisplayNames = {
+const clientDisplayNames = {
     "claude-code": "Claude Code",
     "cursor": "Cursor",
     "windsurf": "Windsurf",
@@ -48,10 +35,10 @@ import {
     "copilot": "GitHub Copilot",
     "qoder": "Qoder",
     "antigravity": "Antigravity",
-    "kiro": "Kiro"
-  };
-
-  function printPostInstallMessage(clientName) {
+    "kiro": "Kiro",
+    "opencode": "OpenCode"
+};
+function printPostInstallMessage(clientName) {
     const displayName = clientDisplayNames[clientName] || clientName;
     console.log(INSFORGE_LOGO);
     console.log(green(`✓ InsForge MCP is now configured for ${cyan(displayName)}!`));
@@ -71,305 +58,301 @@ import {
     console.log('  💬 Discord: https://discord.com/invite/MPxwj5xVvW');
     console.log('  ⭐ GitHub: https://github.com/insforge/insforge');
     console.log();
-  }
-  function builder(yargs2) {
-    return yargs2.option("client", {
-      type: "string",
-      description: "Client to use for installation",
-      demandOption: false,
-      choices: clientNames
+}
+function builder(y) {
+    return y.option("client", {
+        type: "string",
+        description: "Client to use for installation",
+        demandOption: false,
+        choices: clientNames
     }).option("env", {
-      type: "string",
-      description: "Environment variables as key=value pairs (can be used multiple times). API_KEY is required.",
-      array: true
+        type: "string",
+        description: "Environment variables as key=value pairs (can be used multiple times). API_KEY is required.",
+        array: true
     }).option("dev", {
-      type: "boolean",
-      description: "Install dev version (@insforge/mcp@dev) instead of latest",
-      default: false
+        type: "boolean",
+        description: "Install dev version (@insforge/mcp@dev) instead of latest",
+        default: false
     });
-  }
-
-  async function handler(argv) {
+}
+async function handler(argv) {
     let selectedClient = argv.client;
-
-    // If no client specified, show interactive selection
     if (!selectedClient) {
-      console.log();
-      console.log(LINE);
-      console.log(`  ${cyan('InsForge MCP Installer')}`);
-      console.log(LINE);
-      console.log();
-
-      selectedClient = await select({
-        message: 'Select your AI coding client:',
-        choices: clientNames.map(name => ({
-          name: clientDisplayNames[name] || name,
-          value: name
-        }))
-      });
+        console.log();
+        console.log(LINE);
+        console.log(`  ${cyan('InsForge MCP Installer')}`);
+        console.log(LINE);
+        console.log();
+        selectedClient = await select({
+            message: 'Select your coding agent:',
+            pageSize: 15,
+            loop: false,
+            choices: clientNames.map(name => ({
+                name: clientDisplayNames[name] || name,
+                value: name
+            }))
+        });
     }
-
-    // Validate client
     if (!clientNames.includes(selectedClient)) {
-      logger.error(`Invalid client: ${selectedClient}. Available clients: ${clientNames.join(", ")}`);
-      return;
+        logger.error(`Invalid client: ${selectedClient}. Available clients: ${clientNames.join(", ")}`);
+        return;
     }
-
-    // Update argv.client with selected value for downstream use
     argv.client = selectedClient;
     const envVars = {};
     if (argv.env && argv.env.length > 0) {
-      for (const envVar of argv.env) {
-        const [key, ...valueParts] = envVar.split("=");
-        if (key && valueParts.length > 0) {
-          envVars[key] = valueParts.join("=");
-        } else {
-          logger.warn(`Invalid environment variable format: ${envVar}. Expected KEY=VALUE format.`);
+        for (const envVar of argv.env) {
+            const [key, ...valueParts] = envVar.split("=");
+            if (key && valueParts.length > 0) {
+                envVars[key] = valueParts.join("=");
+            }
+            else {
+                logger.warn(`Invalid environment variable format: ${envVar}. Expected KEY=VALUE format.`);
+            }
         }
-      }
     }
     if (!envVars.API_KEY) {
-      logger.error("API_KEY environment variable is required. Use --env API_KEY=your_key");
-      return;
+        logger.error("API_KEY environment variable is required. Use --env API_KEY=your_key");
+        return;
     }
-    // Add default base URL if not provided
     if (!envVars.API_BASE_URL) {
-      envVars.API_BASE_URL = "http://localhost:7130";
+        envVars.API_BASE_URL = "http://localhost:7130";
     }
     const name = "insforge";
     const mcpVersion = argv.dev ? "@insforge/mcp@dev" : "@insforge/mcp@latest";
     try {
-      printHeader('InsForge MCP Installer');
-      logger.info(`Setting up MCP for ${cyan(argv.client)}...`);
-
-      printHeader(`Configuring ${argv.client}`);
-      const config = readConfig(argv.client);
-
-        // Handle different config structures for different clients
+        printHeader('InsForge MCP Installer');
+        logger.info(`Setting up MCP for ${cyan(argv.client)}...`);
+        printHeader(`Configuring ${argv.client}`);
+        const config = readConfig(argv.client);
         if (argv.client === "claude-code") {
-          // Claude Code uses mcpServers at root level
-          if (!config.mcpServers) config.mcpServers = {};
-          const isWindows = process.platform === 'win32';
-          config.mcpServers[name] = isWindows ? {
-            command: "cmd",
-            args: ["/c", "npx", "-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            const isWindows = process.platform === 'win32';
+            config.mcpServers[name] = isWindows ? {
+                command: "cmd",
+                args: ["/c", "npx", "-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            } : {
+                command: "npx",
+                args: ["-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            writeConfig(config, argv.client);
+            const fs = await import('fs');
+            const claudeDir = path.join(process.cwd(), '.claude');
+            const settingsPath = path.join(claudeDir, 'settings.local.json');
+            if (!fs.existsSync(claudeDir)) {
+                fs.mkdirSync(claudeDir, { recursive: true });
             }
-          } : {
-            command: "npx",
-            args: ["-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+            let settings = {};
+            if (fs.existsSync(settingsPath)) {
+                try {
+                    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+                }
+                catch (error) {
+                    logger.warn(`Could not parse existing settings.local.json: ${error.message}`);
+                }
             }
-          };
-          writeConfig(config, argv.client);
-
-          // Create or update .claude/settings.local.json with enableAllProjectMcpServers
-          const fs = await import('fs');
-          const claudeDir = path.join(process.cwd(), '.claude');
-          const settingsPath = path.join(claudeDir, 'settings.local.json');
-
-          if (!fs.existsSync(claudeDir)) {
-            fs.mkdirSync(claudeDir, { recursive: true });
-          }
-
-          let settings = {};
-          if (fs.existsSync(settingsPath)) {
-            try {
-              settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-            } catch (error) {
-              logger.warn(`Could not parse existing settings.local.json: ${error.message}`);
+            if (!settings.enabledMcpjsonServers) {
+                settings.enabledMcpjsonServers = [];
             }
-          }
-
-          // Add "insforge" to enabledMcpjsonServers if not already present
-          if (!settings.enabledMcpjsonServers) {
-            settings.enabledMcpjsonServers = [];
-          }
-          if (!settings.enabledMcpjsonServers.includes("insforge")) {
-            settings.enabledMcpjsonServers.push("insforge");
-          }
-
-          // Remove "insforge" from disabledMcpjsonServers if present
-          if (settings.disabledMcpjsonServers && Array.isArray(settings.disabledMcpjsonServers)) {
-            settings.disabledMcpjsonServers = settings.disabledMcpjsonServers.filter(
-              (server) => server !== "insforge"
-            );
-          }
-
-          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-          logger.info("Added \"insforge\" to enabledMcpjsonServers in .claude/settings.local.json");
-        } else if (argv.client === "codex") {
-          // Use Codex CLI for Codex
-          const homeDir = os.homedir();
-          const isWindows = process.platform === 'win32';
-          const codexPath = isWindows
-            ? path.join(homeDir, 'AppData', 'Roaming', 'npm', 'codex.cmd')
-            : 'codex';
-
-          const envArgs = Object.entries(envVars)
-            .filter(([key]) => key !== 'CLIENT_NAME')
-            .map(([key, value]) => `--env ${key}=${value}`)
-            .join(' ');
-
-          try {
-            // First try to remove existing insforge MCP if it exists
+            if (!settings.enabledMcpjsonServers.includes("insforge")) {
+                settings.enabledMcpjsonServers.push("insforge");
+            }
+            if (settings.disabledMcpjsonServers && Array.isArray(settings.disabledMcpjsonServers)) {
+                settings.disabledMcpjsonServers = settings.disabledMcpjsonServers.filter((server) => server !== "insforge");
+            }
+            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            logger.info("Added \"insforge\" to enabledMcpjsonServers in .claude/settings.local.json");
+        }
+        else if (argv.client === "codex") {
+            const homeDir = os.homedir();
+            const isWindows = process.platform === 'win32';
+            const codexPath = isWindows
+                ? path.join(homeDir, 'AppData', 'Roaming', 'npm', 'codex.cmd')
+                : 'codex';
+            const envArgs = Object.entries(envVars)
+                .filter(([key]) => key !== 'CLIENT_NAME')
+                .map(([key, value]) => `--env ${key}=${value}`)
+                .join(' ');
             try {
-              const removeCmd = isWindows ? `"${codexPath}" mcp remove ${name}` : `codex mcp remove ${name}`;
-              execSync(removeCmd, {
-                stdio: 'pipe',
-                shell: true
-              });
-              logger.info("Removed existing insforge MCP installation.");
-            } catch (removeError) {
-              // It's okay if remove fails - the MCP might not exist
-              logger.info("No existing insforge MCP found");
+                try {
+                    const removeCmd = isWindows ? `"${codexPath}" mcp remove ${name}` : `codex mcp remove ${name}`;
+                    execSync(removeCmd, { stdio: 'pipe' });
+                    logger.info("Removed existing insforge MCP installation.");
+                }
+                catch {
+                    logger.info("No existing insforge MCP found");
+                }
+                const command = isWindows
+                    ? `"${codexPath}" mcp add ${name} ${envArgs} -- npx -y ${mcpVersion}`
+                    : `codex mcp add ${name} ${envArgs} -- npx -y ${mcpVersion}`;
+                logger.info(`Adding insforge MCP server (${mcpVersion})...`);
+                execSync(command, { stdio: 'inherit' });
             }
-
-            // Now add the MCP server using codex CLI with --env flags
-            const command = isWindows
-              ? `"${codexPath}" mcp add ${name} ${envArgs} -- npx -y ${mcpVersion}`
-              : `codex mcp add ${name} ${envArgs} -- npx -y ${mcpVersion}`;
-            logger.info(`Adding insforge MCP server (${mcpVersion})...`);
-            execSync(command, {
-              stdio: 'inherit',
-              shell: true
-            });
-          } catch (error) {
-            throw new Error(`Failed to add MCP server via Codex CLI: ${error.message}`);
-          }
-        } else if (argv.client === "cursor") {
-          // Cursor uses mcpServers at root level
-          if (!config.mcpServers) config.mcpServers = {};
-          config.mcpServers[name] = {
-            command: "npx",
-            args: ["-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+            catch (error) {
+                throw new Error(`Failed to add MCP server via Codex CLI: ${error.message}`);
             }
-          };
-          writeConfig(config, argv.client);
-        } else if (argv.client === "windsurf") {
-          if (!config.mcpServers) config.mcpServers = {};
-          config.mcpServers[name] = {
-            command: "npx",
-            args: ["-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+        }
+        else if (argv.client === "cursor") {
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            config.mcpServers[name] = {
+                command: "npx",
+                args: ["-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            writeConfig(config, argv.client);
+        }
+        else if (argv.client === "windsurf") {
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            config.mcpServers[name] = {
+                command: "npx",
+                args: ["-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            writeConfig(config, argv.client);
+        }
+        else if (argv.client === "cline" || argv.client === "roocode" || argv.client === "trae" || argv.client === "qoder" || argv.client === "kiro") {
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            config.mcpServers[name] = {
+                command: "npx",
+                args: ["-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            writeConfig(config, argv.client);
+        }
+        else if (argv.client === "copilot") {
+            const fs = await import('fs');
+            const vscodeDir = path.join(process.cwd(), '.vscode');
+            const mcpConfigPath = path.join(vscodeDir, 'mcp.json');
+            if (!fs.existsSync(vscodeDir)) {
+                fs.mkdirSync(vscodeDir, { recursive: true });
             }
-          };
-          writeConfig(config, argv.client);
-        } else if (argv.client === "cline" || argv.client === "roocode" || argv.client === "trae" || argv.client === "qoder" || argv.client === "kiro") {
-          if (!config.mcpServers) config.mcpServers = {};
-          config.mcpServers[name] = {
-            command: "npx",
-            args: ["-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+            let copilotConfig = { servers: {} };
+            if (fs.existsSync(mcpConfigPath)) {
+                try {
+                    copilotConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+                    if (!copilotConfig.servers)
+                        copilotConfig.servers = {};
+                }
+                catch (error) {
+                    logger.warn(`Could not parse existing mcp.json: ${error.message}`);
+                    copilotConfig = { servers: {} };
+                }
             }
-          };
-          writeConfig(config, argv.client);
-      } else if (argv.client === "copilot") {
-          // Copilot uses "servers" instead of "mcpServers"
-          const fs = await import('fs');
-          const vscodeDir = path.join(process.cwd(), '.vscode');
-          const mcpConfigPath = path.join(vscodeDir, 'mcp.json');
-
-          if (!fs.existsSync(vscodeDir)) {
-            fs.mkdirSync(vscodeDir, { recursive: true });
-          }
-
-          let copilotConfig = { servers: {} };
-          if (fs.existsSync(mcpConfigPath)) {
-            try {
-              copilotConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
-              if (!copilotConfig.servers) copilotConfig.servers = {};
-            } catch (error) {
-              logger.warn(`Could not parse existing mcp.json: ${error.message}`);
-              copilotConfig = { servers: {} };
+            copilotConfig.servers[name] = {
+                command: "npx",
+                args: ["-y", mcpVersion],
+                env: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            fs.writeFileSync(mcpConfigPath, JSON.stringify(copilotConfig, null, 2));
+            logger.info(`Configured Copilot MCP at: ${mcpConfigPath}`);
+        }
+        else if (argv.client === "antigravity") {
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            config.mcpServers[name] = {
+                command: "npx",
+                args: [
+                    "-y",
+                    mcpVersion,
+                    "--api_key",
+                    envVars.API_KEY,
+                    "--api_base_url",
+                    envVars.API_BASE_URL
+                ],
+                env: {}
+            };
+            writeConfig(config, argv.client);
+        }
+        else if (argv.client === "opencode") {
+            const fs = await import('fs');
+            const opencodeConfigPath = path.join(process.cwd(), 'opencode.json');
+            let opencodeConfig = {};
+            if (fs.existsSync(opencodeConfigPath)) {
+                try {
+                    opencodeConfig = JSON.parse(fs.readFileSync(opencodeConfigPath, 'utf8'));
+                }
+                catch (error) {
+                    logger.warn(`Could not parse existing opencode.json: ${error.message}`);
+                    opencodeConfig = {};
+                }
             }
-          }
-
-          copilotConfig.servers[name] = {
-            command: "npx",
-            args: ["-y", mcpVersion],
-            env: {
-              API_KEY: envVars.API_KEY,
-              API_BASE_URL: envVars.API_BASE_URL
+            if (!opencodeConfig.mcp)
+                opencodeConfig.mcp = {};
+            opencodeConfig.mcp[name] = {
+                type: "local",
+                command: ["npx", "-y", mcpVersion],
+                environment: {
+                    API_KEY: envVars.API_KEY,
+                    API_BASE_URL: envVars.API_BASE_URL
+                }
+            };
+            fs.writeFileSync(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
+            logger.info(`Configured OpenCode MCP at: ${opencodeConfigPath}`);
+        }
+        // Fetch instructions documentation and save to appropriate files
+        let instructionsContent = null;
+        try {
+            const fetch = (await import('node-fetch')).default;
+            const apiBaseUrl = envVars.API_BASE_URL || "http://localhost:7130";
+            const response = await fetch(`${apiBaseUrl}/api/docs/instructions`);
+            if (response.ok) {
+                const result = await response.json();
+                if (result && result.content) {
+                    instructionsContent = result.content;
+                }
             }
-          };
-
-          fs.writeFileSync(mcpConfigPath, JSON.stringify(copilotConfig, null, 2));
-          logger.info(`Configured Copilot MCP at: ${mcpConfigPath}`);
-      } else if (argv.client === "antigravity") {
-          // Antigravity uses args instead of env vars
-          if (!config.mcpServers) config.mcpServers = {};
-          config.mcpServers[name] = {
-            command: "npx",
-            args: [
-              "-y",
-              mcpVersion,
-              "--api_key",
-              envVars.API_KEY,
-              "--api_base_url",
-              envVars.API_BASE_URL
-            ],
-            env: {}
-          };
-          writeConfig(config, argv.client);
-      }
-
-      // Fetch instructions documentation and save to appropriate files
-      let instructionsContent = null;
-      try {
-        const fetch = (await import('node-fetch')).default;
-        const fs = await import('fs');
-        const apiBaseUrl = envVars.API_BASE_URL || "http://localhost:7130";
-        const response = await fetch(`${apiBaseUrl}/api/docs/instructions`);
-
-        if (response.ok) {
-          const result = await response.json();
-          if (result && result.content) {
-            instructionsContent = result.content;
-          }
         }
-      } catch (fetchError) {
-        logger.warn(`Could not download instructions: ${fetchError.message}`);
-      }
-
-      // Save instructions to agent.md for all clients
-      if (instructionsContent) {
-        const fs = await import('fs');
-        const frontmatter = `---
+        catch (fetchError) {
+            logger.warn(`Could not download instructions: ${fetchError.message}`);
+        }
+        if (instructionsContent) {
+            const fs = await import('fs');
+            const frontmatter = `---
 description: Instructions building apps with MCP
 globs: *
 alwaysApply: true
 ---
 
 `;
-        const contentWithFrontmatter = frontmatter + instructionsContent;
-        const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
-        fs.writeFileSync(agentsMdPath, contentWithFrontmatter, 'utf-8');
-        logger.info(`Saved instructions to: ${agentsMdPath}`);
-      }
-
-      printHeader('Setup Complete!');
-      printPostInstallMessage(argv.client);
-    } catch (e) {
-      logger.error(red(e.message));
+            const contentWithFrontmatter = frontmatter + instructionsContent;
+            const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
+            fs.writeFileSync(agentsMdPath, contentWithFrontmatter, 'utf-8');
+            logger.info(`Saved instructions to: ${agentsMdPath}`);
+        }
+        printHeader('Setup Complete!');
+        printPostInstallMessage(argv.client);
+    }
+    catch (e) {
+        logger.error(red(e.message));
     }
-  }
-  
-  var parser = yargs(hideBin(process.argv)).scriptName("@insforge/install").command("install", "Install Insforge MCP server", builder, handler).help().alias("h", "help").version().alias("v", "version");
-  if (!process.argv.slice(2).length || process.argv[2].startsWith("--")) {
+}
+const parser = yargs(hideBin(process.argv)).scriptName("@insforge/install").command("install", "Install Insforge MCP server", builder, handler).help().alias("h", "help").version().alias("v", "version");
+if (!process.argv.slice(2).length || process.argv[2].startsWith("--")) {
     parser.parse(["install", ...process.argv.slice(2)]);
-  } else {
+}
+else {
     parser.parse();
-  }
-  
+}

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+interface McpConfig {
+    mcpServers?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare const logger: import("consola").ConsolaInstance;
+export declare const clientNames: string[];
+export declare function readConfig(client: string, local?: boolean): McpConfig;
+export declare function writeConfig(config: McpConfig, client: string, local?: boolean): void;
+export {};

package/dist/utils.js

@@ -1,158 +1,147 @@
-// src/client-config.ts
 import fs from "fs";
 import os from "os";
 import path from "path";
 import process from "process";
-
-// src/logger.ts
 import { createConsola } from "consola";
-var logger = createConsola({});
-var verbose = (msg) => logger.verbose(msg);
-
-// src/client-config.ts
-var homeDir = os.homedir();
-var platformPaths = {
-  win32: {
-    baseDir: process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
-    vscodePath: path.join("Code", "User", "globalStorage")
-  },
-  darwin: {
-    baseDir: path.join(homeDir, "Library", "Application Support"),
-    vscodePath: path.join("Code", "User", "globalStorage")
-  },
-  linux: {
-    baseDir: process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"),
-    vscodePath: path.join("Code/User/globalStorage")
-  }
+export const logger = createConsola({});
+const verbose = (msg) => logger.verbose(msg);
+const homeDir = os.homedir();
+const platformPaths = {
+    win32: {
+        baseDir: process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+        vscodePath: path.join("Code", "User", "globalStorage")
+    },
+    darwin: {
+        baseDir: path.join(homeDir, "Library", "Application Support"),
+        vscodePath: path.join("Code", "User", "globalStorage")
+    },
+    linux: {
+        baseDir: process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"),
+        vscodePath: path.join("Code/User/globalStorage")
+    }
 };
-var platform = process.platform;
-var { baseDir, vscodePath } = platformPaths[platform];
-var clientPaths = {
-  "claude-code": {
-    type: "file",
-    path: path.join(process.cwd(), ".mcp.json")
-  },
-  cursor: {
-    type: "file",
-    path: path.join(homeDir, ".cursor", "mcp.json"),
-    localPath: path.join(process.cwd(), ".cursor", "mcp.json")
-  },
-  windsurf: {
-    type: "file",
-    path: path.join(homeDir, ".codeium", "windsurf", "mcp_config.json")
-  },
-  cline: {
-    type: "file",
-    path: path.join(baseDir, vscodePath, "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
-  },
-  roocode: {
-    type: "file",
-    path: path.join(baseDir, vscodePath, "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json")
-  },
-  trae: {
-    type: "file",
-    path: path.join(baseDir, "Trae", "User", "mcp.json")
-  },
-  codex: {
-    type: "file",
-    path: path.join(homeDir, ".codex", "mcp_config.json")
-  },
-  copilot: {
-    type: "file",
-    path: path.join(process.cwd(), ".vscode", "mcp.json")
-  },
-  qoder: {
-    type: "file",
-    path: path.join(baseDir, "Qoder", "SharedClientCache", "mcp.json")
-  },
-  antigravity: {
-    type: "file",
-    path: path.join(homeDir, ".gemini", "antigravity", "mcp_config.json")
-  },
-  kiro: {
-    type: "file",
-    path: path.join(homeDir, ".kiro", "settings", "mcp.json")
-  }
+const platform = process.platform;
+const { baseDir, vscodePath } = platformPaths[platform] ?? platformPaths.linux;
+const clientPaths = {
+    cursor: {
+        type: "file",
+        path: path.join(homeDir, ".cursor", "mcp.json"),
+        localPath: path.join(process.cwd(), ".cursor", "mcp.json")
+    },
+    "claude-code": {
+        type: "file",
+        path: path.join(process.cwd(), ".mcp.json")
+    },
+    windsurf: {
+        type: "file",
+        path: path.join(homeDir, ".codeium", "windsurf", "mcp_config.json")
+    },
+    cline: {
+        type: "file",
+        path: path.join(baseDir, vscodePath, "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    },
+    roocode: {
+        type: "file",
+        path: path.join(baseDir, vscodePath, "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json")
+    },
+    trae: {
+        type: "file",
+        path: path.join(baseDir, "Trae", "User", "mcp.json")
+    },
+    codex: {
+        type: "file",
+        path: path.join(homeDir, ".codex", "mcp_config.json")
+    },
+    copilot: {
+        type: "file",
+        path: path.join(process.cwd(), ".vscode", "mcp.json")
+    },
+    qoder: {
+        type: "file",
+        path: path.join(baseDir, "Qoder", "SharedClientCache", "mcp.json")
+    },
+    antigravity: {
+        type: "file",
+        path: path.join(homeDir, ".gemini", "antigravity", "mcp_config.json")
+    },
+    kiro: {
+        type: "file",
+        path: path.join(homeDir, ".kiro", "settings", "mcp.json")
+    },
+    opencode: {
+        type: "file",
+        path: path.join(process.cwd(), "opencode.json")
+    }
 };
-var clientNames = Object.keys(clientPaths);
+export const clientNames = Object.keys(clientPaths);
 function getConfigPath(client, local) {
-  const normalizedClient = client?.toLowerCase() || "claude-code";
-  verbose(`Getting config path for client: ${normalizedClient}${local ? " (local)" : ""}`);
-  const configTarget = clientPaths[normalizedClient];
-  if (!configTarget) {
-    throw new Error(`Unsupported client: ${client}. Supported clients: ${clientNames.join(", ")}`);
-  }
-  if (local && configTarget.localPath) {
-    verbose(`Using local config path for ${normalizedClient}: ${configTarget.localPath}`);
-    return { ...configTarget, path: configTarget.localPath };
-  }
-  verbose(`Using default config path for ${normalizedClient}: ${configTarget.path}`);
-  return configTarget;
+    const normalizedClient = client?.toLowerCase() || "claude-code";
+    verbose(`Getting config path for client: ${normalizedClient}${local ? " (local)" : ""}`);
+    const configTarget = clientPaths[normalizedClient];
+    if (!configTarget) {
+        throw new Error(`Unsupported client: ${client}. Supported clients: ${clientNames.join(", ")}`);
+    }
+    if (local && configTarget.localPath) {
+        verbose(`Using local config path for ${normalizedClient}: ${configTarget.localPath}`);
+        return { ...configTarget, path: configTarget.localPath };
+    }
+    verbose(`Using default config path for ${normalizedClient}: ${configTarget.path}`);
+    return configTarget;
 }
-function readConfig(client, local) {
-  verbose(`Reading config for client: ${client}${local ? " (local)" : ""}`);
-  try {
-    const configPath = getConfigPath(client, local);
-    verbose(`Checking if config file exists at: ${configPath.path}`);
-    if (!fs.existsSync(configPath.path)) {
-      verbose("Config file not found, returning default empty config");
-      // Return appropriate default structure for each client
-      return { mcpServers: {} };
+export function readConfig(client, local) {
+    verbose(`Reading config for client: ${client}${local ? " (local)" : ""}`);
+    try {
+        const configPath = getConfigPath(client, local);
+        verbose(`Checking if config file exists at: ${configPath.path}`);
+        if (!fs.existsSync(configPath.path)) {
+            verbose("Config file not found, returning default empty config");
+            return { mcpServers: {} };
+        }
+        verbose("Reading config file content");
+        const rawConfig = JSON.parse(fs.readFileSync(configPath.path, "utf8"));
+        verbose(`Config loaded successfully: ${JSON.stringify(rawConfig, null, 2)}`);
+        return rawConfig;
+    }
+    catch (error) {
+        verbose(`Error reading config: ${error instanceof Error ? error.stack : JSON.stringify(error)}`);
+        return { mcpServers: {} };
     }
-    verbose("Reading config file content");
-    const rawConfig = JSON.parse(fs.readFileSync(configPath.path, "utf8"));
-    verbose(`Config loaded successfully: ${JSON.stringify(rawConfig, null, 2)}`);
-    // Return the raw config to preserve existing structure
-    return rawConfig;
-  } catch (error) {
-    verbose(`Error reading config: ${error instanceof Error ? error.stack : JSON.stringify(error)}`);
-    return { mcpServers: {} };
-  }
 }
-function writeConfig(config, client, local) {
-  verbose(`Writing config for client: ${client || "default"}${local ? " (local)" : ""}`);
-  verbose(`Config data: ${JSON.stringify(config, null, 2)}`);
-  
-  // All clients use mcpServers
-  if (!config.mcpServers || typeof config.mcpServers !== "object") {
-    verbose("Invalid mcpServers structure in config");
-    throw new Error("Invalid mcpServers structure");
-  }
-  
-  const configPath = getConfigPath(client, local);
-  writeConfigFile(config, configPath);
+export function writeConfig(config, client, local) {
+    verbose(`Writing config for client: ${client || "default"}${local ? " (local)" : ""}`);
+    verbose(`Config data: ${JSON.stringify(config, null, 2)}`);
+    if (!config.mcpServers || typeof config.mcpServers !== "object") {
+        verbose("Invalid mcpServers structure in config");
+        throw new Error("Invalid mcpServers structure");
+    }
+    const configPath = getConfigPath(client, local);
+    writeConfigFile(config, configPath);
 }
 function writeConfigFile(config, target) {
-  const configDir = path.dirname(target.path);
-  verbose(`Ensuring config directory exists: ${configDir}`);
-  if (!fs.existsSync(configDir)) {
-    verbose(`Creating directory: ${configDir}`);
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-  let existingConfig = { mcpServers: {} };
-  try {
-    if (fs.existsSync(target.path)) {
-      verbose("Reading existing config file for merging");
-      existingConfig = JSON.parse(fs.readFileSync(target.path, "utf8"));
-      verbose(`Existing config loaded: ${JSON.stringify(existingConfig, null, 2)}`);
+    const configDir = path.dirname(target.path);
+    verbose(`Ensuring config directory exists: ${configDir}`);
+    if (!fs.existsSync(configDir)) {
+        verbose(`Creating directory: ${configDir}`);
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    let existingConfig = { mcpServers: {} };
+    try {
+        if (fs.existsSync(target.path)) {
+            verbose("Reading existing config file for merging");
+            existingConfig = JSON.parse(fs.readFileSync(target.path, "utf8"));
+            verbose(`Existing config loaded: ${JSON.stringify(existingConfig, null, 2)}`);
+        }
     }
-  } catch (error) {
-    verbose(`Error reading existing config for merge: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  verbose("Merging configs");
-  const mergedConfig = {
-    ...existingConfig,
-    ...config
-  };
-  verbose(`Merged config: ${JSON.stringify(mergedConfig, null, 2)}`);
-  verbose(`Writing config to file: ${target.path}`);
-  fs.writeFileSync(target.path, JSON.stringify(mergedConfig, null, 2));
-  verbose("Config successfully written");
+    catch (error) {
+        verbose(`Error reading existing config for merge: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    verbose("Merging configs");
+    const mergedConfig = {
+        ...existingConfig,
+        ...config
+    };
+    verbose(`Merged config: ${JSON.stringify(mergedConfig, null, 2)}`);
+    verbose(`Writing config to file: ${target.path}`);
+    fs.writeFileSync(target.path, JSON.stringify(mergedConfig, null, 2));
+    verbose("Config successfully written");
 }
-export {
-  logger,
-  clientNames,
-  getConfigPath,
-  readConfig,
-  writeConfig
-};

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@insforge/install",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "description": "CLI tool for installing Insforge MCP servers across different AI clients",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "main": "dist/index.js",
   "bin": {
     "insforge-install": "dist/index.js"
   },
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
     "start": "node dist/index.js"
   },
   "dependencies": {
@@ -26,5 +31,10 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.30",
+    "@types/yargs": "^17.0.35",
+    "typescript": "^5.9.3"
   }
 }

package/.claude/settings.local.json

@@ -1,5 +0,0 @@
-{
-  "enabledMcpjsonServers": [
-    "insforge"
-  ]
-}

package/.mcp.json

@@ -1,15 +0,0 @@
-{
-  "mcpServers": {
-    "insforge": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@insforge/mcp@latest"
-      ],
-      "env": {
-        "API_KEY": "test123",
-        "API_BASE_URL": "http://localhost:7130"
-      }
-    }
-  }
-}