imcp 0.1.1 → 0.1.3

package/dist/services/ServerService.js

@@ -3,8 +3,6 @@ import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
 import { ServerSchemaProvider } 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));
 /**
  * ServerService provides a unified interface for server management operations.
@@ -23,80 +21,8 @@ export class ServerService {
     async getServerCategory(categoryName) {
         const serverCategories = await this.listServerCategories();
         const serverCategory = serverCategories.find(s => s.name === categoryName);
-        // Start async check for requirement updates if one isn't already in progress
-        if (serverCategory && serverCategory.feedConfiguration && serverCategory.name) {
-            // Check if update is already in progress using the tracker
-            const shouldCheckForUpdates = await updateCheckTracker.startOperation(serverCategory.name);
-            if (shouldCheckForUpdates) {
-                this.checkRequirementsForUpdate(serverCategory).catch(error => {
-                    // Ensure we mark the operation as complete on error
-                    if (serverCategory.name) {
-                        updateCheckTracker.endOperation(serverCategory.name)
-                            .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
-                    }
-                    Logger.error(`Error checking requirements for updates: ${error.message}`);
-                });
-            }
-            else {
-                Logger.debug(`Update check already in progress for ${serverCategory.name}, skipping`);
-            }
-        }
         return serverCategory;
     }
-    /**
-     * Check for updates to requirements for a server category
-     * @param serverCategory The server category to check
-     * @private
-     */
-    async checkRequirementsForUpdate(serverCategory) {
-        if (!serverCategory.name || !serverCategory.feedConfiguration?.requirements?.length) {
-            return;
-        }
-        try {
-            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
-                    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, currentStatus);
-                    // If update information is found, update the configuration
-                    if (updatedStatus.availableUpdate && serverCategory.name) {
-                        await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, updatedStatus);
-                        // Also update the in-memory status for immediate use
-                        if (serverCategory.installationStatus?.requirementsStatus) {
-                            serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
-                        }
-                    }
-                    currentStatus.lastCheckTime = new Date().toISOString();
-                    await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, currentStatus);
-                    if (serverCategory.installationStatus?.requirementsStatus) {
-                        serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
-                    }
-                }
-            }
-        }
-        finally {
-            // Always mark the operation as complete when done, even if there was an error
-            if (serverCategory.name) {
-                await updateCheckTracker.endOperation(serverCategory.name)
-                    .catch(error => console.error(`Failed to mark update check as complete: ${error.message}`));
-            }
-        }
-    }
     /**
      * Gets the schema for a specific server in a category
      */

package/dist/utils/adoUtils.js

@@ -104,11 +104,11 @@ targetDir // Optional target directory for npm
     if (!registry) {
         throw new Error('Azure DevOps artifacts registry configuration is required.');
     }
