imcp 0.0.16 → 0.0.17

package/dist/services/RequirementService.d.ts

@@ -0,0 +1,40 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../core/metadatas/types.js';
+/**
+ * Service responsible for managing requirements installation and status
+ */
+export declare class RequirementService {
+    private static instance;
+    private installerFactory;
+    private constructor();
+    /**
+     * Get the singleton instance of RequirementService
+     * @returns The RequirementService instance
+     */
+    static getInstance(): RequirementService;
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @returns The installation status
+     */
+    checkRequirementStatus(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Check if updates are available for a requirement
+     * @param requirement The requirement to check for updates
+     * @returns Updated status with available updates information
+     */
+    checkRequirementForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
+    /**
+     * Update a requirement to a new version
+     * @param requirement The requirement configuration
+     * @param updateVersion The version to update to
+     * @returns The updated requirement status
+     */
+    updateRequirement(requirement: RequirementConfig, updateVersion: string, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Validate a requirement configuration
+     * @param requirement The requirement to validate
+     * @throws Error if the requirement is invalid
+     */
+    private validateRequirement;
+}
+export declare const requirementService: RequirementService;

package/dist/services/RequirementService.js

@@ -0,0 +1,110 @@
+import { createInstallerFactory } from '../core/installers/index.js';
+import { exec } from 'child_process';
+import util from 'util';
+/**
+ * Service responsible for managing requirements installation and status
+ */
+export class RequirementService {
+    static instance;
+    installerFactory = createInstallerFactory(util.promisify(exec));
+    constructor() { }
+    /**
+     * Get the singleton instance of RequirementService
+     * @returns The RequirementService instance
+     */
+    static getInstance() {
+        if (!RequirementService.instance) {
+            RequirementService.instance = new RequirementService();
+        }
+        return RequirementService.instance;
+    }
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @returns The installation status
+     */
+    async checkRequirementStatus(requirement, options) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Check the installation status
+        return await this.installerFactory.checkInstallation(requirement, options);
+    }
+    /**
+     * Check if updates are available for a requirement
+     * @param requirement The requirement to check for updates
+     * @returns Updated status with available updates information
+     */
+    async checkRequirementForUpdates(requirement, currentStatus) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Get current status
+        // Check for updates using the appropriate installer
+        const installer = this.installerFactory.getInstaller(requirement);
+        if (!installer || !installer.supportCheckUpdates()) {
+            return currentStatus;
+        }
+        // Pass pythonEnv from currentStatus if it exists for pip packages
+        const options = requirement.type === 'pip' && currentStatus.pythonEnv
+            ? { settings: { pythonEnv: currentStatus.pythonEnv } }
+            : undefined;
+        const status = await this.checkRequirementStatus(requirement, options);
+        return await installer.checkForUpdates(requirement, status);
+    }
+    /**
+     * Update a requirement to a new version
+     * @param requirement The requirement configuration
+     * @param updateVersion The version to update to
+     * @returns The updated requirement status
+     */
+    async updateRequirement(requirement, updateVersion, options) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Create an updated requirement with the new version
+        const updatedRequirement = {
+            ...requirement,
+            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
+        };
+        // Install the updated version
+        return await this.installerFactory.install(updatedRequirement, options);
+    }
+    /**
+     * Validate a requirement configuration
+     * @param requirement The requirement to validate
+     * @throws Error if the requirement is invalid
+     */
+    validateRequirement(requirement) {
+        // Ensure requirement has required fields
+        if (!requirement.name) {
+            throw new Error('Requirement name is required');
+        }
+        if (!requirement.type) {
+            throw new Error('Requirement type is required');
+        }
+        // For type 'other', registry must be specified
+        if (requirement.type === 'other' && !requirement.registry) {
+            throw new Error('Registry must be specified for requirement type "other"');
+        }
+        // Validate registry configuration if provided
+        if (requirement.registry) {
+            const { githubRelease, artifacts } = requirement.registry;
+            // Validate GitHub release configuration
+            if (githubRelease) {
+                if (!githubRelease.repository) {
+                    throw new Error('Repository is required for GitHub release registry');
+                }
+                if (!githubRelease.assetName) {
+                    throw new Error('Asset name is required for GitHub release registry');
+                }
+            }
+            // Validate artifacts registry configuration
+            if (artifacts) {
+                if (!artifacts.registryUrl) {
+                    throw new Error('Registry URL is required for artifacts registry');
+                }
+            }
+        }
+    }
+}
+// Export a singleton instance
+export const requirementService = RequirementService.getInstance();
+//# sourceMappingURL=RequirementService.js.map

