fca-phantom 1.0.0

package/phantom/datastore/models/matrix/logger.js

@@ -0,0 +1,271 @@
+"use strict";
+
+const path = require("path");
+const fs   = require("fs");
+
+const COLORS = {
+    reset:   "\x1b[0m",
+    bold:    "\x1b[1m",
+    dim:     "\x1b[2m",
+    red:     "\x1b[31m",
+    green:   "\x1b[32m",
+    yellow:  "\x1b[33m",
+    blue:    "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan:    "\x1b[36m",
+    white:   "\x1b[37m",
+    gray:    "\x1b[90m",
+    bgRed:   "\x1b[41m",
+};
+
+const LEVEL_CONFIG = {
+    trace:    { rank: 0, color: COLORS.gray,    label: "TRACE",    out: "log" },
+    debug:    { rank: 1, color: COLORS.cyan,    label: "DEBUG",    out: "log" },
+    info:     { rank: 2, color: COLORS.blue,    label: "INFO",     out: "log" },
+    success:  { rank: 2, color: COLORS.green,   label: "OK",       out: "log" },
+    log:      { rank: 2, color: COLORS.white,   label: "LOG",      out: "log" },
+    warn:     { rank: 3, color: COLORS.yellow,  label: "WARN",     out: "warn" },
+    error:    { rank: 4, color: COLORS.red,     label: "ERROR",    out: "error" },
+    critical: { rank: 5, color: COLORS.bgRed,   label: "CRITICAL", out: "error" },
+};
+
+let _enabled   = true;
+let _minRank   = 2;
+let _useColor  = process.stdout.isTTY ?? true;
+let _fileStream = null;
+let _perf      = new Map();
+let _history   = [];
+const _MAX_HISTORY = 500;
+
+function _ts() {
+    const d = new Date();
+    const h = String(d.getHours()).padStart(2, "0");
+    const m = String(d.getMinutes()).padStart(2, "0");
+    const s = String(d.getSeconds()).padStart(2, "0");
+    const ms = String(d.getMilliseconds()).padStart(3, "0");
+    return `${h}:${m}:${s}.${ms}`;
+}
+
+function _fmt(level, tag, args) {
+    const cfg = LEVEL_CONFIG[level];
+    const ts  = _ts();
+    const msg = args.map(a => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ");
+    const plain  = `[${ts}] [${cfg.label}] [${tag}] ${msg}`;
+    const colored = _useColor
+        ? `${COLORS.gray}[${ts}]${COLORS.reset} ${cfg.color}${COLORS.bold}[${cfg.label}]${COLORS.reset} ${COLORS.magenta}[${tag}]${COLORS.reset} ${msg}`
+        : plain;
+    return { plain, colored, level, tag, msg, ts, at: Date.now() };
+}
+
+function _emit(level, tag, args) {
+    if (!_enabled) return;
+    const cfg = LEVEL_CONFIG[level];
+    if (!cfg || cfg.rank < _minRank) return;
+    const { plain, colored } = _fmt(level, tag, args);
+    console[cfg.out](colored);
+    if (_fileStream) { try { _fileStream.write(plain + "\n"); } catch (_) {} }
+    if (_history.length >= _MAX_HISTORY) _history.shift();
+    _history.push({ level, tag, msg: args.join(" "), at: Date.now() });
+}
+
+function logOptions(v) { _enabled = Boolean(v); }
+function setLogLevel(l) {
+    const lvl = typeof l === "string" ? l : "info";
+    const cfg = LEVEL_CONFIG[lvl];
+    if (cfg) _minRank = cfg.rank;
+}
+function setColor(v) { _useColor = Boolean(v); }
+
+function enableFileLog(filePath) {
+    try {
+        _fileStream = fs.createWriteStream(filePath, { flags: "a" });
+    } catch (_) {}
+}
+
+function trace(  tag, ...a) { _emit("trace",    tag, a); }
+function debug(  tag, ...a) { _emit("debug",    tag, a); }
+function info(   tag, ...a) { _emit("info",     tag, a); }
+function log(    tag, ...a) { _emit("log",      tag, a); }
+function success(tag, ...a) { _emit("success",  tag, a); }
+function warn(   tag, ...a) { _emit("warn",     tag, a); }
+function error(  tag, ...a) { _emit("error",    tag, a); }
+function critical(tag,...a) { _emit("critical", tag, a); }
+function banner(msg)        { if (_enabled && _minRank <= 2) console.log(msg); }
+
+function time(label) { _perf.set(label, process.hrtime.bigint()); }
+function timeEnd(label, tag = "Perf") {
+    const start = _perf.get(label);
+    if (!start) return;
+    const ms = Number(process.hrtime.bigint() - start) / 1e6;
+    _perf.delete(label);
+    log(tag, `${label}: ${ms.toFixed(2)}ms`);
+    return ms;
+}
+
+function getHistory(last = 50) { return _history.slice(-last); }
+function clearHistory() { _history = []; }
+
+const NUM_TO_MONTH = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
+const NUM_TO_DAY   = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
+
+function getRandom(arr)  { return arr[Math.floor(Math.random() * arr.length)]; }
+function padZeros(v, l = 2) { return String(v).padStart(l, "0"); }
+
+function generateThreadingID(clientID) {
+    const ts   = Date.now();
+    const rand = Math.floor(Math.random() * 0xFFFFFFFF).toString(16).padStart(8, "0");
+    const seq  = Math.floor(Math.random() * 9999).toString(16).padStart(4, "0");
+    return `<${ts}:${rand}-${seq}-${clientID}@mail.projektitan.com>`;
+}
+
+function binaryToDecimal(data) {
+    let ret = "";
+    while (data !== "0") {
+        let end = 0, full = "", i = 0;
+        for (; i < data.length; i++) {
+            end = 2 * end + parseInt(data[i], 10);
+            full += end >= 10 ? (end -= 10, "1") : "0";
+        }
+        ret = end + ret;
+        data = full.slice(full.indexOf("1"));
+    }
+    return ret;
+}
+
+function generateOfflineThreadingID() {
+    const ret   = Date.now();
+    const value = Math.floor(Math.random() * 0xFFFFFFFF);
+    const str   = ("0000000000000000000000" + value.toString(2)).slice(-22);
+    return binaryToDecimal(ret.toString(2) + str);
+}
+
+const _ENC = {
+    _: "%", A: "%2", B: "000", C: "%7d", D: "%7b%22", E: "%2c%22", F: "%22%3a",
+    G: "%2c%22ut%22%3a1", H: "%2c%22bls%22%3a", I: "%2c%22n%22%3a%22%",
+    J: "%22%3a%7b%22i%22%3a0%7d", K: "%2c%22pt%22%3a0%2c%22vis%22%3a",
+    L: "%2c%22ch%22%3a%7b%22h%22%3a%22", M: "%7b%22v%22%3a2%2c%22time%22%3a1",
+    N: ".channel%22%2c%22sub%22%3a%5b", O: "%2c%22sb%22%3a1%2c%22t%22%3a%5b",
+    P: "%2c%22ud%22%3a100%2c%22lc%22%3a0", Q: "%5d%2c%22f%22%3anull%2c%22uct%22%3a",
+    R: ".channel%22%2c%22sub%22%3a%5b1%5d", S: "%22%2c%22m%22%3a0%7d%2c%7b%22i%22%3a",
+    T: "%2c%22blc%22%3a1%2c%22snd%22%3a1%2c%22ct%22%3a",
+    U: "%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
+    V: "%2c%22blc%22%3a0%2c%22snd%22%3a0%2c%22ct%22%3a",
+    W: "%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a",
+    X: "%2c%22ri%22%3a0%7d%2c%22state%22%3a%7b%22p%22%3a0%2c%22ut%22%3a1",
+    Y: "%2c%22pt%22%3a0%2c%22vis%22%3a1%2c%22bls%22%3a0%2c%22blc%22%3a0%2c%22snd%22%3a1%2c%22ct%22%3a",
+    Z: "%2c%22sb%22%3a1%2c%22t%22%3a%5b%5d%2c%22f%22%3anull%2c%22uct%22%3a0%2c%22s%22%3a0%2c%22blo%22%3a0%7d%2c%22bl%22%3a%7b%22ac%22%3a",
+};
+const _DEC     = {};
+const _encKeys = [];
+for (const k in _ENC) { _DEC[_ENC[k]] = k; _encKeys.push(_ENC[k]); }
+_encKeys.reverse();
+const _RE = new RegExp(_encKeys.join("|"), "g");
+
+function presenceEncode(str) {
+    return encodeURIComponent(str)
+        .replace(/([_A-Z])|%../g, (m, n) => n ? "%" + n.charCodeAt(0).toString(16) : m)
+        .toLowerCase()
+        .replace(_RE, (m) => _DEC[m]);
+}
+
+function presenceDecode(str) {
+    return decodeURIComponent(str.replace(/[_A-Z]/g, (m) => _ENC[m]));
+}
+
+function generatePresence(userID) {
+    const t = Date.now();
+    const noise = Math.floor(Math.random() * 999) + 1;
+    return "E" + presenceEncode(JSON.stringify({
+        v: 3,
+        time: Math.floor(t / 1000),
+        user: userID,
+        state: {
+            ut: 0, t2: [], lm2: null, uct2: t, tr: null,
+            tw: Math.floor(Math.random() * 0xFFFFFFFF) + 1, at: t,
+        },
+        ch: { [`p_${userID}`]: 0 },
+        noise,
+    }));
+}
+
+function generateAccessiblityCookie() {
+    const t = Date.now();
+    return encodeURIComponent(JSON.stringify({
+        sr: 0, "sr-ts": t, jk: 0, "jk-ts": t,
+        kb: 0, "kb-ts": t, hcm: 0, "hcm-ts": t,
+    }));
+}
+
+function getGUID() {
+    let sl = Date.now();
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.floor((sl + Math.random() * 16) % 16);
+        sl = Math.floor(sl / 16);
+        return (c === "x" ? r : (r & 7) | 8).toString(16);
+    });
+}
+
+function getFrom(str, start, end) {
+    if (!str || typeof str !== "string") return "";
+    const si = str.indexOf(start);
+    if (si === -1) return "";
+    const rest = str.substring(si + start.length);
+    const ei   = rest.indexOf(end);
+    if (ei === -1) return "";
+    return rest.substring(0, ei);
+}
+
+function makeParsable(html) {
+    const clean = html.replace(/for\s*\(\s*;\s*;\s*\)\s*;\s*/, "");
+    const parts = clean.split(/\}\r\n *\{/);
+    return parts.length === 1 ? parts[0] : "[" + parts.join("},{") + "]";
+}
+
+function arrToForm(form) {
+    return form.reduce((acc, v) => { acc[v.name] = v.val; return acc; }, {});
+}
+
+function arrayToObject(arr, getKey, getValue) {
+    return arr.reduce((acc, v) => { acc[getKey(v)] = getValue(v); return acc; }, {});
+}
+
+function getSignatureID()            { return Math.floor(Math.random() * 0x7FFFFFFF).toString(16); }
+function generateTimestampRelative() { const d = new Date(); return d.getHours() + ":" + padZeros(d.getMinutes()); }
+function getType(obj)                { return Object.prototype.toString.call(obj).slice(8, -1); }
+function isReadableStream(obj)       { return obj !== null && typeof obj === "object" && typeof obj.pipe === "function"; }
+
+function _readPkg() {
+    try { return JSON.parse(fs.readFileSync(path.resolve(__dirname, "..", "..", "package.json"), "utf8")); }
+    catch (_) { return {}; }
+}
+
+function startupBanner() {
+    const { name = "phantom-fca", version = "1.0.0" } = _readPkg();
+    const pad = (s, n) => String(s).padEnd(n);
+    const lines = [
+        ``,
+        `  ${COLORS.cyan}╔═══════════════════════════════════════════╗${COLORS.reset}`,
+        `  ${COLORS.cyan}║${COLORS.reset}  ${COLORS.bold}${COLORS.magenta}${pad(name, 41)}${COLORS.reset}${COLORS.cyan}║${COLORS.reset}`,
+        `  ${COLORS.cyan}║${COLORS.reset}  ${COLORS.green}Version  : ${COLORS.bold}${pad(version, 32)}${COLORS.reset}${COLORS.cyan}║${COLORS.reset}`,
+        `  ${COLORS.cyan}║${COLORS.reset}  ${COLORS.yellow}Stealth  : ${COLORS.bold}${pad("Active", 32)}${COLORS.reset}${COLORS.cyan}║${COLORS.reset}`,
+        `  ${COLORS.cyan}║${COLORS.reset}  ${COLORS.blue}Shield   : ${COLORS.bold}${pad("Enabled", 32)}${COLORS.reset}${COLORS.cyan}║${COLORS.reset}`,
+        `  ${COLORS.cyan}║${COLORS.reset}  ${COLORS.blue}Revive   : ${COLORS.bold}${pad("Enabled", 32)}${COLORS.reset}${COLORS.cyan}║${COLORS.reset}`,
+        `  ${COLORS.cyan}╚═══════════════════════════════════════════╝${COLORS.reset}`,
+        ``,
+    ];
+    if (_useColor) lines.forEach(l => console.log(l));
+    else console.log(`${name} v${version} | Stealth Active | Shield Enabled`);
+}
+
+module.exports = {
+    logOptions, setLogLevel, setColor, enableFileLog,
+    trace, debug, info, log, success, warn, error, critical, banner,
+    time, timeEnd, getHistory, clearHistory,
+    getRandom, padZeros,
+    generateThreadingID, binaryToDecimal, generateOfflineThreadingID,
+    presenceEncode, presenceDecode, generatePresence, generateAccessiblityCookie,
+    getGUID, getFrom, makeParsable, arrToForm, arrayToObject,
+    getSignatureID, generateTimestampRelative, getType, isReadableStream,
+    startupBanner, phantomBanner: startupBanner,
+    NUM_TO_MONTH, NUM_TO_DAY,
+};

