@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,63 @@
+import type { RequestOptions, ServerInstanceInfo, ValidServer } from './types.js';
+/**
+ * Type guard to validate that a server object has valid name and configuration.
+ *
+ * This function checks if the provided object is a valid server with both a non-empty
+ * name string and a configuration object, ensuring type safety for server operations.
+ *
+ * @param {unknown} server - Object to validate as a server
+ * @returns {boolean} True if the object is a valid server with name and config
+ *
+ * @example
+ * ```typescript
+ * const server = { name: 'my-server', config: { type: 'stdio' } };
+ * if (hasValidId(server)) {
+ *   // TypeScript knows server is properly typed
+ *   console.log(server.name);
+ * }
+ * ```
+ */
+export declare function hasValidId(server: unknown): server is ValidServer;
+/**
+ * Selects the best server instance based on server name and request options.
+ *
+ * This function resolves a server name to its configuration and instance details,
+ * handling both single and multiple instance scenarios. Currently, it returns
+ * the first instance for multi-instance servers, but the architecture supports
+ * future extensions for intelligent instance selection based on session ID,
+ * tags, client ID, or load conditions.
+ *
+ * The function performs the following steps:
+ * 1. Retrieves all instances of the specified server name
+ * 2. Returns undefined if no instances are found
+ * 3. Gets the server configuration from the hub manager
+ * 4. For single-instance servers, returns the instance directly
+ * 5. For multi-instance servers, currently returns the first instance (with future extension support)
+ *
+ * Future extensions planned include:
+ * - Session-aware instance selection based on sessionId
+ * - Tag-based instance selection for matching specific requirements
+ * - Load-balancing across multiple instances
+ * - Client-specific instance assignment
+ *
+ * @param {string} serverName - Name of the server to select an instance for
+ * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @returns {{ name: string; config: ServerConfig; instance: ServerInstanceConfig & Record<string, unknown> } | undefined}
+ * Server information with configuration and instance details, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const serverInfo = selectBestInstance('my-mcp-server');
+ * if (serverInfo) {
+ *   console.log(`Selected instance: ${serverInfo.instance.id}`);
+ * }
+ *
+ * // With request options (future extension)
+ * const serverInfoWithOptions = selectBestInstance('my-mcp-server', {
+ *   sessionId: 'session-123',
+ *   tags: { environment: 'production' }
+ * });
+ * ```
+ */
+export declare function selectBestInstance(serverName: string, requestOptions?: RequestOptions): ServerInstanceInfo | undefined;
+//# sourceMappingURL=server-selector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server-selector.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/server-selector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,WAAW,CAMjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,cAAc,GAC9B,kBAAkB,GAAG,SAAS,CA+ChC"}

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

