imcp 0.1.7 → 0.1.8-dev

package/dist/core/RequirementService.js

@@ -1,110 +0,0 @@
-import { createInstallerFactory } from './installers/index.js';
-import { exec } from 'child_process';
-import util from 'util';
-/**
- * Service responsible for managing requirements installation and status
- */
-export class RequirementService {
-    static instance;
-    installerFactory = createInstallerFactory(util.promisify(exec));
-    constructor() { }
-    /**
-     * Get the singleton instance of RequirementService
-     * @returns The RequirementService instance
-     */
-    static getInstance() {
-        if (!RequirementService.instance) {
-            RequirementService.instance = new RequirementService();
-        }
-        return RequirementService.instance;
-    }
-    /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
-     */
-    async checkRequirementStatus(requirement, options) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Check the installation status
-        return await this.installerFactory.checkInstallation(requirement, options);
-    }
-    /**
-     * Check if updates are available for a requirement
-     * @param requirement The requirement to check for updates
-     * @returns Updated status with available updates information
-     */
-    async checkRequirementForUpdates(requirement, currentStatus) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Get current status
-        // Check for updates using the appropriate installer
-        const installer = this.installerFactory.getInstaller(requirement);
-        if (!installer || !installer.supportCheckUpdates()) {
-            return currentStatus;
-        }
-        // Pass pythonEnv from currentStatus if it exists for pip packages
-        const options = requirement.type === 'pip' && currentStatus.pythonEnv
-            ? { settings: { pythonEnv: currentStatus.pythonEnv } }
-            : undefined;
-        const status = await this.checkRequirementStatus(requirement, options);
-        return await installer.checkForUpdates(requirement, status);
-    }
-    /**
-     * Update a requirement to a new version
-     * @param requirement The requirement configuration
-     * @param updateVersion The version to update to
-     * @returns The updated requirement status
-     */
-    async updateRequirement(requirement, updateVersion, options) {
-        // Validate requirement
-        this.validateRequirement(requirement);
-        // Create an updated requirement with the new version
-        const updatedRequirement = {
-            ...requirement,
-            version: requirement.version.includes('latest') ? requirement.version : updateVersion,
-        };
-        // Install the updated version
-        return await this.installerFactory.install(updatedRequirement, options);
-    }
-    /**
-     * Validate a requirement configuration
-     * @param requirement The requirement to validate
-     * @throws Error if the requirement is invalid
-     */
-    validateRequirement(requirement) {
-        // Ensure requirement has required fields
-        if (!requirement.name) {
-            throw new Error('Requirement name is required');
-        }
-        if (!requirement.type) {
-            throw new Error('Requirement type is required');
-        }
-        // For type 'other', registry must be specified
-        if (requirement.type === 'other' && !requirement.registry) {
-            throw new Error('Registry must be specified for requirement type "other"');
-        }
-        // Validate registry configuration if provided
-        if (requirement.registry) {
-            const { githubRelease, artifacts } = requirement.registry;
-            // Validate GitHub release configuration
-            if (githubRelease) {
-                if (!githubRelease.repository) {
-                    throw new Error('Repository is required for GitHub release registry');
-                }
-                if (!githubRelease.assetName) {
-                    throw new Error('Asset name is required for GitHub release registry');
-                }
-            }
-            // Validate artifacts registry configuration
-            if (artifacts) {
-                if (!artifacts.registryUrl) {
-                    throw new Error('Registry URL is required for artifacts registry');
-                }
-            }
-        }
-    }
-}
-// Export a singleton instance
-export const requirementService = RequirementService.getInstance();
-//# sourceMappingURL=RequirementService.js.map

package/dist/core/ServerSchemaLoader.d.ts

@@ -1,11 +0,0 @@
-import { ServerSchema } from './ServerSchemaProvider.js';
-export declare class ServerSchemaLoader {
-    /**
-     * Load schema for a specific server in a category
-     */
-    static loadSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
-    /**
-     * Validate schema content against expected format
-     */
-    static validateSchema(schema: any): boolean;
-}

