@jeffusion/bungee-core 3.3.1 → 4.1.0

package/dist/master.js

@@ -16046,9 +16046,697 @@ var init_migrations = __esm(() => {
   ];
 });
 
+// src/config-migrations/types.ts
+var LATEST_CONFIG_VERSION = 4;
+
+// src/config-migrations/utils.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getAtPath(obj, path6) {
+  if (!path6)
+    return obj;
+  return path6.split(".").reduce((current, segment) => {
+    if (!isPlainObject(current) && !Array.isArray(current)) {
+      return;
+    }
+    return current[segment];
+  }, obj);
+}
+function setAtPath(obj, path6, value) {
+  const segments = path6.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (!isPlainObject(current[segment])) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function deleteAtPath(obj, path6) {
+  const segments = path6.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (!isPlainObject(current[segment])) {
+      return;
+    }
+    current = current[segment];
+  }
+  delete current[segments[segments.length - 1]];
+}
+function cleanupEmptyObjects(value) {
+  if (Array.isArray(value)) {
+    return value.map(cleanupEmptyObjects);
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const cleanedEntries = Object.entries(value).map(([key, child]) => [key, cleanupEmptyObjects(child)]).filter(([, child]) => {
+    if (child === undefined)
+      return false;
+    if (isPlainObject(child) && Object.keys(child).length === 0)
+      return false;
+    return true;
+  });
+  return Object.fromEntries(cleanedEntries);
+}
+function detectConfigVersion(rawConfig) {
+  if (!isPlainObject(rawConfig)) {
+    return 1;
+  }
+  const version = rawConfig.configVersion ?? rawConfig.config_version;
+  return typeof version === "number" && Number.isInteger(version) && version > 0 ? version : 1;
+}
+function isPlainRecord(value) {
+  return isPlainObject(value);
+}
+
+// src/config-migrations/versions/v1-to-v2.ts
+function hasAnyValue(route, paths) {
+  return paths.some((path6) => getAtPath(route, path6) !== undefined);
+}
+function moveLegacyField(route, fromPath, toPath, changes) {
+  const currentValue = getAtPath(route, fromPath);
+  if (currentValue === undefined) {
+    return;
+  }
+  setAtPath(route, toPath, currentValue);
+  deleteAtPath(route, fromPath);
+  changes.push({
+    type: "move",
+    path: fromPath,
+    from: currentValue,
+    to: toPath,
+    message: `Moved ${fromPath} to ${toPath}`
+  });
+}
+var LEGACY_FIELD_MAPPINGS, v1ToV2Migration;
+var init_v1_to_v2 = __esm(() => {
+  LEGACY_FIELD_MAPPINGS = [
+    ["failover.requestTimeoutMs", "timeouts.requestMs"],
+    ["failover.connectTimeoutMs", "timeouts.connectMs"],
+    ["failover.retryableStatusCodes", "failover.retryOn"],
+    ["failover.consecutiveFailuresThreshold", "failover.passiveHealth.consecutiveFailures"],
+    ["failover.healthyThreshold", "failover.passiveHealth.healthySuccesses"],
+    ["failover.autoDisableThreshold", "failover.passiveHealth.autoDisableThreshold"],
+    ["failover.autoEnableOnHealthCheck", "failover.passiveHealth.autoEnableOnActiveHealthCheck"],
+    ["failover.recoveryIntervalMs", "failover.recovery.probeIntervalMs"],
+    ["failover.recoveryTimeoutMs", "failover.recovery.probeTimeoutMs"]
+  ];
+  v1ToV2Migration = {
+    fromVersion: 1,
+    toVersion: 2,
+    description: "Migrate legacy failover route fields to config model v2",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      if (!Array.isArray(config.routes)) {
+        throw new Error("Config routes must be an array");
+      }
+      const changes = [];
+      const warnings = [];
+      const newFieldPaths = [
+        "timeouts.requestMs",
+        "timeouts.connectMs",
+        "failover.retryOn",
+        "failover.passiveHealth",
+        "failover.recovery"
+      ];
+      const legacyFieldPaths = LEGACY_FIELD_MAPPINGS.map(([fromPath]) => fromPath);
+      config.routes = config.routes.map((route, routeIndex) => {
+        if (!isPlainRecord(route)) {
+          throw new Error(`Route #${routeIndex + 1} must be an object`);
+        }
+        const migratedRoute = cloneJson(route);
+        if (hasAnyValue(migratedRoute, legacyFieldPaths) && hasAnyValue(migratedRoute, newFieldPaths)) {
+          throw new Error(`Route "${migratedRoute.path || routeIndex}" mixes legacy and v2 failover fields`);
+        }
+        for (const [fromPath, toPath] of LEGACY_FIELD_MAPPINGS) {
+          moveLegacyField(migratedRoute, fromPath, toPath, changes);
+        }
+        return cleanupEmptyObjects(migratedRoute);
+      });
+      config.configVersion = 2;
+      return {
+        config: cleanupEmptyObjects(config),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v2-to-v3.ts
+function renameKeysRecursive(obj, mappings, changes) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => renameKeysRecursive(item, mappings, changes));
+  }
+  if (!isPlainRecord(obj)) {
+    return obj;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const mapping = mappings.find(([from]) => from === key);
+    const newKey = mapping ? mapping[1] : key;
+    if (mapping) {
+      changes.push({
+        type: "rename",
+        path: key,
+        from: key,
+        to: newKey,
+        message: `Renamed ${key} to ${newKey}`
+      });
+    }
+    result[newKey] = renameKeysRecursive(value, mappings, changes);
+  }
+  return result;
+}
+function migrateRoutesToServiceRef(config, changes, warnings) {
+  if (!Array.isArray(config.routes))
+    return;
+  const upstreamSignatureMap = new Map;
+  const services = [];
+  for (const route of config.routes) {
+    if (!isPlainRecord(route))
+      continue;
+    const endpoints = route.endpoints;
+    if (!Array.isArray(endpoints) || endpoints.length === 0) {
+      warnings.push({
+        path: `route "${route.path || "unknown"}"`,
+        message: "Route has no endpoints; skipping service extraction"
+      });
+      continue;
+    }
+    const signature = JSON.stringify(endpoints.map((u) => ({
+      target: u.target,
+      weight: u.weight,
+      priority: u.priority
+    })));
+    let serviceName = upstreamSignatureMap.get(signature);
+    if (!serviceName) {
+      serviceName = `service-${services.length + 1}`;
+      upstreamSignatureMap.set(signature, serviceName);
+      const service = {
+        name: serviceName,
+        endpoints
+      };
+      if (isPlainRecord(route.health_check)) {
+        service.health_check = route.health_check;
+      }
+      services.push(service);
+      changes.push({
+        type: "move",
+        path: `route "${route.path}".endpoints`,
+        from: "route.endpoints",
+        to: `services.${serviceName}.endpoints`,
+        message: `Extracted endpoints to service "${serviceName}"`
+      });
+    }
+    route.service = serviceName;
+    delete route.endpoints;
+  }
+  config.services = services;
+}
+var CAMEL_TO_SNAKE_MAPPINGS, v2ToV3Migration;
+var init_v2_to_v3 = __esm(() => {
+  CAMEL_TO_SNAKE_MAPPINGS = [
+    ["configVersion", "config_version"],
+    ["logLevel", "log_level"],
+    ["bodyParserLimit", "body_parser_limit"],
+    ["pathRewrite", "path_rewrite"],
+    ["stickySession", "sticky_session"],
+    ["keyExpression", "key_expression"],
+    ["connectMs", "connect_ms"],
+    ["requestMs", "request_ms"],
+    ["retryOn", "retry_on"],
+    ["passiveHealth", "passive_health"],
+    ["consecutiveFailures", "consecutive_failures"],
+    ["healthySuccesses", "healthy_successes"],
+    ["autoDisableThreshold", "auto_disable_threshold"],
+    ["autoEnableOnActiveHealthCheck", "auto_enable_on_active_health_check"],
+    ["probeIntervalMs", "probe_interval_ms"],
+    ["probeTimeoutMs", "probe_timeout_ms"],
+    ["slowStart", "slow_start"],
+    ["durationMs", "duration_ms"],
+    ["initialWeightFactor", "initial_weight_factor"],
+    ["healthCheck", "health_check"],
+    ["intervalMs", "interval_ms"],
+    ["timeoutMs", "timeout_ms"],
+    ["expectedStatus", "expected_status"],
+    ["unhealthyThreshold", "unhealthy_threshold"],
+    ["healthyThreshold", "healthy_threshold"],
+    ["contentType", "content_type"],
+    ["maxSize", "max_size"],
+    ["retentionDays", "retention_days"],
+    ["upstreams", "endpoints"]
+  ];
+  v2ToV3Migration = {
+    fromVersion: 2,
+    toVersion: 3,
+    description: "Migrate camelCase to snake_case and extract upstreams into services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const renamedConfig = renameKeysRecursive(config, CAMEL_TO_SNAKE_MAPPINGS, changes);
+      migrateRoutesToServiceRef(renamedConfig, changes, warnings);
+      renamedConfig.config_version = 3;
+      return {
+        config: cleanupEmptyObjects(renamedConfig),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/versions/v3-to-v4.ts
+function serviceNameFromPath(path6) {
+  const base = path6.replace(/^\/+/, "").replace(/\/+$/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return `${base || "root"}-service`;
+}
+function uniqueServiceName(preferredName, existingNames) {
+  if (!existingNames.has(preferredName)) {
+    existingNames.add(preferredName);
+    return preferredName;
+  }
+  let suffix = 2;
+  while (existingNames.has(`${preferredName}-${suffix}`)) {
+    suffix++;
+  }
+  const name = `${preferredName}-${suffix}`;
+  existingNames.add(name);
+  return name;
+}
+function moveRouteConfigToService(route, service, routeIndex, changes) {
+  if (route.failover && !service.failover) {
+    service.failover = route.failover;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.failover`,
+      from: `routes.${routeIndex}.failover`,
+      to: `services.${service.name}.failover`,
+      message: `Moved route failover to service "${service.name}"`
+    });
+  }
+  if (route.sticky_session && !service.sticky_session) {
+    service.sticky_session = route.sticky_session;
+    changes.push({
+      type: "move",
+      path: `routes.${routeIndex}.sticky_session`,
+      from: `routes.${routeIndex}.sticky_session`,
+      to: `services.${service.name}.sticky_session`,
+      message: `Moved route sticky_session to service "${service.name}"`
+    });
+  }
+  if (route.failover) {
+    delete route.failover;
+  }
+  if (route.sticky_session) {
+    delete route.sticky_session;
+  }
+}
+var v3ToV4Migration;
+var init_v3_to_v4 = __esm(() => {
+  v3ToV4Migration = {
+    fromVersion: 3,
+    toVersion: 4,
+    description: "Move failover and sticky_session from routes to services",
+    migrate(input) {
+      const config = cloneJson(input);
+      if (!isPlainRecord(config)) {
+        throw new Error("Config must be an object");
+      }
+      const changes = [];
+      const warnings = [];
+      const routes = Array.isArray(config.routes) ? config.routes : [];
+      const services = Array.isArray(config.services) ? config.services : [];
+      const serviceNames = new Set(services.map((service) => service.name));
+      for (let routeIndex = 0;routeIndex < routes.length; routeIndex++) {
+        const route = routes[routeIndex];
+        if (!isPlainRecord(route)) {
+          continue;
+        }
+        const hasRouteFailover = route.failover !== undefined;
+        const hasRouteStickySession = route.sticky_session !== undefined;
+        if (!hasRouteFailover && !hasRouteStickySession) {
+          continue;
+        }
+        if (route.service) {
+          let service2 = services.find((candidate) => candidate.name === route.service);
+          if (!service2) {
+            const routeEndpoints2 = route.endpoints ?? [];
+            service2 = {
+              name: route.service,
+              endpoints: routeEndpoints2
+            };
+            services.push(service2);
+            serviceNames.add(service2.name);
+            changes.push({
+              type: "move",
+              path: `routes.${routeIndex}.service`,
+              to: `services.${service2.name}`,
+              message: `Created missing service "${service2.name}" for route "${route.path}"`
+            });
+          }
+          moveRouteConfigToService(route, service2, routeIndex, changes);
+          continue;
+        }
+        const serviceName = uniqueServiceName(serviceNameFromPath(route.path), serviceNames);
+        const routeEndpoints = route.endpoints ?? [];
+        const service = {
+          name: serviceName,
+          endpoints: routeEndpoints,
+          ...route.failover && { failover: route.failover },
+          ...route.sticky_session && { sticky_session: route.sticky_session }
+        };
+        services.push(service);
+        route.service = serviceName;
+        delete route.endpoints;
+        changes.push({
+          type: "move",
+          path: `routes.${routeIndex}`,
+          from: `routes.${routeIndex}.endpoints/failover/sticky_session`,
+          to: `services.${serviceName}`,
+          message: `Created service "${serviceName}" from route "${route.path}"`
+        });
+        moveRouteConfigToService(route, service, routeIndex, changes);
+      }
+      if (services.length > 0) {
+        config.services = services;
+      }
+      config.config_version = 4;
+      return {
+        config: cleanupEmptyObjects(config),
+        changes,
+        warnings
+      };
+    }
+  };
+});
+
+// src/config-migrations/index.ts
+var CONFIG_MIGRATIONS;
+var init_config_migrations = __esm(() => {
+  init_v1_to_v2();
+  init_v2_to_v3();
+  init_v3_to_v4();
+  CONFIG_MIGRATIONS = [
+    v1ToV2Migration,
+    v2ToV3Migration,
+    v3ToV4Migration
+  ];
+});
+
+// src/config-migrations/migrate-config.ts
+function buildMigrationMap(migrations2) {
+  return new Map(migrations2.map((migration4) => [migration4.fromVersion, migration4]));
+}
+function migrateConfigToLatest(rawConfig) {
+  const migrationMap = buildMigrationMap(CONFIG_MIGRATIONS);
+  const originalVersion = detectConfigVersion(rawConfig);
+  let currentVersion = originalVersion;
+  let workingConfig = cloneJson(rawConfig);
+  const changes = [];
+  const warnings = [];
+  while (currentVersion < LATEST_CONFIG_VERSION) {
+    const migration4 = migrationMap.get(currentVersion);
+    if (!migration4) {
+      throw new Error(`No config migration registered from version ${currentVersion}`);
+    }
+    const result = migration4.migrate(workingConfig);
+    workingConfig = result.config;
+    changes.push(...result.changes);
+    warnings.push(...result.warnings);
+    currentVersion = migration4.toVersion;
+  }
+  if (!isPlainRecord(workingConfig)) {
+    throw new Error("Migrated config must be an object");
+  }
+  workingConfig.config_version = LATEST_CONFIG_VERSION;
+  return {
+    config: workingConfig,
+    originalVersion,
+    finalVersion: LATEST_CONFIG_VERSION,
+    changes,
+    warnings
+  };
+}
+var init_migrate_config = __esm(() => {
+  init_config_migrations();
+});
+
 // src/config.ts
 import fs6 from "fs";
 import path6 from "path";
+function ensurePositiveNumber(value, field, context) {
+  if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+    logger.error(`${field} in ${context} must be a positive number.`);
+    process.exit(1);
+  }
+  return value;
+}
+function resolveRouteEndpoints(route, services) {
+  if (route.service) {
+    const svc = services?.find((s) => s.name === route.service);
+    if (!svc) {
+      logger.error(`Route "${route.path}" references unknown service "${route.service}".`);
+      process.exit(1);
+    }
+    return svc.endpoints;
+  }
+  const routeEndpoints = route.endpoints ?? [];
+  if (routeEndpoints.length > 0) {
+    return routeEndpoints;
+  }
+  if (route.direct_response?.enabled || route.redirect?.enabled || route.response_rules?.some((rule) => rule.enabled)) {
+    return [];
+  }
+  logger.error(`Route "${route.path}" must have "endpoints", "service", "response_rules", "direct_response", or "redirect" defined.`);
+  process.exit(1);
+}
+function normalizeRouteConfig(route, services) {
+  route.timeouts ??= {};
+  const endpoints = resolveRouteEndpoints(route, services);
+  route.endpoints = endpoints;
+  for (const endpoint of endpoints) {
+    if (endpoint.weight === undefined) {
+      endpoint.weight = 100;
+    }
+    if (endpoint.priority === undefined) {
+      endpoint.priority = 1;
+    }
+  }
+  return route;
+}
+function validateStickySession(service) {
+  if (service.sticky_session === undefined) {
+    return;
+  }
+  if (typeof service.sticky_session !== "object" || service.sticky_session === null || Array.isArray(service.sticky_session)) {
+    logger.error(`Invalid sticky_session config in service "${service.name}". sticky_session must be an object.`);
+    process.exit(1);
+  }
+  if (service.sticky_session.enabled !== undefined && typeof service.sticky_session.enabled !== "boolean") {
+    logger.error(`Invalid sticky_session.enabled in service "${service.name}". sticky_session.enabled must be a boolean.`);
+    process.exit(1);
+  }
+  if (service.sticky_session.key_expression !== undefined && typeof service.sticky_session.key_expression !== "string") {
+    logger.error(`Invalid sticky_session.key_expression in service "${service.name}". sticky_session.key_expression must be a string.`);
+    process.exit(1);
+  }
+}
+function validateFailoverConfig(service) {
+  const failover = service.failover;
+  if (!failover) {
+    return;
+  }
+  if (typeof failover.enabled !== "boolean") {
+    logger.error(`Invalid failover.enabled in service "${service.name}". failover.enabled must be a boolean.`);
+    process.exit(1);
+  }
+  if (service.endpoints.length < 2 && failover.enabled) {
+    logger.warn(`Service "${service.name}" has failover enabled but less than 2 endpoints. Failover will not be active.`);
+  }
+  if (failover.recovery?.probe_interval_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_interval_ms, "failover.recovery.probe_interval_ms", `service "${service.name}"`);
+  }
+  if (failover.recovery?.probe_timeout_ms !== undefined) {
+    ensurePositiveNumber(failover.recovery.probe_timeout_ms, "failover.recovery.probe_timeout_ms", `service "${service.name}"`);
+  }
+  if (failover.passive_health?.consecutive_failures !== undefined) {
+    ensurePositiveNumber(failover.passive_health.consecutive_failures, "failover.passive_health.consecutive_failures", `service "${service.name}"`);
+  }
+  if (failover.passive_health?.healthy_successes !== undefined) {
+    ensurePositiveNumber(failover.passive_health.healthy_successes, "failover.passive_health.healthy_successes", `service "${service.name}"`);
+  }
+  if (failover.passive_health?.auto_disable_threshold !== undefined) {
+    ensurePositiveNumber(failover.passive_health.auto_disable_threshold, "failover.passive_health.auto_disable_threshold", `service "${service.name}"`);
+  }
+  if (failover.passive_health?.auto_enable_on_active_health_check !== undefined && typeof failover.passive_health.auto_enable_on_active_health_check !== "boolean") {
+    logger.error(`Invalid failover.passive_health.auto_enable_on_active_health_check in service "${service.name}". It must be a boolean.`);
+    process.exit(1);
+  }
+  if (failover.slow_start) {
+    if (typeof failover.slow_start.enabled !== "boolean") {
+      logger.error(`Invalid failover.slow_start.enabled in service "${service.name}". It must be a boolean.`);
+      process.exit(1);
+    }
+    if (failover.slow_start.duration_ms !== undefined) {
+      ensurePositiveNumber(failover.slow_start.duration_ms, "failover.slow_start.duration_ms", `service "${service.name}"`);
+    }
+    if (failover.slow_start.initial_weight_factor !== undefined) {
+      const factor = failover.slow_start.initial_weight_factor;
+      if (typeof factor !== "number" || Number.isNaN(factor) || factor <= 0 || factor > 1) {
+        logger.error(`failover.slow_start.initial_weight_factor in service "${service.name}" must be between 0 and 1.`);
+        process.exit(1);
+      }
+    }
+  }
+  if (failover.health_check) {
+    if (typeof failover.health_check.enabled !== "boolean") {
+      logger.error(`Invalid failover.health_check.enabled in service "${service.name}". It must be a boolean.`);
+      process.exit(1);
+    }
+    if (failover.health_check.interval_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.interval_ms, "failover.health_check.interval_ms", `service "${service.name}"`);
+    }
+    if (failover.health_check.timeout_ms !== undefined) {
+      ensurePositiveNumber(failover.health_check.timeout_ms, "failover.health_check.timeout_ms", `service "${service.name}"`);
+    }
+    if (failover.health_check.unhealthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.unhealthy_threshold, "failover.health_check.unhealthy_threshold", `service "${service.name}"`);
+    }
+    if (failover.health_check.healthy_threshold !== undefined) {
+      ensurePositiveNumber(failover.health_check.healthy_threshold, "failover.health_check.healthy_threshold", `service "${service.name}"`);
+    }
+  }
+}
+function validateAuthConfig(authConfig, context) {
+  if (authConfig.enabled === undefined) {
+    logger.error(`Auth config in ${context} must have an "enabled" field.`);
+    process.exit(1);
+  }
+  if (!authConfig.enabled) {
+    return;
+  }
+  if (!authConfig.tokens || !Array.isArray(authConfig.tokens)) {
+    logger.error(`Auth config in ${context} must have a "tokens" array when enabled.`);
+    process.exit(1);
+  }
+  if (authConfig.tokens.length === 0) {
+    logger.error(`Auth config in ${context} must have at least one token in the "tokens" array.`);
+    process.exit(1);
+  }
+  for (let i = 0;i < authConfig.tokens.length; i++) {
+    if (typeof authConfig.tokens[i] !== "string") {
+      logger.error(`Token at index ${i} in ${context} auth config must be a string.`);
+      process.exit(1);
+    }
+  }
+  logger.debug(`Auth config validated successfully for ${context}`);
+}
+function validateServices(services) {
+  const names = new Set;
+  for (const service of services) {
+    if (!service.name || typeof service.name !== "string") {
+      logger.error('Each service must have a non-empty "name" string.');
+      process.exit(1);
+    }
+    if (names.has(service.name)) {
+      logger.error(`Duplicate service name: "${service.name}". Service names must be unique.`);
+      process.exit(1);
+    }
+    names.add(service.name);
+    if (!service.endpoints || !Array.isArray(service.endpoints) || service.endpoints.length === 0) {
+      logger.error(`Service "${service.name}" must have a non-empty "endpoints" array.`);
+      process.exit(1);
+    }
+    for (const endpoint of service.endpoints) {
+      if (typeof endpoint.target !== "string") {
+        logger.error(`Invalid endpoint in service "${service.name}". Each endpoint must have a string "target".`);
+        process.exit(1);
+      }
+    }
+    validateStickySession(service);
+    validateFailoverConfig(service);
+  }
+}
+function validateAndNormalizeConfig(config) {
+  if (!config.routes || !Array.isArray(config.routes)) {
+    logger.error('Error: "routes" is not defined or not an array in config.json.');
+    process.exit(1);
+  }
+  if (config.services && Array.isArray(config.services)) {
+    validateServices(config.services);
+  }
+  if (config.auth) {
+    validateAuthConfig(config.auth, "global");
+  }
+  for (const route of config.routes) {
+    const hasEndpoints = route.endpoints && route.endpoints.length > 0;
+    const hasServiceRef = !!route.service;
+    const hasDirectResponse = !!route.direct_response?.enabled;
+    const hasRedirect = !!route.redirect?.enabled;
+    const hasResponseRules = !!route.response_rules?.some((rule) => rule.enabled);
+    if (!hasEndpoints && !hasServiceRef && !hasDirectResponse && !hasRedirect && !hasResponseRules) {
+      logger.error(`Route for path "${route.path}" must have "endpoints", "service", "response_rules", "direct_response", or "redirect" defined.`);
+      process.exit(1);
+    }
+    if (hasServiceRef && config.services) {
+      const svc = config.services.find((s) => s.name === route.service);
+      if (!svc) {
+        logger.error(`Route "${route.path}" references unknown service "${route.service}".`);
+        process.exit(1);
+      }
+    }
+    if (route.auth) {
+      validateAuthConfig(route.auth, `route "${route.path}"`);
+    }
+    normalizeRouteConfig(route, config.services);
+    if (route.timeouts?.connect_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.connect_ms, "timeouts.connect_ms", `route "${route.path}"`);
+    }
+    if (route.timeouts?.request_ms !== undefined) {
+      ensurePositiveNumber(route.timeouts.request_ms, "timeouts.request_ms", `route "${route.path}"`);
+    }
+    const endpoints = resolveRouteEndpoints(route, config.services);
+    if (endpoints.length > 0) {
+      let total_weight = 0;
+      for (const endpoint of endpoints) {
+        if (typeof endpoint.target !== "string") {
+          logger.error(`Invalid endpoint in route for path "${route.path}". Each endpoint must have a string "target".`);
+          process.exit(1);
+        }
+        if (typeof endpoint.weight !== "number" || endpoint.weight <= 0) {
+          logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
+          process.exit(1);
+        }
+        if (typeof endpoint.priority !== "number" || endpoint.priority <= 0) {
+          logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
+          process.exit(1);
+        }
+        total_weight += endpoint.weight;
+      }
+      if (total_weight === 0) {
+        logger.error(`Total weight for endpoints in route "${route.path}" cannot be zero.`);
+        process.exit(1);
+      }
+    }
+  }
+  return config;
+}
 function preloadGlobalConfig() {
   try {
     const configPath = process.env.CONFIG_PATH || path6.resolve(process.cwd(), "config.json");
@@ -16057,10 +16745,11 @@ function preloadGlobalConfig() {
       return;
     }
     const configContent = fs6.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(configContent);
+    const rawConfig = JSON.parse(configContent);
+    const config = migrateConfigToLatest(rawConfig).config;
     const configMapping = [
       {
-        jsonKey: "logLevel",
+        jsonKey: "log_level",
         envKey: "LOG_LEVEL",
         default: "info",
         validate: (value) => ["trace", "debug", "info", "warn", "error", "fatal"].includes(value.toLowerCase())
@@ -16084,7 +16773,7 @@ function preloadGlobalConfig() {
         }
       },
       {
-        jsonKey: "bodyParserLimit",
+        jsonKey: "body_parser_limit",
         envKey: "BODY_PARSER_LIMIT",
         default: "50mb"
       }
@@ -16109,36 +16798,13 @@ function preloadGlobalConfig() {
     console.log("Falling back to environment variables and defaults.");
   }
 }
-function validateAuthConfig(authConfig, context) {
-  if (authConfig.enabled === undefined) {
-    logger.error(`Auth config in ${context} must have an "enabled" field.`);
-    process.exit(1);
-  }
-  if (!authConfig.enabled) {
-    return;
-  }
-  if (!authConfig.tokens || !Array.isArray(authConfig.tokens)) {
-    logger.error(`Auth config in ${context} must have a "tokens" array when enabled.`);
-    process.exit(1);
-  }
-  if (authConfig.tokens.length === 0) {
-    logger.error(`Auth config in ${context} must have at least one token in the "tokens" array.`);
-    process.exit(1);
-  }
-  for (let i = 0;i < authConfig.tokens.length; i++) {
-    if (typeof authConfig.tokens[i] !== "string") {
-      logger.error(`Token at index ${i} in ${context} auth config must be a string.`);
-      process.exit(1);
-    }
-  }
-  logger.debug(`Auth config validated successfully for ${context}`);
-}
 async function loadConfig(configPath) {
   try {
     const configFilePath = configPath || process.env.CONFIG_PATH || "config.json";
     if (!fs6.existsSync(configFilePath)) {
       logger.info(`Config file not found at ${configFilePath}, creating empty configuration`);
       const minimalConfig = {
+        config_version: 4,
         routes: []
       };
       fs6.writeFileSync(configFilePath, JSON.stringify(minimalConfig, null, 2), "utf-8");
@@ -16146,65 +16812,16 @@ async function loadConfig(configPath) {
       logger.warn(`\u26A0\uFE0F  No routes configured. Please add routes via the web UI at http://localhost:${process.env.PORT || 8088}`);
       logger.info(`\uD83D\uDCDD Built-in endpoints: /health (health check), / (web UI)`);
     }
-    const config = await Bun.file(configFilePath).json();
-    if (!config.routes || !Array.isArray(config.routes)) {
-      logger.error('Error: "routes" is not defined or not an array in config.json.');
-      process.exit(1);
-    }
-    if (config.auth) {
-      validateAuthConfig(config.auth, "global");
-    }
-    for (const route of config.routes) {
-      if (!route.upstreams || route.upstreams.length === 0) {
-        logger.error(`Route for path "${route.path}" must have a non-empty "upstreams" array.`);
-        process.exit(1);
-      }
-      if (route.upstreams.length < 2 && route.failover?.enabled) {
-        logger.warn(`Route for path "${route.path}" has failover enabled but less than 2 upstreams. Failover will not be active.`);
-      }
-      if (route.auth) {
-        validateAuthConfig(route.auth, `route "${route.path}"`);
-      }
-      if (route.stickySession !== undefined) {
-        if (typeof route.stickySession !== "object" || route.stickySession === null || Array.isArray(route.stickySession)) {
-          logger.error(`Invalid stickySession config in route "${route.path}". stickySession must be an object.`);
-          process.exit(1);
-        }
-        if (route.stickySession.enabled !== undefined && typeof route.stickySession.enabled !== "boolean") {
-          logger.error(`Invalid stickySession.enabled in route "${route.path}". stickySession.enabled must be a boolean.`);
-          process.exit(1);
-        }
-        if (route.stickySession.keyExpression !== undefined && typeof route.stickySession.keyExpression !== "string") {
-          logger.error(`Invalid stickySession.keyExpression in route "${route.path}". stickySession.keyExpression must be a string.`);
-          process.exit(1);
-        }
-      }
-      let totalWeight = 0;
-      for (const upstream of route.upstreams) {
-        if (typeof upstream.target !== "string") {
-          logger.error(`Invalid upstream in route for path "${route.path}". Each upstream must have a string "target".`);
-          process.exit(1);
-        }
-        if (upstream.weight === undefined) {
-          upstream.weight = 100;
-        } else if (typeof upstream.weight !== "number" || upstream.weight <= 0) {
-          logger.error(`Invalid weight in route for path "${route.path}". Weight must be a positive number.`);
-          process.exit(1);
-        }
-        if (upstream.priority === undefined) {
-          upstream.priority = 1;
-        } else if (typeof upstream.priority !== "number" || upstream.priority <= 0) {
-          logger.error(`Invalid priority in route for path "${route.path}". Priority must be a positive number.`);
-          process.exit(1);
-        }
-        totalWeight += upstream.weight;
-      }
-      if (totalWeight === 0) {
-        logger.error(`Total weight for upstreams in route "${route.path}" cannot be zero.`);
-        process.exit(1);
-      }
+    const rawConfig = await Bun.file(configFilePath).json();
+    const migrated = migrateConfigToLatest(rawConfig);
+    if (migrated.originalVersion !== migrated.finalVersion) {
+      logger.info({
+        fromVersion: migrated.originalVersion,
+        toVersion: migrated.finalVersion,
+        changeCount: migrated.changes.length
+      }, "Config migrated to latest version in memory");
     }
-    return config;
+    return validateAndNormalizeConfig(migrated.config);
   } catch (error) {
     logger.fatal({ error }, "Failed to load or parse config.json. Please ensure it exists and is valid JSON.");
     process.exit(1);
@@ -16212,6 +16829,7 @@ async function loadConfig(configPath) {
 }
 var init_config = __esm(() => {
   init_logger();
+  init_migrate_config();
 });
 
 // src/plugin-storage-cleanup.ts