package/phantom/datastore/models/matrix/monitor.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./telemetry");

package/phantom/datastore/models/matrix/net.js

@@ -0,0 +1,316 @@
+"use strict";
+
+const axios     = require("axios");
+const { CookieJar } = require("tough-cookie");
+const { wrapper }   = require("axios-cookiejar-support");
+const FormData      = require("form-data");
+const { getHeaders }    = require("./headers");
+const { getType }       = require("./logger");
+const { globalGate }    = require("./gate");
+
+const _jar    = new CookieJar();
+const _client = wrapper(axios.create({ jar: _jar }));
+
+let _proxy    = {};
+let _netStats = { req: 0, err: 0, deduped: 0, cachedHits: 0 };
+
+const _inflightMap  = new Map();
+const _responseCache = new Map();
+const CACHE_TTL_MS   = 5_000;
+const MAX_CACHE_SIZE = 100;
+
+const pause      = (ms) => new Promise(r => setTimeout(r, ms));
+const quickPause = (ms) => {
+    if (ms <= 0)  return Promise.resolve();
+    if (ms <= 5)  return new Promise(r => setImmediate(r));
+    return new Promise(r => setTimeout(r, ms));
+};
+
+function _getCacheKey(url, params) {
+    if (!params) return url;
+    try { return url + "?" + new URLSearchParams(params).toString(); } catch (_) { return url; }
+}
+
+function _pruneCache() {
+    const now = Date.now();
+    for (const [k, v] of _responseCache) {
+        if (now > v.exp) _responseCache.delete(k);
+    }
+}
+
+function _adapt(res) {
+    const r = res.response || res;
+    return {
+        ...r,
+        body:       r.data,
+        statusCode: r.status,
+        request: {
+            uri:      new URL(r.config?.url || "https://www.facebook.com"),
+            headers:  r.config?.headers || {},
+            method:   (r.config?.method || "GET").toUpperCase(),
+            form:     r.config?.data,
+            formData: r.config?.data,
+        },
+    };
+}
+
+const CHECKPOINT_PATTERNS = [
+    { sig: "1501092823525282",                     code: "checkpoint_282",     msg: "Bot checkpoint 282" },
+    { sig: "828281030927956",                       code: "checkpoint_956",     msg: "Bot checkpoint 956" },
+    { sig: "XCheckpointFBScrapingWarningController",code: "checkpoint_scraping",msg: "Scraping warning checkpoint" },
+    { sig: "601051028565049",                       code: "checkpoint_601",     msg: "Automation checkpoint 601" },
+];
+
+async function _inspectBody(adapted, ctx) {
+    if (!ctx || ctx._skipSessionInspect) return;
+    const body = adapted.body;
+    if (!body) return;
+    const bs = typeof body === "string" ? body : JSON.stringify(body);
+
+    for (const { sig, code, msg } of CHECKPOINT_PATTERNS) {
+        if (bs.includes(sig)) {
+            const e = Object.assign(new Error(msg), { error: code, res: body });
+            ctx._emitter?.emit?.(code, { res: body });
+            throw e;
+        }
+    }
+
+    const isLoginPage =
+        bs.includes('<form id="login_form"') ||
+        bs.includes('id="loginbutton"')       ||
+        bs.includes('"login_page"')            ||
+        (bs.includes("login.php") && bs.includes('"next":"'));
+
+    const isLoginBlocked = typeof body === "object" && body?.error === 1357001;
+
+    if (isLoginBlocked) {
+        throw Object.assign(new Error("Login blocked"), { error: "login_blocked", res: body });
+    }
+
+    if (isLoginPage) {
+        ctx._emitter?.emit?.("sessionExpired", { res: body });
+        if (!ctx.auto_login && typeof ctx.performAutoLogin === "function") {
+            ctx.auto_login = true;
+            const t = setTimeout(() => { ctx.auto_login = false; }, 120_000);
+            try {
+                const ok = await ctx.performAutoLogin();
+                clearTimeout(t);
+                ctx.auto_login = false;
+                if (!ok) throw Object.assign(new Error("Not logged in. Auto-revive failed."), { error: "Not logged in.", res: body });
+            } catch (e) {
+                clearTimeout(t);
+                ctx.auto_login = false;
+                throw e;
+            }
+        } else {
+            throw Object.assign(new Error("Not logged in. Session expired."), { error: "Not logged in.", res: body });
+        }
+    }
+}
+
+const ERROR_COOLDOWNS = {
+    1545012: 90_000,
+    1675004: 45_000,
+    368:     180_000,
+    10:      120_000,
+    404:     8_000,
+    500:     15_000,
+    503:     45_000,
+    429:     120_000,
+};
+
+function _applyCooldowns(body, ep, tid) {
+    if (!body || typeof body !== "object") return;
+    function apply(code) {
+        if (!code || !ERROR_COOLDOWNS[code]) return;
+        const ms = ERROR_COOLDOWNS[code];
+        if (tid) globalGate.setThreadCooldown(tid, ms);
+        if (ep)  globalGate.setEndpointCooldown(ep, ms);
+    }
+    apply(body.error);
+    if (Array.isArray(body)) body.forEach(item => {
+        apply(item?.error);
+        (item?.errors || []).forEach(e => apply(e.code || e.extensions?.code));
+    });
+    (body.errors || []).forEach(e => apply(e.code || e.extensions?.code));
+}
+
+const FATAL_ERRORS = new Set([
+    "Not logged in.", "checkpoint_282", "checkpoint_956",
+    "checkpoint_scraping", "checkpoint_601", "login_blocked",
+]);
+
+const NET_CODES = new Set([
+    "ECONNRESET","ETIMEDOUT","ECONNREFUSED","ENETUNREACH",
+    "EHOSTUNREACH","EAI_AGAIN","ENOTFOUND","ESOCKETTIMEDOUT","EPIPE",
+]);
+
+async function _withRetry(fn, retries = 3, ep = "", tid = "", ctx = null) {
+    let release = null;
+    const hasLimiting = !!(ep || tid);
+    if (hasLimiting) release = await globalGate.checkRateLimit(false, ep);
+
+    const globalWait = globalGate.getRemainingCooldown?.("__GLOBAL__") || 0;
+    if (globalWait > 0) await pause(globalWait);
+
+    try {
+        for (let i = 0; i < retries; i++) {
+            try {
+                _netStats.req++;
+                const res = _adapt(await fn());
+                _applyCooldowns(res.body, ep, tid);
+                await _inspectBody(res, ctx);
+                globalGate.recordRequest(true);
+                return res;
+            } catch (e) {
+                if (FATAL_ERRORS.has(e.error)) throw e;
+
+                if (e.code === "ERR_INVALID_CHAR" || e.message?.includes("Invalid character in header")) {
+                    throw Object.assign(new Error("Invalid header character"), { error: "invalid_header" });
+                }
+
+                if (e.response) _applyCooldowns(_adapt(e.response).body, ep, tid);
+
+                _netStats.err++;
+                globalGate.recordRequest(false);
+
+                if (i === retries - 1) {
+                    if (e.response) return _adapt(e.response);
+                    throw e;
+                }
+
+                const isNet = NET_CODES.has(e.code) || NET_CODES.has((e.message || "").split(" ")[0]);
+                const base  = isNet ? 500 : 1000;
+                const wait  = Math.min(30_000, Math.pow(2, i) * base + Math.random() * 1000);
+                await quickPause(wait);
+            }
+        }
+    } finally {
+        release?.();
+    }
+}
+
+function setProxy(url) {
+    if (!url) { _proxy = {}; return; }
+    try {
+        const p  = new URL(url);
+        _proxy = {
+            proxy: {
+                host:     p.hostname,
+                port:     Number(p.port) || (p.protocol === "https:" ? 443 : 80),
+                protocol: p.protocol.replace(":", ""),
+                auth:     p.username ? { username: p.username, password: p.password } : undefined,
+            },
+        };
+    } catch (_) { _proxy = {}; }
+}
+
+function cleanGet(url) {
+    return _withRetry(() => _client.get(url, { timeout: 60_000, ..._proxy }));
+}
+
+async function get(url, jar, params, opts, ctx, customHeader) {
+    const ep  = new URL(url).pathname;
+    const tid = ctx?.requestThreadID ? String(ctx.requestThreadID) : "";
+
+    const cacheKey = _getCacheKey(url, params);
+    const cached   = _responseCache.get(cacheKey);
+    if (cached && Date.now() < cached.exp && !customHeader) {
+        _netStats.cachedHits++;
+        return cached.res;
+    }
+
+    if (_inflightMap.has(cacheKey)) {
+        _netStats.deduped++;
+        return _inflightMap.get(cacheKey);
+    }
+
+    const prom = _withRetry(() => _client.get(url, {
+        headers:          getHeaders(url, opts, ctx, customHeader),
+        timeout:          60_000,
+        params,
+        ..._proxy,
+        validateStatus:   s => s >= 200 && s < 600,
+        decompress:       true,
+        maxContentLength: 100 * 1024 * 1024,
+        maxBodyLength:    100 * 1024 * 1024,
+    }), 3, ep, tid, ctx);
+
+    _inflightMap.set(cacheKey, prom);
+    prom.then(res => {
+        if (_responseCache.size >= MAX_CACHE_SIZE) _pruneCache();
+        _responseCache.set(cacheKey, { res, exp: Date.now() + CACHE_TTL_MS });
+    }).catch(() => {}).finally(() => { _inflightMap.delete(cacheKey); });
+
+    return prom;
+}
+
+async function post(url, jar, form, opts, ctx, customHeader) {
+    const headers = getHeaders(url, opts, ctx, customHeader, "xhr");
+    const ct      = headers["Content-Type"] || "application/x-www-form-urlencoded";
+
+    let data;
+    if (ct.includes("json")) {
+        data = JSON.stringify(form);
+    } else {
+        const sp = new URLSearchParams();
+        for (const k in form) {
+            if (Object.prototype.hasOwnProperty.call(form, k)) {
+                const v = form[k];
+                sp.append(k, getType(v) === "Object" ? JSON.stringify(v) : String(v ?? ""));
+            }
+        }
+        data = sp.toString();
+    }
+
+    headers["Content-Type"]   = ct;
+    headers["Content-Length"] = String(Buffer.byteLength(data, "utf8"));
+
+    const ep  = new URL(url).pathname;
+    const tid = ctx?.requestThreadID ? String(ctx.requestThreadID) : "";
+
+    return _withRetry(() => _client.post(url, data, {
+        headers, timeout: 60_000, ..._proxy,
+        validateStatus:   s => s >= 200 && s < 600,
+        decompress:       true,
+        maxContentLength: 100 * 1024 * 1024,
+        maxBodyLength:    100 * 1024 * 1024,
+    }), 3, ep, tid, ctx);
+}
+
+async function postFormData(url, jar, form, params, opts, ctx) {
+    const fd = new FormData();
+    for (const k in form) {
+        if (Object.prototype.hasOwnProperty.call(form, k)) fd.append(k, form[k]);
+    }
+    const boundary  = fd.getBoundary();
+    const customHdr = { "Content-Type": `multipart/form-data; boundary=${boundary}` };
+    const ep  = new URL(url).pathname;
+    const tid = ctx?.requestThreadID ? String(ctx.requestThreadID) : "";
+
+    return _withRetry(() => _client.post(url, fd, {
+        headers:          getHeaders(url, opts, ctx, customHdr, "xhr"),
+        timeout:          90_000,
+        params,
+        ..._proxy,
+        validateStatus:   s => s >= 200 && s < 600,
+        decompress:       true,
+        maxContentLength: 200 * 1024 * 1024,
+        maxBodyLength:    200 * 1024 * 1024,
+    }), 3, ep, tid, ctx);
+}
+
+function getNetStats() { return { ..._netStats }; }
+function clearNetCache() { _responseCache.clear(); }
+
+module.exports = {
+    get,
+    post,
+    postFormData,
+    cleanGet,
+    getNetStats,
+    clearNetCache,
+    getJar:           () => _jar,
+    setProxy,
+    requestWithRetry: _withRetry,
+};