@@ -0,0 +1,108 @@
+import { hubManager } from '../hub-manager.service.js';
+/**
+ * Type guard to validate that a server object has valid name and configuration.
+ *
+ * This function checks if the provided object is a valid server with both a non-empty
+ * name string and a configuration object, ensuring type safety for server operations.
+ *
+ * @param {unknown} server - Object to validate as a server
+ * @returns {boolean} True if the object is a valid server with name and config
+ *
+ * @example
+ * ```typescript
+ * const server = { name: 'my-server', config: { type: 'stdio' } };
+ * if (hasValidId(server)) {
+ *   // TypeScript knows server is properly typed
+ *   console.log(server.name);
+ * }
+ * ```
+ */
+export function hasValidId(server) {
+    if (typeof server !== 'object' || server === null) {
+        return false;
+    }
+    const s = server;
+    return typeof s.name === 'string' && s.name.length > 0 && typeof s.config === 'object';
+}
+/**
+ * Selects the best server instance based on server name and request options.
+ *
+ * This function resolves a server name to its configuration and instance details,
+ * handling both single and multiple instance scenarios. Currently, it returns
+ * the first instance for multi-instance servers, but the architecture supports
+ * future extensions for intelligent instance selection based on session ID,
+ * tags, client ID, or load conditions.
+ *
+ * The function performs the following steps:
+ * 1. Retrieves all instances of the specified server name
+ * 2. Returns undefined if no instances are found
+ * 3. Gets the server configuration from the hub manager
+ * 4. For single-instance servers, returns the instance directly
+ * 5. For multi-instance servers, currently returns the first instance (with future extension support)
+ *
+ * Future extensions planned include:
+ * - Session-aware instance selection based on sessionId
+ * - Tag-based instance selection for matching specific requirements
+ * - Load-balancing across multiple instances
+ * - Client-specific instance assignment
+ *
+ * @param {string} serverName - Name of the server to select an instance for
+ * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @returns {{ name: string; config: ServerConfig; instance: ServerInstanceConfig & Record<string, unknown> } | undefined}
+ * Server information with configuration and instance details, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const serverInfo = selectBestInstance('my-mcp-server');
+ * if (serverInfo) {
+ *   console.log(`Selected instance: ${serverInfo.instance.id}`);
+ * }
+ *
+ * // With request options (future extension)
+ * const serverInfoWithOptions = selectBestInstance('my-mcp-server', {
+ *   sessionId: 'session-123',
+ *   tags: { environment: 'production' }
+ * });
+ * ```
+ */
+export function selectBestInstance(serverName, requestOptions) {
+    // Get all instances of the server
+    const instances = hubManager.getServerInstanceByName(serverName);
+    if (instances.length === 0) {
+        return undefined;
+    }
+    // Get server configuration
+    const serverConfig = hubManager.getServerByName(serverName);
+    if (!serverConfig) {
+        return undefined;
+    }
+    // If there's only one instance, return it directly
+    if (instances.length === 1) {
+        return {
+            name: serverName,
+            config: serverConfig,
+            instance: instances[0]
+        };
+    }
+    // Multi-instance selection logic (for future extension)
+    // Currently simplified implementation: return the first instance
+    // Future extensions could support:
+    // - Selecting specific instance based on sessionId
+    // - Selecting optimal instance based on tags matching
+    // - Selecting dedicated instance based on client ID
+    // - Selecting instance based on load conditions
+    // Although requestOptions is not currently used, it's kept for future extension
+    if (requestOptions?.sessionId) {
+        // In the future, specific instance can be selected based on sessionId
+        // Currently return the first instance temporarily
+    }
+    if (requestOptions?.tags) {
+        // In the future, optimal instance can be selected based on tags matching
+        // Currently return the first instance temporarily
+    }
+    return {
+        name: serverName,
+        config: serverConfig,
+        instance: instances[0] // Will be extended to intelligent selection logic later
+    };
+}

package/dist/server/src/services/hub-tools/system-tool-definitions.d.ts

@@ -0,0 +1,47 @@
+import type { JsonSchema } from '../../../shared/models/tool.model.js';
+/**
+ * Tool annotation configuration.
+ */
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+/**
+ * System tool definition structure.
+ */
+export interface SystemToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    annotations?: ToolAnnotations;
+}
+/**
+ * Retrieves the complete list of system tools provided by this service.
+ *
+ * This method generates system tool configurations based on the SYSTEM_TOOL_NAMES constant,
+ * ensuring consistency with the defined system tool names. Each tool includes its name,
+ * description, input schema, and annotations for proper client-side rendering and behavior.
+ *
+ * The method implements all standard system tools:
+ * - list-servers: List all connected servers
+ * - find-servers: Find servers matching a pattern
+ * - list-all-tools-in-server: List tools from a specific server
+ * - find-tools-in-server: Find tools in a specific server
+ * - get-tool: Get complete tool schema
+ * - call-tool: Call a specific tool from a specific server
+ * - find-tools: Find tools across all servers
+ *
+ * @returns {Array<{ name: string; description: string; inputSchema: JsonSchema; annotations?: ToolAnnotations }>}
+ * Array of system tool configurations
+ *
+ * @example
+ * ```typescript
+ * const systemTools = getSystemTools();
+ * console.log(`Available system tools: ${systemTools.length}`);
+ * ```
+ */
+export declare function getSystemTools(): SystemToolDefinition[];
+//# sourceMappingURL=system-tool-definitions.d.ts.map

package/dist/server/src/services/hub-tools/system-tool-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-tool-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/system-tool-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAY/D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,EAAE,CAwMvD"}

package/dist/server/src/services/hub-tools/system-tool-definitions.js

