fca-phantom 1.0.0

package/phantom/datastore/session.js

@@ -0,0 +1,129 @@
+"use strict";
+
+const fs   = require("fs");
+const path = require("path");
+
+const STORE_DIR  = process.cwd();
+const STORE_FILE = path.join(STORE_DIR, ".phantom_session.json");
+
+function _safeRead(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) return null;
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch (_) { return null; }
+}
+
+function _safeWrite(filePath, data) {
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+        return true;
+    } catch (_) { return false; }
+}
+
+async function backupAppStateSQL(jar, userID) {
+    try {
+        const fbCookies  = jar.getCookiesSync("https://www.facebook.com");
+        const msgCookies = jar.getCookiesSync("https://www.messenger.com");
+
+        const seen    = new Set();
+        const cookies = [];
+        for (const c of [...fbCookies, ...msgCookies]) {
+            if (seen.has(c.key)) continue;
+            seen.add(c.key);
+            cookies.push({
+                key:      c.key,
+                value:    c.value,
+                domain:   c.domain,
+                path:     c.path    || "/",
+                secure:   c.secure  ?? true,
+                httpOnly: c.httpOnly ?? false,
+                expires:  c.expires instanceof Date ? c.expires.getTime() : null,
+            });
+        }
+
+        if (!cookies.length) return false;
+
+        const existing = _safeRead(STORE_FILE) || { sessions: {} };
+        if (!existing.sessions) existing.sessions = {};
+
+        existing.sessions[userID] = {
+            userID,
+            cookies,
+            savedAt:   Date.now(),
+            savedDate: new Date().toISOString(),
+            version:   2,
+        };
+        existing.lastUserID  = userID;
+        existing.updatedAt   = Date.now();
+
+        return _safeWrite(STORE_FILE, existing);
+    } catch (_) { return false; }
+}
+
+async function hydrateJarFromDB(jar, userID) {
+    try {
+        const data = _safeRead(STORE_FILE);
+        if (!data) return false;
+
+        const targetUserID = userID || data.lastUserID;
+        const session      = data.sessions?.[targetUserID];
+
+        let cookies = session?.cookies;
+        if (!cookies && Array.isArray(data.cookies)) cookies = data.cookies;
+        if (!Array.isArray(cookies) || !cookies.length) return false;
+
+        const { Cookie } = require("tough-cookie");
+        for (const c of cookies) {
+            try {
+                if (c.expires && typeof c.expires === "number" && Date.now() > c.expires) continue;
+                const domain   = c.domain || ".facebook.com";
+                const domainUrl = `https://${domain.replace(/^\./, "")}`;
+                const cookie = new Cookie({
+                    key:      c.key,
+                    value:    c.value,
+                    domain,
+                    path:     c.path    || "/",
+                    secure:   c.secure  ?? true,
+                    httpOnly: c.httpOnly ?? false,
+                });
+                jar.setCookieSync(cookie, domainUrl);
+                if (domain.includes("facebook")) {
+                    jar.setCookieSync(new Cookie({ ...cookie, domain: ".messenger.com" }), "https://www.messenger.com");
+                }
+            } catch (_) {}
+        }
+        return true;
+    } catch (_) { return false; }
+}
+
+async function clearSessionStore(userID = null) {
+    try {
+        if (!fs.existsSync(STORE_FILE)) return;
+        if (!userID) {
+            fs.unlinkSync(STORE_FILE);
+        } else {
+            const data = _safeRead(STORE_FILE);
+            if (data?.sessions?.[userID]) {
+                delete data.sessions[userID];
+                _safeWrite(STORE_FILE, data);
+            }
+        }
+    } catch (_) {}
+}
+
+function listSessions() {
+    const data = _safeRead(STORE_FILE);
+    if (!data?.sessions) return [];
+    return Object.values(data.sessions).map(s => ({
+        userID:  s.userID,
+        savedAt: s.savedAt,
+        cookies: s.cookies?.length || 0,
+    }));
+}
+
+module.exports = {
+    backupAppStateSQL,
+    hydrateJarFromDB,
+    clearSessionStore,
+    listSessions,
+};

