imcp 0.0.18 → 0.1.1

package/src/core/onboard/OnboardProcessor.ts

@@ -127,32 +127,34 @@ export class OnboardProcessor {
             // Create a mutable copy of mcpServers to update schema paths
             const updatedMcpServers = [];
             for (const server of config.mcpServers) {
-                if (!serverList.includes(server.name)) continue;
                 let updatedServer = { ...server }; // Shallow copy server config
-                if (updatedServer.schemas && typeof updatedServer.schemas === 'string' && updatedServer.schemas.trim() !== '') {
-                    const originalSchemaPath = updatedServer.schemas;
-                    const serverName = updatedServer.name;
-                    const newSchemaFileName = `${serverName}.json`;
-
-                    // Schemas are now directly under categorySchemasPath
-                    const newSchemaPathInRepo = path.join(categorySchemasPath, newSchemaFileName);
-
-                    try {
-                        // Read content from the original schema path
-                        const schemaContent = await fs.readFile(originalSchemaPath, 'utf-8');
-                        // Write content to the new schema file in the repo
-                        await fs.writeFile(newSchemaPathInRepo, schemaContent);
-                        Logger.debug(`[${onboardingId}] Copied schema for server '${serverName}' from '${originalSchemaPath}' to '${newSchemaPathInRepo}'`);
-
-                        // Update the schemas property to the new filename, as per instruction "rename schemas in McpServer as serverName].json"
-                        updatedServer.schemas = newSchemaFileName;
-                    } catch (schemaError) {
-                        const errorMsg = `Error processing schema for server '${serverName}' (source: ${originalSchemaPath}): ${schemaError instanceof Error ? schemaError.message : String(schemaError)}`;
-                        Logger.error(`[${onboardingId}] ${errorMsg}`);
-                        // Propagate the error to fail the onboarding step
-                        throw new Error(errorMsg);
+                if (serverList.includes(server.name)) {
+                    if (updatedServer.schemas && typeof updatedServer.schemas === 'string' && updatedServer.schemas.trim() !== '') {
+                        const originalSchemaPath = updatedServer.schemas;
+                        const serverName = updatedServer.name;
+                        const newSchemaFileName = `${serverName}.json`;
+
+                        // Schemas are now directly under categorySchemasPath
+                        const newSchemaPathInRepo = path.join(categorySchemasPath, newSchemaFileName);
+
+                        try {
+                            // Read content from the original schema path
+                            const schemaContent = await fs.readFile(originalSchemaPath, 'utf-8');
+                            // Write content to the new schema file in the repo
+                            await fs.writeFile(newSchemaPathInRepo, schemaContent);
+                            Logger.debug(`[${onboardingId}] Copied schema for server '${serverName}' from '${originalSchemaPath}' to '${newSchemaPathInRepo}'`);
+
+                            // Update the schemas property to the new filename, as per instruction "rename schemas in McpServer as serverName].json"
+                            updatedServer.schemas = newSchemaFileName;
+                        } catch (schemaError) {
+                            const errorMsg = `Error processing schema for server '${serverName}' (source: ${originalSchemaPath}): ${schemaError instanceof Error ? schemaError.message : String(schemaError)}`;
+                            Logger.error(`[${onboardingId}] ${errorMsg}`);
+                            // Propagate the error to fail the onboarding step
+                            throw new Error(errorMsg);
+                        }
                     }
                 }
+
                 updatedMcpServers.push(updatedServer);
             }
 

package/src/services/MCPManager.ts

@@ -13,8 +13,8 @@ import {
   InstallationStatus,
   FeedConfiguration,
 } from '../core/metadatas/types.js';
-import { OperationStatus } from '../core/onboard/OnboardStatus.js';
-import { Logger } from '../utils/logger.js';
+import { OnboardingProcessStatus, OperationStatus } from '../core/onboard/OnboardStatus.js';
+import { Logger, EventType, EventStatus } from '../utils/logger.js';
 import { FeedOnboardService } from '../core/onboard/FeedOnboardService.js';
 import path from 'path';
 import { Server } from 'http';
@@ -78,6 +78,15 @@ export class MCPManager extends EventEmitter {
       }
       const installResult = await this.installationService.install(categoryName, serverName, requestOptions);
 
+      // Log the event with appropriate status
+      Logger.trackEvent(EventType.SERVER_INSTALL, {
+        status: installResult.success ? EventStatus.SUCCESS : EventStatus.FAILED,
+        errorMessage: !installResult.success ? installResult.message : undefined,
+        categoryName,
+        serverName,
+        ...requestOptions
+      });
+
       if (!installResult.success) {
         return installResult;
       }
@@ -86,10 +95,19 @@ export class MCPManager extends EventEmitter {
       return installResult;
 
     } catch (error) {
-      console.error(`Unexpected error during installServer for ${serverName}:`, error);
+      const errorMessage = `Failed to install ${serverName}: ${error instanceof Error ? error.message : String(error)}`;
+      Logger.error(errorMessage, error);
+      Logger.trackEvent(EventType.SERVER_INSTALL, {
+        status: EventStatus.FAILED,
+        errorMessage,
+        categoryName,
+        serverName,
+        ...requestOptions
+      });
+
       return {
         success: false,
-        message: `Failed to install ${serverName}: ${error instanceof Error ? error.message : String(error)}`,
+        message: errorMessage,
         error: error instanceof Error ? error : new Error(String(error)),
       };
     }
@@ -100,6 +118,8 @@ export class MCPManager extends EventEmitter {
     serverName: string,
     options: ServerUninstallOptions = {}
   ): Promise<ServerOperationResult> {
+    const { targets = [], removeData = false } = options;
+
     try {
       const serverCategory = await this.configProvider.getServerCategory(categoryName);
       if (!serverCategory) {
@@ -109,8 +129,6 @@ export class MCPManager extends EventEmitter {
         };
       }
 
-      const { targets = [], removeData = false } = options;
-
       // Clear installation status for specified targets
       const currentStatus: InstallationStatus = serverCategory.installationStatus || {
         requirementsStatus: {},
@@ -141,6 +159,13 @@ export class MCPManager extends EventEmitter {
         currentStatus.requirementsStatus || {},
         serversStatus
       );
+      Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+        status: EventStatus.SUCCESS,
+        categoryName,
+        serverName,
+        targets,
+        removeData
+      });
 
       this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
 
@@ -149,9 +174,20 @@ export class MCPManager extends EventEmitter {
         message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
       };
     } catch (error) {
+      const errorMessage = `Failed to uninstall ${serverName}: ${error instanceof Error ? error.message : String(error)}`;
+      
+      Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+        status: EventStatus.FAILED,
+        errorMessage,
+        categoryName,
+        serverName,
+        targets: targets || [],
+        removeData: removeData || false
+      });
+
       return {
         success: false,
-        message: `Failed to uninstall ${serverName}`,
+        message: errorMessage,
         error: error as Error,
       };
     }
@@ -201,15 +237,34 @@ export class MCPManager extends EventEmitter {
         updatedStatus
       );
 
+      Logger.trackEvent(EventType.REQUIREMENT_UPDATE, {
+        status: EventStatus.SUCCESS,
+        categoryName,
+        serverName,
+        requirementName,
+        updateVersion
+      });
+
       return {
         success: true,
         message: `Successfully updated ${requirementName} to version ${updateVersion}`,
       };
     } catch (error) {
+      const errorMessage = `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`;
       console.error(`Error updating requirement ${requirementName}:`, error);
+      
+      Logger.trackEvent(EventType.REQUIREMENT_UPDATE, {
+        status: EventStatus.FAILED,
+        errorMessage,
+        categoryName,
+        serverName,
+        requirementName,
+        updateVersion
+      });
+
       return {
         success: false,
-        message: `Failed to update ${requirementName}: ${error instanceof Error ? error.message : String(error)}`,
+        message: errorMessage,
         error: error instanceof Error ? error : new Error(String(error)),
       };
     }
