mega-stream-proxy 0.1.9

package/dist/accounts/manager.js

@@ -0,0 +1,149 @@
+const VIDEO_EXT = /\.(mp4|mkv|avi|mov|webm|m4v|ts|flv|wmv|mpg|mpeg|3gp)$/i;
+const SUBTITLE_EXT = /\.(srt|ass|ssa|vtt)$/i;
+function nextId() {
+    try {
+        return globalThis.crypto?.randomUUID?.() ?? fallbackId();
+    }
+    catch {
+        return fallbackId();
+    }
+}
+function fallbackId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+ * Owns the MEGA accounts list (via a pluggable store) plus the live megajs
+ * `Storage` sessions used while browsing a saved account's cloud drive.
+ */
+export class MegaAccountManager {
+    store;
+    sessions = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    /* ------------------------- account CRUD ------------------------- */
+    async listAccounts() {
+        return this.store.list();
+    }
+    subscribe(cb) {
+        return this.store.subscribe?.(cb) ?? (() => { });
+    }
+    async addAccount(input) {
+        const account = {
+            id: nextId(),
+            email: input.email.trim(),
+            password: input.password,
+            label: (input.label ?? "").trim(),
+            createdAt: Date.now(),
+        };
+        await this.store.save(account);
+        return account;
+    }
+    async deleteAccount(id) {
+        this.closeSession(id);
+        await this.store.remove(id);
+    }
+    /* ------------------------- sessions ------------------------- */
+    async openStorage(account) {
+        const existing = this.sessions.get(account.id);
+        if (existing)
+            return existing;
+        const p = (async () => {
+            const { Storage } = (await import("megajs"));
+            const storage = new Storage({
+                email: account.email.trim(),
+                password: account.password,
+                userAgent: "mega-stream-proxy",
+            });
+            await storage.ready;
+            return storage;
+        })();
+        this.sessions.set(account.id, p);
+        p.catch(() => this.sessions.delete(account.id));
+        return p;
+    }
+    closeSession(accountId) {
+        const p = this.sessions.get(accountId);
+        this.sessions.delete(accountId);
+        p?.then((s) => {
+            try {
+                s.close();
+            }
+            catch { }
+        });
+    }
+    closeAll() {
+        for (const id of [...this.sessions.keys()])
+            this.closeSession(id);
+    }
+    /** login only — verifies credentials and counts the cloud drive. */
+    async testAccount(account) {
+        const { Storage } = (await import("megajs"));
+        const storage = new Storage({
+            email: account.email.trim(),
+            password: account.password,
+            userAgent: "mega-stream-proxy",
+        });
+        await storage.ready;
+        let folders = 0;
+        let files = 0;
+        for (const node of Object.values(storage.files ?? {})) {
+            if (node.directory)
+                folders += 1;
+            else
+                files += 1;
+        }
+        const result = { name: storage.name ?? account.email, folders, files };
+        try {
+            storage.close();
+        }
+        catch { }
+        return result;
+    }
+    /** Full Cloud-Drive tree of a saved account, root first. */
+    async loadTree(account) {
+        const storage = await this.openStorage(account);
+        const out = [];
+        const walk = (node, parentPath) => {
+            const isFolder = Boolean(node.directory);
+            const name = String(node.name ?? "");
+            const path = parentPath ? `${parentPath}/${name}` : name;
+            out.push({
+                handle: String(node.nodeId ?? name),
+                name,
+                isFolder,
+                isVideo: !isFolder && VIDEO_EXT.test(name),
+                isSubtitle: !isFolder && SUBTITLE_EXT.test(name),
+                size: Number(node.size ?? 0),
+                path,
+            });
+            if (!isFolder || !Array.isArray(node.children))
+                return;
+            for (const child of node.children)
+                walk(child, path);
+        };
+        const root = storage.root;
+        if (root && Array.isArray(root.children)) {
+            for (const child of root.children)
+                walk(child, "");
+        }
+        return out.filter((n) => n.isFolder || n.isVideo || n.isSubtitle);
+    }
+    /** Export a shareable link (with key) for a file inside the logged-in account. */
+    async exportLink(account, handle) {
+        const storage = await this.openStorage(account);
+        const node = storage.files?.[handle];
+        if (!node)
+            throw new Error("File not found in this MEGA account.");
+        if (typeof node.link !== "function")
+            throw new Error("Node has no link method.");
+        return new Promise((resolve, reject) => {
+            node.link?.((err, link) => {
+                if (err || !link)
+                    reject(err ?? new Error("Failed to generate link"));
+                else
+                    resolve(link);
+            });
+        });
+    }
+}

