Mcp Management

# 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

# 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

#!/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();

#!/usr/bin/env node
/**
 * Tool Analyzer - Intelligently selects relevant MCP tools for tasks
 */
/**
 * Analyze tools and return those relevant to the task
 */
export function analyzeToolsForTask(tools, taskDescription) {
    const keywords = extractKeywords(taskDescription);
    const scoredTools = tools.map(tool => ({
        tool,
        score: calculateRelevanceScore(tool, keywords, taskDescription),
        reasons: explainScore(tool, keywords, taskDescription)
    }));
    // Sort by score descending
    scoredTools.sort((a, b) => b.score - a.score);
    // Filter tools with score above threshold
    const threshold = 0.3;
    const relevant = scoredTools.filter(st => st.score > threshold);
    return {
        relevantTools: relevant.map(st => st.tool),
        reasoning: relevant.map(st => `${st.tool.name} (${st.tool.serverName}): ${st.reasons.join('; ')}`),
        confidence: relevant.length > 0
            ? relevant[0].score
            : 0
    };
}
function extractKeywords(text) {
    const stopWords = new Set([
        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at',
        'to', 'for', 'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are'
    ]);
    return text
        .toLowerCase()
        .split(/\W+/)
        .filter(word => word.length > 2 && !stopWords.has(word));
}
function calculateRelevanceScore(tool, keywords, taskDescription) {
    let score = 0;
    const toolText = `${tool.name} ${tool.description}`.toLowerCase();
    // Keyword matching
    for (const keyword of keywords) {
        if (toolText.includes(keyword)) {
            score += 0.2;
        }
    }
    // Exact phrase matching
    const taskLower = taskDescription.toLowerCase();
    if (toolText.includes(taskLower) || taskLower.includes(tool.name.toLowerCase())) {
        score += 0.5;
    }
    // Schema complexity bonus (more params = more specialized)
    if (tool.inputSchema?.properties) {
        const paramCount = Object.keys(tool.inputSchema.properties).length;
        score += Math.min(paramCount * 0.05, 0.3);
    }
    return Math.min(score, 1.0);
}
function explainScore(tool, keywords, taskDescription) {
    const reasons = [];
    const toolText = `${tool.name} ${tool.description}`.toLowerCase();
    const matchedKeywords = keywords.filter(k => toolText.includes(k));
    if (matchedKeywords.length > 0) {
        reasons.push(`matches keywords: ${matchedKeywords.join(', ')}`);
    }
    if (tool.description) {
        reasons.push(`description: ${tool.description.slice(0, 100)}`);
    }
    return reasons;
}

#!/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);
async function main() {
    const args = process.argv.slice(2);
    const command = args[0];
    const manager = new MCPClientManager();
    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();
    }
    catch (error) {
        console.error('Error:', error);
        process.exit(1);
    }
}
async function listTools(manager) {
    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) {
    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) => a.name).join(', ')}`);
        }
        console.log('');
    }
}
async function listResources(manager) {
    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, serverName, toolName, argsJson) {
    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();

#!/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';
export class MCPClientManager {
    config = null;
    clients = new Map();
    async loadConfig(configPath = '.claude/.mcp.json') {
        const fullPath = resolve(process.cwd(), configPath);
        const content = await readFile(fullPath, 'utf-8');
        const config = JSON.parse(content);
        this.config = config;
        return config;
    }
    async connectToServer(serverName) {
        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);
        return client;
    }
    async connectAll() {
        if (!this.config) {
            throw new Error('Config not loaded. Call loadConfig() first.');
        }
        const connections = Object.keys(this.config.mcpServers).map(name => this.connectToServer(name));
        await Promise.all(connections);
    }
    async getAllTools() {
        const allTools = [];
        for (const [serverName, client] of this.clients.entries()) {
            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.outputSchema
                });
            }
        }
        return allTools;
    }
    async getAllPrompts() {
        const allPrompts = [];
        for (const [serverName, client] of this.clients.entries()) {
            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
                });
            }
        }
        return allPrompts;
    }
    async getAllResources() {
        const allResources = [];
        for (const [serverName, client] of this.clients.entries()) {
            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
                });
            }
        }
        return allResources;
    }
    async callTool(serverName, toolName, args) {
        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, promptName, args) {
        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, uri) {
        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() {
        for (const client of this.clients.values()) {
            await client.close();
        }
        this.clients.clear();
    }
}

#!/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();
  }
}

{
  "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.0.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "nodemon": "^3.1.11",
    "ts-node": "^10.9.2",
    "tsx": "^4.20.6",
    "typescript": "^5.9.3"
  }
}

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