@robiki/proxy 1.0.3 → 1.0.4

package/README.de.md

@@ -18,7 +18,7 @@
 - **✅ Anforderungsvalidierung**: Benutzerdefinierte Validierungslogik für Authentifizierung, Rate Limiting usw.
 - **🔄 URL-Remapping**: URLs vor der Weiterleitung an Zieldienste transformieren
 - **📦 Duale Nutzung**: Als npm-Paket oder Docker-Container verwenden
-- **⚙️ JavaScript & TypeScript-Konfigurationsunterstützung**: Verwenden Sie `.cjs` oder `.ts`-Konfigurationsdateien mit Funktionen in Docker
+- **⚙️ JavaScript & TypeScript-Konfigurationsunterstützung**: Verwenden Sie `.js` oder `.ts`-Konfigurationsdateien mit Funktionen in Docker
 - **🎯 Multi-Port-Unterstützung**: Gleichzeitiges Lauschen auf mehreren Ports
 - **⚡ Hohe Leistung**: Basiert auf der nativen HTTP/2-Implementierung von Node.js
 
@@ -145,8 +145,8 @@ Einfache deklarative Konfiguration:
 Für erweiterte Funktionen wie URL-Remapping und Validierung:
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/README.es.md

@@ -18,6 +18,7 @@
 - **✅ Validación de solicitudes**: Lógica de validación personalizada para autenticación, limitación de velocidad, etc.
 - **🔄 Remapeo de URL**: Transforma URLs antes de reenviarlas a servicios de destino
 - **📦 Uso dual**: Usa como paquete npm o contenedor Docker
+- **⚙️ Soporte de configuración JavaScript y TypeScript**: Usa archivos de configuración `.js` o `.ts` con funciones en Docker
 - **🎯 Soporte multi-puerto**: Escucha en múltiples puertos simultáneamente
 - **⚡ Alto rendimiento**: Construido sobre la implementación nativa HTTP/2 de Node.js
 
@@ -144,8 +145,8 @@ Configuración declarativa simple:
 Para características avanzadas como remapeo de URL y validación:
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/README.ja.md

@@ -18,6 +18,7 @@
 - **✅ リクエスト検証**：認証、レート制限などのカスタム検証ロジック
 - **🔄 URL リマッピング**：ターゲットサービスに転送する前に URL を変換
 - **📦 デュアル使用**：npm パッケージまたは Docker コンテナとして使用
+- **⚙️ JavaScript & TypeScript 設定サポート**：Docker で関数を使用した `.js` または `.ts` 設定ファイルを使用
 - **🎯 マルチポートサポート**：複数のポートで同時にリッスン
 - **⚡ 高性能**：Node.js ネイティブ HTTP/2 実装に基づく
 
@@ -144,8 +145,8 @@ docker-compose up -d
 URL リマッピングや検証などの高度な機能用：
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/README.md

@@ -18,7 +18,7 @@
 - **✅ Request Validation**: Custom validation logic for authentication, rate limiting, etc.
 - **🔄 URL Remapping**: Transform URLs before forwarding to target services
 - **📦 Dual Usage**: Use as npm package or Docker container
-- **⚙️ JavaScript & TypeScript Config Support**: Use `.cjs` or `.ts` config files with functions in Docker
+- **⚙️ JavaScript & TypeScript Config Support**: Use `.js` or `.ts` config files with functions in Docker
 - **🎯 Multi-Port Support**: Listen on multiple ports simultaneously
 - **⚡ High Performance**: Built on Node.js native HTTP/2 implementation
 
