@lobehub/chat 1.96.20 → 1.97.0

package/src/server/services/mcp/deps/MCPSystemDepsCheckService.ts

@@ -0,0 +1,238 @@
+import { DeploymentOption, SystemDependency } from '@lobehub/market-sdk';
+import debug from 'debug';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { SystemDependencyCheckResult } from '@/types/plugins';
+
+import { InstallationChecker, PackageInstallCheckResult } from './types';
+
+const execPromise = promisify(exec);
+const log = debug('lobe-mcp:deps-check');
+
+// Helper function to get current platform install instructions
+const getCurrentPlatformInstructions = (installInstructions: any) => {
+  if (!installInstructions) return undefined;
+
+  const platform = process.platform;
+  let current: string | undefined;
+
+  // Map platform to instruction key
+  switch (platform) {
+    case 'darwin': {
+      current = installInstructions.macos;
+      break;
+    }
+    case 'linux': {
+      current = installInstructions.linux_debian || installInstructions.linux;
+      break;
+    }
+    case 'win32': {
+      current = installInstructions.windows;
+      break;
+    }
+  }
+
+  return {
+    current,
+    manual: installInstructions.manual,
+  };
+};
+
+/**
+ * MCP System Dependency Check Service
+ */
+
+class MCPSystemDepsCheckService {
+  private checkers: Map<string, InstallationChecker> = new Map();
+
+  /**
+   * Register installation checker
+   */
+  registerChecker(method: string, checker: InstallationChecker) {
+    this.checkers.set(method, checker);
+    log(`Installation checker registered: ${method}`);
+  }
+
+  /**
+   * Check system dependency version
+   */
+  async checkSystemDependency(dependency: SystemDependency): Promise<SystemDependencyCheckResult> {
+    try {
+      // If check command not provided, use generic command
+      const checkCommand = dependency.checkCommand || `${dependency.name} --version`;
+      log(`Checking system dependency: ${dependency.name}, command: ${checkCommand}`);
+
+      const { stdout, stderr } = await execPromise(checkCommand);
+      if (stderr && !stdout) {
+        return {
+          error: stderr,
+          installInstructions: getCurrentPlatformInstructions(
+            (dependency as any).installInstructions,
+          ),
+          installed: false,
+          meetRequirement: false,
+          name: dependency.name,
+          requiredVersion: (dependency as any).requiredVersion,
+        };
+      }
+
+      const output = stdout.trim();
+      let version = output;
+
+      // Process version parsing
+      if (dependency.versionParsingRequired) {
+        // Extract version number - usually in format vX.Y.Z or X.Y.Z
+        const versionMatch = output.match(/[Vv]?(\d+(\.\d+)*)/);
+        if (versionMatch) {
+          version = versionMatch[0];
+        }
+      }
+
+      let meetRequirement = true;
+
+      if (dependency.requiredVersion) {
+        // Extract numeric part
+        const currentVersion = version.replace(/^[Vv]/, ''); // Remove possible v prefix
+        const currentVersionNum = parseFloat(currentVersion);
+
+        // Extract condition and number from required version
+        const requirementMatch = dependency.requiredVersion.match(/([<=>]+)?(\d+(\.\d+)*)/);
+
+        if (requirementMatch) {
+          const [, operator = '=', requiredVersion] = requirementMatch;
+          const requiredNum = parseFloat(requiredVersion);
+
+          switch (operator) {
+            case '>=': {
+              meetRequirement = currentVersionNum >= requiredNum;
+              break;
+            }
+            case '>': {
+              meetRequirement = currentVersionNum > requiredNum;
+              break;
+            }
+            case '<=': {
+              meetRequirement = currentVersionNum <= requiredNum;
+              break;
+            }
+            case '<': {
+              meetRequirement = currentVersionNum < requiredNum;
+              break;
+            }
+            default: {
+              // Default equals
+              meetRequirement = currentVersionNum === requiredNum;
+              break;
+            }
+          }
+        }
+      }
+
+      log(
+        `System dependency check result: ${dependency.name}, installed: ${true}, meets requirement: ${meetRequirement}, version: ${version}`,
+      );
+      return {
+        installInstructions: getCurrentPlatformInstructions(
+          (dependency as any).installInstructions,
+        ),
+        installed: true,
+        meetRequirement,
+        name: dependency.name,
+        requiredVersion: (dependency as any).requiredVersion,
+        version,
+      };
+    } catch (error) {
+      log(`System dependency check error: ${dependency.name}, ${error}`);
+      return {
+        error: error instanceof Error ? error.message : 'Unknown error',
+        installInstructions: getCurrentPlatformInstructions(
+          (dependency as any).installInstructions,
+        ),
+        installed: false,
+        meetRequirement: false,
+        name: dependency.name,
+        requiredVersion: (dependency as any).requiredVersion,
+      };
+    }
+  }
+
+  /**
+   * Check deployment option
+   */
+  async checkDeployOption(option: DeploymentOption): Promise<{
+    allDependenciesMet: boolean;
+    configSchema?: any;
+    connection: any;
+    isRecommended?: boolean;
+    needsConfig?: boolean;
+    packageInstalled: boolean;
+    systemDependencies: SystemDependencyCheckResult[];
+  }> {
+    const systemDependenciesResults: SystemDependencyCheckResult[] = [];
+
+    // Check system dependencies
+    if (option.systemDependencies && option.systemDependencies.length > 0) {
+      for (const dep of option.systemDependencies) {
+        const result = await this.checkSystemDependency(dep);
+        systemDependenciesResults.push(result);
+      }
+    }
+
+    // Get corresponding installation checker
+    const checker = this.checkers.get(option.installationMethod);
+    let packageInstalled = false;
+    let packageResult: PackageInstallCheckResult | null = null;
+
+    if (checker) {
+      // Use specific installation checker to check package installation status
+      packageResult = await checker.checkPackageInstalled(option.installationDetails);
+      packageInstalled = packageResult.installed;
+    } else {
+      log(`Installation checker not found: ${option.installationMethod}`);
+    }
+
+    // Check if all system dependencies meet requirements
+    const allDependenciesMet = systemDependenciesResults.every((dep) => dep.meetRequirement);
+
+    // Check if configuration is required (有必填项)
+    const configSchema = option.connection?.configSchema;
+    const needsConfig = Boolean(
+      configSchema &&
+        // 检查是否有 required 数组且不为空
+        ((Array.isArray(configSchema.required) && configSchema.required.length > 0) ||
+          // 检查 properties 中是否有字段标记为 required
+          (configSchema.properties &&
+            Object.values(configSchema.properties).some((prop: any) => prop.required === true))),
+    );
+
+    log(
+      `Configuration check result: needsConfig=${needsConfig}, required=${configSchema?.required}, configSchema=%O`,
+      configSchema,
+    );
+
+    // Create connection info
+    const connection = option.connection.url
+      ? {
+          ...option.connection,
+          type: 'http',
+        }
+      : {
+          ...option.connection,
+          type: 'stdio',
+        };
+
+    return {
+      allDependenciesMet,
+      configSchema,
+      connection,
+      isRecommended: option.isRecommended,
+      needsConfig,
+      packageInstalled,
+      systemDependencies: systemDependenciesResults,
+    };
+  }
+}
+
+// Create singleton instance
+export const mcpSystemDepsCheckService = new MCPSystemDepsCheckService();

