@robiki/proxy 1.0.0 → 1.0.2

package/dist/config-CQ7zIaQt.d.ts

@@ -0,0 +1,172 @@
+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>;
+}
+/**
+ * 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:
+ * 1. Programmatic config (highest priority)
+ * 2. Environment variables
+ * 3. Config file
+ * 4. Defaults (lowest priority)
+ */
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): ProxyConfig;
+/**
+ * Load configuration from a file (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromFile(path: string): ProxyConfig;
+/**
+ * Load configuration from environment variables (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromEnv(): ProxyConfig;
+
+export { ProxyConfig as P, RequestType as e, loadConfigFromFile as f, loadConfigFromEnv as g, 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-CeJ1tf8T.d.ts

@@ -0,0 +1,174 @@
+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:
+ * 1. Programmatic config (highest priority)
+ * 2. Environment variables
+ * 3. Config file
+ * 4. Defaults (lowest priority)
+ */
+declare function loadConfig(programmaticConfig?: Partial<ServerConfig>): ProxyConfig;
+/**
+ * Load configuration from a file (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromFile(path: string): ProxyConfig;
+/**
+ * Load configuration from environment variables (deprecated - use loadConfig instead)
+ */
+declare function loadConfigFromEnv(): ProxyConfig;
+
+export { ProxyConfig as P, RequestType as e, loadConfigFromFile as f, loadConfigFromEnv as g, 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/index.d.ts

@@ -1,15 +1,15 @@
-import { T as TLSWebSocket, P as ProxyConfig, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-_6LOsppp.js';
-export { c as CertificateConfig, d as ConnectionInfo, C as CorsConfig, F as ForwardValidationResult, e as RequestType, b as RouteConfig, g as getConfig, l as loadConfig } from './config-_6LOsppp.js';
+import { P as ProxyConfig, T as TLSWebSocket, S as ServerConfig, R as Router, a as Streamer, W as WebSocketRouter } from './config-CeJ1tf8T.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-CeJ1tf8T.js';
 import { IncomingMessage, ServerResponse, IncomingHttpHeaders as IncomingHttpHeaders$1 } from 'node:http';
 import { ServerHttp2Stream, IncomingHttpHeaders } from 'node:http2';
 import 'node:tls';
 import 'ws';
 
-declare const restAPIProxyHandler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+declare const restAPIProxyHandler: (req: IncomingMessage, res: ServerResponse, config: ProxyConfig) => Promise<void>;
 
-declare const streamAPIProxyHandler: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders) => Promise<void>;
+declare const streamAPIProxyHandler: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, config: ProxyConfig) => Promise<void>;
 
