imcp 0.1.5 → 0.1.6

package/src/utils/feedUtils.ts

@@ -0,0 +1,31 @@
+import fs from 'fs/promises';
+import { Logger } from './logger.js';
+import { LOCAL_FEEDS_DIR } from '../core/metadatas/constants.js';
+
+/**
+ * Checks if local feeds exist in the LOCAL_FEEDS_DIR
+ * Returns true if the directory exists and contains at least one .json file
+ */
+export async function hasLocalFeeds(): Promise<boolean> {
+  try {
+    Logger.debug('Checking for local feeds existence');
+    const feedsExist = await fs.access(LOCAL_FEEDS_DIR)
+      .then(() => true)
+      .catch(() => false);
+
+    if (!feedsExist) {
+      Logger.debug('Local feeds directory does not exist');
+      return false;
+    }
+
+    // Check if directory contains any json files
+    const files = await fs.readdir(LOCAL_FEEDS_DIR);
+    const hasJsonFiles = files.some(file => file.endsWith('.json'));
+
+    Logger.debug(`Local feeds directory ${hasJsonFiles ? 'contains' : 'does not contain'} JSON files`);
+    return hasJsonFiles;
+  } catch (error) {
+    Logger.error('Error checking local feeds:', error);
+    return false;
+  }
+}

package/src/utils/githubAuth.ts

