imcp 0.1.6 → 0.1.8-dev

package/dist/core/installers/PipInstaller.js

@@ -1,127 +0,0 @@
-import { BaseInstaller } from './BaseInstaller.js';
-/**
- * Installer implementation for Python packages using pip
- */
-export class PipInstaller extends BaseInstaller {
-    getPythonCommand(options) {
-        return options?.settings?.pythonEnv || 'python';
-    }
-    getPipCommand(options) {
-        const pythonCmd = this.getPythonCommand(options);
-        return `${pythonCmd} -m pip`;
-    }
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement) {
-        return requirement.type === 'pip';
-    }
-    supportCheckUpdates() {
-        /// temporarily disabling update check for pip as not able to get which pip of python is being used
-        return false;
-    }
-    /**
-     * Check if the Python package is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    async checkInstallation(requirement, options) {
-        try {
-            const pipCmd = this.getPipCommand(options);
-            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
-            // If we get an output and no error, the package is installed
-            const installed = stdout.includes(requirement.name);
-            const versionMatch = stdout.match(/Version: (.+)/);
-            const installedVersion = versionMatch ? versionMatch[1] : undefined;
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed,
-                version: installedVersion,
-                inProgress: false
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
-    }
-    /**
-     * Install the Python package
-     * @param requirement The requirement to install
-     * @returns The status of the installation
-     */
-    async install(requirement, options) {
-        try {
-            const status = await this.checkInstallation(requirement, options);
-            if (status.installed) {
-                return status;
-            }
-            const pipCmd = this.getPipCommand(options);
-            // If no registry is specified, use standard pip installation
-            if (!requirement.registry) {
-                // Standard pip installation
-                const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
-                if (stderr && stderr.toLowerCase().includes('error')) {
-                    throw new Error(stderr);
-                }
-            }
-            else {
-                // Handle different registry types
-                let packageSource;
-                if (requirement.registry.githubRelease) {
-                    const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
-                    packageSource = result.resolvedPath;
-                    // Install from the downloaded wheel or tar.gz file
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                }
-                else if (requirement.registry.artifacts) {
-                    const registryUrl = requirement.registry.artifacts.registryUrl;
-                    // Install using the custom index URL
-                    const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                }
-                else if (requirement.registry.local) {
-                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
-                    // Install from the local path
-                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
-                    if (stderr && stderr.toLowerCase().includes('error')) {
-                        throw new Error(stderr);
-                    }
-                }
-                else {
-                    throw new Error('Invalid registry configuration');
-                }
-            }
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: true,
-                version: requirement.version,
-                inProgress: false
-            };
-        }
-        catch (error) {
-            return {
-                name: requirement.name,
-                type: 'pip',
-                installed: false,
-                error: error instanceof Error ? error.message : String(error),
-                inProgress: false
-            };
-        }
-    }
-}
-//# sourceMappingURL=PipInstaller.js.map

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

@@ -1,33 +0,0 @@
-import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../types.js';
-/**
- * Interface for requirement installers.
- * Implementations should handle specific requirement types.
- */
-export interface RequirementInstaller {
-    /**
-     * Check if this installer can handle the given requirement type
-     * @param requirement The requirement to check
-     * @returns True if this installer can handle the requirement
-     */
-    canHandle(requirement: RequirementConfig): boolean;
-    supportCheckUpdates(): boolean;
-    /**
-     * Install the requirement
-     * @param requirement The requirement to install
-     * @returns The status of the installation
-     */
-    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
-    /**
-     * Check if the requirement is already installed
-     * @param requirement The requirement to check
-     * @returns The status of the requirement
-     */
-    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>;
-}

package/dist/core/installers/RequirementInstaller.js

@@ -1,3 +0,0 @@
-export {};
-// Note: Do not re-export implementations from here to avoid circular dependencies
-//# sourceMappingURL=RequirementInstaller.js.map

package/dist/core/types.d.ts

