MCP Environment & Installation Manager

Implementation Reference

• src/tools/installation-tools.ts:82-113 (handler)

  The MCP tool handler for 'install-mcp', registered inline with server.tool(). Validates input, calls PackageManager.installPackage(), handles errors, and returns structured success/error response.

  server.tool(
    "install-mcp",
    {
      packageName: z.string().describe("Package name to install"),
      version: z.string().optional().describe("Specific version to install")
    },
    async ({ packageName, version }, extra) => {
      if (!packageName.trim()) {
        throw new Error("Package name cannot be empty");
      }
      
      const result = await packageManager.installPackage(packageName, version);
      
      if (!result.success) {
        throw new Error(`Failed to install package: ${result.error}`);
      }
      
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              success: true,
              packageName: result.packageName,
              version: result.version,
              localPath: result.localPath
            }, null, 2)
          }
        ]
      };
    }
  );

• src/server.ts:33-33 (registration)

  Top-level call to register installation tools including 'install-mcp' on the MCP server instance.

  registerInstallationTools(server, configService, packageManager);

• src/services/package-manager.ts:84-146 (helper)

  Core implementation of package installation in PackageManager class: creates directory, sets up package.json, executes npm/yarn/pnpm install, discovers version/bin path, updates registry, handles errors.

  async installPackage(packageName: string, version?: string): Promise<InstallResult> {
    try {
      // Create package-specific directory
      const packageDir = path.join(this.packagesDir, packageName.replace('/', '-'));
      await ensureDir(packageDir);
      
      // Create package.json if it doesn't exist
      const packageJsonPath = path.join(packageDir, 'package.json');
      if (!(await fileExists(packageJsonPath))) {
        await writeJsonFile(packageJsonPath, {
          name: 'mcp-package-wrapper',
          version: '1.0.0',
          private: true,
          type: 'module'
        });
      }
      
      // Install the package
      const installCmd = this.getInstallCommand(packageName, version);
      await exec(installCmd, { cwd: packageDir });
      
      // Get installed version
      const nodeModulesDir = path.join(packageDir, 'node_modules');
      const installedVersion = await this.getInstalledVersion(nodeModulesDir, packageName);
      
      // Find bin path if it exists
      const binPath = await this.findPackageBin(nodeModulesDir, packageName);
      
      // Add to registry
      const now = new Date().toISOString();
      const localPath = path.join(nodeModulesDir, packageName);
      
      const installedPackage: InstalledPackage = {
        name: packageName,
        version: installedVersion,
        localPath,
        binPath,
        installedAt: now,
        updatedAt: now,
        dependencies: [], // TODO: Extract dependencies
        usedByConfigs: []
      };
      
      this.registry.packages[packageName] = installedPackage;
      await this.saveRegistry();
      
      return {
        success: true,
        packageName,
        version: installedVersion,
        localPath,
        binPath
      };
    } catch (error) {
      return {
        success: false,
        packageName,
        version: version || 'latest',
        localPath: '',
        error: error instanceof Error ? error.message : String(error)
      };
    }
  }