@toolprint/hypertool-mcp/dist/connection/extensionFactory.js

HyperTool MCP proxy server for routing requests between clients and multiple underlying MCP servers

/**
 * Enhanced Connection Factory with Extension Support
 * Integrates the new extension system with the existing connection factory
 */
import { ConnectionFactory } from "./factory.js";
/**
 * Enhanced connection factory that supports both regular MCP servers and extensions
 */
export class ExtensionAwareConnectionFactory {
    baseFactory;
    extensionManager;
    constructor() {
        this.baseFactory = new ConnectionFactory();
    }
    /**
     * Set the extension manager for extension support
     */
    setExtensionManager(extensionManager) {
        this.extensionManager = extensionManager;
    }
    /**
     * Create a connection that may come from extensions or regular config
     */
    createConnection(serverName, config, options = {}) {
        // If this is a regular MCP server config, use the base factory
        if (this.baseFactory.isConfigSupported(config)) {
            return this.baseFactory.createConnection(serverName, config, options);
        }
        // If we have an extension manager, check if this is an extension
        if (this.extensionManager) {
            const extensionConfig = this.extensionManager.getExtensionConfig(serverName);
            if (extensionConfig && extensionConfig.enabled) {
                // Convert extension to server config and create connection
                const serverConfig = this.extensionManager.createServerConfigForExtension(serverName);
                return this.baseFactory.createConnection(serverName, serverConfig, options);
            }
        }
        throw new Error(`Unsupported server configuration or extension not found: ${serverName}`);
    }
    /**
     * Get all available server configurations (MCP servers + enabled extensions)
     */
    async getAllServerConfigs() {
        const configs = {};
        // Add enabled extensions as server configs
        if (this.extensionManager) {
            const extensionConfigs = this.extensionManager.getEnabledExtensionsAsServerConfigs();
            Object.assign(configs, extensionConfigs);
        }
        return configs;
    }
    /**
     * Check if a server name is available (either as extension or regular config)
     */
    async isServerAvailable(serverName) {
        // Check if it's an enabled extension
        if (this.extensionManager) {
            const extensionConfig = this.extensionManager.getExtensionConfig(serverName);
            if (extensionConfig && extensionConfig.enabled) {
                return true;
            }
        }
        return false;
    }
    /**
     * List all available server names (extensions + regular servers)
     */
    async listAvailableServers() {
        const servers = [];
        // Add enabled extensions
        if (this.extensionManager) {
            const enabledExtensions = this.extensionManager.getEnabledConfigs();
            servers.push(...enabledExtensions.map((ext) => ext.name));
        }
        return servers;
    }
    /**
     * Get server information including type and status
     */
    async getServerInfo(serverName) {
        // Check if it's an extension
        if (this.extensionManager) {
            const extensionConfig = this.extensionManager.getExtensionConfig(serverName);
            if (extensionConfig) {
                return {
                    name: serverName,
                    type: "extension",
                    enabled: extensionConfig.enabled,
                    valid: extensionConfig.validationResult.isValid,
                    version: extensionConfig.manifest.version,
                    description: extensionConfig.manifest.description,
                    errors: extensionConfig.validationResult.errors,
                    warnings: extensionConfig.validationResult.warnings,
                };
            }
        }
        return undefined;
    }
    /**
     * Refresh all extensions and reload configurations
     */
    async refresh() {
        if (this.extensionManager) {
            await this.extensionManager.refreshExtensions();
        }
    }
    /**
     * Delegate to base factory for regular operations
     */
    createStdioConnection(serverName, config, options = {}) {
        return this.baseFactory.createStdioConnection(serverName, config, options);
    }
    createHttpConnection(serverName, config, options = {}) {
        return this.baseFactory.createHttpConnection(serverName, config, options);
    }
    createSSEConnection(serverName, config, options = {}) {
        return this.baseFactory.createSSEConnection(serverName, config, options);
    }
    isConfigSupported(config) {
        return this.baseFactory.isConfigSupported(config);
    }
    getSupportedTransports() {
        return this.baseFactory.getSupportedTransports();
    }
}
//# sourceMappingURL=extensionFactory.js.map