imcp 0.1.1 → 0.1.3

package/src/services/ServerService.ts

@@ -13,8 +13,6 @@ import {
 } from '../core/metadatas/types.js';
 import { mcpManager } from './MCPManager.js';
 import { OperationStatus } from '../core/onboard/OnboardStatus.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));
 
@@ -36,97 +34,9 @@ export class ServerService {
   async getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined> {
     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
-   */
-  private async checkRequirementsForUpdate(serverCategory: MCPServerCategory): Promise<void> {
-    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/src/utils/adoUtils.ts

@@ -124,13 +124,12 @@ export async function handleArtifact(
     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}`);
@@ -153,6 +152,9 @@ export async function handleArtifact(
         }
 
     } 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')

package/src/utils/logger.ts

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

package/src/utils/macroExpressionUtils.ts

@@ -1,6 +1,7 @@
 import { Logger } from './logger.js';
-import { getPythonPackagePath, getSystemPythonPackageDirectory, GetBrowserPath } from './osUtils.js';
+import { getPythonPackagePath, getSystemPythonPackageDirectory, getBrowserPath, getGlobalNPMPackagePath } from './osUtils.js';
 import { ServerInstallOptions } from '../core/metadatas/types.js'; // Adjusted path
+import { SystemSettingsManager } from '../core/loaders/SystemSettingsManager.js';
 import * as fsSync from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
@@ -64,25 +65,7 @@ export function resolveNpmModulePath(providedNpmPath: string | undefined): strin
         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;
 }
@@ -111,7 +94,7 @@ export async function resolveNpmPathMacro(_finalConfig: any, options: ServerInst
 export async function resolveBrowserPathMacro(): Promise<string | undefined> {
     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;
     } catch (error) {

package/src/utils/osUtils.ts

@@ -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);
 
@@ -421,8 +423,40 @@ export async function getSystemPythonPackageDirectory(): Promise<string | null>
     return null;
   }
 }
+/**
+ * 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(): Promise<string | null> {
+  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(): Promise<string> {
+export async function getBrowserPath(): Promise<string> {
   const osType = getOSType();
   Logger.debug({
     action: 'get_system_browser_path',
@@ -503,4 +537,61 @@ export async function GetBrowserPath(): Promise<string> {
     Logger.error('Failed to get browser path', error);
     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(): string {
+  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(): Promise<string> {
+  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';
+    }
+  }
 }

package/src/utils/versionUtils.ts

@@ -1,33 +1,43 @@
 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
 
-export function getPackageVersion(): string {
+// ANSI color codes
+const COLORS = {
+  reset: '\x1b[0m',
+  yellow: '\x1b[33m'
+};
+
+const PACKAGE_NAME = 'imcp'; // Default package name
+
+export function getPackageVersion(): { packageName: string, packageVersion: string } {
   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
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    
+
     // Traverse up to find package.json (max 3 levels up)
     let currentDir = __dirname;
     for (let i = 0; i < 3; i++) {
       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' };
   }
 }
 
@@ -44,19 +54,61 @@ export function getPackageVersion(): string {
  *           a positive number if v1 > v2, 0 if equal)
  */
 export function compareVersions(v1: string, v2: string): number {
-    const v1Parts = v1.split('.').map(Number);
-    const v2Parts = v2.split('.').map(Number);
-
-    for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
-        const v1Part = i < v1Parts.length ? v1Parts[i] : 0;
-        const v2Part = i < v2Parts.length ? v2Parts[i] : 0;
-
-        if (v1Part !== v2Part) {
-            // This returns the actual difference, which is:
-            // negative if v1Part < v2Part, positive if v1Part > v2Part
-            return v1Part - v2Part;
-        }
+  const v1Parts = v1.split('.').map(Number);
+  const v2Parts = v2.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+    const v1Part = i < v1Parts.length ? v1Parts[i] : 0;
+    const v2Part = i < v2Parts.length ? v2Parts[i] : 0;
+
+    if (v1Part !== v2Part) {
+      // This returns the actual difference, which is:
+      // negative if v1Part < v2Part, positive if v1Part > v2Part
+      return v1Part - v2Part;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Check if there's a newer version of the package available
+ */
+export async function checkForUpdates(): Promise<void> {
+  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}`);
     }
 
-    return 0;
+  } 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(): Promise<{ name: string, version: string; availableUpdate?: { latestVersion: string; message: string} }> {
+  let availableUpdate: { latestVersion: string; message: string } | undefined = 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 };
 }