@samanhappy/mcphub 0.0.5 → 0.0.6

package/src/controllers/serverController.ts

@@ -0,0 +1,303 @@
+import { Request, Response } from 'express';
+import { ApiResponse, AddServerRequest } from '../types/index.js';
+import {
+  getServersInfo,
+  addServer,
+  removeServer,
+  updateMcpServer,
+  notifyToolChanged,
+  toggleServerStatus,
+} from '../services/mcpService.js';
+import { loadSettings, saveSettings } from '../config/index.js';
+
+export const getAllServers = (_: Request, res: Response): void => {
+  try {
+    const serversInfo = getServersInfo();
+    const response: ApiResponse = {
+      success: true,
+      data: serversInfo,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get servers information',
+    });
+  }
+};
+
+export const getAllSettings = (_: Request, res: Response): void => {
+  try {
+    const settings = loadSettings();
+    const response: ApiResponse = {
+      success: true,
+      data: settings,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get server settings',
+    });
+  }
+};
+
+export const createServer = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { name, config } = req.body as AddServerRequest;
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    if (!config || typeof config !== 'object') {
+      res.status(400).json({
+        success: false,
+        message: 'Server configuration is required',
+      });
+      return;
+    }
+
+    if (!config.url && (!config.command || !config.args)) {
+      res.status(400).json({
+        success: false,
+        message: 'Server configuration must include either a URL or command with arguments',
+      });
+      return;
+    }
+
+    const result = await addServer(name, config);
+    if (result.success) {
+      notifyToolChanged();
+      res.json({
+        success: true,
+        message: 'Server added successfully',
+      });
+    } else {
+      res.status(400).json({
+        success: false,
+        message: result.message || 'Failed to add server',
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+export const deleteServer = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { name } = req.params;
+    if (!name) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    const result = removeServer(name);
+    if (result.success) {
+      notifyToolChanged();
+      res.json({
+        success: true,
+        message: 'Server removed successfully',
+      });
+    } else {
+      res.status(404).json({
+        success: false,
+        message: result.message || 'Server not found or failed to remove',
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+export const updateServer = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { name } = req.params;
+    const { config } = req.body;
+    if (!name) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    if (!config || typeof config !== 'object') {
+      res.status(400).json({
+        success: false,
+        message: 'Server configuration is required',
+      });
+      return;
+    }
+
+    if (!config.url && (!config.command || !config.args)) {
+      res.status(400).json({
+        success: false,
+        message: 'Server configuration must include either a URL or command with arguments',
+      });
+      return;
+    }
+
+    const result = await updateMcpServer(name, config);
+    if (result.success) {
+      notifyToolChanged();
+      res.json({
+        success: true,
+        message: 'Server updated successfully',
+      });
+    } else {
+      res.status(404).json({
+        success: false,
+        message: result.message || 'Server not found or failed to update',
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+export const getServerConfig = (req: Request, res: Response): void => {
+  try {
+    const { name } = req.params;
+    const settings = loadSettings();
+    if (!settings.mcpServers || !settings.mcpServers[name]) {
+      res.status(404).json({
+        success: false,
+        message: 'Server not found',
+      });
+      return;
+    }
+
+    const serverInfo = getServersInfo().find((s) => s.name === name);
+    const serverConfig = settings.mcpServers[name];
+    const response: ApiResponse = {
+      success: true,
+      data: {
+        name,
+        status: serverInfo ? serverInfo.status : 'disconnected',
+        tools: serverInfo ? serverInfo.tools : [],
+        config: serverConfig,
+      },
+    };
+
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get server configuration',
+    });
+  }
+};
+
+export const toggleServer = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { name } = req.params;
+    const { enabled } = req.body;
+    if (!name) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    if (typeof enabled !== 'boolean') {
+      res.status(400).json({
+        success: false,
+        message: 'Enabled status must be a boolean',
+      });
+      return;
+    }
+
+    const result = await toggleServerStatus(name, enabled);
+    if (result.success) {
+      notifyToolChanged();
+      res.json({
+        success: true,
+        message: result.message || `Server ${enabled ? 'enabled' : 'disabled'} successfully`,
+      });
+    } else {
+      res.status(404).json({
+        success: false,
+        message: result.message || 'Server not found or failed to toggle status',
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+export const updateSystemConfig = (req: Request, res: Response): void => {
+  try {
+    const { routing } = req.body;
+    
+    if (!routing || (typeof routing.enableGlobalRoute !== 'boolean' && typeof routing.enableGroupNameRoute !== 'boolean')) {
+      res.status(400).json({
+        success: false,
+        message: 'Invalid system configuration provided',
+      });
+      return;
+    }
+    
+    const settings = loadSettings();
+    if (!settings.systemConfig) {
+      settings.systemConfig = {
+        routing: {
+          enableGlobalRoute: true,
+          enableGroupNameRoute: true
+        }
+      };
+    }
+    
+    if (!settings.systemConfig.routing) {
+      settings.systemConfig.routing = {
+        enableGlobalRoute: true,
+        enableGroupNameRoute: true
+      };
+    }
+    
+    if (typeof routing.enableGlobalRoute === 'boolean') {
+      settings.systemConfig.routing.enableGlobalRoute = routing.enableGlobalRoute;
+    }
+    
+    if (typeof routing.enableGroupNameRoute === 'boolean') {
+      settings.systemConfig.routing.enableGroupNameRoute = routing.enableGroupNameRoute;
+    }
+    
+    if (saveSettings(settings)) {
+      res.json({
+        success: true,
+        data: settings.systemConfig,
+        message: 'System configuration updated successfully',
+      });
+    } else {
+      res.status(500).json({
+        success: false,
+        message: 'Failed to save system configuration',
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};

package/src/index.ts

@@ -0,0 +1,17 @@
+import AppServer from './server.js';
+
+const appServer = new AppServer();
+
+async function boot() {
+  try {
+    await appServer.initialize();
+    appServer.start();
+  } catch (error) {
+    console.error('Failed to start application:', error);
+    process.exit(1);
+  }
+}
+
+boot();
+
+export default appServer.getApp();

package/src/middlewares/auth.ts

@@ -0,0 +1,28 @@
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+// Default secret key - in production, use an environment variable
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-this';
+
+// Middleware to authenticate JWT token
+export const auth = (req: Request, res: Response, next: NextFunction): void => {
+  // Get token from header
+  const token = req.header('x-auth-token');
+
+  // Check if no token
+  if (!token) {
+    res.status(401).json({ success: false, message: 'No token, authorization denied' });
+    return;
+  }
+
+  // Verify token
+  try {
+    const decoded = jwt.verify(token, JWT_SECRET);
+    
+    // Add user from payload to request
+    (req as any).user = (decoded as any).user;
+    next();
+  } catch (error) {
+    res.status(401).json({ success: false, message: 'Token is not valid' });
+  }
+};

package/src/middlewares/index.ts

@@ -0,0 +1,43 @@
+import express, { Request, Response, NextFunction } from 'express';
+import path from 'path';
+import { auth } from './auth.js';
+import { initializeDefaultUser } from '../models/User.js';
+
+export const errorHandler = (
+  err: Error, 
+  _req: Request, 
+  res: Response, 
+  _next: NextFunction
+): void => {
+  console.error('Unhandled error:', err);
+  res.status(500).json({
+    success: false,
+    message: 'Internal server error',
+  });
+};
+
+export const initMiddlewares = (app: express.Application): void => {
+  app.use(express.static('frontend/dist'));
+
+  app.use((req, res, next) => {
+    if (req.path !== '/sse' && req.path !== '/messages') {
+      express.json()(req, res, next);
+    } else {
+      next();
+    }
+  });
+
+  // Initialize default admin user if no users exist
+  initializeDefaultUser().catch(err => {
+    console.error('Error initializing default user:', err);
+  });
+
+  // Protect all API routes with authentication middleware
+  app.use('/api', auth);
+
+  app.get('/', (_req: Request, res: Response) => {
+    res.sendFile(path.join(process.cwd(), 'frontend', 'dist', 'index.html'));
+  });
+
+  app.use(errorHandler);
+};

package/src/models/User.ts

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import bcrypt from 'bcryptjs';
+import { IUser, McpSettings } from '../types/index.js';
+import { loadSettings, saveSettings } from '../config/index.js';
+
+// Get all users
+export const getUsers = (): IUser[] => {
+  try {
+    const settings = loadSettings();
+    return settings.users || [];
+  } catch (error) {
+    console.error('Error reading users from settings:', error);
+    return [];
+  }
+};
+
+// Save users to settings
+const saveUsers = (users: IUser[]): void => {
+  try {
+    const settings = loadSettings();
+    settings.users = users;
+    saveSettings(settings);
+  } catch (error) {
+    console.error('Error saving users to settings:', error);
+  }
+};
+
+// Create a new user
+export const createUser = async (userData: IUser): Promise<IUser | null> => {
+  const users = getUsers();
+  
+  // Check if username already exists
+  if (users.some(user => user.username === userData.username)) {
+    return null;
+  }
+  
+  // Hash the password
+  const salt = await bcrypt.genSalt(10);
+  const hashedPassword = await bcrypt.hash(userData.password, salt);
+  
+  const newUser = {
+    username: userData.username,
+    password: hashedPassword,
+    isAdmin: userData.isAdmin || false
+  };
+  
+  users.push(newUser);
+  saveUsers(users);
+  
+  return newUser;
+};
+
+// Find user by username
+export const findUserByUsername = (username: string): IUser | undefined => {
+  const users = getUsers();
+  return users.find(user => user.username === username);
+};
+
+// Verify user password
+export const verifyPassword = async (
+  plainPassword: string, 
+  hashedPassword: string
+): Promise<boolean> => {
+  return await bcrypt.compare(plainPassword, hashedPassword);
+};
+
+// Update user password
+export const updateUserPassword = async (
+  username: string,
+  newPassword: string
+): Promise<boolean> => {
+  const users = getUsers();
+  const userIndex = users.findIndex(user => user.username === username);
+  
+  if (userIndex === -1) {
+    return false;
+  }
+  
+  // Hash the new password
+  const salt = await bcrypt.genSalt(10);
+  const hashedPassword = await bcrypt.hash(newPassword, salt);
+  
+  // Update the user's password
+  users[userIndex].password = hashedPassword;
+  saveUsers(users);
+  
+  return true;
+};
+
+// Initialize with default admin user if no users exist
+export const initializeDefaultUser = async (): Promise<void> => {
+  const users = getUsers();
+  
+  if (users.length === 0) {
+    await createUser({
+      username: 'admin',
+      password: 'admin123',
+      isAdmin: true
+    });
+    console.log('Default admin user created');
+  }
+};

package/src/routes/index.ts

@@ -0,0 +1,96 @@
+import express from 'express';
+import { check } from 'express-validator';
+import {
+  getAllServers,
+  getAllSettings,
+  createServer,
+  updateServer,
+  deleteServer,
+  toggleServer,
+  updateSystemConfig
+} from '../controllers/serverController.js';
+import {
+  getGroups,
+  getGroup,
+  createNewGroup,
+  updateExistingGroup,
+  deleteExistingGroup,
+  addServerToExistingGroup,
+  removeServerFromExistingGroup,
+  getGroupServers,
+  updateGroupServersBatch
+} from '../controllers/groupController.js';
+import {
+  getAllMarketServers,
+  getMarketServer,
+  getAllMarketCategories,
+  getAllMarketTags,
+  searchMarketServersByQuery,
+  getMarketServersByCategory,
+  getMarketServersByTag
+} from '../controllers/marketController.js';
+import {
+  login,
+  register,
+  getCurrentUser,
+  changePassword
+} from '../controllers/authController.js';
+import { auth } from '../middlewares/auth.js';
+
+const router = express.Router();
+
+export const initRoutes = (app: express.Application): void => {
+  // API routes protected by auth middleware in middlewares/index.ts
+  router.get('/servers', getAllServers);
+  router.get('/settings', getAllSettings);
+  router.post('/servers', createServer);
+  router.put('/servers/:name', updateServer);
+  router.delete('/servers/:name', deleteServer);
+  router.post('/servers/:name/toggle', toggleServer);
+  router.put('/system-config', updateSystemConfig);
+  
+  // Group management routes
+  router.get('/groups', getGroups);
+  router.get('/groups/:id', getGroup);
+  router.post('/groups', createNewGroup);
+  router.put('/groups/:id', updateExistingGroup);
+  router.delete('/groups/:id', deleteExistingGroup);
+  router.post('/groups/:id/servers', addServerToExistingGroup);
+  router.delete('/groups/:id/servers/:serverName', removeServerFromExistingGroup);
+  router.get('/groups/:id/servers', getGroupServers);
+  // New route for batch updating servers in a group
+  router.put('/groups/:id/servers/batch', updateGroupServersBatch);
+  
+  // Market routes
+  router.get('/market/servers', getAllMarketServers);
+  router.get('/market/servers/search', searchMarketServersByQuery);
+  router.get('/market/servers/:name', getMarketServer);
+  router.get('/market/categories', getAllMarketCategories);
+  router.get('/market/categories/:category', getMarketServersByCategory);
+  router.get('/market/tags', getAllMarketTags);
+  router.get('/market/tags/:tag', getMarketServersByTag);
+  
+  // Auth routes (these will NOT be protected by auth middleware)
+  app.post('/auth/login', [
+    check('username', 'Username is required').not().isEmpty(),
+    check('password', 'Password is required').not().isEmpty(),
+  ], login);
+  
+  app.post('/auth/register', [
+    check('username', 'Username is required').not().isEmpty(),
+    check('password', 'Password must be at least 6 characters').isLength({ min: 6 }),
+  ], register);
+  
+  app.get('/auth/user', auth, getCurrentUser);
+  
+  // Add change password route
+  app.post('/auth/change-password', [
+    auth,
+    check('currentPassword', 'Current password is required').not().isEmpty(),
+    check('newPassword', 'New password must be at least 6 characters').isLength({ min: 6 }),
+  ], changePassword);
+
+  app.use('/api', router);
+};
+
+export default router;

package/src/server.ts

@@ -0,0 +1,72 @@
+import express from 'express';
+import config from './config/index.js';
+import path from 'path';
+import { initMcpServer } from './services/mcpService.js';
+import { initMiddlewares } from './middlewares/index.js';
+import { initRoutes } from './routes/index.js';
+import {
+  handleSseConnection,
+  handleSseMessage,
+  handleMcpPostRequest,
+  handleMcpOtherRequest,
+} from './services/sseService.js';
+import { migrateUserData } from './utils/migration.js';
+import { initializeDefaultUser } from './models/User.js';
+
+export class AppServer {
+  private app: express.Application;
+  private port: number | string;
+
+  constructor() {
+    this.app = express();
+    this.port = config.port;
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      // Migrate user data from users.json to mcp_settings.json if needed
+      migrateUserData();
+
+      // Initialize default admin user if no users exist
+      await initializeDefaultUser();
+
+      initMiddlewares(this.app);
+      initRoutes(this.app);
+      console.log('Server initialized successfully');
+
+      initMcpServer(config.mcpHubName, config.mcpHubVersion)
+        .then(() => {
+          console.log('MCP server initialized successfully');
+          this.app.get('/sse/:group?', (req, res) => handleSseConnection(req, res));
+          this.app.post('/messages', handleSseMessage);
+          this.app.post('/mcp/:group?', handleMcpPostRequest);
+          this.app.get('/mcp/:group?', handleMcpOtherRequest);
+          this.app.delete('/mcp/:group?', handleMcpOtherRequest);
+        })
+        .catch((error) => {
+          console.error('Error initializing MCP server:', error);
+          throw error;
+        })
+        .finally(() => {
+          this.app.get('*', (_req, res) => {
+            res.sendFile(path.join(process.cwd(), 'frontend', 'dist', 'index.html'));
+          });
+        });
+    } catch (error) {
+      console.error('Error initializing server:', error);
+      throw error;
+    }
+  }
+
+  start(): void {
+    this.app.listen(this.port, () => {
+      console.log(`Server is running on port ${this.port}`);
+    });
+  }
+
+  getApp(): express.Application {
+    return this.app;
+  }
+}
+
+export default AppServer;