fca-phantom 1.0.0

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

@@ -0,0 +1,263 @@
+"use strict";
+
+class LRUNode {
+    constructor(key, value, ttl) {
+        this.key   = key;
+        this.value = value;
+        this.exp   = ttl > 0 ? Date.now() + ttl : Infinity;
+        this.hits  = 0;
+        this.prev  = null;
+        this.next  = null;
+    }
+    isExpired() { return Date.now() > this.exp; }
+}
+
+class DataStore {
+    constructor(opts = {}) {
+        this._maxSize   = opts.maxSize   || 1000;
+        this._defaultTTL= opts.ttl       || 0;
+        this._map       = new Map();
+        this._head      = null;
+        this._tail      = null;
+        this._hits      = 0;
+        this._misses    = 0;
+        this._evictions = 0;
+        this._namespace = opts.namespace || "default";
+        this._listeners = new Map();
+        this._cleanupInterval = null;
+        if (opts.autoClean !== false) {
+            this._cleanupInterval = setInterval(() => this._sweep(), 60_000);
+            this._cleanupInterval.unref?.();
+        }
+    }
+
+    _unlink(node) {
+        if (node.prev) node.prev.next = node.next; else this._head = node.next;
+        if (node.next) node.next.prev = node.prev; else this._tail = node.prev;
+        node.prev = node.next = null;
+    }
+
+    _prepend(node) {
+        node.next = this._head;
+        node.prev = null;
+        if (this._head) this._head.prev = node;
+        this._head = node;
+        if (!this._tail) this._tail = node;
+    }
+
+    _evict() {
+        while (this._map.size >= this._maxSize && this._tail) {
+            const lru = this._tail;
+            this._unlink(lru);
+            this._map.delete(lru.key);
+            this._evictions++;
+            this._emit("evict", lru.key, lru.value);
+        }
+    }
+
+    _sweep() {
+        const now = Date.now();
+        for (const [k, node] of this._map) {
+            if (node.isExpired()) {
+                this._unlink(node);
+                this._map.delete(k);
+                this._emit("expire", k, node.value);
+            }
+        }
+    }
+
+    _emit(event, ...args) {
+        const fns = this._listeners.get(event);
+        if (fns) fns.forEach(fn => { try { fn(...args); } catch (_) {} });
+    }
+
+    on(event, fn) {
+        if (!this._listeners.has(event)) this._listeners.set(event, []);
+        this._listeners.get(event).push(fn);
+        return this;
+    }
+
+    set(key, value, ttl = null) {
+        const k = String(key);
+        const resolvedTTL = ttl != null ? ttl : this._defaultTTL;
+        if (this._map.has(k)) {
+            const node = this._map.get(k);
+            node.value = value;
+            node.exp   = resolvedTTL > 0 ? Date.now() + resolvedTTL : Infinity;
+            node.hits  = 0;
+            this._unlink(node);
+            this._prepend(node);
+            return this;
+        }
+        this._evict();
+        const node = new LRUNode(k, value, resolvedTTL);
+        this._map.set(k, node);
+        this._prepend(node);
+        this._emit("set", k, value);
+        return this;
+    }
+
+    get(key) {
+        const k = String(key);
+        const node = this._map.get(k);
+        if (!node) { this._misses++; return undefined; }
+        if (node.isExpired()) {
+            this._unlink(node);
+            this._map.delete(k);
+            this._misses++;
+            this._emit("expire", k, node.value);
+            return undefined;
+        }
+        this._hits++;
+        node.hits++;
+        this._unlink(node);
+        this._prepend(node);
+        return node.value;
+    }
+
+    getOrSet(key, factory, ttl = null) {
+        const existing = this.get(key);
+        if (existing !== undefined) return existing;
+        const value = typeof factory === "function" ? factory() : factory;
+        this.set(key, value, ttl);
+        return value;
+    }
+
+    async getOrSetAsync(key, asyncFactory, ttl = null) {
+        const existing = this.get(key);
+        if (existing !== undefined) return existing;
+        const value = await asyncFactory();
+        this.set(key, value, ttl);
+        return value;
+    }
+
+    has(key) { return this.get(String(key)) !== undefined; }
+
+    del(key) {
+        const k = String(key);
+        const node = this._map.get(k);
+        if (!node) return false;
+        this._unlink(node);
+        this._map.delete(k);
+        this._emit("del", k, node.value);
+        return true;
+    }
+
+    touch(key, ttl = null) {
+        const node = this._map.get(String(key));
+        if (!node || node.isExpired()) return false;
+        const resolvedTTL = ttl != null ? ttl : this._defaultTTL;
+        node.exp = resolvedTTL > 0 ? Date.now() + resolvedTTL : Infinity;
+        return true;
+    }
+
+    mget(keys) {
+        return keys.map(k => this.get(k));
+    }
+
+    mset(entries, ttl = null) {
+        for (const [k, v] of entries) this.set(k, v, ttl);
+        return this;
+    }
+
+    keys() {
+        const out = [];
+        for (const [k, node] of this._map) {
+            if (!node.isExpired()) out.push(k);
+        }
+        return out;
+    }
+
+    values() {
+        const out = [];
+        for (const [, node] of this._map) {
+            if (!node.isExpired()) out.push(node.value);
+        }
+        return out;
+    }
+
+    entries() {
+        const out = [];
+        for (const [k, node] of this._map) {
+            if (!node.isExpired()) out.push([k, node.value]);
+        }
+        return out;
+    }
+
+    clear() {
+        this._map.clear();
+        this._head = this._tail = null;
+        this._emit("clear");
+    }
+
+    destroy() {
+        if (this._cleanupInterval) clearInterval(this._cleanupInterval);
+        this._map.clear();
+        this._listeners.clear();
+    }
+
+    get size() {
+        this._sweep();
+        return this._map.size;
+    }
+
+    stats() {
+        const total = this._hits + this._misses;
+        return {
+            namespace:   this._namespace,
+            size:        this._map.size,
+            maxSize:     this._maxSize,
+            hits:        this._hits,
+            misses:      this._misses,
+            evictions:   this._evictions,
+            hitRate:     total > 0 ? ((this._hits / total) * 100).toFixed(1) + "%" : "N/A",
+        };
+    }
+}
+
+class StoreManager {
+    constructor() {
+        this._stores  = new Map();
+        this._default = this._make("default", { maxSize: 1000, ttl: 300_000 });
+    }
+
+    _make(ns, opts) {
+        const store = new DataStore({ ...opts, namespace: ns });
+        this._stores.set(ns, store);
+        return store;
+    }
+
+    ns(namespace, opts = {}) {
+        if (this._stores.has(namespace)) return this._stores.get(namespace);
+        return this._make(namespace, opts);
+    }
+
+    set(k, v, ttl)  { return this._default.set(k, v, ttl); }
+    get(k)          { return this._default.get(k); }
+    has(k)          { return this._default.has(k); }
+    del(k)          { return this._default.del(k); }
+    clear()         { return this._default.clear(); }
+
+    allStats() {
+        const out = {};
+        for (const [ns, store] of this._stores) out[ns] = store.stats();
+        return out;
+    }
+
+    destroyAll() {
+        for (const store of this._stores.values()) store.destroy();
+        this._stores.clear();
+    }
+}
+
+const globalCache  = new DataStore({ maxSize: 1000, ttl: 300_000, namespace: "global" });
+const globalStore  = new StoreManager();
+
+module.exports = {
+    DataStore,
+    StoreManager,
+    globalCache,
+    globalStore,
+    DataCache: DataStore,
+    SessionCache: DataStore,
+};

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

