init

.opencode/skills/mcp-management/scripts/.env.example

@@ -0,0 +1,10 @@
+# MCP Management Scripts Environment Variables
+
+# Path to MCP configuration file (optional, defaults to .claude/.mcp.json)
+MCP_CONFIG_PATH=.claude/.mcp.json
+
+# Logging level (optional, defaults to info)
+LOG_LEVEL=info
+
+# Enable debug mode (optional, defaults to false)
+DEBUG=false

.opencode/skills/mcp-management/scripts/.gitignore

@@ -0,0 +1,68 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+node_modules
+.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+coverage
+
+# next.js
+.next
+out
+
+# production
+build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# package manager
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# semantic-release
+.nyc_output
+
+# env files (can opt-in for committing if needed)
+.env*
+!.env.example
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# flutter
+.dart_tool
+build
+GoogleService-Info.plist
+
+repomix-output.xml
+.serena/cache
+plans/**/*
+!plans/templates/*
+screenshots/*
+docs/screenshots/*
+docs/journals/*
+docs/research/*
+logs.txt
+test-ck
+__pycache__
+prompt.md

.opencode/skills/mcp-management/scripts/cli.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * MCP Management CLI - Command-line interface for MCP operations
+ */
+
+import { MCPClientManager } from './mcp-client.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const GLOBAL_TIMEOUT_MS = parseInt(process.env.MCP_TIMEOUT || '120000', 10);
+let globalManager: MCPClientManager | null = null;
+
+function setupShutdownHandlers() {
+  const shutdown = async (signal: string) => {
+    console.log(`\nReceived ${signal}, cleaning up...`);
+    if (globalManager) {
+      await globalManager.cleanup();
+    }
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGHUP', () => shutdown('SIGHUP'));
+
+  process.on('unhandledRejection', (reason) => {
+    console.error('Unhandled rejection:', reason);
+    process.exit(1);
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Setup shutdown handlers
+  setupShutdownHandlers();
+
+  // Check for help flags BEFORE connecting to servers
+  if (!command || command === '--help' || command === 'help') {
+    printUsage();
+    process.exit(0);
+  }
+
+  // Global timeout
+  const timeoutHandle = setTimeout(() => {
+    console.error('Global timeout exceeded, forcing exit');
+    process.exit(1);
+  }, GLOBAL_TIMEOUT_MS);
+  timeoutHandle.unref();
+
+  const manager = new MCPClientManager();
+  globalManager = manager;
+
+  try {
+    // Load config
+    await manager.loadConfig();
+    console.log('✓ Config loaded');
+
+    // Connect to all servers
+    await manager.connectAll();
+    console.log('✓ Connected to all MCP servers\n');
+
+    switch (command) {
+      case 'list-tools':
+        await listTools(manager);
+        break;
+
+      case 'list-prompts':
+        await listPrompts(manager);
+        break;
+
+      case 'list-resources':
+        await listResources(manager);
+        break;
+
+      case 'call-tool':
+        await callTool(manager, args[1], args[2], args[3]);
+        break;
+
+      default:
+        printUsage();
+    }
+
+    await manager.cleanup();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+async function listTools(manager: MCPClientManager) {
+  const tools = await manager.getAllTools();
+  console.log(`Found ${tools.length} tools:\n`);
+
+  for (const tool of tools) {
+    console.log(`📦 ${tool.serverName} / ${tool.name}`);
+    console.log(`   ${tool.description}`);
+    if (tool.inputSchema?.properties) {
+      console.log(`   Parameters: ${Object.keys(tool.inputSchema.properties).join(', ')}`);
+    }
+    console.log('');
+  }
+
+  // Save tools to JSON file
+  const assetsDir = join(__dirname, '..', 'assets');
+  const toolsPath = join(assetsDir, 'tools.json');
+
+  try {
+    mkdirSync(assetsDir, { recursive: true });
+    writeFileSync(toolsPath, JSON.stringify(tools, null, 2));
+    console.log(`\n✓ Tools saved to ${toolsPath}`);
+  } catch (error) {
+    console.error(`\n✗ Failed to save tools: ${error}`);
+  }
+}
+
+async function listPrompts(manager: MCPClientManager) {
+  const prompts = await manager.getAllPrompts();
+  console.log(`Found ${prompts.length} prompts:\n`);
+
+  for (const prompt of prompts) {
+    console.log(`💬 ${prompt.serverName} / ${prompt.name}`);
+    console.log(`   ${prompt.description}`);
+    if (prompt.arguments && prompt.arguments.length > 0) {
+      console.log(`   Arguments: ${prompt.arguments.map((a: any) => a.name).join(', ')}`);
+    }
+    console.log('');
+  }
+}
+
+async function listResources(manager: MCPClientManager) {
+  const resources = await manager.getAllResources();
+  console.log(`Found ${resources.length} resources:\n`);
+
+  for (const resource of resources) {
+    console.log(`📄 ${resource.serverName} / ${resource.name}`);
+    console.log(`   URI: ${resource.uri}`);
+    if (resource.description) {
+      console.log(`   ${resource.description}`);
+    }
+    if (resource.mimeType) {
+      console.log(`   Type: ${resource.mimeType}`);
+    }
+    console.log('');
+  }
+}
+
+async function callTool(
+  manager: MCPClientManager,
+  serverName: string,
+  toolName: string,
+  argsJson: string
+) {
+  if (!serverName || !toolName || !argsJson) {
+    console.error('Usage: cli.ts call-tool <server> <tool> <json-args>');
+    process.exit(1);
+  }
+
+  const args = JSON.parse(argsJson);
+  console.log(`Calling ${serverName}/${toolName}...`);
+
+  const result = await manager.callTool(serverName, toolName, args);
+  console.log('\nResult:');
+  console.log(JSON.stringify(result, null, 2));
+}
+
+function printUsage() {
+  console.log(`
+MCP Management CLI
+
+Usage:
+  cli.ts <command> [options]
+
+Commands:
+  list-tools                        List all tools and save to assets/tools.json
+  list-prompts                      List all prompts from all MCP servers
+  list-resources                    List all resources from all MCP servers
+  call-tool <server> <tool> <json>  Call a specific tool
+
+Examples:
+  cli.ts list-tools
+  cli.ts call-tool memory create_entities '{"entities":[{"name":"Alice","entityType":"person"}]}'
+  cli.ts call-tool human-mcp playwright_screenshot_fullpage '{"url":"https://example.com"}'
+
+Note: Tool analysis is done by the LLM reading assets/tools.json directly.
+  `);
+}
+
+main();

.opencode/skills/mcp-management/scripts/mcp-client.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * MCP Client - Core client for interacting with MCP servers
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+
+interface MCPConfig {
+  mcpServers: {
+    [key: string]: {
+      command: string;
+      args: string[];
+      env?: Record<string, string>;
+    };
+  };
+}
+
+interface ToolInfo {
+  serverName: string;
+  name: string;
+  description: string;
+  inputSchema: any;
+  outputSchema?: any;
+}
+
+interface PromptInfo {
+  serverName: string;
+  name: string;
+  description: string;
+  arguments?: any[];
+}
+
+interface ResourceInfo {
+  serverName: string;
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+export class MCPClientManager {
+  private config: MCPConfig | null = null;
+  private clients: Map<string, Client> = new Map();
+  private transports: Map<string, StdioClientTransport> = new Map();
+
+  async loadConfig(configPath: string = '.claude/.mcp.json'): Promise<MCPConfig> {
+    const fullPath = resolve(process.cwd(), configPath);
+    const content = await readFile(fullPath, 'utf-8');
+    const config = JSON.parse(content) as MCPConfig;
+    this.config = config;
+    return config;
+  }
+
+  async connectToServer(serverName: string): Promise<Client> {
+    if (!this.config?.mcpServers[serverName]) {
+      throw new Error(`Server ${serverName} not found in config`);
+    }
+
+    const serverConfig = this.config.mcpServers[serverName];
+    const transport = new StdioClientTransport({
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env
+    });
+
+    const client = new Client({
+      name: `mcp-manager-${serverName}`,
+      version: '1.0.0'
+    }, { capabilities: {} });
+
+    await client.connect(transport);
+    this.clients.set(serverName, client);
+    this.transports.set(serverName, transport); // Track transport!
+    return client;
+  }
+
+  async connectAll(): Promise<void> {
+    if (!this.config) {
+      throw new Error('Config not loaded. Call loadConfig() first.');
+    }
+
+    const serverNames = Object.keys(this.config.mcpServers);
+    console.log(`Connecting to ${serverNames.length} servers sequentially...`);
+
+    for (const serverName of serverNames) {
+      try {
+        await this.connectToServer(serverName);
+        console.log(`✓ ${serverName} connected`);
+      } catch (error) {
+        console.error(`✗ ${serverName} failed:`, error);
+        // Continue with other servers
+      }
+    }
+  }
+
+  async getAllTools(): Promise<ToolInfo[]> {
+    const allTools: ToolInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listTools({}, { timeout: 300000 });
+        for (const tool of response.tools) {
+          allTools.push({
+            serverName,
+            name: tool.name,
+            description: tool.description || '',
+            inputSchema: tool.inputSchema,
+            outputSchema: (tool as any).outputSchema
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listTools`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allTools;
+  }
+
+  async getAllPrompts(): Promise<PromptInfo[]> {
+    const allPrompts: PromptInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listPrompts({}, { timeout: 300000 });
+        for (const prompt of response.prompts) {
+          allPrompts.push({
+            serverName,
+            name: prompt.name,
+            description: prompt.description || '',
+            arguments: prompt.arguments
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listPrompts`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allPrompts;
+  }
+
+  async getAllResources(): Promise<ResourceInfo[]> {
+    const allResources: ResourceInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listResources({}, { timeout: 300000 });
+        for (const resource of response.resources) {
+          allResources.push({
+            serverName,
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listResources`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allResources;
+  }
+
+  async callTool(serverName: string, toolName: string, args: any): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.callTool(
+      { name: toolName, arguments: args },
+      undefined,
+      { timeout: 300000 }
+    );
+  }
+
+  async getPrompt(serverName: string, promptName: string, args?: any): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.getPrompt({ name: promptName, arguments: args }, { timeout: 300000 });
+  }
+
+  async readResource(serverName: string, uri: string): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.readResource({ uri }, { timeout: 300000 });
+  }
+
+  async cleanup(): Promise<void> {
+    // Close clients with timeout
+    const cleanupPromises: Promise<void>[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      cleanupPromises.push(
+        (async () => {
+          try {
+            await client.close();
+          } catch (error) {
+            console.warn(`Warning closing ${serverName}:`, error);
+          }
+        })()
+      );
+    }
+
+    await Promise.race([
+      Promise.all(cleanupPromises),
+      new Promise<void>((resolve) => setTimeout(resolve, 5000))
+    ]);
+
+    // CRITICAL: Close transports to kill subprocesses
+    for (const [serverName, transport] of this.transports.entries()) {
+      try {
+        await transport.close();
+      } catch (error) {
+        console.warn(`Warning closing ${serverName} transport:`, error);
+      }
+    }
+
+    this.clients.clear();
+    this.transports.clear();
+  }
+}

.opencode/skills/mcp-management/scripts/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "mcp-management-scripts",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "MCP client scripts for managing MCP servers",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --loader ts-node/esm test.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}

.opencode/skills/mcp-management/scripts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "resolveJsonModule": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}