imcp 0.0.1

package/dist/core/installers/PipInstaller.js

@@ -0,0 +1,114 @@
+import { BaseInstaller } from './BaseInstaller.js';
+/**
+ * Installer implementation for Python packages using pip
+ */
+export class PipInstaller extends BaseInstaller {
+    /**
+     * 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';
+    }
+    /**
+     * Check if the Python package is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement) {
+        try {
+            const { stdout, stderr } = await this.execPromise(`pip 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) {
+        try {
+            const status = await this.checkInstallation(requirement);
+            if (status.installed) {
+                return status;
+            }
+            // If no registry is specified, use standard pip installation
+            if (!requirement.registry) {
+                // Standard pip installation
+                const { stderr } = await this.execPromise(`pip 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(`pip 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(`pip 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(`pip 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,32 @@
+import { RequirementConfig, RequirementStatus } 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;
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig): Promise<RequirementStatus>;
+    /**
+     * Check if the requirement is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    checkInstallation(requirement: RequirementConfig): 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/installers/index.d.ts

@@ -0,0 +1,6 @@
+export { RequirementInstaller } from './RequirementInstaller.js';
+export { BaseInstaller } from './BaseInstaller.js';
+export { NpmInstaller } from './NpmInstaller.js';
+export { PipInstaller } from './PipInstaller.js';
+export { GeneralInstaller } from './GeneralInstaller.js';
+export { InstallerFactory, createInstallerFactory } from './InstallerFactory.js';

package/dist/core/installers/index.js

@@ -0,0 +1,7 @@
+// Export all installer implementations
+export { BaseInstaller } from './BaseInstaller.js';
+export { NpmInstaller } from './NpmInstaller.js';
+export { PipInstaller } from './PipInstaller.js';
+export { GeneralInstaller } from './GeneralInstaller.js';
+export { InstallerFactory, createInstallerFactory } from './InstallerFactory.js';
+//# sourceMappingURL=index.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,152 @@
+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;
+        checkTime: string;
+    };
+    operationStatus?: OperationStatus;
+    updateInfo?: {
+        available: boolean;
+        latestVersion?: string;
+        [key: string]: any;
+    } | null;
+}
+export interface MCPServerStatus {
+    installedStatus: Record<string, OperationStatus>;
+    name: 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';
+    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>;
+}
+export interface ServerInstallOptions {
+    force?: boolean;
+    env?: Record<string, string>;
+    targetClients?: string[];
+}
+export interface ServerUninstallOptions {
+    removeData?: boolean;
+}
+export interface EnvVariableConfig {
+    Required: boolean;
+    Description: string;
+    Default?: string;
+}
+export interface InstallationConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, EnvVariableConfig>;
+}
+export interface DependencyConfig {
+    requirements?: Array<{
+        name: string;
+        version: string;
+    }>;
+    mcpServers?: Array<{
+        name: string;
+    }>;
+}
+export interface McpConfig {
+    name: string;
+    description: string;
+    mode: 'stdio' | 'http';
+    dependencies?: DependencyConfig;
+    installation: InstallationConfig;
+}
+export interface RegistryConfig {
+    githubRelease?: {
+        repository: string;
+        assetsName?: string;
+        assetName: string;
+    };
+    artifacts?: {
+        registryUrl: string;
+        assetName?: string;
+    };
+    local?: {
+        localPath: string;
+        assetName?: string;
+    };
+}
+export interface RequirementConfig {
+    name: string;
+    type: 'npm' | 'pip' | 'command' | 'other';
+    alias?: string;
+    version: string;
+    registry?: RegistryConfig;
+}
+export interface FeedConfiguration {
+    name: string;
+    displayName: string;
+    description: string;
+    requirements: RequirementConfig[];
+    mcpServers: McpConfig[];
+}
+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;
+    };
+    [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/index.d.ts

@@ -0,0 +1,11 @@
+export { MCPServerCategory, ServerCategoryListOptions, ServerInstallOptions, ServerUninstallOptions, ServerOperationResult, MCPConfiguration, MCPEvent, MCPEventData, RequirementConfig, RequirementStatus, RegistryConfig } from './core/types.js';
+export { MCPManager, mcpManager } from './core/MCPManager.js';
+export { ServerService, serverService } from './services/ServerService.js';
+export { RequirementService, requirementService } from './core/RequirementService.js';
+export { RequirementInstaller, BaseInstaller, NpmInstaller, PipInstaller, GeneralInstaller, InstallerFactory, createInstallerFactory } from './core/installers/index.js';
+export { startWebServer } from './web/server.js';
+export declare const VERSION = "0.0.1";
+export declare const DEFAULT_CONFIG: {
+    readonly configPath: "./config/servers.json";
+    readonly webPort: 3000;
+};

package/dist/index.js

@@ -0,0 +1,19 @@
+// Public types
+export { MCPEvent } from './core/types.js';
+// Core functionality
+export { MCPManager, mcpManager } from './core/MCPManager.js';
+// Services
+export { ServerService, serverService } from './services/ServerService.js';
+export { RequirementService, requirementService } from './core/RequirementService.js';
+// Installer interfaces and implementations
+export { BaseInstaller, NpmInstaller, PipInstaller, GeneralInstaller, InstallerFactory, createInstallerFactory } from './core/installers/index.js';
+// Web server
+export { startWebServer } from './web/server.js';
+// Version information
+export const VERSION = '0.0.1';
+// Default configuration
+export const DEFAULT_CONFIG = {
+    configPath: './config/servers.json',
+    webPort: 3000
+};
+//# sourceMappingURL=index.js.map

package/dist/services/InstallRequestValidator.d.ts

@@ -0,0 +1,21 @@
+import { ServerInstallOptions } from '../core/types.js';
+import { InstallServersRequestBody } from '../web/server.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/services/ServerService.d.ts

@@ -0,0 +1,47 @@
+import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from '../core/types.js';
+/**
+ * ServerService provides a unified interface for server management operations.
+ * This layer handles business logic that's shared between the CLI and web interface.
+ */
+export declare class ServerService {
+    /**
+     * Lists available MCP servers based on the provided options
+     */
+    listServerCategories(options?: ServerCategoryListOptions): Promise<MCPServerCategory[]>;
+    /**
+     * Gets a server by name
+     */
+    getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined>;
+    /**
+     * Check for updates to requirements for a server category
+     * @param serverCategory The server category to check
+     * @private
+     */
+    private checkRequirementsForUpdate;
+    /**
+     * Installs a specific mcp tool for a server.
+     * TODO: This might require enhancing MCPManager to handle category-specific installs.
+     */
+    installMcpServer(category: string, serverName: string, options?: ServerInstallOptions): Promise<ServerOperationResult>;
+    /**
+     * Installs a specific mcp tool for a server.
+     * TODO: This might require enhancing MCPManager to handle category-specific installs.
+     */
+    uninstallMcpServer(category: string, serverName: string, options?: ServerUninstallOptions): Promise<ServerOperationResult>;
+    /**
+     * Validates server names
+     */
+    validateServerName(category: string, name: string): Promise<boolean>;
+    /**
+     * Formats success/error messages for operations
+     */
+    formatOperationResults(results: ServerOperationResult[]): {
+        success: boolean;
+        messages: string[];
+    };
+    /**
+     * Syncs MCP server configurations from remote feed source
+     */
+    syncFeeds(): Promise<void>;
+}
+export declare const serverService: ServerService;