@samanhappy/mcphub 0.0.5 → 0.0.7

package/src/config/index.ts

@@ -0,0 +1,46 @@
+import dotenv from 'dotenv';
+import path from 'path';
+import fs from 'fs';
+import { McpSettings } from '../types/index.js';
+
+dotenv.config();
+
+const defaultConfig = {
+  port: process.env.PORT || 3000,
+  initTimeout: process.env.INIT_TIMEOUT || 300000,
+  timeout: process.env.REQUEST_TIMEOUT || 60000,
+  mcpHubName: 'mcphub',
+  mcpHubVersion: '0.0.1',
+};
+
+export const getSettingsPath = (): string => {
+  return path.resolve(process.cwd(), 'mcp_settings.json');
+};
+
+export const loadSettings = (): McpSettings => {
+  const settingsPath = getSettingsPath();
+  try {
+    const settingsData = fs.readFileSync(settingsPath, 'utf8');
+    return JSON.parse(settingsData);
+  } catch (error) {
+    console.error(`Failed to load settings from ${settingsPath}:`, error);
+    return { mcpServers: {}, users: [] };
+  }
+};
+
+export const saveSettings = (settings: McpSettings): boolean => {
+  const settingsPath = getSettingsPath();
+  try {
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    return true;
+  } catch (error) {
+    console.error(`Failed to save settings to ${settingsPath}:`, error);
+    return false;
+  }
+};
+
+export const expandEnvVars = (value: string): string => {
+  return value.replace(/\$\{([^}]+)\}/g, (_, key) => process.env[key] || '');
+};
+
+export default defaultConfig;

package/src/controllers/authController.ts

@@ -0,0 +1,179 @@
+import { Request, Response } from 'express';
+import jwt from 'jsonwebtoken';
+import { validationResult } from 'express-validator';
+import { findUserByUsername, verifyPassword, createUser, updateUserPassword } from '../models/User.js';
+
+// Default secret key - in production, use an environment variable
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-this';
+const TOKEN_EXPIRY = '24h';
+
+// Login user
+export const login = async (req: Request, res: Response): Promise<void> => {
+  // Validate request
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    res.status(400).json({ success: false, errors: errors.array() });
+    return;
+  }
+
+  const { username, password } = req.body;
+
+  try {
+    // Find user by username
+    const user = findUserByUsername(username);
+    
+    if (!user) {
+      res.status(401).json({ success: false, message: 'Invalid credentials' });
+      return;
+    }
+
+    // Verify password
+    const isPasswordValid = await verifyPassword(password, user.password);
+    
+    if (!isPasswordValid) {
+      res.status(401).json({ success: false, message: 'Invalid credentials' });
+      return;
+    }
+
+    // Generate JWT token
+    const payload = {
+      user: {
+        username: user.username,
+        isAdmin: user.isAdmin || false
+      }
+    };
+
+    jwt.sign(
+      payload,
+      JWT_SECRET,
+      { expiresIn: TOKEN_EXPIRY },
+      (err, token) => {
+        if (err) throw err;
+        res.json({ 
+          success: true, 
+          token,
+          user: {
+            username: user.username,
+            isAdmin: user.isAdmin
+          }
+        });
+      }
+    );
+  } catch (error) {
+    console.error('Login error:', error);
+    res.status(500).json({ success: false, message: 'Server error' });
+  }
+};
+
+// Register new user
+export const register = async (req: Request, res: Response): Promise<void> => {
+  // Validate request
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    res.status(400).json({ success: false, errors: errors.array() });
+    return;
+  }
+
+  const { username, password, isAdmin } = req.body;
+
+  try {
+    // Create new user
+    const newUser = await createUser({ username, password, isAdmin });
+    
+    if (!newUser) {
+      res.status(400).json({ success: false, message: 'User already exists' });
+      return;
+    }
+
+    // Generate JWT token
+    const payload = {
+      user: {
+        username: newUser.username,
+        isAdmin: newUser.isAdmin || false
+      }
+    };
+
+    jwt.sign(
+      payload,
+      JWT_SECRET,
+      { expiresIn: TOKEN_EXPIRY },
+      (err, token) => {
+        if (err) throw err;
+        res.json({ 
+          success: true, 
+          token,
+          user: {
+            username: newUser.username,
+            isAdmin: newUser.isAdmin
+          }
+        });
+      }
+    );
+  } catch (error) {
+    console.error('Registration error:', error);
+    res.status(500).json({ success: false, message: 'Server error' });
+  }
+};
+
+// Get current user
+export const getCurrentUser = (req: Request, res: Response): void => {
+  try {
+    // User is already attached to request by auth middleware
+    const user = (req as any).user;
+    
+    res.json({ 
+      success: true, 
+      user: {
+        username: user.username,
+        isAdmin: user.isAdmin
+      }
+    });
+  } catch (error) {
+    console.error('Get current user error:', error);
+    res.status(500).json({ success: false, message: 'Server error' });
+  }
+};
+
+// Change password
+export const changePassword = async (req: Request, res: Response): Promise<void> => {
+  // Validate request
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    res.status(400).json({ success: false, errors: errors.array() });
+    return;
+  }
+
+  const { currentPassword, newPassword } = req.body;
+  const username = (req as any).user.username;
+
+  try {
+    // Find user by username
+    const user = findUserByUsername(username);
+    
+    if (!user) {
+      res.status(404).json({ success: false, message: 'User not found' });
+      return;
+    }
+
+    // Verify current password
+    const isPasswordValid = await verifyPassword(currentPassword, user.password);
+    
+    if (!isPasswordValid) {
+      res.status(401).json({ success: false, message: 'Current password is incorrect' });
+      return;
+    }
+
+    // Update the password
+    const updated = await updateUserPassword(username, newPassword);
+    
+    if (!updated) {
+      res.status(500).json({ success: false, message: 'Failed to update password' });
+      return;
+    }
+
+    res.json({ success: true, message: 'Password updated successfully' });
+  } catch (error) {
+    console.error('Change password error:', error);
+    res.status(500).json({ success: false, message: 'Server error' });
+  }
+};

