imcp 0.0.1

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "imcp",
+  "version": "0.0.1",
+  "description": "Node.js SDK for Model Context Protocol (MCP)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "imcp": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-public && npm run copy-feeds",
+    "dev": "tsc -w",
+    "start": "node dist/web/server.js",
+    "dev:server": "ts-node-dev --respawn --transpile-only src/cli/index.ts start",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "copy-public": "xcopy /E /I /Y src\\web\\public dist\\web\\public",
+    "copy-feeds": "xcopy /E /I /Y src\\feeds dist\\feeds"
+  },
+  "keywords": [
+    "mcp",
+    "sdk",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.2",
+    "commander": "^11.1.0",
+    "express": "^4.18.2",
+    "extract-zip": "^2.0.1",
+    "unzipper": "^0.10.14"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.5",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module"
+}

package/src/cli/commands/install.ts

@@ -0,0 +1,140 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+import { Logger } from '../../utils/logger.js';
+import { hasLocalFeeds } from '../../utils/feedUtils.js';
+import { ServerInstallOptions } from '../../core/types.js';
+import { SUPPORTED_CLIENT_NAMES } from '../../core/constants.js';
+
+export function createInstallCommand(): Command {
+  return new Command('install')
+    .description('Install specific MCP servers')
+    .addHelpText('after', `
+Examples:
+  # Install a server
+  $ imcp install --category ai-coder-tools --name github-tools
+
+  # Install with specific client targets (semicolon separated)
+  $ imcp install --category ai-coder-tools --name github-tools --clients "MSRooCode;GithubCopilot"
+
+  # Install with environment variables
+  $ imcp install --category ai-coder-tools --name github-tools --envs "GITHUB_TOKEN=abc123;API_KEY=xyz789"
+    `)
+    .requiredOption(
+      '--category <category>',
+      'Server category'
+    )
+    .requiredOption(
+      '--name <name>',
+      'Server name to install'
+    )
+    .option(
+      '--force',
+      'Force installation even if server already exists',
+      false
+    )
+    .option(
+      '--clients <clients>',
+      'Target clients (semicolon separated). Supported values: Cline, MSRooCode, GithubCopilot. If not specified, installs for all clients'
+    )
+    .option(
+      '--envs <envs>',
+      'Environment variables (semicolon separated key=value pairs)'
+    )
+    .action(async (options: {
+      category: string;
+      name: string;
+      force: boolean;
+      clients?: string;
+      envs?: string;
+      verbose?: boolean;
+    }) => {
+      try {
+        // Check for local feeds existence at the start
+        const feedsExist = await hasLocalFeeds();
+        if (!feedsExist) {
+          Logger.log('Local feeds not found, syncing from remote...');
+          await serverService.syncFeeds();
+        }
+
+        const { category, name, verbose, force, clients, envs } = options;
+        
+        Logger.debug(`Install options: ${JSON.stringify({ category, name, force, verbose, clients, envs })}`);
+        
+        const serverName = name.trim();
+        Logger.debug(`Server name: ${serverName}`);
+
+        if (!await serverService.validateServerName(category, serverName)) {
+          Logger.error('Invalid server name or category provided', {
+            category,
+            serverName
+          });
+          process.exit(1);
+        }
+
+        // Parse and validate clients
+        const parsedClients = clients ? clients.split(';')
+          .map((c: string) => c.trim())
+          .filter(Boolean)
+          .map((c: string) => {
+            const clientName = c.toLowerCase();
+            const validClient = SUPPORTED_CLIENT_NAMES.find((name: string) => name.toLowerCase() === clientName);
+            if (!validClient) {
+              Logger.error(`Invalid client name: ${c}`);
+              return null;
+            }
+            return validClient;
+          })
+          .filter((c: string | null): c is string => c !== null) : undefined;
+
+        if (parsedClients && parsedClients.length > 0) {
+          Logger.debug(`Target clients: ${JSON.stringify(parsedClients)}`);
+        }
+
+        // Parse environment variables
+        const parsedEnvs: Record<string, string> = {};
+        if (envs) {
+          const pairs = envs.split(';');
+          for (const pair of pairs) {
+            const [key, value] = pair.split('=').map((s: string) => s.trim());
+            if (key && value) {
+              parsedEnvs[key] = value;
+            } else {
+              Logger.error(`Invalid environment variable format: ${pair}`);
+            }
+          }
+        }
+
+        if (Object.keys(parsedEnvs).length > 0) {
+          Logger.debug(`Environment variables: ${JSON.stringify(parsedEnvs)}`);
+        }
+
+        Logger.log(`Installing server: ${serverName}`);
+
+        const installOptions: ServerInstallOptions = {
+          force: options.force,
+          ...(parsedClients?.length && { targetClients: parsedClients }),
+          ...(Object.keys(parsedEnvs).length > 0 && { env: parsedEnvs })
+        };
+
+        const results = [await serverService.installMcpServer(category, serverName, installOptions)];
+
+        const { success, messages } = serverService.formatOperationResults(results);
+
+        messages.forEach((message: string) => {
+          if (success) {
+            Logger.log(`✓ ${message}`);
+          } else {
+            Logger.error(`✗ ${message}`);
+          }
+        });
+
+        if (!success) {
+          process.exit(1);
+        }
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        Logger.error('Installation failed:', message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_DIR } from '../../core/constants.js';
+import { mcpManager } from '../../core/MCPManager.js';
+import { Logger } from '../../utils/logger.js';
+
+interface SimplifiedServer {
+  name: string;
+  description: string;
+}
+
+interface SimplifiedFeed {
+  name: string;
+  displayName: string;
+  description: string;
+  mcpServers: SimplifiedServer[];
+}
+
+export function createListCommand(): Command {
+  return new Command('list')
+    .description('List all available MCP servers from feeds')
+    .option('--pull', 'Sync with remote feeds before listing')
+    .action(async (options) => {
+      try {
+        Logger.debug({
+          action: 'list_command_started',
+          options
+        });
+
+        // If sync flag is provided, try to sync first
+        if (options.pull) {
+          try {
+            await mcpManager.syncFeeds();
+          } catch (syncError) {
+            Logger.error('Failed to sync feeds, falling back to local feeds', syncError);
+          }
+        }
+
+        Logger.debug({
+          action: 'ensuring_feeds_directory',
+          path: LOCAL_FEEDS_DIR
+        });
+
+        // Ensure feeds directory exists
+        await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+
+        // Read all json files from feeds directory
+        Logger.debug('Reading feed files from directory...');
+        const files = await fs.readdir(LOCAL_FEEDS_DIR);
+        const jsonFiles = files.filter(file => file.endsWith('.json'));
+
+        Logger.debug({
+          action: 'found_feed_files',
+          count: jsonFiles.length,
+          files: jsonFiles
+        });
+
+        const feeds: SimplifiedFeed[] = [];
+
+        // Process each json file
+        for (const file of jsonFiles) {
+          Logger.debug(`Processing feed file: ${file}`);
+          try {
+            const filePath = path.join(LOCAL_FEEDS_DIR, file);
+            const content = await fs.readFile(filePath, 'utf8');
+            const feedConfig = JSON.parse(content);
+
+            Logger.debug({
+              action: 'processing_feed',
+              file,
+              feedName: feedConfig.name,
+              serverCount: feedConfig.mcpServers?.length ?? 0
+            });
+
+            // Extract only needed information
+            const simplifiedFeed: SimplifiedFeed = {
+              name: feedConfig.name,
+              displayName: feedConfig.displayName,
+              description: feedConfig.description,
+              mcpServers: feedConfig.mcpServers.map((server: any) => ({
+                name: server.name,
+                description: server.description
+              }))
+            };
+
+            feeds.push(simplifiedFeed);
+            Logger.debug(`Successfully processed feed: ${feedConfig.name}`);
+          } catch (error) {
+            Logger.error(`Failed to process feed file: ${file}`, error);
+          }
+        }
+
+        if (feeds.length === 0) {
+          Logger.log('No feeds found.');
+          return;
+        }
+
+        Logger.debug({
+          action: 'completed_processing',
+          totalFeeds: feeds.length,
+          totalServers: feeds.reduce((acc, feed) => acc + feed.mcpServers.length, 0)
+        });
+
+        // Output as formatted JSON
+        console.log(JSON.stringify(feeds, null, 2));
+      } catch (error) {
+        Logger.error('Failed to list servers', error);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/pull.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+
+export function createPullCommand(): Command {
+  return new Command('pull')
+    .description('Pull MCP server configurations from remote feed source')
+    .action(async () => {
+      try {
+        await serverService.syncFeeds();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Error syncing configurations:', message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/serve.ts

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { startWebServer } from '../../web/server.js';
+import { mcpManager } from '../../core/MCPManager.js';
+import { checkGithubAuth } from '../../utils/githubAuth.js';
+import { Logger } from '../../utils/logger.js';
+
+export function createServeCommand(): Command {
+  return new Command('serve')
+    .description('Serve local web interface')
+    .option('-p, --port <port>', 'Port to run the server on', '3000')
+    .action(async (options) => {
+      try {
+        // Sync feeds before start the local UI
+        await mcpManager.syncFeeds();
+
+        // Ensure MCP manager is initialized before starting the web server
+        await mcpManager.initialize();
+        
+        const port = parseInt(options.port, 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+          throw new Error('Invalid port number');
+        }
+
+        await startWebServer(port);
+        
+        // The server is running, keep the process alive
+        process.on('SIGINT', () => {
+          console.log('\nShutting down server...');
+          process.exit(0);
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Failed to start web server:', message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/uninstall.ts

@@ -0,0 +1,54 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+
+export function createUninstallCommand(): Command {
+  return new Command('uninstall')
+    .description('Uninstall specific MCP servers')
+    .requiredOption(
+      '--category <category>',
+      '--names <names>',
+      'Server names (semicolon separated)'
+    )
+    .option(
+      '--remove-data',
+      'Remove all associated data',
+      false
+    )
+    .action(async (options) => {
+      try {
+        const serverNames = options.names.split(';').map((name: string) => name.trim());
+
+        if (!serverService.validateServerName(options.category, serverNames)) {
+          console.error('Invalid server names provided');
+          process.exit(1);
+        }
+
+        console.log(`Uninstalling servers: ${serverNames.join(', ')}`);
+
+        const results = await Promise.all(
+          serverNames.map((serverName: string) =>
+            serverService.uninstallMcpServer(options.category, serverName, {
+              removeData: options.removeData,
+            })
+          )
+        );
+
+        const { success, messages } = serverService.formatOperationResults(results);
+        messages.forEach(message => {
+          if (success) {
+            console.log(`✓ ${message}`);
+          } else {
+            console.error(`✗ ${message}`);
+          }
+        });
+
+        if (!success) {
+          process.exit(1);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Uninstallation failed:', message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/index.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createServeCommand } from './commands/serve.js';
+import { createListCommand } from './commands/list.js';
+import { createInstallCommand } from './commands/install.js';
+import { createUninstallCommand } from './commands/uninstall.js';
+import { createPullCommand } from './commands/pull.js';
+import { mcpManager } from '../core/MCPManager.js';
+import { Logger } from '../utils/logger.js';
+import axios from 'axios';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+// Custom error interface for Commander.js errors
+// ANSI color codes
+const COLORS = {
+  reset: '\x1b[0m',
+  yellow: '\x1b[33m'
+};
+
+interface CommanderError extends Error {
+  code?: string;
+}
+
+async function main(): Promise<void> {
+  // Initialize the MCP manager
+  await mcpManager.initialize();
+
+  const program = new Command();
+  program
+    .name('imcp')
+    .description('IMCP (Install Model Context Protocol) CLI')
+    .version('0.0.1')
+    .option('--verbose', 'Show detailed logs for all commands');
+
+  // Parse global options first
+  program.parseOptions(process.argv);
+  const opts = program.opts();
+  Logger.setVerbose(!!opts.verbose);
+
+  // Add all commands
+  program.addCommand(createServeCommand());
+  program.addCommand(createListCommand());
+  program.addCommand(createInstallCommand());
+  // program.addCommand(createUninstallCommand());
+  program.addCommand(createPullCommand());
+
+  // Error handling for the entire CLI
+  program.exitOverride();
+
+  // Check for updates
+  await checkForUpdates();
+
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const commanderError = error as CommanderError;
+
+    if (commanderError.code === 'commander.help') {
+      // Help was displayed, exit normally
+      process.exit(0);
+    } else if (commanderError.code === 'commander.version') {
+      // Version was displayed, exit normally
+      process.exit(0);
+    } else {
+      console.error('Error:', commanderError.message || 'An unknown error occurred');
+      process.exit(1);
+    }
+  }
+}
+
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (error: unknown) => {
+  if (error instanceof Error) {
+    console.error('Unhandled promise rejection:', error.message);
+  } else {
+    console.error('Unhandled promise rejection:', error);
+  }
+  process.exit(1);
+});
+
+/**
+ * Check if there's a newer version of the package available
+ */
+async function checkForUpdates(): Promise<void> {
+  try {
+    // Get the current package version
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const packagePath = path.resolve(__dirname, '../../package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const currentVersion = packageJson.name && packageJson.version ? packageJson.version : '0.0.0';
+    const packageName = packageJson.name || 'imcp';
+
+    try {
+      // Get the latest version from npm registry (only for published packages)
+      const npmResponse = await axios.get(`https://registry.npmjs.org/${packageName}`);
+
+      if (npmResponse.data && npmResponse.data['dist-tags'] && npmResponse.data['dist-tags'].latest) {
+        const latestVersion = npmResponse.data['dist-tags'].latest;
+
+        if (latestVersion && latestVersion !== currentVersion) {
+          console.log(`${COLORS.yellow}Update available for ${packageName}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
+          console.log(`${COLORS.yellow}Run \`npm install -g ${packageName}@latest\` to update${COLORS.reset}`);
+        }
+      }
+    } catch (npmError) {
+      // Log the npm error
+      Logger.debug(`Failed to check npm registry: ${npmError instanceof Error ? npmError.message : String(npmError)}`);
+    }
+  } catch (error) {
+    // Silently fail - don't interrupt the command if update check fails
+    Logger.debug(`Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// Start the CLI
+main().catch((error: unknown) => {
+  if (error instanceof Error) {
+    console.error('Fatal error:', error.message);
+  } else {
+    console.error('Fatal error:', error);
+  }
+  process.exit(1);
+});