imcp 0.0.1 → 0.0.2

package/dist/cli/commands/install.js

@@ -19,7 +19,6 @@ Examples:
     `)
         .requiredOption('--category <category>', 'Server category')
         .requiredOption('--name <name>', 'Server name to install')
-        .option('--force', 'Force installation even if server already exists', false)
         .option('--clients <clients>', 'Target clients (semicolon separated). Supported values: Cline, MSRooCode, GithubCopilot. If not specified, installs for all clients')
         .option('--envs <envs>', 'Environment variables (semicolon separated key=value pairs)')
         .action(async (options) => {
@@ -30,15 +29,16 @@ Examples:
                 Logger.log('Local feeds not found, syncing from remote...');
                 await serverService.syncFeeds();
             }
-            const { category, name, verbose, force, clients, envs } = options;
-            Logger.debug(`Install options: ${JSON.stringify({ category, name, force, verbose, clients, envs })}`);
+            const { category, name, verbose, clients, envs } = options;
+            Logger.debug(`Install options: ${JSON.stringify({ category, name, verbose, clients, envs })}`);
             const serverName = name.trim();
             Logger.debug(`Server name: ${serverName}`);
             if (!await serverService.validateServerName(category, serverName)) {
-                Logger.error('Invalid server name or category provided', {
-                    category,
-                    serverName
-                });
+                Logger.error('Invalid server name or category provided.\n' +
+                    'This could be because:\n' +
+                    '  1. The server name or category is misspelled\n' +
+                    '  2. Your local feeds are outdated\n\n' +
+                    'Try running "imcp pull" to update your local feeds from remote.', { category, serverName });
                 process.exit(1);
             }
             // Parse and validate clients
@@ -77,7 +77,7 @@ Examples:
             }
             Logger.log(`Installing server: ${serverName}`);
             const installOptions = {
-                force: options.force,
+                force: false,
                 ...(parsedClients?.length && { targetClients: parsedClients }),
                 ...(Object.keys(parsedEnvs).length > 0 && { env: parsedEnvs })
             };

package/dist/cli/index.js

@@ -10,6 +10,7 @@ import axios from 'axios';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import { compareVersions } from '../utils/versionUtils.js';
 // Custom error interface for Commander.js errors
 // ANSI color codes
 const COLORS = {
@@ -23,7 +24,6 @@ async function main() {
     program
         .name('imcp')
         .description('IMCP (Install Model Context Protocol) CLI')
-        .version('0.0.1')
         .option('--verbose', 'Show detailed logs for all commands');
     // Parse global options first
     program.parseOptions(process.argv);
@@ -85,7 +85,8 @@ async function checkForUpdates() {
             const npmResponse = await axios.get(`https://registry.npmjs.org/${packageName}`);
             if (npmResponse.data && npmResponse.data['dist-tags'] && npmResponse.data['dist-tags'].latest) {
                 const latestVersion = npmResponse.data['dist-tags'].latest;
-                if (latestVersion && latestVersion !== currentVersion) {
+                // Compare versions properly to ensure we're only notifying for newer versions
+                if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
                     console.log(`${COLORS.yellow}Update available for ${packageName}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
                     console.log(`${COLORS.yellow}Run \`npm install -g ${packageName}@latest\` to update${COLORS.reset}`);
                 }

package/dist/core/ConfigurationProvider.d.ts

@@ -9,9 +9,11 @@ export declare class ConfigurationProvider {
     static getInstance(): ConfigurationProvider;
     private withLock;
     initialize(): Promise<void>;
+    private loadClientMCPSettings;
     private saveConfiguration;
     getServerCategories(): Promise<MCPServerCategory[]>;
     getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
+    getClientMcpSettings(): Promise<Record<string, Record<string, any>> | undefined>;
     getFeedConfiguration(categoryName: string): Promise<FeedConfiguration | undefined>;
     getInstallationStatus(categoryName: string): Promise<InstallationStatus | undefined>;
     getServerStatus(categoryName: string, serverName: string): Promise<MCPServerStatus | undefined>;

package/dist/core/ConfigurationProvider.js

@@ -3,9 +3,10 @@ import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR } from './constants.js';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from './constants.js';
 import { Logger } from '../utils/logger.js';
 import { checkGithubAuth } from '../utils/githubAuth.js';
+import { readJsonFile } from '../utils/clientUtils.js';
 const execAsync = promisify(exec);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export class ConfigurationProvider {
@@ -20,6 +21,7 @@ export class ConfigurationProvider {
         this.configuration = {
             localServerCategories: [],
             feeds: {},
+            clientMCPSettings: {}
         };
         this.tempDir = path.join(LOCAL_FEEDS_DIR, '../temp');
     }
@@ -49,6 +51,7 @@ export class ConfigurationProvider {
                 const config = JSON.parse(await fs.readFile(this.configPath, 'utf8'));
                 this.configuration = config;
                 await this.loadFeedsIntoConfiguration(); // Load feeds into configuration
+                await this.loadClientMCPSettings(); // Load MCP settings for each client
             }
             catch (error) {
                 if (error.code !== 'ENOENT') {
@@ -59,6 +62,45 @@ export class ConfigurationProvider {
             }
         });
     }
+    async loadClientMCPSettings() {
+        try {
+            Logger.debug('Starting to load MCP client settings...');
+            const settings = {};
+            for (const [clientName, clientSettings] of Object.entries(SUPPORTED_CLIENTS)) {
+                const settingPath = process.env.CODE_INSIDERS
+                    ? clientSettings.codeInsiderSettingPath
+                    : clientSettings.codeSettingPath;
+                try {
+                    let content = await readJsonFile(settingPath, true);
+                    if (clientName === 'GithubCopilot') {
+                        // Initialize the mcp section if it doesn't exist
+                        if (!content.mcp) {
+                            content = {
+                                servers: {},
+                                inputs: []
+                            };
+                        }
+                        else {
+                            content = content.mcp;
+                        }
+                    }
+                    settings[clientName] = content;
+                    Logger.debug(`Successfully loaded MCP settings for ${clientName}`);
+                }
+                catch (error) {
+                    Logger.debug(`Warning: Could not load MCP settings for client ${clientName}: ${error instanceof Error ? error.message : String(error)}`);
+                    settings[clientName] = {};
+                }
+            }
+            this.configuration.clientMCPSettings = settings;
+            await this.saveConfiguration();
+            Logger.debug('Saved MCP client settings to configuration');
+        }
+        catch (error) {
+            Logger.error('Error loading client MCP settings:', error);
+            throw error;
+        }
+    }
     async saveConfiguration() {
         const configDir = path.dirname(this.configPath);
         await fs.mkdir(configDir, { recursive: true });
@@ -74,6 +116,11 @@ export class ConfigurationProvider {
             return this.configuration.localServerCategories.find(s => s.name === categoryName);
         });
     }
