fca-phantom 1.0.0

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

@@ -0,0 +1,114 @@
+"use strict";
+
+const { CookieJar, Cookie } = require("tough-cookie");
+
+const FB_DOMAINS = ["https://www.facebook.com", "https://www.messenger.com"];
+
+function normalizeCookieHeaderString(raw) {
+    if (!raw || typeof raw !== "string") return [];
+    return raw
+        .split(/\s*;\s*/)
+        .filter(p => {
+            const eq  = p.indexOf("=");
+            const key = eq !== -1 ? p.slice(0, eq).trim() : p.trim();
+            return key && eq !== -1;
+        });
+}
+
+function setJarFromPairs(jar, pairs, domains = FB_DOMAINS) {
+    if (!pairs) return;
+    const list = Array.isArray(pairs) ? pairs : [pairs];
+    for (const pair of list) {
+        const raw = typeof pair === "string" ? pair.trim() : null;
+        if (!raw) continue;
+        const eq = raw.indexOf("=");
+        if (eq === -1) continue;
+        const name  = raw.slice(0, eq).trim();
+        const value = raw.slice(eq + 1).trim();
+        if (!name) continue;
+        for (const domain of domains) {
+            try {
+                const cookie = new Cookie({
+                    key:      name,
+                    value,
+                    domain:   "." + new URL(domain).hostname,
+                    path:     "/",
+                    secure:   true,
+                    httpOnly: false,
+                });
+                jar.setCookieSync(cookie, domain);
+            } catch (_) {}
+        }
+    }
+}
+
+function fromStatePairs(statePairs) {
+    const jar = new CookieJar();
+    if (!Array.isArray(statePairs)) return jar;
+    for (const c of statePairs) {
+        if (!c || typeof c !== "object") continue;
+        try {
+            const domain   = c.domain   || ".facebook.com";
+            const domainUrl = `https://${domain.replace(/^\./, "")}`;
+            const cookie = new Cookie({
+                key:      c.key   || c.name  || "",
+                value:    String(c.value ?? ""),
+                domain,
+                path:     c.path     || "/",
+                secure:   c.secure   ?? true,
+                httpOnly: c.httpOnly ?? false,
+                expires:  c.expires  ? new Date(c.expires) : undefined,
+            });
+            jar.setCookieSync(cookie, domainUrl);
+        } catch (_) {}
+    }
+    return jar;
+}
+
+function jarToArray(jar, domains = FB_DOMAINS) {
+    const seen = new Set();
+    const out  = [];
+    for (const domain of domains) {
+        const cookies = jar.getCookiesSync(domain);
+        for (const c of cookies) {
+            if (seen.has(c.key)) continue;
+            seen.add(c.key);
+            out.push({
+                key:      c.key,
+                value:    c.value,
+                domain:   c.domain,
+                path:     c.path,
+                secure:   c.secure,
+                httpOnly: c.httpOnly,
+                expires:  c.expires,
+            });
+        }
+    }
+    return out;
+}
+
+function mergeCookieArrays(...arrays) {
+    const map = new Map();
+    for (const arr of arrays) {
+        if (!Array.isArray(arr)) continue;
+        for (const c of arr) {
+            const k = c.key || c.name;
+            if (k) map.set(k, c);
+        }
+    }
+    return [...map.values()];
+}
+
+function hasCriticalCookies(cookieArray) {
+    const names = (cookieArray || []).map(c => c.key || c.name).filter(Boolean);
+    return names.includes("c_user") && names.includes("xs");
+}
+
+module.exports = {
+    normalizeCookieHeaderString,
+    setJarFromPairs,
+    fromStatePairs,
+    jarToArray,
+    mergeCookieArrays,
+    hasCriticalCookies,
+};

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

