imcp 0.0.11 → 0.0.13

package/dist/core/ServerSchemaProvider.js

@@ -42,9 +42,9 @@ export class ServerSchemaProvider {
             }
         });
     }
-    async loadSchema(categoryName, serverName) {
+    async loadSchema(categoryName, schemaFileName) {
         try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
             const content = await fs.readFile(schemaPath, 'utf8');
             const schema = JSON.parse(content);
             return {
@@ -53,10 +53,10 @@ export class ServerSchemaProvider {
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for server ${serverName} in category ${categoryName}`);
+                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
                 return undefined;
             }
-            Logger.error(`Error loading schema for server ${serverName} in category ${categoryName}:`, error);
+            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
             throw error;
         }
     }
@@ -71,15 +71,15 @@ export class ServerSchemaProvider {
                 const serverSchemas = new Map();
                 for (const file of serverFiles) {
                     if (file.endsWith('.json')) {
-                        const serverName = path.basename(file, '.json');
                         try {
-                            const schema = await this.loadSchema(categoryDir.name, serverName);
+                            const schema = await this.loadSchema(categoryDir.name, file);
                             if (schema) {
-                                serverSchemas.set(serverName, schema);
+                                // Store with the complete file name for direct lookup
+                                serverSchemas.set(file, schema);
                             }
                         }
                         catch (error) {
-                            Logger.error(`Error loading schema for server ${serverName} in category ${categoryDir.name}:`, error);
+                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
                         }
                     }
                 }
@@ -89,13 +89,18 @@ export class ServerSchemaProvider {
             }
         }
     }
-    async getSchema(categoryName, serverName) {
+    async getSchema(categoryName, schemaFileName) {
         return await this.withLock(async () => {
             const categorySchemas = this.schemaMap.get(categoryName);
             if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
                 return undefined;
             }
-            return categorySchemas.get(serverName);
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
         });
     }
     async reloadSchemas() {

package/dist/core/constants.d.ts

@@ -6,7 +6,9 @@
  */
 export declare const GITHUB_REPO: {
     url: string;
+    repoName: string;
     feedsPath: string;
+    feedAssetsName: string;
 };
 /**
  * Local settings directory path based on OS
@@ -16,13 +18,24 @@ export declare const SETTINGS_DIR: string;
  * Local feeds directory path
  */
 export declare const LOCAL_FEEDS_DIR: string;
+export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
 /**
  * Supported client configurations.
  * Key: Client name (e.g., 'vscode')
  * Value: Client-specific settings or configuration details.
  * TODO: Define actual client settings structure.
  */
-export declare const SUPPORTED_CLIENTS: Record<string, any>;
+export declare const SUPPORTED_CLIENTS: Record<string, {
+    extension: {
+        extensionId: string;
+        leastVersion?: string;
+        repository?: string;
+        assetName?: string;
+        private?: boolean;
+    };
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}>;
 /**
  * List of supported client names.
  */

package/dist/core/constants.js

@@ -8,7 +8,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',
 };
 /**
  * Local settings directory path based on OS
@@ -25,6 +27,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) {
         case 'win32':

package/dist/core/installers/clients/ExtensionInstaller.js

@@ -128,6 +128,9 @@ export class ExtensionInstaller {
                 else {
                     // Install private extension from GitHub release using latest version
                     try {
+                        if (!repository || !assetName) {
+                            throw new Error(`Missing repository or assetName for private extension ${extensionId}`);
+                        }
                         const { resolvedPath } = await handleGitHubRelease({ name: extensionId, version: 'latest', type: 'extension' }, { repository, assetName });
                         success = await this.installPrivateExtension(resolvedPath, isInsiders);
                     }

package/dist/core/installers/requirements/PipInstaller.js

@@ -21,7 +21,7 @@ export class PipInstaller extends BaseInstaller {
     }
     supportCheckUpdates() {
         /// 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
@@ -41,7 +41,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) {
@@ -50,7 +51,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
             };
         }
     }
@@ -106,12 +108,14 @@ export class PipInstaller extends BaseInstaller {
                     throw new Error('Invalid registry configuration');
                 }
             }
+            // 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) {
@@ -120,7 +124,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/dist/core/types.d.ts

@@ -16,6 +16,7 @@ export interface RequirementStatus {
     };
     lastCheckTime?: string;
     operationStatus?: OperationStatus;
+    pythonEnv?: string;
 }
 export interface MCPServerStatus {
     installedStatus: Record<string, OperationStatus>;
@@ -73,6 +74,7 @@ export interface UpdateRequirementOptions {
 }
 export interface ServerUninstallOptions {
     removeData?: boolean;
+    targets?: string[];
 }
 export interface EnvVariableConfig {
     Required: boolean;
@@ -99,6 +101,8 @@ export interface McpConfig {
     description: string;
     mode: 'stdio' | 'http';
     dependencies?: DependencyConfig;
+    schemas?: string;
+    repository?: string;
     installation: InstallationConfig;
 }
 export interface RegistryConfig {
@@ -127,9 +131,14 @@ export interface FeedConfiguration {
     name: string;
     displayName: string;
     description: string;
+    repository?: string;
     requirements: RequirementConfig[];
     mcpServers: McpConfig[];
 }
+export interface ClientSettings {
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}
 export declare enum MCPEvent {
     SERVER_INSTALLED = "server:installed",
     SERVER_UNINSTALLED = "server:uninstalled",
@@ -143,6 +152,7 @@ export interface MCPEventData {
     };
     [MCPEvent.SERVER_UNINSTALLED]: {
         serverName: string;
+        targets?: string[];
     };
     [MCPEvent.SERVER_STARTED]: {
         server: MCPServerCategory;

package/dist/services/ServerService.d.ts

@@ -1,3 +1,4 @@
+import { ServerSchema } from '../core/ServerSchemaProvider.js';
 import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from '../core/types.js';
 /**
  * ServerService provides a unified interface for server management operations.
@@ -18,6 +19,10 @@ export declare class ServerService {
      * @private
      */
     private checkRequirementsForUpdate;
+    /**
+     * Gets the schema for a specific server in a category
+     */
+    getServerSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
     /**
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.
@@ -27,11 +32,17 @@ export declare class ServerService {
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.
      */
+    /**
+     * Uninstall MCP server from specified client targets
+     * @param category The server category
+     * @param serverName The server name to uninstall
+     * @param options Uninstall options including target clients and data removal flags
+     */
     uninstallMcpServer(category: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
     /**
      * Validates server names
      */
-    validateServerName(category: string, name: string): Promise<boolean>;
+    validateServerName(category: string, names: string | string[]): Promise<boolean>;
     /**
      * Formats success/error messages for operations
      */

package/dist/services/ServerService.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
+import { getServerSchemaProvider } from '../core/ServerSchemaProvider.js';
 import { mcpManager } from '../core/MCPManager.js';
 import { UPDATE_CHECK_INTERVAL_MS } from '../core/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
@@ -96,6 +97,20 @@ export class ServerService {
             }
         }
     }
+    /**
+     * Gets the schema for a specific server in a category
+     */
+    async getServerSchema(categoryName, serverName) {
+        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.
@@ -117,25 +132,40 @@ export class ServerService {
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.
      */
-    async uninstallMcpServer(category, serverName, options = {} // Reuse ServerInstallOptions for env etc.
-    ) {
-        return mcpManager.uninstallServer(category, serverName, options);
+    /**
+     * Uninstall MCP server from specified client targets
+     * @param category The server category
+     * @param serverName The server name to uninstall
+     * @param options Uninstall options including target clients and data removal flags
+     */
+    async uninstallMcpServer(category, serverName, options = {}) {
+        Logger.debug(`Uninstalling MCP server: ${JSON.stringify({ category, serverName, options })}`);
+        try {
+            const result = await mcpManager.uninstallServer(category, serverName, options);
+            Logger.debug(`Uninstallation result: ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            Logger.error(`Failed to uninstall MCP server: ${serverName}`, error);
+            throw error;
+        }
     }
     /**
      * Validates server names
      */
-    async validateServerName(category, name) {
-        Logger.debug(`Validating server name: ${JSON.stringify({ category, name })}`);
+    async validateServerName(category, names) {
+        const serverNames = Array.isArray(names) ? names : [names];
+        Logger.debug(`Validating server names: ${JSON.stringify({ category, names: serverNames })}`);
         // 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}"`);
+        // Check if all servers exist in the category's mcpServers
+        const invalidServers = serverNames.filter(name => !feedConfig.mcpServers.some(server => server.name === name));
+        if (invalidServers.length > 0) {
+            Logger.debug(`Validation failed: Servers "${invalidServers.join(', ')}" not found in category "${category}"`);
             return false;
         }
         return true;

package/dist/utils/githubAuth.js

@@ -29,16 +29,6 @@ class GithubAuthError extends Error {
 export async function checkGithubAuth() {
     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...');

package/dist/utils/githubUtils.d.ts

@@ -1,4 +1,19 @@
 import { RegistryConfig, RequirementConfig } from '../core/types.js';
+interface DownloadGithubReleaseResult {
+    version: string;
+    downloadPath: string;
+}
+/**
+ * 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 declare function downloadGithubRelease(repo: string, version: string, assetsName?: string, assetName?: string, isFolder?: boolean, targetDirectory?: string): Promise<DownloadGithubReleaseResult>;
 /**
  * Helper to handle GitHub release downloads
  * @param requirement The requirement configuration
@@ -9,3 +24,4 @@ export declare function handleGitHubRelease(requirement: RequirementConfig, regi
     resolvedVersion: string;
     resolvedPath: string;
 }>;
+export {};

package/dist/utils/githubUtils.js

@@ -3,78 +3,94 @@ import util from 'util';
 import fs from 'fs/promises';
 import path from 'path';
 import { extractZipFile } from './clientUtils.js';
-import { Logger } from './logger.js';
 import { SETTINGS_DIR } from '../core/constants.js';
 const execAsync = util.promisify(exec);
 /**
- * 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, registry) {
-    if (!registry) {
-        throw new Error('GitHub release registry configuration is required');
+export async function downloadGithubRelease(repo, version, assetsName, assetName, isFolder = false, targetDirectory) {
+    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 { stdout } = await execAsync(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+    const downloadsDir = targetDirectory || path.join(SETTINGS_DIR, 'downloads');
+    await fs.mkdir(downloadsDir, { recursive: true });
+    // 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');
-        }
-        // If no specific asset is required, return the extraction directory
-        return { resolvedVersion: version, resolvedPath: extractDir };
+        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, registry) {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration is required');
+    }
+    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) {
     try {

package/dist/utils/osUtils.js

@@ -256,7 +256,7 @@ export function getPythonPackagePath(pythonExecutablePath) {
                 const venvRoot = path.dirname(dir);
                 return path.join(venvRoot, 'Lib', 'site-packages');
             }
-            else if (dir.toLowerCase().includes('python')) {
+            else {
                 // System Python or Conda on Windows
                 return path.join(dir, 'Lib', 'site-packages');
             }