@@ -145,8 +145,8 @@ Simple declarative configuration:
 For advanced features like URL remapping and validation:
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',
@@ -262,17 +262,17 @@ interface RouteConfig {
 
 ## 🐳 Docker Usage
 
-Mount your config file (JSON, .cjs, or .ts):
+Mount your config file (JSON, .js, or .ts):
 
 ```yaml
 services:
   proxy:
     image: robiki/proxy:latest
     volumes:
-      - ./proxy.config.cjs:/app/proxy.config.cjs:ro
-      - ./certs:/app/certs:ro
+      - ./proxy.config.js:/usr/src/proxy.config.js:ro
+      - ./certs:/usr/src/certs:ro
     environment:
-      - PROXY_CONFIG=/app/proxy.config.cjs
+      - PROXY_CONFIG=/usr/src/proxy.config.js
 ```
 
 ## 🔐 SSL Certificates

package/README.pl.md

@@ -18,6 +18,7 @@
 - **✅ Walidacja żądań**: Niestandardowa logika walidacji dla uwierzytelniania, limitowania żądań itp.
 - **🔄 Przekierowywanie URL**: Transformacja URL przed przekazaniem do usług docelowych
 - **📦 Podwójne użycie**: Użyj jako pakiet npm lub kontener Docker
+- **⚙️ Obsługa konfiguracji JavaScript i TypeScript**: Użyj plików konfiguracyjnych `.js` lub `.ts` z funkcjami w Docker
 - **🎯 Obsługa wielu portów**: Nasłuchiwanie na wielu portach jednocześnie
 - **⚡ Wysoka wydajność**: Zbudowany na natywnej implementacji HTTP/2 w Node.js
 
@@ -144,8 +145,8 @@ Prosta deklaratywna konfiguracja:
 Dla zaawansowanych funkcji jak przekierowywanie URL i walidacja:
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/README.ru.md

@@ -18,6 +18,7 @@
 - **✅ Валидация запросов**: Пользовательская логика валидации для аутентификации, ограничения скорости и т.д.
 - **🔄 Переназначение URL**: Преобразование URL перед пересылкой к целевым сервисам
 - **📦 Двойное использование**: Используйте как npm-пакет или Docker-контейнер
+- **⚙️ Поддержка конфигурации JavaScript и TypeScript**: Используйте файлы конфигурации `.js` или `.ts` с функциями в Docker
 - **🎯 Поддержка нескольких портов**: Прослушивание нескольких портов одновременно
 - **⚡ Высокая производительность**: Построен на нативной реализации HTTP/2 в Node.js
 
@@ -144,8 +145,8 @@ docker-compose up -d
 Для расширенных функций, таких как переназначение URL и валидация:
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/README.zh.md

@@ -18,6 +18,7 @@
 - **✅ 请求验证**：用于身份验证、速率限制等的自定义验证逻辑
 - **🔄 URL 重映射**：在转发到目标服务之前转换 URL
 - **📦 双重用途**：可作为 npm 包或 Docker 容器使用
+- **⚙️ JavaScript 和 TypeScript 配置支持**：在 Docker 中使用带有函数的 `.js` 或 `.ts` 配置文件
 - **🎯 多端口支持**：同时监听多个端口
 - **⚡ 高性能**：基于 Node.js 原生 HTTP/2 实现
 
@@ -144,8 +145,8 @@ docker-compose up -d
 用于高级功能，如 URL 重映射和验证：
 
 ```javascript
-// proxy.config.cjs
-module.exports = {
+// proxy.config.js
+export default {
   ports: [443, 8080],
   ssl: {
     key: './certs/key.pem',

package/dist/config-Bmt0asXb.d.ts

@@ -0,0 +1,168 @@
+import { OutgoingHttpHeaders, IncomingMessage } from 'node:http';
+import { IncomingHttpHeaders } from 'node:http2';
+import { TLSSocket } from 'node:tls';
+import WebSocket from 'ws';
+
+declare enum RequestType {
+    API = "api",
+    STREAM = "stream",
+    WEBSOCKET = "websocket"
+}
+interface TLSWebSocket extends WebSocket {
+    _socket: TLSSocket;
+}
+type Router = (req: any, res: any) => void;
+type WebSocketRouter = (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders) => void;
+type Streamer = (stream: any, headers: any, flags: any) => void;
+interface ForwardValidationResult {
+    status: boolean;
+    message?: string;
+    code?: number;
+    headers?: OutgoingHttpHeaders;
+}
+interface ConnectionInfo {
+    id: number;
+    method: string;
+    path: string;
+    remoteAddress: string;
+    scheme: string;
+    authority: string;
+    origin: string;
+    headers: IncomingHttpHeaders;
+    query: URLSearchParams;
+    type: RequestType;
+    respond: (status: number, headers?: Record<string, string>, body?: string) => void;
+    end: (body?: string) => void;
+}
+
+/**
+ * Route configuration for a specific domain/host
+ */
+interface RouteConfig {
+    /** Target host:port to proxy to */
+    target: string;
+    /** Enable SSL/TLS for the target */
+    ssl?: boolean;
+    /** Remap the URL path before forwarding */
+    remap?: (url: string) => string;
+    /** Custom CORS configuration */
+    cors?: CorsConfig;
+    /** Validation function for this route */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+}
+/**
+ * CORS configuration
+ */
+interface CorsConfig {
+    /** Allowed origins (array of strings or '*' for all) */
+    origin?: string | string[];
+    /** Allowed HTTP methods */
+    methods?: string[];
+    /** Allowed headers */
+    allowedHeaders?: string[];
+    /** Exposed headers */
+    exposedHeaders?: string[];
+    /** Allow credentials */
+    credentials?: boolean;
+    /** Max age for preflight cache */
+    maxAge?: number;
+}
+/**
+ * SSL/TLS certificate configuration
+ */
+interface CertificateConfig {
+    /** Path to private key file or key content */
+    key: string;
+    /** Path to certificate file or cert content */
+    cert: string;
+    /** Path to CA file or CA content */
+    ca?: string;
+    /** Allow HTTP/1.1 fallback */
+    allowHTTP1?: boolean;
+}
+/**
+ * Server configuration
+ */
+interface ServerConfig {
+    /** SSL/TLS certificate configuration */
+    ssl?: CertificateConfig;
+    /** Route configurations mapped by host */
+    routes: Record<string, RouteConfig>;
+    /** Default CORS configuration */
+    cors?: CorsConfig;
+    /** Global validation function */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    /** Ports to listen on (defaults to [443, 8080, 9229]) */
+    ports?: number[];
+}
+/**
+ * Proxy configuration manager
+ */
+declare class ProxyConfig {
+    private config;
+    private sslConfig?;
+    constructor(config: ServerConfig);
+    /**
+     * Initialize SSL configuration
+     */
+    private initializeSSL;
+    /**
+     * Get SSL configuration
+     */
+    getSSL(): {
+        key: Buffer;
+        cert: Buffer;
+        ca?: Buffer;
+        allowHTTP1?: boolean;
+    } | undefined;
+    /**
+     * Get route configuration for a host
+     */
+    getRoute(host: string): RouteConfig | undefined;
+    /**
+     * Get target for a host
+     */
+    getTarget(host: string): {
+        target: undefined;
+        ssl: undefined;
+        remap: undefined;
+    } | {
+        target: string;
+        ssl: {
+            key: Buffer;
+            cert: Buffer;
+            ca?: Buffer;
+            allowHTTP1?: boolean;
+        } | undefined;
+        remap: ((url: string) => string) | undefined;
+    };
+    /**
+     * Get CORS headers for a request
+     */
+    getCorsHeaders(origin: string, host?: string): OutgoingHttpHeaders;
+    /**
+     * Validate a request
+     */
+    validate(info: ConnectionInfo): Promise<ForwardValidationResult>;
+    /**
+     * Get ports to listen on
+     */
+    getPorts(): number[];
+    /**
+     * Get the full configuration
+     */
+    getConfig(): ServerConfig;
+}
+/**
+ * Load configuration with cascading priority (async):
+ * 1. Programmatic config (highest priority)
+ * 2. Environment variables
+ * 3. Config file
+ * 4. Defaults (lowest priority)
+ *
+ * Supports config file types: .json, .ts, .js
+ */
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): Promise<ProxyConfig>;
+
+export { ProxyConfig as P, RequestType as e, loadConfig as l };
+export type { CorsConfig as C, ForwardValidationResult as F, Router as R, ServerConfig as S, TLSWebSocket as T, WebSocketRouter as W, Streamer as a, RouteConfig as b, CertificateConfig as c, ConnectionInfo as d };

package/dist/config-C-0wrirG.js

@@ -0,0 +1,315 @@
+import { stat, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+function debug(message, data) {
+  if (process.env.DEBUG === "true") {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (data !== void 0) {
+      const sanitized = JSON.stringify(data, (_, value) => typeof value === "function" ? "<function>" : value, 2);
+      return console.log(`[${timestamp}] [CONFIG] ${message}`, sanitized);
+    }
+    return console.log(`[${timestamp}] [CONFIG] ${message}`);
+  }
+}
+
+function loadSSLKey(keyConfig) {
+  debug(`Loading SSL key from: ${keyConfig.includes("-----BEGIN") ? "inline" : keyConfig}`);
+  return keyConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(keyConfig)) : readFile(resolve(keyConfig));
+}
+function loadSSLCert(certConfig) {
+  debug(`Loading SSL cert from: ${certConfig.includes("-----BEGIN") ? "inline" : certConfig}`);
+  return certConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(certConfig)) : readFile(resolve(certConfig));
+}
+function loadSSLCA(caConfig) {
+  if (!caConfig) {
+    debug("Loading SSL CA from: none");
+    return Promise.resolve(void 0);
+  }
+  debug(`Loading SSL CA from: ${caConfig.includes("-----BEGIN") ? "inline" : caConfig}`);
+  return caConfig.includes("-----BEGIN") ? Promise.resolve(Buffer.from(caConfig)) : readFile(resolve(caConfig));
+}
+function initializeSSL(sslConfig) {
+  debug("Initializing SSL configuration...");
+  return Promise.all([loadSSLKey(sslConfig.key), loadSSLCert(sslConfig.cert), loadSSLCA(sslConfig.ca)]).then(([key, cert, ca]) => {
+    const loaded = {
+      key,
+      cert,
+      ca,
+      allowHTTP1: sslConfig.allowHTTP1 ?? true
+    };
+    debug("SSL configuration loaded successfully", {
+      keySize: key.length,
+      certSize: cert.length,
+      caSize: ca?.length || 0,
+      allowHTTP1: loaded.allowHTTP1
+    });
+    return loaded;
+  }).catch((error) => {
+    debug("Failed to load SSL certificates", error);
+    console.error("Failed to load SSL certificates:", error);
+    throw error;
+  });
+}
+function getRoute(config, host) {
+  if (config.routes[host]) {
+    return config.routes[host];
+  }
+  const hostWithoutPort = host.split(":")[0];
+  if (config.routes[hostWithoutPort]) {
+    return config.routes[hostWithoutPort];
+  }
+  for (const [pattern, route] of Object.entries(config.routes)) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      if (regex.test(host) || regex.test(hostWithoutPort)) {
+        return route;
+      }
+    }
+  }
+  return void 0;
+}
+function getTarget(config, sslConfig, host) {
+  const route = getRoute(config, host);
+  if (!route) {
+    return { target: void 0, ssl: void 0, remap: void 0 };
+  }
+  return {
+    target: route.target,
+    ssl: route.ssl ? sslConfig : void 0,
+    remap: route.remap
+  };
+}
+function getCorsHeaders(config, origin, host) {
+  const route = host ? getRoute(config, host) : void 0;
+  const corsConfig = route?.cors || config.cors;
+  if (!corsConfig) {
+    return {
+      "access-control-allow-origin": origin,
+      "access-control-allow-methods": "*",
+      "access-control-allow-headers": "*",
+      "access-control-allow-credentials": "true"
+    };
+  }
+  const headers = {};
+  if (corsConfig.origin === "*") {
+    headers["access-control-allow-origin"] = "*";
+  } else if (Array.isArray(corsConfig.origin)) {
+    if (corsConfig.origin.includes(origin)) {
+      headers["access-control-allow-origin"] = origin;
+    }
+  } else if (corsConfig.origin) {
+    headers["access-control-allow-origin"] = corsConfig.origin;
+  } else {
+    headers["access-control-allow-origin"] = origin;
+  }
+  if (corsConfig.methods) {
+    headers["access-control-allow-methods"] = corsConfig.methods.join(", ");
+  } else {
+    headers["access-control-allow-methods"] = "*";
+  }
+  if (corsConfig.allowedHeaders) {
+    headers["access-control-allow-headers"] = corsConfig.allowedHeaders.join(", ");
+  } else {
+    headers["access-control-allow-headers"] = "*";
+  }
+  if (corsConfig.exposedHeaders) {
+    headers["access-control-expose-headers"] = corsConfig.exposedHeaders.join(", ");
+  }
+  if (corsConfig.credentials !== void 0) {
+    headers["access-control-allow-credentials"] = corsConfig.credentials ? "true" : "false";
+  } else {
+    headers["access-control-allow-credentials"] = "true";
+  }
+  if (corsConfig.maxAge) {
+    headers["access-control-max-age"] = corsConfig.maxAge.toString();
+  }
+  return headers;
+}
+function validateRequest(config, info) {
+  const route = getRoute(config, info.authority);
+  if (route?.validate) return route.validate(info);
+  if (config.validate) return config.validate(info);
+  return Promise.resolve({ status: true });
+}
+function getPorts(config) {
+  return config.ports || [443, 8080, 9229];
+}
+function createProxyConfig(config, sslConfig) {
+  return {
+    config,
+    sslConfig,
+    getSSL: () => sslConfig,
+    getRoute: (host) => getRoute(config, host),
+    getTarget: (host) => getTarget(config, sslConfig, host),
+    getCorsHeaders: (origin, host) => getCorsHeaders(config, origin, host),
+    validate: (info) => validateRequest(config, info),
+    getPorts: () => getPorts(config),
+    getConfig: () => config
+  };
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj) continue;
+    for (const key in obj) {
+      if (obj[key] === void 0) continue;
+      if (typeof obj[key] === "object" && !Array.isArray(obj[key]) && obj[key] !== null) {
+        result[key] = deepMerge(result[key] || {}, obj[key]);
+      } else {
+        result[key] = obj[key];
+      }
+    }
+  }
+  return result;
+}
+function getConfigFromEnv() {
+  debug("Loading configuration from environment variables...");
+  const config = {};
+  if (process.env.SSL_KEY && process.env.SSL_CERT) {
+    debug("Found SSL configuration in environment variables");
+    config.ssl = {
+      key: process.env.SSL_KEY,
+      cert: process.env.SSL_CERT,
+      ca: process.env.SSL_CA,
+      allowHTTP1: process.env.SSL_ALLOW_HTTP1 === "true"
+    };
+  }
+  if (process.env.CORS_ORIGIN) {
+    debug("Found CORS configuration in environment variables", {
+      origin: process.env.CORS_ORIGIN,
+      methods: process.env.CORS_METHODS,
+      headers: process.env.CORS_HEADERS,
+      credentials: process.env.CORS_CREDENTIALS
+    });
+    config.cors = {
+      origin: process.env.CORS_ORIGIN === "*" ? "*" : process.env.CORS_ORIGIN.split(","),
+      methods: process.env.CORS_METHODS?.split(","),
+      allowedHeaders: process.env.CORS_HEADERS?.split(","),
+      credentials: process.env.CORS_CREDENTIALS === "true"
+    };
+  }
+  if (Object.keys(config).length === 0) {
+    debug("No configuration found in environment variables");
+  }
+  return config;
+}
+async function getConfigFromFile() {
+  const configPath = process.env.PROXY_CONFIG || "./proxy.config.json";
+  const resolvedPath = resolve(configPath);
+  debug(`Looking for config file at: ${resolvedPath}`);
+  try {
+    const stats = await stat(resolvedPath);
+    debug(`Config file found (${stats.size} bytes)`);
+    if (resolvedPath.endsWith(".json")) {
+      debug("Loading JSON config file...");
+      const configFile2 = await readFile(resolvedPath, "utf-8");
+      const config2 = JSON.parse(configFile2);
+      debug("JSON config loaded successfully", {
+        routes: Object.keys(config2.routes || {}),
+        hasCors: !!config2.cors,
+        hasSsl: !!config2.ssl,
+        ports: config2.ports
+      });
+      return config2;
+    }
+    if (resolvedPath.endsWith(".ts") || resolvedPath.endsWith(".js")) {
+      const fileType = resolvedPath.endsWith(".ts") ? "TypeScript" : "JavaScript";
+      debug(`Loading ${fileType} config file...`);
+      const configModule = await import(`file://${resolvedPath}`);
+      const config2 = configModule.default || configModule;
+      debug(`${fileType} config loaded successfully`, {
+        routes: Object.keys(config2.routes || {}),
+        hasCors: !!config2.cors,
+        hasSsl: !!config2.ssl,
+        ports: config2.ports
+      });
+      return config2;
+    }
+    debug("Loading config as JSON (no extension match)...");
+    const configFile = await readFile(resolvedPath, "utf-8");
+    const config = JSON.parse(configFile);
+    debug("Config loaded successfully", {
+      routes: Object.keys(config.routes || {}),
+      hasCors: !!config.cors,
+      hasSsl: !!config.ssl,
+      ports: config.ports
+    });
+    return config;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      debug(`Config file not found: ${resolvedPath}`);
+    } else {
+      debug(`Error loading config file: ${error.message}`);
+    }
+    return {};
+  }
+}
+function loadDefaults() {
+  debug("==========================================");
+  debug("Starting configuration loading process...");
+  debug("==========================================");
+  debug("Step 1: Loading default configuration...");
+  const defaults = {
+    routes: {},
+    cors: {
+      origin: "*",
+      credentials: true
+    }
+  };
+  debug("Defaults loaded", defaults);
+  return defaults;
+}
+function loadAndMergeFileConfig(defaults) {
+  debug("Step 2: Loading configuration from file...");
+  return getConfigFromFile().then((fileConfig) => {
+    if (Object.keys(fileConfig).length > 0) {
+      debug("File config loaded", fileConfig);
+    } else {
+      debug("No file configuration loaded");
+    }
+    return deepMerge(defaults, fileConfig);
+  });
+}
+function mergeEnvConfig(config) {
+  debug("Step 3: Loading configuration from environment...");
+  const envConfig = getConfigFromEnv();
+  return deepMerge(config, envConfig);
+}
+function mergeProgrammaticConfig(config, programmaticConfig) {
+  if (programmaticConfig && Object.keys(programmaticConfig).length > 0) {
+    debug("Step 4: Programmatic configuration provided", programmaticConfig);
+    return deepMerge(config, programmaticConfig);
+  }
+  return config;
+}
+function logMergedConfig(merged) {
+  debug("Step 5: Final merged configuration", {
+    routes: Object.keys(merged.routes || {}),
+    ports: merged.ports,
+    hasCors: !!merged.cors,
+    hasSsl: !!merged.ssl,
+    hasValidate: !!merged.validate
+  });
+  return merged;
+}
+function initializeSSLIfConfigured(config) {
+  debug("Step 6: Checking SSL configuration...");
+  if (!config.ssl) {
+    debug("No SSL configuration provided");
+    return Promise.resolve({ config, sslConfig: void 0 });
+  }
+  return initializeSSL(config.ssl).then((sslConfig) => ({ config, sslConfig }));
+}
+function createFinalConfig({ config, sslConfig }) {
+  debug("Step 7: Creating ProxyConfig object...");
+  const proxyConfig = createProxyConfig(config, sslConfig);
+  debug("==========================================");
+  debug("Configuration loading completed successfully");
+  debug("==========================================");
+  return proxyConfig;
+}
+function loadConfig(programmaticConfig) {
+  return Promise.resolve(loadDefaults()).then((defaults) => loadAndMergeFileConfig(defaults)).then((config) => mergeEnvConfig(config)).then((config) => mergeProgrammaticConfig(config, programmaticConfig)).then((merged) => logMergedConfig(merged)).then((merged) => initializeSSLIfConfigured(merged)).then((result) => createFinalConfig(result));
+}
+
+export { debug as d, loadConfig as l };