@@ -1,166 +0,0 @@
-export declare enum OSType {
-    Windows = "windows",
-    MacOS = "macos",
-    Linux = "linux"
-}
-export interface RequirementStatus {
-    name: string;
-    type: string;
-    installed: boolean;
-    inProgress?: boolean;
-    version?: string;
-    error?: string;
-    availableUpdate?: {
-        version: string;
-        message: string;
-    };
-    lastCheckTime?: string;
-    operationStatus?: OperationStatus;
-    pythonEnv?: string;
-    npmPath?: string;
-}
-export interface MCPServerStatus {
-    installedStatus: Record<string, OperationStatus>;
-    name: string;
-    tags?: string[];
-    error?: string;
-}
-export interface OperationStatus {
-    status: 'pending' | 'in-progress' | 'completed' | 'failed';
-    type: 'install' | 'uninstall' | 'update' | 'check';
-    target: 'requirement' | 'server';
-    message?: string;
-    error?: string;
-    operationId?: string;
-}
-export interface InstallationStatus {
-    requirementsStatus: Record<string, RequirementStatus>;
-    serversStatus: Record<string, MCPServerStatus>;
-    lastUpdated: string;
-}
-export interface MCPServerCategory {
-    name: string;
-    displayName: string;
-    description?: string;
-    type: 'local';
-    tags?: string[];
-    path?: string;
-    installationStatus?: InstallationStatus;
-    feedConfiguration?: FeedConfiguration;
-}
-export interface ServerCategoryListOptions {
-    local?: boolean;
-}
-export interface ServerOperationResult {
-    success: boolean;
-    message?: string;
-    error?: Error;
-    output?: string;
-    status?: OperationStatus[];
-}
-export interface MCPConfiguration {
-    localServerCategories: MCPServerCategory[];
-    feeds: Record<string, FeedConfiguration>;
-    clientMCPSettings?: Record<string, Record<string, any>>;
-}
-export interface ServerInstallOptions {
-    force?: boolean;
-    env?: Record<string, string>;
-    targetClients?: string[];
-    requirements?: RequirementConfig[];
-    args?: string[];
-    settings?: Record<string, any>;
-}
-export interface UpdateRequirementOptions {
-    requirementName: string;
-    updateVersion: string;
-}
-export interface ServerUninstallOptions {
-    removeData?: boolean;
-    targets?: string[];
-}
-export interface EnvVariableConfig {
-    Required: boolean;
-    Description: string;
-    Default?: string;
-}
-export interface InstallationConfig {
-    command: string;
-    args: string[];
-    env?: Record<string, EnvVariableConfig>;
-    url?: string;
-}
-export interface DependencyConfig {
-    requirements?: Array<{
-        name: string;
-        version: string;
-        order?: number;
-    }>;
-    mcpServers?: Array<{
-        name: string;
-    }>;
-}
-export interface McpConfig {
-    name: string;
-    description: string;
-    mode: 'stdio' | 'sse';
-    dependencies?: DependencyConfig;
-    schemas?: string;
-    repository?: string;
-    installation: InstallationConfig;
-}
-export interface RegistryConfig {
-    githubRelease?: {
-        repository: string;
-        assetsName?: string;
-        assetName: string;
-    };
-    artifacts?: {
-        registryUrl: string;
-        registryName: string;
-    };
-}
-export interface RequirementConfig {
-    name: string;
-    type: 'npm' | 'pip' | 'command' | 'extension' | 'other';
-    alias?: string;
-    version: string;
-    registry?: RegistryConfig;
-}
-export interface FeedConfiguration {
-    name: string;
-    displayName: string;
-    description: string;
-    repository?: string;
-    requirements: RequirementConfig[];
-    mcpServers: McpConfig[];
-}
-export interface ClientSettings {
-    codeSettingPath: string;
-    codeInsiderSettingPath: string;
-}
-export declare enum MCPEvent {
-    SERVER_INSTALLED = "server:installed",
-    SERVER_UNINSTALLED = "server:uninstalled",
-    SERVER_STARTED = "server:started",
-    SERVER_STOPPED = "server:stopped",
-    CONFIG_CHANGED = "config:changed"
-}
-export interface MCPEventData {
-    [MCPEvent.SERVER_INSTALLED]: {
-        server: MCPServerCategory;
-    };
-    [MCPEvent.SERVER_UNINSTALLED]: {
-        serverName: string;
-        targets?: string[];
-    };
-    [MCPEvent.SERVER_STARTED]: {
-        server: MCPServerCategory;
-    };
-    [MCPEvent.SERVER_STOPPED]: {
-        serverName: string;
-    };
-    [MCPEvent.CONFIG_CHANGED]: {
-        configuration: MCPConfiguration;
-    };
-}

