imcp 0.0.19 → 0.1.2

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

@@ -0,0 +1,15 @@
+export declare class TelemetryService {
+    private static client;
+    private static readonly instrumentationKey;
+    static trackEvent(name: string, properties?: {
+        [key: string]: string;
+    }): void;
+    static trackException(error: Error, properties?: {
+        [key: string]: string;
+    }): void;
+    static trackTrace(message: string, properties?: {
+        [key: string]: string;
+    }): void;
+    static trackMetric(name: string, value: number): void;
+    static flush(): Promise<void>;
+}

package/dist/services/TelemetryService.js

@@ -0,0 +1,54 @@
+import * as appInsights from 'applicationinsights';
+export class TelemetryService {
+    static client = null;
+    static 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, properties) {
+        if (!this.client) {
+            return;
+        }
+        this.client.trackEvent({ name, properties });
+    }
+    static trackException(error, properties) {
+        if (!this.client) {
+            return;
+        }
+        this.client.trackException({ exception: error, properties });
+    }
+    static trackTrace(message, properties) {
+        if (!this.client) {
+            return;
+        }
+        this.client.trackTrace({ message, properties });
+    }
+    static trackMetric(name, value) {
+        if (!this.client) {
+            return;
+        }
+        this.client.trackMetric({ name, value });
+    }
+    static flush() {
+        return new Promise((resolve) => {
+            if (!this.client) {
+                resolve();
+                return;
+            }
+            this.client.flush();
+            resolve();
+        });
+    }
+}
+//# sourceMappingURL=TelemetryService.js.map

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

@@ -2,6 +2,9 @@ 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';
 const execAsync = util.promisify(exec);
 // Create a promisified version of spawn that returns a Promise
 const spawnAsync = (command, args, options = {}) => {
@@ -63,6 +66,8 @@ export async function checkGithubAuth() {
             });
             throw new GithubAuthError(error);
         }
+        // After Microsoft account verification, persist user information
+        await persistUserInfo();
         Logger.debug('GitHub authentication verified successfully with Microsoft account');
     }
     catch (error) {
@@ -86,6 +91,8 @@ export async function checkGithubAuth() {
                 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
             }
@@ -110,4 +117,62 @@ export async function checkGithubAuth() {
         }
     }
 }
+/**
+ * Persists GitHub user information to the system-specific settings directory.
+ * Only performs persistence on non-Windows systems (Linux/macOS).
+ */
+async function persistUserInfo() {
+    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 = 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 = {
+            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
+    }
+}
 //# sourceMappingURL=githubAuth.js.map

package/dist/utils/logger.d.ts

@@ -1,7 +1,21 @@
+export declare 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 declare enum EventStatus {
+    SUCCESS = "success",
+    FAILED = "failed"
+}
 export declare class Logger {
     private static verbose;
     private static fileLoggingEnabled;
     private static logsDir;
+    private static isTestEnvironment;
+    private static packageVersion;
     static setVerbose(isVerbose: boolean): void;
     static setFileLogging(enabled: boolean): void;
     private static ensureLogsDirExists;
@@ -13,4 +27,6 @@ export declare class Logger {
     static warn(message: string): Promise<void>;
     static debug(message: string | object): Promise<void>;
     static error(message: string, error?: unknown): Promise<void>;
+    private static getUsername;
+    static trackEvent(eventType: EventType, dimensions: Record<string, any>): void;
 }

package/dist/utils/logger.js

@@ -1,10 +1,29 @@
 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 var EventType;
+(function (EventType) {
+    EventType["IMCP_SERVE"] = "imcp_serve";
+    EventType["SERVER_INSTALL"] = "server_install";
+    EventType["SERVER_UNINSTALL"] = "server_uninstall";
+    EventType["REQUIREMENT_UPDATE"] = "requirement_update";
+    EventType["FEED_ONBOARD"] = "feed_onboard";
+    EventType["FEED_VALIDATE"] = "feed_validate";
+})(EventType || (EventType = {}));
+export var EventStatus;
+(function (EventStatus) {
+    EventStatus["SUCCESS"] = "success";
+    EventStatus["FAILED"] = "failed";
+})(EventStatus || (EventStatus = {}));
 export class Logger {
     static verbose = false;
     static fileLoggingEnabled = true;
     static logsDir = path.join(SETTINGS_DIR, 'logs');
+    static isTestEnvironment = false;
+    static packageVersion = getPackageVersion().packageVersion;
     static setVerbose(isVerbose) {
         this.verbose = isVerbose;
     }
@@ -96,5 +115,63 @@ export class Logger {
         }
         await this.writeToLogFile('ERROR', logMessage);
     }
+    static getUsername() {
+        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, dimensions) {
+        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);
+        }
+    }
 }
 //# sourceMappingURL=logger.js.map

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,3 +1,7 @@
+export declare function getPackageVersion(): {
+    packageName: string;
+    packageVersion: string;
+};
 /**
  * Utility functions for version comparison and management
  */
@@ -10,3 +14,19 @@
  *           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;
+    };
+}>;