imcp 0.0.1

package/.github/ISSUE_TEMPLATE/JitAccess.yml

@@ -0,0 +1,28 @@
+name: Temporary administrator access request
+description: Request for temporary repository administrator access to this repository, a.k.a Just-in-Time (JIT) access.
+title: "JIT Request"
+labels: ["jit"]
+assignees:
+  - gimsvc_microsoft
+  - 
+body:
+  - type: markdown
+    attributes:
+      value: |
+        :closed_lock_with_key: Permanent repository administrator access is not allowed as per Microsoft security policy. You can use this form to request for temporary administrator access to this repository.
+  - type: textarea
+    id: justification
+    attributes:
+      label: Justification
+      description: Describe the actions that you will perform with your temporary administrator access.
+      placeholder: I need to create secrets.
+    validations:
+      required: true
+  - type: dropdown
+    id: duration
+    attributes:
+      label: Duration (hours)
+      description: How long do you need access for? The duration you select is in hours.
+      options:
+        - 1
+        - 2

package/.github/acl/access.yml

@@ -0,0 +1,20 @@
+# Documentation for ACL policy: https://aka.ms/gim/docs/policy/acl
+
+name: Access control list
+description: List of teams and their permission levels
+resource: repository
+where:
+configuration:
+  manageAccess:
+  - team: aicodervteam
+    role: Triage
+  - member: hod
+    role: Maintain
+  - member: penwa
+    role: Maintain
+  - member: anthu
+    role: Maintain
+  - member: enbaowang
+    role: Maintain
+  - member: xinli7
+    role: Maintain

package/.github/compliance/inventory.yml

@@ -0,0 +1,5 @@
+inventory:
+- source: ServiceTree
+  items:
+  - id: 447fe696-ca1f-419e-8da1-2c6d9cdfe31b
+  isProduction: true

package/.github/policies/jit.yml

@@ -0,0 +1,19 @@
+# Documentation for JIT policy: https://aka.ms/gim/docs/policy/jit
+
+# metadata
+id: id
+name: JIT_Access
+description: Policy for admin JIT for repos in this org
+
+# filters
+resource: repository
+
+# primitive configuration
+configuration:
+    jitAccess:
+        enabled: true
+        maxHours: 2
+        approvers:
+            role: Maintain
+        requestors:
+            role: Write

package/README.md

@@ -0,0 +1,137 @@
+# IMCP
+
+IMCP (Install Model Context Protocol) is a unified MCP management project that provides the ability to list, install, and manage MCP servers based on unified feeds.
+
+## Overview
+
+IMCP is a command-line tool that simplifies the management of Model Context Protocol (MCP) servers. It allows you to:
+
+- Discover available MCP servers from configurable feeds
+- Install servers with specific configurations
+- Manage server installations
+- Run a local web interface to manage your MCP servers
+
+## Installation
+
+```bash
+npm install -g imcp
+```
+
+## Commands
+
+### Global Options
+
+- `--verbose`: Show detailed logs for all commands
+
+### serve
+
+Starts a local web interface for managing MCP servers.
+
+```bash
+imcp serve [options]
+```
+
+Options:
+- `-p, --port <port>`: Port to run the server on (default: 3000)
+
+Example:
+```bash
+# Start the web interface on port 8080
+imcp serve --port 8080
+```
+
+### list
+
+Lists all available MCP servers from configured feeds.
+
+```bash
+imcp list [options]
+```
+
+Options:
+- `--pull`: Sync with remote feeds before listing
+
+Example:
+```bash
+# List servers after syncing with remote feeds
+imcp list --pull
+```
+
+### install
+
+Installs specific MCP servers.
+
+```bash
+imcp install [options]
+```
+
+Options:
+- `--category <category>`: Server category (required)
+- `--name <name>`: Server name to install (required)
+- `--force`: Force installation even if server already exists
+- `--clients <clients>`: Target clients (semicolon separated). Supported values: Cline, MSRooCode, GithubCopilot
+- `--envs <envs>`: Environment variables (semicolon separated key=value pairs)
+
+Examples:
+```bash
+# Install a server
+imcp install --category ai-coder-tools --name github-tools
+
+# Install with specific client targets
+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"
+```
+
+### pull
+
+Pulls MCP server configurations from remote feed sources to update local feeds.
+
+```bash
+imcp pull
+```
+
+Example:
+```bash
+# Update local feeds with the latest server configurations
+imcp pull
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js
+- npm
+
+### Setup
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd imcp
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run in development mode
+npm run dev
+```
+
+### Scripts
+
+- `npm run build`: Builds the project and copies necessary files
+- `npm run dev`: Runs TypeScript in watch mode
+- `npm run start`: Starts the web server
+- `npm run dev:server`: Starts the development server with hot reloading
+- `npm run test`: Runs tests
+- `npm run lint`: Lints the source code
+- `npm run format`: Formats the source code
+
+## License
+
+MIT