@@ -222,6 +277,13 @@ export class MCPManager extends EventEmitter {
   async onboardFeed(config: FeedConfiguration): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
     try {
       const result = await this.feedOnboardService.onboardFeed(config);
+
+      Logger.trackEvent(EventType.FEED_ONBOARD, {
+        status: result.status === OnboardingProcessStatus.SUCCEEDED ? EventStatus.SUCCESS : EventStatus.FAILED,
+        errorMessage: result.message,
+        feedConfig: config
+      });
+
       // After successful onboarding initiation, sync feeds to get the latest changes
       // Syncing should ideally happen after the PR is merged, but for now,
       // syncing here makes the new (pending) category available locally if needed.
@@ -229,7 +291,15 @@ export class MCPManager extends EventEmitter {
       await this.syncFeeds();
       return result;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       Logger.error('Failed to onboard feed in MCPManager:', error);
+      
+      Logger.trackEvent(EventType.FEED_ONBOARD, {
+        status: EventStatus.FAILED,
+        errorMessage,
+        feedName: config.name
+      });
+
       throw error; // Rethrow or handle by returning a failed OperationStatus
     }
   }

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/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();
 
   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/versionUtils.ts

@@ -1,3 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export function getPackageVersion(): string {
+  try {
+    // First try npm environment variable (available during npm scripts)
+    if (process.env.npm_package_version) {
+      return 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;
+      }
+      currentDir = path.join(currentDir, '..');
+    }
+
+    return 'unknown';
+  } catch (error) {
+    console.error('Failed to get package version:', error);
+    return 'unknown';
+  }
+}
+
 /**
  * Utility functions for version comparison and management
  */