package/dist/config-DtfpOtWI.d.ts

@@ -0,0 +1,137 @@
+import { OutgoingHttpHeaders, IncomingMessage } from 'node:http';
+import { IncomingHttpHeaders } from 'node:http2';
+import { TLSSocket } from 'node:tls';
+import WebSocket from 'ws';
+
+declare enum RequestType {
+    API = "api",
+    STREAM = "stream",
+    WEBSOCKET = "websocket"
+}
+interface TLSWebSocket extends WebSocket {
+    _socket: TLSSocket;
+}
+type Router = (req: any, res: any) => void;
+type WebSocketRouter = (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders) => void;
+type Streamer = (stream: any, headers: any, flags: any) => void;
+interface ForwardValidationResult {
+    status: boolean;
+    message?: string;
+    code?: number;
+    headers?: OutgoingHttpHeaders;
+}
+interface ConnectionInfo {
+    id: number;
+    method: string;
+    path: string;
+    remoteAddress: string;
+    scheme: string;
+    authority: string;
+    origin: string;
+    headers: IncomingHttpHeaders;
+    query: URLSearchParams;
+    type: RequestType;
+    respond: (status: number, headers?: Record<string, string>, body?: string) => void;
+    end: (body?: string) => void;
+}
+
+/**
+ * Route configuration for a specific domain/host
+ */
+interface RouteConfig {
+    /** Target host:port to proxy to */
+    target: string;
+    /** Enable SSL/TLS for the target */
+    ssl?: boolean;
+    /** Remap the URL path before forwarding */
+    remap?: (url: string) => string;
+    /** Custom CORS configuration */
+    cors?: CorsConfig;
+    /** Validation function for this route */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+}
+/**
+ * CORS configuration
+ */
+interface CorsConfig {
+    /** Allowed origins (array of strings or '*' for all) */
+    origin?: string | string[];
+    /** Allowed HTTP methods */
+    methods?: string[];
+    /** Allowed headers */
+    allowedHeaders?: string[];
+    /** Exposed headers */
+    exposedHeaders?: string[];
+    /** Allow credentials */
+    credentials?: boolean;
+    /** Max age for preflight cache */
+    maxAge?: number;
+}
+/**
+ * SSL/TLS certificate configuration
+ */
+interface CertificateConfig {
+    /** Path to private key file or key content */
+    key: string;
+    /** Path to certificate file or cert content */
+    cert: string;
+    /** Path to CA file or CA content */
+    ca?: string;
+    /** Allow HTTP/1.1 fallback */
+    allowHTTP1?: boolean;
+}
+/**
+ * Server configuration
+ */
+interface ServerConfig {
+    /** SSL/TLS certificate configuration */
+    ssl?: CertificateConfig;
+    /** Route configurations mapped by host */
+    routes: Record<string, RouteConfig>;
+    /** Default CORS configuration */
+    cors?: CorsConfig;
+    /** Global validation function */
+    validate?: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    /** Ports to listen on (defaults to [443, 8080, 9229]) */
+    ports?: number[];
+}
+/**
+ * Processed SSL configuration with loaded certificates
+ */
+interface LoadedSSLConfig {
+    key: Buffer;
+    cert: Buffer;
+    ca?: Buffer;
+    allowHTTP1: boolean;
+}
+/**
+ * Proxy configuration object with loaded SSL
+ */
+interface ProxyConfig {
+    config: ServerConfig;
+    sslConfig?: LoadedSSLConfig;
+    getSSL: () => LoadedSSLConfig | undefined;
+    getRoute: (host: string) => RouteConfig | undefined;
+    getTarget: (host: string) => {
+        target: string | undefined;
+        ssl: LoadedSSLConfig | undefined;
+        remap: ((url: string) => string) | undefined;
+    };
+    getCorsHeaders: (origin: string, host?: string) => OutgoingHttpHeaders;
+    validate: (info: ConnectionInfo) => Promise<ForwardValidationResult>;
+    getPorts: () => number[];
+    getConfig: () => ServerConfig;
+}
+/**
+ * Load configuration with cascading priority using promise chain:
+ * 1. Programmatic config (highest priority)
+ * 2. Environment variables
+ * 3. Config file
+ * 4. Defaults (lowest priority)
+ *
+ * Supports config file types: .json, .ts, .js
+ */
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): Promise<ProxyConfig>;
+
+export { RequestType as e, loadConfig as l };
+export type { CorsConfig as C, ForwardValidationResult as F, LoadedSSLConfig as L, ProxyConfig as P, Router as R, ServerConfig as S, TLSWebSocket as T, WebSocketRouter as W, Streamer as a, RouteConfig as b, CertificateConfig as c, ConnectionInfo as d };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { P as ProxyConfig, T as TLSWebSocket, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-CCOdQL7F.js';
-export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, l as loadConfig } from './config-CCOdQL7F.js';
+import { P as ProxyConfig, T as TLSWebSocket, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-DtfpOtWI.js';
+export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, l as loadConfig } from './config-DtfpOtWI.js';
 import { IncomingMessage, ServerResponse, IncomingHttpHeaders as IncomingHttpHeaders$1 } from 'node:http';
 import { ServerHttp2Stream, IncomingHttpHeaders } from 'node:http2';
 import 'node:tls';