@@ -0,0 +1,272 @@
+"use strict";
+
+const { warn, log } = require("./logger");
+
+const DEFAULT_ALERTS = {
+    errorRate:   { threshold: 5,    unit: "%",  label: "Error Rate" },
+    avgLatency:  { threshold: 2000, unit: "ms", label: "Avg Latency" },
+    p95Latency:  { threshold: 5000, unit: "ms", label: "P95 Latency" },
+    rateLimitHits:{ threshold: 50,  unit: "",   label: "Rate Limit Hits" },
+};
+
+function percentile(sorted, p) {
+    if (!sorted.length) return 0;
+    const idx = Math.ceil((p / 100) * sorted.length) - 1;
+    return sorted[Math.min(idx, sorted.length - 1)];
+}
+
+class Telemetry {
+    constructor() {
+        this._start   = Date.now();
+        this._timer   = null;
+        this._alerts  = new Map(Object.entries(DEFAULT_ALERTS));
+        this._alertCbs= new Map();
+
+        this.req = {
+            total: 0, ok: 0, fail: 0,
+            byEndpoint: new Map(),
+        };
+
+        this.errs = {
+            total: 0,
+            byType:   new Map(),
+            byCode:   new Map(),
+            recent:   [],
+            maxRecent: 200,
+        };
+
+        this.perf = {
+            times:     [],
+            maxTimes:  2000,
+            slow:      [],
+            maxSlow:   100,
+            threshold: 4000,
+        };
+
+        this.sess = {
+            loginAt:    null,
+            lastAct:    null,
+            refreshes:  0,
+            reconnects: 0,
+            revives:    0,
+        };
+
+        this.gate = {
+            hits:      0,
+            cooldowns: 0,
+            delayed:   0,
+            throttled: 0,
+        };
+
+        this._timeSeries = [];
+        this._maxSeries  = 60;
+        this._seriesTimer = setInterval(() => this._snapSeries(), 60_000);
+        try { this._seriesTimer.unref(); } catch (_) {}
+    }
+
+    _snapSeries() {
+        const m = this.getMetrics();
+        this._timeSeries.push({
+            at:          Date.now(),
+            reqs:        m.requests.total,
+            ok:          m.requests.ok,
+            fail:        m.requests.fail,
+            avgMs:       m.perf.avgMs,
+            errTotal:    m.errors.total,
+        });
+        if (this._timeSeries.length > this._maxSeries) this._timeSeries.shift();
+        this._checkAlerts(m);
+    }
+
+    _checkAlerts(metrics) {
+        const errRate = metrics.requests.total > 0
+            ? (metrics.errors.total / metrics.requests.total) * 100 : 0;
+
+        const checks = {
+            errorRate:    errRate,
+            avgLatency:   metrics.perf.avgMs,
+            p95Latency:   metrics.perf.p95,
+            rateLimitHits:this.gate.hits,
+        };
+
+        for (const [key, cfg] of this._alerts) {
+            const val = checks[key] ?? 0;
+            if (val > cfg.threshold) {
+                const msg = `ALERT: ${cfg.label} = ${val.toFixed ? val.toFixed(1) : val}${cfg.unit} (threshold: ${cfg.threshold}${cfg.unit})`;
+                warn("Telemetry", msg);
+                const cb = this._alertCbs.get(key);
+                if (cb) try { cb({ key, value: val, threshold: cfg.threshold, metric: metrics }); } catch (_) {}
+            }
+        }
+    }
+
+    setAlert(key, threshold, unit = "", label = "", cb = null) {
+        this._alerts.set(key, { threshold, unit, label: label || key });
+        if (cb) this._alertCbs.set(key, cb);
+    }
+
+    onAlert(key, cb) { this._alertCbs.set(key, cb); }
+
+    record(endpoint, ok, ms, err = null) {
+        this.req.total++;
+        ok ? this.req.ok++ : this.req.fail++;
+
+        const ep = this.req.byEndpoint.get(endpoint) || {
+            total: 0, ok: 0, fail: 0, ms: [], avgMs: 0,
+        };
+        ep.total++; ok ? ep.ok++ : ep.fail++;
+        ep.ms.push(ms);
+        if (ep.ms.length > 200) ep.ms.shift();
+        ep.avgMs = ep.ms.reduce((a, b) => a + b, 0) / ep.ms.length;
+        this.req.byEndpoint.set(endpoint, ep);
+
+        this.perf.times.push(ms);
+        if (this.perf.times.length > this.perf.maxTimes) this.perf.times.shift();
+
+        if (ms > this.perf.threshold) {
+            this.perf.slow.push({ endpoint, ms, at: Date.now() });
+            if (this.perf.slow.length > this.perf.maxSlow) this.perf.slow.shift();
+        }
+
+        if (err) this._recordErr(err, endpoint);
+        this.sess.lastAct = Date.now();
+    }
+
+    _recordErr(err, ctx = "") {
+        this.errs.total++;
+        const type = err.errorType || err.name || "Unknown";
+        const code = err.errorCode || err.code || "N/A";
+        this.errs.byType.set(type, (this.errs.byType.get(type) || 0) + 1);
+        this.errs.byCode.set(code, (this.errs.byCode.get(code) || 0) + 1);
+        this.errs.recent.push({ type, code, msg: err.message, ctx, at: Date.now() });
+        if (this.errs.recent.length > this.errs.maxRecent) this.errs.recent.shift();
+    }
+
+    trackGate(type) {
+        this.gate.hits++;
+        if      (type === "cooldown")  this.gate.cooldowns++;
+        else if (type === "delayed")   this.gate.delayed++;
+        else if (type === "throttled") this.gate.throttled++;
+    }
+
+    trackRefresh()  { this.sess.refreshes++; }
+    trackReconnect(){ this.sess.reconnects++; }
+    trackRevive()   { this.sess.revives++; }
+    markLogin()     { this.sess.loginAt = Date.now(); }
+
+    _computePerf() {
+        if (!this.perf.times.length) return { avgMs: 0, p50: 0, p75: 0, p95: 0, p99: 0, max: 0 };
+        const sorted = [...this.perf.times].sort((a, b) => a - b);
+        return {
+            avgMs: Math.round(sorted.reduce((a, b) => a + b, 0) / sorted.length),
+            p50:   percentile(sorted, 50),
+            p75:   percentile(sorted, 75),
+            p95:   percentile(sorted, 95),
+            p99:   percentile(sorted, 99),
+            max:   sorted[sorted.length - 1],
+        };
+    }
+
+    getMetrics() {
+        const perf = this._computePerf();
+        return {
+            uptime:    Date.now() - this._start,
+            sessionMs: this.sess.loginAt ? Date.now() - this.sess.loginAt : 0,
+            requests: {
+                ...this.req,
+                byEndpoint:  Object.fromEntries(
+                    [...this.req.byEndpoint].map(([k, v]) => [k, { ...v, ms: undefined }])
+                ),
+                successRate: this.req.total
+                    ? ((this.req.ok / this.req.total) * 100).toFixed(2) + "%"
+                    : "N/A",
+            },
+            errors: {
+                ...this.errs,
+                byType: Object.fromEntries(this.errs.byType),
+                byCode: Object.fromEntries(this.errs.byCode),
+            },
+            perf: {
+                ...perf,
+                slowRequests: this.perf.slow.slice(-20),
+            },
+            session: this.sess,
+            gate:    this.gate,
+        };
+    }
+
+    getHealth() {
+        const m       = this.getMetrics();
+        const errRate = m.requests.total > 0 ? (m.errors.total / m.requests.total) * 100 : 0;
+        const checks  = {
+            errorRate:   { ok: errRate < 5,                label: "Error Rate",   value: errRate.toFixed(2) + "%" },
+            avgLatency:  { ok: m.perf.avgMs < 2000,        label: "Avg Latency",  value: m.perf.avgMs + "ms" },
+            p95Latency:  { ok: m.perf.p95 < 5000,          label: "P95 Latency",  value: m.perf.p95 + "ms" },
+            session:     { ok: !!m.session.loginAt,        label: "Session",      value: m.session.loginAt ? "active" : "inactive" },
+            rateLimiting:{ ok: m.gate.hits < 100,          label: "Rate Limiting",value: m.gate.hits + " hits" },
+        };
+        const failing = Object.values(checks).filter(c => !c.ok).length;
+        return {
+            status:  failing >= 3 ? "unhealthy" : failing > 0 ? "degraded" : "healthy",
+            score:   Math.round(((Object.values(checks).length - failing) / Object.values(checks).length) * 100),
+            checks,
+            at:      Date.now(),
+        };
+    }
+
+    getTimeSeries() { return [...this._timeSeries]; }
+
+    topEndpoints(n = 5) {
+        return [...this.req.byEndpoint.entries()]
+            .sort(([, a], [, b]) => b.total - a.total)
+            .slice(0, n)
+            .map(([ep, s]) => ({ endpoint: ep, ...s, ms: undefined }));
+    }
+
+    export() {
+        return JSON.stringify({
+            metrics:    this.getMetrics(),
+            health:     this.getHealth(),
+            timeSeries: this.getTimeSeries(),
+            top5:       this.topEndpoints(5),
+            exportedAt: new Date().toISOString(),
+        }, null, 2);
+    }
+
+    reset() {
+        this.req  = { total: 0, ok: 0, fail: 0, byEndpoint: new Map() };
+        this.errs = { total: 0, byType: new Map(), byCode: new Map(), recent: [], maxRecent: 200 };
+        this.perf = { times: [], maxTimes: 2000, slow: [], maxSlow: 100, threshold: 4000 };
+        this.gate = { hits: 0, cooldowns: 0, delayed: 0, throttled: 0 };
+    }
+
+    startReporting(interval = 60_000) {
+        if (this._timer) clearInterval(this._timer);
+        this._timer = setInterval(() => {
+            const m = this.getMetrics();
+            const h = this.getHealth();
+            log("Telemetry",
+                `[${h.status.toUpperCase()}] req:${m.requests.total} ok:${m.requests.ok} ` +
+                `fail:${m.requests.fail} avg:${m.perf.avgMs}ms p95:${m.perf.p95}ms errors:${m.errors.total}`
+            );
+        }, interval);
+        try { this._timer.unref(); } catch (_) {}
+    }
+
+    stopReporting() {
+        if (this._timer) { clearInterval(this._timer); this._timer = null; }
+    }
+
+    destroy() {
+        this.stopReporting();
+        if (this._seriesTimer) clearInterval(this._seriesTimer);
+    }
+}
+
+const globalMonitor = new Telemetry();
+
+module.exports = {
+    Telemetry,
+    globalMonitor,
+    ProductionMonitor: Telemetry,
+};

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