package/src/server/services/mcp/deps/checkers/ManualInstallationChecker.ts

@@ -0,0 +1,20 @@
+import { InstallationChecker, PackageInstallCheckResult } from '../types';
+
+/**
+ * Manual Installation Checker
+ */
+export class ManualInstallationChecker implements InstallationChecker {
+  /**
+   * Check if manually installed package is installed
+   * Manually installed packages cannot be automatically detected, always returns not installed status, user needs to confirm manually
+   */
+  async checkPackageInstalled(details: {
+    packageName?: string;
+    repositoryUrlToClone?: string;
+  }): Promise<PackageInstallCheckResult> {
+    return {
+      installed: false,
+      packageName: details.packageName || details.repositoryUrlToClone || '',
+    };
+  }
+}

package/src/server/services/mcp/deps/checkers/NpmInstallationChecker.ts

@@ -0,0 +1,51 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { InstallationChecker, PackageInstallCheckResult } from '../types';
+
+const execPromise = promisify(exec);
+
+/**
+ * NPM Installation Checker
+ */
+export class NpmInstallationChecker implements InstallationChecker {
+  /**
+   * Check if npm package is installed
+   */
+  async checkPackageInstalled(details: {
+    packageName?: string;
+  }): Promise<PackageInstallCheckResult> {
+    if (!details.packageName) {
+      return {
+        error: 'Package name not provided',
+        installed: false,
+        packageName: '',
+      };
+    }
+
+    try {
+      const packageName = details.packageName;
+      // Use npm list to check if package is globally installed
+      const { stdout: globalStdout } = await execPromise(`npm list -g ${packageName} --depth=0`);
+      if (!globalStdout.includes('(empty)') && globalStdout.includes(packageName)) {
+        return {
+          installed: true,
+          packageName,
+        };
+      }
+
+      // Check if package can be used directly via npx (which also verifies if package is available)
+      await execPromise(`npx -y ${packageName} --version`);
+      return {
+        installed: true,
+        packageName,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : 'Unknown error',
+        installed: false,
+        packageName: details.packageName,
+      };
+    }
+  }
+}

