@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/config/config-loader.js

@@ -0,0 +1,66 @@
+/**
+ * Configuration loading utilities.
+ * Handles loading and parsing configuration from files with validation.
+ */
+import * as fs from 'fs';
+import { logger, LOG_MODULES } from '../utils/logger.js';
+import { SystemConfigSchema } from './config.schema.js';
+import { convertHttpToStreamableHttp } from './type-converter.js';
+/**
+ * Loads configuration from the specified file path.
+ *
+ * This function handles the complete configuration loading process:
+ * - Checks if the config file exists at the specified path
+ * - Reads and parses the JSON configuration
+ * - Performs type conversion for compatibility (e.g., 'http' to 'streamable-http')
+ * - Validates the configuration using Zod schema
+ * - Handles validation failures gracefully by falling back to default configuration
+ *
+ * If the config file doesn't exist or fails to load, a default configuration is returned.
+ *
+ * @param configPath - Path to the configuration file
+ * @returns The loaded and validated system configuration
+ */
+export function loadConfig(configPath) {
+    try {
+        if (fs.existsSync(configPath)) {
+            logger.info(`Loading configuration from: ${configPath}`, LOG_MODULES.CONFIG_MANAGER);
+            const content = fs.readFileSync(configPath, 'utf-8');
+            let config = JSON.parse(content);
+            // Unified type conversion: convert http to streamable-http
+            config = convertHttpToStreamableHttp(config);
+            // Ensure defaults without validation errors blocking
+            try {
+                // Use safeParse to validate configuration
+                const parsed = SystemConfigSchema.safeParse(config);
+                if (parsed.success) {
+                    // Ensure server configurations are sorted by name
+                    const configWithSortedServers = {
+                        ...parsed.data,
+                        servers: Object.fromEntries(Object.entries(parsed.data.servers).sort(([a], [b]) => a.localeCompare(b)))
+                    };
+                    return configWithSortedServers;
+                }
+                else {
+                    // On validation failure, log error and use default configuration
+                    logger.error(`Config validation failed: ${parsed.error}`);
+                    return SystemConfigSchema.parse({});
+                }
+            }
+            catch (e) {
+                logger.error(`Failed to parse config: ${e}`);
+                // On parsing failure, use default configuration
+                return SystemConfigSchema.parse({});
+            }
+        }
+        else {
+            // When config file doesn't exist, create default config in memory only
+            return SystemConfigSchema.parse({});
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to load config: ${error}`);
+        // On config file load failure, use default configuration
+        return SystemConfigSchema.parse({});
+    }
+}

package/dist/server/src/config/config-manager.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Configuration Manager for MCP Hub Lite system.
+ *
+ * This class provides comprehensive configuration management capabilities including:
+ * - Loading and parsing configuration from JSON files
+ * - Runtime configuration updates with validation
+ * - Server and server instance lifecycle management
+ * - Automatic configuration persistence to disk
+ * - Type conversion and compatibility handling (e.g., 'http' to 'streamable-http')
+ * - Configuration change logging and tracking
+ *
+ * This is a thin wrapper around modular utilities for better maintainability.
+ *
+ * @example
+ * ```typescript
+ * // Get the config manager instance
+ * const configManager = getConfigManager();
+ *
+ * // Get all servers
+ * const servers = configManager.getServers();
+ *
+ * // Add a new server
+ * await configManager.addServer('my-server', {
+ *   type: 'stdio',
+ *   command: 'npx my-mcp-server',
+ *   enabled: true
+ * });
+ * ```
+ */
+import { SystemConfigSchema, ServerConfigSchema, ServerInstanceConfigSchema } from './config.schema.js';
+import type { ServerConfig, SystemConfig, ServerInstanceConfig } from './config.schema.js';
+export { ServerConfig, SystemConfig, ServerInstanceConfig, SystemConfigSchema, ServerConfigSchema, ServerInstanceConfigSchema };
+export declare class ConfigManager {
+    private configPath;
+    private config;
+    private serverInstances;
+    constructor(configPath?: string);
+    private initServerInstances;
+    /**
+     * Retrieves the current system configuration.
+     *
+     * @returns A deep copy of the current system configuration
+     */
+    getConfig(): SystemConfig;
+    /**
+     * Retrieves all configured servers with their configurations.
+     *
+     * @param sortByName - Whether to sort servers by name
+     * @returns Array of server objects with name and config
+     */
+    getServers(sortByName?: boolean): Array<{
+        name: string;
+        config: ServerConfig;
+    }>;
+    /**
+     * Retrieves a server configuration by name.
+     *
+     * @param name - The name of the server to retrieve
+     * @returns The server configuration or undefined if not found
+     */
+    getServerByName(name: string): ServerConfig | undefined;
+    /**
+     * Retrieves all server instances grouped by server name.
+     *
+     * @returns Server instances grouped by server name
+     */
+    getServerInstances(): Record<string, ServerInstanceConfig[]>;
+    /**
+     * Retrieves all server instances for a specific server by name.
+     *
+     * @param name - The name of the server to retrieve instances for
+     * @returns Array of server instances, or empty array if none exist
+     */
+    getServerInstanceByName(name: string): ServerInstanceConfig[];
+    /**
+     * Retrieves server information by its unique instance ID.
+     *
+     * @param id - The unique instance ID to search for
+     * @returns Complete server information including name, configuration, and instance details
+     */
+    getServerById(id: string): {
+        name: string;
+        config: ServerConfig;
+        instance: ServerInstanceConfig;
+    } | undefined;
+    /**
+     * Adds multiple server configurations to the system in a single operation.
+     *
+     * @param servers - Array of server objects containing name and partial configuration
+     */
+    addServers(servers: Array<{
+        name: string;
+        config: Partial<ServerConfig>;
+    }>): Promise<void>;
+    /**
+     * Adds a new server configuration to the system.
+     *
+     * @param name - The unique name for the server
+     * @param config - The server configuration
+     * @returns The validated and complete server configuration
+     */
+    addServer(name: string, config: Partial<ServerConfig>): Promise<ServerConfig>;
+    /**
+     * Adds a new server instance for the specified server.
+     *
+     * @param name - The name of the server to add an instance for
+     * @param instance - The server instance configuration
+     * @returns The validated and complete server instance configuration
+     */
+    addServerInstance(name: string, instance: Partial<ServerInstanceConfig>): Promise<ServerInstanceConfig>;
+    /**
+     * Updates an existing server configuration with the provided changes.
+     *
+     * @param name - The name of the server to update
+     * @param updates - The partial configuration updates to apply
+     */
+    updateServer(name: string, updates: Partial<ServerConfig>): Promise<void>;
+    /**
+     * Updates an existing server instance configuration with the provided changes.
+     *
+     * @param name - The name of the server containing the instance to update
+     * @param index - The index of the instance to update in the instances array
+     * @param updates - The partial instance configuration updates to apply
+     */
+    updateServerInstance(name: string, index: number, updates: Partial<ServerInstanceConfig>): Promise<void>;
+    /**
+     * Removes a server configuration and all its instances from the system.
+     *
+     * @param name - The name of the server to remove
+     * @returns True if the server was removed, false if it didn't exist
+     */
+    removeServer(name: string): Promise<void>;
+    /**
+     * Removes a specific server instance from the system.
+     *
+     * @param name - The name of the server containing the instance to remove
+     * @param index - The index of the instance to remove from the instances array
+     */
+    removeServerInstance(name: string, index: number): Promise<void>;
+    /**
+     * Updates the entire system configuration with the provided partial configuration.
+     *
+     * @param newConfig - Partial system configuration containing updates
+     */
+    updateConfig(newConfig: Partial<SystemConfig>): Promise<void>;
+    private persistConfig;
+    /**
+     * Synchronizes the in-memory configuration with the on-disk configuration file.
+     */
+    syncConfig(): Promise<void>;
+}
+/**
+ * Get the config manager instance
+ * In test environment, always creates a new instance to prevent test pollution
+ */
+export declare function getConfigManager(): ConfigManager;
+export declare const configManager: ConfigManager;
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/server/src/config/config-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-manager.d.ts","sourceRoot":"","sources":["../../../../src/config/config-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAgB3F,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,EAC3B,CAAC;AAEF,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,eAAe,CAA8C;gBAEzD,UAAU,CAAC,EAAE,MAAM;IAU/B,OAAO,CAAC,mBAAmB;IAW3B;;;;OAIG;IACI,SAAS,IAAI,YAAY;IAIhC;;;;;OAKG;IACI,UAAU,CAAC,UAAU,GAAE,OAAe,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;IAW7F;;;;;OAKG;IACI,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI9D;;;;OAIG;IACI,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAInE;;;;;OAKG;IACI,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,EAAE;IAIpE;;;;;OAKG;IACI,aAAa,CAClB,EAAE,EAAE,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,oBAAoB,CAAA;KAAE,GAAG,SAAS;IAUrF;;;;OAIG;IACU,UAAU,CACrB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;KAAE,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC;IAKhB;;;;;;OAMG;IACU,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IAM1F;;;;;;OAMG;IACU,iBAAiB,CAC5B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACtC,OAAO,CAAC,oBAAoB,CAAC;IAIhC;;;;;OAKG;IACU,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtF;;;;;;OAMG;IACU,oBAAoB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACrC,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;OAKG;IACU,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD;;;;;OAKG;IACU,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7E;;;;OAIG;IACU,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ1E,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAIzC;AAKD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAchD;AAGD,eAAO,MAAM,aAAa,eAAqB,CAAC"}

package/dist/server/src/config/config-manager.js

@@ -0,0 +1,246 @@
+/**
+ * Configuration Manager for MCP Hub Lite system.
+ *
+ * This class provides comprehensive configuration management capabilities including:
+ * - Loading and parsing configuration from JSON files
+ * - Runtime configuration updates with validation
+ * - Server and server instance lifecycle management
+ * - Automatic configuration persistence to disk
+ * - Type conversion and compatibility handling (e.g., 'http' to 'streamable-http')
+ * - Configuration change logging and tracking
+ *
+ * This is a thin wrapper around modular utilities for better maintainability.
+ *
+ * @example
+ * ```typescript
+ * // Get the config manager instance
+ * const configManager = getConfigManager();
+ *
+ * // Get all servers
+ * const servers = configManager.getServers();
+ *
+ * // Add a new server
+ * await configManager.addServer('my-server', {
+ *   type: 'stdio',
+ *   command: 'npx my-mcp-server',
+ *   enabled: true
+ * });
+ * ```
+ */
+import path from 'path';
+import os from 'os';
+import { logger, LOG_MODULES } from '../utils/logger.js';
+import { SystemConfigSchema, ServerConfigSchema, ServerInstanceConfigSchema } from './config.schema.js';
+import { loadConfig } from './config-loader.js';
+import { saveConfig } from './config-saver.js';
+import { convertHttpToStreamableHttp } from './type-converter.js';
+import { logConfigChanges } from './config-change-logger.js';
+import { addServers, addServer, addServerInstance, updateServer, updateServerInstance, removeServer, removeServerInstance } from './server-config-manager.js';
+// Re-export types for external use
+export { SystemConfigSchema, ServerConfigSchema, ServerInstanceConfigSchema };
+export class ConfigManager {
+    configPath;
+    config;
+    serverInstances = {};
+    constructor(configPath) {
+        this.configPath =
+            configPath ||
+                process.env.MCP_HUB_CONFIG_PATH ||
+                path.join(os.homedir(), '.mcp-hub-lite', 'config', '.mcp-hub.json');
+        logger.info(`Using config file: ${this.configPath}`, LOG_MODULES.CONFIG_MANAGER);
+        this.config = loadConfig(this.configPath);
+        this.initServerInstances();
+    }
+    initServerInstances() {
+        // Init server instances
+        if (this.config && this.config.servers && typeof this.config.servers === 'object') {
+            Object.keys(this.config.servers).forEach((name) => {
+                if (!this.serverInstances[name])
+                    this.serverInstances[name] = [];
+            });
+        }
+        else if (!this.config) {
+            this.config = SystemConfigSchema.parse({});
+        }
+    }
+    /**
+     * Retrieves the current system configuration.
+     *
+     * @returns A deep copy of the current system configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Retrieves all configured servers with their configurations.
+     *
+     * @param sortByName - Whether to sort servers by name
+     * @returns Array of server objects with name and config
+     */
+    getServers(sortByName = false) {
+        let servers = Object.entries(this.config.servers || {}).map(([name, config]) => ({
+            name,
+            config
+        }));
+        if (sortByName) {
+            servers = [...servers].sort((a, b) => a.name.localeCompare(b.name));
+        }
+        return servers;
+    }
+    /**
+     * Retrieves a server configuration by name.
+     *
+     * @param name - The name of the server to retrieve
+     * @returns The server configuration or undefined if not found
+     */
+    getServerByName(name) {
+        return this.config.servers?.[name];
+    }
+    /**
+     * Retrieves all server instances grouped by server name.
+     *
+     * @returns Server instances grouped by server name
+     */
+    getServerInstances() {
+        return { ...this.serverInstances };
+    }
+    /**
+     * Retrieves all server instances for a specific server by name.
+     *
+     * @param name - The name of the server to retrieve instances for
+     * @returns Array of server instances, or empty array if none exist
+     */
+    getServerInstanceByName(name) {
+        return this.serverInstances[name] || [];
+    }
+    /**
+     * Retrieves server information by its unique instance ID.
+     *
+     * @param id - The unique instance ID to search for
+     * @returns Complete server information including name, configuration, and instance details
+     */
+    getServerById(id) {
+        for (const [serverName, instances] of Object.entries(this.serverInstances)) {
+            const instance = instances.find((inst) => inst.id === id);
+            if (instance) {
+                return { name: serverName, config: this.config.servers[serverName], instance };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Adds multiple server configurations to the system in a single operation.
+     *
+     * @param servers - Array of server objects containing name and partial configuration
+     */
+    async addServers(servers) {
+        this.config.servers = addServers(servers, this.config.servers, this.serverInstances);
+        this.persistConfig();
+    }
+    /**
+     * Adds a new server configuration to the system.
+     *
+     * @param name - The unique name for the server
+     * @param config - The server configuration
+     * @returns The validated and complete server configuration
+     */
+    async addServer(name, config) {
+        const validated = addServer(name, config, this.config.servers, this.serverInstances);
+        this.persistConfig();
+        return validated;
+    }
+    /**
+     * Adds a new server instance for the specified server.
+     *
+     * @param name - The name of the server to add an instance for
+     * @param instance - The server instance configuration
+     * @returns The validated and complete server instance configuration
+     */
+    async addServerInstance(name, instance) {
+        return addServerInstance(name, instance, this.serverInstances);
+    }
+    /**
+     * Updates an existing server configuration with the provided changes.
+     *
+     * @param name - The name of the server to update
+     * @param updates - The partial configuration updates to apply
+     */
+    async updateServer(name, updates) {
+        if (updateServer(name, updates, this.config.servers)) {
+            this.persistConfig();
+        }
+    }
+    /**
+     * Updates an existing server instance configuration with the provided changes.
+     *
+     * @param name - The name of the server containing the instance to update
+     * @param index - The index of the instance to update in the instances array
+     * @param updates - The partial instance configuration updates to apply
+     */
+    async updateServerInstance(name, index, updates) {
+        updateServerInstance(name, index, updates, this.serverInstances);
+    }
+    /**
+     * Removes a server configuration and all its instances from the system.
+     *
+     * @param name - The name of the server to remove
+     * @returns True if the server was removed, false if it didn't exist
+     */
+    async removeServer(name) {
+        if (removeServer(name, this.config.servers, this.serverInstances)) {
+            this.persistConfig();
+        }
+    }
+    /**
+     * Removes a specific server instance from the system.
+     *
+     * @param name - The name of the server containing the instance to remove
+     * @param index - The index of the instance to remove from the instances array
+     */
+    async removeServerInstance(name, index) {
+        removeServerInstance(name, index, this.serverInstances);
+    }
+    /**
+     * Updates the entire system configuration with the provided partial configuration.
+     *
+     * @param newConfig - Partial system configuration containing updates
+     */
+    async updateConfig(newConfig) {
+        const oldConfig = JSON.parse(JSON.stringify(this.config));
+        const convertedConfig = convertHttpToStreamableHttp(newConfig);
+        this.config = SystemConfigSchema.parse({ ...this.config, ...convertedConfig });
+        logConfigChanges(oldConfig, this.config);
+        this.persistConfig();
+    }
+    persistConfig() {
+        saveConfig(this.configPath, this.config);
+    }
+    /**
+     * Synchronizes the in-memory configuration with the on-disk configuration file.
+     */
+    async syncConfig() {
+        this.config = loadConfig(this.configPath);
+        this.initServerInstances();
+    }
+}
+// Lazy initialization of configManager to avoid creating instance during module import
+let _configManager = null;
+/**
+ * Get the config manager instance
+ * In test environment, always creates a new instance to prevent test pollution
+ */
+export function getConfigManager() {
+    // In test environment, always create a new instance to ensure test isolation
+    if (process.env.VITEST === 'true' || process.env.NODE_ENV === 'test') {
+        const testConfigPath = process.env.MCP_HUB_CONFIG_PATH ||
+            path.join(os.tmpdir(), `mcp-hub-test-fallback-${Date.now()}`, '.mcp-hub.json');
+        return new ConfigManager(testConfigPath);
+    }
+    // In production, use singleton pattern
+    if (!_configManager) {
+        _configManager = new ConfigManager();
+    }
+    return _configManager;
+}
+// Export the getter function directly
+export const configManager = getConfigManager();

package/dist/server/src/config/config-saver.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Configuration saving utilities.
+ * Handles persisting configuration to disk with proper directory creation.
+ */
+/**
+ * Saves the configuration to disk at the specified path.
+ *
+ * This function writes the current configuration to the configured file path,
+ * creating the directory structure if it doesn't exist. Errors during the save
+ * operation are silently ignored to prevent crashes during normal operation.
+ *
+ * @param configPath - Path to save the configuration file
+ * @param config - The configuration object to save
+ */
+export declare function saveConfig(configPath: string, config: unknown): void;
+//# sourceMappingURL=config-saver.d.ts.map

package/dist/server/src/config/config-saver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-saver.d.ts","sourceRoot":"","sources":["../../../../src/config/config-saver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAUpE"}

package/dist/server/src/config/config-saver.js

@@ -0,0 +1,28 @@
+/**
+ * Configuration saving utilities.
+ * Handles persisting configuration to disk with proper directory creation.
+ */
+import * as fs from 'fs';
+import path from 'path';
+/**
+ * Saves the configuration to disk at the specified path.
+ *
+ * This function writes the current configuration to the configured file path,
+ * creating the directory structure if it doesn't exist. Errors during the save
+ * operation are silently ignored to prevent crashes during normal operation.
+ *
+ * @param configPath - Path to save the configuration file
+ * @param config - The configuration object to save
+ */
+export function saveConfig(configPath, config) {
+    try {
+        const dir = path.dirname(configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    catch {
+        // Ignore
+    }
+}

package/dist/server/src/config/config.schema.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import type { LogLevel } from '../../shared/types/common.types.js';
+/**
+ * MCP Server Configuration Schema
+ * Simplified schema for MCP-HUB-LITE Lite version
+ */
+export declare const ServerConfigSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodDefault<z.ZodEnum<{
+        stdio: "stdio";
+        sse: "sse";
+        "streamable-http": "streamable-http";
+        http: "http";
+    }>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+    allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ServerInstanceConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    hash: z.ZodString;
+    pid: z.ZodOptional<z.ZodNumber>;
+    startTime: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Logging Configuration Schema
+ */
+export declare const LoggingConfigSchema: z.ZodDefault<z.ZodObject<{
+    level: z.ZodDefault<z.ZodCustom<LogLevel, LogLevel>>;
+    rotationAge: z.ZodDefault<z.ZodString>;
+    jsonPretty: z.ZodDefault<z.ZodBoolean>;
+    mcpCommDebug: z.ZodDefault<z.ZodBoolean>;
+    sessionDebug: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+ * Security Configuration Schema
+ */
+export declare const SecurityConfigSchema: z.ZodDefault<z.ZodObject<{
+    allowedNetworks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxConcurrentConnections: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    idleConnectionTimeout: z.ZodDefault<z.ZodNumber>;
+    sessionTimeout: z.ZodDefault<z.ZodNumber>;
+    sessionFlushInterval: z.ZodDefault<z.ZodNumber>;
+    maxConnections: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+/**
+ * System Configuration Schema
+ */
+export declare const SystemConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    system: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        language: z.ZodDefault<z.ZodEnum<{
+            zh: "zh";
+            en: "en";
+        }>>;
+        theme: z.ZodDefault<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+            system: "system";
+        }>>;
+        logging: z.ZodDefault<z.ZodObject<{
+            level: z.ZodDefault<z.ZodCustom<LogLevel, LogLevel>>;
+            rotationAge: z.ZodDefault<z.ZodString>;
+            jsonPretty: z.ZodDefault<z.ZodBoolean>;
+            mcpCommDebug: z.ZodDefault<z.ZodBoolean>;
+            sessionDebug: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    security: z.ZodDefault<z.ZodObject<{
+        allowedNetworks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        maxConcurrentConnections: z.ZodDefault<z.ZodNumber>;
+        connectionTimeout: z.ZodDefault<z.ZodNumber>;
+        idleConnectionTimeout: z.ZodDefault<z.ZodNumber>;
+        sessionTimeout: z.ZodDefault<z.ZodNumber>;
+        sessionFlushInterval: z.ZodDefault<z.ZodNumber>;
+        maxConnections: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodDefault<z.ZodEnum<{
+            stdio: "stdio";
+            sse: "sse";
+            "streamable-http": "streamable-http";
+            http: "http";
+        }>>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        url: z.ZodOptional<z.ZodString>;
+        allowedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SystemConfig = z.infer<typeof SystemConfigSchema>;
+export type ServerConfig = z.infer<typeof ServerConfigSchema>;
+export type ServerInstanceConfig = z.infer<typeof ServerInstanceConfigSchema>;
+//# sourceMappingURL=config.schema.d.ts.map

package/dist/server/src/config/config.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/config/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D;;;GAGG;AAGH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAW7B,CAAC;AAGH,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;kBAc5B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;kBA0B7B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyB7B,CAAC;AAGH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}