fca-phantom 1.0.0

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

@@ -0,0 +1,298 @@
+"use strict";
+
+const { log, warn, error } = require("./logger");
+const { isNetworkError }   = require("./revive");
+
+function _jitter(ms) { return Math.floor(Math.random() * ms); }
+
+class CycleManager {
+    constructor() {
+        this._timer        = null;
+        this._healthTimer  = null;
+        this._keepalive    = null;
+        this._cookieTimer  = null;
+        this._adaptTimer   = null;
+
+        this.CYCLE_MS      = 2 * 60 * 60_000;
+        this.HEALTH_MS     = 20 * 60_000;
+        this.KEEPALIVE_MS  = 4 * 60_000;
+        this.COOKIE_MS     = 10 * 60 * 60_000;
+        this.MIN_CYCLE_MS  = 30 * 60_000;
+        this.MAX_CYCLE_MS  = 6  * 60 * 60_000;
+
+        this.lastRefresh      = Date.now();
+        this.failureCount     = 0;
+        this.MAX_FAILURES     = 20;
+        this.onExpiry         = null;
+
+        this._refreshing      = false;
+        this._refreshLock     = null;
+        this._unlock          = null;
+        this._successStreak   = 0;
+        this._ctx             = null;
+        this._funcs           = null;
+        this._origin          = null;
+        this._tokenCache      = new Map();
+        this._healthHistory   = [];
+        this._adaptedCycleMs  = this.CYCLE_MS;
+        this._keepaliveErrors = 0;
+        this._lastHealthCheck = null;
+    }
+
+    async _acquireLock() {
+        if (this._refreshing) {
+            try { await this._refreshLock; } catch (_) {}
+        }
+        if (this._refreshing) return false;
+        this._refreshing = true;
+        this._refreshLock = new Promise(r => { this._unlock = r; });
+        return true;
+    }
+
+    _releaseLock() {
+        this._refreshing = false;
+        if (this._unlock) { this._unlock(); this._unlock = null; }
+    }
+
+    setExpiryHandler(fn)         { this.onExpiry = fn; }
+    setSessionExpiryCallback(fn) { this.onExpiry = fn; }
+
+    _adaptCycleInterval() {
+        if (this._successStreak >= 10) {
+            this._adaptedCycleMs = Math.min(this.MAX_CYCLE_MS, this._adaptedCycleMs + 15 * 60_000);
+        } else if (this.failureCount > 2) {
+            this._adaptedCycleMs = Math.max(this.MIN_CYCLE_MS, this._adaptedCycleMs - 20 * 60_000);
+        }
+    }
+
+    startAutoRefresh(ctx, funcs, origin) {
+        this._ctx    = ctx;
+        this._funcs  = funcs;
+        this._origin = origin;
+
+        this._clearAllTimers();
+
+        const schedule = () => {
+            this._adaptCycleInterval();
+            const next = this._adaptedCycleMs + _jitter(5 * 60_000);
+            this._timer = setTimeout(async () => {
+                try {
+                    const ok = await this.refreshTokens(ctx, funcs, origin);
+                    if (ok) {
+                        this._successStreak++;
+                        log("Heartbeat", `Tokens refreshed (streak:${this._successStreak}, cycle:${Math.round(this._adaptedCycleMs / 60_000)}min)`);
+                    } else {
+                        this._successStreak = 0;
+                        warn("Heartbeat", "Token refresh returned false");
+                    }
+                } catch (e) {
+                    this._successStreak = 0;
+                    error("Heartbeat", "Token refresh error:", e.message);
+                } finally {
+                    schedule();
+                }
+            }, next);
+            try { this._timer.unref(); } catch (_) {}
+            log("Heartbeat", `Next token refresh in ${Math.round(next / 60_000)}min`);
+        };
+
+        this._healthTimer = setInterval(async () => {
+            try {
+                const ok = await this._checkHealth(ctx, funcs, origin);
+                this._lastHealthCheck = { ok, at: Date.now() };
+                this._healthHistory.push({ ok: ok === true, at: Date.now() });
+                if (this._healthHistory.length > 30) this._healthHistory.shift();
+
+                if (ok === "network_error") {
+                    warn("Heartbeat", "Health probe — network issue, skipping"); return;
+                }
+                if (!ok) {
+                    warn("Heartbeat", "Health check failed — trying token refresh");
+                    this._successStreak = 0;
+                    const refreshed = await this.refreshTokens(ctx, funcs, origin);
+                    if (!refreshed) {
+                        warn("Heartbeat", "Refresh also failed — trying alt refresh");
+                        await this._refreshAlt(ctx, funcs, origin);
+                    }
+                }
+            } catch (e) {
+                if (isNetworkError(e)) { warn("Heartbeat", "Health check — network:", e.message); return; }
+                error("Heartbeat", "Health check error:", e.message);
+            }
+        }, this.HEALTH_MS + _jitter(2 * 60_000));
+
+        this._keepalive = setInterval(() => {
+            this._sendKeepalive(ctx).catch(e => {
+                this._keepaliveErrors++;
+                if (this._keepaliveErrors > 10) {
+                    warn("Heartbeat", "Keepalive repeatedly failing — network may be unstable");
+                    this._keepaliveErrors = 0;
+                }
+            });
+        }, this.KEEPALIVE_MS + _jitter(60_000));
+
+        this._cookieTimer = setInterval(async () => {
+            try { await this._refreshCookies(ctx, funcs, origin); }
+            catch (e) { if (!isNetworkError(e)) warn("Heartbeat", "Cookie refresh failed:", e.message); }
+        }, this.COOKIE_MS + _jitter(30 * 60_000));
+
+        [this._healthTimer, this._keepalive, this._cookieTimer].forEach(t => {
+            try { t.unref(); } catch (_) {}
+        });
+
+        schedule();
+    }
+
+    _clearAllTimers() {
+        ["_timer","_healthTimer","_keepalive","_cookieTimer","_adaptTimer"].forEach(k => {
+            if (this[k]) { clearInterval(this[k]); clearTimeout(this[k]); this[k] = null; }
+        });
+    }
+
+    async _checkHealth(ctx, funcs, origin) {
+        try {
+            const net  = require("./net");
+            const opts = { ...ctx.globalOptions, _skipSessionInspect: true };
+            const r    = await net.get(
+                "https://www.facebook.com/ajax/presence/reconnect.php",
+                ctx.jar, { reason: "14", __a: 1 }, opts, { _skipSessionInspect: true }
+            );
+            const html = typeof r.body === "string" ? r.body : "";
+            if (!html && r.statusCode >= 500) return "network_error";
+            const ok = html &&
+                !html.includes("login_form") &&
+                !html.includes('"login_page"') &&
+                !html.includes('"checkpoint"');
+            return !!ok;
+        } catch (e) {
+            if (isNetworkError(e)) return "network_error";
+            return false;
+        }
+    }
+
+    async refreshTokens(ctx, funcs, origin) {
+        if (!await this._acquireLock()) return false;
+        try {
+            const net  = require("./net");
+            const url  = origin || "https://www.facebook.com";
+            const r    = await net.get(url, ctx.jar, null, ctx.globalOptions, {
+                noRef: true, _skipSessionInspect: true,
+            });
+            const html = typeof r.body === "string" ? r.body : "";
+            if (!html) return false;
+
+            const tryExtract = (key) => {
+                const patterns = [
+                    new RegExp(`"${key}"[^}]*"token":"([^"]+)"`),
+                    new RegExp(`"${key}",\\[\\],\\{"token":"([^"]+)"`),
+                    new RegExp(`"token":"([^"]+)"[^}]*"${key}"`),
+                ];
+                for (const re of patterns) {
+                    const m = html.match(re);
+                    if (m?.[1]) return m[1];
+                }
+                return null;
+            };
+
+            const dtsg = tryExtract("DTSGInitialData") || html.match(/"token":"([^"]{10,})"/)?.[1];
+            const lsd  = tryExtract("LSD") || html.match(/"LSD"[^}]*"token":"([^"]+)"/)?.[1];
+
+            if (!dtsg) { this.failureCount++; return false; }
+
+            ctx.fb_dtsg = dtsg;
+            ctx.lsd     = lsd || ctx.lsd;
+            ctx.jazoest = "2" + Array.from(dtsg).reduce((a, c) => a + c.charCodeAt(0), 0);
+
+            const spinR = html.match(/"__spin_r":(\d+)/)?.[1];
+            const spinB = html.match(/"__spin_b":"([^"]+)"/)?.[1];
+            const spinT = html.match(/"__spin_t":(\d+)/)?.[1];
+            if (spinR) ctx.__spin_r = spinR;
+            if (spinB) ctx.__spin_b = spinB;
+            if (spinT) ctx.__spin_t = spinT;
+
+            const cookies = ctx.jar.getCookiesSync("https://www.facebook.com");
+            const cUser   = cookies.find(c => c.key === "c_user");
+            if (cUser) ctx.userID = cUser.value;
+
+            this.failureCount = 0;
+            this.lastRefresh  = Date.now();
+            this._tokenCache.set("dtsg", { val: dtsg, at: Date.now() });
+            log("Heartbeat", "Tokens refreshed successfully");
+            return true;
+
+        } catch (e) {
+            this.failureCount++;
+            if (isNetworkError(e)) { warn("Heartbeat", "Token refresh — network error:", e.message); return false; }
+            error("Heartbeat", "refreshTokens failed:", e.message);
+            if (this.failureCount >= this.MAX_FAILURES && this.onExpiry) this.onExpiry(e);
+            return false;
+        } finally {
+            this._releaseLock();
+        }
+    }
+
+    async _refreshAlt(ctx, funcs, origin) {
+        try {
+            if (!funcs?.post) return false;
+            const r    = await funcs.post("https://www.facebook.com/ajax/dtsg/", ctx.jar, { __a: 1 }, ctx);
+            const body = typeof r.body === "string" ? r.body.replace(/^for\s*\(\s*;\s*;\s*\)\s*;\s*/, "") : null;
+            if (!body) return false;
+            const parsed = JSON.parse(body);
+            const dtsg   = parsed?.jsmods?.define?.[0]?.[2]?.token;
+            if (dtsg) { ctx.fb_dtsg = dtsg; log("Heartbeat", "Alt token refresh succeeded"); return true; }
+        } catch (_) {}
+        return false;
+    }
+
+    async _sendKeepalive(ctx) {
+        try {
+            const net = require("./net");
+            await net.get(
+                "https://www.facebook.com/ajax/presence/reconnect.php",
+                ctx.jar, { reason: "14", __a: 1 }, ctx.globalOptions,
+                { _skipSessionInspect: true }
+            );
+        } catch (_) {}
+    }
+
+    async _refreshCookies(ctx, funcs, origin) {
+        try {
+            const net = require("./net");
+            const r   = await net.get("https://www.facebook.com", ctx.jar, null, ctx.globalOptions, {
+                noRef: true, _skipSessionInspect: true,
+            });
+            if (r.statusCode === 200) log("Heartbeat", "Cookie refresh done");
+        } catch (_) {}
+    }
+
+    halt() {
+        this._clearAllTimers();
+        this._releaseLock();
+        log("Heartbeat", "Halted");
+    }
+
+    stopAutoRefresh() { this.halt(); }
+
+    resetFailureCount() { this.failureCount = 0; this._successStreak = 0; }
+    getFailureCount()   { return this.failureCount; }
+
+    getStatus() {
+        return {
+            lastRefresh:      this.lastRefresh,
+            failures:         this.failureCount,
+            streak:           this._successStreak,
+            adaptedCycleMin:  Math.round(this._adaptedCycleMs / 60_000),
+            lastHealthCheck:  this._lastHealthCheck,
+            healthHistory:    this._healthHistory.slice(-5),
+        };
+    }
+
+    getTimeUntilNextRefresh() {
+        return Math.max(0, (this.lastRefresh + this._adaptedCycleMs) - Date.now());
+    }
+}
+
+module.exports = {
+    CycleManager,
+    TokenRefreshManager: CycleManager,
+};

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

