imcp 0.0.1

package/src/core/installers/InstallerFactory.ts

@@ -0,0 +1,109 @@
+import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementInstaller } from './RequirementInstaller.js';
+import { NpmInstaller } from './NpmInstaller.js';
+import { PipInstaller } from './PipInstaller.js';
+import { CommandInstaller } from './CommandInstaller.js';
+import { GeneralInstaller } from './GeneralInstaller.js';
+import { exec } from 'child_process';
+import util from 'util';
+
+/**
+ * Factory for creating the appropriate installer for a requirement
+ */
+export class InstallerFactory {
+    private installers: RequirementInstaller[] = [];
+    private readonly execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>;
+
+    /**
+     * Create a new InstallerFactory
+     * @param execPromise Function to execute commands
+     */
+    constructor(execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>) {
+        this.execPromise = execPromise;
+        this.registerDefaultInstallers();
+    }
+
+    /**
+     * Register default installers for npm, pip, and general requirements
+     * @private
+     */
+    private registerDefaultInstallers(): void {
+        this.registerInstaller(new NpmInstaller(this.execPromise));
+        this.registerInstaller(new PipInstaller(this.execPromise));
+        this.registerInstaller(new CommandInstaller(this.execPromise));
+        this.registerInstaller(new GeneralInstaller(this.execPromise));
+    }
+
+    /**
+     * Register a custom installer
+     * @param installer The installer to register
+     */
+    public registerInstaller(installer: RequirementInstaller): void {
+        this.installers.push(installer);
+    }
+
+    /**
+     * Get the appropriate installer for a requirement
+     * @param requirement The requirement to get an installer for
+     * @returns The appropriate installer, or undefined if none found
+     */
+    public getInstaller(requirement: RequirementConfig): RequirementInstaller | undefined {
+        // Validate that if registry is empty, type must not be 'other'
+        if (!requirement.registry && requirement.type === 'other') {
+            throw new Error('Registry must be specified for requirement type "other"');
+        }
+
+        return this.installers.find(installer => installer.canHandle(requirement));
+    }
+
+    /**
+     * Install a requirement using the appropriate installer
+     * @param requirement The requirement to install
+     * @returns The installation status
+     */
+    public async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+        const installer = this.getInstaller(requirement);
+        if (!installer) {
+            return {
+                name: requirement.name,
+                type: requirement.type,
+                installed: false,
+                error: `No installer found for requirement type '${requirement.type}'`,
+                inProgress: false
+            };
+        }
+
+        return await installer.install(requirement);
+    }
+
+    /**
+     * Check the installation status of a requirement
+     * @param requirement The requirement to check
+     * @returns The installation status
+     */
+    public async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+        const installer = this.getInstaller(requirement);
+        if (!installer) {
+            return {
+                name: requirement.name,
+                type: requirement.type,
+                installed: false,
+                error: `No installer found for requirement type '${requirement.type}'`,
+                inProgress: false
+            };
+        }
+
+        return await installer.checkInstallation(requirement);
+    }
+}
+
+/**
+ * Create a new InstallerFactory with default settings
+ * @param execPromise Optional function to execute commands
+ * @returns A new InstallerFactory
+ */
+export const createInstallerFactory = (
+    execPromise = util.promisify(exec)
+): InstallerFactory => {
+    return new InstallerFactory(execPromise);
+};

package/src/core/installers/NpmInstaller.ts