package/dist/core/types.js

@@ -1,16 +0,0 @@
-export var OSType;
-(function (OSType) {
-    OSType["Windows"] = "windows";
-    OSType["MacOS"] = "macos";
-    OSType["Linux"] = "linux";
-})(OSType || (OSType = {}));
-// Events that can be emitted by the SDK
-export var MCPEvent;
-(function (MCPEvent) {
-    MCPEvent["SERVER_INSTALLED"] = "server:installed";
-    MCPEvent["SERVER_UNINSTALLED"] = "server:uninstalled";
-    MCPEvent["SERVER_STARTED"] = "server:started";
-    MCPEvent["SERVER_STOPPED"] = "server:stopped";
-    MCPEvent["CONFIG_CHANGED"] = "config:changed";
-})(MCPEvent || (MCPEvent = {}));
-//# sourceMappingURL=types.js.map

package/dist/services/InstallRequestValidator.d.ts

@@ -1,21 +0,0 @@
-import { ServerInstallOptions } from '../core/types.js';
-import { InstallServersRequestBody } from '../web/contract/serverContract.js';
-export declare class InstallRequestValidator {
-    private serverFeedConfigs;
-    private feedDirectory;
-    constructor(feedDirectory?: string);
-    private loadServerFeedConfiguration;
-    /**
-     * Validates the install request body for a specific server.
-     * @param serverName The name of the server to validate against.
-     * @param requestBody The installation request body.
-     * @returns An array of error messages, or an empty array if validation passes.
-     */
-    validate(serverName: string, requestBody: ServerInstallOptions): Promise<string[]>;
-    /**
-     * Validates the install request body for multiple servers.
-     * @param requestBody The installation request body containing multiple server names.
-     * @returns An object mapping server names to their validation errors. Empty arrays indicate success.
-     */
-    validateMultiple(requestBody: InstallServersRequestBody): Promise<Record<string, string[]>>;
-}

package/dist/services/InstallRequestValidator.js

@@ -1,99 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { SUPPORTED_CLIENT_NAMES } from '../core/constants.js';
-export class InstallRequestValidator {
-    serverFeedConfigs = new Map();
-    feedDirectory;
-    constructor(feedDirectory = path.join(__dirname, '../feeds')) {
-        this.feedDirectory = feedDirectory;
-        // Consider loading configs lazily or providing an explicit load method
-        // For now, let's assume pre-loading or loading on demand in validate
-    }
-    async loadServerFeedConfiguration(serverName) {
-        if (this.serverFeedConfigs.has(serverName)) {
-            return this.serverFeedConfigs.get(serverName);
-        }
-        const filePath = path.join(this.feedDirectory, `${serverName}.json`);
-        try {
-            const fileContent = await fs.readFile(filePath, 'utf-8');
-            const config = JSON.parse(fileContent);
-            // Basic validation of the loaded config structure could be added here
-            if (config && config.name === serverName) {
-                this.serverFeedConfigs.set(serverName, config);
-                return config;
-            }
-            console.error(`Configuration name mismatch in ${filePath}`);
-            return undefined;
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                console.warn(`Server feed configuration not found for: ${serverName} at ${filePath}`);
-            }
-            else {
-                console.error(`Error loading server feed configuration for ${serverName}:`, error);
-            }
-            return undefined;
-        }
-    }
-    /**
-     * Validates the install request body for a specific server.
-     * @param serverName The name of the server to validate against.
-     * @param requestBody The installation request body.
-     * @returns An array of error messages, or an empty array if validation passes.
-     */
-    async validate(serverName, requestBody) {
-        const errors = [];
-        const config = await this.loadServerFeedConfiguration(serverName);
-        if (!config) {
-            errors.push(`Server configuration feed not found for '${serverName}'.`);
-            // Cannot perform further validation without the config
-            return errors;
-        }
-        // 1.2 Validate required environment variables
-        config.mcpServers.forEach(mcp => {
-            if (mcp.installation?.env) {
-                Object.entries(mcp.installation.env).forEach(([envVar, envConfig]) => {
-                    if (envConfig.Required) {
-                        if (!requestBody.env || !(envVar in requestBody.env) || !requestBody.env[envVar]) {
-                            errors.push(`Missing required environment variable '${envVar}' for server '${serverName}' (category: ${mcp.name}).`);
-                        }
-                    }
-                });
-            }
-        });
-        // 1.3 Validate target clients
-        if (!requestBody.targetClients || requestBody.targetClients.length === 0) {
-            errors.push(`Request body must include a non-empty 'targetClients' array for server '${serverName}'.`);
-        }
-        else {
-            requestBody.targetClients.forEach((client) => {
-                if (!SUPPORTED_CLIENT_NAMES.includes(client)) {
-                    errors.push(`Unsupported target client '${client}' specified for server '${serverName}'. Supported clients are: ${SUPPORTED_CLIENT_NAMES.join(', ')}.`);
-                }
-            });
-        }
-        // Add other validation rules as needed
-        return errors;
-    }
-    /**
-     * Validates the install request body for multiple servers.
-     * @param requestBody The installation request body containing multiple server names.
-     * @returns An object mapping server names to their validation errors. Empty arrays indicate success.
-     */
-    async validateMultiple(requestBody) {
-        const results = {};
-        if (!requestBody.serverList || Object.keys(requestBody.serverList).length === 0) {
-            return { '_global': ['Request body must include a non-empty \'serverCategoryList\' record.'] };
-        }
-        for (const serverName of Object.keys(requestBody.serverList)) {
-            results[serverName] = await this.validate(serverName, requestBody.serverList[serverName]);
-        }
-        return results;
-    }
-}
-// Helper __dirname for ES modules
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Export a singleton instance (optional, depends on usage pattern)
-// export const installRequestValidator = new InstallRequestValidator();
-//# sourceMappingURL=InstallRequestValidator.js.map