package/src/web/public/css/serverCategoryList.css

@@ -0,0 +1,120 @@
+/* Server Category List Styles */
+.category-toggle {
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    color: #4b5563; /* gray-600 */
+    transition: all 0.2s;
+}
+
+.category-toggle:hover {
+    color: #1e40af; /* blue-800 */
+}
+
+.category-toggle i {
+    font-size: 1.25rem;
+    transition: transform 0.2s;
+}
+
+.category-toggle.collapsed i {
+    transform: rotate(-90deg);
+}
+
+.server-list-container {
+    transition: height 0.3s ease, opacity 0.3s ease, margin 0.3s ease;
+    overflow: hidden;
+}
+
+.server-list-container.collapsed {
+    height: 0 !important;
+    opacity: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+}
+
+.category-section {
+    margin-bottom: 1rem;
+    border-bottom: 1px solid #e5e7eb; /* gray-200 */
+    padding-bottom: 0.5rem;
+}
+
+.category-section:last-child {
+    border-bottom: none;
+    margin-bottom: 0;
+}
+
+.category-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+}
+
+/* Pin button styles */
+.pin-button {
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    color: #9ca3af; /* gray-400 */
+    margin-right: 8px;
+    transition: all 0.2s ease;
+}
+
+.pin-button:hover {
+    color: #4b5563; /* gray-600 */
+}
+
+.pin-button.pinned {
+    color: #2563eb; /* blue-600 */
+}
+
+.pin-button.pinned:hover {
+    color: #1d4ed8; /* blue-700 */
+}
+
+/* Pinned server section */
+.server-item.pinned {
+    border-left: 3px solid #2563eb; /* blue-600 */
+    background-color: #f0f7ff; /* very light blue */
+    position: relative;
+    transition: all 0.2s ease-in-out;
+}
+
+/* Pin animation */
+.server-item {
+    transition: transform 0.3s ease, border-left 0.2s ease, background-color 0.2s ease;
+}
+
+/* Visual indicator for pinned items at the top */
+.server-item.pinned::before {
+    content: "";
+    position: absolute;
+    top: -3px;
+    left: 0;
+    right: 0;
+    height: 3px;
+    background-color: #2563eb; /* blue-600 */
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+
+/* Show top indicator for the first pinned item */
+.server-item.pinned:first-child::before {
+    opacity: 1;
+}
+
+/* Add hover effect to pinned items */
+.server-item.pinned:hover {
+    background-color: #e6f0ff; /* slightly darker on hover */
+}
+
+/* Pin animation effect */
+@keyframes pin-animation {
+    0% { transform: scale(1); }
+    50% { transform: scale(1.03); }
+    100% { transform: scale(1); }
+}
+
+.pin-animation {
+    animation: pin-animation 0.3s ease;
+}

package/src/web/public/index.html

@@ -9,11 +9,12 @@
     <link href="https://unpkg.com/boxicons@2.1.4/css/boxicons.min.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.2/font/bootstrap-icons.css" rel="stylesheet">
-    <link rel="stylesheet" href="styles.css">
+    <link rel="stylesheet" href="styles.css">    
     <link rel="stylesheet" href="css/modal.css">
     <link rel="stylesheet" href="css/notifications.css">
     <link rel="stylesheet" href="css/serverDetails.css">
     <link rel="stylesheet" href="css/detailsWidget.css">
+    <link rel="stylesheet" href="css/serverCategoryList.css">
     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
 
     <!-- Alert container for notifications -->
@@ -25,8 +26,10 @@
     <div class="container mx-auto px-4 py-6">
         <div class="flex items-center justify-between mb-8">
             <h1 class="text-3xl font-bold text-gray-900 flex items-center">
-                <i class='bx bx-server mr-3 text-blue-600'></i>
-                IMCP Server Manager
+                <a href="index.html" class="flex items-center text-gray-900 hover:text-blue-600 transition-colors">
+                    <i class='bx bx-server mr-3 text-blue-600'></i>
+                    IMCP Server Manager
+                </a>
             </h1>
             <div class="lg:w-2/3 flex justify-end items-center gap-4">
                 <div class="relative w-48 focus-within:w-96 transition-all duration-300 ease-in-out">