package/phantom/datastore/threads.js

@@ -0,0 +1,22 @@
+"use strict";
+
+module.exports = function createThreadData(api) {
+    const _store = new Map();
+    return {
+        get(threadID)         { return _store.get(String(threadID)) || null; },
+        set(threadID, data)   { _store.set(String(threadID), data); return data; },
+        delete(threadID)      { _store.delete(String(threadID)); },
+        has(threadID)         { return _store.has(String(threadID)); },
+        clear()               { _store.clear(); },
+        all()                 { return [..._store.entries()]; },
+        size()                { return _store.size; },
+        toArray()             { return [..._store.values()]; },
+        getIDs()              { return [..._store.keys()]; },
+        update(threadID, patch) {
+            const existing = _store.get(String(threadID)) || {};
+            const updated  = { ...existing, ...patch, updatedAt: Date.now() };
+            _store.set(String(threadID), updated);
+            return updated;
+        },
+    };
+};

package/phantom/datastore/users.js

@@ -0,0 +1,26 @@
+"use strict";
+
+module.exports = function createUserData(api) {
+    const _store = new Map();
+    return {
+        get(userID)         { return _store.get(String(userID)) || null; },
+        set(userID, data)   { _store.set(String(userID), data); return data; },
+        delete(userID)      { _store.delete(String(userID)); },
+        has(userID)         { return _store.has(String(userID)); },
+        clear()             { _store.clear(); },
+        all()               { return [..._store.entries()]; },
+        size()              { return _store.size; },
+        toArray()           { return [..._store.values()]; },
+        getIDs()            { return [..._store.keys()]; },
+        update(userID, patch) {
+            const existing = _store.get(String(userID)) || {};
+            const updated  = { ...existing, ...patch, updatedAt: Date.now() };
+            _store.set(String(userID), updated);
+            return updated;
+        },
+        findByName(name) {
+            const q = (name || "").toLowerCase();
+            return [..._store.values()].filter(u => (u.name || "").toLowerCase().includes(q));
+        },
+    };
+};

package/phantom/dispatch/addExternalModule.js

