@robiki/proxy 1.0.0

package/dist/index.js

@@ -0,0 +1,542 @@
+#!/usr/bin/env node
+import net from 'node:net';
+import { createServer as createServer$2, request as request$1 } from 'node:http';
+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 'node:fs';
+import 'node:path';
+
+const num = (seed) => {
+  const a = 1664525;
+  const c = 1013904223;
+  const m = 2 ** 32;
+  let state = Date.now();
+  state = (a * state + c) % m;
+  return state;
+};
+
+var RequestType = /* @__PURE__ */ ((RequestType2) => {
+  RequestType2["API"] = "api";
+  RequestType2["STREAM"] = "stream";
+  RequestType2["WEBSOCKET"] = "websocket";
+  return RequestType2;
+})(RequestType || {});
+const { HTTP2_HEADER_PATH, HTTP2_HEADER_METHOD, HTTP2_HEADER_SCHEME, HTTP2_HEADER_AUTHORITY } = constants;
+const kill = (port) => {
+  return new Promise((resolve, reject) => {
+    console.log(`Attempting to kill process on port ${port}...`);
+    exec(`sleep 3 && kill -9 $(lsof -t -i:${port})`, (err) => {
+      if (err && err.message.indexOf("ENOENT") === -1) return reject(err);
+      return resolve();
+    });
+  });
+};
+const isPortTaken = (port) => {
+  return new Promise((resolve, reject) => {
+    const tester = net.createServer().once("error", (err) => {
+      if (err.code !== "EADDRINUSE") return reject(err);
+      resolve(true);
+    }).once("listening", () => {
+      tester.once("close", () => resolve(false)).close();
+    }).listen(port);
+  });
+};
+const allocatePort = (port) => {
+  return isPortTaken(port).then((isTaken) => {
+    if (!isTaken) return;
+    return kill(port);
+  });
+};
+const getCorsHeaders = (origin) => {
+  return {
+    "access-control-allow-origin": origin,
+    "access-control-allow-methods": "*",
+    "access-control-allow-headers": "*",
+    "access-control-allow-credentials": "true"
+  };
+};
+const http1ToHttp2Headers = (headers) => {
+  const http2Headers = {};
+  for (const [key, value] of Object.entries(headers)) {
+    switch (key.toLowerCase()) {
+      case "host":
+        http2Headers[":authority"] = value;
+        break;
+      /* HTTP/1.1-specific and WebSocket-specific headers */
+      case "connection":
+      case "upgrade":
+      case "http2-settings":
+      case "sec-websocket-key":
+      case "sec-websocket-version":
+      case "sec-websocket-protocol":
+      case "sec-websocket-extensions":
+      case "keep-alive":
+      case "transfer-encoding":
+      case "te":
+        break;
+      /* Other headers */
+      default:
+        http2Headers[key] = value;
+    }
+  }
+  return http2Headers;
+};
+const http2HeadersToHttp1Headers = (headers) => {
+  const http1Headers = {};
+  for (const [key, value] of Object.entries(headers)) {
+    switch (key) {
+      case ":authority":
+        http1Headers["host"] = value;
+        break;
+      /* HTTP/2 pseudo-headers */
+      case ":method":
+      case ":path":
+      case ":scheme":
+      case ":status":
+        break;
+      /* Other headers */
+      default:
+        http1Headers[key.replace(":", "")] = value;
+    }
+  }
+  return http1Headers;
+};
+const http = (routes, opts) => {
+  const port = opts?.port || 8080;
+  const sslOpts = opts && (opts.key || opts.cert) ? { key: opts.key, cert: opts.cert, ca: opts.ca } : void 0;
+  return (sslOpts ? createServer$1(sslOpts, routes) : createServer$2(routes)).listen(port, "0.0.0.0", () => {
+    console.log(`Server is listening on 0.0.0.0:${port}`);
+  }).on("error", async (err) => {
+    if (err && err.message.indexOf("EADDRINUSE") !== -1) {
+      console.log(`Port ${port} is already in use, attempting to kill process...`);
+      return allocatePort(port).then(() => http(routes, opts));
+    }
+    console.log("Server error: ", err);
+    throw err;
+  });
+};
+const http2 = (routes, streams, opts) => {
+  return (opts ? createSecureServer(opts, routes) : createServer(routes)).listen(opts?.port || 3e3, "0.0.0.0", () => {
+    console.log(`Server is listening on 0.0.0.0:${opts?.port || 3e3}`);
+  }).on("stream", (stream, headers, flags) => streams && streams(stream, headers, flags)).on("error", async (err) => {
+    if (err && err.message.indexOf("EADDRINUSE") !== -1) {
+      console.log(`Port ${opts?.port || 3e3} is already in use, attempting to kill process...`);
+      return allocatePort(opts?.port || 3e3).then(() => http2(routes, streams, opts));
+    }
+    console.log("Server error: ", err);
+    throw err;
+  });
+};
+const websocket = (server, routes, validate) => {
+  const wss = new WebSocketServer({
+    noServer: true,
+    verifyClient: ({ secure, req }, callback) => {
+      if (validate) {
+        const { headers, method, url, socket } = req;
+        const query = new URLSearchParams(req.url?.split("?")[1] || "");
+        const info = {
+          id: num(),
+          scheme: !!secure ? "https" : "http",
+          authority: headers.host || "",
+          origin: headers.origin || "",
+          method: method || "GET",
+          path: url || "/",
+          remoteAddress: socket.remoteAddress || "",
+          headers,
+          query,
+          type: "websocket" /* WEBSOCKET */,
+          respond: (status, headers2 = {}, body) => {
+            if (body) {
+              socket.push({ ":status": status, ...headers2, ...getCorsHeaders(info.origin) });
+              return socket.push(body);
+            }
+            socket.push({ ":status": status, ...headers2, ...getCorsHeaders(info.origin) });
+            return socket.push("");
+          },
+          end: (body) => {
+            if (body) return socket.end(body);
+            return socket.end();
+          }
+        };
+        return validate(info).then(({ status, message, code, headers: headers2 }) => {
+          console.log("Validated WebSocket request", status, code, message, headers2);
+          callback(status, code || 500, message || "Internal Server Error", headers2);
+        }).catch(() => callback(false, 500, "Internal Server Error"));
+      }
+      return callback(true);
+    }
+  });
+  server.on("upgrade", async (request, socket, upgradeHead) => {
+    return wss.handleUpgrade(
+      request,
+      socket,
+      upgradeHead,
+      (connection) => routes(request, connection, request.headers)
+    );
+  });
+  console.log("Websocket server started");
+  return wss;
+};
+
+const second = (num = 1) => {
+  return num * 1e3;
+};
+const minute = (num = 1) => {
+  return num * 60 * second();
+};
+const hour = (num = 1) => {
+  return num * 60 * minute();
+};
+const day = (num = 1) => {
+  return num * 24 * hour();
+};
+
+function isMediaFile(path) {
+  const mediaExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".mp4",
+    ".webm",
+    ".ogg",
+    ".mov",
+    ".avi",
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".aac",
+    ".m4a",
+    ".ogg",
+    ".wav",
+    ".flac",
+    ".aac",
+    ".m4a",
+    ".woff2",
+    ".woff",
+    ".ttf",
+    ".eot",
+    ".otf",
+    ".ico"
+  ];
+  return mediaExtensions.some((ext) => {
+    return path.split("?")[0].split("#")[0].toLowerCase().endsWith(ext);
+  });
+}
+
+const restAPIProxyHandler = async (req, res) => {
+  const config = getConfig();
+  const { target, ssl, remap } = config.getTarget(req.headers.host || req.headers[":authority"]?.toString() || "");
+  if (req.httpVersion === "2.0" && ssl) return;
+  if (!target) {
+    res.writeHead(404);
+    res.end("Not Found");
+    return;
+  }
+  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);
+  const proxy = requestFn(
+    `${ssl ? "https" : "http"}://${target}${req.url || ""}`,
+    {
+      ...ssl ? { ...ssl, rejectUnauthorized: false } : {},
+      method,
+      headers
+    },
+    (proxyRes) => {
+      const responseHeaders = req.httpVersion === "2.0" ? http1ToHttp2Headers(proxyRes.headers) : proxyRes.headers;
+      if (req.url && isMediaFile(req.url)) {
+        responseHeaders["cache-control"] = `public, max-age=${day()}`;
+      }
+      res.writeHead(proxyRes.statusCode || 500, responseHeaders);
+      proxyRes.on("data", (chunk) => {
+        if (!res.writableEnded && !res.closed && !res.destroyed) {
+          res.write(chunk);
+        }
+      });
+      proxyRes.on("end", () => {
+        if (!res.writableEnded && !res.closed && !res.destroyed) {
+          res.end();
+        }
+      });
+      proxyRes.on("error", (error) => {
+        console.error("Proxy response error:", error);
+        if (!res.destroyed) res.destroy(error);
+      });
+    }
+  );
+  req.on("data", (chunk) => {
+    if (!proxy.writableEnded && !proxy.closed && !proxy.destroyed) {
+      proxy.write(chunk);
+    }
+  });
+  req.on("end", () => {
+    if (!proxy.writableEnded && !proxy.closed && !proxy.destroyed) {
+      proxy.end();
+    }
+  });
+  req.on("error", (error) => {
+    console.error("Client request error:", error);
+    if (!proxy.destroyed) proxy.destroy(error);
+  });
+};
+
+const streamAPIProxyHandler = async (stream, headers) => {
+  const config = getConfig();
+  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 (remap) headers[":path"] = remap(headers[":path"] || "");
+  console.log("Proxy Request::", headers[":path"]);
+  const proxy = connect(`https://${target}${headers[":path"]}`, {
+    ...ssl,
+    rejectUnauthorized: false
+  });
+  proxy.on("connect", () => {
+    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 (headers[":path"] && isMediaFile(headers[":path"])) {
+          headerResponse["cache-control"] = `public, max-age=${day()}`;
+        }
+        stream.respond(headerResponse);
+      }
+    });
+    stream.on("data", (chunk) => {
+      if (!request.writableEnded && !request.closed && !request.destroyed) {
+        request.write(chunk);
+      }
+    });
+    stream.on("end", () => {
+      if (!request.writableEnded && !request.closed && !request.destroyed) {
+        request.end();
+      }
+    });
+    stream.on("close", () => {
+      if (!request.closed && !request.destroyed) request.close();
+    });
+    stream.on("goaway", (_, errorCode) => {
+      if (errorCode && !request.destroyed) {
+        request.destroy(new Error(`HTTP/2 connection closed with error code ${errorCode}`));
+      }
+      if (!stream.closed && !stream.destroyed) stream.close();
+    });
+    stream.on("error", (error) => {
+      console.error("HTTP2 stream proxy error:", error);
+      if (!request.destroyed) request.destroy(error);
+      if (!proxy.closed) proxy.close();
+    });
+    request.on("data", (chunk) => {
+      if (!stream.writableEnded && !stream.closed && !stream.destroyed) {
+        stream.write(chunk);
+      }
+    });
+    request.on("end", () => {
+      if (!stream.writableEnded && !stream.closed && !stream.destroyed) {
+        stream.end();
+      }
+    });
+    request.on("close", () => {
+      if (!stream.closed && !stream.destroyed) stream.close();
+    });
+    request.on("error", (error) => {
+      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 (!stream.destroyed) stream.destroy(new Error("HTTP/2 client timeout"));
+    });
+  });
+  proxy.on("error", (error) => {
+    console.error("HTTP2 proxy connection error:", error);
+    if (!stream.destroyed) {
+      stream.destroy(error);
+    }
+  });
+};
+
+const websocketAPIProxyHandler = async (req, socket, headers) => {
+  const config = getConfig();
+  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 (remap) req.url = remap(req.url || "");
+  const proxy = new WebSocket(
+    `${ssl ? "wss" : "ws"}://${target}${req.url || ""}`,
+    req.headers["sec-websocket-protocol"]?.split(",").map((p) => p.trim()),
+    {
+      ...ssl ? { ...ssl, rejectUnauthorized: false } : {},
+      headers: req.headers,
+      host: req.headers.host,
+      origin: req.headers.origin,
+      protocol: req.headers["sec-websocket-protocol"]
+    }
+  );
+  proxy.on("message", (message) => {
+    if (message.toString("utf8").startsWith("{")) {
+      socket.send(message.toString("utf8"));
+    } else {
+      socket.send(message);
+    }
+  });
+  socket.on("message", (message) => proxy.send(message));
+  proxy.on("close", () => socket.close());
+  socket.on("close", () => proxy.close());
+  proxy.on("error", (error) => {
+    console.error("WebSocket proxy error:", error);
+    socket.close();
+  });
+};
+
+class ProxyServer {
+  config;
+  servers = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Start the proxy server
+   */
+  async start() {
+    const ssl = this.config.getSSL();
+    const ports = this.config.getPorts();
+    const logStartup = () => {
+      console.log("STARTING PROXY SERVER....");
+      console.log("Ports:", ports);
+      console.log("SSL:", !!ssl);
+      return { ssl, ports };
+    };
+    const createServers = ({ ssl: ssl2, ports: ports2 }) => {
+      for (const port of ports2) {
+        let server;
+        if (ssl2) {
+          server = http2(restAPIProxyHandler, streamAPIProxyHandler, { ...ssl2, port });
+        } else {
+          server = http(restAPIProxyHandler, { port });
+        }
+        websocket(server, websocketAPIProxyHandler, (info) => this.config.validate(info));
+        this.servers.push(server);
+      }
+      return this.servers;
+    };
+    const logSuccess = () => {
+      console.log("Proxy server started successfully");
+    };
+    const handleError = (error) => {
+      console.error("Failed to start proxy server:", error);
+      throw error;
+    };
+    return Promise.resolve().then(() => logStartup()).then((config) => createServers(config)).then(() => logSuccess()).catch((error) => handleError(error));
+  }
+  /**
+   * Stop the proxy server
+   */
+  async stop() {
+    console.log("Stopping proxy server...");
+    for (const server of this.servers) {
+      server.close();
+    }
+    this.servers = [];
+    console.log("Proxy server stopped");
+  }
+  /**
+   * Get the configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+}
+function createProxy(config) {
+  const createProxyInstance = () => {
+    return new ProxyServer(loadConfig(config));
+  };
+  const startProxy = (proxy) => {
+    return proxy.start().then(() => proxy);
+  };
+  return Promise.resolve().then(() => createProxyInstance()).then((proxy) => startProxy(proxy));
+}
+function createCustomProxy(config, handlers) {
+  const servers = [];
+  const initializeConfig = () => {
+    const proxyConfig = loadConfig(config);
+    return {
+      ssl: proxyConfig.getSSL(),
+      ports: proxyConfig.getPorts(),
+      proxyConfig
+    };
+  };
+  const logStartup = (cfg) => {
+    console.log("STARTING CUSTOM PROXY SERVER....");
+    return cfg;
+  };
+  const createServers = ({ ssl, ports, proxyConfig }) => {
+    for (const port of ports) {
+      let server;
+      if (ssl) {
+        server = http2(handlers.rest || restAPIProxyHandler, handlers.stream || streamAPIProxyHandler, {
+          ...ssl,
+          port
+        });
+      } else {
+        server = http(handlers.rest || restAPIProxyHandler, { port });
+      }
+      websocket(server, handlers.websocket || websocketAPIProxyHandler);
+      servers.push(server);
+    }
+    return proxyConfig;
+  };
+  const createProxyInstance = (proxyConfig) => {
+    console.log("Custom proxy server started successfully");
+    return {
+      getConfig: () => proxyConfig,
+      start: async () => {
+      },
+      stop: async () => {
+        for (const server of servers) {
+          server.close();
+        }
+      }
+    };
+  };
+  const handleError = (error) => {
+    console.error("Failed to start custom proxy server:", error);
+    throw error;
+  };
+  return Promise.resolve().then(() => initializeConfig()).then((cfg) => logStartup(cfg)).then((cfg) => createServers(cfg)).then((proxyConfig) => createProxyInstance(proxyConfig)).catch((error) => handleError(error));
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const setupErrorHandlers = () => {
+    process.on("uncaughtException", function(error) {
+      console.log("UNCAUGHT EXCEPTION: ", error);
+    });
+    process.on("unhandledRejection", function(reason, promise) {
+      console.log("UNHANDLED REJECTION: ", reason, promise);
+    });
+  };
+  const startProxyServer = () => {
+    return createProxy();
+  };
+  const handleStartupError = (error) => {
+    console.error("Failed to start proxy server:", error);
+    process.exit(1);
+  };
+  setupErrorHandlers();
+  Promise.resolve().then(() => startProxyServer()).catch((error) => handleStartupError(error));
+}
+
+export { ProxyServer, RequestType, createCustomProxy, createProxy, getConfig, loadConfig, restAPIProxyHandler, streamAPIProxyHandler, websocketAPIProxyHandler };

package/dist/utils/config.d.ts

@@ -0,0 +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';
+import 'node:http2';
+import 'node:tls';
+import 'ws';