mcpmate 0.1.0

package/src/commands/openclaw.ts

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import YAML from 'yaml';
+
+const CONFIG_DIR = path.join(os.homedir(), '.mcpm');
+const SERVERS_FILE = path.join(CONFIG_DIR, 'servers.json');
+
+// OpenClaw configuration paths
+const OPENCLAW_CONFIG_PATHS = [
+  path.join(os.homedir(), '.openclaw', 'mcp.yaml'),
+  path.join(os.homedir(), '.openclaw', 'mcp.json'),
+  path.join(os.homedir(), '.openclaw', 'config', 'mcp.yaml'),
+];
+
+async function getInstalledServers(): Promise<Record<string, any>> {
+  if (await fs.pathExists(SERVERS_FILE)) {
+    return await fs.readJson(SERVERS_FILE);
+  }
+  return {};
+}
+
+async function findOpenClawConfig(): Promise<string | null> {
+  for (const configPath of OPENCLAW_CONFIG_PATHS) {
+    if (await fs.pathExists(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+
+async function ensureOpenClawConfigDir(): Promise<string> {
+  const openclawDir = path.join(os.homedir(), '.openclaw');
+  await fs.ensureDir(openclawDir);
+  return path.join(openclawDir, 'mcp.yaml');
+}
+
+export const openclawCommand = {
+  async setup(): Promise<void> {
+    console.log(chalk.blue('🔧 Setting up OpenClaw MCP integration...\n'));
+
+    const existingConfig = await findOpenClawConfig();
+    
+    if (existingConfig) {
+      console.log(chalk.green('✅ OpenClaw configuration found:'));
+      console.log(chalk.gray(`  ${existingConfig}`));
+      console.log();
+      console.log(chalk.blue('💡 Run the following to sync your MCP servers:'));
+      console.log(chalk.cyan('  mcpm openclaw sync'));
+    } else {
+      console.log(chalk.yellow('⚠️  No existing OpenClaw configuration found.'));
+      console.log(chalk.gray('Creating new configuration...\n'));
+      
+      const configPath = await ensureOpenClawConfigDir();
+      const initialConfig = {
+        version: '1.0',
+        mcpServers: {},
+        metadata: {
+          createdAt: new Date().toISOString(),
+          tool: 'mcp-server-manager'
+        }
+      };
+      
+      await fs.writeFile(configPath, YAML.stringify(initialConfig));
+      
+      console.log(chalk.green('✅ OpenClaw configuration created:'));
+      console.log(chalk.gray(`  ${configPath}`));
+    }
+
+    console.log();
+    console.log(chalk.blue('📚 Next steps:'));
+    console.log(chalk.gray('  1. Install MCP servers:'), chalk.cyan('mcpm install <server>'));
+    console.log(chalk.gray('  2. Enable servers:'), chalk.cyan('mcpm enable <server>'));
+    console.log(chalk.gray('  3. Sync to OpenClaw:'), chalk.cyan('mcpm openclaw sync'));
+  },
+
+  async sync(): Promise<void> {
+    console.log(chalk.blue('🔄 Syncing MCP configuration to OpenClaw...\n'));
+
+    const servers = await getInstalledServers();
+    const enabledServers = Object.values(servers).filter((s: any) => s.enabled);
+
+    if (enabledServers.length === 0) {
+      console.log(chalk.yellow('⚠️  No enabled servers to sync.'));
+      console.log(chalk.gray('Enable servers with:'), chalk.cyan('mcpm enable <server>'));
+      return;
+    }
+
+    const configPath = await findOpenClawConfig() || await ensureOpenClawConfigDir();
+    
+    // Build MCP servers config
+    const mcpServers: Record<string, any> = {};
+    enabledServers.forEach((server: any) => {
+      mcpServers[server.name] = {
+        command: server.command,
+        args: server.args,
+        env: server.env || {},
+        enabled: true
+      };
+    });
+
+    // Read existing config or create new
+    let existingConfig: any = {};
+    if (await fs.pathExists(configPath)) {
+      const content = await fs.readFile(configPath, 'utf-8');
+      existingConfig = YAML.parse(content) || {};
+    }
+
+    // Merge configs
+    const newConfig = {
+      ...existingConfig,
+      version: existingConfig.version || '1.0',
+      mcpServers,
+      metadata: {
+        ...(existingConfig.metadata || {}),
+        lastSyncedAt: new Date().toISOString(),
+        tool: 'mcp-server-manager',
+        version: '0.1.0'
+      }
+    };
+
+    await fs.writeFile(configPath, YAML.stringify(newConfig));
+
+    console.log(chalk.green('✅ Synced successfully!'));
+    console.log(chalk.gray(`Configuration: ${configPath}`));
+    console.log(chalk.gray(`Servers synced: ${enabledServers.length}`));
+    console.log();
+    
+    enabledServers.forEach((server: any) => {
+      console.log(chalk.gray(`  • ${server.name}`));
+    });
+
+    console.log();
+    console.log(chalk.blue('💡 Restart OpenClaw to apply changes.'));
+  },
+
+  async status(): Promise<void> {
+    console.log(chalk.blue('📊 OpenClaw MCP Configuration Status\n'));
+
+    const configPath = await findOpenClawConfig();
+    
+    if (!configPath) {
+      console.log(chalk.yellow('⚠️  OpenClaw configuration not found.'));
+      console.log(chalk.gray('Run setup first:'), chalk.cyan('mcpm openclaw setup'));
+      return;
+    }
+
+    console.log(chalk.green('✅ Configuration found:'));
+    console.log(chalk.gray(`  ${configPath}`));
+    console.log();
+
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = YAML.parse(content) || {};
+
+    if (config.metadata) {
+      console.log(chalk.blue('Metadata:'));
+      if (config.metadata.lastSyncedAt) {
+        console.log(chalk.gray(`  Last synced: ${new Date(config.metadata.lastSyncedAt).toLocaleString()}`));
+      }
+      if (config.metadata.tool) {
+        console.log(chalk.gray(`  Managed by: ${config.metadata.tool}`));
+      }
+      console.log();
+    }
+
+    const mcpServers = config.mcpServers || {};
+    const serverCount = Object.keys(mcpServers).length;
+
+    if (serverCount === 0) {
+      console.log(chalk.yellow('No MCP servers configured.'));
+    } else {
+      console.log(chalk.blue(`MCP Servers (${serverCount}):\n`));
+      Object.entries(mcpServers).forEach(([name, server]: [string, any]) => {
+        const status = server.enabled !== false ? chalk.green('✅') : chalk.gray('⏸️');
+        console.log(`  ${status} ${name}`);
+      });
+    }
+
+    console.log();
+    console.log(chalk.blue('💡 Commands:'));
+    console.log(chalk.gray('  Sync:'), chalk.cyan('mcpm openclaw sync'));
+    console.log(chalk.gray('  List local:'), chalk.cyan('mcpm list'));
+    console.log(chalk.gray('  Install:'), chalk.cyan('mcpm install <server>'));
+  }
+};

package/src/commands/search.ts

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import axios from 'axios';
+
+interface ServerInfo {
+  name: string;
+  description: string;
+  author: string;
+  category: string;
+  downloads: number;
+  rating: number;
+}
+
+// Mock registry data for MVP
+const MOCK_REGISTRY: ServerInfo[] = [
+  {
+    name: '@modelcontextprotocol/server-postgres',
+    description: 'PostgreSQL database integration',
+    author: 'Anthropic',
+    category: 'database',
+    downloads: 15000,
+    rating: 4.5
+  },
+  {
+    name: '@modelcontextprotocol/server-github',
+    description: 'GitHub API integration',
+    author: 'Anthropic',
+    category: 'version-control',
+    downloads: 12000,
+    rating: 4.7
+  },
+  {
+    name: '@modelcontextprotocol/server-filesystem',
+    description: 'Local filesystem access',
+    author: 'Anthropic',
+    category: 'filesystem',
+    downloads: 20000,
+    rating: 4.6
+  },
+  {
+    name: '@modelcontextprotocol/server-puppeteer',
+    description: 'Web scraping and browser automation',
+    author: 'Anthropic',
+    category: 'automation',
+    downloads: 8000,
+    rating: 4.3
+  },
+  {
+    name: '@modelcontextprotocol/server-redis',
+    description: 'Redis database integration',
+    author: 'Community',
+    category: 'database',
+    downloads: 6000,
+    rating: 4.4
+  },
+  {
+    name: '@modelcontextprotocol/server-slack',
+    description: 'Slack workspace integration',
+    author: 'Anthropic',
+    category: 'communication',
+    downloads: 9000,
+    rating: 4.5
+  }
+];
+
+export async function searchServers(query: string, options: { category?: string }): Promise<void> {
+  console.log(chalk.blue('🔍 Searching for MCP servers...'));
+  console.log(chalk.gray(`Query: "${query}"`));
+  
+  if (options.category) {
+    console.log(chalk.gray(`Category: ${options.category}`));
+  }
+  console.log();
+
+  // Filter servers based on query
+  const filteredServers = MOCK_REGISTRY.filter(server => {
+    const matchesQuery = server.name.toLowerCase().includes(query.toLowerCase()) ||
+                        server.description.toLowerCase().includes(query.toLowerCase());
+    const matchesCategory = !options.category || server.category === options.category;
+    return matchesQuery && matchesCategory;
+  });
+
+  if (filteredServers.length === 0) {
+    console.log(chalk.yellow('No servers found matching your query.'));
+    console.log(chalk.gray('Try searching with different keywords or browse all with: mcpm list --all'));
+    return;
+  }
+
+  console.log(chalk.green(`Found ${filteredServers.length} server(s):\n`));
+
+  filteredServers.forEach((server, index) => {
+    console.log(chalk.white(`${index + 1}. ${chalk.bold(server.name)}`));
+    console.log(chalk.gray(`   ${server.description}`));
+    console.log(chalk.gray(`   Category: ${server.category} | Author: ${server.author}`));
+    console.log(chalk.gray(`   Downloads: ${server.downloads.toLocaleString()} | Rating: ${'⭐'.repeat(Math.floor(server.rating))}`));
+    console.log();
+  });
+
+  console.log(chalk.blue('💡 Install a server with:'), chalk.cyan('mcpm install <server-name>'));
+}

package/src/commands/template.ts

@@ -0,0 +1,135 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { installServer } from './install';
+
+interface Template {
+  name: string;
+  description: string;
+  servers: string[];
+  category: string;
+}
+
+const TEMPLATES: Record<string, Template> = {
+  'ecommerce-analytics': {
+    name: 'ecommerce-analytics',
+    description: '电商数据分析场景 - 包含数据库、缓存、电商 API',
+    category: '电商',
+    servers: [
+      '@modelcontextprotocol/server-postgres',
+      '@modelcontextprotocol/server-redis',
+      '@custom/taobao-api',
+      '@custom/jingdong-api'
+    ]
+  },
+  'content-creation': {
+    name: 'content-creation',
+    description: '内容创作场景 - 小红书、抖音内容创作助手',
+    category: '内容',
+    servers: [
+      '@modelcontextprotocol/server-filesystem',
+      '@custom/xiaohongshu-api',
+      '@custom/douyin-api'
+    ]
+  },
+  'wechat-miniprogram': {
+    name: 'wechat-miniprogram',
+    description: '微信小程序开发场景',
+    category: '开发',
+    servers: [
+      '@modelcontextprotocol/server-filesystem',
+      '@custom/wechat-devtools',
+      '@modelcontextprotocol/server-git'
+    ]
+  },
+  'alipay-miniprogram': {
+    name: 'alipay-miniprogram',
+    description: '支付宝小程序开发场景',
+    category: '开发',
+    servers: [
+      '@modelcontextprotocol/server-filesystem',
+      '@custom/alipay-devtools',
+      '@modelcontextprotocol/server-git'
+    ]
+  },
+  'backend-api': {
+    name: 'backend-api',
+    description: '后端 API 开发场景 - 数据库、缓存、消息队列',
+    category: '开发',
+    servers: [
+      '@modelcontextprotocol/server-postgres',
+      '@modelcontextprotocol/server-redis',
+      '@modelcontextprotocol/server-sqlite'
+    ]
+  }
+};
+
+export const templateCommand = {
+  async list(): Promise<void> {
+    console.log(chalk.blue('📋 Available Templates\n'));
+
+    const templates = Object.values(TEMPLATES);
+    
+    templates.forEach((template, index) => {
+      console.log(chalk.white(`${index + 1}. ${chalk.bold(template.name)}`));
+      console.log(chalk.gray(`   ${template.description}`));
+      console.log(chalk.gray(`   Category: ${template.category}`));
+      console.log(chalk.gray(`   Servers: ${template.servers.length}`));
+      console.log();
+    });
+
+    console.log(chalk.blue('💡 Use a template:'), chalk.cyan('mcpmate template use <template-name>'));
+  },
+
+  async use(templateName: string): Promise<void> {
+    const template = TEMPLATES[templateName];
+
+    if (!template) {
+      console.log(chalk.yellow(`⚠️  Template "${templateName}" not found.`));
+      console.log(chalk.gray('Available templates:'));
+      Object.keys(TEMPLATES).forEach(name => {
+        console.log(chalk.gray(`  - ${name}`));
+      });
+      return;
+    }
+
+    console.log(chalk.blue('📦 Using template:'), chalk.bold(template.name));
+    console.log(chalk.gray(template.description));
+    console.log();
+
+    console.log(chalk.blue('This template includes:'));
+    template.servers.forEach(server => {
+      console.log(chalk.gray(`  • ${server}`));
+    });
+    console.log();
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Install all servers in this template?',
+      default: true
+    }]);
+
+    if (!confirm) {
+      console.log(chalk.gray('Installation cancelled.'));
+      return;
+    }
+
+    console.log();
+    console.log(chalk.blue('🚀 Installing servers...\n'));
+
+    for (const server of template.servers) {
+      try {
+        await installServer(server, {});
+        console.log();
+      } catch (error) {
+        console.log(chalk.yellow(`⚠️  Failed to install ${server}, continuing...`));
+      }
+    }
+
+    console.log();
+    console.log(chalk.green('✅ Template installation completed!'));
+    console.log(chalk.blue('💡 Next steps:'));
+    console.log(chalk.gray('  - Enable servers:'), chalk.cyan('mcpmate enable <server>'));
+    console.log(chalk.gray('  - Sync to OpenClaw:'), chalk.cyan('mcpmate openclaw sync'));
+  }
+};

package/src/commands/toggle.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.mcpm');
+const SERVERS_FILE = path.join(CONFIG_DIR, 'servers.json');
+
+async function getInstalledServers(): Promise<Record<string, any>> {
+  if (await fs.pathExists(SERVERS_FILE)) {
+    return await fs.readJson(SERVERS_FILE);
+  }
+  return {};
+}
+
+async function saveInstalledServers(servers: Record<string, any>): Promise<void> {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJson(SERVERS_FILE, servers, { spaces: 2 });
+}
+
+export async function enableServer(serverName: string): Promise<void> {
+  const servers = await getInstalledServers();
+
+  if (!servers[serverName]) {
+    console.log(chalk.yellow(`⚠️  Server "${serverName}" is not installed.`));
+    console.log(chalk.gray('Install it first with:'), chalk.cyan(`mcpm install ${serverName}`));
+    return;
+  }
+
+  if (servers[serverName].enabled) {
+    console.log(chalk.yellow(`⚠️  Server "${serverName}" is already enabled.`));
+    return;
+  }
+
+  servers[serverName].enabled = true;
+  await saveInstalledServers(servers);
+
+  console.log(chalk.green(`✅ Server "${serverName}" enabled successfully!`));
+}
+
+export async function disableServer(serverName: string): Promise<void> {
+  const servers = await getInstalledServers();
+
+  if (!servers[serverName]) {
+    console.log(chalk.yellow(`⚠️  Server "${serverName}" is not installed.`));
+    return;
+  }
+
+  if (!servers[serverName].enabled) {
+    console.log(chalk.yellow(`⚠️  Server "${serverName}" is already disabled.`));
+    return;
+  }
+
+  servers[serverName].enabled = false;
+  await saveInstalledServers(servers);
+
+  console.log(chalk.gray(`⏸️  Server "${serverName}" disabled.`));
+}

package/src/commands/uninstall.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import inquirer from 'inquirer';
+
+const CONFIG_DIR = path.join(os.homedir(), '.mcpm');
+const SERVERS_FILE = path.join(CONFIG_DIR, 'servers.json');
+
+async function getInstalledServers(): Promise<Record<string, any>> {
+  if (await fs.pathExists(SERVERS_FILE)) {
+    return await fs.readJson(SERVERS_FILE);
+  }
+  return {};
+}
+
+async function saveInstalledServers(servers: Record<string, any>): Promise<void> {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJson(SERVERS_FILE, servers, { spaces: 2 });
+}
+
+export async function uninstallServer(serverName: string): Promise<void> {
+  console.log(chalk.blue('🗑️  Uninstalling MCP server...'));
+  console.log(chalk.gray(`Server: ${serverName}`));
+  console.log();
+
+  const servers = await getInstalledServers();
+
+  if (!servers[serverName]) {
+    console.log(chalk.yellow(`⚠️  Server "${serverName}" is not installed.`));
+    return;
+  }
+
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: `Are you sure you want to uninstall "${serverName}"?`,
+    default: false
+  }]);
+
+  if (!confirm) {
+    console.log(chalk.gray('Uninstallation cancelled.'));
+    return;
+  }
+
+  delete servers[serverName];
+  await saveInstalledServers(servers);
+
+  console.log();
+  console.log(chalk.green('✅ Server uninstalled successfully!'));
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}