@@ -33,11 +33,22 @@ declare class ProxyServer {
 }
 /**
  * Create and start a proxy server
- * Supports all config file types: .json, .cjs, .ts, .js, .mjs
+ * Supports config file types: .json, .ts, .js
+ *
+ * Promise chain:
+ * 1. Load configuration from file/env/programmatic
+ * 2. Initialize SSL certificates
+ * 3. Create proxy server instance
+ * 4. Start listening on configured ports
  */
 declare function createProxy(config?: Partial<ServerConfig>): Promise<ProxyServer>;
 /**
  * Create a proxy server with custom handlers
+ *
+ * Promise chain:
+ * 1. Load configuration from file/env/programmatic
+ * 2. Initialize SSL certificates
+ * 3. Create servers with custom handlers
  */
 declare function createCustomProxy(config: Partial<ServerConfig> | undefined, handlers: {
     rest?: Router;

package/dist/index.js

@@ -5,8 +5,8 @@ import { createServer as createServer$1, request } from 'node:https';
 import { constants, createSecureServer, createServer, connect } from 'node:http2';
 import { exec } from 'node:child_process';
 import { WebSocketServer, WebSocket } from 'ws';
-import { loadConfig } from './utils/config.js';
-import 'node:fs';
+import { d as debug, l as loadConfig } from './config-C-0wrirG.js';
+import 'node:fs/promises';
 import 'node:path';
 
 const num = (seed) => {
@@ -224,7 +224,6 @@ function isMediaFile(path) {
   });
 }
 
-const DEBUG$2 = process.env.DEBUG === "true";
 const restAPIProxyHandler = async (req, res, config) => {
   const { target, ssl, remap } = config.getTarget(req.headers.host || req.headers[":authority"]?.toString() || "");
   if (req.httpVersion === "2.0" && ssl) return;
@@ -233,12 +232,12 @@ const restAPIProxyHandler = async (req, res, config) => {
     res.end("Not Found");
     return;
   }
-  if (DEBUG$2) console.log("HTTP1 rest proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, req.headers.host);
+  debug(`HTTP1 rest proxy for ${req.headers.host}`, `${ssl ? "https" : "http"}://${target}${req.url}`);
   if (remap) req.url = remap(req.url || "");
   const requestFn = ssl ? request : request$1;
   const headers = req.httpVersion === "2.0" ? http2HeadersToHttp1Headers(req.headers) : req.headers;
   const method = req.httpVersion === "2.0" ? req.headers[":method"]?.toString() : req.method;
-  if (DEBUG$2) console.log("Proxy Request::", req.url, method, headers);
+  debug(`Proxy Request :: ${req.url} ${method} ::`, headers);
   const proxy = requestFn(
     `${ssl ? "https" : "http"}://${target}${req.url || ""}`,
     {
@@ -263,13 +262,13 @@ const restAPIProxyHandler = async (req, res, config) => {
         }
       });
       proxyRes.on("error", (error) => {
-        if (DEBUG$2) console.error("Proxy response error:", error);
+        debug("Proxy response error:", error);
         if (!res.destroyed) res.destroy(error);
       });
     }
   );
   proxy.on("error", (error) => {
-    if (DEBUG$2) console.error("Proxy request error:", error);
+    debug("Proxy request error:", error);
     if (!res.headersSent) {
       res.writeHead(502, { "Content-Type": "text/plain" });
       res.end("Bad Gateway");
@@ -286,12 +285,11 @@ const restAPIProxyHandler = async (req, res, config) => {
     }
   });
   req.on("error", (error) => {
-    if (DEBUG$2) console.error("Client request error:", error);
+    debug("Client request error:", error);
     if (!proxy.destroyed) proxy.destroy(error);
   });
 };
 
-const DEBUG$1 = process.env.DEBUG === "true";
 const streamAPIProxyHandler = async (stream, headers, config) => {
   const { target, ssl, remap } = config.getTarget(headers[":authority"] || "");
   if (!ssl) return;
@@ -299,14 +297,9 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
     stream.destroy(new Error("Not Found"));
     return;
   }
-  if (DEBUG$1)
-    console.log(
-      "HTTP2 stream proxy",
-      `${ssl ? "https" : "http"}://${target}${headers[":path"]}`,
-      headers[":authority"]
-    );
+  debug(`HTTP2 stream proxy for ${headers[":authority"]}`, `${ssl ? "https" : "http"}://${target}${headers[":path"]}`);
   if (remap) headers[":path"] = remap(headers[":path"] || "");
-  if (DEBUG$1) console.log("Proxy Request::", headers[":path"]);
+  debug("Proxy Request::", headers[":path"]);
   const proxy = connect(`https://${target}${headers[":path"]}`, {
     ...ssl,
     rejectUnauthorized: false
@@ -315,7 +308,7 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
     const request = proxy.request(headers);
     request.on("response", (headerResponse) => {
       if (!stream.writableEnded && !stream.closed && !stream.destroyed) {
-        if (DEBUG$1) console.log("Proxy Response::", headerResponse[":status"], `for ${headers[":path"]}`);
+        debug(`Proxy Response for ${headers[":path"]}::`, headerResponse[":status"]);
         if (headers[":path"] && isMediaFile(headers[":path"])) {
           headerResponse["cache-control"] = `public, max-age=${day()}`;
         }
@@ -342,7 +335,7 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     stream.on("error", (error) => {
-      if (DEBUG$1) console.error("HTTP2 stream proxy error:", error);
+      debug("HTTP2 stream proxy error:", error);
       if (!request.destroyed) request.destroy(error);
       if (!proxy.closed) proxy.close();
     });
@@ -360,28 +353,27 @@ const streamAPIProxyHandler = async (stream, headers, config) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     request.on("error", (error) => {
-      if (DEBUG$1) console.error("HTTP2 request proxy error:", error);
+      debug("HTTP2 request proxy error:", error);
       if (!stream.destroyed) stream.destroy(error);
       return !proxy.closed && proxy.close();
     });
     proxy.on("timeout", () => {
-      if (DEBUG$1) console.error("HTTP/2 client timeout");
+      debug("HTTP/2 client timeout");
       if (!stream.destroyed) stream.destroy(new Error("HTTP/2 client timeout"));
     });
   });
   proxy.on("error", (error) => {
-    if (DEBUG$1) console.error("HTTP2 proxy connection error:", error);
+    debug("HTTP2 proxy connection error:", error);
     if (!stream.destroyed) {
       stream.destroy(error);
     }
   });
 };
 
-const DEBUG = process.env.DEBUG === "true";
 const websocketAPIProxyHandler = async (req, socket, headers, config) => {
   const { target, ssl, remap } = config.getTarget(req.headers.host || "");
   if (!target) return socket.close();
-  if (DEBUG) console.log("HTTP2 websocket proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, headers.host);
+  debug(`HTTP2 websocket proxy for ${headers.host}`, `${ssl ? "https" : "http"}://${target}${req.url}`);
   if (remap) req.url = remap(req.url || "");
   const proxy = new WebSocket(
     `${ssl ? "wss" : "ws"}://${target}${req.url || ""}`,
@@ -405,7 +397,7 @@ const websocketAPIProxyHandler = async (req, socket, headers, config) => {
   proxy.on("close", () => socket.close());
   socket.on("close", () => proxy.close());
   proxy.on("error", (error) => {
-    if (DEBUG) console.error("WebSocket proxy error:", error);
+    debug("WebSocket proxy error:", error);
     socket.close();
   });
 };
@@ -486,58 +478,59 @@ class ProxyServer {
   }
 }
 async function createProxy(config) {
-  const proxyConfig = await loadConfig(config);
-  const proxy = new ProxyServer(proxyConfig);
-  await proxy.start();
-  return proxy;
+  return loadConfig(config).then((proxyConfig) => {
+    const proxy = new ProxyServer(proxyConfig);
+    return proxy.start().then(() => proxy);
+  });
 }
 async function createCustomProxy(config, handlers) {
-  const servers = [];
   console.log("STARTING CUSTOM PROXY SERVER....");
-  const proxyConfig = await loadConfig(config);
-  const ssl = proxyConfig.getSSL();
-  const ports = proxyConfig.getPorts();
-  const boundRestHandler = (req, res) => {
-    if (req.url === "/robiki-proxy/health" && req.method === "GET") {
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end("OK");
-      return;
-    }
-    return restAPIProxyHandler(req, res, proxyConfig);
-  };
-  const boundStreamHandler = (stream, headers) => streamAPIProxyHandler(stream, headers, proxyConfig);
-  const boundWebsocketHandler = (req, socket, headers) => websocketAPIProxyHandler(req, socket, headers, proxyConfig);
-  for (const port of ports) {
-    let server;
-    if (ssl) {
-      server = http2(handlers.rest || boundRestHandler, handlers.stream || boundStreamHandler, {
-        ...ssl,
-        port
-      });
-    } else {
-      server = http(handlers.rest || boundRestHandler, { port });
-    }
-    websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
-    servers.push(server);
-  }
-  console.log("Custom proxy server started successfully");
-  return {
-    getConfig: () => proxyConfig,
-    start: async () => {
-    },
-    stop: async () => {
-      await Promise.all(
-        servers.map(
-          (server) => new Promise((resolve, reject) => {
-            server.close((err) => {
-              if (err) reject(err);
-              else resolve();
-            });
-          })
-        )
-      );
+  return loadConfig(config).then((proxyConfig) => {
+    const servers = [];
+    const ssl = proxyConfig.getSSL();
+    const ports = proxyConfig.getPorts();
+    const boundRestHandler = (req, res) => {
+      if (req.url === "/robiki-proxy/health" && req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end("OK");
+        return;
+      }
+      return restAPIProxyHandler(req, res, proxyConfig);
+    };
+    const boundStreamHandler = (stream, headers) => streamAPIProxyHandler(stream, headers, proxyConfig);
+    const boundWebsocketHandler = (req, socket, headers) => websocketAPIProxyHandler(req, socket, headers, proxyConfig);
+    for (const port of ports) {
+      let server;
+      if (ssl) {
+        server = http2(handlers.rest || boundRestHandler, handlers.stream || boundStreamHandler, {
+          ...ssl,
+          port
+        });
+      } else {
+        server = http(handlers.rest || boundRestHandler, { port });
+      }
+      websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
+      servers.push(server);
     }
-  };
+    console.log("Custom proxy server started successfully");
+    return {
+      getConfig: () => proxyConfig,
+      start: async () => {
+      },
+      stop: async () => {
+        await Promise.all(
+          servers.map(
+            (server) => new Promise((resolve, reject) => {
+              server.close((err) => {
+                if (err) reject(err);
+                else resolve();
+              });
+            })
+          )
+        );
+      }
+    };
+  });
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
   const setupErrorHandlers = () => {

package/dist/utils/config.d.ts

@@ -1,5 +1,5 @@
 import 'node:http';
-export { c as CertificateConfig, C as CorsConfig, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig } from '../config-CCOdQL7F.js';
+export { c as CertificateConfig, C as CorsConfig, L as LoadedSSLConfig, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig } from '../config-DtfpOtWI.js';
 import 'node:http2';
 import 'node:tls';
 import 'ws';

package/dist/utils/config.js

@@ -1,232 +1,3 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-class ProxyConfig {
-  config;
-  sslConfig;
-  constructor(config) {
-    this.config = config;
-    this.initializeSSL();
-  }
-  /**
-   * Initialize SSL configuration
-   */
-  initializeSSL() {
-    if (!this.config.ssl) return;
-    try {
-      const key = this.config.ssl.key.includes("-----BEGIN") ? Buffer.from(this.config.ssl.key) : readFileSync(resolve(this.config.ssl.key));
-      const cert = this.config.ssl.cert.includes("-----BEGIN") ? Buffer.from(this.config.ssl.cert) : readFileSync(resolve(this.config.ssl.cert));
-      const ca = this.config.ssl.ca ? this.config.ssl.ca.includes("-----BEGIN") ? Buffer.from(this.config.ssl.ca) : readFileSync(resolve(this.config.ssl.ca)) : void 0;
-      this.sslConfig = {
-        key,
-        cert,
-        ca,
-        allowHTTP1: this.config.ssl.allowHTTP1 ?? true
-      };
-    } catch (error) {
-      console.error("Failed to load SSL certificates:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get SSL configuration
-   */
-  getSSL() {
-    return this.sslConfig;
-  }
-  /**
-   * Get route configuration for a host
-   */
-  getRoute(host) {
-    if (this.config.routes[host]) {
-      return this.config.routes[host];
-    }
-    const hostWithoutPort = host.split(":")[0];
-    if (this.config.routes[hostWithoutPort]) {
-      return this.config.routes[hostWithoutPort];
-    }
-    for (const [pattern, route] of Object.entries(this.config.routes)) {
-      if (pattern.includes("*")) {
-        const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-        if (regex.test(host) || regex.test(hostWithoutPort)) {
-          return route;
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Get target for a host
-   */
-  getTarget(host) {
-    const route = this.getRoute(host);
-    if (!route) {
-      return { target: void 0, ssl: void 0, remap: void 0 };
-    }
-    return {
-      target: route.target,
-      ssl: route.ssl ? this.sslConfig : void 0,
-      remap: route.remap
-    };
-  }
-  /**
-   * Get CORS headers for a request
-   */
-  getCorsHeaders(origin, host) {
-    const route = host ? this.getRoute(host) : void 0;
-    const corsConfig = route?.cors || this.config.cors;
-    if (!corsConfig) {
-      return {
-        "access-control-allow-origin": origin,
-        "access-control-allow-methods": "*",
-        "access-control-allow-headers": "*",
-        "access-control-allow-credentials": "true"
-      };
-    }
-    const headers = {};
-    if (corsConfig.origin === "*") {
-      headers["access-control-allow-origin"] = "*";
-    } else if (Array.isArray(corsConfig.origin)) {
-      if (corsConfig.origin.includes(origin)) {
-        headers["access-control-allow-origin"] = origin;
-      }
-    } else if (corsConfig.origin) {
-      headers["access-control-allow-origin"] = corsConfig.origin;
-    } else {
-      headers["access-control-allow-origin"] = origin;
-    }
-    if (corsConfig.methods) {
-      headers["access-control-allow-methods"] = corsConfig.methods.join(", ");
-    } else {
-      headers["access-control-allow-methods"] = "*";
-    }
-    if (corsConfig.allowedHeaders) {
-      headers["access-control-allow-headers"] = corsConfig.allowedHeaders.join(", ");
-    } else {
-      headers["access-control-allow-headers"] = "*";
-    }
-    if (corsConfig.exposedHeaders) {
-      headers["access-control-expose-headers"] = corsConfig.exposedHeaders.join(", ");
-    }
-    if (corsConfig.credentials !== void 0) {
-      headers["access-control-allow-credentials"] = corsConfig.credentials ? "true" : "false";
-    } else {
-      headers["access-control-allow-credentials"] = "true";
-    }
-    if (corsConfig.maxAge) {
-      headers["access-control-max-age"] = corsConfig.maxAge.toString();
-    }
-    return headers;
-  }
-  /**
-   * Validate a request
-   */
-  async validate(info) {
-    const route = this.getRoute(info.authority);
-    if (route?.validate) return route.validate(info);
-    if (this.config.validate) return this.config.validate(info);
-    return { status: true };
-  }
-  /**
-   * Get ports to listen on
-   */
-  getPorts() {
-    return this.config.ports || [443, 8080, 9229];
-  }
-  /**
-   * Get the full configuration
-   */
-  getConfig() {
-    return this.config;
-  }
-}
-function deepMerge(...objects) {
-  const result = {};
-  for (const obj of objects) {
-    if (!obj) continue;
-    for (const key in obj) {
-      if (obj[key] === void 0) continue;
-      if (typeof obj[key] === "object" && !Array.isArray(obj[key]) && obj[key] !== null) {
-        result[key] = deepMerge(result[key] || {}, obj[key]);
-      } else {
-        result[key] = obj[key];
-      }
-    }
-  }
-  return result;
-}
-function getConfigFromEnv() {
-  const config = {};
-  if (process.env.SSL_KEY && process.env.SSL_CERT) {
-    config.ssl = {
-      key: process.env.SSL_KEY,
-      cert: process.env.SSL_CERT,
-      ca: process.env.SSL_CA,
-      allowHTTP1: process.env.SSL_ALLOW_HTTP1 === "true"
-    };
-  }
-  if (process.env.CORS_ORIGIN) {
-    config.cors = {
-      origin: process.env.CORS_ORIGIN === "*" ? "*" : process.env.CORS_ORIGIN.split(","),
-      methods: process.env.CORS_METHODS?.split(","),
-      allowedHeaders: process.env.CORS_HEADERS?.split(","),
-      credentials: process.env.CORS_CREDENTIALS === "true"
-    };
-  }
-  return config;
-}
-function loadTypeScriptConfig(resolvedPath) {
-  try {
-    const { register } = require("tsx/cjs/api");
-    const unregister = register();
-    try {
-      delete require.cache[resolvedPath];
-      const configModule = require(resolvedPath);
-      return configModule.default || configModule;
-    } finally {
-      unregister();
-    }
-  } catch (error) {
-    console.warn("Failed to load TypeScript config file:", error);
-    console.warn("Make sure tsx is installed: npm install tsx or yarn add tsx");
-    return {};
-  }
-}
-async function getConfigFromFile() {
-  const configPath = process.env.PROXY_CONFIG || "./proxy.config.json";
-  try {
-    const resolvedPath = resolve(configPath);
-    if (resolvedPath.endsWith(".ts")) {
-      return loadTypeScriptConfig(resolvedPath);
-    }
-    if (resolvedPath.endsWith(".js") || resolvedPath.endsWith(".mjs")) {
-      const fileUrl = `file://${resolvedPath}`;
-      const configModule = await import(fileUrl);
-      return configModule.default || configModule;
-    }
-    if (resolvedPath.endsWith(".cjs")) {
-      delete require.cache[resolvedPath];
-      const configModule = require(resolvedPath);
-      return configModule.default || configModule;
-    }
-    const configFile = readFileSync(resolvedPath, "utf-8");
-    return JSON.parse(configFile);
-  } catch (error) {
-    return {};
-  }
-}
-async function loadConfig(programmaticConfig) {
-  const defaults = {
-    routes: {},
-    cors: {
-      origin: "*",
-      credentials: true
-    }
-  };
-  const fileConfig = await getConfigFromFile();
-  const envConfig = getConfigFromEnv();
-  const merged = deepMerge(defaults, fileConfig, envConfig, programmaticConfig || {});
-  return new ProxyConfig(merged);
-}
-
-export { ProxyConfig, loadConfig };
+import 'node:fs/promises';
+import 'node:path';
+export { l as loadConfig } from '../config-C-0wrirG.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robiki/proxy",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A flexible HTTP/2 proxy server with WebSocket support, configurable routing, CORS, and validation. Use as npm package or Docker container.",
   "keywords": [
     "proxy",