@@ -0,0 +1,93 @@
+"use strict";
+
+const cheerio = require("cheerio");
+const util    = require("util");
+
+async function json(url, jar, params, opts, ctx, customHeader) {
+    const net = require("./net");
+    const log = require("./logger");
+    try {
+        const res  = await net.get(url, jar, params, opts, ctx, customHeader);
+        const $    = cheerio.load(res.body);
+        const tags = $('script[type="application/json"]');
+        if (!tags.length) { log.warn("Tools", `No JSON blobs found on ${url}`); return []; }
+        const out = [];
+        tags.each((_, el) => {
+            try { const txt = $(el).html(); if (txt) out.push(JSON.parse(txt)); } catch (_) {}
+        });
+        return out;
+    } catch (err) {
+        require("./logger").error("Tools", `json() failed for ${url}:`, err);
+        throw err;
+    }
+}
+
+function makeDefaults(pageHtml, accountID, ctx) {
+    const net = require("./net");
+    const log = require("./logger");
+    let   seq = 1;
+    const rev = log.getFrom(pageHtml, 'revision":', ",");
+
+    function blend(obj) {
+        const base = {
+            av:       accountID,
+            __user:   accountID,
+            __req:    (seq++).toString(36),
+            __rev:    rev,
+            __a:      1,
+            ...(ctx && { fb_dtsg: ctx.fb_dtsg, jazoest: ctx.jazoest }),
+        };
+        if (!obj) return base;
+        for (const k in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, k) && !(k in base)) base[k] = obj[k];
+        }
+        return base;
+    }
+
+    return {
+        get:          (url, jar, params, ctxx, hdr = {}) => net.get(url, jar, blend(params), ctx?.globalOptions, ctxx || ctx, hdr),
+        post:         (url, jar, form,   ctxx, hdr = {}) => net.post(url, jar, blend(form), ctx?.globalOptions, ctxx || ctx, hdr),
+        postFormData: (url, jar, form, params, ctxx)     => net.postFormData(url, jar, blend(form), blend(params), ctx?.globalOptions, ctxx || ctx),
+    };
+}
+
+module.exports = {
+    ...require("./net"),
+    ...require("./response"),
+    ...require("./logger"),
+    ...require("./transform"),
+    ...require("./headers"),
+    ...require("./identity"),
+    ...require("./ghost"),
+    ...require("./revive"),
+    ...require("./gate"),
+    ...require("./auth"),
+    globalValidator:     require("./validator").globalValidator,
+    Validator:           require("./validator").Validator,
+    globalMonitor:       require("./telemetry").globalMonitor,
+    Telemetry:           require("./telemetry").Telemetry,
+    ProductionMonitor:   require("./telemetry").Telemetry,
+    CycleManager:        require("./heartbeat").CycleManager,
+    TokenRefreshManager: require("./heartbeat").TokenRefreshManager,
+    json,
+    makeDefaults,
+    promisify:    (fn) => util.promisify(fn),
+    delay:        (ms) => new Promise(r => setTimeout(r, ms)),
+    phantomBanner() {
+        const pkg = (() => { try { return require("../../package.json"); } catch (_) { return {}; } })();
+        const v   = pkg.version || "2.0.0";
+        const nm  = pkg.name    || "phantom-fca";
+        const lines = [
+            "",
+            "  ╔═══════════════════════════════════════╗",
+            `  ║         ${nm.padEnd(33)}║`,
+            `  ║  Version: ${v.padEnd(31)}║`,
+            "  ║  Stealth Mode: Active                 ║",
+            "  ║  Anti-Detection: Enabled              ║",
+            "  ╚═══════════════════════════════════════╝",
+            "",
+        ];
+        lines.forEach(l => console.log(l));
+    },
+    startupBanner() { this.phantomBanner(); },
+};

package/phantom/datastore/models/matrix/transform/cookieParser.js

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