package/dist/core/ServerSchemaLoader.js

@@ -1,43 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
-import { Logger } from '../utils/logger.js';
-export class ServerSchemaLoader {
-    /**
-     * Load schema for a specific server in a category
-     */
-    static async loadSchema(categoryName, serverName) {
-        try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, `${serverName}.json`);
-            const content = await fs.readFile(schemaPath, 'utf8');
-            const schema = JSON.parse(content);
-            // Validate schema structure
-            if (!schema.version || !schema.schema) {
-                Logger.debug(`Invalid schema format for server ${serverName} in category ${categoryName}`);
-                return undefined;
-            }
-            return {
-                schema: schema
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for server ${serverName} in category ${categoryName}`);
-                return undefined;
-            }
-            Logger.error(`Error loading schema for server ${serverName} in category ${categoryName}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Validate schema content against expected format
-     */
-    static validateSchema(schema) {
-        return (typeof schema === 'object' &&
-            schema !== null &&
-            typeof schema.version === 'string' &&
-            typeof schema.schema === 'object' &&
-            schema.schema !== null);
-    }
-}
-//# sourceMappingURL=ServerSchemaLoader.js.map

package/dist/core/ServerSchemaProvider.d.ts

@@ -1,17 +0,0 @@
-export interface ServerSchema {
-    schema: Record<string, any>;
-}
-export declare class ServerSchemaProvider {
-    private static instance;
-    private schemaMap;
-    private schemaLock;
-    private constructor();
-    static getInstance(): Promise<ServerSchemaProvider>;
-    private withLock;
-    initialize(): Promise<void>;
-    private loadSchema;
-    private loadAllSchemas;
-    getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined>;
-    reloadSchemas(): Promise<void>;
-}
-export declare function getServerSchemaProvider(): Promise<ServerSchemaProvider>;

package/dist/core/ServerSchemaProvider.js

@@ -1,120 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
-import { Logger } from '../utils/logger.js';
-export class ServerSchemaProvider {
-    static instance;
-    schemaMap;
-    schemaLock = Promise.resolve();
-    constructor() {
-        this.schemaMap = new Map();
-    }
-    static async getInstance() {
-        if (!ServerSchemaProvider.instance) {
-            ServerSchemaProvider.instance = new ServerSchemaProvider();
-            await ServerSchemaProvider.instance.initialize();
-        }
-        return ServerSchemaProvider.instance;
-    }
-    async withLock(operation) {
-        const current = this.schemaLock;
-        let resolve;
-        this.schemaLock = new Promise(r => resolve = r);
-        try {
-            await current;
-            return await operation();
-        }
-        finally {
-            resolve();
-        }
-    }
-    async initialize() {
-        await this.withLock(async () => {
-            try {
-                // Create feeds directory if it doesn't exist
-                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
-                // Load all schemas from the feeds directory
-                await this.loadAllSchemas();
-            }
-            catch (error) {
-                Logger.error('Error during schema initialization:', error);
-                throw error;
-            }
-        });
-    }
-    async loadSchema(categoryName, schemaFileName) {
-        try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
-            const content = await fs.readFile(schemaPath, 'utf8');
-            const schema = JSON.parse(content);
-            return {
-                schema: schema
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
-                return undefined;
-            }
-            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
-            throw error;
-        }
-    }
-    async loadAllSchemas() {
-        this.schemaMap.clear();
-        // Read server category directories
-        const categoryDirs = await fs.readdir(LOCAL_FEEDS_SCHEMA_DIR, { withFileTypes: true });
-        for (const categoryDir of categoryDirs) {
-            if (categoryDir.isDirectory()) {
-                const categoryPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryDir.name);
-                const serverFiles = await fs.readdir(categoryPath);
-                const serverSchemas = new Map();
-                for (const file of serverFiles) {
-                    if (file.endsWith('.json')) {
-                        try {
-                            const schema = await this.loadSchema(categoryDir.name, file);
-                            if (schema) {
-                                // Store with the complete file name for direct lookup
-                                serverSchemas.set(file, schema);
-                            }
-                        }
-                        catch (error) {
-                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
-                        }
-                    }
-                }
-                if (serverSchemas.size > 0) {
-                    this.schemaMap.set(categoryDir.name, serverSchemas);
-                }
-            }
-        }
-    }
-    async getSchema(categoryName, schemaFileName) {
-        return await this.withLock(async () => {
-            const categorySchemas = this.schemaMap.get(categoryName);
-            if (!categorySchemas) {
-                Logger.debug(`No schemas found for category ${categoryName}`);
-                return undefined;
-            }
-            const schema = categorySchemas.get(schemaFileName);
-            if (!schema) {
-                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
-            }
-            return schema;
-        });
-    }
-    async reloadSchemas() {
-        return await this.withLock(async () => {
-            await this.loadAllSchemas();
-        });
-    }
-}
-// Export a lazy initialized singleton instance getter
-let initPromise = null;
-export function getServerSchemaProvider() {
-    if (!initPromise) {
-        initPromise = ServerSchemaProvider.getInstance();
-    }
-    return initPromise;
-}
-//# sourceMappingURL=ServerSchemaProvider.js.map

