mega-stream-proxy 0.1.9

package/src/proxy/native.ts

@@ -0,0 +1,396 @@
+/**
+ * Android / iOS streaming proxy. Binds a local HTTP-ish TCP server on
+ * 127.0.0.1 so the OS video player can request DECRYPTED byte ranges (HTTP
+ * Range) without writing files to device storage. Each connection is answered
+ * by piping the truncated, decrypted megajs download stream back to the socket.
+ *
+ * Single-file: `createStream(url)` registers one route -> one playable URL.
+ *  - stitched:    `createStreams(urls)` -> `/part-N.mp4` URLs, played
+ *                   in sequence by the app's player.
+ *
+ * All requests are routed by a keyed session id (`/<sessionId>/<name>`). The
+ * TCP server is a singleton bound once per app lifetime via `ensureProxy()`;
+ * sessions come and go independently, and `releaseStream(sessionId)` tears a
+ * single route down without touching the others.
+ *
+ * Multi-part files are NOT byte-concatenated: each part has its own moov with
+ * part-relative sample offsets, so playback advances part by part instead.
+ *
+ * Platform: React Native only. Requires the `react-native-tcp-socket` peer.
+ */
+import TcpSocket from "react-native-tcp-socket";
+import { Buffer } from "buffer";
+import { loadMegaFile } from "../megaFile.js";
+import { parseRange, rangeHeaders, type RangeResult } from "../ranges.js";
+import type { MegaFileLike } from "./types.js";
+
+/** Structural types decoupled from react-native-tcp-socket's odd type surface. */
+type TcpServerLike = {
+  on: (event: string, cb: (...args: any[]) => void) => TcpServerLike;
+  removeListener: (event: string, cb: (...args: any[]) => void) => TcpServerLike;
+  listen: (opts: { port: number; host?: string }, cb?: () => void) => void;
+  address: () => { port: number; address?: string; family?: string } | string | null;
+  close: (cb?: () => void) => void;
+};
+
+type TcpSocketLike = {
+  on: (event: string, cb: (...args: any[]) => void) => TcpSocketLike;
+  write: (data: string | Uint8Array) => boolean;
+  end: () => void;
+  destroy: () => void;
+};
+
+type TcpModule = {
+  createServer: (
+    options: { noDelay?: boolean },
+    cb?: (socket: unknown) => void,
+  ) => TcpServerLike;
+};
+
+const tcp = TcpSocket as unknown as TcpModule;
+const createServer = tcp.createServer;
+
+type ServePart = { name: string; file: MegaFileLike; size: number };
+
+type ParsedRequest = {
+  method: string;
+  target: string;
+  headers: Record<string, string>;
+};
+
+/** One registered route: an ordered set of playable parts (single file = one part). */
+type Session = {
+  parts: ServePart[];
+};
+
+let server: TcpServerLike | null = null;
+let proxyBase = "";
+let proxyReady: Promise<void> | null = null;
+const sessions = new Map<string, Session>();
+let sessionCounter = 0;
+
+/** Collision-resistant session key: time base + monotonic counter + random tail. */
+function newSessionId(): string {
+  sessionCounter += 1;
+  const t = Date.now().toString(36);
+  const c = sessionCounter.toString(36);
+  const r = Math.random().toString(36).slice(2, 6);
+  return `${t}${c}${r}`;
+}
+
+/** Coerce whatever the socket hands us (Buffer, Uint8Array, ArrayBuffer, string, array). */
+function toBytes(data: unknown): Uint8Array {
+  if (typeof data === "string") {
+    const out = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i++) out[i] = data.charCodeAt(i) & 0xff;
+    return out;
+  }
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (Array.isArray(data)) return Uint8Array.from(data);
+  return new Uint8Array(0);
+}
+
+/** Latin-1 decode: polyfill-proof byte -> char conversion for header parsing. */
+function bytesToText(bytes: Uint8Array): string {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += String.fromCharCode(bytes[i]);
+  return out;
+}
+
+function findDoubleCrlf(bytes: Uint8Array): number {
+  for (let i = 0; i < bytes.length - 3; i++) {
+    if (
+      bytes[i] === 13 &&
+      bytes[i + 1] === 10 &&
+      bytes[i + 2] === 13 &&
+      bytes[i + 3] === 10
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function parseHttpHead(head: string): ParsedRequest {
+  const lines = head.split("\r\n");
+  const parts = (lines[0] ?? "").split(" ");
+  const headers: Record<string, string> = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      headers[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
+    }
+  }
+  return { method: parts[0] ?? "", target: parts[1] ?? "", headers };
+}
+
+function serveError(socket: TcpSocketLike, status: number, reason: string): void {
+  const body = `${status} ${reason}`;
+  const head = [
+    `HTTP/1.1 ${status} ${reason}`,
+    "Content-Type: text/plain",
+    `Content-Length: ${body.length}`,
+    "Cache-Control: no-store",
+    "Connection: close",
+    "",
+    "",
+  ].join("\r\n");
+  socket.write(head + body);
+  socket.end();
+}
+
+function handleConnection(socket: TcpSocketLike): void {
+  const buf: number[] = [];
+  let handled = false;
+
+  socket.on("data", (data: unknown) => {
+    if (handled) return;
+    const bytes = toBytes(data);
+    for (let i = 0; i < bytes.length; i++) buf.push(bytes[i]);
+
+    const headEnd = findDoubleCrlf(Uint8Array.from(buf));
+    if (headEnd === -1) {
+      if (buf.length > 64 * 1024) {
+        handled = true;
+        serveError(socket, 400, "Bad Request");
+      }
+      return;
+    }
+
+    handled = true;
+    const head = bytesToText(Uint8Array.from(buf.slice(0, headEnd)));
+    handleRequest(socket, parseHttpHead(head));
+  });
+
+  socket.on("error", () => {});
+  socket.on("close", () => {});
+}
+
+/** Serves one file (a MEGA link or one stitched part) over a socket, honoring Range. */
+function serveSingleFile(socket: TcpSocketLike, req: ParsedRequest, file: MegaFileLike, size: number): void {
+  if (size <= 0) return serveError(socket, 503, "Stream has no size");
+
+  const range: RangeResult = parseRange(req.headers.range, size);
+  if (!range.satisfiable) return serveError(socket, 416, "Range Not Satisfiable");
+
+  const headers = rangeHeaders(range, size, "video/mp4");
+  const statusLine = range.partial ? "HTTP/1.1 206 Partial Content" : "HTTP/1.1 200 OK";
+  const head = [
+    statusLine,
+    ...Object.entries(headers).map(([k, v]) => `${k}: ${v}`),
+    "Connection: close",
+    "",
+    "",
+  ].join("\r\n");
+
+  if (req.method === "HEAD") {
+    socket.write(head);
+    socket.end();
+    return;
+  }
+
+  console.log(
+    `[megaStream] ${req.method} ${req.target} ${req.headers.range ?? "full"} -> ${range.start}-${range.end} of ${size}`,
+  );
+
+  const stream = file.download({
+    start: range.start,
+    end: range.end,
+    // Do NOT use maxConnections: 1 — that path pipes a streaming body which
+    // React Native's fetch layer cannot provide. The default multi-connection
+    // path reads chunks via arrayBuffer(), the proven working path.
+    maxConnections: 4,
+  });
+
+  let headSent = false;
+  let socketClosed = false;
+
+  const closeSocket = () => {
+    if (socketClosed) return;
+    socketClosed = true;
+    try {
+      socket.end();
+    } catch {}
+  };
+
+  const teardown = () => {
+    if (socketClosed) return;
+    socketClosed = true;
+    try {
+      stream.destroy?.();
+    } catch {}
+    try {
+      socket.destroy();
+    } catch {}
+  };
+
+  stream.on("data", (chunk: Uint8Array) => {
+    if (socketClosed) return;
+    if (!headSent) {
+      headSent = true;
+      try {
+        socket.write(head);
+      } catch {
+        teardown();
+        return;
+      }
+    }
+    try {
+      const bytes =
+        chunk instanceof Uint8Array
+          ? chunk
+          : new Uint8Array((chunk as ArrayBufferLike)?.byteLength ?? 0);
+      if (!socket.write(Buffer.isBuffer(chunk) ? chunk : bytes)) {
+        stream.pause?.();
+      }
+    } catch {
+      teardown();
+    }
+  });
+
+  socket.on("drain", () => {
+    if (!socketClosed) stream.resume?.();
+  });
+  stream.on("end", () => closeSocket());
+  stream.on("error", (err: Error) => {
+    console.warn("[megaStream] stream error:", err?.message ?? err);
+    teardown();
+  });
+  socket.on("close", () => teardown());
+  socket.on("error", () => teardown());
+}
+
+function handleRequest(socket: TcpSocketLike, req: ParsedRequest): void {
+  console.log(
+    `[megaStream] <- ${req.method || "(none)"} ${req.target || "(none)"} range=${req.headers.range ?? "none"}`,
+  );
+  if (req.method && req.method !== "GET" && req.method !== "HEAD") {
+    console.warn(`[megaStream] unexpected method ${req.method} — serving as GET`);
+  }
+
+  const [sessionId, name] = req.target.replace(/^\//, "").split(/\?|#/)[0].split("/", 2);
+  if (!sessionId) return serveError(socket, 404, "Not Found");
+
+  const session = sessions.get(sessionId);
+  if (!session) return serveError(socket, 404, `No stream session ${sessionId}`);
+
+  if (name) {
+    const part = session.parts.find((p) => p.name === name);
+    if (!part) return serveError(socket, 404, `Not Found: ${name}`);
+    return serveSingleFile(socket, req, part.file, part.size);
+  }
+  return serveError(socket, 404, "Not Found");
+}
+
+async function bindProxyServer(): Promise<TcpServerLike> {
+  const srv = createServer({ noDelay: true }, (socket: unknown) =>
+    handleConnection(socket as TcpSocketLike),
+  );
+  await new Promise<void>((resolve, reject) => {
+    const onErr = (e: Error) => {
+      srv.removeListener("error", onErr);
+      reject(e);
+    };
+    srv.on("error", onErr);
+    srv.listen({ port: 0, host: "127.0.0.1" }, () => {
+      srv.removeListener("error", onErr);
+      resolve();
+    });
+  });
+  return srv;
+}
+
+/**
+ * Idempotent: binds the singleton local proxy server once per app lifetime.
+ * Safe to call concurrently and repeatedly — subsequent calls are no-ops until
+ * `stopProxy()` is called. Does not load any MEGA file.
+ */
+export async function ensureProxy(): Promise<void> {
+  if (server) return;
+  if (proxyReady) return proxyReady;
+  proxyReady = (async () => {
+    const srv = await bindProxyServer();
+    const addr = srv.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    if (!port) throw new Error("Failed to bind local stream server");
+    server = srv;
+    proxyBase = `http://127.0.0.1:${port}`;
+    console.log(`[megaStream] proxy listening on ${proxyBase}`);
+  })().catch((e) => {
+    proxyReady = null; // allow a retry after a failed bind
+    throw e;
+  });
+  return proxyReady;
+}
+
+/** Registers one MEGA link as its own keyed session; returns its local URL. */
+export async function createStream(megaUrl: string): Promise<{ url: string; sessionId: string }> {
+  if (!megaUrl?.trim()) throw new Error("No MEGA file to stream.");
+  await ensureProxy();
+
+  const file = await loadMegaFile(megaUrl);
+  if (!file.size) throw new Error("MEGA file has no size");
+
+  const sessionId = newSessionId();
+  const name = file.name || "stream.mp4";
+  sessions.set(sessionId, { parts: [{ name, file, size: file.size }] });
+
+  const url = `${proxyBase}/${sessionId}/${name}`;
+  console.log(`[megaStream] session ${sessionId}: serving '${name}' via ${url}`);
+  return { url, sessionId };
+}
+
+/**
+ * Loads all MEGA parts and serves each at its own `/part-N.mp4` URL inside one
+ * session. Returns the ordered local URLs the player should play in sequence,
+ * plus the session id to release later. Nothing is written to disk; every byte
+ * range is streamed from MEGA as the player reads it.
+ */
+export async function createStreams(
+  megaUrls: string[],
+): Promise<{ urls: string[]; sessionId: string }> {
+  const clean = (megaUrls ?? []).map((u) => u?.trim()).filter(Boolean);
+  if (!clean.length) throw new Error("No video parts to stream.");
+  await ensureProxy();
+
+  const parts: ServePart[] = [];
+  for (let i = 0; i < clean.length; i++) {
+    const file = await loadMegaFile(clean[i]);
+    if (!file.size) throw new Error("MEGA part has no size.");
+    parts.push({ name: `part-${i}.mp4`, file, size: file.size });
+  }
+  if (!parts.length) throw new Error("No streamable parts found.");
+
+  const sessionId = newSessionId();
+  sessions.set(sessionId, { parts });
+
+  const urls = parts.map((p) => `${proxyBase}/${sessionId}/${p.name}`);
+  console.log(
+    `[megaStream] session ${sessionId}: streaming ${parts.length} parts (${parts.map((p) => p.size).join(",")}) via ${urls[0]}`,
+  );
+  return { urls, sessionId };
+}
+
+/** Removes one session; other sessions and the singleton server keep running. */
+export function releaseStream(sessionId: string): void {
+  if (!sessionId || !sessions.has(sessionId)) return;
+  sessions.delete(sessionId);
+  console.log(`[megaStream] released session ${sessionId}`);
+}
+
+/** Tear-down for tests / HMR: unbinds the server and clears every session. */
+export function stopProxy(): void {
+  sessions.clear();
+  if (server) {
+    try {
+      server.close();
+    } catch {}
+    server = null;
+  }
+  proxyBase = "";
+  proxyReady = null;
+}

package/src/proxy/sw/bundle.ts

@@ -0,0 +1,37 @@
+/**
+ * Access to the bundled Service Worker assets (sw.js + megajs.browser.js).
+ * Consumers (web / Expo / static hosts) copy these into their `public/` (or
+ * equivalent) so the client from `mega-stream-proxy/web` can register them.
+ */
+import { copyFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SW_MARKER } from "../../swDefine.js";
+
+export { SW_MARKER };
+
+/** Paths of the bundled files inside this package (dist/proxy/sw). */
+export function swAssetPaths(): { sw: string; megajs: string; marker: string } {
+  const dir = dirname(fileURLToPath(import.meta.url));
+  return { sw: join(dir, "sw.js"), megajs: join(dir, "megajs.browser.js"), marker: SW_MARKER };
+}
+
+export type CopiedSwAssets = { sw: string; megajs: string; marker: string };
+
+/**
+ * Copies `sw.js` and `megajs.browser.js` into `outDir` (e.g. your `public/`
+ * or `web/` folder). Both files must be served from the same directory as the
+ * worker script so the SW can `importScripts("./megajs.browser.js")`.
+ *
+ * Returns the destination paths + the URL marker the client will use.
+ */
+export function copySwAssets(outDir: string): CopiedSwAssets {
+  const src = swAssetPaths();
+  mkdirSync(outDir, { recursive: true });
+  const sw = join(outDir, "sw.js");
+  const megajs = join(outDir, "megajs.browser.js");
+  copyFileSync(src.sw, sw);
+  copyFileSync(src.megajs, megajs);
+  console.log(`[megaStream] copied sw.js + megajs.browser.js -> ${outDir}`);
+  return { sw, megajs, marker: SW_MARKER };
+}