package/dist/accounts/types.d.ts

@@ -0,0 +1,35 @@
+/** A saved MEGA account (credentials + label). Passwords are handled by the store. */
+export type MegaAccount = {
+    id: string;
+    email: string;
+    password: string;
+    label: string;
+    createdAt: number;
+};
+/**
+ * Pluggable persistence for MEGA accounts. Bring your own backend (Firestore,
+ * AsyncStorage, localStorage, …) by implementing this interface.
+ */
+export type MegaAccountStore = {
+    list: () => Promise<MegaAccount[]>;
+    /** Upsert by id. */
+    save: (account: MegaAccount) => Promise<void>;
+    remove: (id: string) => Promise<void>;
+    /** Optional live updates; return an unsubscribe function. */
+    subscribe?: (cb: (accounts: MegaAccount[]) => void, key?: string) => () => void;
+};
+export type MegaTreeNode = {
+    /** MEGA node handle */
+    handle: string;
+    name: string;
+    isFolder: boolean;
+    isVideo: boolean;
+    isSubtitle: boolean;
+    size: number;
+    path: string;
+};
+export type AccountTestResult = {
+    name: string;
+    folders: number;
+    files: number;
+};

package/dist/accounts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { loadMegaFile, fileSizeOf, withTimeout } from "./megaFile.js";
+export { collectMegaFileStream } from "./stream.js";
+export { parseRange, toMegaRange, rangeHeaders, type RangeResult, } from "./ranges.js";
+export { SW_MARKER } from "./swDefine.js";
+export type { MegaFileLike, StreamLike } from "./proxy/types.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { loadMegaFile, fileSizeOf, withTimeout } from "./megaFile.js";
+export { collectMegaFileStream } from "./stream.js";
+export { parseRange, toMegaRange, rangeHeaders, } from "./ranges.js";
+export { SW_MARKER } from "./swDefine.js";

package/dist/megaFile.d.ts

@@ -0,0 +1,7 @@
+import type { MegaFileLike } from "./proxy/types.js";
+/** Lazily resolves megajs `File.fromURL` + attributes (incl. folder-link child). */
+export declare function loadMegaFile(url: string): Promise<MegaFileLike>;
+export declare function fileSizeOf(file: {
+    size?: number;
+}): number;
+export declare function withTimeout<T>(p: Promise<T>, ms: number, msg: string): Promise<T>;

package/dist/megaFile.js

@@ -0,0 +1,31 @@
+const ATTRS_TIMEOUT_MS = 30_000;
+/** Lazily resolves megajs `File.fromURL` + attributes (incl. folder-link child). */
+export async function loadMegaFile(url) {
+    const { File } = (await import("megajs"));
+    const file = File.fromURL(url.trim());
+    await withTimeout(file.loadAttributes(), ATTRS_TIMEOUT_MS, "MEGA did not respond. Check your connection and try again.");
+    // Folder links: loadAttributes resolves to the folder itself — pick the
+    // first non-directory child instead (mirrors the megajs docs sample).
+    const group = file;
+    if (group.children?.length) {
+        const child = group.find?.((n) => !n.children, true);
+        if (child)
+            return child;
+    }
+    return file;
+}
+export function fileSizeOf(file) {
+    return Number(file.size ?? 0);
+}
+export async function withTimeout(p, ms, msg) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error(msg)), ms);
+        p.then((v) => {
+            clearTimeout(t);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(t);
+            reject(e);
+        });
+    });
+}

