@samanhappy/mcphub 0.0.9 → 0.0.10

package/src/services/mcpService.ts

@@ -0,0 +1,385 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { ServerInfo, ServerConfig } from '../types/index.js';
+import { loadSettings, saveSettings, expandEnvVars } from '../config/index.js';
+import config from '../config/index.js';
+import { getGroup } from './sseService.js';
+import { getServersInGroup } from './groupService.js';
+
+let currentServer: Server;
+
+export const initMcpServer = async (name: string, version: string): Promise<void> => {
+  currentServer = createMcpServer(name, version);
+  await registerAllTools(currentServer, true, true);
+};
+
+export const setMcpServer = (server: Server): void => {
+  currentServer = server;
+};
+
+export const getMcpServer = (): Server => {
+  return currentServer;
+};
+
+export const notifyToolChanged = async () => {
+  await registerAllTools(currentServer, true, false);
+  currentServer
+    .sendToolListChanged()
+    .catch((error) => {
+      console.warn('Failed to send tool list changed notification:', error.message);
+    })
+    .then(() => {
+      console.log('Tool list changed notification sent successfully');
+    });
+};
+
+// Store all server information
+let serverInfos: ServerInfo[] = [];
+
+// Initialize MCP server clients
+export const initializeClientsFromSettings = (isInit: boolean): ServerInfo[] => {
+  const settings = loadSettings();
+  const existingServerInfos = serverInfos;
+  serverInfos = [];
+
+  for (const [name, conf] of Object.entries(settings.mcpServers)) {
+    // Skip disabled servers
+    if (conf.enabled === false) {
+      console.log(`Skipping disabled server: ${name}`);
+      serverInfos.push({
+        name,
+        status: 'disconnected',
+        error: null,
+        tools: [],
+        createTime: Date.now(),
+        enabled: false,
+      });
+      continue;
+    }
+
+    // Check if server is already connected
+    const existingServer = existingServerInfos.find(
+      (s) => s.name === name && s.status === 'connected',
+    );
+    if (existingServer) {
+      serverInfos.push({
+        ...existingServer,
+        enabled: conf.enabled === undefined ? true : conf.enabled,
+      });
+      console.log(`Server '${name}' is already connected.`);
+      continue;
+    }
+
+    let transport;
+    if (conf.url) {
+      transport = new SSEClientTransport(new URL(conf.url));
+    } else if (conf.command && conf.args) {
+      const env: Record<string, string> = conf.env || {};
+      env['PATH'] = expandEnvVars(process.env.PATH as string) || '';
+      transport = new StdioClientTransport({
+        command: conf.command,
+        args: conf.args,
+        env: env,
+      });
+    } else {
+      console.warn(`Skipping server '${name}': missing required configuration`);
+      serverInfos.push({
+        name,
+        status: 'disconnected',
+        error: 'Missing required configuration',
+        tools: [],
+        createTime: Date.now(),
+      });
+      continue;
+    }
+
+    const client = new Client(
+      {
+        name: `mcp-client-${name}`,
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          prompts: {},
+          resources: {},
+          tools: {},
+        },
+      },
+    );
+    const timeout = isInit ? Number(config.initTimeout) : Number(config.timeout);
+    client
+      .connect(transport, { timeout: timeout })
+      .then(() => {
+        console.log(`Successfully connected client for server: ${name}`);
+
+        client
+          .listTools({}, { timeout: timeout })
+          .then((tools) => {
+            console.log(`Successfully listed ${tools.tools.length} tools for server: ${name}`);
+            const serverInfo = getServerByName(name);
+            if (!serverInfo) {
+              console.warn(`Server info not found for server: ${name}`);
+              return;
+            }
+
+            serverInfo.tools = tools.tools.map((tool) => ({
+              name: tool.name,
+              description: tool.description || '',
+              inputSchema: tool.inputSchema || {},
+            }));
+            serverInfo.status = 'connected';
+            serverInfo.error = null;
+          })
+          .catch((error) => {
+            console.error(
+              `Failed to list tools for server ${name} by error: ${error} with stack: ${error.stack}`,
+            );
+            const serverInfo = getServerByName(name);
+            if (serverInfo) {
+              serverInfo.status = 'disconnected';
+              serverInfo.error = `Failed to list tools: ${error.stack} `;
+            }
+          });
+      })
+      .catch((error) => {
+        console.error(
+          `Failed to connect client for server ${name} by error: ${error} with stack: ${error.stack}`,
+        );
+        const serverInfo = getServerByName(name);
+        if (serverInfo) {
+          serverInfo.status = 'disconnected';
+          serverInfo.error = `Failed to connect: ${error.stack} `;
+        }
+      });
+    serverInfos.push({
+      name,
+      status: 'connecting',
+      error: null,
+      tools: [],
+      client,
+      transport,
+      createTime: Date.now(),
+    });
+    console.log(`Initialized client for server: ${name}`);
+  }
+
+  return serverInfos;
+};
+
+// Register all MCP tools
+export const registerAllTools = async (
+  server: Server,
+  forceInit: boolean,
+  isInit: boolean,
+): Promise<void> => {
+  initializeClientsFromSettings(isInit);
+};
+
+// Get all server information
+export const getServersInfo = (): Omit<ServerInfo, 'client' | 'transport'>[] => {
+  const settings = loadSettings();
+  const infos = serverInfos.map(({ name, status, tools, createTime, error }) => {
+    const serverConfig = settings.mcpServers[name];
+    const enabled = serverConfig ? serverConfig.enabled !== false : true;
+    return {
+      name,
+      status,
+      error,
+      tools,
+      createTime,
+      enabled,
+    };
+  });
+  infos.sort((a, b) => {
+    if (a.enabled === b.enabled) return 0;
+    return a.enabled ? -1 : 1;
+  });
+  return infos;
+};
+
+// Get server by name
+const getServerByName = (name: string): ServerInfo | undefined => {
+  return serverInfos.find((serverInfo) => serverInfo.name === name);
+};
+
+// Get server by tool name
+const getServerByTool = (toolName: string): ServerInfo | undefined => {
+  return serverInfos.find((serverInfo) => serverInfo.tools.some((tool) => tool.name === toolName));
+};
+
+// Add new server
+export const addServer = async (
+  name: string,
+  config: ServerConfig,
+): Promise<{ success: boolean; message?: string }> => {
+  try {
+    const settings = loadSettings();
+    if (settings.mcpServers[name]) {
+      return { success: false, message: 'Server name already exists' };
+    }
+
+    settings.mcpServers[name] = config;
+    if (!saveSettings(settings)) {
+      return { success: false, message: 'Failed to save settings' };
+    }
+
+    registerAllTools(currentServer, false, false);
+    return { success: true, message: 'Server added successfully' };
+  } catch (error) {
+    console.error(`Failed to add server: ${name}`, error);
+    return { success: false, message: 'Failed to add server' };
+  }
+};
+
+// Remove server
+export const removeServer = (name: string): { success: boolean; message?: string } => {
+  try {
+    const settings = loadSettings();
+    if (!settings.mcpServers[name]) {
+      return { success: false, message: 'Server not found' };
+    }
+
+    delete settings.mcpServers[name];
+
+    if (!saveSettings(settings)) {
+      return { success: false, message: 'Failed to save settings' };
+    }
+
+    serverInfos = serverInfos.filter((serverInfo) => serverInfo.name !== name);
+    return { success: true, message: 'Server removed successfully' };
+  } catch (error) {
+    console.error(`Failed to remove server: ${name}`, error);
+    return { success: false, message: `Failed to remove server: ${error}` };
+  }
+};
+
+// Update existing server
+export const updateMcpServer = async (
+  name: string,
+  config: ServerConfig,
+): Promise<{ success: boolean; message?: string }> => {
+  try {
+    const settings = loadSettings();
+    if (!settings.mcpServers[name]) {
+      return { success: false, message: 'Server not found' };
+    }
+
+    settings.mcpServers[name] = config;
+    if (!saveSettings(settings)) {
+      return { success: false, message: 'Failed to save settings' };
+    }
+
+    closeServer(name);
+
+    serverInfos = serverInfos.filter((serverInfo) => serverInfo.name !== name);
+    return { success: true, message: 'Server updated successfully' };
+  } catch (error) {
+    console.error(`Failed to update server: ${name}`, error);
+    return { success: false, message: 'Failed to update server' };
+  }
+};
+
+// Close server client and transport
+function closeServer(name: string) {
+  const serverInfo = serverInfos.find((serverInfo) => serverInfo.name === name);
+  if (serverInfo && serverInfo.client && serverInfo.transport) {
+    serverInfo.client.close();
+    serverInfo.transport.close();
+    console.log(`Closed client and transport for server: ${serverInfo.name}`);
+    // TODO kill process
+  }
+}
+
+// Toggle server enabled status
+export const toggleServerStatus = async (
+  name: string,
+  enabled: boolean,
+): Promise<{ success: boolean; message?: string }> => {
+  try {
+    const settings = loadSettings();
+    if (!settings.mcpServers[name]) {
+      return { success: false, message: 'Server not found' };
+    }
+
+    // Update the enabled status in settings
+    settings.mcpServers[name].enabled = enabled;
+
+    if (!saveSettings(settings)) {
+      return { success: false, message: 'Failed to save settings' };
+    }
+
+    // If disabling, disconnect the server and remove from active servers
+    if (!enabled) {
+      closeServer(name);
+
+      // Update the server info to show as disconnected and disabled
+      const index = serverInfos.findIndex((s) => s.name === name);
+      if (index !== -1) {
+        serverInfos[index] = {
+          ...serverInfos[index],
+          status: 'disconnected',
+          enabled: false,
+        };
+      }
+    }
+
+    return { success: true, message: `Server ${enabled ? 'enabled' : 'disabled'} successfully` };
+  } catch (error) {
+    console.error(`Failed to toggle server status: ${name}`, error);
+    return { success: false, message: 'Failed to toggle server status' };
+  }
+};
+
+// Create McpServer instance
+export const createMcpServer = (name: string, version: string): Server => {
+  const server = new Server({ name, version }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async (_, extra) => {
+    const sessionId = extra.sessionId || '';
+    const group = getGroup(sessionId);
+    console.log(`Handling ListToolsRequest for group: ${group}`);
+    const allServerInfos = serverInfos.filter((serverInfo) => {
+      if (serverInfo.enabled === false) return false;
+      if (!group) return true;
+      const serversInGroup = getServersInGroup(group);
+      return serversInGroup.includes(serverInfo.name);
+    });
+
+    const allTools = [];
+    for (const serverInfo of allServerInfos) {
+      if (serverInfo.tools && serverInfo.tools.length > 0) {
+        allTools.push(...serverInfo.tools);
+      }
+    }
+
+    return {
+      tools: allTools,
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request, _) => {
+    console.log(`Handling CallToolRequest for tool: ${request.params.name}`);
+    try {
+      if (!request.params.arguments) {
+        throw new Error('Arguments are required');
+      }
+      const serverInfo = getServerByTool(request.params.name);
+      if (!serverInfo) {
+        throw new Error(`Server not found: ${request.params.name}`);
+      }
+      const client = serverInfo.client;
+      if (!client) {
+        throw new Error(`Client not found for server: ${request.params.name}`);
+      }
+      const result = await client.callTool(request.params);
+      console.log(`Tool call result: ${JSON.stringify(result)}`);
+      return result;
+    } catch (error) {
+      console.error(`Error handling CallToolRequest: ${error}`);
+      return { error: `Failed to call tool: ${error}` };
+    }
+  });
+  return server;
+};

package/src/services/sseService.ts

@@ -0,0 +1,119 @@
+import { Request, Response } from 'express';
+import { randomUUID } from 'node:crypto';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { getMcpServer } from './mcpService.js';
+import { loadSettings } from '../config/index.js';
+
+const transports: { [sessionId: string]: { transport: Transport; group: string } } = {};
+
+export const getGroup = (sessionId: string): string => {
+  return transports[sessionId]?.group || '';
+};
+
+export const handleSseConnection = async (req: Request, res: Response): Promise<void> => {
+  const settings = loadSettings();
+  const routingConfig = settings.systemConfig?.routing || {
+    enableGlobalRoute: true,
+    enableGroupNameRoute: true,
+  };
+  const group = req.params.group;
+
+  // Check if this is a global route (no group) and if it's allowed
+  if (!group && !routingConfig.enableGlobalRoute) {
+    res.status(403).send('Global routes are disabled. Please specify a group ID.');
+    return;
+  }
+
+  const transport = new SSEServerTransport('/messages', res);
+  transports[transport.sessionId] = { transport, group: group };
+
+  res.on('close', () => {
+    delete transports[transport.sessionId];
+    console.log(`SSE connection closed: ${transport.sessionId}`);
+  });
+
+  console.log(
+    `New SSE connection established: ${transport.sessionId} with group: ${group || 'global'}`,
+  );
+  await getMcpServer().connect(transport);
+};
+
+export const handleSseMessage = async (req: Request, res: Response): Promise<void> => {
+  const sessionId = req.query.sessionId as string;
+  const { transport, group } = transports[sessionId];
+  req.params.group = group;
+  req.query.group = group;
+  console.log(`Received message for sessionId: ${sessionId} in group: ${group}`);
+  if (transport) {
+    await (transport as SSEServerTransport).handlePostMessage(req, res);
+  } else {
+    console.error(`No transport found for sessionId: ${sessionId}`);
+    res.status(400).send('No transport found for sessionId');
+  }
+};
+
+export const handleMcpPostRequest = async (req: Request, res: Response): Promise<void> => {
+  console.log('Handling MCP post request');
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+  const group = req.params.group;
+  const settings = loadSettings();
+  const routingConfig = settings.systemConfig?.routing || {
+    enableGlobalRoute: true,
+    enableGroupNameRoute: true,
+  };
+  if (!group && !routingConfig.enableGlobalRoute) {
+    res.status(403).send('Global routes are disabled. Please specify a group ID.');
+    return;
+  }
+
+  let transport: StreamableHTTPServerTransport;
+  if (sessionId && transports[sessionId]) {
+    transport = transports[sessionId].transport as StreamableHTTPServerTransport;
+  } else if (!sessionId && isInitializeRequest(req.body)) {
+    transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID(),
+      onsessioninitialized: (sessionId) => {
+        transports[sessionId] = { transport, group };
+      },
+    });
+
+    transport.onclose = () => {
+      if (transport.sessionId) {
+        delete transports[transport.sessionId];
+      }
+    };
+
+    await getMcpServer().connect(transport);
+  } else {
+    res.status(400).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: 'Bad Request: No valid session ID provided',
+      },
+      id: null,
+    });
+    return;
+  }
+
+  await transport.handleRequest(req, res, req.body);
+};
+
+export const handleMcpOtherRequest = async (req: Request, res: Response) => {
+  console.log('Handling MCP other request');
+  const sessionId = req.headers['mcp-session-id'] as string | undefined;
+  if (!sessionId || !transports[sessionId]) {
+    res.status(400).send('Invalid or missing session ID');
+    return;
+  }
+
+  const { transport } = transports[sessionId];
+  await (transport as StreamableHTTPServerTransport).handleRequest(req, res);
+};
+
+export const getConnectionCount = (): number => {
+  return Object.keys(transports).length;
+};

