@samanhappy/mcphub 0.0.7 → 0.0.9

package/src/services/mcpService.ts

@@ -1,385 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,52 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-{
-  "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"]
-}