imcp 0.0.19 → 0.1.2

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/services/TelemetryService.ts

@@ -0,0 +1,59 @@
+import * as appInsights from 'applicationinsights';
+
+export class TelemetryService {
+  private static client: appInsights.TelemetryClient | null = null;
+  private static readonly instrumentationKey = 'InstrumentationKey=c5fc06c7-a96c-4d80-9aff-bc9c933db0d1';
+  
+  static {
+    // Initialize Application Insights
+    try {
+      const client = new appInsights.TelemetryClient(TelemetryService.instrumentationKey);
+      client.config.disableAppInsights = false;
+      client.config.maxBatchSize = 250;
+      client.context.tags[client.context.keys.cloudRole] = 'imcp';
+      TelemetryService.client = client;
+      console.log('Application Insights initialized');
+    } catch (error) {
+      console.error('Failed to initialize Application Insights:', error);
+    }
+  }
+
+  static trackEvent(name: string, properties?: { [key: string]: string }): void {
+    if (!this.client) {
+      return;
+    }
+    this.client.trackEvent({ name, properties });
+  }
+
+  static trackException(error: Error, properties?: { [key: string]: string }): void {
+    if (!this.client) {
+      return;
+    }
+    this.client.trackException({ exception: error, properties });
+  }
+
+  static trackTrace(message: string, properties?: { [key: string]: string }): void {
+    if (!this.client) {
+      return;
+    }
+    this.client.trackTrace({ message, properties });
+  }
+
+  static trackMetric(name: string, value: number): void {
+    if (!this.client) {
+      return;
+    }
+    this.client.trackMetric({ name, value });
+  }
+
+  static flush(): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.client) {
+        resolve();
+        return;
+      }
+      this.client.flush();
+      resolve();
+    });
+  }
+}

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/githubAuth.ts

@@ -2,6 +2,16 @@ import { isToolInstalled, installCLI } from './osUtils.js';
 import { exec, spawn } from 'child_process';
 import util from 'util';
 import { Logger } from './logger.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { USER_INFO_PATH } from '../core/metadatas/constants.js';
+
+interface UserInfo {
+  alias?: string;
+  name?: string;
+  email?: string;
+}
+
 
 const execAsync = util.promisify(exec);
 
@@ -74,6 +84,9 @@ export async function checkGithubAuth(): Promise<void> {
       throw new GithubAuthError(error);
     }
 
+    // After Microsoft account verification, persist user information
+    await persistUserInfo();
+
     Logger.debug('GitHub authentication verified successfully with Microsoft account');
   } catch (error) {
     if (error instanceof GithubAuthError) {
@@ -101,7 +114,9 @@ export async function checkGithubAuth(): Promise<void> {
         if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
           throw new GithubAuthError('You must be logged in with a Microsoft account (username should end with _microsoft).');
         }
-
+        
+        // After Microsoft account verification, persist user information
+        await persistUserInfo();
         Logger.debug(`Successfully authenticated as ${viewer.login}`);
         return; // Auth successful, continue execution
       } catch (loginError) {
@@ -126,4 +141,72 @@ export async function checkGithubAuth(): Promise<void> {
       throw new GithubAuthError(errorMessage);
     }
   }
+}
+
+/**
+ * Persists GitHub user information to the system-specific settings directory.
+ * Only performs persistence on non-Windows systems (Linux/macOS).
+ */
+async function persistUserInfo(): Promise<void> {
+  try {
+    Logger.debug('Starting user information persistence check');
+
+    // 1. Skip persistence on Windows systems
+    if (process.platform === 'win32') {
+      Logger.debug('Skipping user info persistence on Windows system');
+      return;
+    }
+
+    // 2. Check if file exists and has all required keys
+    try {
+      if (await fs.access(USER_INFO_PATH).then(() => true).catch(() => false)) {
+        const existingContent = await fs.readFile(USER_INFO_PATH, 'utf8');
+        const existingData: UserInfo = JSON.parse(existingContent);
+        
+        if (existingData.alias && existingData.name && existingData.email) {
+          Logger.debug('User info already exists with all required fields, skipping update');
+          return;
+        }
+      }
+    } catch (err) {
+      Logger.debug('No valid existing user info found, proceeding with persistence');
+    }
+
+    // Proceed with persistence since both checks passed
+    Logger.debug('Proceeding with user information persistence');
+
+    // Get user info from GitHub API
+    const { stdout: userDataStr } = await execAsync('gh api user');
+    const userData = JSON.parse(userDataStr);
+    const { login, name, email } = userData;
+
+    Logger.debug({ message: 'Retrieved user information from GitHub API', login, name, email });
+
+    // Check if login ends with _microsoft
+    if (!login.toLowerCase().endsWith('_microsoft')) {
+      Logger.log(`GitHub login "${login}" does not end with _microsoft, skipping user information persistence`);
+      return;
+    }
+
+    // Create directory if it doesn't exist
+    await fs.mkdir(path.dirname(USER_INFO_PATH), { recursive: true });
+    Logger.debug(`Ensuring directory exists for user info at ${USER_INFO_PATH}`);
+
+    // Extract alias from login (remove _microsoft suffix)
+    const alias = login.toLowerCase().replace(/_microsoft$/, '');
+
+    // Prepare user information
+    const userInfo: UserInfo = {
+      alias,
+      name,
+      email
+    };
+
+    // Write user information to file
+    await fs.writeFile(USER_INFO_PATH, JSON.stringify(userInfo, null, 2));
+    Logger.debug({ message: 'User information persisted successfully', path: USER_INFO_PATH, alias });
+  } catch (error) {
+    Logger.error('Failed to persist user information:', error);
+    // Don't throw - persistence failure shouldn't block auth flow
+  }
 }