package/dist/cli/commands/install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createInstallCommand(): Command;

package/dist/cli/commands/install.js

@@ -0,0 +1,105 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+import { Logger } from '../../utils/logger.js';
+import { hasLocalFeeds } from '../../utils/feedUtils.js';
+import { SUPPORTED_CLIENT_NAMES } from '../../core/constants.js';
+export function createInstallCommand() {
+    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) => {
+        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) => c.trim())
+                .filter(Boolean)
+                .map((c) => {
+                const clientName = c.toLowerCase();
+                const validClient = SUPPORTED_CLIENT_NAMES.find((name) => name.toLowerCase() === clientName);
+                if (!validClient) {
+                    Logger.error(`Invalid client name: ${c}`);
+                    return null;
+                }
+                return validClient;
+            })
+                .filter((c) => c !== null) : undefined;
+            if (parsedClients && parsedClients.length > 0) {
+                Logger.debug(`Target clients: ${JSON.stringify(parsedClients)}`);
+            }
+            // Parse environment variables
+            const parsedEnvs = {};
+            if (envs) {
+                const pairs = envs.split(';');
+                for (const pair of pairs) {
+                    const [key, value] = pair.split('=').map((s) => 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 = {
+                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) => {
+                if (success) {
+                    Logger.log(`✓ ${message}`);
+                }
+                else {
+                    Logger.error(`✗ ${message}`);
+                }
+            });
+            if (!success) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            Logger.error('Installation failed:', message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=install.js.map

package/dist/cli/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createListCommand(): Command;

package/dist/cli/commands/list.js

@@ -0,0 +1,90 @@
+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';
+export function createListCommand() {
+    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 = [];
+            // 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 = {
+                        name: feedConfig.name,
+                        displayName: feedConfig.displayName,
+                        description: feedConfig.description,
+                        mcpServers: feedConfig.mcpServers.map((server) => ({
+                            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);
+        }
+    });
+}
+//# sourceMappingURL=list.js.map

package/dist/cli/commands/pull.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createPullCommand(): Command;

package/dist/cli/commands/pull.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+export function createPullCommand() {
+    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);
+        }
+    });
+}
+//# sourceMappingURL=pull.js.map

package/dist/cli/commands/serve.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createServeCommand(): Command;

package/dist/cli/commands/serve.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { startWebServer } from '../../web/server.js';
+import { mcpManager } from '../../core/MCPManager.js';
+export function createServeCommand() {
+    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);
+        }
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/cli/commands/start.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createStartCommand(): Command;

package/dist/cli/commands/start.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { startWebServer } from '../../web/server.js';
+import { mcpManager } from '../../core/MCPManager.js';
+export function createStartCommand() {
+    return new Command('start')
+        .description('Start 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);
+        }
+    });
+}
+//# sourceMappingURL=start.js.map

package/dist/cli/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createSyncCommand(): Command;

package/dist/cli/commands/sync.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+export function createSyncCommand() {
+    return new Command('sync')
+        .description('Sync 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);
+        }
+    });
+}
+//# sourceMappingURL=sync.js.map

package/dist/cli/commands/uninstall.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createUninstallCommand(): Command;

package/dist/cli/commands/uninstall.js

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import { serverService } from '../../services/ServerService.js';
+export function createUninstallCommand() {
+    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) => 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) => 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);
+        }
+    });
+}
+//# sourceMappingURL=uninstall.js.map

package/dist/cli/index.d.ts

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