package/dist/web/public/js/modal/installHandler.js

@@ -1,227 +0,0 @@
-import { showLoadingModal, appendLoadingMessage } from './loadingUI.js';
-import { compareVersions } from './version.js';
-
-/**
- * Handle bulk client installations
- * @param {string} categoryName Category name
- * @param {string} serverName Server name
- * @param {string[]} targets Target clients
- * @param {Object} options Installation options
- */
-export async function handleInstallation(categoryName, serverName, targets, options = {}) {
-    const { envVars = {}, installingMessage = "Starting installation...", serverData = null } = options;
-
-    hideInstallModal();
-    initializeInstallation(installingMessage, serverData, serverName, targets);
-
-    try {
-        await executeInstallation(categoryName, serverName, targets, options);
-    } catch (error) {
-        handleInstallationError(error);
-    }
-}
-
-/**
- * Handle uninstallation of tools
- * @param {string} categoryName Category name
- * @param {Object|Array} serverList Servers to uninstall
- * @param {string[]} targets Target clients
- */
-export async function handleUninstallation(categoryName, serverList, targets) {
-    const selectedTargets = getSelectedTargets(targets);
-    validateTargets(selectedTargets);
-
-    try {
-        await executeUninstallation(categoryName, serverList, selectedTargets);
-    } catch (error) {
-        handleUninstallationError(error);
-        throw error;
-    }
-}
-
-// Private helper functions
-
-function hideInstallModal() {
-    const installModal = document.getElementById('installModal');
-    if (installModal) {
-        installModal.style.display = "none";
-    }
-}
-
-function initializeInstallation(installingMessage, serverData, serverName, targets) {
-    showLoadingModal();
-
-    if (hasExistingStatus(serverData, serverName, targets)) {
-        const existingMessage = getExistingMessage(serverData, serverName, targets[0]);
-        if (existingMessage && existingMessage !== "Starting installation...") {
-            appendLoadingMessage(existingMessage);
-        }
-    }
-
-    appendLoadingMessage(installingMessage);
-}
-
-function hasExistingStatus(serverData, serverName, targets) {
-    return serverData?.data?.installationStatus?.serversStatus &&
-        targets?.length > 0;
-}
-
-function getExistingMessage(serverData, serverName, target) {
-    const serverStatuses = serverData.data.installationStatus.serversStatus;
-    const serverStatus = serverStatuses[serverName] || { installedStatus: {} };
-    return serverStatus.installedStatus?.[target]?.message;
-}
-
-async function executeInstallation(categoryName, serverName, targets, options) {
-    appendLoadingMessage("Installing, please wait...");
-
-    const requestBody = buildInstallRequestBody(serverName, targets, options);
-    const response = await fetchWithErrorHandling(
-        `api/categories/${categoryName}/install`,
-        requestBody
-    );
-
-    if (response.success) {
-        startStatusPolling(categoryName, serverName, targets, options);
-    }
-}
-
-function buildInstallRequestBody(serverName, targets, options) {
-    const { envVars = {}, args = [], pythonEnv, requirements = [] } = options;
-
-    const serverOptions = {
-        targetClients: targets,
-        env: envVars,
-        args: args,
-        settings: pythonEnv ? { pythonEnv } : undefined
-    };
-
-    if (requirements.length > 0) {
-        serverOptions.requirements = requirements;
-    }
-
-    return {
-        serverList: {
-            [serverName]: serverOptions
-        }
-    };
-}
-
-async function executeUninstallation(categoryName, serverList, selectedTargets) {
-    appendLoadingMessage('Starting uninstallation...');
-
-    const formattedServerList = formatServerList(serverList);
-    await fetchWithErrorHandling(
-        `api/categories/${categoryName}/uninstall`,
-        {
-            serverList: formattedServerList,
-            options: {
-                targets: selectedTargets,
-                removeData: true
-            }
-        }
-    );
-
-    appendLoadingMessage(`Successfully uninstalled from ${selectedTargets.join(', ')}`, true);
-    window.selectedClients = [];
-}
-
-function formatServerList(serverList) {
-    if (Array.isArray(serverList)) {
-        return serverList.reduce((acc, server) => {
-            acc[server] = { removeData: true };
-            return acc;
-        }, {});
-    }
-    return serverList;
-}
-
-async function fetchWithErrorHandling(endpoint, body) {
-    const response = await fetch(endpoint, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        },
-        body: JSON.stringify(body)
-    });
-
-    if (!response.ok) {
-        const errorData = await response.text();
-        throw new Error(`Operation failed: ${errorData || response.statusText}`);
-    }
-
-    const result = await response.json();
-    if (!result.success) {
-        throw new Error(result.error || 'Operation failed');
-    }
-
-    return result;
-}
-
-function handleInstallationError(error) {
-    console.error('[LoadingModal] Error:', error);
-    appendLoadingMessage(`<span style="color:red;">Error: ${error.message}</span>`);
-}
-
-function handleUninstallationError(error) {
-    console.error('Error uninstalling tools:', error);
-    appendLoadingMessage(`Error: ${error.message}`, true);
-}
-
-function getSelectedTargets(targets) {
-    return window.selectedClients || (Array.isArray(targets) ? targets : [targets]);
-}
-
-function validateTargets(selectedTargets) {
-    if (!selectedTargets || selectedTargets.length === 0) {
-        throw new Error('Please select at least one client to uninstall.');
-    }
-}
-
-// Status polling functionality
-async function startStatusPolling(categoryName, serverName, targets, options) {
-    const { requirements = [] } = options;
-    let lastMessages = {};
-    let lastRequirementMessages = {};
-    let lastRequirementErrorMessages = {};
-    let completionMessageSent = false;
-
-    const startTime = Date.now();
-    const maxTimeout = 10 * 60 * 1000; // 10 minutes
-
-    while (Date.now() - startTime < maxTimeout) {
-        try {
-            const status = await pollStatus(categoryName, serverName, targets, requirements);
-
-            if (status.isComplete) {
-                sendCompletionMessage(status, targets);
-                return;
-            }
-
-            updateMessages(status, lastMessages, lastRequirementMessages, lastRequirementErrorMessages);
-        } catch (error) {
-            console.error('[LoadingModal] Error polling status:', error);
-        }
-
-        await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-
-    handlePollingTimeout(completionMessageSent);
-}
-
-async function pollStatus(categoryName, serverName, targets, requirements) {
-    const response = await fetch(`api/categories/${categoryName}`);
-    if (!response.ok) {
-        throw new Error('Failed to fetch status');
-    }
-
-    const data = await response.json();
-    return processStatusData(data, serverName, targets, requirements);
-}
-
-function processStatusData(data, serverName, targets, requirements) {
-    // Implementation details for processing status data
-    // This would include checking requirements status and target status
-    // Returns an object with status information
-}