imcp 0.0.1

package/src/services/InstallRequestValidator.ts

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { FeedConfiguration, EnvVariableConfig, ServerInstallOptions } from '../core/types.js';
+import { InstallServersRequestBody } from '../web/server.js'; // Assuming InstallRequestBody is defined here
+import { SUPPORTED_CLIENT_NAMES } from '../core/constants.js';
+
+export class InstallRequestValidator {
+  private serverFeedConfigs: Map<string, FeedConfiguration> = new Map();
+  private feedDirectory: string;
+
+  constructor(feedDirectory: string = path.join(__dirname, '../feeds')) {
+    this.feedDirectory = feedDirectory;
+    // Consider loading configs lazily or providing an explicit load method
+    // For now, let's assume pre-loading or loading on demand in validate
+  }
+
+  private async loadServerFeedConfiguration(serverName: string): Promise<FeedConfiguration | undefined> {
+    if (this.serverFeedConfigs.has(serverName)) {
+      return this.serverFeedConfigs.get(serverName);
+    }
+
+    const filePath = path.join(this.feedDirectory, `${serverName}.json`);
+    try {
+      const fileContent = await fs.readFile(filePath, 'utf-8');
+      const config: FeedConfiguration = JSON.parse(fileContent);
+      // Basic validation of the loaded config structure could be added here
+      if (config && config.name === serverName) {
+        this.serverFeedConfigs.set(serverName, config);
+        return config;
+      }
+      console.error(`Configuration name mismatch in ${filePath}`);
+      return undefined;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        console.warn(`Server feed configuration not found for: ${serverName} at ${filePath}`);
+      } else {
+        console.error(`Error loading server feed configuration for ${serverName}:`, error);
+      }
+      return undefined;
+    }
+  }
+
+  /**
+   * Validates the install request body for a specific server.
+   * @param serverName The name of the server to validate against.
+   * @param requestBody The installation request body.
+   * @returns An array of error messages, or an empty array if validation passes.
+   */
+  async validate(serverName: string, requestBody: ServerInstallOptions): Promise<string[]> {
+    const errors: string[] = [];
+    const config = await this.loadServerFeedConfiguration(serverName);
+
+    if (!config) {
+      errors.push(`Server configuration feed not found for '${serverName}'.`);
+      // Cannot perform further validation without the config
+      return errors;
+    }
+
+    // 1.2 Validate required environment variables
+    config.mcpServers.forEach(mcp => {
+      if (mcp.installation?.env) {
+        Object.entries(mcp.installation.env).forEach(([envVar, envConfig]) => {
+          if (envConfig.Required) {
+            if (!requestBody.env || !(envVar in requestBody.env) || !requestBody.env[envVar]) {
+              errors.push(`Missing required environment variable '${envVar}' for server '${serverName}' (category: ${mcp.name}).`);
+            }
+          }
+        });
+      }
+    });
+
+    // 1.3 Validate target clients
+    if (!requestBody.targetClients || requestBody.targetClients.length === 0) {
+      errors.push(`Request body must include a non-empty 'targetClients' array for server '${serverName}'.`);
+    } else {
+      requestBody.targetClients.forEach((client: string) => {
+        if (!SUPPORTED_CLIENT_NAMES.includes(client)) {
+          errors.push(`Unsupported target client '${client}' specified for server '${serverName}'. Supported clients are: ${SUPPORTED_CLIENT_NAMES.join(', ')}.`);
+        }
+      });
+    }
+
+    // Add other validation rules as needed
+
+    return errors;
+  }
+
+  /**
+   * Validates the install request body for multiple servers.
+   * @param requestBody The installation request body containing multiple server names.
+   * @returns An object mapping server names to their validation errors. Empty arrays indicate success.
+   */
+  async validateMultiple(requestBody: InstallServersRequestBody): Promise<Record<string, string[]>> {
+    const results: Record<string, string[]> = {};
+    if (!requestBody.serverList || Object.keys(requestBody.serverList).length === 0) {
+      return { '_global': ['Request body must include a non-empty \'serverCategoryList\' record.'] };
+    }
+
+    for (const serverName of Object.keys(requestBody.serverList)) {
+      results[serverName] = await this.validate(serverName, requestBody.serverList[serverName]);
+    }
+
+    return results;
+  }
+}
+
+// Helper __dirname for ES modules
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Export a singleton instance (optional, depends on usage pattern)
+// export const installRequestValidator = new InstallRequestValidator();