-    if (!registry.registryName || !registry.registryUrl) {
-        throw new Error('Registry name and URL are required for Azure DevOps artifacts.');
-    }
     Logger.debug(`Handling ADO artifact for requirement: ${requirement.name}, type: ${requirement.type}`);
     if (requirement.type === 'npm') {
+        if (!registry.registryName || !registry.registryUrl) {
+            throw new Error('Registry name and URL are required for NPM source in Azure DevOps artifacts.');
+        }
         const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
         await fs.mkdir(requirementDir, { recursive: true });
         Logger.debug(`Ensured directory for npm requirement: ${requirementDir}`);
@@ -130,6 +130,9 @@ targetDir // Optional target directory for npm
         }
     }
     else if (requirement.type === 'pip') {
+        if (!registry.registryUrl) {
+            throw new Error('Registry URL are required for PIP source in Azure DevOps artifacts.');
+        }
         await _installPipRequirements(pythonCommand);
         const packageName = requirement.version.toLowerCase().includes('latest')
             ? `${requirement.name} --upgrade`

package/dist/utils/logger.js

@@ -23,7 +23,7 @@ export class Logger {
     static fileLoggingEnabled = true;
     static logsDir = path.join(SETTINGS_DIR, 'logs');
     static isTestEnvironment = false;
-    static packageVersion = getPackageVersion();
+    static packageVersion = getPackageVersion().packageVersion;
     static setVerbose(isVerbose) {
         this.verbose = isVerbose;
     }

package/dist/utils/macroExpressionUtils.js

@@ -1,8 +1,5 @@
 import { Logger } from './logger.js';
-import { getPythonPackagePath, getSystemPythonPackageDirectory, GetBrowserPath } from './osUtils.js';
-import * as fsSync from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
+import { getPythonPackagePath, getSystemPythonPackageDirectory, getBrowserPath, getGlobalNPMPackagePath } from './osUtils.js';
 export const MACRO_EXPRESSIONS = {
     PYTHON_PACKAGE: '${PYTHON_PACKAGE}',
     NPMPATH: '${NPMPATH}',
@@ -57,26 +54,7 @@ export function resolveNpmModulePath(providedNpmPath) {
     if (providedNpmPath) {
         return `${providedNpmPath}/node_modules`;
     }
-    const nvmHome = process.env.NVM_HOME;
-    if (nvmHome) {
-        try {
-            const nodeVersion = execSync('node -v').toString().trim();
-            const nvmNodePath = path.join(nvmHome, nodeVersion);
-            // Check if this path exists
-            try {
-                fsSync.accessSync(nvmNodePath);
-                Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via NVM to: ${nvmNodePath}`);
-                return nvmNodePath;
-            }
-            catch (error) {
-                Logger.debug(`NVM controlled path doesn't exist: ${nvmNodePath}, will try global npm`);
-            }
-        }
-        catch (error) {
-            Logger.debug(`Error determining Node version for NVM: ${error}, will use global npm`);
-        }
-    }
-    const globalNpmPath = execSync('npm root -g').toString().trim();
+    const globalNpmPath = getGlobalNPMPackagePath();
     Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via global npm to: ${globalNpmPath}`);
     return globalNpmPath;
 }
@@ -104,7 +82,7 @@ export async function resolveNpmPathMacro(_finalConfig, options) {
 export async function resolveBrowserPathMacro() {
     Logger.debug(`Resolving ${MACRO_EXPRESSIONS.BROWSER_PATH}`);
     try {
-        const browserPath = await GetBrowserPath();
+        const browserPath = await getBrowserPath();
         Logger.debug(`Resolved ${MACRO_EXPRESSIONS.BROWSER_PATH} to: ${browserPath}`);
         return browserPath;
     }

package/dist/utils/osUtils.d.ts

@@ -14,4 +14,25 @@ export declare function isToolInstalled(tool: 'gh' | 'git', retries?: number): P
 export declare function openBrowser(url: string): Promise<void>;
 export declare function getPythonPackagePath(pythonExecutablePath: string): string;
 export declare function getSystemPythonPackageDirectory(): Promise<string | null>;
-export declare function GetBrowserPath(): Promise<string>;
+/**
+ * Get the system Python executable path.
+ * This function returns the absolute path to the system Python executable (e.g., /Users/penwa/miniconda3/envs/browser-use-temp/bin/python).
+ * It uses 'which python' (Unix) or 'where python' (Windows) to locate the executable.
+ * @returns {Promise<string | null>} The path to the Python executable, or null if not found.
+ */
+export declare function getSystemPythonExecutablePath(): Promise<string | null>;
+export declare function getBrowserPath(): Promise<string>;
+/**
+ * Get the global NPM path
+ * This function checks if NVM is installed and retrieves the global NPM path accordingly.
+ * If NVM is not installed, it falls back to the global NPM path.
+ * @returns The global NPM path as a string.
+ * @throws Error if the NPM path cannot be determined.
+ * */
+export declare function getGlobalNPMPackagePath(): string;
+/**
+ * Get the NPM executable path on the current platform (Windows, macOS, Linux).
+ * On Windows, uses PowerShell to locate npm. On macOS/Linux, uses 'which' to locate npm.
+ * Returns the directory containing the npm executable, or a platform-appropriate default if not found.
+ */
+export declare function getNpmExecutablePath(): Promise<string>;

package/dist/utils/osUtils.js

@@ -5,6 +5,8 @@ import util from 'util';
 import { Logger } from './logger.js';
 import fs from 'fs';
 import path from 'path';
+import { execSync } from 'child_process';
+import * as fsSync from 'fs';
 const execAsync = util.promisify(exec);
 export function getOSType() {
     const platform = os.platform();
@@ -394,7 +396,38 @@ export async function getSystemPythonPackageDirectory() {
         return null;
     }
 }
-export async function GetBrowserPath() {
+/**
+ * Get the system Python executable path.
+ * This function returns the absolute path to the system Python executable (e.g., /Users/penwa/miniconda3/envs/browser-use-temp/bin/python).
+ * It uses 'which python' (Unix) or 'where python' (Windows) to locate the executable.
+ * @returns {Promise<string | null>} The path to the Python executable, or null if not found.
+ */
+export async function getSystemPythonExecutablePath() {
+    const command = process.platform === 'win32' ? 'where python' : 'which python';
+    Logger.debug({
+        action: 'get_system_python_executable_path',
+        command
+    });
+    try {
+        const { stdout } = await execAsync(command);
+        // Use the first path found, trim whitespace
+        const pythonPath = stdout.split('\n')[0].trim();
+        if (pythonPath) {
+            Logger.debug({
+                action: 'get_system_python_executable_path_success',
+                pythonPath
+            });
+            return pythonPath;
+        }
+        Logger.debug('No Python executable found');
+        return null;
+    }
+    catch (error) {
+        Logger.debug(`Could not find system python using "${command}": ${error}`);
+        return null;
+    }
+}
+export async function getBrowserPath() {
     const osType = getOSType();
     Logger.debug({
         action: 'get_system_browser_path',
@@ -471,4 +504,62 @@ export async function GetBrowserPath() {
         throw error;
     }
 }
+/**
+ * Get the global NPM path
+ * This function checks if NVM is installed and retrieves the global NPM path accordingly.
+ * If NVM is not installed, it falls back to the global NPM path.
+ * @returns The global NPM path as a string.
+ * @throws Error if the NPM path cannot be determined.
+ * */
+export function getGlobalNPMPackagePath() {
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) {
+        try {
+            const nodeVersion = execSync('node -v').toString().trim();
+            const nvmNodePath = path.join(nvmHome, nodeVersion);
+            // Check if this path exists
+            try {
+                fsSync.accessSync(nvmNodePath);
+                return nvmNodePath;
+            }
+            catch (error) {
+                Logger.debug(`NVM controlled path doesn't exist: ${nvmNodePath}, will try global npm`);
+            }
+        }
+        catch (error) {
+            Logger.debug(`Error determining Node version for NVM: ${error}, will use global npm`);
+        }
+    }
+    const globalNpmPath = execSync('npm root -g').toString().trim();
+    return globalNpmPath;
+}
+/**
+ * Get the NPM executable path on the current platform (Windows, macOS, Linux).
+ * On Windows, uses PowerShell to locate npm. On macOS/Linux, uses 'which' to locate npm.
+ * Returns the directory containing the npm executable, or a platform-appropriate default if not found.
+ */
+export async function getNpmExecutablePath() {
+    try {
+        if (process.platform === 'win32') {
+            const { stdout } = await execAsync('powershell -Command "get-command npm | Select-Object -ExpandProperty Source"');
+            return stdout.trim().replace(/\\npm\.cmd$/, '');
+        }
+        else {
+            // macOS or Linux
+            const { stdout } = await execAsync('which npm');
+            // Remove the trailing '/npm' to get the directory
+            return stdout.trim().replace(/\/npm$/, '');
+        }
+    }
+    catch (error) {
+        Logger.error('Error getting npm path:', error);
+        if (process.platform === 'win32') {
+            return 'C:\\Program Files\\nodejs';
+        }
+        else {
+            // Common default for Unix systems
+            return '/usr/local/bin';
+        }
+    }
+}
 //# sourceMappingURL=osUtils.js.map

