imcp 0.0.18 → 0.1.1

package/.roo/rules-code/rules.md

@@ -0,0 +1,88 @@
+*IMPORTANT* Before I attempt to complete a task with code changes, I MUST have to ask confirmation with user whether to update memory bank
+
+memory*bank_strategy:
+initialization: |
+<thinking> - **CHECK FOR MEMORY BANK:**
+</thinking>
+<thinking>
+* First, check if the memory-bank/ directory exists.
+</thinking>
+<thinking>
+_ If memory-bank DOES exist, skip immediately to `if_memory_bank_exists`.
+</thinking>
+if_no_memory_bank: | 1. **Inform the User:**  
+ "No Memory Bank was found. I recommend creating one to maintain project context. Would you like to switch to Flow-Architect mode to do this?" 2. **Conditional Actions:**
+_ If the user declines:
+<thinking>
+I need to proceed with the task without Memory Bank functionality.
+</thinking>
+a. Inform the user that the Memory Bank will not be created.
+b. Set the status to '[MEMORY BANK: INACTIVE]'.
+c. Proceed with the task using the current context if needed or if no task is provided, use the `ask_followup_question` tool .
+_ If the user agrees:
+Switch to Flow-Architect mode to create the Memory Bank.
+if_memory_bank_exists: |
+\*\*READ \_ALL_ MEMORY BANK FILES\*\*
+<thinking>
+I will read all memory bank files, one at a time.
+</thinking>
+Plan: Read all mandatory files sequentially. 1. Read `productContext.md` 2. Read `activeContext.md` 3. Read `systemPatterns.md` 4. Read `decisionLog.md` 5. Read `progress.md` 6. Set status to [MEMORY BANK: ACTIVE] and inform user. 7. Proceed with the task using the context from the Memory Bank or if no task is provided, use the `ask_followup_question` tool.
+
+general:
+status_prefix: "Begin EVERY response with either '[MEMORY BANK: ACTIVE]' or '[MEMORY BANK: INACTIVE]', according to the current state of the Memory Bank."
+
+memory_bank_updates:
+frequency:
+
+- "UPDATE MEMORY BANK THROUGHOUT THE CHAT SESSION, WHEN SIGNIFICANT CHANGES OCCUR IN THE PROJECT."
+  decisionLog.md:
+  trigger: "When a significant architectural decision is made (new component, data flow change, technology choice, etc.). Use your judgment to determine significance."
+  action: |
+  <thinking>
+  I need to update decisionLog.md with a decision, the rationale, and any implications.
+  </thinking>
+  Use insert*content to \_append* new information. Never overwrite existing entries. Always include a timestamp.  
+   format: |
+  "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+  productContext.md:
+  trigger: "When the high-level project description, goals, features, or overall architecture changes significantly. Use your judgment to determine significance."
+  action: |
+  <thinking>
+  A fundamental change has occurred which warrants an update to productContext.md.
+  </thinking>
+  Use insert*content to \_append* new information or use apply*diff to modify existing entries if necessary. Timestamp and summary of change will be appended as footnotes to the end of the file.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change]"
+  systemPatterns.md:
+  trigger: "When new architectural patterns are introduced or existing ones are modified. Use your judgement."
+  action: |
+  <thinking>
+  I need to update systemPatterns.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* new patterns or use apply*diff to modify existing entries if warranted. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Description of Pattern/Change]"
+  activeContext.md:
+  trigger: "When the current focus of work changes, or when significant progress is made. Use your judgement."
+  action: |
+  <thinking>
+  I need to update activeContext.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* to the relevant section (Current Focus, Recent Changes, Open Questions/Issues) or use apply*diff to modify existing entries if warranted. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+  progress.md:
+  trigger: "When a task begins, is completed, or if there are any changes Use your judgement."
+  action: |
+  <thinking>
+  I need to update progress.md with a brief summary and time stamp.
+  </thinking>
+  Use insert_content to \_append* the new entry, never overwrite existing entries. Always include a timestamp.
+  format: "[YYYY-MM-DD HH:MM:SS] - [Summary of Change/Focus/Issue]"
+
+umb:
+trigger: "^(Update Memory Bank|UMB)$"
+instructions: - "Halt Current Task: Stop current activity" - "Acknowledge Command: '[MEMORY BANK: UPDATING]'" - "Review Chat History"
+core_update_process: | 1. Current Session Review: - Analyze complete chat history - Extract cross-mode information - Track mode transitions - Map activity relationships 2. Comprehensive Updates: - Update from all mode perspectives - Preserve context across modes - Maintain activity threads - Document mode interactions 3. Memory Bank Synchronization: - Update all affected *.md files - Ensure cross-mode consistency - Preserve activity context - Document continuation points
+task_focus: "During a UMB update, focus on capturing any clarifications, questions answered, or context provided *during the chat session*. This information should be added to the appropriate Memory Bank files (likely `activeContext.md` or `decisionLog.md`), using the other modes' update formats as a guide. *Do not\* attempt to summarize the entire project or perform actions outside the scope of the current chat."
+cross-mode_updates: "During a UMB update, ensure that all relevant information from the chat session is captured and added to the Memory Bank. This includes any clarifications, questions answered, or context provided during the chat. Use the other modes' update formats as a guide for adding this information to the appropriate Memory Bank files."
+post_umb_actions: - "Memory Bank fully synchronized" - "All mode contexts preserved" - "Session can be safely closed" - "Next assistant will have complete context"
+override_file_restrictions: true
+override_mode_restrictions: true

