Refactor env var access to simplify logic

This commit refactors how environment variables are accessed across
different runtimes (Bun, Node.js, and browser) to simplify the logic. It
also consolidates the checks for `IS_BUN || IS_NODE` where appropriate,
as the access method is the same for both.

Additionally, it removes an unnecessary environment variable
`NODE_TLS_REJECT_UNAUTHORIZED` from the `frontendV3` Vercel
configuration. A new `workers-proxy.ts` file has been added to manage
proxying for Cloudflare Workers.

src/index.ts

@@ -9,11 +9,17 @@ import { FfmpegRouter } from "./sub-router/ffmpeg";
 import { ShowtimeRouter } from "./sub-router/showtime";
 import { TestRouter } from "./sub-router/test";
 import { NS_runtime } from "../../../../packages/lib/env.runtime";
+import { NS_workers_proxy } from "../../../../packages/lib/proxy-server/workers-proxy";
+
+const { rewriteWorkersUrl, startWorkersProxy, rewriteWorkersUrl_t2, get_dns } =
+  NS_workers_proxy;
 
 const APP_ENV = process.env.APP_ENV;
 const APP_ORIGIN = process.env.APP_ORIGIN;
 const PORT = process.env.PORT;
 
+await startWorkersProxy();
+
 const app = new Elysia()
 
   .use(
@@ -64,10 +70,31 @@ const app = new Elysia()
   .use(FfmpegRouter)
   .use(TestRouter)
 
-  .get("/", () => {
+  .get("/", async ({ request }) => {
     return "🦊 Hello Rafiki 🍿";
   })
 
+  .get("/test/p", async ({ request }) => {
+    const originalUrl =
+      "https://cool.tylerfisher55.workers.dev/afc7d47f/uz5gyMPGU9TVujalv1-l0gCq1t5YoLPmJOs0BK8vPdXqyusELznNCnUjCjs93MmANIYp__VYV9NVMM33xaH8-hxFDOQjzy6xGM8xf6yfw1YOmJhdwv2R3fFOXPVk90JFUhfo-oz1cLaYBHPnU0wPrb84UsIVRnunq3UKDSpFMLVBnEy7VJtuHl7T90GpI0EcY_xtuRtQguJ7pQqdKgGVJRP7_urSkYuXf-zAySLgY6isRw-vKYh1EnOLybifGW5Q8AT-r-BlvwNe4vDMjJ3blHFeAsSS2Z3XMfOdM0dQbJwO7o4igwfpIVILbI2YkKuRzIbaWTMXAe7f9vKUJpS5cXEG5UB3EwOm_-yobxVKvrPZqcdrG-Qteh16fTl9Ll7PiYwlA-Ebc2S0QlEWRAXsB0IZd3ixrCxSqSfHZwF6p38FGC0EeNUqW_enbS8BA_kGQhiA9q9Z4P2yxF5CN5-WBTXw6O8UMygbUNhoi-BWnk02DRu0oeyEoE2OGVrN-zRP2KNGOejNL-BbmcLd9yB0qP1Z1RF8wszuFx8x6iQUuIXCXUSGzxZAQie3dELhVWFKSj__CqTSgk8adDCyd8mYLnHzh1jFpSlDDOwF65blF6rmWcYZmgfHcSIe9mIgpkRE0zPF5J_AcvKdYSoILfKj2kzpaF_yI8DceEqCWsDojyzMQi7YO02EMx8MdmtqG9BnHtto7tEiVWZnOQJyc6BinQ.m3u8";
+
+    await get_dns({
+      target: originalUrl,
+      method: "GET",
+      headers: {
+        Referer: "https://111movies.net/"
+      }
+    });
+
+    const foo = rewriteWorkersUrl_t2(originalUrl);
+
+    const res = await fetch(foo, {
+      method: "GET"
+    });
+
+    return res;
+  })
+
   .listen({
     port: PORT || 7860,
     ...(NS_runtime.IS_PROD && { hostname: "0.0.0.0" }),

src/proxy/workers-proxy.ts

@@ -0,0 +1,239 @@
+import * as https from "node:https";
+import * as http from "node:http";
+
+export const PROXY_PORT = 18080;
+let proxyServer: http.Server | null = null;
+
+const REPO_ORIGIN = process.env.REPO_ORIGIN;
+
+// Registry of active proxy targets — keyed by servername
+const targetRegistry = new Map<
+  string,
+  {
+    hostname: string;
+    port: number;
+    servername: string;
+    headers: Record<string, string>;
+    path: string;
+    method: string;
+  }
+>();
+
+export function registerProxyTarget(config: {
+  hostname: string;
+  port: number;
+  servername: string;
+  headers: Record<string, string>;
+  path: string;
+  method: string;
+}) {
+  targetRegistry.set(config.servername, config);
+}
+
+export async function get_dns(arg0: {
+  target: string;
+  method: string;
+  headers: Record<string, string>;
+}) {
+  if (!REPO_ORIGIN) return;
+  try {
+    const { target, headers, method } = arg0;
+
+    const res = await fetch(`${REPO_ORIGIN}/dns/resolve`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ target, method, headers })
+    });
+    const data = await res.json();
+
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      registerProxyTarget({
+        ...data
+      });
+
+      return data;
+    }
+  } catch {}
+}
+
+export function rewriteWorkersUrl(originalUrl: string): string {
+  try {
+    const u = new URL(originalUrl);
+    if (u.hostname.endsWith(".workers.dev")) {
+      return `http://127.0.0.1:${PROXY_PORT}/__proxy__/${u.hostname}${u.pathname}${u.search}`;
+    }
+  } catch {}
+  return originalUrl;
+}
+
+export function rewriteWorkersUrl_t2(originalUrl: string): string {
+  try {
+    const is_http = originalUrl.startsWith("http");
+
+    if (!is_http) return originalUrl;
+
+    const start_http = originalUrl.startsWith("https://")
+      ? "https://"
+      : "http://";
+    const rest = originalUrl.replace(start_http, "");
+
+    if (rest) return `http://127.0.0.1:${PROXY_PORT}/__proxy__/${rest}`;
+
+    return originalUrl;
+  } catch {}
+  return originalUrl;
+}
+
+function isM3u8(headers: http.IncomingHttpHeaders): boolean {
+  const ct = headers["content-type"] ?? "";
+  // Also check path-based detection as some servers return wrong content-type
+  return ct.includes("mpegurl") || ct.includes("x-mpegurl");
+}
+
+function rewriteM3u8Body(body: string): string {
+  console.log({ body });
+  return body.replace(
+    /https?:\/\/([a-zA-Z0-9._-]+\.workers\.dev)(:[0-9]+)?([^\s"'\n]*)/g,
+    (_, host, _port, rest) =>
+      `http://127.0.0.1:${PROXY_PORT}/__proxy__/${host}${rest}`
+  );
+}
+
+export async function startWorkersProxy(): Promise<void> {
+  if (proxyServer) return Promise.resolve(); // already running
+
+  return new Promise((resolve, reject) => {
+    proxyServer = http.createServer((req, res) => {
+      // Parse target host from /__proxy__/<host>/path or Host header
+      let targetHost: string;
+      let targetPath: string;
+
+      const proxyPrefixMatch = req.url?.match(/^\/__proxy__\/([^/]+)(\/.*)?$/);
+
+      if (proxyPrefixMatch) {
+        targetHost = proxyPrefixMatch[1];
+        targetPath = proxyPrefixMatch[2] ?? "/";
+        // Preserve query string
+        const qIndex = (req.url ?? "").indexOf(
+          "?",
+          `/__proxy__/${targetHost}`.length
+        );
+        if (qIndex !== -1) {
+          targetPath = proxyPrefixMatch[2]?.split("?")[0] ?? "/";
+          targetPath += req.url!.slice(qIndex);
+        }
+      } else {
+        targetHost = (req.headers["host"] ?? "").split(":")[0];
+        targetPath = req.url ?? "/";
+      }
+
+      if (!targetHost.endsWith(".workers.dev")) {
+        res.writeHead(400);
+        res.end(`[workers-proxy] unexpected host: ${targetHost}`);
+        return;
+      }
+
+      // Look up registered target or fall back to Cloudflare Anycast
+      const registered = (() => {
+        const _ = targetRegistry.get(targetHost);
+
+        return _;
+      })();
+
+      if (!registered) {
+        console.error(
+          `[workers-proxy] no registered target for: ${targetHost}`
+        );
+        res.writeHead(502);
+        res.end(`[workers-proxy] no registered target for: ${targetHost}`);
+        return;
+      }
+
+      const targetIp = registered.hostname;
+      const extraHeaders = registered.headers ?? {};
+
+      const options: https.RequestOptions = {
+        hostname: targetIp,
+        port: registered.port || 443,
+        path: registered.path || targetPath,
+        method: registered.method || req.method, // registered.method
+        servername: registered.servername || targetHost, // SNI
+        rejectUnauthorized: false,
+        headers: {
+          // ...req.headers,
+          ...extraHeaders,
+          Host: targetHost,
+          host: targetHost
+        }
+      };
+
+      console.log(
+        `[workers-proxy] ${req.method} ${targetHost}${targetPath} → ${targetIp}`
+      );
+
+      const proxyReq = https.request(options, (proxyRes) => {
+        const isPlaylist =
+          isM3u8(proxyRes.headers) ||
+          targetPath.includes(".m3u8") ||
+          targetPath.includes(".m3u");
+
+        if (isPlaylist) {
+          const chunks: Buffer[] = [];
+          proxyRes.on("data", (chunk) => chunks.push(chunk));
+          proxyRes.on("end", () => {
+            const original = Buffer.concat(chunks).toString("utf8");
+            const rewritten = rewriteM3u8Body(original);
+
+            console.log({ rewritten });
+
+            const responseHeaders: Record<string, any> = {
+              ...proxyRes.headers,
+              "content-length": Buffer.byteLength(rewritten).toString(),
+              "content-encoding": undefined // decoded already
+            };
+            // Remove undefined keys
+            Object.keys(responseHeaders).forEach(
+              (k) =>
+                responseHeaders[k] === undefined && delete responseHeaders[k]
+            );
+
+            res.writeHead(proxyRes.statusCode ?? 502, responseHeaders);
+            res.end(rewritten);
+          });
+        } else {
+          // Segments — stream straight through, no buffering
+          res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+          proxyRes.pipe(res);
+        }
+      });
+
+      proxyReq.on("error", (err) => {
+        console.error(`[workers-proxy] error for ${targetHost}:`, err.message);
+        if (!res.headersSent) {
+          res.writeHead(502);
+          res.end("Proxy error: " + err.message);
+        }
+      });
+
+      req.pipe(proxyReq);
+    });
+
+    proxyServer.listen(PROXY_PORT, "127.0.0.1", () => {
+      console.log(
+        `[workers-proxy] listening on http://127.0.0.1:${PROXY_PORT}`
+      );
+      resolve();
+    });
+
+    proxyServer.on("error", reject);
+  });
+}
+
+export function stopWorkersProxy(): Promise<void> {
+  return new Promise((resolve) => {
+    if (proxyServer) proxyServer.close(() => resolve());
+    else resolve();
+  });
+}