@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/api/web/mcp-status.d.ts

@@ -0,0 +1,29 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * MCP Connection Status API Routes
+ *
+ * Provides real-time monitoring and management endpoints for MCP (Model Context Protocol) server connections.
+ * This module enables administrators to check the health of connected servers, manage connection states,
+ * and retrieve server capabilities including available tools and resources.
+ *
+ * The status API provides comprehensive information about each connected MCP server including:
+ * - Connection status (connected/disconnected)
+ * - Server performance metrics
+ * - Available tools and resources count
+ * - Process information (PID, start time)
+ * - Error conditions and recovery status
+ *
+ * Additionally, it provides active connection management capabilities to connect/disconnect
+ * servers programmatically, making it suitable for automated infrastructure management.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register MCP status routes
+ * await webMcpStatusRoutes(app);
+ * ```
+ */
+export declare function webMcpStatusRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=mcp-status.d.ts.map

package/dist/server/src/api/web/mcp-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-status.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/mcp-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAO1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,iBAsHhE"}

package/dist/server/src/api/web/mcp-status.js

@@ -0,0 +1,126 @@
+import { hubManager } from '../../services/hub-manager.service.js';
+import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
+import { logger } from '../../utils/logger.js';
+import { LOG_MODULES } from '../../utils/logger/log-modules.js';
+/**
+ * MCP Connection Status API Routes
+ *
+ * Provides real-time monitoring and management endpoints for MCP (Model Context Protocol) server connections.
+ * This module enables administrators to check the health of connected servers, manage connection states,
+ * and retrieve server capabilities including available tools and resources.
+ *
+ * The status API provides comprehensive information about each connected MCP server including:
+ * - Connection status (connected/disconnected)
+ * - Server performance metrics
+ * - Available tools and resources count
+ * - Process information (PID, start time)
+ * - Error conditions and recovery status
+ *
+ * Additionally, it provides active connection management capabilities to connect/disconnect
+ * servers programmatically, making it suitable for automated infrastructure management.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register MCP status routes
+ * await webMcpStatusRoutes(app);
+ * ```
+ */
+export async function webMcpStatusRoutes(fastify) {
+    // GET /web/mcp/status - Get status of all MCP servers
+    fastify.get('/web/mcp/status', async (_request, reply) => {
+        try {
+            const servers = hubManager.getAllServers();
+            const serverInstances = hubManager.getServerInstances();
+            const statusList = [];
+            servers.forEach((server) => {
+                const instances = serverInstances[server.name] || [];
+                instances.forEach((instance) => {
+                    statusList.push({
+                        id: instance.id || '',
+                        name: server.name,
+                        type: server.config.type,
+                        status: mcpConnectionManager.getStatus(instance.id || '') || {
+                            connected: false,
+                            lastCheck: Date.now(),
+                            toolsCount: 0,
+                            resourcesCount: 0,
+                            pid: undefined
+                        }
+                    });
+                });
+            });
+            return statusList;
+        }
+        catch (error) {
+            logger.error('Failed to get MCP status:', error, LOG_MODULES.MCP_STATUS);
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // POST /web/mcp/servers/:id/connect - Connect to MCP server
+    fastify.post('/web/mcp/servers/:id/connect', async (request, reply) => {
+        try {
+            const server = hubManager.getServerById(request.params.id);
+            if (!server) {
+                return reply.code(404).send({ error: 'Server not found' });
+            }
+            const success = await mcpConnectionManager.connect({
+                ...server.config,
+                ...server.instance
+            });
+            if (!success) {
+                return reply.code(500).send({ error: 'Failed to connect to server' });
+            }
+            // Update enabled status in config - The enabled field now belongs to server configuration, not instance configuration
+            await hubManager.updateServer(server.name, { enabled: true });
+            return { success: true };
+        }
+        catch (error) {
+            logger.error('Failed to connect MCP server:', error, LOG_MODULES.MCP_STATUS);
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // POST /web/mcp/servers/:id/disconnect - Disconnect from MCP server
+    fastify.post('/web/mcp/servers/:id/disconnect', async (request, reply) => {
+        try {
+            await mcpConnectionManager.disconnect(request.params.id);
+            // Update enabled status in config to ensure it doesn't show as "starting"
+            // The enabled field now belongs to server configuration, not instance configuration
+            const server = hubManager.getServerById(request.params.id);
+            if (server) {
+                await hubManager.updateServer(server.name, { enabled: false });
+            }
+            return { success: true };
+        }
+        catch (error) {
+            logger.error('Failed to disconnect MCP server:', error, LOG_MODULES.MCP_STATUS);
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // GET /web/mcp/servers/:id/tools - Get tools for a specific server
+    fastify.get('/web/mcp/servers/:id/tools', async (request, reply) => {
+        try {
+            logger.info(`API request tools for server: ${request.params.id}`, LOG_MODULES.MCP_STATUS);
+            const tools = mcpConnectionManager.getTools(request.params.id);
+            return tools;
+        }
+        catch (error) {
+            logger.error('Failed to get MCP tools:', error, LOG_MODULES.MCP_STATUS);
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // GET /web/mcp/servers/:id/resources - Get resources for a specific server
+    fastify.get('/web/mcp/servers/:id/resources', async (request, reply) => {
+        try {
+            logger.info(`API request resources for server: ${request.params.id}`, LOG_MODULES.MCP_STATUS);
+            const resources = mcpConnectionManager.getResources(request.params.id);
+            return resources;
+        }
+        catch (error) {
+            logger.error('Failed to get MCP resources:', error, LOG_MODULES.MCP_STATUS);
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+}

package/dist/server/src/api/web/resources.d.ts

@@ -0,0 +1,28 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * MCP Resources API Routes
+ *
+ * Provides endpoints for discovering and accessing resources from connected MCP (Model Context Protocol) servers.
+ * This module enables clients to list available resources across all servers and read specific resource content.
+ *
+ * The resources API handles both system-level resources (provided by MCP Hub Lite itself) and server-specific
+ * resources from connected MCP servers. It provides a unified interface for resource discovery and access,
+ * abstracting away the underlying server implementation details.
+ *
+ * Key features include:
+ * - Cross-server resource listing with server categorization
+ * - Resource content reading with proper URI handling
+ * - System resource integration alongside server resources
+ * - Error handling for disconnected or unavailable servers
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register resource routes
+ * await webResourceRoutes(app);
+ * ```
+ */
+export declare function webResourceRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/server/src/api/web/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBA2E/D"}

package/dist/server/src/api/web/resources.js

@@ -0,0 +1,93 @@
+import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
+import { hubToolsService } from '../../services/hub-tools.service.js';
+import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
+/**
+ * MCP Resources API Routes
+ *
+ * Provides endpoints for discovering and accessing resources from connected MCP (Model Context Protocol) servers.
+ * This module enables clients to list available resources across all servers and read specific resource content.
+ *
+ * The resources API handles both system-level resources (provided by MCP Hub Lite itself) and server-specific
+ * resources from connected MCP servers. It provides a unified interface for resource discovery and access,
+ * abstracting away the underlying server implementation details.
+ *
+ * Key features include:
+ * - Cross-server resource listing with server categorization
+ * - Resource content reading with proper URI handling
+ * - System resource integration alongside server resources
+ * - Error handling for disconnected or unavailable servers
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register resource routes
+ * await webResourceRoutes(app);
+ * ```
+ */
+export async function webResourceRoutes(fastify) {
+    // GET /web/servers/:name/resources/read
+    fastify.get('/web/servers/:name/resources/read', async (request, reply) => {
+        try {
+            const { name } = request.params;
+            const { uri } = request.query;
+            if (!uri) {
+                return reply.code(400).send({ error: 'URI is required' });
+            }
+            // Handle system resources (mcp-hub-lite)
+            if (name === MCP_HUB_LITE_SERVER) {
+                const content = await hubToolsService.readResource(uri);
+                // Wrap content in MCP resource read format
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'application/json',
+                            text: JSON.stringify(content, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Find server ID
+            const serverId = mcpConnectionManager.getServerIdByName(name);
+            if (!serverId) {
+                // Try using name directly as ID (unlikely but for robustness)
+                if (mcpConnectionManager.getStatus(name)) {
+                    const result = await mcpConnectionManager.readResource(name, uri);
+                    return result;
+                }
+                return reply.code(404).send({ error: 'Server not connected or not found' });
+            }
+            const result = await mcpConnectionManager.readResource(serverId, uri);
+            return result;
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({ error: errorObj.message || 'Failed to read resource' });
+        }
+    });
+    fastify.get('/web/resources', async (_request, reply) => {
+        try {
+            const allResources = mcpConnectionManager.getAllResources();
+            // Add Hub System resources
+            const systemResources = await hubToolsService.listResources();
+            const resources = {};
+            // 1. Add Hub System resources first if they exist
+            if (systemResources && systemResources.length > 0) {
+                resources[MCP_HUB_LITE_SERVER] = systemResources;
+            }
+            // 2. Add other server resources, filtering out empty ones
+            for (const [serverName, serverResources] of Object.entries(allResources)) {
+                if (serverResources && serverResources.length > 0) {
+                    resources[serverName] = serverResources;
+                }
+            }
+            return { resources };
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({ error: errorObj.message || 'Failed to fetch resources' });
+        }
+    });
+}

package/dist/server/src/api/web/search.d.ts

@@ -0,0 +1,26 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * Tool Search API Routes
+ *
+ * Provides powerful fuzzy search capabilities for discovering tools across all connected MCP (Model Context Protocol) servers.
+ * This module enables users to quickly find relevant tools based on name, description, or other metadata using
+ * advanced search algorithms with pagination support.
+ *
+ * The search API supports flexible query parameters including result limits, offsets for pagination,
+ * and various search modes. It integrates with the core search service to provide fast and accurate
+ * tool discovery across the entire MCP ecosystem.
+ *
+ * Additionally includes a dedicated health check endpoint for monitoring the search service availability
+ * in production environments.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register search routes
+ * await webSearchRoutes(app);
+ * ```
+ */
+export declare function webSearchRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=search.d.ts.map

package/dist/server/src/api/web/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBA+C7D"}

package/dist/server/src/api/web/search.js

@@ -0,0 +1,62 @@
+import { searchCoreService } from '../../services/search/search-core.service.js';
+/**
+ * Tool Search API Routes
+ *
+ * Provides powerful fuzzy search capabilities for discovering tools across all connected MCP (Model Context Protocol) servers.
+ * This module enables users to quickly find relevant tools based on name, description, or other metadata using
+ * advanced search algorithms with pagination support.
+ *
+ * The search API supports flexible query parameters including result limits, offsets for pagination,
+ * and various search modes. It integrates with the core search service to provide fast and accurate
+ * tool discovery across the entire MCP ecosystem.
+ *
+ * Additionally includes a dedicated health check endpoint for monitoring the search service availability
+ * in production environments.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register search routes
+ * await webSearchRoutes(app);
+ * ```
+ */
+export async function webSearchRoutes(fastify) {
+    // GET /web/search - Search for tools with query and optional filters
+    fastify.get('/web/search', async (request) => {
+        const { q, limit, offset } = request.query;
+        // Parse search options
+        const options = {
+            mode: 'fuzzy',
+            limit: limit ? Number(limit) : 50,
+            offset: offset ? Number(offset) : 0,
+            filters: {}
+        };
+        // Perform search
+        const results = await searchCoreService.search(q || '', options);
+        return {
+            results,
+            pagination: {
+                total: results.length,
+                limit: options.limit,
+                offset: options.offset,
+                hasMore: results.length >= options.limit
+            },
+            metadata: {
+                query: q,
+                filters: options.filters,
+                processingTime: 0, // To be implemented: measure processing time
+                cached: false // To be implemented: check cache status
+            }
+        };
+    });
+    // GET /web/search/health - Search service health check (for monitoring)
+    fastify.get('/web/search/health', async () => {
+        return {
+            status: 'healthy',
+            timestamp: new Date().toISOString(),
+            service: 'search-core-service'
+        };
+    });
+}

package/dist/server/src/api/web/servers.d.ts

@@ -0,0 +1,33 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * MCP Server Management API Routes
+ *
+ * Provides comprehensive CRUD (Create, Read, Update, Delete) operations for managing MCP (Model Context Protocol) servers
+ * and their runtime instances within the MCP Hub Lite system. This module serves as the primary interface for
+ * server configuration management, process control, and bulk operations.
+ *
+ * The API supports both static server configuration (defining how servers should be configured) and dynamic
+ * instance management (controlling actual running server processes). It includes sophisticated validation
+ * using Zod schemas to ensure configuration integrity and provides detailed error handling with appropriate
+ * HTTP status codes.
+ *
+ * Key features include:
+ * - Full CRUD operations for server configurations
+ * - Instance-level management for running server processes
+ * - Batch import/export capabilities for server configurations
+ * - Automatic server startup based on enabled status
+ * - Comprehensive validation using Zod schemas
+ * - Detailed error handling with appropriate HTTP status codes
+ * - Support for multiple server types (stdio, sse, streamable-http)
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register server management routes
+ * await webServerRoutes(app);
+ * ```
+ */
+export declare function webServerRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=servers.d.ts.map

package/dist/server/src/api/web/servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/servers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAY1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBA4O7D"}

package/dist/server/src/api/web/servers.js

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+import { hubManager } from '../../services/hub-manager.service.js';
+import { ServerConfigSchema, ServerInstanceConfigSchema } from '../../config/config.schema.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * MCP Server Management API Routes
+ *
+ * Provides comprehensive CRUD (Create, Read, Update, Delete) operations for managing MCP (Model Context Protocol) servers
+ * and their runtime instances within the MCP Hub Lite system. This module serves as the primary interface for
+ * server configuration management, process control, and bulk operations.
+ *
+ * The API supports both static server configuration (defining how servers should be configured) and dynamic
+ * instance management (controlling actual running server processes). It includes sophisticated validation
+ * using Zod schemas to ensure configuration integrity and provides detailed error handling with appropriate
+ * HTTP status codes.
+ *
+ * Key features include:
+ * - Full CRUD operations for server configurations
+ * - Instance-level management for running server processes
+ * - Batch import/export capabilities for server configurations
+ * - Automatic server startup based on enabled status
+ * - Comprehensive validation using Zod schemas
+ * - Detailed error handling with appropriate HTTP status codes
+ * - Support for multiple server types (stdio, sse, streamable-http)
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register server management routes
+ * await webServerRoutes(app);
+ * ```
+ */
+export async function webServerRoutes(fastify) {
+    // GET /web/servers
+    fastify.get('/web/servers', async () => {
+        return hubManager.getAllServers();
+    });
+    // GET /web/servers/name/:name
+    fastify.get('/web/servers/name/:name', async (request, reply) => {
+        const server = hubManager.getServerByName(request.params.name);
+        if (!server) {
+            return reply.code(404).send({ error: 'Server not found' });
+        }
+        return server;
+    });
+    // GET /web/server-instances
+    fastify.get('/web/server-instances', async () => {
+        return hubManager.getServerInstances();
+    });
+    // GET /web/server-instances/:name
+    fastify.get('/web/server-instances/:name', async (request, reply) => {
+        const instances = hubManager.getServerInstanceByName(request.params.name);
+        if (instances.length === 0) {
+            return reply.code(404).send({ error: 'Server instances not found' });
+        }
+        return instances;
+    });
+    // POST /web/servers
+    fastify.post('/web/servers', async (request, reply) => {
+        try {
+            // Accept server name and configuration as request body
+            const postSchema = z.object({
+                name: z.string().min(1).max(100),
+                config: ServerConfigSchema.partial()
+            });
+            const body = postSchema.parse(request.body);
+            const newServer = await hubManager.addServer(body.name, body.config);
+            // If auto-start is enabled, add server instance (addServerInstance will automatically check and handle startup)
+            if (newServer.enabled !== false && newServer.enabled !== undefined) {
+                try {
+                    await hubManager.addServerInstance(body.name, {});
+                }
+                catch (error) {
+                    // Auto-start failure does not affect server addition operation
+                    logger.warn(`Failed to auto-start server instance for ${body.name}:`, error);
+                }
+            }
+            return reply.code(201).send({ name: body.name, config: newServer });
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // POST /web/server-instances/:name
+    fastify.post('/web/server-instances/:name', async (request, reply) => {
+        try {
+            const instanceSchema = ServerInstanceConfigSchema.partial();
+            const body = instanceSchema.parse(request.body);
+            // Check if server exists
+            const server = hubManager.getServerByName(request.params.name);
+            if (!server) {
+                return reply.code(404).send({ error: 'Server not found' });
+            }
+            const newInstance = await hubManager.addServerInstance(request.params.name, body);
+            return reply.code(201).send(newInstance);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // PUT /web/servers/:name
+    fastify.put('/web/servers/:name', async (request, reply) => {
+        try {
+            const partialSchema = ServerConfigSchema.partial();
+            const body = partialSchema.parse(request.body);
+            const updatedServer = await hubManager.updateServer(request.params.name, body);
+            if (!updatedServer) {
+                return reply.code(404).send({ error: 'Server not found' });
+            }
+            return { name: request.params.name, config: updatedServer };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // PUT /web/server-instances/:name/:index
+    fastify.put('/web/server-instances/:name/:index', async (request, reply) => {
+        try {
+            const partialSchema = ServerInstanceConfigSchema.partial();
+            const body = partialSchema.parse(request.body);
+            await hubManager.updateServerInstance(request.params.name, request.params.index, body);
+            return reply.code(200).send({ message: 'Server instance updated' });
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // DELETE /web/servers/:name
+    fastify.delete('/web/servers/:name', async (request, reply) => {
+        const success = await hubManager.removeServer(request.params.name);
+        if (!success) {
+            return reply.code(404).send({ error: 'Server not found' });
+        }
+        return reply.code(204).send();
+    });
+    // DELETE /web/server-instances/:name/:index
+    fastify.delete('/web/server-instances/:name/:index', async (request, reply) => {
+        try {
+            await hubManager.removeServerInstance(request.params.name, request.params.index);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+    // POST /web/servers/batch
+    fastify.post('/web/servers/batch', async (request, reply) => {
+        try {
+            // First parse the basic structure without strict validation of server configuration to allow preprocessing
+            const batchSchema = z.object({
+                mcpServers: z.array(z.object({
+                    name: z.string().min(1).max(100),
+                    config: ServerConfigSchema.partial()
+                }))
+            });
+            const body = batchSchema.parse(request.body);
+            const results = {
+                success: [],
+                errors: []
+            };
+            const existingServers = hubManager.getAllServers();
+            const existingNames = new Set(existingServers.map((server) => server.name.toLowerCase()));
+            const serversToAdd = [];
+            const serversToConnect = [];
+            // Phase 1: Collect and validate all servers
+            for (const { name, config: serverConfig } of body.mcpServers) {
+                try {
+                    const processedName = name.toLowerCase();
+                    // Check for duplicate names
+                    if (existingNames.has(processedName)) {
+                        results.errors.push({
+                            name: name,
+                            error: 'Server with this name already exists'
+                        });
+                        continue;
+                    }
+                    // Validate server configuration using Zod (now supports "http" type)
+                    const validatedConfig = ServerConfigSchema.partial().parse(serverConfig);
+                    serversToAdd.push({ name: processedName, config: validatedConfig });
+                    if (validatedConfig.enabled !== false && validatedConfig.enabled !== undefined) {
+                        serversToConnect.push(processedName);
+                    }
+                    results.success.push({ name: processedName, config: validatedConfig });
+                    existingNames.add(processedName); // Prevent duplicates within the same batch
+                }
+                catch (error) {
+                    results.errors.push({
+                        name: name,
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    });
+                }
+            }
+            // Phase 2: Batch save configuration (save only once)
+            if (serversToAdd.length > 0) {
+                await hubManager.addServersWithoutAutoStart(serversToAdd);
+            }
+            // Phase 3: Batch create server instances (without auto-connect)
+            if (serversToAdd.length > 0) {
+                await hubManager.addServerInstancesWithoutConnect(serversToAdd.map((s) => s.name));
+            }
+            // Phase 4: Concurrently start all server instances that need to be connected
+            if (serversToConnect.length > 0) {
+                await hubManager.connectServerInstances(serversToConnect);
+            }
+            return reply.code(200).send({
+                code: 200,
+                message: 'Servers imported successfully',
+                data: results
+            });
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.code(400).send({ error: 'Validation failed', details: error.issues });
+            }
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
+}