@@ -0,0 +1,225 @@
+import { SYSTEM_TOOL_NAMES, LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS_IN_SERVER_TOOL, FIND_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, FIND_TOOLS_TOOL } from '../../models/system-tools.constants.js';
+/**
+ * Retrieves the complete list of system tools provided by this service.
+ *
+ * This method generates system tool configurations based on the SYSTEM_TOOL_NAMES constant,
+ * ensuring consistency with the defined system tool names. Each tool includes its name,
+ * description, input schema, and annotations for proper client-side rendering and behavior.
+ *
+ * The method implements all standard system tools:
+ * - list-servers: List all connected servers
+ * - find-servers: Find servers matching a pattern
+ * - list-all-tools-in-server: List tools from a specific server
+ * - find-tools-in-server: Find tools in a specific server
+ * - get-tool: Get complete tool schema
+ * - call-tool: Call a specific tool from a specific server
+ * - find-tools: Find tools across all servers
+ *
+ * @returns {Array<{ name: string; description: string; inputSchema: JsonSchema; annotations?: ToolAnnotations }>}
+ * Array of system tool configurations
+ *
+ * @example
+ * ```typescript
+ * const systemTools = getSystemTools();
+ * console.log(`Available system tools: ${systemTools.length}`);
+ * ```
+ */
+export function getSystemTools() {
+    const systemTools = [];
+    // Build system tools based on the constant array to ensure consistency
+    for (const toolName of SYSTEM_TOOL_NAMES) {
+        switch (toolName) {
+            case LIST_SERVERS_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'List all connected servers',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {}
+                    },
+                    annotations: {
+                        title: 'List Servers',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            case FIND_SERVERS_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'Find servers matching a pattern',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pattern: { type: 'string', description: 'Regex pattern to search for' },
+                            searchIn: {
+                                type: 'string',
+                                enum: ['name', 'description', 'both'],
+                                default: 'both'
+                            },
+                            caseSensitive: { type: 'boolean', default: false }
+                        },
+                        required: ['pattern']
+                    },
+                    annotations: {
+                        title: 'Find Servers',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            case LIST_ALL_TOOLS_IN_SERVER_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'List all tools from a specific server',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            serverName: { type: 'string', description: 'Name of the MCP server' },
+                            requestOptions: {
+                                type: 'object',
+                                properties: {
+                                    sessionId: { type: 'string', description: 'Session ID for instance selection' },
+                                    tags: { type: 'object', description: 'Tags for instance selection' }
+                                }
+                            }
+                        },
+                        required: ['serverName']
+                    },
+                    annotations: {
+                        title: 'List Tools in Server',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            case FIND_TOOLS_IN_SERVER_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'Find tools matching a pattern in a specific server',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            serverName: { type: 'string', description: 'Name of the MCP server' },
+                            pattern: { type: 'string', description: 'Regex pattern to search for' },
+                            searchIn: {
+                                type: 'string',
+                                enum: ['name', 'description', 'both'],
+                                default: 'both'
+                            },
+                            caseSensitive: { type: 'boolean', default: false },
+                            requestOptions: {
+                                type: 'object',
+                                properties: {
+                                    sessionId: { type: 'string', description: 'Session ID for instance selection' },
+                                    tags: { type: 'object', description: 'Tags for instance selection' }
+                                }
+                            }
+                        },
+                        required: ['serverName', 'pattern']
+                    },
+                    annotations: {
+                        title: 'Find Tools in Server',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            case GET_TOOL_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'Get complete schema for a specific tool from a specific server',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            serverName: { type: 'string', description: 'Name of the MCP server' },
+                            toolName: { type: 'string', description: 'Exact name of the tool' },
+                            requestOptions: {
+                                type: 'object',
+                                properties: {
+                                    sessionId: { type: 'string', description: 'Session ID for instance selection' },
+                                    tags: { type: 'object', description: 'Tags for instance selection' }
+                                }
+                            }
+                        },
+                        required: ['serverName', 'toolName']
+                    },
+                    annotations: {
+                        title: 'Get Tool Details',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            case CALL_TOOL_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'Call a specific tool from a specific server',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            serverName: { type: 'string', description: 'Name of the MCP server' },
+                            toolName: { type: 'string', description: 'Name of the tool to call' },
+                            toolArgs: { type: 'object', description: 'Arguments to pass to the tool' },
+                            requestOptions: {
+                                type: 'object',
+                                properties: {
+                                    sessionId: { type: 'string', description: 'Session ID for instance selection' },
+                                    tags: { type: 'object', description: 'Tags for instance selection' }
+                                }
+                            }
+                        },
+                        required: ['serverName', 'toolName', 'toolArgs']
+                    },
+                    annotations: {
+                        title: 'Call Tool',
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                        openWorldHint: true
+                    }
+                });
+                break;
+            case FIND_TOOLS_TOOL:
+                systemTools.push({
+                    name: toolName,
+                    description: 'Find tools matching a pattern across all connected servers',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pattern: { type: 'string', description: 'Regex pattern to search for' },
+                            searchIn: {
+                                type: 'string',
+                                enum: ['name', 'description', 'both'],
+                                default: 'both'
+                            },
+                            caseSensitive: { type: 'boolean', default: false }
+                        },
+                        required: ['pattern']
+                    },
+                    annotations: {
+                        title: 'Find Tools',
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                });
+                break;
+            default:
+                // This should never happen due to TypeScript type checking
+                throw new Error(`Unknown system tool: ${toolName}`);
+        }
+    }
+    return systemTools;
+}

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

