@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/services/hub-manager.service.js

@@ -0,0 +1,413 @@
+import { configManager } from '../config/config-manager.js';
+import { logger, LOG_MODULES } from '../utils/logger.js';
+import { mcpConnectionManager } from './mcp-connection-manager.js';
+import { eventBus, EventTypes } from './event-bus.service.js';
+/**
+ * Manages MCP server configurations and lifecycle operations through the configuration manager.
+ *
+ * This service provides a comprehensive interface for CRUD operations on MCP servers,
+ * including batch operations for performance optimization, instance management, and
+ * event-driven communication with other system components. It serves as the primary
+ * entry point for server management operations in the MCP Hub Lite system.
+ *
+ * The service integrates with the configuration manager for persistence and the
+ * MCP connection manager for automatic connection handling, while publishing
+ * events to notify other components of state changes.
+ *
+ * @example
+ * ```typescript
+ * const hubManager = new HubManagerService();
+ * await hubManager.addServer('my-server', { type: 'stdio', command: 'npx my-mcp' });
+ * await hubManager.removeServer('my-server');
+ * ```
+ */
+export class HubManagerService {
+    configManager;
+    constructor(manager = configManager) {
+        this.configManager = manager;
+    }
+    /**
+     * Adds multiple server configurations in a single batch operation without auto-starting.
+     *
+     * This method optimizes performance for bulk server addition by batching configuration
+     * updates and saving the configuration only once at the end. It publishes SERVER_ADDED
+     * events for each newly added server to notify other system components.
+     *
+     * @param {Array<{ name: string; config: Partial<ServerConfig> }>} servers - Array of server configurations to add
+     * @returns {Promise<void>} Resolves when all servers are added and configuration is saved
+     *
+     * @example
+     * ```typescript
+     * await hubManager.addServersWithoutAutoStart([
+     *   { name: 'server1', config: { type: 'stdio', command: 'npx server1' } },
+     *   { name: 'server2', config: { type: 'http', url: 'http://localhost:8080' } }
+     * ]);
+     * ```
+     */
+    async addServersWithoutAutoStart(servers) {
+        await this.configManager.addServers(servers);
+        // Publish SERVER_ADDED event for all newly added servers
+        for (const { name } of servers) {
+            const serverConfig = this.getServerByName(name);
+            if (serverConfig) {
+                eventBus.publish(EventTypes.SERVER_ADDED, { name, config: serverConfig });
+            }
+        }
+    }
+    /**
+     * Creates server instances for multiple servers without automatically connecting them.
+     *
+     * This method iterates through the provided server names and creates a new instance
+     * for each server using the configuration manager. It publishes SERVER_INSTANCE_ADDED
+     * events for each created instance to notify other system components.
+     *
+     * @param {string[]} serverNames - Array of server names to create instances for
+     * @returns {Promise<void>} Resolves when all instances are created
+     *
+     * @example
+     * ```typescript
+     * await hubManager.addServerInstancesWithoutConnect(['server1', 'server2']);
+     * ```
+     */
+    async addServerInstancesWithoutConnect(serverNames) {
+        for (const name of serverNames) {
+            await this.configManager.addServerInstance(name, {});
+            const instances = this.getServerInstanceByName(name);
+            const lastInstance = instances[instances.length - 1];
+            eventBus.publish(EventTypes.SERVER_INSTANCE_ADDED, { name, instance: lastInstance });
+        }
+    }
+    /**
+     * Concurrently connects to multiple server instances using Promise.all for efficiency.
+     *
+     * This method iterates through the provided server names, retrieves their configurations
+     * and instances, and attempts to connect to each instance concurrently. It only attempts
+     * to connect to servers that are enabled in their configuration. Errors during connection
+     * are logged but don't prevent other connections from proceeding.
+     *
+     * @param {string[]} serverNames - Array of server names to connect instances for
+     * @returns {Promise<void>} Resolves when all connection attempts complete
+     *
+     * @example
+     * ```typescript
+     * await hubManager.connectServerInstances(['server1', 'server2']);
+     * ```
+     */
+    async connectServerInstances(serverNames) {
+        const connectPromises = serverNames.map(async (name) => {
+            const server = this.getServerByName(name);
+            if (server && server.enabled !== false) {
+                const instances = this.getServerInstanceByName(name);
+                for (const instance of instances) {
+                    try {
+                        await mcpConnectionManager.connect({ ...server, ...instance });
+                    }
+                    catch (error) {
+                        logger.error(`Failed to connect server instance for ${name}:`, error, LOG_MODULES.HUB_MANAGER);
+                    }
+                }
+            }
+        });
+        // Execute concurrently using Promise.all
+        await Promise.all(connectPromises);
+    }
+    /**
+     * Retrieves all configured servers with their names and configurations.
+     *
+     * This method delegates to the configuration manager to return a complete list of
+     * all servers that have been configured in the system, including their full
+     * configuration objects.
+     *
+     * @returns {Array<{ name: string; config: ServerConfig }>} Array of all configured servers
+     *
+     * @example
+     * ```typescript
+     * const servers = hubManager.getAllServers();
+     * console.log(`Total servers: ${servers.length}`);
+     * ```
+     */
+    getAllServers() {
+        return this.configManager.getServers();
+    }
+    /**
+     * Retrieves a server configuration and instance by its unique instance ID.
+     *
+     * This method performs an O(n) search across all servers and their instances to find
+     * the matching instance ID. It returns a composite object containing the server name,
+     * full configuration, and specific instance configuration.
+     *
+     * @param {string} id - Unique instance ID to search for
+     * @returns {{ name: string; config: ServerConfig; instance: ServerInstanceConfig } | undefined}
+     * Composite server/instance object or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const serverInfo = hubManager.getServerById('instance-123');
+     * if (serverInfo) {
+     *   console.log(`Found server: ${serverInfo.name}`);
+     * }
+     * ```
+     */
+    getServerById(id) {
+        // Iterate through all servers and instances to find matching id
+        const serverInstances = this.configManager.getServerInstances();
+        for (const [serverName, instances] of Object.entries(serverInstances)) {
+            const instance = instances.find((inst) => inst.id === id);
+            if (instance) {
+                const serverConfig = this.configManager.getServerByName(serverName);
+                if (serverConfig) {
+                    return {
+                        name: serverName,
+                        config: serverConfig,
+                        instance
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Retrieves a server configuration by its name.
+     *
+     * This method delegates to the configuration manager to return the full configuration
+     * for a server with the specified name, or undefined if no such server exists.
+     *
+     * @param {string} name - Server name to look up
+     * @returns {ServerConfig | undefined} Full server configuration or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const config = hubManager.getServerByName('my-server');
+     * if (config) {
+     *   console.log(`Server type: ${config.type}`);
+     * }
+     * ```
+     */
+    getServerByName(name) {
+        return this.configManager.getServerByName(name);
+    }
+    /**
+     * Retrieves all server instances grouped by server name.
+     *
+     * This method returns a record mapping server names to arrays of their instance configurations,
+     * providing a complete view of all server instances in the system.
+     *
+     * @returns {Record<string, ServerInstanceConfig[]>} Object mapping server names to instance arrays
+     *
+     * @example
+     * ```typescript
+     * const instances = hubManager.getServerInstances();
+     * Object.entries(instances).forEach(([name, instances]) => {
+     *   console.log(`${name} has ${instances.length} instances`);
+     * });
+     * ```
+     */
+    getServerInstances() {
+        return this.configManager.getServerInstances();
+    }
+    /**
+     * Retrieves all instances for a specific server by name.
+     *
+     * This method returns an array of all instance configurations for the specified server,
+     * or an empty array if the server doesn't exist or has no instances.
+     *
+     * @param {string} name - Server name to get instances for
+     * @returns {ServerInstanceConfig[]} Array of instance configurations for the server
+     *
+     * @example
+     * ```typescript
+     * const instances = hubManager.getServerInstanceByName('my-server');
+     * console.log(`Server has ${instances.length} instances`);
+     * ```
+     */
+    getServerInstanceByName(name) {
+        return this.configManager.getServerInstanceByName(name);
+    }
+    /**
+     * Adds a new server configuration to the system.
+     *
+     * This method creates a new server with the specified name and configuration,
+     * logs the addition, and publishes a SERVER_ADDED event to notify other system components.
+     * The method returns the complete server configuration after validation and normalization.
+     *
+     * @param {string} name - Unique name for the new server
+     * @param {Partial<ServerConfig>} config - Partial server configuration to merge with defaults
+     * @returns {Promise<ServerConfig>} Complete server configuration after creation
+     *
+     * @example
+     * ```typescript
+     * const config = await hubManager.addServer('my-server', {
+     *   type: 'stdio',
+     *   command: 'npx my-mcp-server'
+     * });
+     * console.log('Server added successfully');
+     * ```
+     */
+    async addServer(name, config) {
+        const newServer = await this.configManager.addServer(name, config);
+        logger.info(`Server added: [${name}]`, LOG_MODULES.HUB_MANAGER);
+        // Publish server added event
+        eventBus.publish(EventTypes.SERVER_ADDED, { name, config: newServer });
+        return newServer;
+    }
+    /**
+     * Adds a new instance to an existing server and optionally connects to it.
+     *
+     * This method creates a new instance for the specified server, and if the server is enabled,
+     * automatically attempts to connect to the new instance. It publishes a SERVER_INSTANCE_ADDED
+     * event to notify other system components and returns the complete instance configuration.
+     *
+     * @param {string} name - Name of the existing server to add an instance to
+     * @param {Partial<ServerInstanceConfig>} instance - Partial instance configuration to merge with defaults
+     * @returns {Promise<ServerInstanceConfig>} Complete instance configuration after creation
+     * @throws {Error} If the server doesn't exist or connection fails (logged but not thrown)
+     *
+     * @example
+     * ```typescript
+     * const instance = await hubManager.addServerInstance('my-server', {
+     *   cwd: '/path/to/working/directory'
+     * });
+     * console.log('Server instance added successfully');
+     * ```
+     */
+    async addServerInstance(name, instance) {
+        const newInstance = await this.configManager.addServerInstance(name, instance);
+        logger.info(`Server instance added for server: [${name}]`, LOG_MODULES.HUB_MANAGER);
+        // If server config is enabled, attempt to connect
+        const server = this.getServerByName(name);
+        if (server && server.enabled !== false) {
+            try {
+                await mcpConnectionManager.connect({ ...server, ...newInstance });
+            }
+            catch (error) {
+                logger.error(`Failed to auto-connect server instance for ${name}:`, error, LOG_MODULES.HUB_MANAGER);
+            }
+        }
+        eventBus.publish(EventTypes.SERVER_INSTANCE_ADDED, { name, instance: newInstance });
+        return newInstance;
+    }
+    /**
+     * Updates an existing server configuration with new values.
+     *
+     * This method validates that the server exists before applying updates, logs the operation,
+     * and publishes a SERVER_UPDATED event to notify other system components. It returns the
+     * updated server configuration or null if the server doesn't exist.
+     *
+     * @param {string} name - Name of the server to update
+     * @param {Partial<ServerConfig>} updates - Partial configuration updates to apply
+     * @returns {Promise<ServerConfig | null>} Updated server configuration or null if not found
+     *
+     * @example
+     * ```typescript
+     * const updated = await hubManager.updateServer('my-server', {
+     *   enabled: false
+     * });
+     * if (updated) {
+     *   console.log('Server updated successfully');
+     * }
+     * ```
+     */
+    async updateServer(name, updates) {
+        const existing = this.getServerByName(name);
+        if (!existing) {
+            logger.warn(`Attempted to update non-existent server: ${name}`, LOG_MODULES.HUB_MANAGER);
+            return null;
+        }
+        await this.configManager.updateServer(name, updates);
+        logger.info(`Server updated: ${name}`, LOG_MODULES.HUB_MANAGER);
+        const updatedServer = this.getServerByName(name) || null;
+        if (updatedServer) {
+            eventBus.publish(EventTypes.SERVER_UPDATED, { name, config: updatedServer });
+        }
+        return updatedServer;
+    }
+    /**
+     * Updates a specific server instance at the given index.
+     *
+     * This method applies updates to the server instance at the specified index within the
+     * server's instance array, logs the operation, and publishes a SERVER_INSTANCE_UPDATED
+     * event to notify other system components.
+     *
+     * @param {string} name - Name of the server containing the instance to update
+     * @param {number} index - Index of the instance within the server's instance array
+     * @param {Partial<ServerInstanceConfig>} updates - Partial instance configuration updates to apply
+     * @returns {Promise<void>} Resolves when the update is complete
+     * @throws {Error} If the server or instance index doesn't exist
+     *
+     * @example
+     * ```typescript
+     * await hubManager.updateServerInstance('my-server', 0, {
+     *   cwd: '/new/working/directory'
+     * });
+     * console.log('Server instance updated successfully');
+     * ```
+     */
+    async updateServerInstance(name, index, updates) {
+        await this.configManager.updateServerInstance(name, index, updates);
+        logger.info(`Server instance updated for server: [${name}] at index: ${index}`, LOG_MODULES.HUB_MANAGER);
+        eventBus.publish(EventTypes.SERVER_INSTANCE_UPDATED, { name, index, updates });
+    }
+    /**
+     * Removes a server and all its instances from the system.
+     *
+     * This method performs a graceful shutdown by first disconnecting all instances of the server,
+     * then removing the server configuration from the system. It publishes a SERVER_DELETED event
+     * to notify other system components and returns true if the server existed and was removed.
+     *
+     * @param {string} name - Name of the server to remove
+     * @returns {Promise<boolean>} True if server existed and was removed, false if not found
+     *
+     * @example
+     * ```typescript
+     * const removed = await hubManager.removeServer('my-server');
+     * if (removed) {
+     *   console.log('Server removed successfully');
+     * }
+     * ```
+     */
+    async removeServer(name) {
+        const existing = this.getServerByName(name);
+        if (!existing) {
+            return false;
+        }
+        // Disconnect all instances of this server
+        const instances = this.getServerInstanceByName(name);
+        for (const instance of instances) {
+            await mcpConnectionManager.disconnect(instance.id).catch(() => { });
+        }
+        await this.configManager.removeServer(name);
+        logger.info(`Server removed: ${name}`, LOG_MODULES.HUB_MANAGER);
+        eventBus.publish(EventTypes.SERVER_DELETED, name);
+        return true;
+    }
+    /**
+     * Removes a specific server instance at the given index.
+     *
+     * This method performs a graceful shutdown by first disconnecting the specified instance,
+     * then removing it from the server's instance array. It publishes a SERVER_INSTANCE_DELETED
+     * event to notify other system components and logs the operation.
+     *
+     * @param {string} name - Name of the server containing the instance to remove
+     * @param {number} index - Index of the instance within the server's instance array
+     * @returns {Promise<void>} Resolves when the instance is removed
+     * @throws {Error} If the server doesn't exist or the index is out of bounds
+     *
+     * @example
+     * ```typescript
+     * await hubManager.removeServerInstance('my-server', 0);
+     * console.log('Server instance removed successfully');
+     * ```
+     */
+    async removeServerInstance(name, index) {
+        const instances = this.getServerInstanceByName(name);
+        if (index >= 0 && index < instances.length) {
+            const instance = instances[index];
+            // Disconnect this instance
+            await mcpConnectionManager.disconnect(instance.id).catch(() => { });
+        }
+        await this.configManager.removeServerInstance(name, index);
+        logger.info(`Server instance removed for server: [${name}] at index: ${index}`, LOG_MODULES.HUB_MANAGER);
+        eventBus.publish(EventTypes.SERVER_INSTANCE_DELETED, { name, index });
+    }
+}
+export const hubManager = new HubManagerService();

package/dist/server/src/services/hub-tools/index.d.ts

@@ -0,0 +1,10 @@
+export { HubToolsService, hubToolsService } from '../hub-tools.service.js';
+export type { RequestOptions, ServerInstanceInfo, ValidServer } from './types.js';
+export { hasValidId, selectBestInstance } from './server-selector.js';
+export { getSystemTools } from './system-tool-definitions.js';
+export type { ToolAnnotations, SystemToolDefinition } from './system-tool-definitions.js';
+export { findServers, findToolsInServer, findTools } from './tool-search.js';
+export type { SearchOptions } from './tool-search.js';
+export { generateDynamicResources, readResource } from './resource-generator.js';
+export type { ServerMetadata } from './resource-generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/hub-tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG3E,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7E,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,wBAAwB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACjF,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/server/src/services/hub-tools/index.js

@@ -0,0 +1,6 @@
+// Re-export the original service for backward compatibility
+export { HubToolsService, hubToolsService } from '../hub-tools.service.js';
+export { hasValidId, selectBestInstance } from './server-selector.js';
+export { getSystemTools } from './system-tool-definitions.js';
+export { findServers, findToolsInServer, findTools } from './tool-search.js';
+export { generateDynamicResources, readResource } from './resource-generator.js';

package/dist/server/src/services/hub-tools/resource-generator.d.ts

@@ -0,0 +1,63 @@
+import type { Resource } from '../../../shared/models/resource.model.js';
+import type { ServerStatus } from '../../../shared/types/common.types.js';
+/**
+ * Server metadata resource content.
+ */
+export interface ServerMetadata {
+    name: string;
+    status: ServerStatus;
+    toolsCount: number;
+    resourcesCount: number;
+    tags: Record<string, string>;
+    lastHeartbeat: number;
+    uptime: number;
+}
+/**
+ * Generates dynamic Hub resources based on currently connected MCP servers.
+ *
+ * This method creates virtual resources that represent the current state of connected
+ * servers, including server metadata, available tools, and server resources. Each
+ * resource has a unique URI following the hub://servers/{serverName}[/type] pattern.
+ *
+ * The generated resources include:
+ * - Server metadata: hub://servers/{serverName}
+ * - Tools list: hub://servers/{serverName}/tools
+ * - Resources list: hub://servers/{serverName}/resources (only if server has resources)
+ *
+ * @returns {Resource[]} Array of dynamically generated MCP resource objects
+ *
+ * @example
+ * ```typescript
+ * const resources = generateDynamicResources();
+ * console.log(`Generated ${resources.length} dynamic resources`);
+ * ```
+ */
+export declare function generateDynamicResources(): Resource[];
+/**
+ * Reads content from a specific Hub resource URI.
+ *
+ * This method provides access to dynamically generated Hub resources by parsing the URI
+ * and returning the appropriate content based on the resource type. It supports three
+ * types of resources:
+ * - Server metadata: hub://servers/{serverName}
+ * - Tools list: hub://servers/{serverName}/tools
+ * - Resources list: hub://servers/{serverName}/resources
+ *
+ * The method includes comprehensive validation of URI format and server existence,
+ * throwing descriptive errors for invalid requests.
+ *
+ * @param {string} uri - Resource URI to read (e.g., hub://servers/server-name)
+ * @returns {Promise<ServerMetadata | Tool[] | Resource[]>} Resource content based on URI type
+ * @throws {Error} If URI format is invalid, server not found, or resource type unknown
+ *
+ * @example
+ * ```typescript
+ * // Read server metadata
+ * const serverInfo = await readResource('hub://servers/my-mcp-server');
+ *
+ * // Read tools list
+ * const tools = await readResource('hub://servers/my-mcp-server/tools');
+ * ```
+ */
+export declare function readResource(uri: string): Promise<ServerMetadata | Resource[]>;
+//# sourceMappingURL=resource-generator.d.ts.map

package/dist/server/src/services/hub-tools/resource-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-generator.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/resource-generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGlE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,IAAI,QAAQ,EAAE,CAqDrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,QAAQ,EAAE,CAAC,CAgDpF"}

package/dist/server/src/services/hub-tools/resource-generator.js

@@ -0,0 +1,141 @@
+import { hubManager } from '../hub-manager.service.js';
+import { mcpConnectionManager } from '../mcp-connection-manager.js';
+import { hasValidId, selectBestInstance } from './server-selector.js';
+/**
+ * Generates dynamic Hub resources based on currently connected MCP servers.
+ *
+ * This method creates virtual resources that represent the current state of connected
+ * servers, including server metadata, available tools, and server resources. Each
+ * resource has a unique URI following the hub://servers/{serverName}[/type] pattern.
+ *
+ * The generated resources include:
+ * - Server metadata: hub://servers/{serverName}
+ * - Tools list: hub://servers/{serverName}/tools
+ * - Resources list: hub://servers/{serverName}/resources (only if server has resources)
+ *
+ * @returns {Resource[]} Array of dynamically generated MCP resource objects
+ *
+ * @example
+ * ```typescript
+ * const resources = generateDynamicResources();
+ * console.log(`Generated ${resources.length} dynamic resources`);
+ * ```
+ */
+export function generateDynamicResources() {
+    const resources = [];
+    // Use the same access pattern as tools - directly access manager cache
+    const servers = hubManager.getAllServers();
+    for (const server of servers) {
+        if (!hasValidId(server) || !server.config.enabled) {
+            continue;
+        }
+        const bestInstance = selectBestInstance(server.name);
+        if (!bestInstance || !bestInstance.instance.id) {
+            continue;
+        }
+        const instanceId = bestInstance.instance.id;
+        // Server metadata resource
+        resources.push({
+            uri: `hub://servers/${server.name}`,
+            name: `Server: ${server.name}`,
+            description: server.config.description || `Connected MCP server: ${server.name}`,
+            mimeType: 'application/json',
+            serverId: instanceId
+        });
+        // Tools resource - only add if server has tools
+        const tools = mcpConnectionManager.getTools(instanceId);
+        if (tools.length > 0) {
+            resources.push({
+                uri: `hub://servers/${server.name}/tools`,
+                name: `Tools: ${server.name}`,
+                description: `${tools.length} tools available from ${server.name}`,
+                mimeType: 'application/json',
+                serverId: instanceId
+            });
+        }
+        // Resources resource - only add if server has resources
+        const serverResources = mcpConnectionManager.getResources(instanceId);
+        if (serverResources.length > 0) {
+            resources.push({
+                uri: `hub://servers/${server.name}/resources`,
+                name: `Resources: ${server.name}`,
+                description: `${serverResources.length} resources available from ${server.name}`,
+                mimeType: 'application/json',
+                serverId: instanceId
+            });
+        }
+    }
+    return resources;
+}
+/**
+ * Reads content from a specific Hub resource URI.
+ *
+ * This method provides access to dynamically generated Hub resources by parsing the URI
+ * and returning the appropriate content based on the resource type. It supports three
+ * types of resources:
+ * - Server metadata: hub://servers/{serverName}
+ * - Tools list: hub://servers/{serverName}/tools
+ * - Resources list: hub://servers/{serverName}/resources
+ *
+ * The method includes comprehensive validation of URI format and server existence,
+ * throwing descriptive errors for invalid requests.
+ *
+ * @param {string} uri - Resource URI to read (e.g., hub://servers/server-name)
+ * @returns {Promise<ServerMetadata | Tool[] | Resource[]>} Resource content based on URI type
+ * @throws {Error} If URI format is invalid, server not found, or resource type unknown
+ *
+ * @example
+ * ```typescript
+ * // Read server metadata
+ * const serverInfo = await readResource('hub://servers/my-mcp-server');
+ *
+ * // Read tools list
+ * const tools = await readResource('hub://servers/my-mcp-server/tools');
+ * ```
+ */
+export async function readResource(uri) {
+    // Validate URI format
+    if (!uri.startsWith('hub://')) {
+        throw new Error(`Invalid Hub resource URI: ${uri}. Must start with 'hub://'`);
+    }
+    // Parse URI
+    const uriParts = uri.replace('hub://', '').split('/');
+    if (uriParts.length < 2 || uriParts[0] !== 'servers') {
+        throw new Error(`Invalid Hub resource URI format: ${uri}`);
+    }
+    const serverName = uriParts[1];
+    const resourceType = uriParts[2]; // 'tools', 'resources', or undefined for server metadata
+    // Check if server exists and is connected
+    const serverInfo = selectBestInstance(serverName);
+    if (!serverInfo) {
+        throw new Error(`Server not found or not connected: ${serverName}`);
+    }
+    const instanceId = serverInfo.instance.id;
+    // Return appropriate content based on resource type
+    if (!resourceType) {
+        // Server metadata
+        const serverConfig = hubManager.getServerByName(serverName);
+        const tools = mcpConnectionManager.getTools(instanceId);
+        const resources = mcpConnectionManager.getResources(instanceId);
+        return {
+            name: serverName,
+            status: serverInfo.instance.status,
+            toolsCount: tools.length,
+            resourcesCount: resources.length,
+            tags: serverConfig?.tags || {},
+            lastHeartbeat: serverInfo.instance.lastHeartbeat,
+            uptime: serverInfo.instance.uptime
+        };
+    }
+    else if (resourceType === 'tools') {
+        // Tools list
+        return mcpConnectionManager.getTools(instanceId);
+    }
+    else if (resourceType === 'resources') {
+        // Resources list
+        return mcpConnectionManager.getResources(instanceId);
+    }
+    else {
+        throw new Error(`Unknown resource type: ${resourceType}`);
+    }
+}