package/dist/core/constants.d.ts

@@ -1,47 +0,0 @@
-/**
- * Defines constants used across the application.
- */
-/**
- * GitHub repository configuration for feeds
- */
-export declare const GITHUB_REPO: {
-    url: string;
-    repoName: string;
-    feedsPath: string;
-    feedAssetsName: string;
-};
-/**
- * Local settings directory path based on OS
- */
-export declare const SETTINGS_DIR: string;
-/**
- * Local feeds directory path
- */
-export declare const LOCAL_FEEDS_DIR: string;
-export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
-/**
- * Supported client configurations.
- * Key: Client name (e.g., 'vscode')
- * Value: Client-specific settings or configuration details.
- * TODO: Define actual client settings structure.
- */
-export declare const SUPPORTED_CLIENTS: Record<string, {
-    extension: {
-        extensionId: string;
-        leastVersion?: string;
-        repository?: string;
-        assetName?: string;
-        private?: boolean;
-    };
-    codeSettingPath: string;
-    codeInsiderSettingPath: string;
-}>;
-/**
- * List of supported client names.
- */
-export declare const SUPPORTED_CLIENT_NAMES: string[];
-/**
- * Minimum time between requirement update checks (in milliseconds)
- * 10 minutes = 10 * 60 * 1000 = 600000 ms
- */
-export declare const UPDATE_CHECK_INTERVAL_MS: number;

package/dist/core/constants.js