@@ -0,0 +1,85 @@
+import type { Tool } from '../../../shared/models/tool.model.js';
+import type { RequestOptions } from './types.js';
+/**
+ * Search options for server searches.
+ */
+export interface SearchOptions {
+    searchIn?: 'name' | 'description' | 'both';
+    caseSensitive?: boolean;
+}
+/**
+ * Finds servers matching a specified regex pattern.
+ *
+ * This method searches through all configured servers using the provided regex pattern,
+ * supporting flexible search options including case sensitivity and search scope
+ * (name, description, or both). It returns an array of matching server names.
+ *
+ * @param {string} pattern - Regex pattern to search for in server names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @returns {Promise<string[]>} Array of matching server names
+ *
+ * @example
+ * ```typescript
+ * // Find servers with 'api' in their name (case-insensitive)
+ * const apiServers = await findServers('api');
+ *
+ * // Find servers with exact case match
+ * const exactMatch = await findServers('^MyServer$', 'name', true);
+ * ```
+ */
+export declare function findServers(pattern: string, searchIn?: 'name' | 'description' | 'both', caseSensitive?: boolean): Promise<string[]>;
+/**
+ * Finds tools matching a pattern within a specific MCP server.
+ *
+ * This method searches through all tools available from the specified server using
+ * the provided regex pattern, supporting flexible search options including case
+ * sensitivity and search scope (name, description, or both). It returns matching
+ * tools grouped by server name.
+ *
+ * @param {string} serverName - Name of the MCP server to search tools in
+ * @param {string} pattern - Regex pattern to search for in tool names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and matching tools
+ * @throws {Error} If the specified server is not found or not connected
+ *
+ * @example
+ * ```typescript
+ * const result = await findToolsInServer('my-mcp-server', 'list');
+ * console.log(`Found ${result.tools.length} tools matching 'list'`);
+ * ```
+ */
+export declare function findToolsInServer(serverName: string, pattern: string, searchIn?: 'name' | 'description' | 'both', caseSensitive?: boolean, requestOptions?: RequestOptions): Promise<{
+    serverName: string;
+    tools: Tool[];
+}>;
+/**
+ * Finds tools matching a pattern across all connected MCP servers.
+ *
+ * This method searches through all available tools from all connected servers using the
+ * provided regex pattern, supporting flexible search options including case sensitivity
+ * and search scope (name, description, or both). It returns matching tools grouped by
+ * their originating server names.
+ *
+ * @param {string} pattern - Regex pattern to search for in tool names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @param {() => Promise<Record<string, { tools: Tool[] }>>} listAllToolsFn - Function to list all tools
+ * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to matching tools
+ *
+ * @example
+ * ```typescript
+ * const matchingTools = await findTools('list');
+ * Object.entries(matchingTools).forEach(([serverName, { tools }]) => {
+ *   console.log(`${serverName}: ${tools.length} matching tools`);
+ * });
+ * ```
+ */
+export declare function findTools(pattern: string, searchIn: "name" | "description" | "both" | undefined, caseSensitive: boolean | undefined, listAllToolsFn: () => Promise<Record<string, {
+    tools: Tool[];
+}>>): Promise<Record<string, {
+    tools: Tool[];
+}>>;
+//# sourceMappingURL=tool-search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-search.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/tool-search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAYnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,EAC9B,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC,CAqBD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,YAAS,EAClD,aAAa,EAAE,OAAO,YAAQ,EAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,CAAC,GAC/D,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,CAAC,CAsB5C"}

package/dist/server/src/services/hub-tools/tool-search.js