package/src/utils/logger.ts

@@ -1,11 +1,30 @@
 import fs from 'fs';
 import path from 'path';
-import { SETTINGS_DIR } from '../core/metadatas/constants.js';
+import os from 'os';
+import { SETTINGS_DIR, USER_INFO_PATH } from '../core/metadatas/constants.js';
+import { TelemetryService } from '../services/TelemetryService.js';
+import { getPackageVersion } from './versionUtils.js';
+
+export enum EventType {
+  IMCP_SERVE = 'imcp_serve',
+  SERVER_INSTALL = 'server_install',
+  SERVER_UNINSTALL = 'server_uninstall',
+  REQUIREMENT_UPDATE = 'requirement_update',
+  FEED_ONBOARD = 'feed_onboard',
+  FEED_VALIDATE = 'feed_validate'
+}
+
+export enum EventStatus {
+  SUCCESS = 'success',
+  FAILED = 'failed'
+}
 
 export class Logger {
   private static verbose = false;
   private static fileLoggingEnabled = true;
   private static logsDir = path.join(SETTINGS_DIR, 'logs');
+  private static isTestEnvironment: boolean = false;
+  private static packageVersion = getPackageVersion().packageVersion;
 
   static setVerbose(isVerbose: boolean): void {
     this.verbose = isVerbose;
@@ -110,4 +129,67 @@ export class Logger {
 
     await this.writeToLogFile('ERROR', logMessage);
   }
+
+  private static getUsername(): string {
+    try {
+      // If on Windows, use os username directly
+      if (process.platform === 'win32') {
+        return os.userInfo().username;
+      }
+
+      // For Mac/Linux users
+      try {
+        const userInfoPath = USER_INFO_PATH;
+
+        if (fs.existsSync(userInfoPath)) {
+          const userInfo = JSON.parse(fs.readFileSync(userInfoPath, 'utf8'));
+          if (userInfo.alias) {
+            return userInfo.alias;
+          }
+        }
+      } catch (error) {
+        this.error('Failed to get user info from file', error);
+      }
+
+      // Fall back to os username if all else fails
+      return os.userInfo().username;
+    } catch (error) {
+      this.error('Failed to get username', error);
+      return 'unknown';
+    }
+  }
+
+  static trackEvent(eventType: EventType, dimensions: Record<string, any>): void {
+    try {
+      const username = this.getUsername();
+      
+      // Add username and package version to dimensions
+      const allDimensions = {
+        username,
+        packageVersion: this.packageVersion,
+        ...dimensions
+      };
+      
+      // Log to file
+      if (this.verbose) {
+        this.log(`Event: ${eventType}`);
+        this.log(JSON.stringify(allDimensions, null, 2));
+      }
+
+      // Skip AppInsights in test environment
+      if (Logger.isTestEnvironment) {
+        return;
+      }
+      
+      // Log to Application Insights
+      try {
+        TelemetryService.trackEvent(eventType, allDimensions);
+        TelemetryService.flush();
+      } catch (insightsError) {
+        this.error('Failed to track event in Application Insights', insightsError);
+      }
+    } catch (error) {
+      this.error('Failed to log event', error);
+    }
+  }
 }

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,3 +1,46 @@
+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(): { packageName: string, packageVersion: string } {
+  try {
+    // First try npm environment variable (available during npm scripts)
+    if (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 { packageName: PACKAGE_NAME, packageVersion: packageJson.version };
+      }
+      currentDir = path.join(currentDir, '..');
+    }
+
+    return { packageName: PACKAGE_NAME, packageVersion: 'unknown' };
+  } catch (error) {
+    console.error('Failed to get package version:', error);
+    return { packageName: PACKAGE_NAME, packageVersion: 'unknown' };
+  }
+}
+
 /**
  * Utility functions for version comparison and management
  */
@@ -11,19 +54,61 @@
  *           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}`);
+    }
+
+  } 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 0;
+  return { name: packageName, version: packageVersion, availableUpdate };
 }