@@ -0,0 +1,239 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+const MODULE_REGISTRY = new Map();
+const MODULE_AUDIT_LOG = [];
+const MAX_AUDIT_LOG = 500;
+const DEPENDENCY_GRAPH = new Map();
+const MIDDLEWARE_PIPELINES = new Map();
+const MODULE_VERSIONS = new Map();
+const MODULE_HOOKS = new Map();
+
+function recordAudit(action, moduleName, meta = {}) {
+  const entry = { action, moduleName, ts: Date.now(), ...meta };
+  MODULE_AUDIT_LOG.unshift(entry);
+  if (MODULE_AUDIT_LOG.length > MAX_AUDIT_LOG) MODULE_AUDIT_LOG.length = MAX_AUDIT_LOG;
+}
+
+function detectCircularDependency(name, deps, visited = new Set()) {
+  if (visited.has(name)) return true;
+  visited.add(name);
+  const childDeps = DEPENDENCY_GRAPH.get(name) || [];
+  for (const dep of childDeps) {
+    if (deps.includes(dep) || detectCircularDependency(dep, deps, new Set(visited))) return true;
+  }
+  return false;
+}
+
+function buildMiddlewarePipeline(middlewares) {
+  return function pipeline(fn) {
+    return async function pipelined(...args) {
+      let i = 0;
+      const next = async (...nextArgs) => {
+        if (i < middlewares.length) {
+          const mid = middlewares[i++];
+          return mid(...(nextArgs.length ? nextArgs : args), next);
+        }
+        return fn(...(nextArgs.length ? nextArgs : args));
+      };
+      return next(...args);
+    };
+  };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  function validateModule(moduleObj) {
+    if (!moduleObj || typeof moduleObj !== 'object' || Array.isArray(moduleObj)) {
+      throw new TypeError(`addExternalModule: moduleObj must be a plain object, got ${utils.getType(moduleObj)}`);
+    }
+    const keys = Object.keys(moduleObj);
+    if (keys.length === 0) throw new Error('addExternalModule: moduleObj must have at least one key');
+
+    const errors = [];
+    for (const key of keys) {
+      const t = utils.getType(moduleObj[key]);
+      if (t !== 'Function' && t !== 'AsyncFunction') {
+        errors.push(`"${key}" must be a Function (got ${t})`);
+      }
+      if (/^(constructor|prototype|__proto__|toString|valueOf|hasOwnProperty)$/.test(key)) {
+        errors.push(`"${key}" is a reserved property name`);
+      }
+    }
+    if (errors.length) throw new Error(`addExternalModule: invalid entries — ${errors.join('; ')}`);
+    return keys;
+  }
+
+  function checkConflicts(keys, { overwrite = false, namespace = null } = {}) {
+    const conflicts = [];
+    const targetObj = namespace ? (api[namespace] || {}) : api;
+    for (const key of keys) {
+      if (Object.prototype.hasOwnProperty.call(targetObj, key) && !overwrite) {
+        conflicts.push(key);
+      }
+    }
+    if (conflicts.length) {
+      throw new Error(`addExternalModule: conflicting API keys (use overwrite:true to force): ${conflicts.join(', ')}`);
+    }
+  }
+
+  function applyNamespace(namespace, keys, builtFunctions) {
+    if (namespace) {
+      if (!api[namespace] || typeof api[namespace] !== 'object') api[namespace] = {};
+      for (const key of keys) api[namespace][key] = builtFunctions[key];
+      recordAudit('namespace_attach', namespace, { keys });
+    } else {
+      for (const key of keys) api[key] = builtFunctions[key];
+      recordAudit('global_attach', 'root', { keys });
+    }
+  }
+
+  function wrapWithTelemetry(name, fn) {
+    return async function telemetried(...args) {
+      const start = Date.now();
+      try {
+        const result = await fn(...args);
+        utils.log('addExternalModule', `[${name}] executed in ${Date.now() - start}ms`);
+        return result;
+      } catch (err) {
+        utils.error('addExternalModule', `[${name}] failed after ${Date.now() - start}ms:`, err.message || err);
+        throw err;
+      }
+    };
+  }
+
+  function wrapWithMiddleware(name, fn, middlewares) {
+    if (!middlewares || !middlewares.length) return fn;
+    const pipeline = buildMiddlewarePipeline(middlewares);
+    return pipeline(fn);
+  }
+
+  return function addExternalModule(moduleObj, options = {}) {
+    const {
+      overwrite = false,
+      namespace = null,
+      dependencies = [],
+      version = '1.0.0',
+      middlewares = [],
+      lazy = false,
+      description = '',
+      tags = []
+    } = typeof options === 'string' ? { namespace: options } : options;
+
+    const keys = validateModule(moduleObj);
+
+    if (dependencies.length) {
+      for (const dep of dependencies) {
+        if (!MODULE_REGISTRY.has(dep) && !api[dep]) {
+          throw new Error(`addExternalModule: unresolved dependency "${dep}" — install it first`);
+        }
+      }
+      if (detectCircularDependency(keys[0], dependencies)) {
+        throw new Error(`addExternalModule: circular dependency detected for ${keys.join(', ')}`);
+      }
+    }
+
+    checkConflicts(keys, { overwrite, namespace });
+
+    const builtFunctions = {};
+    const moduleName = namespace || keys.join('+');
+
+    for (const key of keys) {
+      const rawFn = moduleObj[key](defaultFuncs, api, ctx);
+      const t = utils.getType(rawFn);
+      if (t !== 'Function' && t !== 'AsyncFunction') {
+        throw new TypeError(`addExternalModule: factory for "${key}" must return a function, got ${t}`);
+      }
+
+      let wrappedFn = rawFn;
+
+      if (middlewares.length) wrappedFn = wrapWithMiddleware(key, wrappedFn, middlewares);
+      wrappedFn = wrapWithTelemetry(key, wrappedFn);
+
+      if (lazy) {
+        let cached = null;
+        const lazyFn = wrappedFn;
+        wrappedFn = function lazyWrapper(...args) {
+          if (!cached) cached = lazyFn;
+          return cached(...args);
+        };
+      }
+
+      builtFunctions[key] = wrappedFn;
+
+      const fullKey = namespace ? `${namespace}.${key}` : key;
+      MODULE_REGISTRY.set(fullKey, {
+        name: fullKey,
+        version,
+        description,
+        tags,
+        dependencies,
+        installedAt: Date.now(),
+        fn: wrappedFn
+      });
+    }
+
+    if (dependencies.length) DEPENDENCY_GRAPH.set(moduleName, dependencies);
+    if (middlewares.length) MIDDLEWARE_PIPELINES.set(moduleName, middlewares);
+    MODULE_VERSIONS.set(moduleName, version);
+
+    if (MODULE_HOOKS.has('beforeAttach')) {
+      for (const hook of MODULE_HOOKS.get('beforeAttach')) {
+        try { hook({ moduleName, keys, version }); } catch (_) {}
+      }
+    }
+
+    applyNamespace(namespace, keys, builtFunctions);
+
+    if (MODULE_HOOKS.has('afterAttach')) {
+      for (const hook of MODULE_HOOKS.get('afterAttach')) {
+        try { hook({ moduleName, keys, version }); } catch (_) {}
+      }
+    }
+
+    utils.log('addExternalModule', `Installed [${moduleName}] v${version} — keys: ${keys.join(', ')}${namespace ? ` (namespace: ${namespace})` : ''}`);
+
+    return {
+      success: true,
+      installedKeys: keys,
+      namespace: namespace || null,
+      version,
+      moduleName,
+      removeModule() {
+        const target = namespace ? api[namespace] : api;
+        for (const key of keys) {
+          if (target) delete target[key];
+          MODULE_REGISTRY.delete(namespace ? `${namespace}.${key}` : key);
+        }
+        DEPENDENCY_GRAPH.delete(moduleName);
+        MODULE_VERSIONS.delete(moduleName);
+        recordAudit('remove', moduleName);
+        utils.log('addExternalModule', `Removed [${moduleName}]`);
+        return { success: true, removedKeys: keys };
+      },
+      updateModule(newModuleObj, newOpts = {}) {
+        return addExternalModule(newModuleObj, { ...options, ...newOpts, overwrite: true });
+      }
+    };
+  };
+
+  Object.assign(module.exports, {
+    getRegistry: () => Object.fromEntries(MODULE_REGISTRY),
+    getAuditLog: (limit = 50) => MODULE_AUDIT_LOG.slice(0, limit),
+    getDependencyGraph: () => Object.fromEntries(DEPENDENCY_GRAPH),
+    getVersions: () => Object.fromEntries(MODULE_VERSIONS),
+    isInstalled: (key) => MODULE_REGISTRY.has(key),
+    addHook(event, fn) {
+      if (!MODULE_HOOKS.has(event)) MODULE_HOOKS.set(event, []);
+      MODULE_HOOKS.get(event).push(fn);
+    },
+    clearRegistry() {
+      MODULE_REGISTRY.clear();
+      DEPENDENCY_GRAPH.clear();
+      MODULE_VERSIONS.clear();
+      MODULE_AUDIT_LOG.length = 0;
+      utils.log('addExternalModule', 'Registry cleared');
+    }
+  });
+};