package/dist/core/metadatas/constants.d.ts

@@ -18,6 +18,13 @@ export declare const SETTINGS_DIR: string;
  * Local feeds directory path
  */
 export declare const LOCAL_FEEDS_DIR: string;
+/**
+ * Path to the user information file
+ */
+export declare const USER_INFO_PATH: string;
+/**
+ * Path to the local feeds schema directory
+ */
 export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
 /**
  * Supported client configurations.

package/dist/core/metadatas/constants.js

@@ -27,6 +27,13 @@ export const SETTINGS_DIR = (() => {
  * Local feeds directory path
  */
 export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+/**
+ * Path to the user information file
+ */
+export const USER_INFO_PATH = path.join(SETTINGS_DIR, 'settings', 'user_info.json');
+/**
+ * Path to the local feeds schema directory
+ */
 export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
 const CODE_STRORAGE_DIR = (() => {
     switch (process.platform) {

package/dist/core/onboard/FeedOnboardService.d.ts

@@ -13,16 +13,20 @@ export declare class FeedOnboardService {
      */
     private createOperationId;
     /**
-     * Onboard a new feed configuration
+     * Onboard a new feed configuration. This method performs validation and initiates the onboarding process.
      * @param config Feed configuration to onboard
+     * @param forExistingCategory Whether this onboarding is for an existing category
+     * @returns Promise resolving to operation status with optional feed configuration
      */
     onboardFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
         feedConfiguration?: FeedConfiguration;
     }>;
     /**
-     * Validate a feed configuration without performing full onboarding
+     * Validate a feed configuration without performing full onboarding.
+     * This method performs static validation and initiates the validation process.
      * @param config Feed configuration to validate
-     * @returns Operation status indicating the result of the validation initiation
+     * @param forExistingCategory Whether this validation is for an existing category
+     * @returns Promise resolving to operation status with optional feed configuration
      */
     validateFeed(config: FeedConfiguration, forExistingCategory?: boolean): Promise<OperationStatus & {
         feedConfiguration?: FeedConfiguration;

package/dist/core/onboard/FeedOnboardService.js

@@ -1,7 +1,7 @@
 import { configProvider } from '../loaders/ConfigurationProvider.js';
 import { ServerSchemaProvider } from '../loaders/ServerSchemaProvider.js';
 import { feedValidator } from '../validators/FeedValidator.js';
-import { Logger } from '../../utils/logger.js';
+import { Logger, EventType, EventStatus } from '../../utils/logger.js';
 import { OnboardingProcessStatus } from './OnboardStatus.js';
 import { onboardStatusManager } from './OnboardStatusManager.js';
 import { onboardProcessor } from './OnboardProcessor.js';
@@ -23,8 +23,10 @@ export class FeedOnboardService {
         return `${feedName}_${operationType}`;
     }
     /**
-     * Onboard a new feed configuration
+     * Onboard a new feed configuration. This method performs validation and initiates the onboarding process.
      * @param config Feed configuration to onboard
+     * @param forExistingCategory Whether this onboarding is for an existing category
+     * @returns Promise resolving to operation status with optional feed configuration
      */
     async onboardFeed(config, forExistingCategory) {
         // Perform static validation first
@@ -40,10 +42,19 @@ export class FeedOnboardService {
             // For now, let's return a FAILED status for the attempted FULL_ONBOARDING initiation.
             // A more robust solution might involve a different return type or error code.
             const onboardingId = this.createOperationId(config.name, 'FULL_ONBOARDING'); // Hypothetical ID
+            const errorMessage = `No prior successful validation found for feed: ${config.name}. Please validate the configuration before publishing.`;
+            // Track failed event
+            Logger.trackEvent(EventType.FEED_ONBOARD, {
+                status: EventStatus.FAILED,
+                feedName: config.name,
+                errorMessage,
+                onboardingId: onboardingId,
+                feedConfiguration: config
+            });
             return {
                 onboardingId: onboardingId,
                 status: OnboardingProcessStatus.FAILED, // Or a new status like 'VALIDATION_REQUIRED'
-                message: 'The feed configuration has not been validated or has changed. Please validate the configuration before publishing.',
+                message: errorMessage,
                 lastQueried: new Date().toISOString(),
                 feedConfiguration: config
             };
@@ -58,9 +69,11 @@ export class FeedOnboardService {
         };
     }
     /**
-     * Validate a feed configuration without performing full onboarding
+     * Validate a feed configuration without performing full onboarding.
+     * This method performs static validation and initiates the validation process.
      * @param config Feed configuration to validate
-     * @returns Operation status indicating the result of the validation initiation
+     * @param forExistingCategory Whether this validation is for an existing category
+     * @returns Promise resolving to operation status with optional feed configuration
      */
     async validateFeed(config, forExistingCategory) {
         // Perform static validation first
@@ -307,10 +320,28 @@ export class FeedOnboardService {
                 validationStatus: result.validationStatus // Ensure validationStatus is also updated on success
             });
             Logger.log(`[${onboardingId}] Successfully validated feed: ${config.name}`);
+            // Track successful validation
+            Logger.trackEvent(EventType.FEED_VALIDATE, {
+                status: EventStatus.SUCCESS,
+                feedName: config.name,
+                operationType: 'VALIDATION_ONLY',
+                onboardingId: onboardingId,
+                feedConfiguration: config
+            });
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
             // Error is already logged and status updated by _validateFeedConfiguration or its callers
             Logger.error(`[${onboardingId}] Feed validation process failed for ${config.name} (already handled):`, error);
+            // Track validation failure
+            Logger.trackEvent(EventType.FEED_VALIDATE, {
+                status: EventStatus.FAILED,
+                feedName: config.name,
+                operationType: 'VALIDATION_ONLY',
+                errorMessage: errorMessage,
+                onboardingId: onboardingId,
+                feedConfiguration: config
+            });
         }
     }
     /**
@@ -359,6 +390,14 @@ export class FeedOnboardService {
                 await configProvider.initialize(feedFilePath, { prLink: prInfo.url, adhocServers: serverList }); // configProvider is already an instance
                 Logger.log(`[${onboardingId}] ConfigurationProvider re-initialized.`);
                 Logger.log(`[${onboardingId}] Successfully completed full onboarding for feed: ${config.name}`);
+                // Track successful onboarding
+                Logger.trackEvent(EventType.FEED_ONBOARD, {
+                    status: EventStatus.SUCCESS,
+                    feedName: config.name,
+                    onboardingId: onboardingId,
+                    prUrl: prInfo.url,
+                    feedConfiguration: config
+                });
             }
             catch (reinitError) {
                 Logger.warn(`[${onboardingId}] Failed to re-initialize providers after PR creation for feed ${config.name}:`);
@@ -368,6 +407,14 @@ export class FeedOnboardService {
         catch (error) {
             Logger.error(`[${onboardingId}] Full feed onboarding process failed:`, error);
             const errorMessage = error instanceof Error ? error.message : String(error);
+            // Track onboarding failure
+            Logger.trackEvent(EventType.FEED_ONBOARD, {
+                status: EventStatus.FAILED,
+                feedName: config.name,
+                onboardingId: onboardingId,
+                errorMessage,
+                feedConfiguration: config
+            });
             // Check if status is already FAILED (e.g., by _validateFeedConfiguration)
             // to avoid overwriting a more specific error message or step from validation.
             const currentStatus = await onboardStatusManager.getStatus(config.name, operationType);

package/dist/core/onboard/OnboardProcessor.js

@@ -117,29 +117,29 @@ 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/dist/services/MCPManager.js

@@ -3,7 +3,8 @@ import { ConfigurationProvider } from '../core/loaders/ConfigurationProvider.js'
 import { ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
 import { InstallationService } from './InstallationService.js';
 import { MCPEvent, } from '../core/metadatas/types.js';
-import { Logger } from '../utils/logger.js';
+import { OnboardingProcessStatus } from '../core/onboard/OnboardStatus.js';
+import { Logger, EventType, EventStatus } from '../utils/logger.js';
 import { FeedOnboardService } from '../core/onboard/FeedOnboardService.js';
 export class MCPManager extends EventEmitter {
     installationService;
@@ -53,6 +54,14 @@ 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;
             }
@@ -60,15 +69,24 @@ 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)),
             };
         }
     }
     async uninstallServer(categoryName, serverName, options = {}) {
+        const { targets = [], removeData = false } = options;
         try {
             const serverCategory = await this.configProvider.getServerCategory(categoryName);
             if (!serverCategory) {
@@ -77,7 +95,6 @@ export class MCPManager extends EventEmitter {
                     message: `Server category ${categoryName} is not onboarded`,
                 };
             }
-            const { targets = [], removeData = false } = options;
             // Clear installation status for specified targets
             const currentStatus = serverCategory.installationStatus || {
                 requirementsStatus: {},
@@ -101,6 +118,13 @@ export class MCPManager extends EventEmitter {
             serversStatus[serverName] = serverStatus;
             // Update status keeping requirements
             await this.configProvider.updateInstallationStatus(categoryName, currentStatus.requirementsStatus || {}, serversStatus);
+            Logger.trackEvent(EventType.SERVER_UNINSTALL, {
+                status: EventStatus.SUCCESS,
+                categoryName,
+                serverName,
+                targets,
+                removeData
+            });
             this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
             return {
                 success: true,
@@ -108,9 +132,18 @@ export class MCPManager extends EventEmitter {
             };
         }
         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,
             };
         }
@@ -143,16 +176,32 @@ export class MCPManager extends EventEmitter {
             const updatedStatus = await requirementService.updateRequirement(requirement, updateVersion);
             // Update the status in configuration
             await this.configProvider.updateRequirementStatus(categoryName, requirementName, 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)),
             };
         }
@@ -164,6 +213,11 @@ export class MCPManager extends EventEmitter {
     async onboardFeed(config) {
         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.
@@ -172,7 +226,13 @@ export class MCPManager extends EventEmitter {
             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/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/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;
 }