+    async getClientMcpSettings() {
+        return await this.withLock(async () => {
+            return this.configuration.clientMCPSettings;
+        });
+    }
     async getFeedConfiguration(categoryName) {
         return await this.withLock(async () => {
             return this.configuration.feeds[categoryName];
@@ -325,8 +372,7 @@ export class ConfigurationProvider {
                                 type: req.type,
                                 installed: false,
                                 version: req.version,
-                                error: undefined,
-                                updateInfo: null
+                                error: undefined
                             };
                         }
                     }

package/dist/core/InstallationService.d.ts

@@ -14,4 +14,12 @@ export declare class InstallationService {
      * @returns A result object indicating success or failure.
      */
     install(categoryName: string, serverName: string, options: ServerInstallOptions): Promise<ServerOperationResult>;
+    /**
+     * Process requirement updates specified in serverInstallOptions
+     * All updates are processed in parallel for maximum efficiency
+     * @param categoryName The category name
+     * @param serverName The server name
+     * @param requirements The requirements to update
+     */
+    private processRequirementUpdates;
 }

package/dist/core/InstallationService.js

@@ -29,6 +29,15 @@ export class InstallationService {
     async install(categoryName, serverName, options) {
         const configProvider = ConfigurationProvider.getInstance();
         const clients = options.targetClients || Object.keys(SUPPORTED_CLIENTS);
+        // Process updates for requirements if specified in options
+        // Fire off requirement updates in the background without awaiting completion
+        if (options.requirements && options.requirements.length > 0) {
+            // Start the process but don't await it - it will run in the background
+            this.processRequirementUpdates(categoryName, serverName, options.requirements)
+                .catch(error => {
+                console.error(`Error in background requirement updates: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }
         // Check if server is already ready
         const isReady = await configProvider.isServerReady(categoryName, serverName, clients);
         if (isReady) {
@@ -138,6 +147,114 @@ export class InstallationService {
         // Each client installer will check requirements before actual installation
         return await clientInstaller.install(options);
     }
+    /**
+     * Process requirement updates specified in serverInstallOptions
+     * All updates are processed in parallel for maximum efficiency
+     * @param categoryName The category name
+     * @param serverName The server name
+     * @param requirements The requirements to update
+     */
+    async processRequirementUpdates(categoryName, serverName, requirements) {
+        // Use UpdateCheckTracker to prevent concurrent updates
+        const updateCheckTracker = await import('../utils/UpdateCheckTracker.js').then(m => m.updateCheckTracker);
+        const operationKey = `requirement-updates-${categoryName}-${serverName}`;
+        // Check if there's already an update operation in progress for this server
+        const canProceed = await updateCheckTracker.startOperation(operationKey);
+        if (!canProceed) {
+            console.log(`Requirement updates for ${categoryName}/${serverName} already in progress, skipping`);
+            return;
+        }
+        try {
+            const configProvider = ConfigurationProvider.getInstance();
+            const feedConfig = await configProvider.getFeedConfiguration(categoryName);
+            if (!feedConfig) {
+                console.error(`Feed configuration not found for category: ${categoryName}`);
+                return;
+            }
+            // Import the RequirementService
+            const { requirementService } = await import('./RequirementService.js');
+            // Create an array of promises to update all requirements in parallel
+            const updatePromises = requirements.map(async (reqToUpdate) => {
+                try {
+                    // Find the full requirement config
+                    const reqConfig = feedConfig.requirements?.find((r) => r.name === reqToUpdate.name);
+                    if (!reqConfig) {
+                        console.error(`Requirement configuration not found for: ${reqToUpdate.name}`);
+                        return;
+                    }
+                    // Get current status
+                    const currentStatus = await configProvider.getRequirementStatus(categoryName, reqToUpdate.name);
+                    if (!currentStatus) {
+                        console.error(`No current status found for requirement: ${reqToUpdate.name}`);
+                        return;
+                    }
+                    // Update requirement status to indicate update in progress
+                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                        ...currentStatus,
+                        name: reqToUpdate.name, // Ensure name is included
+                        type: currentStatus.type || 'unknown', // Ensure type is included
+                        installed: currentStatus.installed || false, // Ensure installed is included
+                        inProgress: true,
+                        operationStatus: {
+                            status: 'in-progress',
+                            type: 'update',
+                            target: 'requirement',
+                            message: `Updating ${reqToUpdate.name} from ${currentStatus.version || 'unknown'} to ${reqToUpdate.version}`
+                        }
+                    });
+                    // Create updated requirement config with new version
+                    const updatedReqConfig = {
+                        ...reqConfig,
+                        version: reqToUpdate.version
+                    };
+                    // Update the requirement
+                    const updatedStatus = await requirementService.updateRequirement(updatedReqConfig, reqToUpdate.version);
+                    // Update requirement status
+                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                        ...updatedStatus,
+                        name: reqToUpdate.name, // Ensure name is always included
+                        type: updatedStatus.type || currentStatus.type || 'unknown', // Ensure type is included
+                        installed: updatedStatus.installed, // This should be defined from updatedStatus
+                        inProgress: false,
+                        operationStatus: {
+                            status: updatedStatus.installed ? 'completed' : 'failed',
+                            type: 'update',
+                            target: 'requirement',
+                            message: updatedStatus.installed
+                                ? `Successfully updated ${reqToUpdate.name} to version ${reqToUpdate.version}`
+                                : `Failed to update ${reqToUpdate.name} to version ${reqToUpdate.version}`
+                        },
+                        // Clear availableUpdate if update was successful
+                        availableUpdate: updatedStatus.installed ? undefined : currentStatus.availableUpdate
+                    });
+                    console.log(`Requirement ${reqToUpdate.name} updated to version ${reqToUpdate.version}`);
+                }
+                catch (error) {
+                    console.error(`Error updating requirement ${reqToUpdate.name}:`, error);
+                    // Update status to indicate failure
+                    await configProvider.updateRequirementStatus(categoryName, reqToUpdate.name, {
+                        name: reqToUpdate.name,
+                        type: 'unknown',
+                        installed: false,
+                        inProgress: false,
+                        error: error instanceof Error ? error.message : String(error),
+                        operationStatus: {
+                            status: 'failed',
+                            type: 'update',
+                            target: 'requirement',
+                            message: `Error updating requirement: ${error instanceof Error ? error.message : String(error)}`
+                        }
+                    });
+                }
+            });
+            // Wait for all updates to complete in parallel
+            await Promise.all(updatePromises);
+        }
+        finally {
+            // Always release the lock when done, even if there was an error
+            await updateCheckTracker.endOperation(operationKey);
+        }
+    }
 }
 // Export a singleton instance (optional)
 // export const installationService = new InstallationService();

package/dist/core/MCPManager.d.ts

@@ -10,6 +10,7 @@ export declare class MCPManager extends EventEmitter {
     getFeedConfiguration(categoryName: string): Promise<import("./types.js").FeedConfiguration | undefined>;
     installServer(categoryName: string, serverName: string, requestOptions?: ServerInstallOptions): Promise<ServerOperationResult>;
     uninstallServer(categoryName: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
+    updateRequirement(categoryName: string, serverName: string, requirementName: string, updateVersion: string): Promise<ServerOperationResult>;
     emit<E extends MCPEvent>(event: E, data: MCPEventData[E]): boolean;
     on<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this;
     off<E extends MCPEvent>(event: E, listener: (data: MCPEventData[E]) => void): this;

package/dist/core/MCPManager.js

@@ -82,6 +82,48 @@ export class MCPManager extends EventEmitter {
             };
         }
     }
+    async updateRequirement(categoryName, serverName, requirementName, updateVersion) {
+        try {
+            const { requirementService } = await import('./RequirementService.js');
+            const serverCategory = await this.configProvider.getServerCategory(categoryName);
+            if (!serverCategory) {
+                return {
+                    success: false,
+                    message: `Server category ${categoryName} is not onboarded`,
+                };
+            }
+            if (!serverCategory.feedConfiguration) {
+                return {
+                    success: false,
+                    message: `Server category ${categoryName} has no feed configuration`,
+                };
+            }
+            // Find the requirement
+            const requirement = serverCategory.feedConfiguration.requirements.find(r => r.name === requirementName);
+            if (!requirement) {
+                return {
+                    success: false,
+                    message: `Requirement ${requirementName} not found in category ${categoryName}`,
+                };
+            }
+            // Update the requirement using requirementService
+            const updatedStatus = await requirementService.updateRequirement(requirement, updateVersion);
+            // Update the status in configuration
+            await this.configProvider.updateRequirementStatus(categoryName, requirementName, updatedStatus);
+            return {
+                success: true,
+                message: `Successfully updated ${requirementName} to version ${updateVersion}`,
+            };
+        }
+        catch (error) {
+            console.error(`Error updating requirement ${requirementName}:`, error);
+            return {
+                success: false,
+                message: `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }
     // Type-safe event emitter methods
     emit(event, data) {
         return super.emit(event, data);

package/dist/core/RequirementService.d.ts

@@ -29,6 +29,13 @@ export declare class RequirementService {
      * @returns Updated status with available updates information
      */
     checkRequirementForUpdates(requirement: RequirementConfig): 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): Promise<RequirementStatus>;
     /**
      * Install multiple requirements
      * @param requirements The requirements to install

package/dist/core/RequirementService.js

@@ -61,6 +61,23 @@ export class RequirementService {
         }
         return 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) {
+        // Validate requirement
+        this.validateRequirement(requirement);
+        // Create an updated requirement with the new version
+        const updatedRequirement = {
+            ...requirement,
+            version: updateVersion
+        };
+        // Install the updated version
+        return await this.installRequirement(updatedRequirement);
+    }
     /**
      * Install multiple requirements
      * @param requirements The requirements to install

package/dist/core/constants.d.ts

@@ -27,3 +27,8 @@ export declare const SUPPORTED_CLIENTS: Record<string, any>;
  * List of supported client names.
  */
 export declare const SUPPORTED_CLIENT_NAMES: string[];
+/**
+ * Minimum time between requirement update checks (in milliseconds)
+ * 10 minutes = 10 * 60 * 1000 = 600000 ms
+ */
+export declare const UPDATE_CHECK_INTERVAL_MS: number;

package/dist/core/constants.js

@@ -34,14 +34,14 @@ const CODE_INSIDER_STRORAGE_DIR = path.join(os.homedir(), 'AppData', 'Roaming',
  * TODO: Define actual client settings structure.
  */
 export const SUPPORTED_CLIENTS = {
-    'Cline': {
-        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-    },
     'MSRooCode': {
         codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
         codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-clinev', 'settings', 'cline_mcp_settings.json'),
     },
+    'Cline': {
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+    },
     'GithubCopilot': {
         codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
         codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
@@ -52,4 +52,9 @@ export const SUPPORTED_CLIENTS = {
  * List of supported client names.
  */
 export const SUPPORTED_CLIENT_NAMES = Object.keys(SUPPORTED_CLIENTS);
+/**
+ * Minimum time between requirement update checks (in milliseconds)
+ * 10 minutes = 10 * 60 * 1000 = 600000 ms
+ */
+export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
 //# sourceMappingURL=constants.js.map

package/dist/core/installers/BaseInstaller.js

@@ -2,6 +2,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { SETTINGS_DIR } from '../constants.js';
 import { extractZipFile } from '../../utils/clientUtils.js';
+import { Logger } from '../../utils/logger.js';
 /**
  * Abstract base class with common functionality for all requirement installers
  */
@@ -51,12 +52,17 @@ export class BaseInstaller {
                     ...currentStatus,
                     availableUpdate: {
                         version: latestVersion,
-                        message: `Update available: ${currentStatus.version} → ${latestVersion}`,
-                        checkTime: new Date().toISOString()
-                    }
+                        message: `Update available: ${currentStatus.version} → ${latestVersion}`
+                    },
+                    lastCheckTime: new Date().toISOString()
+                };
+            }
+            else {
+                return {
+                    ...currentStatus,
+                    lastCheckTime: new Date().toISOString()
                 };
             }
-            return currentStatus;
         }
         catch (error) {
             // Don't update status on error, just log it
@@ -88,31 +94,42 @@ export class BaseInstaller {
         let version = requirement.version;
         let resolvedAssetName = assetName || '';
         let resolvedAssetsName = assetsName || '';
+        const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+        const latestTag = stdout.trim();
         // Handle latest version detection
         if (version.includes('${latest}') || version === 'latest') {
-            const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
-            const latestTag = stdout.trim();
             let latestVersion = latestTag;
             if (latestVersion.startsWith('v') && version.startsWith('v')) {
                 latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
                 // Replace ${latest} in version and asset names
                 version = version.replace('${latest}', latestVersion);
                 if (assetsName) {
-                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion);
+                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion).replace('${version}', version);
                 }
                 if (assetName) {
-                    resolvedAssetName = assetName.replace('${latest}', latestVersion);
+                    resolvedAssetName = assetName.replace('${latest}', latestVersion).replace('${version}', version);
                 }
             }
         }
+        else {
+            if (assetsName) {
+                resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+            }
+            if (assetName) {
+                resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+            }
+            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');
         }
         // Download the release asset
         const downloadPath = path.join(this.downloadsDir, path.basename(pattern));
         if (!await this.fileExists(downloadPath)) {
-            await this.execPromise(`gh release download ${version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+            await this.execPromise(`gh release download ${version.startsWith('v') ? version : `v${version}`} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
         }
         // Handle zip file extraction if the downloaded file is a zip
         if (downloadPath.endsWith('.zip')) {

package/dist/core/installers/GeneralInstaller.js

@@ -66,11 +66,6 @@ export class GeneralInstaller extends BaseInstaller {
                 installed: true,
                 version: requirement.version,
                 inProgress: false,
-                // Store installation path in a way that it can be retrieved later if needed
-                updateInfo: {
-                    available: false,
-                    installPath
-                }
             };
         }
         catch (error) {

package/dist/core/installers/NpmInstaller.js

@@ -1,4 +1,5 @@
 import { BaseInstaller } from './BaseInstaller.js';
+import { compareVersions } from '../../utils/versionUtils.js';
 /**
  * Installer implementation for NPM packages
  */
@@ -47,7 +48,7 @@ export class NpmInstaller extends BaseInstaller {
     async install(requirement) {
         try {
             const status = await this.checkInstallation(requirement);
-            if (status.installed) {
+            if (status.installed && status.version && compareVersions(status.version, requirement.version) === 0) {
                 return status;
             }
             let resolvedVersion = requirement.version;

package/dist/core/types.d.ts

@@ -13,14 +13,9 @@ export interface RequirementStatus {
     availableUpdate?: {
         version: string;
         message: string;
-        checkTime: string;
     };
+    lastCheckTime?: string;
     operationStatus?: OperationStatus;
-    updateInfo?: {
-        available: boolean;
-        latestVersion?: string;
-        [key: string]: any;
-    } | null;
 }
 export interface MCPServerStatus {
     installedStatus: Record<string, OperationStatus>;
@@ -62,11 +57,17 @@ export interface ServerOperationResult {
 export interface MCPConfiguration {
     localServerCategories: MCPServerCategory[];
     feeds: Record<string, FeedConfiguration>;
+    clientMCPSettings?: Record<string, Record<string, any>>;
 }
 export interface ServerInstallOptions {
     force?: boolean;
     env?: Record<string, string>;
     targetClients?: string[];
+    requirements?: RequirementConfig[];
+}
+export interface UpdateRequirementOptions {
+    requirementName: string;
+    updateVersion: string;
 }
 export interface ServerUninstallOptions {
     removeData?: boolean;

package/dist/services/ServerService.js

@@ -2,6 +2,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
 import { mcpManager } from '../core/MCPManager.js';
+import { UPDATE_CHECK_INTERVAL_MS } from '../core/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
@@ -59,6 +60,16 @@ export class ServerService {
                     const currentStatus = serverCategory.installationStatus?.requirementsStatus[requirement.name];
                     if (!currentStatus)
                         continue;
+                    // Skip update check if last check was less than UPDATE_CHECK_INTERVAL_MS ago
+                    if (currentStatus.lastCheckTime) {
+                        const lastCheckTime = new Date(currentStatus.lastCheckTime);
+                        const currentTime = new Date();
+                        const timeSinceLastCheck = currentTime.getTime() - lastCheckTime.getTime();
+                        if (timeSinceLastCheck < UPDATE_CHECK_INTERVAL_MS) {
+                            Logger.debug(`Skipping update check for ${requirement.name}, last check was ${Math.round(timeSinceLastCheck / 1000)} seconds ago`);
+                            continue;
+                        }
+                    }
                     // Check for updates
                     const updatedStatus = await requirementService.checkRequirementForUpdates(requirement);
                     // If update information is found, update the configuration
@@ -69,6 +80,11 @@ export class ServerService {
                             serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
                         }
                     }
+                    currentStatus.lastCheckTime = new Date().toISOString();
+                    await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, currentStatus);
+                    if (serverCategory.installationStatus?.requirementsStatus) {
+                        serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
+                    }
                 }
             }
         }

package/dist/utils/versionUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utility functions for version comparison and management
+ */
+/**
+ * Compare two semantic version strings
+ * @param v1 First version
+ * @param v2 Second version
+ * @returns -1 if v1 < v2, 0 if v1 = v2, 1 if v1 > v2
+ *          (or more specifically, a negative number if v1 < v2,
+ *           a positive number if v1 > v2, 0 if equal)
+ */
+export declare function compareVersions(v1: string, v2: string): number;