@@ -0,0 +1,203 @@
+"use strict";
+
+const cookieParser = require("./cookies");
+const { getType, padZeros, NUM_TO_MONTH, NUM_TO_DAY, isReadableStream } = require("../logger");
+const url    = require("url");
+const qs     = require("querystring");
+const stream = require("stream");
+
+function getExtension(ext, fileName = "") {
+    if (ext) return ext;
+    const parts = fileName.split(".");
+    return parts.length > 1 ? parts.pop().toLowerCase() : "";
+}
+
+const ATTACH_HANDLERS = {
+    StickerAttachment: (blob) => ({
+        type:         "sticker",
+        ID:           blob.id,
+        url:          blob.thread_image?.uri || blob.url,
+        packID:       blob.pack?.id,
+        width:        blob.frame_size?.width,
+        height:       blob.frame_size?.height,
+        frameCount:   blob.frame_count,
+        frameRate:    blob.frame_rate,
+        framesPerRow: blob.frames_per_row,
+        framesPerCol: blob.frames_per_column,
+        label:        blob.label,
+    }),
+    MessageImage: (blob, a2) => ({
+        type:           "photo",
+        ID:             blob.legacy_attachment_id || blob.id || a2?.id || "",
+        filename:       blob.filename || (blob.legacy_attachment_id + ".jpg"),
+        fileSize:       Number(blob.large_image?.size || blob.preview?.size || 0),
+        width:          blob.large_image?.width  || blob.preview?.width  || 0,
+        height:         blob.large_image?.height || blob.preview?.height || 0,
+        url:            blob.large_image?.uri    || blob.preview?.uri    || null,
+        thumbnailUrl:   blob.thumbnail?.uri      || null,
+        previewUrl:     blob.preview?.uri        || null,
+        largePreviewUrl:blob.large_preview?.uri  || null,
+        mimeType:       blob.original_extension ? `image/${blob.original_extension}` : "image/jpeg",
+    }),
+    MessageVideo: (blob, a2) => ({
+        type:         "video",
+        ID:           blob.legacy_attachment_id || blob.id || a2?.id || "",
+        filename:     blob.filename || "video.mp4",
+        fileSize:     Number(blob.attachment_video_data?.video_file_size || 0),
+        duration:     blob.attachment_video_data?.video_length || 0,
+        url:          blob.attachment_video_data?.video_hd_url ||
+                      blob.attachment_video_data?.video_sd_url || null,
+        thumbnailUrl: blob.attachment_video_data?.video_image?.uri || null,
+        mimeType:     "video/mp4",
+    }),
+    MessageFile: (blob, a2) => ({
+        type:     "file",
+        ID:       blob.legacy_attachment_id || blob.id || a2?.id || "",
+        filename: blob.filename || "file",
+        fileSize: Number(blob.filesize || 0),
+        url:      blob.url || null,
+        mimeType: blob.content_type || "application/octet-stream",
+    }),
+    MessageAudio: (blob, a2) => ({
+        type:        "audio",
+        ID:          blob.legacy_attachment_id || blob.id || a2?.id || "",
+        filename:    blob.filename || "audio",
+        duration:    Number(blob.playable_duration_in_ms || 0),
+        url:         blob.playable_url || null,
+        mimeType:    blob.content_type || "audio/mpeg",
+        isVoiceMail: !!blob.is_voicemail,
+    }),
+    ExternalUrl: (blob) => ({
+        type:        "share",
+        ID:          blob.url,
+        url:         blob.url,
+        title:       blob.title || "",
+        description: blob.description?.text || "",
+        source:      blob.source,
+        favicon:     blob.icon?.uri || null,
+    }),
+    Photo: (blob, a2) => ({
+        type:     "photo",
+        ID:       blob.legacy_attachment_id || blob.id || a2?.id || "",
+        url:      blob.large_image?.uri || blob.preview?.uri || null,
+        mimeType: "image/jpeg",
+    }),
+};
+
+function formatAttachment(a1, a2) {
+    const blob = a1.mercury || a1.blob_attachment || a1.sticker_attachment;
+    const tp   = blob?.__typename || a1.attach_type;
+
+    if (!tp && a1.id != null && !a1.extensible_attachment) {
+        return { type: "share", ID: a1.id, url: a1.href || null, title: "Shared Content", isUnrecognized: true };
+    }
+
+    if (!a1.attach_type && a1.imageMetadata) {
+        return {
+            type:     "photo",
+            ID:       a1.fbid,
+            filename: a1.filename,
+            fileSize: Number(a1.fileSize || 0),
+            mimeType: a1.mimeType,
+            width:    a1.imageMetadata.width,
+            height:   a1.imageMetadata.height,
+        };
+    }
+
+    if (ATTACH_HANDLERS[tp]) return ATTACH_HANDLERS[tp](blob || a1, a2);
+
+    if (a1.extensible_attachment?.story_attachment?.target?.__typename === "ExternalUrl") {
+        const ext = a1.extensible_attachment.story_attachment;
+        return {
+            type:        "share",
+            ID:          ext.url_share_data?.share_id || "",
+            url:         ext.url_share_data?.share_url || ext.target?.url || "",
+            title:       ext.title_with_entities?.text || "",
+            description: ext.description?.text || "",
+            source:      ext.source?.text || null,
+            media:       ext.media?.image?.uri || null,
+        };
+    }
+
+    return { type: tp || "unknown", ID: blob?.id || a1.id || "", raw: a1 };
+}
+
+function formatDeltaMessage(d) {
+    const msg  = d.message;
+    const body = msg?.text || "";
+
+    const rawAtts = [];
+    if (msg?.sticker_attachment) rawAtts.push(msg.sticker_attachment);
+    if (Array.isArray(msg?.blob_attachments)) rawAtts.push(...msg.blob_attachments);
+    if (Array.isArray(d.attachments)) rawAtts.push(...d.attachments);
+    const atts = rawAtts.filter(Boolean).map(a => formatAttachment(a));
+
+    const participants = d.participants || [];
+    const senderID     = participants.find(p => p !== d.threadKey?.otherUserFbId)
+        || d.actorFbId || d.actor_fbid || "";
+    const threadID     = d.threadKey?.threadFbId || d.threadKey?.otherUserFbId || "";
+    const messageID    = d.messageId || d.message_id || "";
+
+    const mentions = {};
+    if (msg?.text && Array.isArray(d.mentionOffsets)) {
+        d.mentionOffsets.forEach((offset, i) => {
+            const len = d.mentionLengths?.[i];
+            const uid = d.mentionUIDs?.[i];
+            if (uid && len != null) mentions[uid] = msg.text.substr(offset, len);
+        });
+    }
+
+    return {
+        type:        "message",
+        senderID:    String(senderID),
+        body,
+        threadID:    String(threadID),
+        messageID:   String(messageID),
+        attachments: atts,
+        mentions,
+        isGroup:     !!d.threadKey?.threadFbId,
+        isUnread:    false,
+        isRead:      false,
+        timestamp:   msg?.timestamp_precise ? Number(msg.timestamp_precise) : Date.now(),
+    };
+}
+
+function formatID(n) { return String(n || ""); }
+
+function formatDuration(ms) {
+    ms = Number(ms);
+    if (!isFinite(ms) || ms < 0) return "0s";
+    const s = Math.floor(ms / 1000);
+    const m = Math.floor(s / 60);
+    const h = Math.floor(m / 60);
+    const d = Math.floor(h / 24);
+    if (d > 0) return `${d}d ${h % 24}h`;
+    if (h > 0) return `${h}h ${m % 60}m`;
+    if (m > 0) return `${m}m ${s % 60}s`;
+    return `${s}s`;
+}
+
+function formatFileSize(bytes) {
+    if (bytes < 1024)        return `${bytes}B`;
+    if (bytes < 1024 ** 2)   return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 ** 3)   return `${(bytes / 1024 ** 2).toFixed(1)}MB`;
+    return `${(bytes / 1024 ** 3).toFixed(2)}GB`;
+}
+
+function formatTimestamp(ms) {
+    const d   = new Date(ms || Date.now());
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+           `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+module.exports = {
+    ...cookieParser,
+    getExtension,
+    formatAttachment,
+    formatDeltaMessage,
+    formatID,
+    formatDuration,
+    formatFileSize,
+    formatTimestamp,
+};

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

@@ -0,0 +1,157 @@
+"use strict";
+
+const RULES = {
+    required:  (v) => v != null && v !== "",
+    string:    (v) => typeof v === "string",
+    number:    (v) => typeof v === "number" && isFinite(v),
+    boolean:   (v) => typeof v === "boolean",
+    array:     (v) => Array.isArray(v),
+    object:    (v) => v !== null && typeof v === "object" && !Array.isArray(v),
+    positive:  (v) => typeof v === "number" && v > 0,
+    nonEmpty:  (v) => (typeof v === "string" && v.trim().length > 0) || (Array.isArray(v) && v.length > 0),
+    url:       (v) => { try { new URL(String(v)); return true; } catch (_) { return false; } },
+    email:     (v) => /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(String(v || "")),
+    numericID: (v) => !!v && /^\d{1,20}$/.test(String(v).trim()),
+};
+
+class ValidationError extends Error {
+    constructor(field, rule, value, message) {
+        super(message || `Validation failed for '${field}' (rule: ${rule})`);
+        this.name = "ValidationError";
+        this.field = field;
+        this.rule  = rule;
+        this.value = value;
+    }
+}
+
+class Validator {
+    constructor() {
+        this.maxMessageLength = 20_000;
+        this.maxThreadName    = 255;
+        this.maxNickname      = 50;
+        this.maxReactionLen   = 8;
+        this._customRules     = new Map();
+    }
+
+    addRule(name, fn) {
+        if (typeof fn !== "function") throw new TypeError("Rule must be a function");
+        this._customRules.set(name, fn);
+        return this;
+    }
+
+    check(value, ruleName, field = "value") {
+        const fn = this._customRules.get(ruleName) || RULES[ruleName];
+        if (!fn) throw new Error(`Unknown rule: ${ruleName}`);
+        return fn(value);
+    }
+
+    validate(data, schema) {
+        const errors = [];
+        for (const [field, rules] of Object.entries(schema)) {
+            const value = data?.[field];
+            for (const rule of (Array.isArray(rules) ? rules : [rules])) {
+                const name = typeof rule === "string" ? rule : rule.rule;
+                const fn   = this._customRules.get(name) || RULES[name];
+                if (!fn) continue;
+                const opts = typeof rule === "object" ? rule : {};
+                if (!fn(value, opts)) {
+                    errors.push(new ValidationError(field, name, value, opts.message));
+                    break;
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+
+    isValidID(id)       { return !!id && /^\d{1,20}$/.test(String(id).trim()); }
+    isValidThreadID(id) { return this.isValidID(id); }
+    isValidUserID(id)   { return this.isValidID(id); }
+    isValidGroupID(id)  { return this.isValidID(id); }
+    isValidMessageID(id){ return typeof id === "string" && id.length > 0 && id.length <= 50; }
+
+    isValidMessage(msg) {
+        if (typeof msg === "string") return msg.length > 0 && msg.length <= this.maxMessageLength;
+        if (msg && typeof msg === "object") {
+            return !!(msg.body || msg.sticker || msg.attachment || msg.emoji ||
+                     msg.url  || msg.mentions || msg.location);
+        }
+        return false;
+    }
+
+    sanitizeMessage(msg) {
+        if (typeof msg !== "string") return msg;
+        return msg
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
+            .trim()
+            .slice(0, this.maxMessageLength);
+    }
+
+    isValidURL(url) {
+        try { const u = new URL(url); return ["http:", "https:"].includes(u.protocol); }
+        catch (_) { return false; }
+    }
+
+    isValidImageURL(url) {
+        return this.isValidURL(url) && /\.(jpg|jpeg|png|gif|webp|bmp|svg|avif|heic)(\?.*)?$/i.test(url);
+    }
+
+    isValidVideoURL(url) {
+        return this.isValidURL(url) && /\.(mp4|webm|mov|avi|mkv|3gp)(\?.*)?$/i.test(url);
+    }
+
+    isValidEmail(email) { return RULES.email(email); }
+
+    isValidReaction(reaction) {
+        if (!reaction || typeof reaction !== "string") return false;
+        const r = reaction.trim();
+        return r.length > 0 && r.length <= this.maxReactionLen;
+    }
+
+    isValidThreadName(name) {
+        return typeof name === "string" && name.trim().length > 0 && name.length <= this.maxThreadName;
+    }
+
+    isValidNickname(nick) {
+        return typeof nick === "string" && nick.length <= this.maxNickname;
+    }
+
+    isValidColor(color) {
+        return typeof color === "string" && /^(#[0-9A-Fa-f]{6}|#[0-9A-Fa-f]{3}|[a-zA-Z]+)$/.test(color.trim());
+    }
+
+    isValidAttachment(att) {
+        if (!att || typeof att !== "object") return false;
+        return !!(att.type && (att.url || att.path || att.data));
+    }
+
+    sanitizeID(id) {
+        const s = String(id || "").trim().replace(/\D/g, "");
+        return s.length > 0 && s.length <= 20 ? s : null;
+    }
+
+    sanitizeOptions(opts, defaults = {}) {
+        if (!opts || typeof opts !== "object") return { ...defaults };
+        const clean = { ...defaults };
+        for (const [k, v] of Object.entries(opts)) {
+            if (Object.prototype.hasOwnProperty.call(defaults, k)) {
+                clean[k] = typeof defaults[k] === typeof v ? v : defaults[k];
+            }
+        }
+        return clean;
+    }
+
+    coerce(value, type) {
+        switch (type) {
+            case "string":  return String(value ?? "");
+            case "number":  return Number(value) || 0;
+            case "boolean": return Boolean(value);
+            case "array":   return Array.isArray(value) ? value : [value].filter(v => v != null);
+            case "id":      return this.sanitizeID(value);
+            default:        return value;
+        }
+    }
+}
+
+const globalValidator = new Validator();
+
+module.exports = { Validator, ValidationError, globalValidator, RULES };