imcp 0.0.12 → 0.0.14

package/src/core/constants.ts

@@ -10,7 +10,9 @@ import path from 'path';
  */
 export const GITHUB_REPO = {
   url: 'https://github.com/ai-microsoft/imcp-feed.git',
-  feedsPath: 'feeds'
+  repoName: 'ai-microsoft/imcp-feed',
+  feedsPath: 'feeds',
+  feedAssetsName: 'imcp-feeds-${latest}.zip',
 };
 
 /**
@@ -29,6 +31,7 @@ export const SETTINGS_DIR = (() => {
  * Local feeds directory path
  */
 export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
 
 const CODE_STRORAGE_DIR = (() => {
   switch (process.platform) {

package/src/core/installers/clients/ClientInstaller.ts

@@ -373,6 +373,7 @@ export class ClientInstaller {
 
             // Clone the base installation configuration to avoid modifying the original serverConfig
             const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
+            installConfig.mode = serverConfig.mode
             const pythonEnv = options.settings?.pythonEnv;
             let pythonDir: string | null = null;
 
@@ -606,46 +607,54 @@ export class ClientInstaller {
             settings.mcpServers = {};
         }
 
-        // Special handling for Windows when command is npx for Cline and MSROO clients
-        // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
-        const serverConfigForClient = { ...installConfig };
-        if (process.platform === 'win32' &&
-            serverConfigForClient.command === 'npx' &&
-            (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
-            // Update command to cmd
-            serverConfigForClient.command = 'cmd';
-
-            // Add /c and npx at the beginning of args
-            serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
-
-            // Add APPDATA environment variable pointing to npm directory
-            if (!serverConfigForClient.env) {
-                serverConfigForClient.env = {};
+        if (installConfig.mode === 'stdio') {
+            // Special handling for Windows when command is npx for Cline and MSROO clients
+            // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
+            const serverConfigForClient = { ...installConfig };
+            if (process.platform === 'win32' &&
+                serverConfigForClient.command === 'npx' &&
+                (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
+                // Update command to cmd
+                serverConfigForClient.command = 'cmd';
+
+                // Add /c and npx at the beginning of args
+                serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
+
+                // Add APPDATA environment variable pointing to npm directory
+                if (!serverConfigForClient.env) {
+                    serverConfigForClient.env = {};
+                }
+
+                // Dynamically get npm path and set APPDATA to it
+                const npmPath = await this.getNpmPath();
+                serverConfigForClient.env['APPDATA'] = npmPath;
+                Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
+            }
+            // Convert backslashes to forward slashes in args paths
+            if (serverConfigForClient.args) {
+                serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
+                    typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+                );
             }
 
-            // Dynamically get npm path and set APPDATA to it
-            const npmPath = await this.getNpmPath();
-            serverConfigForClient.env['APPDATA'] = npmPath;
-            Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
-        }
-        // Convert backslashes to forward slashes in args paths
-        if (serverConfigForClient.args) {
-            serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
-                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
-            );
+            // Add or update the server configuration
+            settings.mcpServers[serverName] = {
+                command: serverConfigForClient.command,
+                args: serverConfigForClient.args,
+                env: serverConfigForClient.env,
+                autoApprove: [],
+                disabled: false,
+                alwaysAllow: []
+            };
+            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
+        } else if (installConfig.mode === 'sse') {
+            // Handle SSE mode for Cline and MSRoo clients
+            settings.mcpServers[serverName] = {
+                type: 'sse',
+                url: installConfig.url
+            };
         }
 
-        // Add or update the server configuration
-        settings.mcpServers[serverName] = {
-            command: serverConfigForClient.command,
-            args: serverConfigForClient.args,
-            env: serverConfigForClient.env,
-            autoApprove: [],
-            disabled: false,
-            alwaysAllow: []
-        };
-        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
-
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
     }
@@ -673,20 +682,28 @@ export class ClientInstaller {
         // Use a copy to avoid modifying the passed installConfig directly
         const serverConfigForClient = { ...installConfig };
 
-        // Convert backslashes to forward slashes in args paths
-        if (serverConfigForClient.args) {
-            serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
-                typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
-            );
-        }
+        if (installConfig.mode === 'stdio') {
+            if (serverConfigForClient.args) {
+                serverConfigForClient.args = serverConfigForClient.args.map((arg: string) =>
+                    typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg
+                );
+            }
 
-        // Add or update the server configuration
-        settings.mcp.servers[serverName] = {
-            command: serverConfigForClient.command,
-            args: serverConfigForClient.args,
-            env: serverConfigForClient.env
-        };
-        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
+            // Add or update the server configuration
+            settings.mcp.servers[serverName] = {
+                command: serverConfigForClient.command,
+                args: serverConfigForClient.args,
+                env: serverConfigForClient.env
+            };
+            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
+        }
+        else if (installConfig.mode === 'sse') {
+            // Handle SSE mode for Github Copilot
+            settings.mcp.servers[serverName] = {
+                type: 'sse',
+                url: installConfig.url
+            };
+        }
 
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);

package/src/core/installers/requirements/PipInstaller.ts

@@ -25,7 +25,7 @@ export class PipInstaller extends BaseInstaller {
 
     supportCheckUpdates(): boolean {
         /// temporarily disabling update check for pip as not able to get which pip of python is being used
-        return false;
+        return true;
     }
     /**
      * Check if the Python package is already installed
@@ -47,7 +47,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed,
                 version: installedVersion,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
             };
         } catch (error) {
             return {
@@ -55,7 +56,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
             };
         }
     }
@@ -117,12 +119,14 @@ export class PipInstaller extends BaseInstaller {
                 }
             }
 
+            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
                 version: requirement.version,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         } catch (error) {
             return {
@@ -130,7 +134,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         }
     }

package/src/core/types.ts

@@ -17,6 +17,7 @@ export interface RequirementStatus {
   };
   lastCheckTime?: string;
   operationStatus?: OperationStatus;
+  pythonEnv?: string; // Store Python environment path for pip requirements
 }
 
 export interface MCPServerStatus {
@@ -98,6 +99,7 @@ export interface InstallationConfig {
   command: string;
   args: string[]; // Can use ${packageSource} as template variable for installation path
   env?: Record<string, EnvVariableConfig>; // Note the colon in property name
+  url?: string; // URL for sse mode
 }
 
 export interface DependencyConfig {
@@ -114,8 +116,10 @@ export interface DependencyConfig {
 export interface McpConfig {
   name: string;
   description: string;
-  mode: 'stdio' | 'http'; // Currently only stdio mode is supported in ai-coder-tools
+  mode: 'stdio' | 'sse'; // Currently only stdio mode is supported in ai-coder-tools
   dependencies?: DependencyConfig;
+  schemas?: string; // Path to the schema file
+  repository?: string; // Repository URL for the server
   installation: InstallationConfig;
 }
 
@@ -147,6 +151,7 @@ export interface FeedConfiguration {
   name: string;
   displayName: string;
   description: string;
+  repository?: string;
   requirements: RequirementConfig[];
   mcpServers: McpConfig[];
 }

package/src/services/ServerService.ts

@@ -1,6 +1,7 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
+import { getServerSchemaProvider, ServerSchema } from '../core/ServerSchemaProvider.js';
 import {
   MCPServerCategory,
   ServerInstallOptions,
@@ -123,6 +124,20 @@ export class ServerService {
     }
   }
 
+  /**
+   * Gets the schema for a specific server in a category
+   */
+  async getServerSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined> {
+    try {
+      const provider = await getServerSchemaProvider();
+      const serverMcpConfig = await mcpManager.getServerMcpConfig(categoryName, serverName);
+      return await provider.getSchema(categoryName, serverMcpConfig?.schemas || `${serverName}.json`);
+    } catch (error) {
+      Logger.error(`Failed to get schema for server ${serverName} in category ${categoryName}:`, error);
+      throw error;
+    }
+  }
+
   /**
    * Installs a specific mcp tool for a server.
    * TODO: This might require enhancing MCPManager to handle category-specific installs.

package/src/utils/githubAuth.ts

@@ -9,7 +9,7 @@ const execAsync = util.promisify(exec);
 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);
@@ -17,7 +17,7 @@ const spawnAsync = (command: string, args: string[], options: any = {}) => {
         reject(new Error(`Process exited with code ${code}`));
       }
     });
-    
+
     childProcess.on('error', (err) => {
       reject(err);
     });
@@ -35,29 +35,16 @@ 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) {
@@ -70,12 +57,12 @@ export async function checkGithubAuth(): Promise<void> {
     // 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). ' +
@@ -92,34 +79,34 @@ export async function checkGithubAuth(): Promise<void> {
     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' +
@@ -129,7 +116,7 @@ export async function checkGithubAuth(): Promise<void> {
           '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.');
       }

package/src/utils/githubUtils.ts

@@ -9,95 +9,132 @@ import { SETTINGS_DIR } from '../core/constants.js';
 
 const execAsync = util.promisify(exec);
 
+interface DownloadGithubReleaseResult {
+    version: string;
+    downloadPath: string;
+}
+
 /**
- * Helper to handle GitHub release downloads
- * @param requirement The requirement configuration
- * @param registry The GitHub release registry configuration
- * @returns The path to the downloaded file
+ * Downloads a GitHub release asset
+ * @param repo GitHub repository in format owner/repo
+ * @param version Version to download, can be "latest"
+ * @param assetsName Assets name pattern (optional, but either assetsName or assetName must be provided)
+ * @param assetName Asset name pattern (optional, but either assetsName or assetName must be provided)
+ * @param isFolder Whether to treat the downloaded asset as a folder (default: false)
+ * @param targetDirectory Target directory for downloads (default: SETTINGS_DIR/downloads)
+ * @returns Object containing version and download path
  */
-export async function handleGitHubRelease(
-    requirement: RequirementConfig,
-    registry: RegistryConfig['githubRelease']
-): Promise<{ resolvedVersion: string; resolvedPath: string }> {
-    if (!registry) {
-        throw new Error('GitHub release registry configuration is required');
+export async function downloadGithubRelease(
+    repo: string,
+    version: string,
+    assetsName?: string,
+    assetName?: string,
+    isFolder: boolean = false,
+    targetDirectory?: string
+): Promise<DownloadGithubReleaseResult> {
+    if (!repo) {
+        throw new Error('GitHub repository is required');
     }
 
-    const downloadsDir = path.join(SETTINGS_DIR, 'downloads');
-    await fs.mkdir(downloadsDir, { recursive: true });
-    const { repository, assetsName, assetName } = registry;
-
-    if (!repository) {
-        throw new Error('GitHub repository is required for GitHub release downloads');
+    if (!assetsName && !assetName) {
+        throw new Error('Either assetsName or assetName must be specified');
     }
 
-    let version = requirement.version;
-    let resolvedAssetName = assetName || '';
-    let resolvedAssetsName = assetsName || '';
+    const downloadsDir = targetDirectory || path.join(SETTINGS_DIR, 'downloads');
+    await fs.mkdir(downloadsDir, { recursive: true });
 
-    const { stdout } = await execAsync(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+    // Get latest version if needed
+    const { stdout } = await execAsync(`gh release view --repo ${repo} --json tagName --jq .tagName`);
     const latestTag = stdout.trim();
     let latestVersion = latestTag;
 
     const tagWithVPrefix = latestVersion.startsWith('v');
     if (tagWithVPrefix) latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
-    version = version.includes("latest") ? latestVersion : version;
+    const resolvedVersion = version.includes("latest") ? latestVersion : version;
+
+    // Resolve asset names
+    let resolvedAssetsName = '';
+    let resolvedAssetName = '';
     if (assetsName) {
-        resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+        resolvedAssetsName = assetsName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
     }
     if (assetName) {
-        resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+        resolvedAssetName = assetName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
     }
 
-    Logger.debug(`Downloading ${requirement.name} from GitHub release ${repository} version ${version}`);
-    Logger.debug(`ResolvedAssetsName} ${resolvedAssetName}; ResolvedAsetName} ${resolvedAssetName}`);
-    const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
-    Logger.debug(`Resolved pattern: ${pattern}`);
-
-    if (!pattern) {
-        throw new Error('Either assetsName or assetName must be specified for GitHub release downloads');
+    // Validate zip requirement for isFolder
+    const pattern = resolvedAssetsName || resolvedAssetName;
+    if (isFolder && (!resolvedAssetsName || !resolvedAssetsName.endsWith('.zip'))) {
+        throw new Error('When isFolder is true, assetsName must be provided and end with .zip');
     }
 
     // Download the release asset
     const downloadPath = path.join(downloadsDir, path.basename(pattern));
     if (!await fileExists(downloadPath)) {
-        await execAsync(`gh release download ${tagWithVPrefix ? `v${version}` : version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+        await execAsync(`gh release download ${tagWithVPrefix ? `v${resolvedVersion}` : resolvedVersion} --repo ${repo} --pattern "${pattern}" -O "${downloadPath}"`);
     }
 
-    // Handle zip file extraction if the downloaded file is a zip
-    if (downloadPath.endsWith('.zip')) {
+    // Handle zip extraction if needed
+    if (isFolder && downloadPath.endsWith('.zip')) {
         const extractDir = path.join(downloadsDir, path.basename(pattern, '.zip'));
         await fs.mkdir(extractDir, { recursive: true });
-
-        // Extract the zip file
         await extractZipFile(downloadPath, { dir: extractDir });
-        let assetPath = '';
+
         // If resolvedAssetName is specified, look for it in the extracted directory
         if (resolvedAssetName) {
-            assetPath = path.join(extractDir, resolvedAssetName);
+            const assetPath = path.join(extractDir, resolvedAssetName);
             try {
                 await fs.access(assetPath);
-                return { resolvedVersion: version, resolvedPath: assetPath };
+                return { version: resolvedVersion, downloadPath: assetPath };
             } catch (error) {
                 throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
             }
         }
-        else {
-            assetPath = path.join(extractDir, path.basename(pattern, '.zip') + '.tgz');
-        }
+        return { version: resolvedVersion, downloadPath: extractDir };
+    }
+
+    return { version: resolvedVersion, downloadPath };
+}
+
+/**
+ * Helper to handle GitHub release downloads
+ * @param requirement The requirement configuration
+ * @param registry The GitHub release registry configuration
+ * @returns The path to the downloaded file
+ */
+export async function handleGitHubRelease(
+    requirement: RequirementConfig,
+    registry: RegistryConfig['githubRelease']
+): Promise<{ resolvedVersion: string; resolvedPath: string }> {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration is required');
+    }
 
-        // If no specific asset is required, return the extraction directory
-        return { resolvedVersion: version, resolvedPath: extractDir };
+    const { repository, assetsName, assetName } = registry;
+    if (!repository) {
+        throw new Error('GitHub repository is required for GitHub release downloads');
     }
 
-    return { resolvedVersion: version, resolvedPath: downloadPath };
+    const isZipAsset = assetsName?.endsWith('.zip') || false;
+    const result = await downloadGithubRelease(
+        repository,
+        requirement.version,
+        assetsName,
+        assetName,
+        isZipAsset
+    );
+
+    return {
+        resolvedVersion: result.version,
+        resolvedPath: result.downloadPath
+    };
 }
 
 async function fileExists(filePath: string): Promise<boolean> {
     try {
-        await fs.access(filePath)
-        return true
+        await fs.access(filePath);
+        return true;
     } catch {
-        return false
+        return false;
     }
 }