-declare const websocketAPIProxyHandler: (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders$1) => Promise<void>;
+declare const websocketAPIProxyHandler: (req: IncomingMessage, socket: TLSWebSocket, headers: IncomingHttpHeaders$1, config: ProxyConfig) => Promise<void>;
 
 /**
  * Proxy server instance

package/dist/index.js

@@ -5,7 +5,7 @@ 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 { getConfig, loadConfig } from './utils/config.js';
+import { loadConfig } from './utils/config.js';
 import 'node:fs';
 import 'node:path';
 
@@ -212,11 +212,6 @@ function isMediaFile(path) {
     ".flac",
     ".aac",
     ".m4a",
-    ".ogg",
-    ".wav",
-    ".flac",
-    ".aac",
-    ".m4a",
     ".woff2",
     ".woff",
     ".ttf",
@@ -229,8 +224,8 @@ function isMediaFile(path) {
   });
 }
 
-const restAPIProxyHandler = async (req, res) => {
-  const config = getConfig();
+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;
   if (!target) {
@@ -238,12 +233,12 @@ const restAPIProxyHandler = async (req, res) => {
     res.end("Not Found");
     return;
   }
-  console.log("HTTP1 rest proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, req.headers.host);
+  if (DEBUG$2) console.log("HTTP1 rest proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, req.headers.host);
   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;
-  console.log("Proxy Request::", req.url, method, headers);
+  if (DEBUG$2) console.log("Proxy Request::", req.url, method, headers);
   const proxy = requestFn(
     `${ssl ? "https" : "http"}://${target}${req.url || ""}`,
     {
@@ -268,11 +263,18 @@ const restAPIProxyHandler = async (req, res) => {
         }
       });
       proxyRes.on("error", (error) => {
-        console.error("Proxy response error:", error);
+        if (DEBUG$2) console.error("Proxy response error:", error);
         if (!res.destroyed) res.destroy(error);
       });
     }
   );
+  proxy.on("error", (error) => {
+    if (DEBUG$2) console.error("Proxy request error:", error);
+    if (!res.headersSent) {
+      res.writeHead(502, { "Content-Type": "text/plain" });
+      res.end("Bad Gateway");
+    }
+  });
   req.on("data", (chunk) => {
     if (!proxy.writableEnded && !proxy.closed && !proxy.destroyed) {
       proxy.write(chunk);
@@ -284,22 +286,27 @@ const restAPIProxyHandler = async (req, res) => {
     }
   });
   req.on("error", (error) => {
-    console.error("Client request error:", error);
+    if (DEBUG$2) console.error("Client request error:", error);
     if (!proxy.destroyed) proxy.destroy(error);
   });
 };
 
-const streamAPIProxyHandler = async (stream, headers) => {
-  const config = getConfig();
+const DEBUG$1 = process.env.DEBUG === "true";
+const streamAPIProxyHandler = async (stream, headers, config) => {
   const { target, ssl, remap } = config.getTarget(headers[":authority"] || "");
   if (!ssl) return;
   if (!target) {
     stream.destroy(new Error("Not Found"));
     return;
   }
-  console.log("HTTP2 stream proxy", `${ssl ? "https" : "http"}://${target}${headers[":path"]}`, headers[":authority"]);
+  if (DEBUG$1)
+    console.log(
+      "HTTP2 stream proxy",
+      `${ssl ? "https" : "http"}://${target}${headers[":path"]}`,
+      headers[":authority"]
+    );
   if (remap) headers[":path"] = remap(headers[":path"] || "");
-  console.log("Proxy Request::", headers[":path"]);
+  if (DEBUG$1) console.log("Proxy Request::", headers[":path"]);
   const proxy = connect(`https://${target}${headers[":path"]}`, {
     ...ssl,
     rejectUnauthorized: false
@@ -308,7 +315,7 @@ const streamAPIProxyHandler = async (stream, headers) => {
     const request = proxy.request(headers);
     request.on("response", (headerResponse) => {
       if (!stream.writableEnded && !stream.closed && !stream.destroyed) {
-        console.log("Proxy Response::", headerResponse[":status"], `for ${headers[":path"]}`);
+        if (DEBUG$1) console.log("Proxy Response::", headerResponse[":status"], `for ${headers[":path"]}`);
         if (headers[":path"] && isMediaFile(headers[":path"])) {
           headerResponse["cache-control"] = `public, max-age=${day()}`;
         }
@@ -335,7 +342,7 @@ const streamAPIProxyHandler = async (stream, headers) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     stream.on("error", (error) => {
-      console.error("HTTP2 stream proxy error:", error);
+      if (DEBUG$1) console.error("HTTP2 stream proxy error:", error);
       if (!request.destroyed) request.destroy(error);
       if (!proxy.closed) proxy.close();
     });
@@ -353,28 +360,28 @@ const streamAPIProxyHandler = async (stream, headers) => {
       if (!stream.closed && !stream.destroyed) stream.close();
     });
     request.on("error", (error) => {
-      console.error("HTTP2 request proxy error:", error);
+      if (DEBUG$1) console.error("HTTP2 request proxy error:", error);
       if (!stream.destroyed) stream.destroy(error);
       return !proxy.closed && proxy.close();
     });
     proxy.on("timeout", () => {
-      console.error("HTTP/2 client timeout");
+      if (DEBUG$1) console.error("HTTP/2 client timeout");
       if (!stream.destroyed) stream.destroy(new Error("HTTP/2 client timeout"));
     });
   });
   proxy.on("error", (error) => {
-    console.error("HTTP2 proxy connection error:", error);
+    if (DEBUG$1) console.error("HTTP2 proxy connection error:", error);
     if (!stream.destroyed) {
       stream.destroy(error);
     }
   });
 };
 
-const websocketAPIProxyHandler = async (req, socket, headers) => {
-  const config = getConfig();
+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();
-  console.log("HTTP2 websocket proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, headers.host);
+  if (DEBUG) console.log("HTTP2 websocket proxy", `${ssl ? "https" : "http"}://${target}${req.url}`, headers.host);
   if (remap) req.url = remap(req.url || "");
   const proxy = new WebSocket(
     `${ssl ? "wss" : "ws"}://${target}${req.url || ""}`,
@@ -398,7 +405,7 @@ const websocketAPIProxyHandler = async (req, socket, headers) => {
   proxy.on("close", () => socket.close());
   socket.on("close", () => proxy.close());
   proxy.on("error", (error) => {
-    console.error("WebSocket proxy error:", error);
+    if (DEBUG) console.error("WebSocket proxy error:", error);
     socket.close();
   });
 };
@@ -422,14 +429,24 @@ class ProxyServer {
       return { ssl, ports };
     };
     const createServers = ({ ssl: ssl2, ports: ports2 }) => {
+      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, this.config);
+      };
+      const boundStreamHandler = (stream, headers) => streamAPIProxyHandler(stream, headers, this.config);
+      const boundWebsocketHandler = (req, socket, headers) => websocketAPIProxyHandler(req, socket, headers, this.config);
       for (const port of ports2) {
         let server;
         if (ssl2) {
-          server = http2(restAPIProxyHandler, streamAPIProxyHandler, { ...ssl2, port });
+          server = http2(boundRestHandler, boundStreamHandler, { ...ssl2, port });
         } else {
-          server = http(restAPIProxyHandler, { port });
+          server = http(boundRestHandler, { port });
         }
-        websocket(server, websocketAPIProxyHandler, (info) => this.config.validate(info));
+        websocket(server, boundWebsocketHandler, (info) => this.config.validate(info));
         this.servers.push(server);
       }
       return this.servers;
@@ -448,9 +465,16 @@ class ProxyServer {
    */
   async stop() {
     console.log("Stopping proxy server...");
-    for (const server of this.servers) {
-      server.close();
-    }
+    await Promise.all(
+      this.servers.map(
+        (server) => new Promise((resolve, reject) => {
+          server.close((err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        })
+      )
+    );
     this.servers = [];
     console.log("Proxy server stopped");
   }
@@ -485,17 +509,27 @@ function createCustomProxy(config, handlers) {
     return cfg;
   };
   const createServers = ({ ssl, ports, proxyConfig }) => {
+    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 || restAPIProxyHandler, handlers.stream || streamAPIProxyHandler, {
+        server = http2(handlers.rest || boundRestHandler, handlers.stream || boundStreamHandler, {
           ...ssl,
           port
         });
       } else {
-        server = http(handlers.rest || restAPIProxyHandler, { port });
+        server = http(handlers.rest || boundRestHandler, { port });
       }
-      websocket(server, handlers.websocket || websocketAPIProxyHandler);
+      websocket(server, handlers.websocket || boundWebsocketHandler, (info) => proxyConfig.validate(info));
       servers.push(server);
     }
     return proxyConfig;
@@ -507,9 +541,16 @@ function createCustomProxy(config, handlers) {
       start: async () => {
       },
       stop: async () => {
-        for (const server of servers) {
-          server.close();
-        }
+        await Promise.all(
+          servers.map(
+            (server) => new Promise((resolve, reject) => {
+              server.close((err) => {
+                if (err) reject(err);
+                else resolve();
+              });
+            })
+          )
+        );
       }
     };
   };
@@ -539,4 +580,4 @@ if (import.meta.url === `file://${process.argv[1]}`) {
   Promise.resolve().then(() => startProxyServer()).catch((error) => handleStartupError(error));
 }
 
-export { ProxyServer, RequestType, createCustomProxy, createProxy, getConfig, loadConfig, restAPIProxyHandler, streamAPIProxyHandler, websocketAPIProxyHandler };
+export { ProxyServer, RequestType, createCustomProxy, createProxy, loadConfig, restAPIProxyHandler, streamAPIProxyHandler, websocketAPIProxyHandler };

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, g as getConfig, i as initConfig, l as loadConfig, h as loadConfigFromEnv, f as loadConfigFromFile } from '../config-_6LOsppp.js';
+export { c as CertificateConfig, C as CorsConfig, P as ProxyConfig, b as RouteConfig, S as ServerConfig, l as loadConfig, g as loadConfigFromEnv, f as loadConfigFromFile } from '../config-CeJ1tf8T.js';
 import 'node:http2';
 import 'node:tls';
 import 'ws';

