@toolprint/hypertool-mcp/dist/persona/mcp-integration.d.ts

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

/**
 * PersonaMcpIntegration Implementation
 *
 * This module implements integration with the MCP configuration system to apply
 * persona-specific server configurations. When a persona is activated, its MCP
 * configuration is merged with the existing MCP configuration, and when deactivated,
 * the original configuration is restored.
 *
 * @fileoverview MCP configuration integration for persona content pack system
 */
import type { MCPConfig, ServerEntry } from "../types/config.js";
import type { PersonaAssets } from "./types.js";
/**
 * MCP configuration backup for restoration
 */
export interface McpConfigBackup {
    /** Original MCP configuration */
    originalConfig: MCPConfig;
    /** Backup timestamp */
    backupTimestamp: Date;
    /** Source of the backup (e.g., "file", "database") */
    source: string;
    /** Original config file path if applicable */
    originalConfigPath?: string;
    /** Additional metadata */
    metadata?: Record<string, any>;
}
/**
 * Configuration merge options
 */
export interface McpConfigMergeOptions {
    /** How to resolve server name conflicts */
    conflictResolution: "persona-wins" | "base-wins" | "user-choice" | "error";
    /** Whether to preserve environment variables from base config */
    preserveBaseEnv?: boolean;
    /** Whether to merge environment variables or replace them */
    mergeEnvironment?: boolean;
    /** Custom conflict resolver function */
    customResolver?: (serverName: string, baseServer: ServerEntry, personaServer: ServerEntry) => ServerEntry | null;
}
/**
 * Configuration merge result
 */
export interface McpConfigMergeResult {
    /** Whether merge was successful */
    success: boolean;
    /** Merged configuration */
    mergedConfig?: MCPConfig;
    /** List of conflicts encountered */
    conflicts: string[];
    /** Warnings during merge */
    warnings: string[];
    /** Errors during merge */
    errors: string[];
    /** Statistics about the merge */
    stats: {
        baseServersCount: number;
        personaServersCount: number;
        mergedServersCount: number;
        conflictsResolved: number;
    };
}
/**
 * PersonaMcpIntegration class for handling MCP config operations
 *
 * Provides functionality to merge persona MCP configurations with existing
 * configurations, handle conflicts, backup and restore configurations, and
 * manage server connections during persona activation/deactivation.
 */
export declare class PersonaMcpIntegration {
    private readonly getCurrentConfig;
    private readonly setCurrentConfig;
    private readonly restartConnections?;
    private currentBackup;
    private readonly parser;
    private readonly defaultMergeOptions;
    constructor(getCurrentConfig: () => Promise<MCPConfig | null>, setCurrentConfig: (config: MCPConfig) => Promise<void>, restartConnections?: (() => Promise<void>) | undefined, mergeOptions?: Partial<McpConfigMergeOptions>);
    /**
     * Apply persona MCP configuration
     *
     * Loads the persona's MCP configuration, merges it with the current configuration,
     * and applies the result. Creates a backup for later restoration.
     *
     * @param mcpConfigFile - Path to persona's mcp.json file
     * @param options - Merge options
     * @returns Promise resolving to merge result
     */
    applyPersonaConfig(mcpConfigFile: string, options?: Partial<McpConfigMergeOptions>): Promise<McpConfigMergeResult>;
    /**
     * Restore original MCP configuration
     *
     * Restores the configuration that was backed up before persona activation.
     *
     * @returns Promise resolving when restoration is complete
     */
    restoreOriginalConfig(): Promise<void>;
    /**
     * Check if there's a backup available for restoration
     */
    hasBackup(): boolean;
    /**
     * Get backup information
     */
    getBackupInfo(): McpConfigBackup | null;
    /**
     * Load persona MCP configuration from file
     */
    private loadPersonaMcpConfig;
    /**
     * Create backup of current configuration
     */
    private createConfigBackup;
    /**
     * Merge base and persona MCP configurations
     */
    private mergeConfigurations;
    /**
     * Merge two server configurations
     */
    private mergeServerConfigs;
    /**
     * Generate a simple hash of the configuration for tracking changes
     */
    private generateConfigHash;
    /**
     * Validate MCP configuration format
     */
    static validateMcpConfig(config: unknown): config is MCPConfig;
    /**
     * Create a PersonaMcpIntegration instance for personas that don't have MCP configs
     */
    static createNullIntegration(): PersonaMcpIntegration;
    /**
     * Dispose of the integration and clean up resources
     */
    dispose(): void;
}
/**
 * Create a PersonaMcpIntegration instance with default configuration handlers
 */
export declare function createPersonaMcpIntegration(getCurrentConfig: () => Promise<MCPConfig | null>, setCurrentConfig: (config: MCPConfig) => Promise<void>, restartConnections?: () => Promise<void>, mergeOptions?: Partial<McpConfigMergeOptions>): PersonaMcpIntegration;
/**
 * Helper function to check if persona assets include MCP configuration
 */
export declare function personaHasMcpConfig(assets: PersonaAssets): boolean;
/**
 * Helper function to validate persona MCP config file exists and is readable
 */
export declare function validatePersonaMcpConfigFile(filePath: string): Promise<{
    isValid: boolean;
    error?: string;
}>;
//# sourceMappingURL=mcp-integration.d.ts.map