package/src/controllers/groupController.ts

@@ -0,0 +1,341 @@
+import { Request, Response } from 'express';
+import { ApiResponse } from '../types/index.js';
+import {
+  getAllGroups,
+  getGroupByIdOrName,
+  createGroup,
+  updateGroup,
+  updateGroupServers,
+  deleteGroup,
+  addServerToGroup,
+  removeServerFromGroup,
+  getServersInGroup
+} from '../services/groupService.js';
+
+// Get all groups
+export const getGroups = (_: Request, res: Response): void => {
+  try {
+    const groups = getAllGroups();
+    const response: ApiResponse = {
+      success: true,
+      data: groups,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get groups information',
+    });
+  }
+};
+
+// Get a specific group by ID
+export const getGroup = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    const group = getGroupByIdOrName(id);
+    if (!group) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: group,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get group information',
+    });
+  }
+};
+
+// Create a new group
+export const createNewGroup = (req: Request, res: Response): void => {
+  try {
+    const { name, description, servers } = req.body;
+    if (!name) {
+      res.status(400).json({
+        success: false,
+        message: 'Group name is required',
+      });
+      return;
+    }
+
+    const serverList = Array.isArray(servers) ? servers : [];
+    const newGroup = createGroup(name, description, serverList);
+    if (!newGroup) {
+      res.status(400).json({
+        success: false,
+        message: 'Failed to create group or group name already exists',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: newGroup,
+      message: 'Group created successfully',
+    };
+    res.status(201).json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Update an existing group
+export const updateExistingGroup = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    const { name, description, servers } = req.body;
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    // Allow updating servers along with other fields
+    const updateData: any = {};
+    if (name !== undefined) updateData.name = name;
+    if (description !== undefined) updateData.description = description;
+    if (servers !== undefined) updateData.servers = servers;
+
+    if (Object.keys(updateData).length === 0) {
+      res.status(400).json({
+        success: false,
+        message: 'At least one field (name, description, or servers) is required to update',
+      });
+      return;
+    }
+
+    const updatedGroup = updateGroup(id, updateData);
+    if (!updatedGroup) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found or name already exists',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: updatedGroup,
+      message: 'Group updated successfully',
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Update servers in a group (batch update)
+export const updateGroupServersBatch = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    const { servers } = req.body;
+    
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    if (!Array.isArray(servers)) {
+      res.status(400).json({
+        success: false,
+        message: 'Servers must be an array of server names',
+      });
+      return;
+    }
+
+    const updatedGroup = updateGroupServers(id, servers);
+    if (!updatedGroup) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: updatedGroup,
+      message: 'Group servers updated successfully',
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Delete a group
+export const deleteExistingGroup = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    const success = deleteGroup(id);
+    if (!success) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found or failed to delete',
+      });
+      return;
+    }
+
+    res.json({
+      success: true,
+      message: 'Group deleted successfully',
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Add server to a group
+export const addServerToExistingGroup = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    const { serverName } = req.body;
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    if (!serverName) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    const updatedGroup = addServerToGroup(id, serverName);
+    if (!updatedGroup) {
+      res.status(404).json({
+        success: false,
+        message: 'Group or server not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: updatedGroup,
+      message: 'Server added to group successfully',
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Remove server from a group
+export const removeServerFromExistingGroup = (req: Request, res: Response): void => {
+  try {
+    const { id, serverName } = req.params;
+    if (!id || !serverName) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID and server name are required',
+      });
+      return;
+    }
+
+    const updatedGroup = removeServerFromGroup(id, serverName);
+    if (!updatedGroup) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: updatedGroup,
+      message: 'Server removed from group successfully',
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error',
+    });
+  }
+};
+
+// Get servers in a group
+export const getGroupServers = (req: Request, res: Response): void => {
+  try {
+    const { id } = req.params;
+    if (!id) {
+      res.status(400).json({
+        success: false,
+        message: 'Group ID is required',
+      });
+      return;
+    }
+
+    const group = getGroupByIdOrName(id);
+    if (!group) {
+      res.status(404).json({
+        success: false,
+        message: 'Group not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: group.servers,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get group servers',
+    });
+  }
+};

package/src/controllers/marketController.ts

@@ -0,0 +1,154 @@
+import { Request, Response } from 'express';
+import { ApiResponse } from '../types/index.js';
+import {
+  getMarketServers,
+  getMarketServerByName,
+  getMarketCategories,
+  getMarketTags,
+  searchMarketServers,
+  filterMarketServersByCategory,
+  filterMarketServersByTag
+} from '../services/marketService.js';
+
+// Get all market servers
+export const getAllMarketServers = (_: Request, res: Response): void => {
+  try {
+    const marketServers = Object.values(getMarketServers());
+    const response: ApiResponse = {
+      success: true,
+      data: marketServers,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get market servers information',
+    });
+  }
+};
+
+// Get a specific market server by name
+export const getMarketServer = (req: Request, res: Response): void => {
+  try {
+    const { name } = req.params;
+    if (!name) {
+      res.status(400).json({
+        success: false,
+        message: 'Server name is required',
+      });
+      return;
+    }
+
+    const server = getMarketServerByName(name);
+    if (!server) {
+      res.status(404).json({
+        success: false,
+        message: 'Market server not found',
+      });
+      return;
+    }
+
+    const response: ApiResponse = {
+      success: true,
+      data: server,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get market server information',
+    });
+  }
+};
+
+// Get all market categories
+export const getAllMarketCategories = (_: Request, res: Response): void => {
+  try {
+    const categories = getMarketCategories();
+    const response: ApiResponse = {
+      success: true,
+      data: categories,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get market categories',
+    });
+  }
+};
+
+// Get all market tags
+export const getAllMarketTags = (_: Request, res: Response): void => {
+  try {
+    const tags = getMarketTags();
+    const response: ApiResponse = {
+      success: true,
+      data: tags,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get market tags',
+    });
+  }
+};
+
+// Search market servers
+export const searchMarketServersByQuery = (req: Request, res: Response): void => {
+  try {
+    const { query } = req.query;
+    const searchQuery = typeof query === 'string' ? query : '';
+    
+    const servers = searchMarketServers(searchQuery);
+    const response: ApiResponse = {
+      success: true,
+      data: servers,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to search market servers',
+    });
+  }
+};
+
+// Filter market servers by category
+export const getMarketServersByCategory = (req: Request, res: Response): void => {
+  try {
+    const { category } = req.params;
+    
+    const servers = filterMarketServersByCategory(category);
+    const response: ApiResponse = {
+      success: true,
+      data: servers,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to filter market servers by category',
+    });
+  }
+};
+
+// Filter market servers by tag
+export const getMarketServersByTag = (req: Request, res: Response): void => {
+  try {
+    const { tag } = req.params;
+    
+    const servers = filterMarketServersByTag(tag);
+    const response: ApiResponse = {
+      success: true,
+      data: servers,
+    };
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Failed to filter market servers by tag',
+    });
+  }
+};