@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

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,110 +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>>;
-    headers: 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>>;
-        headers: 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;;;;;;;;;;;;;;;;;iBAY7B,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"}

package/dist/server/src/config/config.schema.js

@@ -1,104 +1,20 @@
-import { z } from 'zod';
+import { TransportType, TagDefinitionSchema, ServerInstanceSchema, ServerInstanceUpdateSchema, ServerTemplateSchema, ServerConfigSchema, LoggingConfigSchema, SecurityConfigSchema, SystemConfigSchema, ServerInstanceConfigSchema } 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.
  */
-// Server configuration schema (keyed by server name)
-export const ServerConfigSchema = z.object({
-    command: z.string().optional(),
-    args: z.array(z.string()).default([]),
-    env: z.record(z.string(), z.string()).optional(),
-    headers: z.record(z.string(), z.string()).optional(),
-    enabled: z.boolean().default(true),
-    tags: z.record(z.string(), z.string()).optional(),
-    type: z.enum(['stdio', 'sse', 'streamable-http', 'http']).default('stdio'),
-    timeout: z.number().default(60000),
-    url: z.string().optional(),
-    allowedTools: z.array(z.string()).default([]),
-    description: z.string().optional()
-});
-// Server instance schema (each instance contains id, timestamp, hash)
-export const ServerInstanceConfigSchema = z.object({
-    id: z.string(),
-    timestamp: z.number(), // Startup time
-    hash: z.string(),
-    pid: z.number().optional(), // Process ID
-    startTime: z.number().optional() // Startup time (same as timestamp, for compatibility)
-});
+// Re-export shared types for backward compatibility
+export { TransportType, TagDefinitionSchema, ServerInstanceSchema, ServerInstanceUpdateSchema, ServerTemplateSchema, ServerConfigSchema, LoggingConfigSchema, SecurityConfigSchema, SystemConfigSchema, ServerInstanceConfigSchema };
 /**
- * Logging Configuration Schema
+ * Simplified type guard - only check for legacy v1.0 format for migration
  */
-export const LoggingConfigSchema = z
-    .object({
-    level: z.custom().default('info'),
-    rotationAge: z.string().default('7d'), // e.g., "7d", "30d"
-    jsonPretty: z.boolean().default(true), // Enable pretty JSON formatting in logs
-    mcpCommDebug: z.boolean().default(false), // Enable MCP communication debug logging
-    sessionDebug: z.boolean().default(false) // Enable session debug logging
-})
-    .default({
-    level: 'info',
-    rotationAge: '7d',
-    jsonPretty: true,
-    mcpCommDebug: false,
-    sessionDebug: false
-});
-/**
- * Security Configuration Schema
- */
-export const SecurityConfigSchema = z
-    .object({
-    allowedNetworks: z
-        .array(z.string())
-        .default(['127.0.0.1', '192.168.0.0/16', '10.0.0.0/8', '172.16.0.0/12']),
-    maxConcurrentConnections: z.number().min(1).max(1000).default(50),
-    connectionTimeout: z.number().min(1000).default(30000),
-    idleConnectionTimeout: z.number().min(30000).default(300000),
-    sessionTimeout: z
-        .number()
-        .min(60000)
-        .default(30 * 60 * 1000), // Default 30 minutes, min 1 minute
-    sessionFlushInterval: z
-        .number()
-        .min(1000)
-        .default(15 * 60 * 1000), // Default 15 minutes, min 1 second
-    maxConnections: z.number().min(1).max(1000).default(50)
-})
-    .default({
-    allowedNetworks: ['127.0.0.1', '192.168.0.0/16', '10.0.0.0/8', '172.16.0.0/12'],
-    maxConcurrentConnections: 50,
-    connectionTimeout: 30000,
-    idleConnectionTimeout: 300000,
-    sessionTimeout: 30 * 60 * 1000,
-    sessionFlushInterval: 15 * 60 * 1000,
-    maxConnections: 50
-});
-/**
- * System Configuration Schema
- */
-export const SystemConfigSchema = z.object({
-    version: z.string().default('1.0.0'),
-    system: z
-        .object({
-        host: z.string().default('localhost'),
-        port: z.number().default(7788),
-        language: z.enum(['zh', 'en']).default('zh'),
-        theme: z.enum(['light', 'dark', 'system']).default('system'),
-        logging: LoggingConfigSchema
-    })
-        .default({
-        host: 'localhost',
-        port: 7788,
-        language: 'zh',
-        theme: 'system',
-        logging: {
-            level: 'info',
-            rotationAge: '7d',
-            jsonPretty: true,
-            mcpCommDebug: false,
-            sessionDebug: false
-        }
-    }),
-    security: SecurityConfigSchema,
-    servers: z.record(z.string(), ServerConfigSchema).default({})
-});
+export function isLegacyV1Config(config) {
+    if (typeof config !== 'object' || config === null)
+        return false;
+    const c = config;
+    return c.version !== '1.1.0';
+}

package/dist/server/src/config/path-validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Path validation utilities for configuration files.
+ * Provides basic path validation to prevent path traversal attacks.
+ */
+/**
+ * Validates that a path is within an allowed directory.
+ *
+ * @param configPath - The path to validate
+ * @param allowedDirs - Array of allowed parent directories
+ * @returns true if path is valid, false otherwise
+ */
+export declare function isValidConfigPath(configPath: string, allowedDirs: string[]): boolean;
+/**
+ * Ensures a path is absolute and normalized.
+ *
+ * @param configPath - The path to sanitize
+ * @returns Normalized absolute path
+ */
+export declare function sanitizeConfigPath(configPath: string): string;
+/**
+ * Validates that a filename doesn't contain path traversal characters.
+ *
+ * @param filename - The filename to validate
+ * @returns true if filename is safe, false otherwise
+ */
+export declare function isSafeFilename(filename: string): boolean;
+//# sourceMappingURL=path-validator.d.ts.map

package/dist/server/src/config/path-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../../../../src/config/path-validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAepF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CASxD"}