package/phantom/dispatch/addUserToGroup.js

@@ -0,0 +1,161 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const CACHE = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+
+function cacheSet(key, val) { CACHE.set(key, { val, ts: Date.now() }); }
+function cacheGet(key) {
+  const e = CACHE.get(key);
+  if (!e) return null;
+  if (Date.now() - e.ts > CACHE_TTL) { CACHE.delete(key); return null; }
+  return e.val;
+}
+
+async function retryOp(fn, retries = 3, base = 600) {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      if (i === retries - 1) throw err;
+      await new Promise(r => setTimeout(r, base * Math.pow(2, i) + Math.random() * 300));
+    }
+  }
+}
+
+async function mqttAddUsers(ctx, userIDs, threadID) {
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const payload = {
+      epoch_id: utils.generateOfflineThreadingID(),
+      tasks: [{
+        failure_count: null,
+        label: "23",
+        payload: JSON.stringify({
+          thread_key: threadID,
+          contact_ids: userIDs.map(id => String(id)),
+          sync_group: 1
+        }),
+        queue_name: threadID.toString(),
+        task_id: taskID
+      }],
+      version_id: "24502707779384158"
+    };
+
+    const form = JSON.stringify({
+      app_id: "772021112871879",
+      payload: JSON.stringify(payload),
+      request_id: reqID,
+      type: 3
+    });
+
+    let handled = false;
+    const handleRes = (topic, message) => {
+      if (topic !== "/ls_resp" || handled) return;
+      let j;
+      try { j = JSON.parse(message.toString()); j.payload = JSON.parse(j.payload); } catch { return; }
+      if (j.request_id !== reqID) return;
+      handled = true;
+      clearTimeout(timer);
+      ctx.mqttClient.removeListener("message", handleRes);
+      resolve({ success: true, addedUsers: userIDs, threadID, response: j.payload });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener("message", handleRes);
+        reject(new Error("MQTT timeout waiting for addUserToGroup response"));
+      }
+    }, 30000);
+
+    ctx.mqttClient.on("message", handleRes);
+    ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener("message", handleRes);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function httpAddUsers(defaultFuncs, ctx, userIDs, threadID) {
+  const form = {
+    fb_api_caller_class: "RelayModern",
+    fb_api_req_friendly_name: "MessengerAddMembersMutation",
+    doc_id: "6564756290218688",
+    variables: JSON.stringify({
+      input: {
+        thread_fbid: threadID,
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000)),
+        user_ids: userIDs.map(String)
+      }
+    }),
+    av: ctx.userID
+  };
+
+  const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (res && res.errors && res.errors.length) throw new Error(JSON.stringify(res.errors));
+  return { success: true, addedUsers: userIDs, threadID, method: "graphql" };
+}
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function addUserToGroup(userID, threadID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== "function") {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!threadID) throw new Error("addUserToGroup: threadID is required");
+
+      const t = utils.getType(threadID);
+      if (t !== "Number" && t !== "String") throw new Error("addUserToGroup: threadID must be a Number or String");
+
+      const userIDs = Array.isArray(userID) ? userID : [userID];
+      if (userIDs.length === 0) throw new Error("addUserToGroup: at least one userID is required");
+
+      const cacheKey = `addUser_${threadID}_${userIDs.sort().join(",")}`;
+      const cached = cacheGet(cacheKey);
+      if (cached) return callback(null, cached);
+
+      await globalShield.addSmartDelay();
+
+      let result;
+
+      if (ctx.mqttClient) {
+        try {
+          result = await retryOp(() => mqttAddUsers(ctx, userIDs, threadID));
+        } catch (mqttErr) {
+          utils.warn("addUserToGroup", "MQTT failed, falling back to HTTP:", mqttErr.message);
+          result = await retryOp(() => httpAddUsers(defaultFuncs, ctx, userIDs, threadID));
+        }
+      } else {
+        result = await retryOp(() => httpAddUsers(defaultFuncs, ctx, userIDs, threadID));
+      }
+
+      cacheSet(cacheKey, result);
+      callback(null, result);
+    } catch (err) {
+      utils.error("addUserToGroup", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};