@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

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

@@ -1,4 +1,5 @@
 import { configManager } from '../config/config-manager.js';
+import { resolveInstanceConfig } from '../config/config-migrator.js';
 import { logger, LOG_MODULES } from '../utils/logger.js';
 import { mcpConnectionManager } from './mcp-connection-manager.js';
 import { eventBus, EventTypes } from './event-bus.service.js';
@@ -7,19 +8,7 @@ import { eventBus, EventTypes } from './event-bus.service.js';
  *
  * 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');
- * ```
+ * event-driven communication with other system components.
  */
 export class HubManagerService {
     configManager;
@@ -28,25 +17,9 @@ export class HubManagerService {
     }
     /**
      * 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) {
@@ -56,228 +29,121 @@ export class HubManagerService {
     }
     /**
      * 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 instances = this.getServerInstancesByName(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']);
-     * ```
+     * Concurrently connects to multiple server instances.
      */
     async connectServerInstances(serverNames) {
         const connectPromises = serverNames.map(async (name) => {
             const server = this.getServerByName(name);
-            if (server && server.enabled !== false) {
-                const instances = this.getServerInstanceByName(name);
+            if (server) {
+                const instances = this.getServerInstancesByName(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);
+                    if (instance.enabled !== false) {
+                        const resolvedConfig = this.getResolvedServerConfig(name, instance.id);
+                        if (resolvedConfig) {
+                            try {
+                                await mcpConnectionManager.connect(name, instance.index ?? 0, {
+                                    ...resolvedConfig,
+                                    id: instance.id
+                                });
+                            }
+                            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}`);
-     * ```
+     * Retrieves all configured servers.
      */
     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);
+        const servers = this.configManager.getServers();
+        for (const server of servers) {
+            const instance = server.config.instances.find((inst) => inst.id === id);
             if (instance) {
-                const serverConfig = this.configManager.getServerByName(serverName);
-                if (serverConfig) {
-                    return {
-                        name: serverName,
-                        config: serverConfig,
-                        instance
-                    };
-                }
+                return {
+                    name: server.name,
+                    config: server.config,
+                    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}`);
-     * }
-     * ```
+     * Retrieves a server configuration by name.
      */
     getServerByName(name) {
         return this.configManager.getServerByName(name);
     }
+    /**
+     * Retrieves all instances for a specific server by name.
+     */
+    getServerInstancesByName(name) {
+        return this.configManager.getServerInstancesByName(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();
+        const servers = this.getAllServers();
+        const instances = {};
+        for (const server of servers) {
+            instances[server.name] = server.config.instances || [];
+        }
+        return instances;
     }
     /**
-     * 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`);
-     * ```
+     * Gets the resolved server configuration by merging template and instance.
      */
-    getServerInstanceByName(name) {
-        return this.configManager.getServerInstanceByName(name);
+    getResolvedServerConfig(name, instanceId) {
+        const serverConfig = this.getServerByName(name);
+        if (!serverConfig) {
+            return null;
+        }
+        return resolveInstanceConfig(serverConfig, instanceId);
     }
     /**
      * 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');
-     * ```
+     * Adds a new instance to an existing server.
      */
     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) {
+        const resolvedConfig = this.getResolvedServerConfig(name, newInstance.id);
+        if (resolvedConfig && resolvedConfig.enabled !== false) {
             try {
-                await mcpConnectionManager.connect({ ...server, ...newInstance });
+                await mcpConnectionManager.connect(name, newInstance.index ?? 0, {
+                    ...resolvedConfig,
+                    id: newInstance.id
+                });
             }
             catch (error) {
                 logger.error(`Failed to auto-connect server instance for ${name}:`, error, LOG_MODULES.HUB_MANAGER);
@@ -287,25 +153,7 @@ export class HubManagerService {
         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');
-     * }
-     * ```
+     * Updates an existing server template configuration.
      */
     async updateServer(name, updates) {
         const existing = this.getServerByName(name);
@@ -322,25 +170,7 @@ export class HubManagerService {
         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');
-     * ```
+     * Updates a specific server instance.
      */
     async updateServerInstance(name, index, updates) {
         await this.configManager.updateServerInstance(name, index, updates);
@@ -348,32 +178,16 @@ export class HubManagerService {
         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');
-     * }
-     * ```
+     * Removes a server and all its instances.
      */
     async removeServer(name) {
         const existing = this.getServerByName(name);
         if (!existing) {
             return false;
         }
-        // Disconnect all instances of this server
-        const instances = this.getServerInstanceByName(name);
+        const instances = this.getServerInstancesByName(name);
         for (const instance of instances) {
-            await mcpConnectionManager.disconnect(instance.id).catch(() => { });
+            await mcpConnectionManager.disconnect(name, instance.index ?? 0).catch(() => { });
         }
         await this.configManager.removeServer(name);
         logger.info(`Server removed: ${name}`, LOG_MODULES.HUB_MANAGER);
@@ -381,33 +195,41 @@ export class HubManagerService {
         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');
-     * ```
+     * Removes a specific server instance.
      */
     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(() => { });
+        const instances = this.getServerInstancesByName(name);
+        const instance = instances.find((inst) => inst.index === index);
+        if (instance) {
+            await mcpConnectionManager.disconnect(name, instance.index ?? 0).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 });
     }
+    /**
+     * Reassigns server instance indexes.
+     */
+    async reassignInstanceIndexes(name) {
+        return this.configManager.reassignInstanceIndexes(name);
+    }
+    /**
+     * Updates the instance selection strategy for a server.
+     */
+    async updateServerInstanceSelectionStrategy(name, strategy) {
+        const existing = this.getServerByName(name);
+        if (!existing) {
+            logger.warn(`Attempted to update instance selection strategy for non-existent server: ${name}`, LOG_MODULES.HUB_MANAGER);
+            return null;
+        }
+        // Update strategy in template instead of server-level configuration
+        await this.configManager.updateServer(name, { instanceSelectionStrategy: strategy });
+        logger.info(`Server instance selection strategy updated: ${name} -> ${strategy}`, LOG_MODULES.HUB_MANAGER);
+        const updatedServer = this.getServerByName(name) || null;
+        if (updatedServer) {
+            eventBus.publish(EventTypes.SERVER_UPDATED, { name, config: updatedServer });
+        }
+        return updatedServer;
+    }
 }
 export const hubManager = new HubManagerService();

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

@@ -1,10 +1,8 @@
 export { HubToolsService, hubToolsService } from '../hub-tools.service.js';
 export type { RequestOptions, ServerInstanceInfo, ValidServer } from './types.js';
-export { hasValidId, selectBestInstance } from './server-selector.js';
+export { hasValidId, selectBestInstance, getServerDescription } 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

@@ -1 +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"}
+{"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,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAC1F,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

@@ -1,6 +1,5 @@
 // Re-export the original service for backward compatibility
 export { HubToolsService, hubToolsService } from '../hub-tools.service.js';
-export { hasValidId, selectBestInstance } from './server-selector.js';
+export { hasValidId, selectBestInstance, getServerDescription } 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/instance-matcher.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Instance Matcher Service
+ * Provides intelligent instance selection based on tags and connection status.
+ */
+/**
+ * Minimal instance interface for matching - works with any instance type that has an id.
+ */
+export interface MatchableInstance {
+    id: string;
+    enabled?: boolean;
+    tags?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Extended service instance with connection status for matching.
+ */
+export interface InstanceWithStatus extends MatchableInstance {
+    connected?: boolean;
+}
+/**
+ * Calculates the match score between an instance and requested tags.
+ *
+ * The score ranges from 0.0 (no match) to 1.0 (perfect match).
+ * Calculated as the ratio of matching tags to total requested tags.
+ *
+ * @param instance - The service instance to evaluate
+ * @param requestedTags - The tags to match against
+ * @returns Match score between 0.0 and 1.0
+ */
+export declare function calculateMatchScore(instance: MatchableInstance, requestedTags: Record<string, string> | undefined): number;
+/**
+ * Filters instances to only include enabled ones.
+ *
+ * @param instances - Array of instances to filter
+ * @returns Array of enabled instances
+ */
+export declare function filterEnabledInstances<T extends MatchableInstance>(instances: T[]): T[];
+/**
+ * Sorts instances by connection status (connected first).
+ *
+ * Preserves the original order within each status group.
+ *
+ * @param instances - Array of instances with connection status
+ * @returns Sorted array with connected instances first
+ */
+export declare function sortByConnectionStatus<T extends InstanceWithStatus>(instances: T[]): T[];
+/**
+ * Selects the best matching instance based on tags and connection status.
+ *
+ * Selection priority:
+ * 1. Only consider enabled instances
+ * 2. Prioritize connected instances over disconnected ones (ALWAYS prefer connected if available)
+ * 3. Among connected instances, select the one with highest tag match score
+ * 4. Among disconnected instances, select the one with highest tag match score
+ * 5. Only return undefined if NO connected instances AND tags requested but no match
+ *
+ * @param instances - Array of instances to choose from
+ * @param requestedTags - Optional tags to match
+ * @returns The best matching instance, or undefined if no suitable instance found
+ */
+export declare function selectBestMatch<T extends InstanceWithStatus>(instances: T[], requestedTags: Record<string, string> | undefined): T | undefined;
+//# sourceMappingURL=instance-matcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-matcher.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/instance-matcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAChD,MAAM,CAsBR;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,iBAAiB,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAEvF;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,kBAAkB,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAaxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,kBAAkB,EAC1D,SAAS,EAAE,CAAC,EAAE,EACd,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAChD,CAAC,GAAG,SAAS,CAiCf"}