@@ -0,0 +1,115 @@
+import { hubManager } from '../hub-manager.service.js';
+import { mcpConnectionManager } from '../mcp-connection-manager.js';
+import { hasValidId, selectBestInstance } from './server-selector.js';
+/**
+ * Finds servers matching a specified regex pattern.
+ *
+ * This method searches through all configured servers using the provided regex pattern,
+ * supporting flexible search options including case sensitivity and search scope
+ * (name, description, or both). It returns an array of matching server names.
+ *
+ * @param {string} pattern - Regex pattern to search for in server names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @returns {Promise<string[]>} Array of matching server names
+ *
+ * @example
+ * ```typescript
+ * // Find servers with 'api' in their name (case-insensitive)
+ * const apiServers = await findServers('api');
+ *
+ * // Find servers with exact case match
+ * const exactMatch = await findServers('^MyServer$', 'name', true);
+ * ```
+ */
+export async function findServers(pattern, searchIn = 'both', caseSensitive = false) {
+    const allServers = hubManager.getAllServers();
+    const validServers = allServers.filter(hasValidId);
+    const regex = new RegExp(pattern, caseSensitive ? '' : 'i');
+    return validServers
+        .filter((server) => {
+        const matchName = searchIn !== 'description' && regex.test(server.name);
+        const matchDescription = searchIn !== 'name' && server.name && regex.test(server.name); // Using name as fallback if no description
+        return matchName || matchDescription;
+    })
+        .map((server) => server.name);
+}
+/**
+ * Finds tools matching a pattern within a specific MCP server.
+ *
+ * This method searches through all tools available from the specified server using
+ * the provided regex pattern, supporting flexible search options including case
+ * sensitivity and search scope (name, description, or both). It returns matching
+ * tools grouped by server name.
+ *
+ * @param {string} serverName - Name of the MCP server to search tools in
+ * @param {string} pattern - Regex pattern to search for in tool names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and matching tools
+ * @throws {Error} If the specified server is not found or not connected
+ *
+ * @example
+ * ```typescript
+ * const result = await findToolsInServer('my-mcp-server', 'list');
+ * console.log(`Found ${result.tools.length} tools matching 'list'`);
+ * ```
+ */
+export async function findToolsInServer(serverName, pattern, searchIn = 'both', caseSensitive = false, requestOptions) {
+    const serverInfo = selectBestInstance(serverName, requestOptions);
+    if (!serverInfo) {
+        throw new Error(`Server not found: ${serverName}`);
+    }
+    const tools = mcpConnectionManager.getTools(serverInfo.instance.id);
+    const regex = new RegExp(pattern, caseSensitive ? '' : 'i');
+    const matchingTools = tools.filter((tool) => {
+        const matchName = searchIn !== 'description' && regex.test(tool.name);
+        const matchDescription = searchIn !== 'name' && tool.description && regex.test(tool.description);
+        return matchName || matchDescription;
+    });
+    return {
+        serverName: serverName,
+        tools: matchingTools
+    };
+}
+/**
+ * Finds tools matching a pattern across all connected MCP servers.
+ *
+ * This method searches through all available tools from all connected servers using the
+ * provided regex pattern, supporting flexible search options including case sensitivity
+ * and search scope (name, description, or both). It returns matching tools grouped by
+ * their originating server names.
+ *
+ * @param {string} pattern - Regex pattern to search for in tool names and descriptions
+ * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
+ * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
+ * @param {() => Promise<Record<string, { tools: Tool[] }>>} listAllToolsFn - Function to list all tools
+ * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to matching tools
+ *
+ * @example
+ * ```typescript
+ * const matchingTools = await findTools('list');
+ * Object.entries(matchingTools).forEach(([serverName, { tools }]) => {
+ *   console.log(`${serverName}: ${tools.length} matching tools`);
+ * });
+ * ```
+ */
+export async function findTools(pattern, searchIn = 'both', caseSensitive = false, listAllToolsFn) {
+    const allTools = await listAllToolsFn();
+    const regex = new RegExp(pattern, caseSensitive ? '' : 'i');
+    const matchingTools = {};
+    for (const [serverName, serverData] of Object.entries(allTools)) {
+        const filteredTools = serverData.tools.filter((tool) => {
+            const matchName = searchIn !== 'description' && regex.test(tool.name);
+            const matchDescription = searchIn !== 'name' && tool.description && regex.test(tool.description);
+            return matchName || matchDescription;
+        });
+        if (filteredTools.length > 0) {
+            matchingTools[serverName] = {
+                tools: filteredTools
+            };
+        }
+    }
+    return matchingTools;
+}