package/dist/utils/config.js

@@ -131,7 +131,7 @@ class ProxyConfig {
    * Get ports to listen on
    */
   getPorts() {
-    return [443, 8080, 9229];
+    return this.config.ports || [443, 8080, 9229];
   }
   /**
    * Get the full configuration
@@ -140,17 +140,6 @@ class ProxyConfig {
     return this.config;
   }
 }
-let globalConfig;
-function initConfig(config) {
-  globalConfig = new ProxyConfig(config);
-  return globalConfig;
-}
-function getConfig() {
-  if (!globalConfig) {
-    throw new Error("Configuration not initialized. Call initConfig() first.");
-  }
-  return globalConfig;
-}
 function deepMerge(...objects) {
   const result = {};
   for (const obj of objects) {
@@ -206,13 +195,13 @@ function loadConfig(programmaticConfig) {
   const fileConfig = getConfigFromFile();
   const envConfig = getConfigFromEnv();
   const merged = deepMerge(defaults, fileConfig, envConfig, programmaticConfig || {});
-  return initConfig(merged);
+  return new ProxyConfig(merged);
 }
 function loadConfigFromFile(path) {
   try {
     const configFile = readFileSync(resolve(path), "utf-8");
     const config = JSON.parse(configFile);
-    return initConfig(config);
+    return new ProxyConfig(config);
   } catch (error) {
     console.error("Failed to load configuration file:", error);
     throw error;
@@ -220,7 +209,7 @@ function loadConfigFromFile(path) {
 }
 function loadConfigFromEnv() {
   const config = getConfigFromEnv();
-  return initConfig(config);
+  return new ProxyConfig(config);
 }
 
-export { ProxyConfig, getConfig, initConfig, loadConfig, loadConfigFromEnv, loadConfigFromFile };
+export { ProxyConfig, loadConfig, loadConfigFromEnv, loadConfigFromFile };