package/src/server/services/mcp/deps/checkers/PythonInstallationChecker.ts

@@ -0,0 +1,69 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { InstallationChecker, PackageInstallCheckResult } from '../types';
+
+const execPromise = promisify(exec);
+
+/**
+ * Python Installation Checker
+ */
+export class PythonInstallationChecker implements InstallationChecker {
+  /**
+   * Check if Python package is installed
+   */
+  async checkPackageInstalled(details: {
+    packageName?: string;
+    pythonCommand?: string;
+  }): Promise<PackageInstallCheckResult> {
+    if (!details.packageName) {
+      return {
+        error: 'Package name not provided',
+        installed: false,
+        packageName: '',
+      };
+    }
+
+    try {
+      const packageName = details.packageName;
+      const pythonCommand = details.pythonCommand || 'python';
+
+      // Use pip list to check if package is installed
+      const command = `${pythonCommand} -m pip list | grep -i "${packageName}"`;
+      const { stdout } = await execPromise(command);
+
+      // If there's output and it contains the package name, consider it installed
+      if (stdout.trim() && stdout.toLowerCase().includes(packageName.toLowerCase())) {
+        return {
+          installed: true,
+          packageName,
+        };
+      }
+
+      // Try to directly import the package to verify
+      const importCommand = `${pythonCommand} -c "import ${packageName.replace('-', '_')}; print('Package installed')"`;
+      try {
+        const { stdout: importStdout } = await execPromise(importCommand);
+        if (importStdout.includes('Package installed')) {
+          return {
+            installed: true,
+            packageName,
+          };
+        }
+      } catch {
+        // Import failed, package may not exist
+      }
+
+      return {
+        installed: false,
+        packageName,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : 'Unknown error',
+        installed: false,
+        packageName: details.packageName,
+      };
+    }
+  }
+}

package/src/server/services/mcp/deps/index.ts

@@ -0,0 +1,14 @@
+import { mcpSystemDepsCheckService } from './MCPSystemDepsCheckService';
+import { ManualInstallationChecker } from './checkers/ManualInstallationChecker';
+import { NpmInstallationChecker } from './checkers/NpmInstallationChecker';
+import { PythonInstallationChecker } from './checkers/PythonInstallationChecker';
+
+// Register all checkers
+mcpSystemDepsCheckService.registerChecker('npm', new NpmInstallationChecker());
+mcpSystemDepsCheckService.registerChecker('python', new PythonInstallationChecker());
+mcpSystemDepsCheckService.registerChecker('manual', new ManualInstallationChecker());
+
+// Export service instance
+
+export { mcpSystemDepsCheckService } from './MCPSystemDepsCheckService';
+export * from './types';

package/src/server/services/mcp/deps/types.ts

@@ -0,0 +1,49 @@
+/**
+ * Installation Check Result
+ */
+export interface InstallCheckResult {
+  /**
+   * Error message
+   */
+  error?: string;
+  /**
+   * Whether installed
+   */
+  installed: boolean;
+  /**
+   * Whether meets version requirements
+   */
+  meetRequirement: boolean;
+  /**
+   * Version information
+   */
+  version?: string;
+}
+
+/**
+ * Package Installation Check Result
+ */
+export interface PackageInstallCheckResult {
+  /**
+   * Error message
+   */
+  error?: string;
+  /**
+   * Whether installed
+   */
+  installed: boolean;
+  /**
+   * Package name
+   */
+  packageName: string;
+}
+
+/**
+ * Installation Checker Interface
+ */
+export interface InstallationChecker {
+  /**
+   * Check if package is installed
+   */
+  checkPackageInstalled(details: any): Promise<PackageInstallCheckResult>;
+}