package/dist/services/ServerService.d.ts

@@ -1,5 +1,5 @@
-import { ServerSchema } from '../core/ServerSchemaProvider.js';
-import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions, FeedConfiguration } from '../core/types.js';
+import { ServerSchema } from '../core/loaders/ServerSchemaProvider.js';
+import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions, FeedConfiguration } from '../core/metadatas/types.js';
 import { OperationStatus } from '../core/onboard/OnboardStatus.js';
 /**
  * ServerService provides a unified interface for server management operations.

package/dist/services/ServerService.js

@@ -1,9 +1,9 @@
 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 { getServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
+import { mcpManager } from './MCPManager.js';
+import { UPDATE_CHECK_INTERVAL_MS } from '../core/metadatas/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
@@ -53,8 +53,8 @@ export class ServerService {
             return;
         }
         try {
-            const { requirementService } = await import('../core/RequirementService.js');
-            const { configProvider } = await import('../core/ConfigurationProvider.js');
+            const { requirementService } = await import('./RequirementService.js');
+            const { configProvider } = await import('../core/loaders/ConfigurationProvider.js');
             for (const requirement of serverCategory.feedConfiguration.requirements) {
                 if (requirement.version.includes('latest')) {
                     // Get current status if available

package/dist/utils/adoUtils.d.ts

@@ -1,4 +1,4 @@
-import { RequirementConfig, RegistryConfig } from '../core/types.js';
+import { RequirementConfig, RegistryConfig } from '../core/metadatas/types.js';
 export interface AdoArtifactResult {
     type: 'npm' | 'pip';
     package: string;
@@ -25,5 +25,5 @@ targetDir?: string): Promise<AdoArtifactResult>;
  * @param options Optional server install options (e.g., for pythonCommand).
  * @returns The latest version string, or undefined if not found or an error occurs.
  */