package/dist/utils/versionUtils.d.ts

@@ -1,4 +1,7 @@
-export declare function getPackageVersion(): string;
+export declare function getPackageVersion(): {
+    packageName: string;
+    packageVersion: string;
+};
 /**
  * Utility functions for version comparison and management
  */
@@ -11,3 +14,19 @@ export declare function getPackageVersion(): string;
  *           a positive number if v1 > v2, 0 if equal)
  */
 export declare function compareVersions(v1: string, v2: string): number;
+/**
+ * Check if there's a newer version of the package available
+ */
+export declare function checkForUpdates(): Promise<void>;
+/**
+ * Retrieves the application version and information about available updates.
+ * @returns A promise that resolves to an object containing the current packageVersion and any availableUpdates.
+ */
+export declare function getAppVersion(): Promise<{
+    name: string;
+    version: string;
+    availableUpdate?: {
+        latestVersion: string;
+        message: string;
+    };
+}>;

package/dist/utils/versionUtils.js

@@ -1,11 +1,19 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import axios from 'axios';
+import { Logger } from './logger.js'; // Assuming logger.js is in the same directory
+// ANSI color codes
+const COLORS = {
+    reset: '\x1b[0m',
+    yellow: '\x1b[33m'
+};
+const PACKAGE_NAME = 'imcp'; // Default package name
 export function getPackageVersion() {
     try {
         // First try npm environment variable (available during npm scripts)
         if (process.env.npm_package_version) {
-            return process.env.npm_package_version;
+            return { packageName: PACKAGE_NAME, packageVersion: process.env.npm_package_version };
         }
         // Fall back to reading package.json
         // Get directory name of current module
@@ -16,15 +24,15 @@ export function getPackageVersion() {
             const packagePath = path.join(currentDir, 'package.json');
             if (fs.existsSync(packagePath)) {
                 const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-                return packageJson.version;
+                return { packageName: PACKAGE_NAME, packageVersion: packageJson.version };
             }
             currentDir = path.join(currentDir, '..');
         }
-        return 'unknown';
+        return { packageName: PACKAGE_NAME, packageVersion: 'unknown' };
     }
     catch (error) {
         console.error('Failed to get package version:', error);
-        return 'unknown';
+        return { packageName: PACKAGE_NAME, packageVersion: 'unknown' };
     }
 }
 /**
@@ -52,4 +60,43 @@ export function compareVersions(v1, v2) {
     }
     return 0;
 }
+/**
+ * Check if there's a newer version of the package available
+ */
+export async function checkForUpdates() {
+    Logger.debug(`Checking for updates...`);
+    try {
+        const version = await getAppVersion();
+        if (version.availableUpdate) {
+            console.log(`${COLORS.yellow}Update available for ${version.name}: ${version.version} → ${version.availableUpdate.latestVersion}${COLORS.reset}`);
+            console.log(`${COLORS.yellow}Relaunch with \`npx -y ${version.name}@latest serve\` or update package with \`npm install -g ${version.name}@latest\`${COLORS.reset}`);
+        }
+    }
+    catch (error) {
+        // Log the npm error
+        Logger.debug(`Failed to check npm registry: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves the application version and information about available updates.
+ * @returns A promise that resolves to an object containing the current packageVersion and any availableUpdates.
+ */
+export async function getAppVersion() {
+    let availableUpdate = undefined;
+    const { packageName, packageVersion } = getPackageVersion();
+    // Check for updates from npm registry
+    try {
+        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 (compareVersions(latestVersion, packageVersion) > 0) {
+                availableUpdate = { latestVersion, message: `New version (${latestVersion}) is available. Relaunch with \`npx -y ${packageName}@latest serve\`` };
+            }
+        }
+    }
+    catch (npmError) {
+        Logger.debug(`Failed to fetch latest version from npm for ${packageName}: ${npmError instanceof Error ? npmError.message : String(npmError)}`);
+    }
+    return { name: packageName, version: packageVersion, availableUpdate };
+}
 //# sourceMappingURL=versionUtils.js.map