@@ -1,94 +0,0 @@
-import os from 'os';
-import path from 'path';
-/**
- * Defines constants used across the application.
- */
-/**
- * GitHub repository configuration for feeds
- */
-export const GITHUB_REPO = {
-    url: 'https://github.com/ai-microsoft/imcp-feed.git',
-    repoName: 'ai-microsoft/imcp-feed',
-    feedsPath: 'feeds',
-    feedAssetsName: 'imcp-feeds-${latest}.zip',
-};
-/**
- * Local settings directory path based on OS
- */
-export const SETTINGS_DIR = (() => {
-    switch (process.platform) {
-        case 'win32':
-            return path.join(os.homedir(), '.imcp');
-        default: // linux, darwin (macOS), etc.
-            return path.join(os.homedir(), '.imcp');
-    }
-})();
-/**
- * Local feeds directory path
- */
-export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
-export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
-const CODE_STRORAGE_DIR = (() => {
-    switch (process.platform) {
-        case 'win32':
-            return path.join(os.homedir(), 'AppData', 'Roaming', 'Code', 'User');
-        case 'darwin': // macOS
-            return path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User');
-        default: // linux
-            return path.join(os.homedir(), '.config', 'Code', 'User');
-    }
-})();
-const CODE_INSIDER_STRORAGE_DIR = (() => {
-    switch (process.platform) {
-        case 'win32':
-            return path.join(os.homedir(), 'AppData', 'Roaming', 'Code - Insiders', 'User');
-        case 'darwin': // macOS
-            return path.join(os.homedir(), 'Library', 'Application Support', 'Code - Insiders', 'User');
-        default: // linux
-            return path.join(os.homedir(), '.config', 'Code - Insiders', 'User');
-    }
-})();
-/**
- * Supported client configurations.
- * Key: Client name (e.g., 'vscode')
- * Value: Client-specific settings or configuration details.
- * TODO: Define actual client settings structure.
- */
-export const SUPPORTED_CLIENTS = {
-    'MSRooCode': {
-        extension: {
-            extensionId: 'microsoftai.ms-roo-cline',
-            leastVersion: '0.0.8',
-            repository: 'ai-microsoft/roo-cline',
-            assetName: 'ms-roo-cline-${version}.vsix',
-            private: true
-        },
-        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
-        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
-    },
-    'Cline': {
-        extension: {
-            extensionId: 'saoudrizwan.claude-dev',
-        },
-        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
-    },
-    'GithubCopilot': {
-        extension: {
-            extensionId: 'github.copilot',
-        },
-        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
-        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
-    },
-    // Add other supported clients here
-};
-/**
- * List of supported client names.
- */
-export const SUPPORTED_CLIENT_NAMES = Object.keys(SUPPORTED_CLIENTS);
-/**
- * Minimum time between requirement update checks (in milliseconds)
- * 10 minutes = 10 * 60 * 1000 = 600000 ms
- */
-export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
-//# sourceMappingURL=constants.js.map

package/dist/core/installers/BaseInstaller.d.ts

@@ -1,74 +0,0 @@
-import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../types.js';
-import { RequirementInstaller } from './RequirementInstaller.js';
-/**
- * Abstract base class with common functionality for all requirement installers
- */
-export declare abstract class BaseInstaller implements RequirementInstaller {
-    protected execPromise: (command: string) => Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-    protected downloadsDir: string;
-    constructor(execPromise: (command: string) => Promise<{
-        stdout: string;
-        stderr: string;
-    }>);
-    abstract canHandle(requirement: RequirementConfig): boolean;
-    abstract supportCheckUpdates(): boolean;
-    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Check if updates are available for the requirement
-     * @param requirement The requirement to check
-     * @param currentStatus The current status of the requirement
-     * @returns The status of the requirement with update information
-     */
-    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
-    /**
-     * Helper method to ensure downloads directory exists
-     */
-    protected ensureDownloadsDir(): Promise<void>;
-    /**
-     * 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
-     */
-    protected handleGitHubRelease(requirement: RequirementConfig, registry: RegistryConfig['githubRelease']): Promise<{
-        resolvedVersion: string;
-        resolvedPath: string;
-    }>;
-    /**
-     * Helper to handle artifact registry downloads
-     * @param requirement The requirement configuration
-     * @param registry The artifacts registry configuration
-     * @returns The registry URL
-     */
-    protected handleArtifactsRegistry(requirement: RequirementConfig, registry: RegistryConfig['artifacts']): Promise<string>;
-    /**
-     * Helper to handle local path registry
-     * @param requirement The requirement configuration
-     * @param registry The local registry configuration
-     * @returns The local path or extracted asset path
-     */
-    protected handleLocalRegistry(requirement: RequirementConfig, registry: RegistryConfig['local']): Promise<string>;
-    private fileExists;
-    /**
-     * Get the latest version available for a GitHub repository
-     * @param repository The GitHub repository in format 'owner/repo'
-     * @returns The latest version or tag
-     */
-    protected getGitHubLatestVersion(repository: string): Promise<string>;
-    /**
-     * Get the latest version available for an NPM package
-     * @param packageName The name of the NPM package
-     * @returns The latest version
-     */
-    protected getNpmLatestVersion(packageName: string): Promise<string>;
-    /**
-     * Get the latest version available for a pip package
-     * @param packageName The name of the pip package
-     * @returns The latest version
-     */
-    protected getPipLatestVersion(packageName: string, options?: ServerInstallOptions): Promise<string>;
-}