imcp 0.0.1

package/dist/services/ServerService.js

@@ -0,0 +1,145 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Logger } from '../utils/logger.js';
+import { mcpManager } from '../core/MCPManager.js';
+import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * ServerService provides a unified interface for server management operations.
+ * This layer handles business logic that's shared between the CLI and web interface.
+ */
+export class ServerService {
+    /**
+     * Lists available MCP servers based on the provided options
+     */
+    async listServerCategories(options = {}) {
+        return mcpManager.listServerCategories(options);
+    }
+    /**
+     * Gets a server by name
+     */
+    async getServerCategory(categoryName) {
+        const serverCategories = await this.listServerCategories();
+        const serverCategory = serverCategories.find(s => s.name === categoryName);
+        // Start async check for requirement updates if one isn't already in progress
+        if (serverCategory && serverCategory.feedConfiguration && serverCategory.name) {
+            // Check if update is already in progress using the tracker
+            const shouldCheckForUpdates = await updateCheckTracker.startOperation(serverCategory.name);
+            if (shouldCheckForUpdates) {
+                this.checkRequirementsForUpdate(serverCategory).catch(error => {
+                    // Ensure we mark the operation as complete on error
+                    if (serverCategory.name) {
+                        updateCheckTracker.endOperation(serverCategory.name)
+                            .catch(lockError => console.error(`Failed to mark update check as complete: ${lockError.message}`));
+                    }
+                    Logger.error(`Error checking requirements for updates: ${error.message}`);
+                });
+            }
+            else {
+                Logger.debug(`Update check already in progress for ${serverCategory.name}, skipping`);
+            }
+        }
+        return serverCategory;
+    }
+    /**
+     * Check for updates to requirements for a server category
+     * @param serverCategory The server category to check
+     * @private
+     */
+    async checkRequirementsForUpdate(serverCategory) {
+        if (!serverCategory.name || !serverCategory.feedConfiguration?.requirements?.length) {
+            return;
+        }
+        try {
+            const { requirementService } = await import('../core/RequirementService.js');
+            const { configProvider } = await import('../core/ConfigurationProvider.js');
+            for (const requirement of serverCategory.feedConfiguration.requirements) {
+                if (requirement.version.includes('latest')) {
+                    // Get current status if available
+                    const currentStatus = serverCategory.installationStatus?.requirementsStatus[requirement.name];
+                    if (!currentStatus)
+                        continue;
+                    // Check for updates
+                    const updatedStatus = await requirementService.checkRequirementForUpdates(requirement);
+                    // If update information is found, update the configuration
+                    if (updatedStatus.availableUpdate && serverCategory.name) {
+                        await configProvider.updateRequirementStatus(serverCategory.name, requirement.name, updatedStatus);
+                        // Also update the in-memory status for immediate use
+                        if (serverCategory.installationStatus?.requirementsStatus) {
+                            serverCategory.installationStatus.requirementsStatus[requirement.name] = updatedStatus;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            // Always mark the operation as complete when done, even if there was an error
+            if (serverCategory.name) {
+                await updateCheckTracker.endOperation(serverCategory.name)
+                    .catch(error => console.error(`Failed to mark update check as complete: ${error.message}`));
+            }
+        }
+    }
+    /**
+     * Installs a specific mcp tool for a server.
+     * TODO: This might require enhancing MCPManager to handle category-specific installs.
+     */
+    async installMcpServer(category, serverName, options = {} // Reuse ServerInstallOptions for env etc.
+    ) {
+        Logger.debug(`Installing MCP server: ${JSON.stringify({ category, serverName, options })}`);
+        try {
+            const result = await mcpManager.installServer(category, serverName, options);
+            Logger.debug(`Installation result: ${JSON.stringify(result)}`);
+            return result;
+        }
+        catch (error) {
+            Logger.error(`Failed to install MCP server: ${serverName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Installs a specific mcp tool for a server.
+     * TODO: This might require enhancing MCPManager to handle category-specific installs.
+     */
+    async uninstallMcpServer(category, serverName, options = {} // Reuse ServerInstallOptions for env etc.
+    ) {
+        return mcpManager.uninstallServer(category, serverName, options);
+    }
+    /**
+     * Validates server names
+     */
+    async validateServerName(category, name) {
+        Logger.debug(`Validating server name: ${JSON.stringify({ category, name })}`);
+        // Check if category exists in feeds
+        const feedConfig = await mcpManager.getFeedConfiguration(category);
+        if (!feedConfig) {
+            Logger.debug(`Validation failed: Category "${category}" not found in feeds`);
+            return false;
+        }
+        // Check if server exists in the category's mcpServers
+        const serverExists = feedConfig.mcpServers.some(server => server.name === name);
+        if (!serverExists) {
+            Logger.debug(`Validation failed: Server "${name}" not found in category "${category}"`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Formats success/error messages for operations
+     */
+    formatOperationResults(results) {
+        return {
+            success: results.every(r => r.success),
+            messages: results.map(r => r.message).filter((m) => m !== undefined)
+        };
+    }
+    /**
+     * Syncs MCP server configurations from remote feed source
+     */
+    async syncFeeds() {
+        return mcpManager.syncFeeds();
+    }
+}
+// Export a singleton instance
+export const serverService = new ServerService();
+//# sourceMappingURL=ServerService.js.map

package/dist/utils/UpdateCheckTracker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Utility class to track update check operations in progress
+ * Provides thread-safe access to check status with proper locking
+ */
+export declare class UpdateCheckTracker {
+    private static instance;
+    private operationsInProgress;
+    private operationsLock;
+    private constructor();
+    /**
+     * Get the singleton instance of the tracker
+     */
+    static getInstance(): UpdateCheckTracker;
+    /**
+     * Execute an operation with a lock to ensure thread safety
+     * @param operation The operation to execute
+     * @returns The result of the operation
+     * @private
+     */
+    private withLock;
+    /**
+     * Check if an operation can be started and mark it as in progress if so
+     * @param key The key to identify the operation
+     * @returns True if the operation can be started, false if already in progress
+     */
+    startOperation(key: string): Promise<boolean>;
+    /**
+     * Mark an operation as complete
+     * @param key The key to identify the operation
+     */
+    endOperation(key: string): Promise<void>;
+    /**
+     * Check if an operation is in progress
+     * @param key The key to identify the operation
+     * @returns True if the operation is in progress
+     */
+    isOperationInProgress(key: string): Promise<boolean>;
+}
+export declare const updateCheckTracker: UpdateCheckTracker;

package/dist/utils/UpdateCheckTracker.js

@@ -0,0 +1,80 @@
+/**
+ * Utility class to track update check operations in progress
+ * Provides thread-safe access to check status with proper locking
+ */
+export class UpdateCheckTracker {
+    static instance;
+    // Map to track operations in progress (key -> inProgress)
+    operationsInProgress = new Map();
+    // Lock for thread safety when checking/updating the in-progress map
+    operationsLock = Promise.resolve();
+    constructor() { }
+    /**
+     * Get the singleton instance of the tracker
+     */
+    static getInstance() {
+        if (!UpdateCheckTracker.instance) {
+            UpdateCheckTracker.instance = new UpdateCheckTracker();
+        }
+        return UpdateCheckTracker.instance;
+    }
+    /**
+     * Execute an operation with a lock to ensure thread safety
+     * @param operation The operation to execute
+     * @returns The result of the operation
+     * @private
+     */
+    async withLock(operation) {
+        const current = this.operationsLock;
+        let resolve;
+        this.operationsLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    /**
+     * Check if an operation can be started and mark it as in progress if so
+     * @param key The key to identify the operation
+     * @returns True if the operation can be started, false if already in progress
+     */
+    async startOperation(key) {
+        return await this.withLock(async () => {
+            if (!this.operationsInProgress.get(key)) {
+                this.operationsInProgress.set(key, true);
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Mark an operation as complete
+     * @param key The key to identify the operation
+     */
+    async endOperation(key) {
+        try {
+            await this.withLock(async () => {
+                this.operationsInProgress.set(key, false);
+            });
+        }
+        catch (error) {
+            console.error(`Failed to end operation for key: ${key}`, error);
+        }
+    }
+    /**
+     * Check if an operation is in progress
+     * @param key The key to identify the operation
+     * @returns True if the operation is in progress
+     */
+    async isOperationInProgress(key) {
+        return await this.withLock(async () => {
+            return !!this.operationsInProgress.get(key);
+        });
+    }
+}
+// Export a singleton instance
+export const updateCheckTracker = UpdateCheckTracker.getInstance();
+//# sourceMappingURL=UpdateCheckTracker.js.map

package/dist/utils/clientUtils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Extract a zip file to a directory
+ * @param zipPath The path to the zip file
+ * @param options Extraction options
+ * @returns A promise that resolves when extraction is complete
+ */
+export declare function extractZipFile(zipPath: string, options: {
+    dir: string;
+}): Promise<void>;
+/**
+ * Resolves the path to an NPM module, replacing template variables
+ * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
+ * @param pathString The path string potentially containing template variables
+ * @returns The resolved path
+ */
+export declare function resolveNpmModulePath(pathString: string): string;
+/**
+ * Reads a JSON file and parses its content
+ * @param filePath Path to the JSON file
+ * @param createIfNotExist Whether to create the file if it doesn't exist
+ * @returns The parsed JSON content
+ */
+export declare function readJsonFile(filePath: string, createIfNotExist?: boolean): Promise<any>;
+/**
+ * Writes content to a JSON file
+ * @param filePath Path to the JSON file
+ * @param content Content to write to the file
+ */
+export declare function writeJsonFile(filePath: string, content: any): Promise<void>;

package/dist/utils/clientUtils.js

@@ -0,0 +1,105 @@
+import fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import extractZipModule from 'extract-zip';
+import { Logger } from './logger.js';
+/**
+ * Extract a zip file to a directory
+ * @param zipPath The path to the zip file
+ * @param options Extraction options
+ * @returns A promise that resolves when extraction is complete
+ */
+export async function extractZipFile(zipPath, options) {
+    try {
+        // Try to use extract-zip if available
+        if (typeof extractZipModule === 'function') {
+            return await extractZipModule(zipPath, options);
+        }
+        // Fallback to Node.js built-in unzipper
+        const fs = require('fs');
+        const unzipper = require('unzipper');
+        await fs.promises.mkdir(options.dir, { recursive: true });
+        return new Promise((resolve, reject) => {
+            fs.createReadStream(zipPath)
+                .pipe(unzipper.Extract({ path: options.dir }))
+                .on('close', resolve)
+                .on('error', reject);
+        });
+    }
+    catch (error) {
+        console.error(`Error extracting zip: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to extract zip file ${zipPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Resolves the path to an NPM module, replacing template variables
+ * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
+ * @param pathString The path string potentially containing template variables
+ * @returns The resolved path
+ */
+export function resolveNpmModulePath(pathString) {
+    // If the path doesn't contain the ${NPMPATH} template, return it as is
+    if (!pathString.includes('${NPMPATH}')) {
+        return pathString;
+    }
+    // First try to get NVM-controlled npm path
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) {
+        try {
+            // Get current node version
+            const nodeVersion = execSync('node -v').toString().trim();
+            // Construct the path to npm in the NVM directory
+            const nvmNodePath = path.join(nvmHome, nodeVersion);
+            const resolvedPath = pathString.replace('${NPMPATH}', nvmNodePath);
+            // Check if this path exists
+            try {
+                fsSync.accessSync(resolvedPath);
+                return resolvedPath;
+            }
+            catch (error) {
+                Logger.debug(`NVM controlled path doesn't exist: ${resolvedPath}, will try global npm`);
+                // Path doesn't exist, will fall back to global npm
+            }
+        }
+        catch (error) {
+            Logger.debug(`Error determining Node version: ${error}, will use global npm`);
+            // Error getting node version, will fall back to global npm
+        }
+    }
+    // Fall back to global npm path
+    const globalNpmPath = execSync('npm root -g').toString().trim();
+    return pathString.replace('${NPMPATH}', globalNpmPath);
+}
+/**
+ * Reads a JSON file and parses its content
+ * @param filePath Path to the JSON file
+ * @param createIfNotExist Whether to create the file if it doesn't exist
+ * @returns The parsed JSON content
+ */
+export async function readJsonFile(filePath, createIfNotExist = false) {
+    try {
+        // Ensure directory exists
+        if (createIfNotExist) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+        }
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' && createIfNotExist) {
+            return {};
+        }
+        throw error;
+    }
+}
+/**
+ * Writes content to a JSON file
+ * @param filePath Path to the JSON file
+ * @param content Content to write to the file
+ */
+export async function writeJsonFile(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2), 'utf8');
+}
+//# sourceMappingURL=clientUtils.js.map

package/dist/utils/feedUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if local feeds exist in the LOCAL_FEEDS_DIR
+ * Returns true if the directory exists and contains at least one .json file
+ */
+export declare function hasLocalFeeds(): Promise<boolean>;

package/dist/utils/feedUtils.js

@@ -0,0 +1,29 @@
+import fs from 'fs/promises';
+import { Logger } from './logger.js';
+import { LOCAL_FEEDS_DIR } from '../core/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() {
+    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;
+    }
+}
+//# sourceMappingURL=feedUtils.js.map

package/dist/utils/githubAuth.d.ts

@@ -0,0 +1 @@
+export declare function checkGithubAuth(): Promise<void>;

package/dist/utils/githubAuth.js

@@ -0,0 +1,123 @@
+import { isToolInstalled, installCLI } from './osUtils.js';
+import { exec, spawn } from 'child_process';
+import util from 'util';
+import { Logger } from './logger.js';
+const execAsync = util.promisify(exec);
+// Create a promisified version of spawn that returns a Promise
+const spawnAsync = (command, args, options = {}) => {
+    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) {
+        super(message);
+        this.name = 'GithubAuthError';
+    }
+}
+export async function checkGithubAuth() {
+    Logger.debug('Starting GitHub authentication check');
+    try {
+        // Check if git is installed
+        if (!await isToolInstalled('git')) {
+            Logger.log('Installing required Git...');
+            await installCLI('git');
+            // Verify git was installed correctly, with retry mechanism
+            if (!await isToolInstalled('git')) {
+                throw new Error('Failed to install Git. Please install it manually and try again.');
+            }
+            Logger.debug('Git installed successfully and verified');
+        }
+        // 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.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);
+        }
+        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?.stderr || 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).');
+                }
+                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.message}`;
+            Logger.error(errorMessage, error);
+            throw new GithubAuthError(errorMessage);
+        }
+    }
+}
+//# sourceMappingURL=githubAuth.js.map

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export declare class Logger {
+    private static verbose;
+    private static fileLoggingEnabled;
+    private static logsDir;
+    static setVerbose(isVerbose: boolean): void;
+    static setFileLogging(enabled: boolean): void;
+    private static ensureLogsDirExists;
+    private static getLogFileName;
+    private static getTimestamp;
+    private static writeToLogFile;
+    static log(message: string): Promise<void>;
+    static debug(message: string | object): Promise<void>;
+    static error(message: string, error?: unknown): Promise<void>;
+}

package/dist/utils/logger.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { SETTINGS_DIR } from '../core/constants.js';
+export class Logger {
+    static verbose = false;
+    static fileLoggingEnabled = true;
+    static logsDir = path.join(SETTINGS_DIR, 'logs');
+    static setVerbose(isVerbose) {
+        this.verbose = isVerbose;
+    }
+    static setFileLogging(enabled) {
+        this.fileLoggingEnabled = enabled;
+    }
+    static async ensureLogsDirExists() {
+        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;
+        }
+    }
+    static getLogFileName() {
+        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`;
+    }
+    static getTimestamp() {
+        return new Date().toISOString();
+    }
+    static async writeToLogFile(level, content) {
+        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) {
+        console.log(message);
+        await this.writeToLogFile('INFO', message);
+    }
+    static async debug(message) {
+        let formattedMessage;
+        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, error) {
+        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);
+    }
+}
+//# sourceMappingURL=logger.js.map