@@ -0,0 +1,128 @@
+import { stat } from 'fs';
+import { RequirementConfig, RequirementStatus } from '../types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+
+/**
+ * Installer implementation for NPM packages
+ */
+export class NpmInstaller 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: RequirementConfig): boolean {
+        return requirement.type === 'npm';
+    }
+
+    /**
+     * Check if the NPM package is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+        try {
+            const { stdout } = await this.execPromise(`npm list -g ${requirement.name} --json`);
+            const pkgInfo = JSON.parse(stdout);
+            const installedVersion = pkgInfo?.dependencies?.[requirement.name]?.version;
+
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: !!installedVersion,
+                version: installedVersion,
+                inProgress: false
+            };
+        } catch (error) {
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+
+    /**
+     * Install the NPM package
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+        try {
+            const status = await this.checkInstallation(requirement);
+            if (status.installed) {
+                return status;
+            }
+
+            let resolvedVersion = requirement.version;
+
+            // If no registry is specified, use standard npm installation
+            if (!requirement.registry) {
+                const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
+                if (stderr && !stderr.includes('added')) {
+                    throw new Error(stderr);
+                }
+            } else {
+                // Handle different registry types
+                let packageSource: string;
+
+                if (requirement.registry.githubRelease) {
+                    const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                    packageSource = result.resolvedPath;
+                    resolvedVersion = result.resolvedVersion;
+                } else if (requirement.registry.artifacts) {
+                    // For npm with artifacts, configure npm to use the specified registry URL
+                    const registryUrl = requirement.registry.artifacts.registryUrl;
+                    await this.execPromise(`npm config set registry ${registryUrl}`);
+
+                    // Now install the package with the configured registry
+                    const { stderr } = await this.execPromise(`npm install -g ${requirement.name}@${requirement.version}`);
+                    if (stderr && !stderr.includes('added')) {
+                        // Reset the registry to the default npm registry
+                        await this.execPromise('npm config set registry https://registry.npmjs.org/');
+                        throw new Error(stderr);
+                    }
+
+                    // Reset the registry to the default npm registry
+                    await this.execPromise('npm config set registry https://registry.npmjs.org/');
+                    return {
+                        name: requirement.name,
+                        type: 'npm',
+                        installed: true,
+                        version: requirement.version,
+                        inProgress: false
+                    };
+                } else if (requirement.registry.local) {
+                    packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
+                } else {
+                    throw new Error('Invalid registry configuration');
+                }
+
+                // Install from the package source
+                const { stderr } = await this.execPromise(`npm install -g "${packageSource}"`);
+                if (stderr && !stderr.includes('added')) {
+                    const status = await this.checkInstallation(requirement);
+                    if (!status.installed) throw new Error(stderr);
+                }
+            }
+
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: true,
+                version: resolvedVersion,
+                inProgress: false
+            };
+        } catch (error) {
+            return {
+                name: requirement.name,
+                type: 'npm',
+                installed: false,
+                error: error instanceof Error ? error.message : String(error),
+                inProgress: false
+            };
+        }
+    }
+}

package/src/core/installers/PipInstaller.ts

@@ -0,0 +1,121 @@
+import { RequirementConfig, RequirementStatus } from '../types.js';
+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: RequirementConfig): boolean {
+        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: RequirementConfig): Promise<RequirementStatus> {
+        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: RequirementConfig): Promise<RequirementStatus> {
+        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: string;
+
+                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
+            };
+        }
+    }
+}

package/src/core/installers/RequirementInstaller.ts

@@ -0,0 +1,38 @@
+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>;
+}
+
+// Note: Do not re-export implementations from here to avoid circular dependencies

package/src/core/installers/index.ts

@@ -0,0 +1,9 @@
+// Export the interface
+export { RequirementInstaller } from './RequirementInstaller.js';
+
+// 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';

package/src/core/types.ts

@@ -0,0 +1,163 @@
+export 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>; // client: installed
+  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; // Added to track async operations
+}
+
+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; // Added to capture installation logs
+  status?: OperationStatus[]; // Added to capture operation status
+}
+
+export interface MCPConfiguration {
+  localServerCategories: MCPServerCategory[];
+  feeds: Record<string, FeedConfiguration>;
+}
+
+export interface ServerInstallOptions {
+  force?: boolean;
+  env?: Record<string, string>; // Environment variables for installation
+  targetClients?: string[]; // Target clients for configuration
+}
+
+export interface ServerUninstallOptions {
+  removeData?: boolean;
+}
+
+// Types related to server feed configuration (e.g., ai-coder-tools.json)
+export interface EnvVariableConfig {
+  Required: boolean;
+  Description: string;
+  Default?: string;
+}
+
+export interface InstallationConfig {
+  command: string;
+  args: string[]; // Can use ${packageSource} as template variable for installation path
+  env?: Record<string, EnvVariableConfig>; // Note the colon in property name
+}
+
+export interface DependencyConfig {
+  requirements?: Array<{
+    name: string;
+    version: string;
+  }>;
+  mcpServers?: Array<{
+    name: string;
+  }>;
+}
+
+export interface McpConfig {
+  name: string;
+  description: string;
+  mode: 'stdio' | 'http'; // Currently only stdio mode is supported in ai-coder-tools
+  dependencies?: DependencyConfig;
+  installation: InstallationConfig;
+}
+
+export interface RegistryConfig {
+  githubRelease?: {
+    repository: string;
+    assetsName?: string; // Template string like "ai-coder-tools-${latest}.zip"
+    assetName: string; // Template string like "ai-coder-tools-${latest}.tgz"
+  };
+  artifacts?: {
+    registryUrl: string;
+    assetName?: string; // Template string like "ai-coder-tools-${latest}.tgz"
+  };
+  local?: {
+    localPath: string; // Local path for local registry
+    assetName?: string; // Template string like "ai-coder-tools-${latest}.tgz"
+  }
+}
+
+export interface RequirementConfig {
+  name: string;
+  type: 'npm' | 'pip' | 'command' | 'other'; // Add other requirement types if needed
+  alias?: string; // Alias for the command type
+  version: string;
+  registry?: RegistryConfig;
+}
+
+export interface FeedConfiguration {
+  name: string;
+  displayName: string;
+  description: string;
+  requirements: RequirementConfig[];
+  mcpServers: McpConfig[];
+}
+
+// Events that can be emitted by the SDK
+export 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/src/index.ts

@@ -0,0 +1,44 @@
+// Public types
+export {
+  MCPServerCategory,
+  ServerCategoryListOptions,
+  ServerInstallOptions,
+  ServerUninstallOptions,
+  ServerOperationResult,
+  MCPConfiguration,
+  MCPEvent,
+  MCPEventData,
+  RequirementConfig,
+  RequirementStatus,
+  RegistryConfig
+} 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 {
+  RequirementInstaller,
+  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
+} as const;