@nordsym/apiclaw 1.5.12 → 1.5.14

package/dist/src/utils/config.js

@@ -0,0 +1,220 @@
+/**
+ * Config Management
+ * Handles JSON read/write/merge operations for MCP config files
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { createBackup } from './backup.js';
+/**
+ * Read and parse a JSON config file
+ */
+export function readConfig(configPath) {
+    try {
+        if (!existsSync(configPath)) {
+            return {
+                success: true,
+                config: {},
+                isNew: true,
+            };
+        }
+        const content = readFileSync(configPath, 'utf-8');
+        // Handle empty files
+        if (!content.trim()) {
+            return {
+                success: true,
+                config: {},
+                isNew: true,
+            };
+        }
+        const config = JSON.parse(content);
+        return {
+            success: true,
+            config,
+            isNew: false,
+        };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return {
+                success: false,
+                config: null,
+                error: `Invalid JSON in config file: ${error.message}`,
+            };
+        }
+        return {
+            success: false,
+            config: null,
+            error: error instanceof Error ? error.message : 'Unknown error reading config',
+        };
+    }
+}
+/**
+ * Write config to file with backup
+ */
+export function writeConfig(configPath, config, createBackupFirst = true) {
+    try {
+        // Ensure directory exists
+        const dir = dirname(configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Create backup if file exists and backup requested
+        let backupPath = null;
+        if (createBackupFirst && existsSync(configPath)) {
+            const backupResult = createBackup(configPath);
+            if (!backupResult.success) {
+                return {
+                    success: false,
+                    error: `Failed to create backup: ${backupResult.error}`,
+                };
+            }
+            backupPath = backupResult.backupPath;
+        }
+        // Validate JSON before writing
+        const content = JSON.stringify(config, null, 2);
+        JSON.parse(content); // Validation parse
+        // Write file
+        writeFileSync(configPath, content, 'utf-8');
+        return {
+            success: true,
+            backupPath,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error writing config',
+        };
+    }
+}
+/**
+ * Deep merge two objects
+ */
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (sourceValue !== null &&
+            typeof sourceValue === 'object' &&
+            !Array.isArray(sourceValue) &&
+            targetValue !== null &&
+            typeof targetValue === 'object' &&
+            !Array.isArray(targetValue)) {
+            // Recursively merge objects
+            result[key] = deepMerge(targetValue, sourceValue);
+        }
+        else {
+            // Overwrite value
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+/**
+ * Generate APIClaw MCP server configuration
+ */
+export function generateApiclawConfig(options = {}) {
+    const config = {
+        command: 'npx',
+        args: ['-y', '@nordsym/apiclaw'],
+    };
+    if (options.workspace) {
+        config.env = {
+            APICLAW_WORKSPACE: options.workspace,
+        };
+    }
+    return config;
+}
+/**
+ * Generate APIClaw config for Continue (array format)
+ */
+export function generateApiclawContinueConfig(options = {}) {
+    const config = {
+        name: options.serverName || 'apiclaw',
+        command: 'npx',
+        args: ['-y', '@nordsym/apiclaw'],
+    };
+    if (options.workspace) {
+        config.env = {
+            APICLAW_WORKSPACE: options.workspace,
+        };
+    }
+    return config;
+}
+/**
+ * Check if APIClaw is already configured
+ */
+export function hasApiclawConfig(config, serverName = 'apiclaw') {
+    // Handle Continue's array format
+    if (Array.isArray(config.mcpServers)) {
+        const continueConfig = config;
+        return continueConfig.mcpServers?.some(s => s.name === serverName) || false;
+    }
+    // Handle standard object format
+    const mcpConfig = config;
+    return mcpConfig.mcpServers?.[serverName] !== undefined;
+}
+/**
+ * Merge APIClaw config into existing config (standard format)
+ */
+export function mergeApiclawConfig(existingConfig, options = {}) {
+    const serverName = options.serverName || 'apiclaw';
+    const apiclawConfig = generateApiclawConfig(options);
+    return deepMerge(existingConfig, {
+        mcpServers: {
+            ...existingConfig.mcpServers,
+            [serverName]: apiclawConfig,
+        },
+    });
+}
+/**
+ * Merge APIClaw config into Continue config (array format)
+ */
+export function mergeApiclawContinueConfig(existingConfig, options = {}) {
+    const serverName = options.serverName || 'apiclaw';
+    const apiclawConfig = generateApiclawContinueConfig(options);
+    const existingServers = existingConfig.mcpServers || [];
+    // Check if already exists
+    const existingIndex = existingServers.findIndex(s => s.name === serverName);
+    let newServers;
+    if (existingIndex >= 0) {
+        // Update existing
+        newServers = [...existingServers];
+        newServers[existingIndex] = apiclawConfig;
+    }
+    else {
+        // Add new
+        newServers = [...existingServers, apiclawConfig];
+    }
+    return {
+        ...existingConfig,
+        mcpServers: newServers,
+    };
+}
+/**
+ * Remove APIClaw from config
+ */
+export function removeApiclawConfig(config, serverName = 'apiclaw') {
+    // Handle Continue's array format
+    if (Array.isArray(config.mcpServers)) {
+        const continueConfig = config;
+        return {
+            ...continueConfig,
+            mcpServers: continueConfig.mcpServers?.filter(s => s.name !== serverName),
+        };
+    }
+    // Handle standard object format
+    const mcpConfig = config;
+    const { [serverName]: _, ...remainingServers } = mcpConfig.mcpServers || {};
+    return {
+        ...mcpConfig,
+        mcpServers: remainingServers,
+    };
+}
+/**
+ * Detect if config uses Continue's array format
+ */
+export function isContinueFormat(config) {
+    return Array.isArray(config.mcpServers);
+}

package/dist/src/utils/os.js

@@ -0,0 +1,105 @@
+/**
+ * OS Detection Utility
+ * Detects the operating system and provides platform-specific helpers
+ */
+import { platform, homedir } from 'os';
+import { join } from 'path';
+/**
+ * Detect the current operating system
+ */
+export function detectOS() {
+    const os = platform();
+    switch (os) {
+        case 'darwin':
+            return 'mac';
+        case 'win32':
+            return 'win';
+        case 'linux':
+            return 'linux';
+        default:
+            // Default to linux for other Unix-like systems
+            return 'linux';
+    }
+}
+/**
+ * Get the home directory for the current user
+ */
+export function getHomeDir() {
+    return homedir();
+}
+/**
+ * Get the app data directory based on OS
+ * - macOS: ~/Library/Application Support
+ * - Windows: %APPDATA%
+ * - Linux: ~/.config
+ */
+export function getAppDataDir() {
+    const home = getHomeDir();
+    const os = detectOS();
+    switch (os) {
+        case 'mac':
+            return join(home, 'Library', 'Application Support');
+        case 'win':
+            return process.env.APPDATA || join(home, 'AppData', 'Roaming');
+        case 'linux':
+            return process.env.XDG_CONFIG_HOME || join(home, '.config');
+    }
+}
+/**
+ * Get the user profile directory (Windows-specific, falls back to home)
+ */
+export function getUserProfileDir() {
+    return process.env.USERPROFILE || getHomeDir();
+}
+/**
+ * Check if running as root/admin
+ */
+export function isElevated() {
+    const os = detectOS();
+    if (os === 'win') {
+        // Windows admin check is more complex, skip for now
+        return false;
+    }
+    // Unix-like: check if UID is 0
+    return process.getuid?.() === 0;
+}
+/**
+ * Get OS-specific path separator
+ */
+export function getPathSeparator() {
+    return detectOS() === 'win' ? '\\' : '/';
+}
+/**
+ * Normalize path for current OS
+ */
+export function normalizePath(path) {
+    const os = detectOS();
+    if (os === 'win') {
+        // Convert forward slashes to backslashes on Windows
+        return path.replace(/\//g, '\\');
+    }
+    return path;
+}
+/**
+ * Expand ~ to home directory
+ */
+export function expandHome(path) {
+    if (path.startsWith('~')) {
+        return join(getHomeDir(), path.slice(1));
+    }
+    return path;
+}
+/**
+ * Get OS display name
+ */
+export function getOSDisplayName() {
+    const os = detectOS();
+    switch (os) {
+        case 'mac':
+            return 'macOS';
+        case 'win':
+            return 'Windows';
+        case 'linux':
+            return 'Linux';
+    }
+}

package/dist/src/utils/paths.js

@@ -0,0 +1,159 @@
+/**
+ * Config Path Resolver
+ * Resolves config file paths for all MCP clients across all operating systems
+ */
+import { join } from 'path';
+import { detectOS, getHomeDir, getAppDataDir, getUserProfileDir } from './os.js';
+/**
+ * Get config path for Claude Desktop
+ */
+function getClaudeDesktopPath(os) {
+    const home = getHomeDir();
+    const appData = getAppDataDir();
+    switch (os) {
+        case 'mac':
+            return join(appData, 'Claude', 'claude_desktop_config.json');
+        case 'win':
+            return join(appData, 'Claude', 'claude_desktop_config.json');
+        case 'linux':
+            return join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    }
+}
+/**
+ * Get config path for Cursor
+ */
+function getCursorPath(os) {
+    const home = getHomeDir();
+    const appData = getAppDataDir();
+    switch (os) {
+        case 'mac':
+            return join(appData, 'Cursor', 'User', 'globalStorage', 'cursor.mcp', 'config.json');
+        case 'win':
+            return join(appData, 'Cursor', 'User', 'globalStorage', 'cursor.mcp', 'config.json');
+        case 'linux':
+            return join(home, '.config', 'Cursor', 'User', 'globalStorage', 'cursor.mcp', 'config.json');
+    }
+}
+/**
+ * Get config path for Windsurf
+ */
+function getWindsurfPath(os) {
+    const home = getHomeDir();
+    const userProfile = getUserProfileDir();
+    switch (os) {
+        case 'mac':
+        case 'linux':
+            return join(home, '.codeium', 'windsurf', 'mcp_config.json');
+        case 'win':
+            return join(userProfile, '.codeium', 'windsurf', 'mcp_config.json');
+    }
+}
+/**
+ * Get config path for Cline (VS Code extension)
+ */
+function getClinePath(os) {
+    const home = getHomeDir();
+    const appData = getAppDataDir();
+    const relativePath = join('Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
+    switch (os) {
+        case 'mac':
+            return join(appData, relativePath);
+        case 'win':
+            return join(appData, relativePath);
+        case 'linux':
+            return join(home, '.config', relativePath);
+    }
+}
+/**
+ * Get config path for Continue
+ */
+function getContinuePath(os) {
+    const home = getHomeDir();
+    const userProfile = getUserProfileDir();
+    switch (os) {
+        case 'mac':
+        case 'linux':
+            return join(home, '.continue', 'config.json');
+        case 'win':
+            return join(userProfile, '.continue', 'config.json');
+    }
+}
+/**
+ * Get the config path for a specific MCP client
+ */
+export function getConfigPath(client, os) {
+    const currentOS = os || detectOS();
+    switch (client) {
+        case 'claude-desktop':
+            return getClaudeDesktopPath(currentOS);
+        case 'cursor':
+            return getCursorPath(currentOS);
+        case 'windsurf':
+            return getWindsurfPath(currentOS);
+        case 'cline':
+            return getClinePath(currentOS);
+        case 'continue':
+            return getContinuePath(currentOS);
+    }
+}
+/**
+ * Get full client configuration info
+ */
+export function getClientConfig(client, os) {
+    const configPath = getConfigPath(client, os);
+    const pathParts = configPath.split(/[/\\]/);
+    const configFile = pathParts.pop() || '';
+    const configDir = pathParts.join('/');
+    const displayNames = {
+        'claude-desktop': 'Claude Desktop',
+        'cursor': 'Cursor',
+        'windsurf': 'Windsurf',
+        'cline': 'Cline',
+        'continue': 'Continue',
+    };
+    return {
+        name: client,
+        displayName: displayNames[client],
+        configPath,
+        configDir,
+        configFile,
+    };
+}
+/**
+ * Get all supported MCP clients
+ */
+export function getAllClients() {
+    return ['claude-desktop', 'cursor', 'windsurf', 'cline', 'continue'];
+}
+/**
+ * Get config paths for all clients
+ */
+export function getAllConfigPaths(os) {
+    const paths = new Map();
+    for (const client of getAllClients()) {
+        paths.set(client, getClientConfig(client, os));
+    }
+    return paths;
+}
+/**
+ * Validate that a client name is valid
+ */
+export function isValidClient(client) {
+    return getAllClients().includes(client);
+}
+/**
+ * Parse client argument (accepts various formats)
+ */
+export function parseClientArg(arg) {
+    const normalized = arg.toLowerCase().replace(/[_\s]/g, '-');
+    const aliases = {
+        'claude': 'claude-desktop',
+        'claude-desktop': 'claude-desktop',
+        'claudedesktop': 'claude-desktop',
+        'cursor': 'cursor',
+        'windsurf': 'windsurf',
+        'cline': 'cline',
+        'continue': 'continue',
+    };
+    return aliases[normalized] || null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nordsym/apiclaw",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "The API layer for AI agents. Dashboard + 22K APIs + 18 Direct Call providers. MCP native.",
   "type": "module",
   "main": "dist/index.js",

package/src/bin.ts

@@ -6,7 +6,7 @@
  * - setup/doctor/restore/uninstall → Run CLI
  */
 
-const cliCommands = ['setup', 'mcp-install', 'doctor', 'restore', 'uninstall', 'help', '--help', '-h', '--version', '-V'];
+const cliCommands = ['setup', 'mcp-install', 'mcp-uninstall', 'doctor', 'restore', 'uninstall', 'help', '--help', '-h', '--version', '-V'];
 
 const firstArg = process.argv[2];
 

package/src/cli/commands/mcp-install.ts

@@ -276,9 +276,9 @@ export async function mcpInstallCommand(options: MCPInstallOptions): Promise<voi
     } else if (successCount > 0) {
       console.log(chalk.green('\n✅ APIClaw installed successfully!\n'));
       console.log(chalk.bold('What you get:\n'));
-      console.log(chalk.cyan('  🔍 Search') + '      22,000+ APIs indexed');
-      console.log(chalk.cyan('  🌐 Open APIs') + '   1,600 APIs - no keys needed');
-      console.log(chalk.cyan('  🔑 Direct Call') + ' 1,500+ endpoints - no keys needed');
+      console.log(chalk.cyan('  🔍 Search') + '      22,000+ APIs to discover');
+      console.log(chalk.cyan('  🌐 Open APIs') + '   1,600 free APIs');
+      console.log(chalk.cyan('  🔑 Direct Call') + ' 1,500+ premium (APIClaw manages keys)');
       console.log('');
       console.log('Next:');
       console.log('  1. Restart your MCP client');
@@ -288,9 +288,9 @@ export async function mcpInstallCommand(options: MCPInstallOptions): Promise<voi
     } else {
       console.log(chalk.yellow('\n✅ APIClaw already installed in all clients.\n'));
       console.log(chalk.bold('What you have:\n'));
-      console.log(chalk.cyan('  🔍 Search') + '      22,000+ APIs indexed');
-      console.log(chalk.cyan('  🌐 Open APIs') + '   1,600 APIs - no keys needed');
-      console.log(chalk.cyan('  🔑 Direct Call') + ' 1,500+ endpoints - no keys needed');
+      console.log(chalk.cyan('  🔍 Search') + '      22,000+ APIs to discover');
+      console.log(chalk.cyan('  🌐 Open APIs') + '   1,600 free APIs');
+      console.log(chalk.cyan('  🔑 Direct Call') + ' 1,500+ premium (APIClaw manages keys)');
       console.log('');
       console.log('Run with --force to reinstall (coming soon).\n');
     }

package/src/cli/index.ts

@@ -107,6 +107,14 @@ program
   .option('-f, --force', 'Remove even if not configured')
   .action(uninstallCommand);
 
+// MCP Uninstall alias - same as uninstall but for consistency with mcp-install
+program
+  .command('mcp-uninstall')
+  .description('Remove APIClaw from Claude Desktop or Claude Code MCP config')
+  .option('-c, --client <client>', 'Target specific client (claude-desktop, claude-code)')
+  .option('--dry-run', 'Show what would be done without making changes')
+  .action(uninstallCommand);
+
 // Parse and execute
 program.parse();