-export declare function getArtifactLatestVersion(requirement: RequirementConfig, registry: RegistryConfig['artifacts'], options?: import('../core/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
+export declare function getArtifactLatestVersion(requirement: RequirementConfig, registry: RegistryConfig['artifacts'], options?: import('../core/metadatas/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
 targetDir?: string): Promise<string | undefined>;

package/dist/utils/adoUtils.js

@@ -1,4 +1,4 @@
-import { SETTINGS_DIR } from '../core/constants.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 import { Logger } from './logger.js';
 import { exec } from 'child_process';
 import util from 'util';

package/dist/utils/feedUtils.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import { Logger } from './logger.js';
-import { LOCAL_FEEDS_DIR } from '../core/constants.js';
+import { LOCAL_FEEDS_DIR } from '../core/metadatas/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

package/dist/utils/githubUtils.d.ts

@@ -1,4 +1,4 @@
-import { RegistryConfig, RequirementConfig } from '../core/types.js';
+import { RegistryConfig, RequirementConfig } from '../core/metadatas/types.js';
 /**
  * Get the latest version available for a GitHub repository
  * @param execPromise The promise-based exec function

package/dist/utils/githubUtils.js

@@ -3,7 +3,7 @@ import util from 'util';
 import fs from 'fs/promises';
 import path from 'path';
 import { extractZipFile } from './clientUtils.js';
-import { SETTINGS_DIR } from '../core/constants.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 const execAsync = util.promisify(exec);
 /**
  * Get the latest version available for a GitHub repository

package/dist/utils/logger.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { SETTINGS_DIR } from '../core/constants.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
 export class Logger {
     static verbose = false;
     static fileLoggingEnabled = true;

package/dist/utils/macroExpressionUtils.d.ts

@@ -1,4 +1,4 @@
-import { ServerInstallOptions } from '../core/types.js';
+import { ServerInstallOptions } from '../core/metadatas/types.js';
 export declare const MACRO_EXPRESSIONS: {
     readonly PYTHON_PACKAGE: "${PYTHON_PACKAGE}";
     readonly NPMPATH: "${NPMPATH}";

package/dist/utils/osUtils.d.ts

@@ -1,4 +1,4 @@
-import { OSType } from '../core/types.js';
+import { OSType } from '../core/metadatas/types.js';
 export declare function getOSType(): OSType;
 export declare function installCLI(tool: 'gh' | 'git'): Promise<void>;
 /**

package/dist/utils/osUtils.js

@@ -1,4 +1,4 @@
-import { OSType } from '../core/types.js';
+import { OSType } from '../core/metadatas/types.js';
 import os from 'os';
 import { exec } from 'child_process';
 import util from 'util';

package/dist/web/contract/serverContract.d.ts

@@ -1,4 +1,4 @@
-import { DependencyConfig, RegistryConfig, ServerInstallOptions } from '../../core/types.js';
+import { DependencyConfig, RegistryConfig, ServerInstallOptions } from '../../core/metadatas/types.js';
 export interface OnboardServerConfig {
     name: string;
     description: string;

package/dist/web/public/index.html

@@ -167,7 +167,7 @@
 
     <!-- Module scripts -->
     <script type="module">
-        import { fetchServerCategories, handleInstallServer, installRequirement, upgradeRequirement, uninstallTool } from './js/api.js';
+        import { fetchServerCategories, handleInstallServer, uninstallTool } from './js/api.js';
         import { setupSearch } from './js/serverCategoryList.js';
         import { showServerDetails } from './js/serverCategoryDetails.js';
         import { showInstallModal, closeModal, setupModalOutsideClick } from './js/modal.js';
@@ -182,8 +182,6 @@
                                                     // If other parts of the app call window.showOnboardModal, they'll need updating too.
         window.closeModal = closeModal;
         window.handleInstallServer = handleInstallServer;
-        window.installRequirement = installRequirement;
-        window.upgradeRequirement = upgradeRequirement;
         window.uninstallTool = uninstallTool;
 
         // Initialize

package/dist/web/public/js/api.js

@@ -42,7 +42,7 @@ async function fetchServerCategories() {
 async function handleInstallServer(event, categoryName, serverName, callback, options = {}) {
     event.preventDefault(); // Prevent page reload
     console.log("Handling install for:", categoryName, serverName);
-    
+
     // Get selected targets from the form if not provided in options
     const selectedTargets = options.targets || [...document.querySelectorAll('input[name="targets"]:checked')]
         .map(cb => cb.value);
@@ -71,7 +71,7 @@ async function handleInstallServer(event, categoryName, serverName, callback, op
         const response = await fetch(`/api/categories/${categoryName}/install`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({serverList: serverList})
+            body: JSON.stringify({ serverList: serverList })
         });
 
         if (!response.ok) {
@@ -90,82 +90,6 @@ async function handleInstallServer(event, categoryName, serverName, callback, op
     }
 }
 
-// Install requirement handler
-async function installRequirement(reqName) {
-    const detailsDiv = document.getElementById('serverCategoryDetails');
-    const serverTitle = detailsDiv.querySelector('h3');
-    if (!serverTitle) {
-        showToast('No server selected.', 'error');
-        return;
-    }
-    let serverName = serverTitle.textContent;
-    if (serverName.includes(' for ')) {
-        serverName = serverName.split(' for ')[0];
-    }
-    const confirmed = await showConfirm(`Do you want to install requirement '${reqName}' for ${serverName}?`);
-    if (!confirmed) {
-        return;
-    }
-    
-    const btn = Array.from(document.querySelectorAll('button')).find(b => b.textContent.trim() === 'Install' && b.onclick?.toString().includes(reqName));
-    if (btn) btn.disabled = true;
-    
-    try {
-        const response = await fetch(`/api/categories/${serverName}/install-requirement`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ requirementName: reqName })
-        });
-        if (!response.ok) {
-            const errorData = await response.text();
-            throw new Error(`Installation failed: ${errorData || response.statusText}`);
-        }
-        showToast(`Requirement '${reqName}' installation initiated successfully!`, 'success');
-        setTimeout(() => {
-            fetchServerCategories();
-            window.showServerDetails(serverName);
-        }, 1000);
-    } catch (error) {
-        console.error('Error installing requirement:', error);
-        showToast(`Error installing requirement: ${error.message}. Please check console.`, 'error');
-    } finally {
-        if (btn) btn.disabled = false;
-    }
-}
-
-// Handle upgrade/uninstall actions
-async function upgradeRequirement(name) {
-    const serverTitle = document.querySelector('#serverCategoryDetails h3')?.textContent;
-    if (!serverTitle) {
-        showToast('No server selected.', 'error');
-        return;
-    }
-
-    const upgradeConfirmed = await showConfirm(`Do you want to upgrade requirement '${name}' for ${serverTitle}?`);
-    if (!upgradeConfirmed) {
-        return;
-    }
-
-    try {
-        const response = await fetch(`/api/categories/${serverTitle}/upgrade-requirement`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ requirementName: name })
-        });
-
-        if (!response.ok) {
-            const errorData = await response.text();
-            throw new Error(`Upgrade failed: ${errorData || response.statusText}`);
-        }
-
-        showToast(`Requirement '${name}' upgrade initiated successfully!`, 'success');
-        fetchServerCategories();
-        window.showServerDetails(serverTitle);
-    } catch (error) {
-        console.error('Error upgrading requirement:', error);
-        showToast(`Error upgrading requirement: ${error.message}`, 'error');
-    }
-}
 
 async function uninstallTool(name) {
     const serverTitle = document.querySelector('#serverCategoryDetails h3')?.textContent;
@@ -204,7 +128,5 @@ export {
     allServerCategoriesData,
     fetchServerCategories,
     handleInstallServer,
-    installRequirement,
-    upgradeRequirement,
     uninstallTool
 };

package/dist/web/server.js

@@ -2,12 +2,12 @@ import express from 'express';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { OnboardingProcessStatus } from '../core/onboard/OnboardStatus.js';
-import { SUPPORTED_CLIENT_NAMES } from '../core/constants.js';
+import { SUPPORTED_CLIENT_NAMES } from '../core/metadatas/constants.js';
 import { serverService } from '../services/ServerService.js';
 import { feedOnboardService } from '../core/onboard/FeedOnboardService.js';
 import { openBrowser } from '../utils/osUtils.js';
 import { Logger } from '../utils/logger.js';
-import { configProvider } from '../core/ConfigurationProvider.js';
+import { configProvider } from '../core/loaders/ConfigurationProvider.js';
 import { onboardStatusManager } from '../core/onboard/OnboardStatusManager.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const app = express();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imcp",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "Node.js SDK for Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli/commands/install.ts

@@ -2,9 +2,9 @@ import { Command } from 'commander';
 import { serverService } from '../../services/ServerService.js';
 import { Logger } from '../../utils/logger.js';
 import { hasLocalFeeds } from '../../utils/feedUtils.js';
-import { ServerInstallOptions } from '../../core/types.js';
-import { SUPPORTED_CLIENT_NAMES } from '../../core/constants.js';
-import { mcpManager } from '../../core/MCPManager.js';
+import { ServerInstallOptions } from '../../core/metadatas/types.js';
+import { SUPPORTED_CLIENT_NAMES } from '../../core/metadatas/constants.js';
+import { mcpManager } from '../../services/MCPManager.js';
 
 export function createInstallCommand(): Command {
   return new Command('install')

package/src/cli/commands/list.ts

@@ -1,8 +1,8 @@
 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 { LOCAL_FEEDS_DIR } from '../../core/metadatas/constants.js';
+import { mcpManager } from '../../services/MCPManager.js';
 import { Logger } from '../../utils/logger.js';
 
 interface SimplifiedServer {

package/src/cli/commands/serve.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { startWebServer } from '../../web/server.js';
-import { mcpManager } from '../../core/MCPManager.js';
+import { mcpManager } from '../../services/MCPManager.js';
 import { checkGithubAuth } from '../../utils/githubAuth.js';
 import { Logger } from '../../utils/logger.js';
 
@@ -9,13 +9,14 @@ export function createServeCommand(): Command {
     .description('Serve local web interface')
     .option('-p, --port <port>', 'Port to run the server on', '3000')
     .option('-f, --feed-file <filepath>', 'Path to a custom feed configuration file')
+    .option('-s, --schemas-directory <path>', 'Path to a directory containing adhoc schema files')
     .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(options.feedFile);
+        await mcpManager.initialize(options.feedFile, options.schemasDirectory);
 
         const port = parseInt(options.port, 10);
         if (isNaN(port) || port < 1 || port > 65535) {

package/src/cli/index.ts

@@ -6,7 +6,7 @@ import { createListCommand } from './commands/list.js';
 import { createInstallCommand } from './commands/install.js';
 import { createUninstallCommand } from './commands/uninstall.js';
 import { createPullCommand } from './commands/pull.js';
-import { mcpManager } from '../core/MCPManager.js';
+import { mcpManager } from '../services/MCPManager.js';
 import { Logger } from '../utils/logger.js';
 import axios from 'axios';
 import path from 'path';

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

@@ -1,11 +1,14 @@
 import { Logger } from '../../../utils/logger.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { isCommandAvailable } from '../../../utils/osUtils.js';
+import { ExtensionInstaller } from './ExtensionInstaller.js';
+import { SUPPORTED_CLIENTS } from '../../metadatas/constants.js';
 import {
     OperationStatus,
     McpConfig,
     ServerInstallOptions,
-} from '../../types.js';
+} from '../../metadatas/types.js';
 import {
     MACRO_EXPRESSIONS,
     MacroResolverFunctions
@@ -17,6 +20,7 @@ const execAsync = promisify(exec);
  * Base class for client installers with shared functionality
  */
 export abstract class BaseClientInstaller {
+    protected abstract readonly clientName: string;
     /**
      * Generate a unique operation ID for tracking installations
      */
@@ -189,8 +193,135 @@ export abstract class BaseClientInstaller {
     }
 
     /**
-     * Abstract methods that must be implemented by client-specific installers
+     * Checks if VS Code or VS Code Insiders is installed and installs the client extension.
+     * @param operationId The operation ID for tracking.
+     * @returns An OperationStatus object if checks fail or installation fails, otherwise undefined.
+     */
+    protected async checkVSCodeAndInstallExtension(operationId: string): Promise<OperationStatus | undefined> {
+        // Check if VS Code or VS Code Insiders is installed
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+        if (!isVSCodeInstalled && !isVSCodeInsidersInstalled) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: 'Failed to install as neither VS Code nor VS Code Insiders are installed on this system. Please run `code` or `code-insiders` to make sure they are installed. Relaunch imcp after installation.',
+                operationId
+            };
+        }
+
+        // Install extension
+        const extensionResult = await ExtensionInstaller.installExtension(this.clientName);
+        if (!extensionResult) {
+            Logger.debug(`Failed to install ${this.clientName} extension`);
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Failed to install ${this.clientName} extension`,
+                operationId
+            };
+        }
+        return undefined;
+    }
+
+    /**
+     * Update VS Code settings for both VS Code and VS Code Insiders if installed
+     * @param serverName The name of the server to configure
+     * @param installConfig The installation configuration
+     * @returns Array of results indicating success/failure for each VS Code variant
+     */
+    protected async updateVSCodeSettings(serverName: string, installConfig: any): Promise<Array<{ success: boolean; path: string; error?: string }>> {
+        const results: Array<{ success: boolean; path: string; error?: string }> = [];
+        const isVSCodeInstalled = await isCommandAvailable('code');
+        const isVSCodeInsidersInstalled = await isCommandAvailable('code-insiders');
+
+        // Update settings for VS Code if installed
+        if (isVSCodeInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+
+        // Update settings for VS Code Insiders if installed
+        if (isVSCodeInsidersInstalled) {
+            try {
+                const settingPath = SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath;
+                await this.setupClientSettings(settingPath, serverName, installConfig);
+                results.push({ success: true, path: settingPath });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    path: SUPPORTED_CLIENTS[this.clientName].codeInsiderSettingPath,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Install the client
+     * @param serverConfig Server configuration
+     * @param options Installation options including environment variables and arguments
+     */
+    async install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus> {
+        const operationId = this.generateOperationId();
+
+        try {
+            const vsCodeCheckResult = await this.checkVSCodeAndInstallExtension(operationId);
+            if (vsCodeCheckResult) {
+                return vsCodeCheckResult;
+            }
+
+            const installConfig = await this.setupInstallConfig(serverConfig, options);
+            if (serverConfig.mode) {
+                installConfig.mode = serverConfig.mode;
+            }
+
+            // Update VS Code settings
+            const results = await this.updateVSCodeSettings(serverConfig.name, installConfig);
+
+            // Determine overall success
+            const anySuccess = results.some(r => r.success);
+            const successPaths = results.filter(r => r.success).map(r => r.path);
+            const errors = results.filter(r => !r.success).map(r => r.error);
+
+            return {
+                status: anySuccess ? 'completed' : 'failed',
+                type: 'install',
+                target: 'server',
+                message: anySuccess
+                    ? `Successfully installed ${this.clientName} client. Updated settings in: ${successPaths.join(', ')}`
+                    : `Failed to install ${this.clientName} client. Errors: ${errors.join('; ')}`,
+                operationId,
+                error: anySuccess ? undefined : errors.join('; ')
+            };
+        } catch (error) {
+            return {
+                status: 'failed',
+                type: 'install',
+                target: 'server',
+                message: `Unexpected error installing ${this.clientName} client: ${error instanceof Error ? error.message : String(error)}`,
+                operationId,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+
+    /**
+     * Abstract method that must be implemented by client-specific installers
      */
-    abstract install(serverConfig: McpConfig, options: ServerInstallOptions): Promise<OperationStatus>;
     abstract setupClientSettings(settingPath: string, serverName: string, installConfig: any): Promise<void>;
 }