package/dist/proxy/native.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 declare function ensureProxy(): Promise<void>;
+/** Registers one MEGA link as its own keyed session; returns its local URL. */
+export declare function createStream(megaUrl: string): Promise<{
+    url: string;
+    sessionId: string;
+}>;
+/**
+ * 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 declare function createStreams(megaUrls: string[]): Promise<{
+    urls: string[];
+    sessionId: string;
+}>;
+/** Removes one session; other sessions and the singleton server keep running. */
+export declare function releaseStream(sessionId: string): void;
+/** Tear-down for tests / HMR: unbinds the server and clears every session. */
+export declare function stopProxy(): void;

package/dist/proxy/native.js

@@ -0,0 +1,336 @@
+/**
+ * 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 } from "../ranges.js";
+const tcp = TcpSocket;
+const createServer = tcp.createServer;
+let server = null;
+let proxyBase = "";
+let proxyReady = null;
+const sessions = new Map();
+let sessionCounter = 0;
+/** Collision-resistant session key: time base + monotonic counter + random tail. */
+function newSessionId() {
+    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) {
+    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) {
+    let out = "";
+    for (let i = 0; i < bytes.length; i++)
+        out += String.fromCharCode(bytes[i]);
+    return out;
+}
+function findDoubleCrlf(bytes) {
+    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) {
+    const lines = head.split("\r\n");
+    const parts = (lines[0] ?? "").split(" ");
+    const headers = {};
+    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, status, reason) {
+    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) {
+    const buf = [];
+    let handled = false;
+    socket.on("data", (data) => {
+        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, req, file, size) {
+    if (size <= 0)
+        return serveError(socket, 503, "Stream has no size");
+    const range = 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) => {
+        if (socketClosed)
+            return;
+        if (!headSent) {
+            headSent = true;
+            try {
+                socket.write(head);
+            }
+            catch {
+                teardown();
+                return;
+            }
+        }
+        try {
+            const bytes = chunk instanceof Uint8Array
+                ? chunk
+                : new Uint8Array(chunk?.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) => {
+        console.warn("[megaStream] stream error:", err?.message ?? err);
+        teardown();
+    });
+    socket.on("close", () => teardown());
+    socket.on("error", () => teardown());
+}
+function handleRequest(socket, req) {
+    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() {
+    const srv = createServer({ noDelay: true }, (socket) => handleConnection(socket));
+    await new Promise((resolve, reject) => {
+        const onErr = (e) => {
+            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() {
+    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) {
+    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) {
+    const clean = (megaUrls ?? []).map((u) => u?.trim()).filter(Boolean);
+    if (!clean.length)
+        throw new Error("No video parts to stream.");
+    await ensureProxy();
+    const parts = [];
+    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) {
+    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() {
+    sessions.clear();
+    if (server) {
+        try {
+            server.close();
+        }
+        catch { }
+        server = null;
+    }
+    proxyBase = "";
+    proxyReady = null;
+}

package/dist/proxy/sw/bundle.d.ts

@@ -0,0 +1,21 @@
+import { SW_MARKER } from "../../swDefine.js";
+export { SW_MARKER };
+/** Paths of the bundled files inside this package (dist/proxy/sw). */
+export declare function swAssetPaths(): {
+    sw: string;
+    megajs: string;
+    marker: string;
+};
+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 declare function copySwAssets(outDir: string): CopiedSwAssets;

package/dist/proxy/sw/bundle.js

@@ -0,0 +1,32 @@
+/**
+ * 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() {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    return { sw: join(dir, "sw.js"), megajs: join(dir, "megajs.browser.js"), marker: SW_MARKER };
+}
+/**
+ * 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) {
+    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 };
+}