@@ -0,0 +1,212 @@
+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);
+
+// Create a promisified version of spawn that returns a Promise
+const spawnAsync = (command: string, args: string[], options: any = {}) => {
+  return new Promise((resolve, reject) => {
+    const childProcess = spawn(command, args, options);
+
+    childProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve(code);
+      } else {
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+
+    childProcess.on('error', (err) => {
+      reject(err);
+    });
+  });
+};
+
+class GithubAuthError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GithubAuthError';
+  }
+}
+
+export async function checkGithubAuth(): Promise<void> {
+  Logger.debug('Starting GitHub authentication check');
+
+  try {
+    // Check if gh CLI is installed
+    if (!await isToolInstalled('gh')) {
+      Logger.log('Installing required GitHub CLI...');
+      await installCLI('gh');
+
+      // Verify gh CLI was installed correctly, with retry mechanism
+      if (!await isToolInstalled('gh')) {
+        throw new Error('Failed to install GitHub CLI. Please install it manually and try again.');
+      }
+
+      Logger.debug('GitHub CLI installed successfully and verified');
+    }
+  } catch (error) {
+    Logger.error('Error during tool installation:', error);
+    throw new Error(`Tool installation failed: ${(error as Error).message}`);
+  }
+
+  try {
+    Logger.debug('Checking GitHub authentication status');
+    // Check if user is authenticated
+    const { stdout: viewerData } = await execAsync('gh api user');
+    const viewer = JSON.parse(viewerData);
+
+    Logger.debug({
+      action: 'github_auth_check',
+      username: viewer.login
+    });
+
+    // Check if user is using company account (ends with _microsoft)
+    if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
+      const error = 'Error: You must be logged in with a Microsoft account (username should end with _microsoft). ' +
+        'Please run "gh auth logout" and then "gh auth login" with your Microsoft account. Current username: ' +
+        viewer.login;
+      Logger.error(error, {
+        username: viewer.login
+      });
+      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) {
+      throw error;
+    }
+
+    // If the error is due to not being authenticated
+    const errorMessage = (error as any)?.stderr || (error as Error).message;
+    if (errorMessage.includes('please run:  gh auth login') || errorMessage.includes('GH_TOKEN')) {
+      Logger.log('GitHub authentication required at the first run. Please login account end with _microsoft.');
+
+      try {
+        // Use spawnAsync for interactive authentication
+        await spawnAsync('gh', ['auth', 'login', '--web', '--hostname', 'github.com', '--git-protocol', 'https'], {
+          stdio: 'inherit' // User sees & interacts directly with the process
+        });
+
+        Logger.debug('GitHub authentication process completed');
+
+        // Verify the authentication was successful
+        const { stdout: viewerData } = await execAsync('gh api user');
+        const viewer = JSON.parse(viewerData);
+
+        // Check if user is using company account (ends with _microsoft)
+        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) {
+        Logger.error('Error during GitHub authentication process', loginError);
+
+        // If the interactive login failed, provide manual instructions
+        const authInstructions =
+          '\nError: GitHub authentication required. Please follow these steps:\n\n' +
+          '1. Run this command:\n' +
+          '     gh auth login --web --hostname github.com --git-protocol https\n' +
+          '2. Choose Y when prompted authenticating Git with your GitHub credentials.\n' +
+          '3. Follow the prompts to login with your Microsoft account (username must end with _microsoft)\n' +
+          '4. Authorize ai-microsoft organization.\n' +
+          '5. After successful login, run imcp command again.\n\n';
+
+        Logger.log(authInstructions);
+        throw new GithubAuthError('GitHub authentication required. Please login first and try again.');
+      }
+    } else {
+      const errorMessage = `Failed to verify GitHub authentication: ${(error as Error).message}`;
+      Logger.error(errorMessage, error);
+      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/githubUtils.ts

@@ -0,0 +1,164 @@
+import { RegistryConfig, RequirementConfig } from '../core/metadatas/types.js';
+import { exec } from 'child_process';
+import util from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { extractZipFile } from './clientUtils.js';
+import { Logger } from './logger.js';
+import { SETTINGS_DIR } from '../core/metadatas/constants.js';
+
+const execAsync = util.promisify(exec);
+
+/**
+ * Get the latest version available for a GitHub repository
+ * @param execPromise The promise-based exec function
+ * @param repository The GitHub repository in format 'owner/repo'
+ * @returns The latest version or tag
+ */
+export async function getGitHubLatestVersion(execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>, repository: string): Promise<string> {
+    try {
+        // Use GitHub CLI to get the latest release
+        const { stdout } = await execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+        const latestTag = stdout.trim();
+
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    } catch (error) {
+        // If gh command fails, try to get the latest tag
+        const { stdout } = await execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
+        let latestTag = stdout.trim();
+
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    }
+}
+
+interface DownloadGithubReleaseResult {
+    version: string;
+    downloadPath: string;
+}
+
+/**
+ * Downloads a GitHub release asset
+ * @param repo GitHub repository in format owner/repo
+ * @param version Version to download, can be "latest"
+ * @param assetsName Assets name pattern (optional, but either assetsName or assetName must be provided)
+ * @param assetName Asset name pattern (optional, but either assetsName or assetName must be provided)
+ * @param isFolder Whether to treat the downloaded asset as a folder (default: false)
+ * @param targetDirectory Target directory for downloads (default: SETTINGS_DIR/downloads)
+ * @returns Object containing version and download path
+ */
+export async function downloadGithubRelease(
+    repo: string,
+    version: string,
+    assetsName?: string,
+    assetName?: string,
+    isFolder: boolean = false,
+    targetDirectory?: string
+): Promise<DownloadGithubReleaseResult> {
+    if (!repo) {
+        throw new Error('GitHub repository is required');
+    }
+
+    if (!assetsName && !assetName) {
+        throw new Error('Either assetsName or assetName must be specified');
+    }
+
+    const downloadsDir = targetDirectory || path.join(SETTINGS_DIR, 'downloads');
+    await fs.mkdir(downloadsDir, { recursive: true });
+
+    // Get latest version if needed
+    const { stdout } = await execAsync(`gh release view --repo ${repo} --json tagName --jq .tagName`);
+    const latestTag = stdout.trim();
+    let latestVersion = latestTag;
+
+    const tagWithVPrefix = latestVersion.startsWith('v');
+    if (tagWithVPrefix) latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
+    const resolvedVersion = version.includes("latest") ? latestVersion : version;
+
+    // Resolve asset names
+    let resolvedAssetsName = '';
+    let resolvedAssetName = '';
+    if (assetsName) {
+        resolvedAssetsName = assetsName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
+    }
+    if (assetName) {
+        resolvedAssetName = assetName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
+    }
+
+    // Validate zip requirement for isFolder
+    const pattern = resolvedAssetsName || resolvedAssetName;
+    if (isFolder && (!resolvedAssetsName || !resolvedAssetsName.endsWith('.zip'))) {
+        throw new Error('When isFolder is true, assetsName must be provided and end with .zip');
+    }
+
+    // Download the release asset
+    const downloadPath = path.join(downloadsDir, path.basename(pattern));
+    if (!await fileExists(downloadPath)) {
+        await execAsync(`gh release download ${tagWithVPrefix ? `v${resolvedVersion}` : resolvedVersion} --repo ${repo} --pattern "${pattern}" -O "${downloadPath}"`);
+    }
+
+    // Handle zip extraction if needed
+    if (isFolder && downloadPath.endsWith('.zip')) {
+        const extractDir = path.join(downloadsDir, path.basename(pattern, '.zip'));
+        await fs.mkdir(extractDir, { recursive: true });
+        await extractZipFile(downloadPath, { dir: extractDir });
+
+        // If resolvedAssetName is specified, look for it in the extracted directory
+        if (resolvedAssetName) {
+            const assetPath = path.join(extractDir, resolvedAssetName);
+            try {
+                await fs.access(assetPath);
+                return { version: resolvedVersion, downloadPath: assetPath };
+            } catch (error) {
+                throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
+            }
+        }
+        return { version: resolvedVersion, downloadPath: extractDir };
+    }
+
+    return { version: resolvedVersion, downloadPath };
+}
+
+/**
+ * Helper to handle GitHub release downloads
+ * @param requirement The requirement configuration
+ * @param registry The GitHub release registry configuration
+ * @returns The path to the downloaded file
+ */
+export async function handleGitHubRelease(
+    requirement: RequirementConfig,
+    registry: RegistryConfig['githubRelease']
+): Promise<{ resolvedVersion: string; resolvedPath: string }> {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration is required');
+    }
+
+    const { repository, assetsName, assetName } = registry;
+    if (!repository) {
+        throw new Error('GitHub repository is required for GitHub release downloads');
+    }
+
+    const isZipAsset = assetsName?.endsWith('.zip') || false;
+    const result = await downloadGithubRelease(
+        repository,
+        requirement.version,
+        assetsName,
+        assetName,
+        isZipAsset
+    );
+
+    return {
+        resolvedVersion: result.version,
+        resolvedPath: result.downloadPath
+    };
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/utils/logger.ts

@@ -0,0 +1,195 @@
+import fs from 'fs';
+import path from 'path';
+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;
+  }
+
+  static setFileLogging(enabled: boolean): void {
+    this.fileLoggingEnabled = enabled;
+  }
+
+  private static async ensureLogsDirExists(): Promise<void> {
+    try {
+      await fs.promises.mkdir(this.logsDir, { recursive: true });
+    } catch (error) {
+      console.error(`Failed to create logs directory: ${error instanceof Error ? error.message : String(error)}`);
+      // Disable file logging if directory creation fails
+      this.fileLoggingEnabled = false;
+    }
+  }
+
+  private static getLogFileName(): string {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}.log`;
+  }
+
+  private static getTimestamp(): string {
+    return new Date().toISOString();
+  }
+
+  private static async writeToLogFile(level: string, content: string): Promise<void> {
+    if (!this.fileLoggingEnabled) return;
+
+    try {
+      await this.ensureLogsDirExists();
+      const logFile = path.join(this.logsDir, this.getLogFileName());
+      const logEntry = `[${this.getTimestamp()}] [${level}] ${content}\n`;
+
+      await fs.promises.appendFile(logFile, logEntry, { encoding: 'utf8' });
+    } catch (error) {
+      console.error(`Failed to write to log file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  static async log(message: string): Promise<void> {
+    console.log(message);
+    await this.writeToLogFile('INFO', message);
+  }
+
+  static async info(message: string): Promise<void> {
+    console.info(message);
+    await this.writeToLogFile('INFO', message);
+  }
+
+  static async warn(message: string): Promise<void> {
+    const yellowColor = '\x1b[33m';
+    const resetColor = '\x1b[0m';
+    console.warn(`${yellowColor}${message}${resetColor}`);
+    await this.writeToLogFile('WARN', message);
+  }
+
+  static async debug(message: string | object): Promise<void> {
+    let formattedMessage: string;
+
+    if (typeof message === 'object') {
+      formattedMessage = JSON.stringify(message, null, 2);
+      if (this.verbose) {
+        console.log(formattedMessage);
+      }
+    } else {
+      formattedMessage = message;
+      if (this.verbose) {
+        console.log(message);
+      }
+    }
+
+    if (this.verbose) {
+      await this.writeToLogFile('DEBUG', formattedMessage);
+    }
+  }
+
+  static async error(message: string, error?: unknown): Promise<void> {
+    console.error(message);
+
+    let logMessage = message;
+
+    if (this.verbose && error) {
+      if (error instanceof Error) {
+        const errorDetails = {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        };
+        console.error('Error details:', errorDetails);
+        logMessage += `\nError details: ${JSON.stringify(errorDetails, null, 2)}`;
+      } else {
+        console.error('Error details:', error);
+        logMessage += `\nError details: ${JSON.stringify(error, null, 2)}`;
+      }
+    }
+
+    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);
+    }
+  }
+}