@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

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

@@ -0,0 +1,82 @@
+import type { ServerInstance, SystemConfig } from './config.schema.js';
+import type { ServerRuntimeConfig } from '../../shared/models/server.model.js';
+/**
+ * @deprecated Use ServerRuntimeConfig from @shared-models/server.model instead
+ * Resolved server configuration with template + instance merged
+ */
+export type ResolvedServerConfig = ServerRuntimeConfig;
+/**
+ * Configuration Migration Result
+ */
+export interface MigrationResult {
+    success: boolean;
+    backupPath?: string;
+    migratedConfig?: SystemConfig;
+    error?: string;
+    warnings: string[];
+}
+/**
+ * Configuration Migrator Options
+ */
+export interface MigrationOptions {
+    dryRun?: boolean;
+    createBackup?: boolean;
+    validateAfterMigration?: boolean;
+}
+/**
+ * Main migration function that migrates a configuration from v1.0 to v1.1
+ *
+ * @param configPath Path to the configuration file
+ * @param options Migration options
+ * @returns Migration result with backup path and migrated config
+ */
+export declare function migrateConfig(configPath: string, options?: MigrationOptions): MigrationResult;
+/**
+ * Performs a dry run of the migration without modifying files
+ *
+ * @param configPath Path to the configuration file
+ * @returns Migration result with what would happen
+ */
+export declare function dryRunMigration(configPath: string): MigrationResult;
+/**
+ * Rolls back a migration using a backup file
+ *
+ * @param configPath Path to the current configuration file
+ * @param backupPath Path to the backup file
+ * @returns Success status and any error message
+ */
+export declare function rollbackMigration(configPath: string, backupPath: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Checks the migration status of a configuration file
+ *
+ * @param configPath Path to the configuration file
+ * @returns Status information
+ */
+export declare function checkMigrationStatus(configPath: string): {
+    exists: boolean;
+    version: 'v1' | 'v1.1' | 'unknown';
+    canMigrate: boolean;
+    message: string;
+};
+/**
+ * Resolves a server instance configuration by merging template and instance overrides
+ *
+ * @param serverConfig The server configuration with template and instances
+ * @param instanceId Optional instance ID (uses first enabled instance if not provided)
+ * @returns The resolved server configuration
+ */
+export declare function resolveInstanceConfig(serverConfig: SystemConfig['servers'][string], instanceId?: string): ServerRuntimeConfig | null;
+/**
+ * Gets all enabled instances for a server
+ *
+ * @param serverConfig The server configuration
+ * @returns Array of enabled instances with resolved configs
+ */
+export declare function getEnabledInstances(serverConfig: SystemConfig['servers'][string]): Array<{
+    instance: ServerInstance;
+    resolved: ServerRuntimeConfig;
+}>;
+//# sourceMappingURL=config-migrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-migrator.d.ts","sourceRoot":"","sources":["../../../../src/config/config-migrator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAkB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAG1E;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAyMD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,eAAe,CAwDjG;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAMnE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAyBA;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG;IACxD,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAsCA;AAID;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EAC7C,UAAU,CAAC,EAAE,MAAM,GAClB,mBAAmB,GAAG,IAAI,CA+B5B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GAC5C,KAAK,CAAC;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAapE"}

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

@@ -0,0 +1,348 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { logger, LOG_MODULES } from '../utils/logger.js';
+import { generateInstanceId } from '../utils/instance-id.js';
+import { isLegacyV1Config, SystemConfigSchema } from './config.schema.js';
+import { reassignServerInstanceIndexes } from './server-config-manager.js';
+/**
+ * Default migration options
+ */
+const DEFAULT_OPTIONS = {
+    dryRun: false,
+    createBackup: true,
+    validateAfterMigration: true
+};
+/**
+ * Generates a timestamp for backup files
+ */
+function generateTimestamp() {
+    const now = new Date();
+    return now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+}
+/**
+ * Creates a backup of the configuration file
+ */
+function createBackup(configPath) {
+    try {
+        if (!existsSync(configPath)) {
+            return null;
+        }
+        const timestamp = generateTimestamp();
+        const backupDir = dirname(configPath);
+        const backupPath = join(backupDir, `.mcp-hub.json.backup.${timestamp}`);
+        const content = readFileSync(configPath, 'utf8');
+        writeFileSync(backupPath, content, 'utf8');
+        return backupPath;
+    }
+    catch (error) {
+        logger.warn('Failed to create backup:', LOG_MODULES.CONFIG_MANAGER, error);
+        return null;
+    }
+}
+/**
+ * Converts a legacy v1.0 ServerConfig to a v1.1 ServerTemplate
+ */
+function convertToServerTemplate(v1Config) {
+    return {
+        command: v1Config.command,
+        args: v1Config.args || [],
+        env: v1Config.env || {},
+        headers: v1Config.headers || {},
+        type: v1Config.type || 'stdio',
+        timeout: v1Config.timeout || 60000,
+        url: v1Config.url,
+        aggregatedTools: v1Config.allowedTools || [],
+        description: v1Config.description
+    };
+}
+/**
+ * Converts a legacy v1.0 ServerConfig to a v1.1 ServerInstance
+ */
+function convertToServerInstance(v1Config, serverName) {
+    // Only keep the differences from template (args should be empty since template has full args)
+    const instanceConfig = {
+        args: [],
+        env: v1Config.env || {},
+        headers: v1Config.headers || {},
+        tags: v1Config.tags || {}
+    };
+    return {
+        id: generateInstanceId(serverName, instanceConfig),
+        index: 0, // Set initial index for migrated instances
+        enabled: v1Config.enabled !== false,
+        args: [], // In v1.1, instance args are just the append part
+        env: v1Config.env || {},
+        headers: v1Config.headers || {},
+        tags: v1Config.tags || {}
+        // command and description are removed from instance
+    };
+}
+/**
+ * Converts a legacy v1.0 SystemConfig to a v1.1 SystemConfig
+ */
+function migrateV1ToV1_1(v1Config) {
+    const warnings = [];
+    const servers = {};
+    // Convert each v1 server to a v1.1 server
+    for (const [serverName, serverConfig] of Object.entries(v1Config.servers || {})) {
+        const template = convertToServerTemplate(serverConfig);
+        const instance = convertToServerInstance(serverConfig, serverName);
+        servers[serverName] = {
+            template,
+            instances: [instance],
+            tagDefinitions: []
+        };
+    }
+    // Ensure all server instances have proper indexes
+    for (const serverName of Object.keys(servers)) {
+        reassignServerInstanceIndexes(serverName, servers);
+    }
+    const v1_1Config = {
+        version: '1.1.0',
+        system: v1Config.system,
+        security: v1Config.security,
+        servers,
+        tagDefinitions: []
+    };
+    return { config: v1_1Config, warnings };
+}
+/**
+ * Validates a configuration against the schema
+ */
+function validateConfig(config) {
+    try {
+        SystemConfigSchema.parse(config);
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Loads and parses a configuration file
+ */
+function loadConfigFile(configPath) {
+    if (!existsSync(configPath)) {
+        throw new Error(`Configuration file not found: ${configPath}`);
+    }
+    const content = readFileSync(configPath, 'utf8');
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse configuration file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Saves a configuration file
+ */
+function saveConfigFile(configPath, config) {
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const content = JSON.stringify(config, null, 2);
+    writeFileSync(configPath, content, 'utf8');
+}
+/**
+ * Main migration function that migrates a configuration from v1.0 to v1.1
+ *
+ * @param configPath Path to the configuration file
+ * @param options Migration options
+ * @returns Migration result with backup path and migrated config
+ */
+export function migrateConfig(configPath, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const result = {
+        success: false,
+        warnings: []
+    };
+    try {
+        // Load and validate source config
+        const sourceConfig = loadConfigFile(configPath);
+        // Check if already v1.1
+        if (!isLegacyV1Config(sourceConfig)) {
+            result.success = true;
+            result.warnings.push('Configuration is already in v1.1 format');
+            result.migratedConfig = sourceConfig;
+            return result;
+        }
+        // Create backup if requested
+        let backupPath = null;
+        if (opts.createBackup) {
+            backupPath = createBackup(configPath);
+            if (backupPath) {
+                result.backupPath = backupPath;
+            }
+            else {
+                result.warnings.push('Failed to create backup file');
+            }
+        }
+        // Perform migration
+        const v1Config = sourceConfig;
+        const { config: migratedConfig, warnings } = migrateV1ToV1_1(v1Config);
+        result.warnings.push(...warnings);
+        // Validate migrated config
+        if (opts.validateAfterMigration) {
+            const validation = validateConfig(migratedConfig);
+            if (!validation.valid) {
+                result.error = `Migrated configuration validation failed: ${validation.errors}`;
+                return result;
+            }
+        }
+        // Save if not dry run
+        if (!opts.dryRun) {
+            saveConfigFile(configPath, migratedConfig);
+        }
+        result.success = true;
+        result.migratedConfig = migratedConfig;
+        return result;
+    }
+    catch (error) {
+        result.error = error instanceof Error ? error.message : String(error);
+        return result;
+    }
+}
+/**
+ * Performs a dry run of the migration without modifying files
+ *
+ * @param configPath Path to the configuration file
+ * @returns Migration result with what would happen
+ */
+export function dryRunMigration(configPath) {
+    return migrateConfig(configPath, {
+        dryRun: true,
+        createBackup: false,
+        validateAfterMigration: true
+    });
+}
+/**
+ * Rolls back a migration using a backup file
+ *
+ * @param configPath Path to the current configuration file
+ * @param backupPath Path to the backup file
+ * @returns Success status and any error message
+ */
+export function rollbackMigration(configPath, backupPath) {
+    try {
+        if (!existsSync(backupPath)) {
+            return {
+                success: false,
+                error: `Backup file not found: ${backupPath}`
+            };
+        }
+        const backupContent = readFileSync(backupPath, 'utf8');
+        const dir = dirname(configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(configPath, backupContent, 'utf8');
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Checks the migration status of a configuration file
+ *
+ * @param configPath Path to the configuration file
+ * @returns Status information
+ */
+export function checkMigrationStatus(configPath) {
+    if (!existsSync(configPath)) {
+        return {
+            exists: false,
+            version: 'unknown',
+            canMigrate: false,
+            message: 'Configuration file does not exist'
+        };
+    }
+    try {
+        const config = loadConfigFile(configPath);
+        if (!isLegacyV1Config(config)) {
+            return {
+                exists: true,
+                version: 'v1.1',
+                canMigrate: false,
+                message: 'Configuration is already in v1.1 format'
+            };
+        }
+        return {
+            exists: true,
+            version: 'v1',
+            canMigrate: true,
+            message: 'Configuration is in v1.0 format and can be migrated'
+        };
+    }
+    catch (error) {
+        return {
+            exists: true,
+            version: 'unknown',
+            canMigrate: false,
+            message: `Error reading configuration: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+// ====== v1.1 Configuration Helpers ======
+/**
+ * Resolves a server instance configuration by merging template and instance overrides
+ *
+ * @param serverConfig The server configuration with template and instances
+ * @param instanceId Optional instance ID (uses first enabled instance if not provided)
+ * @returns The resolved server configuration
+ */
+export function resolveInstanceConfig(serverConfig, instanceId) {
+    const { template, instances } = serverConfig;
+    // Find the target instance
+    let targetInstance;
+    if (instanceId) {
+        targetInstance = instances.find((inst) => inst.id === instanceId);
+    }
+    else {
+        // Use first enabled instance
+        targetInstance = instances.find((inst) => inst.enabled !== false);
+    }
+    if (!targetInstance) {
+        return null;
+    }
+    // Merge template with instance overrides
+    return {
+        command: template.command,
+        args: [...(template.args || []), ...(targetInstance.args || [])],
+        env: { ...template.env, ...targetInstance.env },
+        headers: { ...template.headers, ...targetInstance.headers },
+        proxy: targetInstance.proxy || template.proxy,
+        type: template.type,
+        timeout: template.timeout,
+        url: template.url,
+        aggregatedTools: template.aggregatedTools,
+        tags: targetInstance.tags,
+        enabled: targetInstance.enabled !== false,
+        description: template.description
+    };
+}
+/**
+ * Gets all enabled instances for a server
+ *
+ * @param serverConfig The server configuration
+ * @returns Array of enabled instances with resolved configs
+ */
+export function getEnabledInstances(serverConfig) {
+    const result = [];
+    for (const instance of serverConfig.instances) {
+        if (instance.enabled !== false) {
+            const resolved = resolveInstanceConfig(serverConfig, instance.id);
+            if (resolved) {
+                result.push({ instance, resolved });
+            }
+        }
+    }
+    return result;
+}

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

@@ -9,6 +9,8 @@
  * creating the directory structure if it doesn't exist. Errors during the save
  * operation are silently ignored to prevent crashes during normal operation.
  *
+ * All empty values and empty objects are preserved as-is in the output.
+ *
  * @param configPath - Path to save the configuration file
  * @param config - The configuration object to save
  */

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

@@ -1 +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"}
+{"version":3,"file":"config-saver.d.ts","sourceRoot":"","sources":["../../../../src/config/config-saver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAYpE"}

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

@@ -4,6 +4,8 @@
  */
 import * as fs from 'fs';
 import path from 'path';
+import { logger } from '../utils/logger.js';
+import { LOG_MODULES } from '../utils/logger/log-modules.js';
 /**
  * Saves the configuration to disk at the specified path.
  *
@@ -11,18 +13,22 @@ import path from 'path';
  * creating the directory structure if it doesn't exist. Errors during the save
  * operation are silently ignored to prevent crashes during normal operation.
  *
+ * All empty values and empty objects are preserved as-is in the output.
+ *
  * @param configPath - Path to save the configuration file
  * @param config - The configuration object to save
  */
 export function saveConfig(configPath, config) {
     try {
+        logger.debug(`Saving configuration to: ${configPath}`, LOG_MODULES.CONFIG_SAVER);
         const dir = path.dirname(configPath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        logger.debug(`Configuration saved successfully`, LOG_MODULES.CONFIG_SAVER);
     }
-    catch {
-        // Ignore
+    catch (error) {
+        logger.error(`Failed to save configuration:`, error, LOG_MODULES.CONFIG_SAVER);
     }
 }

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

@@ -1,108 +1,16 @@
-import { z } from 'zod';
-import type { LogLevel } from '../../shared/types/common.types.js';
+import { TransportType, TagDefinitionSchema, ServerInstanceSchema, ServerInstanceUpdateSchema, ServerTemplateSchema, ServerConfigSchema, LoggingConfigSchema, SecurityConfigSchema, SystemConfigSchema, ServerInstanceConfigSchema, type SystemConfig, type ServerConfig, type ServerTemplate, type ServerInstance, type ServerInstanceUpdate, type TagDefinition, type ServerInstanceConfig, type ServerRuntimeConfig } from '../../shared/models/server.model.js';
 /**
  * MCP Server Configuration Schema
- * Simplified schema for MCP-HUB-LITE Lite version
+ * Simplified v1.1 only - No v1.0 compatibility
+ *
+ * Note: All core schemas are now defined in @shared-models/server.model.ts
+ * This file re-exports them for backward compatibility and retains
+ * TransportType constants and legacy helper functions.
  */
-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>;
+export { TransportType, TagDefinitionSchema, ServerInstanceSchema, ServerInstanceUpdateSchema, ServerTemplateSchema, ServerConfigSchema, LoggingConfigSchema, SecurityConfigSchema, SystemConfigSchema, ServerInstanceConfigSchema };
+export type { SystemConfig, ServerConfig, ServerTemplate, ServerInstance, ServerInstanceUpdate, TagDefinition, ServerInstanceConfig, ServerRuntimeConfig };
 /**
- * Logging Configuration Schema
+ * Simplified type guard - only check for legacy v1.0 format for migration
  */
-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>;
+export declare function isLegacyV1Config(config: unknown): boolean;
 //# sourceMappingURL=config.schema.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../../../src/config/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,0BAA0B,EAC1B,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,gCAAgC,CAAC;AAExC;;;;;;;GAOG;AAGH,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,0BAA0B,EAC3B,CAAC;AAEF,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACpB,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAIzD"}