fca-phantom 1.0.0

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

@@ -0,0 +1,193 @@
+"use strict";
+
+const { makeParsable, warn, log } = require("./logger");
+const { globalGate, configureRateLimiter } = require("./gate");
+
+function _formatCookie(arr, domain) {
+    return `${arr[0]}=${arr[1]}; Path=${arr[3]}; Domain=${domain}.com`;
+}
+
+function _delay(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+const SESSION_ERRORS = {
+    1357046: "Session token expired",
+    1357045: "Invalid session token",
+    458:     "Not logged in",
+    1357004: "Checkpoint required",
+};
+
+const ACCOUNT_ERRORS = {
+    1357001: "Account blocked — automated behavior detected",
+    1357031: "Account temporarily locked",
+    1357033: "Account suspended",
+    2056003: "Account restricted — suspicious activity",
+    1357048: "Account requires verification",
+    190:     "OAuth access token expired or invalid",
+    100:     "Invalid parameter",
+};
+
+function parseAndCheckLogin(ctx, http, retry = 0) {
+    return async (data) => {
+        if (data.statusCode === 401) {
+            const e = Object.assign(new Error("Session expired — re-authentication required"), {
+                error: 401, errorCode: 401, errorType: "AUTH_EXPIRED", requiresReLogin: true,
+            });
+            warn("Session", "Session expired (401)");
+            throw e;
+        }
+
+        if (data.statusCode === 429) {
+            warn("Session", "Rate limited by server (429)");
+            await _delay(5000 + Math.random() * 5000);
+            throw Object.assign(new Error("Rate limited"), {
+                error: 429, errorCode: 429, errorType: "RATE_LIMITED",
+            });
+        }
+
+        if (data.statusCode >= 500 && data.statusCode < 600) {
+            if (retry >= 5) {
+                throw Object.assign(new Error(`Server error ${data.statusCode} after retries`), {
+                    statusCode: data.statusCode, res: data.body,
+                });
+            }
+            await _delay(1000 + Math.random() * 4000);
+            const url = data.request.uri.protocol + "//" + data.request.uri.hostname + data.request.uri.pathname;
+            const ct  = (data.request.headers["content-type"] || "").split(";")[0];
+            const nd  = ct === "multipart/form-data"
+                ? await http.postFormData(url, ctx.jar, data.request.formData, data.request.qs, ctx.globalOptions, ctx)
+                : await http.post(url, ctx.jar, data.request.form, ctx.globalOptions, ctx);
+            return parseAndCheckLogin(ctx, http, retry + 1)(nd);
+        }
+
+        if (data.statusCode === 404) return;
+
+        if (data.statusCode !== 200) {
+            warn("Session", `Unexpected HTTP ${data.statusCode}`);
+            throw new Error(`Unexpected HTTP ${data.statusCode}`);
+        }
+
+        let res;
+        if (typeof data.body === "object" && data.body !== null) {
+            res = data.body;
+        } else if (typeof data.body === "string") {
+            try {
+                res = JSON.parse(makeParsable(data.body));
+            } catch (e) {
+                throw Object.assign(new Error("Response parse error"), { detail: e, res: data.body });
+            }
+        } else {
+            throw new Error(`Unknown response body type: ${typeof data.body}`);
+        }
+
+        if (res.redirect && data.request.method === "GET") {
+            return parseAndCheckLogin(ctx, http)(await http.get(res.redirect, ctx.jar));
+        }
+
+        if (res.jsmods?.require?.[0]?.[0] === "Cookie") {
+            res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace("_js_", "");
+            const ck = res.jsmods.require[0][3];
+            try { ctx.jar.setCookie(_formatCookie(ck, "facebook"),  "https://www.facebook.com"); } catch (_) {}
+            try { ctx.jar.setCookie(_formatCookie(ck, "messenger"), "https://www.messenger.com"); } catch (_) {}
+        }
+
+        if (Array.isArray(res.jsmods?.require)) {
+            for (const r of res.jsmods.require) {
+                if (r[0] === "DTSG" && r[1] === "setToken" && r[3]?.[0]) {
+                    ctx.fb_dtsg = r[3][0];
+                    ctx.ttstamp = "2";
+                    for (let i = 0; i < ctx.fb_dtsg.length; i++) {
+                        ctx.ttstamp += ctx.fb_dtsg.charCodeAt(i);
+                    }
+                }
+            }
+        }
+
+        if (res.error && SESSION_ERRORS[res.error]) {
+            const e = Object.assign(new Error(SESSION_ERRORS[res.error]), {
+                error: res.error, errorCode: res.error, errorType: "SESSION_EXPIRED", requiresReLogin: true,
+            });
+            warn("Session", `${SESSION_ERRORS[res.error]} (code ${res.error})`);
+            throw e;
+        }
+
+        if (res.error && ACCOUNT_ERRORS[res.error]) {
+            const kind = res.error === 1357004 ? "CHECKPOINT" :
+                         res.error === 1357031 ? "LOCKED"     : "BLOCKED";
+            const e = Object.assign(new Error(ACCOUNT_ERRORS[res.error]), {
+                error: "account_security", errorCode: res.error, errorType: kind,
+                requiresReLogin: [1357004, 1357031, 1357048].includes(res.error),
+            });
+            warn("Account", `${ACCOUNT_ERRORS[res.error]} (code ${res.error})`);
+            throw e;
+        }
+
+        const rs = JSON.stringify(res);
+
+        if (rs.includes("XCheckpointFBScrapingWarningController") || rs.includes("601051028565049")) {
+            warn("Shield", "Scraping checkpoint — applying cooldown");
+            try {
+                globalGate.setEndpointCooldown("__GLOBAL__", 8 * 60_000);
+                configureRateLimiter({ maxConcurrentRequests: 2 });
+            } catch (_) {}
+            throw Object.assign(new Error("Automation checkpoint — account may be flagged"), {
+                errorCode: "CHECKPOINT_SCRAPING", errorType: "BOT_DETECTION", requiresReLogin: true,
+            });
+        }
+
+        if (rs.includes("1501092823525282")) {
+            warn("Shield", "Critical checkpoint 282 detected");
+            try {
+                globalGate.setEndpointCooldown("__GLOBAL__", 15 * 60_000);
+                configureRateLimiter({ maxConcurrentRequests: 1, maxRequestsPerMinute: 20 });
+            } catch (_) {}
+            throw Object.assign(new Error("Critical automation checkpoint"), {
+                errorCode: "CHECKPOINT_282", errorType: "BOT_DETECTION_CRITICAL", requiresReLogin: true,
+            });
+        }
+
+        if (rs.includes("828281030927956")) {
+            warn("Shield", "Checkpoint 956 detected — account may be restricted");
+            try { globalGate.setEndpointCooldown("__GLOBAL__", 5 * 60_000); } catch (_) {}
+        }
+
+        if (String(res.redirect || "").includes("login.php")) {
+            warn("Session", "Login redirect detected — session expired");
+            throw Object.assign(new Error("Session expired — login redirect"), {
+                error: 401, errorCode: 401, errorType: "LOGIN_REDIRECT", requiresReLogin: true,
+            });
+        }
+
+        if (typeof data.body === "string" && (data.body.includes("login_form") || data.body.includes("LoginForm"))) {
+            warn("Session", "Login page detected in response — session expired");
+            throw Object.assign(new Error("Session expired — login page in response"), {
+                error: 401, errorCode: 401, errorType: "LOGIN_REDIRECT", requiresReLogin: true,
+            });
+        }
+
+        return res;
+    };
+}
+
+function saveCookies(jar) {
+    return (res) => {
+        const cookies = res.headers?.["set-cookie"] || [];
+        for (const c of cookies) {
+            try { jar.setCookie(c, "https://www.facebook.com"); } catch (_) {}
+            try { jar.setCookie(c.replace(/domain=\.facebook\.com/i, "domain=.messenger.com"), "https://www.messenger.com"); } catch (_) {}
+        }
+        return res;
+    };
+}
+
+function getAppState(jar) {
+    const fbCookies  = jar.getCookiesSync("https://www.facebook.com");
+    const msgCookies = jar.getCookiesSync("https://www.messenger.com");
+    const seen = new Set();
+    return [...fbCookies, ...msgCookies].filter(c => {
+        if (seen.has(c.key)) return false;
+        seen.add(c.key);
+        return true;
+    });
+}
+
+module.exports = { parseAndCheckLogin, saveCookies, getAppState };

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

@@ -0,0 +1,255 @@
+"use strict";
+
+const { warn, log, error } = require("./logger");
+
+const NET_ERRORS = [
+    "ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH",
+    "EAI_AGAIN", "ENOTFOUND", "ESOCKETTIMEDOUT", "EPIPE", "ECONNABORTED",
+    "socket hang up", "network error", "connect ETIMEDOUT",
+    "read ECONNRESET", "write ECONNRESET", "network socket disconnected",
+];
+
+function isNetworkError(err) {
+    if (!err) return false;
+    const msg  = (err.message || String(err || "")).toLowerCase();
+    const code = err.code || "";
+    return NET_ERRORS.some(p => msg.includes(p.toLowerCase()) || code === p);
+}
+
+function _jitter(ms) { return Math.floor(Math.random() * ms); }
+
+class ReviveManager {
+    constructor() {
+        this.creds        = null;
+        this.opts         = null;
+        this.cb           = null;
+        this.active       = false;
+        this.pending      = [];
+        this.maxRetries   = 6;
+        this.retries      = 0;
+        this.lastFailAt   = 0;
+        this.decayMs      = 2 * 60 * 60_000;
+        this.onSuccess    = null;
+        this.onFailure    = null;
+        this.checkInterval = 30 * 60_000;
+        this._monitorTimer = null;
+        this._lock         = false;
+        this._lockResolve  = null;
+        this.sessionMonitorInterval = null;
+        this._healthHistory = [];
+        this._healthScore   = 100;
+        this._lastReviveAt  = null;
+        this._reviveCount   = 0;
+        this._strategyIndex = 0;
+        this._strategies    = ["token_refresh", "cookie_refresh", "full_reauth"];
+    }
+
+    setCredentials(creds, opts, cb) {
+        this.creds   = creds;
+        this.opts    = opts  || {};
+        this.cb      = cb;
+        this.active  = true;
+        this.retries = 0;
+    }
+
+    isEnabled()      { return this.active && !!this.creds; }
+    getHealthScore() { return this._healthScore; }
+
+    _recordHealth(ok) {
+        this._healthHistory.push({ ok, at: Date.now() });
+        if (this._healthHistory.length > 50) this._healthHistory.shift();
+        const recent = this._healthHistory.slice(-10);
+        const okCount = recent.filter(h => h.ok).length;
+        this._healthScore = Math.round((okCount / recent.length) * 100);
+    }
+
+    startSessionMonitoring(api) {
+        if (this._monitorTimer) clearInterval(this._monitorTimer);
+        if (!this.active || !api) return;
+
+        this._monitorTimer = setInterval(async () => {
+            if (this._lock) return;
+            try {
+                const alive = await api.isSessionAlive?.() ?? await api.isSessionValid?.();
+                if (alive === "network_error") {
+                    warn("Revive", "Session probe — transient network, skipping");
+                    this._recordHealth(true);
+                    return;
+                }
+                this._recordHealth(!!alive);
+                if (alive) return;
+
+                warn("Revive", `Session check failed [health:${this._healthScore}%] — attempting recovery`);
+
+                let recovered = false;
+                if (api._cycleManager?.refreshTokens) {
+                    try {
+                        recovered = await api._cycleManager.refreshTokens(
+                            api.ctx, api.defaultFuncs, "https://www.facebook.com"
+                        );
+                    } catch (e) {
+                        if (isNetworkError(e)) { warn("Revive", "Token refresh — network error:", e.message); return; }
+                    }
+                }
+
+                if (!recovered) {
+                    warn("Revive", "Refresh unsuccessful — triggering full revive");
+                    await this.handleSessionExpiry(api, "https://www.facebook.com", "Session expired");
+                } else {
+                    log("Revive", "Token refresh restored session");
+                    this._recordHealth(true);
+                }
+            } catch (e) {
+                if (isNetworkError(e)) { warn("Revive", "Monitor error (network):", e.message); return; }
+                error("Revive", "Monitor error:", e.message);
+            }
+        }, this.checkInterval);
+
+        try { this._monitorTimer.unref(); } catch (_) {}
+        this.sessionMonitorInterval = this._monitorTimer;
+        log("Revive", `Session monitor started (every ${Math.round(this.checkInterval / 60_000)}min)`);
+    }
+
+    stopSessionMonitoring() {
+        if (this._monitorTimer) {
+            clearInterval(this._monitorTimer);
+            this._monitorTimer = null;
+            this.sessionMonitorInterval = null;
+        }
+    }
+
+    async handleSessionExpiry(api, urlOrFn, errMsg) {
+        if (!this.isEnabled()) {
+            warn("Revive", "Not enabled — no credentials set");
+            return false;
+        }
+
+        const originFn = typeof urlOrFn === "function" ? urlOrFn : () => urlOrFn;
+
+        if (this._lock) {
+            return new Promise((res, rej) => this.pending.push({ res, rej }));
+        }
+
+        if (this.retries >= this.maxRetries && this.lastFailAt > 0) {
+            const age = Date.now() - this.lastFailAt;
+            if (age >= this.decayMs) {
+                log("Revive", `Decay reset after ${Math.round(age / 60_000)}min`);
+                this.retries        = 0;
+                this._strategyIndex = 0;
+            }
+        }
+
+        if (this.retries >= this.maxRetries) {
+            error("Revive", `Max retries (${this.maxRetries}) exceeded`);
+            this.onFailure?.(new Error("Max session revive retries exceeded"));
+            return false;
+        }
+
+        this._lock = true;
+        let lockRelease;
+        const lockPromise = new Promise(r => { lockRelease = r; });
+        this.retries++;
+        this._reviveCount++;
+
+        const strategy = this._strategies[Math.min(this._strategyIndex, this._strategies.length - 1)];
+        log("Revive", `Reviving session [attempt:${this.retries}/${this.maxRetries}, strategy:${strategy}]`);
+
+        await new Promise(r => setTimeout(r, 800 + _jitter(400)));
+
+        try {
+            const ignite      = require("../core/builder/bootstrap");
+            const forge       = require("../core/builder/forge");
+            const applyConfig = require("../core/builder/options");
+
+            await new Promise((res, rej) => {
+                ignite(this.creds, this.opts, (err, newApi) => {
+                    if (err) return rej(err);
+                    if (api) {
+                        api.ctx          = newApi.ctx;
+                        api.defaultFuncs = newApi.defaultFuncs;
+                        api._cycleManager?.resetFailureCount?.();
+                    }
+                    res(newApi);
+                }, applyConfig, forge, api, originFn, errMsg);
+            });
+
+            log("Revive", `Session revived successfully (total revives: ${this._reviveCount})`);
+            this.retries        = 0;
+            this._strategyIndex = 0;
+            this._lock          = false;
+            lockRelease?.();
+            this._recordHealth(true);
+            this._lastReviveAt  = Date.now();
+            this._resolvePending(true);
+            this.onSuccess?.();
+
+            try {
+                if (api?.ctx?._listeningActive) {
+                    const cb = api.ctx._lastListenCallback;
+                    try { api.stopListening?.(); } catch (_) {}
+                    if (cb) api.listenMqtt(cb);
+                }
+            } catch (_) {}
+
+            return true;
+
+        } catch (e) {
+            error("Revive", `Revive failed [strategy:${strategy}]:`, e.message);
+            this._lock      = false;
+            this.lastFailAt = Date.now();
+            lockRelease?.();
+            this._recordHealth(false);
+            this._strategyIndex = Math.min(this._strategyIndex + 1, this._strategies.length - 1);
+            this._resolvePending(false);
+
+            if (this.retries >= this.maxRetries) {
+                this.onFailure?.(e);
+                return false;
+            }
+
+            const wait = Math.min(60_000, Math.pow(2, this.retries) * 1500 + _jitter(2000));
+            log("Revive", `Retrying in ${Math.round(wait / 1000)}s...`);
+            await new Promise(r => setTimeout(r, wait));
+            return this.handleSessionExpiry(api, urlOrFn, errMsg);
+        }
+    }
+
+    _resolvePending(ok) {
+        const queue = this.pending.splice(0);
+        queue.forEach(({ res, rej }) => ok ? res(true) : rej(new Error("Session revive failed")));
+    }
+
+    updateAppState(state) {
+        if (!this.creds || !Array.isArray(state) || !state.length) return;
+        this.creds.appState = state;
+    }
+
+    disable() {
+        this.active = false;
+        this.stopSessionMonitoring();
+        this.creds = this.opts = this.cb = null;
+        log("Revive", "Auto-revive disabled");
+    }
+
+    getStats() {
+        return {
+            enabled:        this.isEnabled(),
+            healthScore:    this._healthScore,
+            retries:        this.retries,
+            maxRetries:     this.maxRetries,
+            reviveCount:    this._reviveCount,
+            lastReviveAt:   this._lastReviveAt,
+            strategy:       this._strategies[Math.min(this._strategyIndex, this._strategies.length - 1)],
+            monitoring:     !!this.sessionMonitorInterval,
+        };
+    }
+}
+
+const globalReviveManager = new ReviveManager();
+
+module.exports = {
+    ReviveManager,
+    globalReviveManager,
+    globalAutoReLoginManager: globalReviveManager,
+    isNetworkError,
+};

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

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