imcp 0.1.7 → 0.1.8-dev

package/src/utils/feedUtils.ts

@@ -1,31 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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);
-    }
-  }
-}