package/src/services/ServerService.ts

@@ -0,0 +1,181 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Logger } from '../utils/logger.js';
+import {
+  MCPServerCategory,
+  ServerInstallOptions,
+  ServerCategoryListOptions,
+  ServerOperationResult,
+  ServerUninstallOptions
+} from '../core/types.js';
+import { mcpManager } from '../core/MCPManager.js';
+import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * ServerService provides a unified interface for server management operations.
+ * This layer handles business logic that's shared between the CLI and web interface.
+ */
+export class ServerService {
+  /**
+   * Lists available MCP servers based on the provided options
+   */
+  async listServerCategories(options: ServerCategoryListOptions = {}): Promise<MCPServerCategory[]> {
+    return mcpManager.listServerCategories(options);
+  }
+
+  /**
+   * Gets a server by name
+   */
+  async getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined> {
+    const serverCategories = await this.listServerCategories();
+    const serverCategory = serverCategories.find(s => s.name === categoryName);
+
+    // Start async check for requirement updates if one isn't already in progress
+    if (serverCategory && serverCategory.feedConfiguration && serverCategory.name) {
+      // Check if update is already in progress using the tracker
+      const shouldCheckForUpdates = await updateCheckTracker.startOperation(serverCategory.name);
+
+      if (shouldCheckForUpdates) {
+        this.checkRequirementsForUpdate(serverCategory).catch(error => {
+          // Ensure we mark the operation as complete on error
+          if (serverCategory.name) {
+            updateCheckTracker.endOperation(serverCategory.name)
+              .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
+          }
+          Logger.error(`Error checking requirements for updates: ${error.message}`);
+        });
+      } else {
+        Logger.debug(`Update check already in progress for ${serverCategory.name}, skipping`);
+      }
+    }
+
+    return serverCategory;
+  }
+
+  /**
+   * Check for updates to requirements for a server category
+   * @param serverCategory The server category to check
+   * @private
+   */
+  private async checkRequirementsForUpdate(serverCategory: MCPServerCategory): Promise<void> {
+    if (!serverCategory.name || !serverCategory.feedConfiguration?.requirements?.length) {
+      return;
+    }
+
+    try {
+      const { requirementService } = await import('../core/RequirementService.js');
+      const { configProvider } = await import('../core/ConfigurationProvider.js');
+
+      for (const requirement of serverCategory.feedConfiguration.requirements) {
+        if (requirement.version.includes('latest')) {
+          // Get current status if available
+          const currentStatus = serverCategory.installationStatus?.requirementsStatus[requirement.name];
+          if (!currentStatus) continue;
+
+          // Check for updates
+          const updatedStatus = await requirementService.checkRequirementForUpdates(requirement);
+
+          // If update information is found, update the configuration
+          if (updatedStatus.availableUpdate && serverCategory.name) {
+            await configProvider.updateRequirementStatus(
+              serverCategory.name,
+              requirement.name,
+              updatedStatus
+            );
+
+            // Also update the in-memory status for immediate use
+            if (serverCategory.installationStatus?.requirementsStatus) {
+              serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
+            }
+          }
+        }
+      }
+    } finally {
+      // Always mark the operation as complete when done, even if there was an error
+      if (serverCategory.name) {
+        await updateCheckTracker.endOperation(serverCategory.name)
+          .catch(error => console.error(`Failed to mark update check as complete: ${error.message}`));
+      }
+    }
+  }
+
+  /**
+   * Installs a specific mcp tool for a server.
+   * TODO: This might require enhancing MCPManager to handle category-specific installs.
+   */
+  async installMcpServer(
+    category: string,
+    serverName: string,
+    options: ServerInstallOptions = {} // Reuse ServerInstallOptions for env etc.
+  ): Promise<ServerOperationResult> {
+    Logger.debug(`Installing MCP server: ${JSON.stringify({ category, serverName, options })}`);
+    try {
+      const result = await mcpManager.installServer(category, serverName, options);
+      Logger.debug(`Installation result: ${JSON.stringify(result)}`);
+      return result;
+    } catch (error) {
+      Logger.error(`Failed to install MCP server: ${serverName}`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Installs a specific mcp tool for a server.
+   * TODO: This might require enhancing MCPManager to handle category-specific installs.
+   */
+  async uninstallMcpServer(
+    category: string,
+    serverName: string,
+    options: ServerUninstallOptions = {} // Reuse ServerInstallOptions for env etc.
+  ): Promise<ServerOperationResult> {
+    return mcpManager.uninstallServer(category, serverName, options);
+  }
+
+  /**
+   * Validates server names
+   */
+  async validateServerName(category: string, name: string): Promise<boolean> {
+    Logger.debug(`Validating server name: ${JSON.stringify({ category, name })}`);
+
+    // Check if category exists in feeds
+    const feedConfig = await mcpManager.getFeedConfiguration(category);
+    if (!feedConfig) {
+      Logger.debug(`Validation failed: Category "${category}" not found in feeds`);
+      return false;
+    }
+
+    // Check if server exists in the category's mcpServers
+    const serverExists = feedConfig.mcpServers.some(server => server.name === name);
+    if (!serverExists) {
+      Logger.debug(`Validation failed: Server "${name}" not found in category "${category}"`);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Formats success/error messages for operations
+   */
+  formatOperationResults(results: ServerOperationResult[]): {
+    success: boolean;
+    messages: string[];
+  } {
+    return {
+      success: results.every(r => r.success),
+      messages: results.map(r => r.message).filter((m): m is string => m !== undefined)
+    };
+  }
+
+  /**
+   * Syncs MCP server configurations from remote feed source
+   */
+  async syncFeeds(): Promise<void> {
+    return mcpManager.syncFeeds();
+  }
+}
+
+// Export a singleton instance
+export const serverService = new ServerService();

package/src/utils/UpdateCheckTracker.ts

@@ -0,0 +1,86 @@
+/**
+ * Utility class to track update check operations in progress
+ * Provides thread-safe access to check status with proper locking
+ */
+export class UpdateCheckTracker {
+    private static instance: UpdateCheckTracker;
+
+    // Map to track operations in progress (key -> inProgress)
+    private operationsInProgress: Map<string, boolean> = new Map();
+
+    // Lock for thread safety when checking/updating the in-progress map
+    private operationsLock: Promise<void> = Promise.resolve();
+
+    private constructor() { }
+
+    /**
+     * Get the singleton instance of the tracker
+     */
+    public static getInstance(): UpdateCheckTracker {
+        if (!UpdateCheckTracker.instance) {
+            UpdateCheckTracker.instance = new UpdateCheckTracker();
+        }
+        return UpdateCheckTracker.instance;
+    }
+
+    /**
+     * Execute an operation with a lock to ensure thread safety
+     * @param operation The operation to execute
+     * @returns The result of the operation
+     * @private
+     */
+    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
+        const current = this.operationsLock;
+        let resolve: () => void;
+        this.operationsLock = new Promise<void>(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        } finally {
+            resolve!();
+        }
+    }
+
+    /**
+     * Check if an operation can be started and mark it as in progress if so
+     * @param key The key to identify the operation
+     * @returns True if the operation can be started, false if already in progress
+     */
+    async startOperation(key: string): Promise<boolean> {
+        return await this.withLock(async () => {
+            if (!this.operationsInProgress.get(key)) {
+                this.operationsInProgress.set(key, true);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     * Mark an operation as complete
+     * @param key The key to identify the operation
+     */
+    async endOperation(key: string): Promise<void> {
+        try {
+            await this.withLock(async () => {
+                this.operationsInProgress.set(key, false);
+            });
+        } catch (error) {
+            console.error(`Failed to end operation for key: ${key}`, error);
+        }
+    }
+
+    /**
+     * Check if an operation is in progress
+     * @param key The key to identify the operation
+     * @returns True if the operation is in progress
+     */
+    async isOperationInProgress(key: string): Promise<boolean> {
+        return await this.withLock(async () => {
+            return !!this.operationsInProgress.get(key);
+        });
+    }
+}
+
+// Export a singleton instance
+export const updateCheckTracker = UpdateCheckTracker.getInstance();

package/src/utils/clientUtils.ts

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import extractZipModule from 'extract-zip';
+import { Logger } from './logger.js';
+
+/**
+ * Extract a zip file to a directory
+ * @param zipPath The path to the zip file
+ * @param options Extraction options
+ * @returns A promise that resolves when extraction is complete
+ */
+export async function extractZipFile(zipPath: string, options: { dir: string }): Promise<void> {
+    try {
+        // Try to use extract-zip if available
+        if (typeof extractZipModule === 'function') {
+            return await extractZipModule(zipPath, options);
+        }
+
+        // Fallback to Node.js built-in unzipper
+        const fs = require('fs');
+        const unzipper = require('unzipper');
+
+        await fs.promises.mkdir(options.dir, { recursive: true });
+
+        return new Promise<void>((resolve, reject) => {
+            fs.createReadStream(zipPath)
+                .pipe(unzipper.Extract({ path: options.dir }))
+                .on('close', resolve)
+                .on('error', reject);
+        });
+    } catch (error) {
+        console.error(`Error extracting zip: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to extract zip file ${zipPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+
+
+/**
+ * Resolves the path to an NPM module, replacing template variables
+ * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
+ * @param pathString The path string potentially containing template variables
+ * @returns The resolved path
+ */
+export function resolveNpmModulePath(pathString: string): string {
+    // If the path doesn't contain the ${NPMPATH} template, return it as is
+    if (!pathString.includes('${NPMPATH}')) {
+        return pathString;
+    }
+
+    // First try to get NVM-controlled npm path
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) {
+        try {
+            // Get current node version
+            const nodeVersion = execSync('node -v').toString().trim();
+
+            // Construct the path to npm in the NVM directory
+            const nvmNodePath = path.join(nvmHome, nodeVersion);
+            const resolvedPath = pathString.replace('${NPMPATH}', nvmNodePath);
+            // Check if this path exists
+            try {
+                fsSync.accessSync(resolvedPath);
+                return resolvedPath;
+            } catch (error) {
+                Logger.debug(`NVM controlled path doesn't exist: ${resolvedPath}, will try global npm`);
+                // Path doesn't exist, will fall back to global npm
+            }
+        } catch (error) {
+            Logger.debug(`Error determining Node version: ${error}, will use global npm`);
+            // Error getting node version, will fall back to global npm
+        }
+    }
+
+    // Fall back to global npm path
+    const globalNpmPath = execSync('npm root -g').toString().trim();
+    return pathString.replace('${NPMPATH}', globalNpmPath);
+}
+
+/**
+ * Reads a JSON file and parses its content
+ * @param filePath Path to the JSON file
+ * @param createIfNotExist Whether to create the file if it doesn't exist
+ * @returns The parsed JSON content
+ */
+export async function readJsonFile(filePath: string, createIfNotExist = false): Promise<any> {
+    try {
+        // Ensure directory exists
+        if (createIfNotExist) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+        }
+
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT' && createIfNotExist) {
+            return {};
+        }
+        throw error;
+    }
+}
+
+/**
+ * Writes content to a JSON file
+ * @param filePath Path to the JSON file
+ * @param content Content to write to the file
+ */
+export async function writeJsonFile(filePath: string, content: any): Promise<void> {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2), 'utf8');
+}

package/src/utils/feedUtils.ts

@@ -0,0 +1,31 @@
+import fs from 'fs/promises';
+import { Logger } from './logger.js';
+import { LOCAL_FEEDS_DIR } from '../core/constants.js';
+
+/**
+ * Checks if local feeds exist in the LOCAL_FEEDS_DIR
+ * Returns true if the directory exists and contains at least one .json file
+ */
+export async function hasLocalFeeds(): Promise<boolean> {
+  try {
+    Logger.debug('Checking for local feeds existence');
+    const feedsExist = await fs.access(LOCAL_FEEDS_DIR)
+      .then(() => true)
+      .catch(() => false);
+
+    if (!feedsExist) {
+      Logger.debug('Local feeds directory does not exist');
+      return false;
+    }
+
+    // Check if directory contains any json files
+    const files = await fs.readdir(LOCAL_FEEDS_DIR);
+    const hasJsonFiles = files.some(file => file.endsWith('.json'));
+    
+    Logger.debug(`Local feeds directory ${hasJsonFiles ? 'contains' : 'does not contain'} JSON files`);
+    return hasJsonFiles;
+  } catch (error) {
+    Logger.error('Error checking local feeds:', error);
+    return false;
+  }
+}

package/src/utils/githubAuth.ts

@@ -0,0 +1,142 @@
+import { isToolInstalled, installCLI } from './osUtils.js';
+import { exec, spawn } from 'child_process';
+import util from 'util';
+import { Logger } from './logger.js';
+
+const execAsync = util.promisify(exec);
+
+// Create a promisified version of spawn that returns a Promise
+const spawnAsync = (command: string, args: string[], options: any = {}) => {
+  return new Promise((resolve, reject) => {
+    const childProcess = spawn(command, args, options);
+    
+    childProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve(code);
+      } else {
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+    
+    childProcess.on('error', (err) => {
+      reject(err);
+    });
+  });
+};
+
+class GithubAuthError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GithubAuthError';
+  }
+}
+
+export async function checkGithubAuth(): Promise<void> {
+  Logger.debug('Starting GitHub authentication check');
+
+  try {
+    // Check if git is installed
+    if (!await isToolInstalled('git')) {
+      Logger.log('Installing required Git...');
+      await installCLI('git');
+      
+      // Verify git was installed correctly, with retry mechanism
+      if (!await isToolInstalled('git')) {
+        throw new Error('Failed to install Git. Please install it manually and try again.');
+      }
+      
+      Logger.debug('Git installed successfully and verified');
+    }
+
+    // Check if gh CLI is installed
+    if (!await isToolInstalled('gh')) {
+      Logger.log('Installing required GitHub CLI...');
+      await installCLI('gh');
+      
+      // Verify gh CLI was installed correctly, with retry mechanism
+      if (!await isToolInstalled('gh')) {
+        throw new Error('Failed to install GitHub CLI. Please install it manually and try again.');
+      }
+      
+      Logger.debug('GitHub CLI installed successfully and verified');
+    }
+  } catch (error) {
+    Logger.error('Error during tool installation:', error);
+    throw new Error(`Tool installation failed: ${(error as Error).message}`);
+  }
+
+  try {
+    Logger.debug('Checking GitHub authentication status');
+    // Check if user is authenticated
+    const { stdout: viewerData } = await execAsync('gh api user');
+    const viewer = JSON.parse(viewerData);
+    
+    Logger.debug({
+      action: 'github_auth_check',
+      username: viewer.login
+    });
+    
+    // Check if user is using company account (ends with _microsoft)
+    if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
+      const error = 'Error: You must be logged in with a Microsoft account (username should end with _microsoft). ' +
+        'Please run "gh auth logout" and then "gh auth login" with your Microsoft account. Current username: ' +
+        viewer.login;
+      Logger.error(error, {
+        username: viewer.login
+      });
+      throw new GithubAuthError(error);
+    }
+
+    Logger.debug('GitHub authentication verified successfully with Microsoft account');
+  } catch (error) {
+    if (error instanceof GithubAuthError) {
+      throw error;
+    }
+    
+    // If the error is due to not being authenticated
+    const errorMessage = (error as any)?.stderr || (error as Error).message;
+    if (errorMessage.includes('please run:  gh auth login') || errorMessage.includes('GH_TOKEN')) {
+      Logger.log('GitHub authentication required at the first run. Please login account end with _microsoft.');
+      
+      try {
+        // Use spawnAsync for interactive authentication
+        await spawnAsync('gh', ['auth', 'login', '--web', '--hostname', 'github.com', '--git-protocol', 'https'], {
+          stdio: 'inherit' // User sees & interacts directly with the process
+        });
+        
+        Logger.debug('GitHub authentication process completed');
+        
+        // Verify the authentication was successful
+        const { stdout: viewerData } = await execAsync('gh api user');
+        const viewer = JSON.parse(viewerData);
+        
+        // Check if user is using company account (ends with _microsoft)
+        if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
+          throw new GithubAuthError('You must be logged in with a Microsoft account (username should end with _microsoft).');
+        }
+        
+        Logger.debug(`Successfully authenticated as ${viewer.login}`);
+        return; // Auth successful, continue execution
+      } catch (loginError) {
+        Logger.error('Error during GitHub authentication process', loginError);
+        
+        // If the interactive login failed, provide manual instructions
+        const authInstructions =
+          '\nError: GitHub authentication required. Please follow these steps:\n\n' +
+          '1. Run this command:\n' +
+          '     gh auth login --web --hostname github.com --git-protocol https\n' +
+          '2. Choose Y when prompted authenticating Git with your GitHub credentials.\n' +
+          '3. Follow the prompts to login with your Microsoft account (username must end with _microsoft)\n' +
+          '4. Authorize ai-microsoft organization.\n' +
+          '5. After successful login, run imcp command again.\n\n';
+        
+        Logger.log(authInstructions);
+        throw new GithubAuthError('GitHub authentication required. Please login first and try again.');
+      }
+    } else {
+      const errorMessage = `Failed to verify GitHub authentication: ${(error as Error).message}`;
+      Logger.error(errorMessage, error);
+      throw new GithubAuthError(errorMessage);
+    }
+  }
+}