imcp 0.1.4 → 0.1.6

package/dist/core/installers/PipInstaller.js

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

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

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

package/dist/core/types.d.ts

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

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

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

@@ -0,0 +1,99 @@
+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/index.html

@@ -47,7 +47,7 @@
                 <button id="onboardButton" style="display: none;"
                     class="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors flex items-center">
                     <i class='bx bx-plus-circle mr-2'></i>
-                    Onboard
+                    Publish Server
                 </button>
             </div>
             <script>