@@ -0,0 +1,235 @@
+"use strict";
+
+const { getRandom } = require("./logger");
+
+const BROWSER_POOL = {
+    windows: {
+        platform: "Windows NT 10.0; Win64; x64",
+        chrome:   ["136.0.0.0","135.0.7049.52","134.0.6998.88","133.0.6943.98","132.0.6834.110","131.0.6778.86","130.0.6723.92","129.0.6668.101"],
+        edge:     ["136.0.0.0","135.0.3179.52","134.0.3124.72","133.0.3065.92","131.0.2903.51","130.0.2849.68"],
+        firefox:  ["134.0","133.0","132.0","131.0","130.0","129.0"],
+        platV:    '"15.0.0"',
+    },
+    mac: {
+        platform: "Macintosh; Intel Mac OS X 10_15_7",
+        chrome:   ["136.0.0.0","135.0.7049.52","134.0.6998.88","133.0.6943.98","132.0.6834.110","131.0.6778.86","130.0.6723.92"],
+        edge:     ["136.0.0.0","135.0.3179.52","134.0.3124.72","133.0.3065.92","131.0.2903.51"],
+        firefox:  ["134.0","133.0","132.0","131.0","130.0"],
+        safari:   ["17.4.1","17.3","17.2","17.1","17.0","16.6"],
+        platV:    '"14.7.0"',
+    },
+    linux: {
+        platform: "X11; Linux x86_64",
+        chrome:   ["136.0.0.0","135.0.7049.52","134.0.6998.88","133.0.6943.98","132.0.6834.110","131.0.6778.86"],
+        firefox:  ["134.0","133.0","132.0","131.0","130.0"],
+        platV:    '""',
+    },
+};
+
+const ANDROID_MODELS = [
+    "Pixel 9 Pro", "Pixel 9", "Pixel 8 Pro", "Pixel 8", "Pixel 7 Pro", "Pixel 7",
+    "Samsung Galaxy S25 Ultra", "Samsung Galaxy S25+", "Samsung Galaxy S25",
+    "Samsung Galaxy S24 Ultra", "Samsung Galaxy S24+", "Samsung Galaxy S24",
+    "Samsung Galaxy S23", "Samsung Galaxy A54", "Samsung Galaxy A34",
+    "OnePlus 12", "OnePlus 12R", "OnePlus 11",
+    "Xiaomi 14 Ultra", "Xiaomi 14 Pro", "Xiaomi 14",
+    "OPPO Find X7 Pro", "OPPO Find X7", "OPPO Reno 12 Pro",
+    "realme GT 5 Pro", "realme GT 6", "Vivo X100 Pro",
+    "Nothing Phone (2a)", "ASUS ROG Phone 8 Pro",
+];
+
+const ANDROID_VERSIONS = ["13", "14", "15"];
+const ANDROID_LOCALES  = [
+    "en-US", "en-GB", "en-AU", "en-CA", "en-IN",
+    "es-US", "es-MX", "fr-FR", "de-DE",
+    "ja-JP", "ko-KR", "pt-BR", "it-IT",
+];
+
+const GREASY_BRANDS = [
+    "Not_A Brand",
+    "Not;A=Brand",
+    "Not A;Brand",
+    "Not/A)Brand",
+    "NotABrand",
+    "Not=A,Brand",
+    "Not A Brand",
+];
+
+function _ri(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }
+function _rch(arr)     { return arr[Math.floor(Math.random() * arr.length)]; }
+
+function _buildAndroidBuildID() {
+    const prefixes = ["QP1A", "RP1A", "SP1A", "TP1A", "UP1A", "AP1A", "BP1A", "GP1A"];
+    return `${_rch(prefixes)}.${_ri(200000, 260000)}.${_ri(10, 99).toString().padStart(3, "0")}`;
+}
+
+function _resolution() {
+    return _rch([
+        { width: 720,  height: 1280,  density: 2.0   },
+        { width: 1080, height: 1920,  density: 2.625 },
+        { width: 1080, height: 2340,  density: 2.75  },
+        { width: 1080, height: 2400,  density: 3.0   },
+        { width: 1440, height: 3040,  density: 3.5   },
+        { width: 1440, height: 3088,  density: 3.625 },
+        { width: 1440, height: 3200,  density: 4.0   },
+    ]);
+}
+
+function _buildBrands(bName, major, ver) {
+    const greasy = _rch(GREASY_BRANDS);
+    const greasyVer = _rch(["8", "24", "99", "100"]);
+    const chromiumMaj = major;
+    const out = [];
+
+    if (bName === "Microsoft Edge") {
+        out.push(
+            `"Chromium";v="${chromiumMaj}"`,
+            `"${greasy}";v="${greasyVer}"`,
+            `"Microsoft Edge";v="${major}"`,
+        );
+    } else {
+        out.push(
+            `"Google Chrome";v="${major}"`,
+            `"${greasy}";v="${greasyVer}"`,
+            `"Chromium";v="${major}"`,
+        );
+    }
+
+    const secChUa             = out.join(", ");
+    const secChUaFullVersionList = out.map(b => {
+        const m = b.match(/v="(\d+)"/);
+        return (m && m[1] === major) ? b.replace(`v="${major}"`, `v="${ver}"`) : b;
+    }).join(", ");
+
+    return { secChUa, secChUaFullVersionList };
+}
+
+function randomDesktopIdentity() {
+    const os      = getRandom(Object.keys(BROWSER_POOL));
+    const data    = BROWSER_POOL[os];
+    const rand    = Math.random();
+    let   browser, versions, useFirefox = false, useSafari = false;
+
+    if (os === "mac" && rand > 0.85 && data.safari) {
+        useSafari = true;
+        browser   = "Safari";
+        versions  = data.safari;
+    } else if (rand > 0.75 && data.firefox) {
+        useFirefox = true;
+        browser    = "Firefox";
+        versions   = data.firefox;
+    } else if (rand > 0.6 && data.edge) {
+        browser  = "Microsoft Edge";
+        versions = data.edge;
+    } else {
+        browser  = "Google Chrome";
+        versions = data.chrome;
+    }
+
+    const ver   = getRandom(versions);
+    const major = ver.split(".")[0];
+
+    if (useSafari) {
+        const ua = `Mozilla/5.0 (${data.platform}) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${ver} Safari/605.1.15`;
+        return {
+            userAgent: ua, browser,
+            secChUa: "", secChUaFullVersionList: "",
+            secChUaPlatform: '"macOS"', secChUaPlatformVersion: data.platV,
+        };
+    }
+
+    if (useFirefox) {
+        const ua = `Mozilla/5.0 (${data.platform}; rv:${ver}) Gecko/20100101 Firefox/${ver}`;
+        const platName = os === "windows" ? "Windows" : os === "mac" ? "macOS" : "Linux";
+        return {
+            userAgent: ua, browser,
+            secChUa: `"Firefox";v="${major}", "Not/A)Brand";v="8"`,
+            secChUaFullVersionList: `"Firefox";v="${ver}", "Not/A)Brand";v="8.0.0.0"`,
+            secChUaPlatform: `"${platName}"`, secChUaPlatformVersion: data.platV,
+        };
+    }
+
+    const useEdge = browser === "Microsoft Edge";
+    const { secChUa, secChUaFullVersionList } = _buildBrands(browser, major, ver);
+    const platName = os === "windows" ? "Windows" : os === "mac" ? "macOS" : "Linux";
+
+    const ua = useEdge
+        ? `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${ver} Safari/537.36 Edg/${ver}`
+        : `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${ver} Safari/537.36`;
+
+    return {
+        userAgent: ua, browser,
+        secChUa, secChUaFullVersionList,
+        secChUaPlatform: `"${platName}"`,
+        secChUaPlatformVersion: data.platV,
+    };
+}
+
+function randomAndroidIdentity(opts = {}) {
+    const model   = _rch(ANDROID_MODELS);
+    const av      = _rch(ANDROID_VERSIONS);
+    const locale  = _rch(ANDROID_LOCALES);
+    const build   = _buildAndroidBuildID();
+    const res     = _resolution();
+    const fbVer   = opts.fbAndroidVersion || _rch(["467.0.0.35.108","466.0.0.34.107","465.0.0.33.106"]);
+    const chromeV = _rch(["126.0.6478.122","125.0.6422.52","124.0.6367.82"]);
+    const modelKey = model.replace(/ /g, "_");
+
+    const ua = `Mozilla/5.0 (Linux; Android ${av}; ${model} Build/${build}; wv) ` +
+               `AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/${chromeV} Mobile Safari/537.36 ` +
+               `[FBAN/FB4A;FBAV/${fbVer};FBDV/${modelKey};FBMD/${modelKey};` +
+               `FBSN/Android;FBSV/${av};FBSS/3;FBID/phone;FBLC/${locale.replace("-", "_")};FBOP/1]`;
+
+    return {
+        userAgent:      ua,
+        resolution:     res,
+        locale,
+        device:         model,
+        androidVersion: av,
+        buildID:        build,
+        persona:        "android",
+    };
+}
+
+function generateIdentityByMode(mode, opts = {}) {
+    if (mode === "android" || mode === "mobile") return randomAndroidIdentity(opts);
+    return randomDesktopIdentity();
+}
+
+function cacheIdentityData(cfg, id) {
+    if (!cfg || !id) return;
+    if (id.androidVersion) {
+        cfg.cachedAndroidUA         = id.userAgent;
+        cfg.cachedAndroidDevice     = id.device;
+        cfg.cachedAndroidVersion    = id.androidVersion;
+        cfg.cachedAndroidResolution = id.resolution;
+        cfg.cachedAndroidLocale     = id.locale;
+        cfg.cachedAndroidBuildId    = id.buildID;
+    } else if (id.userAgent) {
+        cfg.cachedUserAgent                  = id.userAgent;
+        cfg.cachedSecChUa                    = id.secChUa;
+        cfg.cachedSecChUaFullVersionList      = id.secChUaFullVersionList;
+        cfg.cachedSecChUaPlatform            = id.secChUaPlatform;
+        cfg.cachedSecChUaPlatformVersion     = id.secChUaPlatformVersion;
+        cfg.cachedBrowser                    = id.browser;
+    }
+}
+
+function isConsistentIdentity(cfg) {
+    const hasDesktop = !!(cfg.cachedUserAgent && cfg.cachedSecChUa);
+    const hasAndroid = !!(cfg.cachedAndroidUA && cfg.cachedAndroidDevice);
+    return hasDesktop || hasAndroid;
+}
+
+module.exports = {
+    randomDesktopIdentity,
+    randomAndroidIdentity,
+    generateIdentityByMode,
+    cacheIdentityData,
+    isConsistentIdentity,
+    randomUserAgent:             randomDesktopIdentity,
+    generateUserAgentByPersona:  (mode, opts) => generateIdentityByMode(mode, opts),
+    ANDROID_MODELS,
+    ANDROID_VERSIONS,
+    BROWSER_POOL,
+};