package/src/types/index.ts

@@ -0,0 +1,129 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+// User interface
+export interface IUser {
+  username: string;
+  password: string;
+  isAdmin?: boolean;
+}
+
+// Group interface for server grouping
+export interface IGroup {
+  id: string;        // Unique UUID for the group
+  name: string;      // Display name of the group
+  description?: string; // Optional description of the group
+  servers: string[]; // Array of server names that belong to this group
+}
+
+// Market server types
+export interface MarketServerRepository {
+  type: string;
+  url: string;
+}
+
+export interface MarketServerAuthor {
+  name: string;
+}
+
+export interface MarketServerInstallation {
+  type: string;
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+}
+
+export interface MarketServerArgument {
+  description: string;
+  required: boolean;
+  example: string;
+}
+
+export interface MarketServerExample {
+  title: string;
+  description: string;
+  prompt: string;
+}
+
+export interface MarketServerTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, any>;
+}
+
+export interface MarketServer {
+  name: string;
+  display_name: string;
+  description: string;
+  repository: MarketServerRepository;
+  homepage: string;
+  author: MarketServerAuthor;
+  license: string;
+  categories: string[];
+  tags: string[];
+  examples: MarketServerExample[];
+  installations: {
+    [key: string]: MarketServerInstallation;
+  };
+  arguments: Record<string, MarketServerArgument>;
+  tools: MarketServerTool[];
+  is_official?: boolean;
+}
+
+// Represents the settings for MCP servers
+export interface McpSettings {
+  users?: IUser[]; // Array of user credentials and permissions
+  mcpServers: {
+    [key: string]: ServerConfig; // Key-value pairs of server names and their configurations
+  };
+  groups?: IGroup[]; // Array of server groups
+  systemConfig?: {
+    routing?: {
+      enableGlobalRoute?: boolean; // Controls whether the /sse endpoint without group is enabled
+      enableGroupNameRoute?: boolean; // Controls whether group routing by name is allowed
+    };
+    // Add other system configuration sections here in the future
+  };
+}
+
+// Configuration details for an individual server
+export interface ServerConfig {
+  url?: string; // URL for SSE-based servers
+  command?: string; // Command to execute for stdio-based servers
+  args?: string[]; // Arguments for the command
+  env?: Record<string, string>; // Environment variables
+  enabled?: boolean; // Flag to enable/disable the server
+}
+
+// Information about a server's status and tools
+export interface ServerInfo {
+  name: string; // Unique name of the server
+  status: 'connected' | 'connecting' | 'disconnected'; // Current connection status
+  error: string | null; // Error message if any
+  tools: ToolInfo[]; // List of tools available on the server
+  client?: Client; // Client instance for communication
+  transport?: SSEClientTransport | StdioClientTransport; // Transport mechanism used
+  createTime: number; // Timestamp of when the server was created
+  enabled?: boolean; // Flag to indicate if the server is enabled
+}
+
+// Details about a tool available on the server
+export interface ToolInfo {
+  name: string; // Name of the tool
+  description: string; // Brief description of the tool
+  inputSchema: Record<string, unknown>; // Input schema for the tool
+}
+
+// Standardized API response structure
+export interface ApiResponse<T = unknown> {
+  success: boolean; // Indicates if the operation was successful
+  message?: string; // Optional message providing additional details
+  data?: T; // Optional data payload
+}
+
+// Request payload for adding a new server
+export interface AddServerRequest {
+  name: string; // Name of the server to add
+  config: ServerConfig; // Configuration details for the server
+}

