@insforge/install 0.0.2

package/README.md

@@ -0,0 +1,49 @@
+# @insforge/install
+
+CLI tool for installing Insforge MCP servers across different AI clients.
+
+## Installation & Usage
+
+```bash
+# Interactive mode (will prompt for API key)
+npx @insforge/install
+
+# Quick install with required API key
+npx @insforge/install --client claude --api-key YOUR_API_KEY
+
+# With custom base URL (API key still required)
+npx @insforge/install --client cursor --api-key YOUR_API_KEY --base-url http://localhost:7130
+
+# Uninstall
+npx @insforge/install uninstall --client claude
+```
+
+## Required Configuration
+
+- **API Key** (required): Your Insforge API key for authentication
+- **Base URL** (optional): Defaults to `http://localhost:7130`
+
+## Supported Clients
+
+- **claude** - Claude Desktop
+- **cursor** - Cursor IDE
+- **windsurf** - Windsurf IDE  
+- **cline** - Cline VS Code Extension
+- **roocode** - Roo-Code VS Code Extension (Cline fork)
+
+## Options
+
+```
+--client <client>     Target AI client
+--api-key <key>       Insforge API key
+--base-url <url>      Insforge base URL (default: http://localhost:7130)
+--force               Overwrite existing configuration
+```
+
+## Examples
+
+See the [examples](./examples) directory for programmatic usage.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import {
+    clientNames,
+    logger,
+    readConfig,
+    writeConfig
+  } from "./utils.js";
+  import { execSync } from 'child_process';
+  
+  import yargs from "yargs";
+  import { hideBin } from "yargs/helpers";
+  
+  import pc from "picocolors";
+  var { green, red } = pc;
+  function builder(yargs2) {
+    return yargs2.option("client", {
+      type: "string",
+      description: "Client to use for installation",
+      demandOption: true,
+      choices: clientNames
+    }).option("env", {
+      type: "string",
+      description: "Environment variables as key=value pairs (can be used multiple times). API_KEY is required.",
+      array: true
+    });
+  }
+  async function handler(argv) {
+    if (!argv.client || !clientNames.includes(argv.client)) {
+      logger.error(`Invalid client: ${argv.client}. Available clients: ${clientNames.join(", ")}`);
+      return;
+    }
+    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.`);
+        }
+      }
+    }
+    if (!envVars.API_KEY) {
+      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";
+    }
+    const name = "insforge";
+    const ready = true; // Auto-confirm for simplified installation
+    if (ready) {
+      try {
+        const config = readConfig(argv.client);
+        
+        // Handle different config structures for different clients
+        if (argv.client === "claude-code") {
+          // Use Claude CLI for Claude Code
+          const envArgs = Object.entries(envVars)
+            .filter(([key]) => key !== 'CLIENT_NAME')
+            .map(([key, value]) => `-e ${key}=${value}`)
+            .join(' ');
+          
+          try {
+            execSync(`claude mcp add ${name} ${envArgs} -- npx -y @insforge/insforge-mcp@latest`, {
+              stdio: 'inherit'
+            });
+          } catch (error) {
+            throw new Error(`Failed to add MCP server via Claude 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", "@insforge/insforge-mcp@latest"],
+            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", "@insforge/insforge-mcp@latest"],
+            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") {
+          if (!config.mcpServers) config.mcpServers = {};
+          config.mcpServers[name] = {
+            command: "npx",
+            args: ["-y", "@insforge/insforge-mcp@latest"],
+            env: {
+              API_KEY: envVars.API_KEY,
+              API_BASE_URL: envVars.API_BASE_URL
+            }
+          };
+          writeConfig(config, argv.client);
+        }
+        logger.box(green(`Successfully installed Insforge MCP server in ${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("--")) {
+    parser.parse(["install", ...process.argv.slice(2)]);
+  } else {
+    parser.parse();
+  }
+  

package/dist/utils.js

@@ -0,0 +1,134 @@
+// 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")
+  }
+};
+var platform = process.platform;
+var { baseDir, vscodePath } = platformPaths[platform];
+var clientPaths = {
+  "claude-code": { 
+    type: "file", 
+    path: path.join(homeDir, ".claude", "claude_mcp_config.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, "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+  }
+};
+var 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;
+}
+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: {} };
+    }
+    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);
+}
+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)}`);
+    }
+  } 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

@@ -0,0 +1,28 @@
+{
+  "name": "@insforge/install",
+  "version": "0.0.2",
+  "description": "CLI tool for installing Insforge MCP servers across different AI clients",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "insforge-install": "dist/index.js"
+  },
+  "scripts": {
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "yargs": "^17.7.2",
+    "picocolors": "^1.0.0",
+    "consola": "^3.2.3"
+  },
+  "keywords": [
+    "insforge",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "author": "Insforge",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}