package/src/utils/migration.ts

@@ -0,0 +1,52 @@
+// filepath: /Users/sunmeng/code/github/mcphub/src/utils/migration.ts
+import fs from 'fs';
+import path from 'path';
+import { loadSettings, saveSettings } from '../config/index.js';
+import { IUser } from '../types/index.js';
+
+/**
+ * Migrates user data from the old users.json file to mcp_settings.json
+ * This is a one-time migration to support the refactoring from separate
+ * users.json to integrated user data in mcp_settings.json
+ */
+export const migrateUserData = (): void => {
+  const oldUsersFilePath = path.join(process.cwd(), 'data', 'users.json');
+  
+  // Check if the old users file exists
+  if (fs.existsSync(oldUsersFilePath)) {
+    try {
+      // Read users from the old file
+      const usersData = fs.readFileSync(oldUsersFilePath, 'utf8');
+      const users = JSON.parse(usersData) as IUser[];
+      
+      if (users && Array.isArray(users) && users.length > 0) {
+        console.log(`Migrating ${users.length} users from users.json to mcp_settings.json`);
+        
+        // Load current settings
+        const settings = loadSettings();
+        
+        // Merge users, giving priority to existing settings users
+        const existingUsernames = new Set((settings.users || []).map(u => u.username));
+        const newUsers = users.filter(u => !existingUsernames.has(u.username));
+        
+        settings.users = [...(settings.users || []), ...newUsers];
+        
+        // Save updated settings
+        if (saveSettings(settings)) {
+          console.log('User data migration completed successfully');
+          
+          // Rename the old file as backup
+          const backupPath = `${oldUsersFilePath}.bak.${Date.now()}`;
+          fs.renameSync(oldUsersFilePath, backupPath);
+          console.log(`Renamed old users file to ${backupPath}`);
+        }
+      } else {
+        console.log('No users found in users.json, skipping migration');
+      }
+    } catch (error) {
+      console.error('Error during user data migration:', error);
+    }
+  } else {
+    console.log('users.json not found, no migration needed');
+  }
+};

package/tsconfig.json

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