shadowx-fca 8.0.0

package/src/getThreadTheme.js

@@ -0,0 +1,77 @@
+/**
+ * ===========================================================
+ * 🔰 Owner & Developer
+ * -----------------------------------------------------------
+ * 🕊️ Respect the creator & give proper credits if reused.
+ * ===========================================================
+ */
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadTheme(themeID, callback) {
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (!themeID) {
+      return callback({ error: "themeID is required" });
+    }
+
+    const form = {
+      av: ctx.userID,
+      __user: ctx.userID,
+      __a: 1,
+      __req: utils.getSignatureID(),
+      fb_dtsg: ctx.fb_dtsg,
+      jazoest: ctx.ttstamp,
+      lsd: ctx.fb_dtsg,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWPThreadThemeProviderQuery",
+      variables: JSON.stringify({
+        id: themeID.toString() // <-- THEME ID instead of threadID
+      }),
+      server_timestamps: true,
+      doc_id: "9734829906576883"
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) throw resData.errors;
+
+        if (resData.data && resData.data.messenger_thread_theme) {
+          const themeData = resData.data.messenger_thread_theme;
+          return callback(null, {
+            id: themeData.id,
+            name: themeData.accessibility_label,
+            description: themeData.description,
+            colors: themeData.gradient_colors || [themeData.fallback_color],
+            backgroundImage: themeData.background_asset
+              ? themeData.background_asset.image.uri
+              : null
+          });
+        } else {
+          throw new Error("No theme data found");
+        }
+      })
+      .catch(function (err) {
+        log.error("getThreadTheme", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/getUID.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getUID(url, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.get(url, ctx.jar, {})
+            .then(res => {
+                var m = (res.body || "").match(/"profile_id":"(\d+)"/);
+                if (!m) m = (res.body || "").match(/"entity_id":"(\d+)"/);
+                if (!m) m = (res.body || "").match(/"userID":"(\d+)"/);
+                if (m && m[1]) return cb(null, m[1]);
+                cb({ error: "Could not extract UID from: " + url });
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getUserID.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getUserID(name, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.get("https://www.facebook.com/public/" + encodeURIComponent(name), ctx.jar, {})
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                var data = [];
+                var matches = (resData.body || "").matchAll(/"userID":"(\d+)"/g);
+                for (var m of matches) if (!data.includes(m[1])) data.push(m[1]);
+                cb(null, data);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/getUserInfo.js

@@ -0,0 +1,28 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function getUserInfo(id, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        if (utils.getType(id) !== "Array") id = [id];
+        var form = {};
+        id.forEach((v, i) => { form["ids[" + i + "]"] = v; });
+        defaultFuncs.post("https://www.facebook.com/chat/user_info/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.error) throw resData;
+                var profiles = resData.payload.profiles;
+                var ret = {};
+                for (var prop in profiles) {
+                    var p = profiles[prop];
+                    ret[prop] = {
+                        name: p.name, firstName: p.firstName, vanity: p.vanity,
+                        thumbSrc: p.thumbSrc, profileUrl: p.uri, gender: p.gender,
+                        type: p.type, isFriend: p.is_friend, isBirthday: !!p.is_birthday
+                    };
+                }
+                cb(null, ret);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/handleFriendRequest.js

@@ -0,0 +1,21 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function handleFriendRequest(userID, accept, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/requests/friends/ajax/", ctx.jar, {
+            viewer_id: ctx.userID,
+            "frefs[0]": "jwl",
+            floc: "friend_center_requests",
+            ref: "/reqs.php",
+            action: accept ? "confirm" : "reject"
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => {
+                if (resData.payload && resData.payload.err) throw { err: resData.payload.err };
+                cb(null, true);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/handleMessageRequest.js

@@ -0,0 +1,15 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function handleMessageRequest(threadID, accept, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/filteredmessages.php", ctx.jar, {
+            action: accept ? "accept" : "ignore",
+            thread_fbids: Array.isArray(threadID) ? threadID : [threadID]
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/httpGet.js

@@ -0,0 +1,13 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function httpGet(url, form, callback) {
+        if (typeof form === "function") { callback = form; form = {}; }
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.get(url, ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(data => cb(null, data))
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/httpPost.js

@@ -0,0 +1,12 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function httpPost(url, form, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post(url, ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(data => cb(null, data))
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/httpPostFormData.js

@@ -0,0 +1,12 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function httpPostFormData(url, form, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.postFormData(url, ctx.jar, form, {})
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(data => cb(null, data))
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/listenE2EE.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var logger = require("../logger");
+var EventEmitter = require("events");
+
+/**
+ * listenE2EE — merges E2EE messages into the same event stream as MQTT.
+ *
+ * Usage (identical to api.listen):
+ *   api.listenE2EE(callback)   // Node-style callback(err, event)
+ *   api.listenE2EE()           // returns MessageEmitter
+ *
+ * Combines:
+ *   - Regular MQTT messages    (from api.listenMqtt)
+ *   - E2EE encrypted messages  (received via SHADOWX native Noise WebSocket)
+ *
+ * All events share the same shape (type, senderID, threadID, body, etc.),
+ * with E2EE events carrying `isE2EE: true`.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    return function listenE2EE(callback) {
+        class CombinedEmitter extends EventEmitter {
+            stopListening(cb) {
+                if (api._mqttEmitter && typeof api._mqttEmitter.stopListening === "function") {
+                    api._mqttEmitter.stopListening(cb);
+                } else if (typeof cb === "function") {
+                    cb([]);
+                }
+                if (ctx.e2ee && ctx.e2ee.connected) {
+                    ctx.e2ee.disconnect().catch(() => {});
+                }
+            }
+            stopListeningAsync() {
+                return new Promise(res => this.stopListening(res));
+            }
+        }
+
+        var emitter = new CombinedEmitter();
+
+        var isCallbackMode = typeof callback === "function";
+        var globalCallback = isCallbackMode ? callback : function (err, event) {
+            if (err) return emitter.emit("error", err);
+            emitter.emit("message", event);
+        };
+
+// Start regular MQTT listener
+        var mqttEmitter = api.listenMqtt(globalCallback);
+        api._mqttEmitter = mqttEmitter;
+
+// Hook E2EE incoming messages (SHADOWX native Noise WebSocket)
+        var e2ee = api.e2ee || ctx.e2ee;
+        if (!e2ee || !e2ee.isConnected()) {
+            logger.warn(
+                "listenE2EE",
+                "E2EE not connected. E2EE messages will not be received. " +
+                "Call api.connectE2EE() before listenE2EE() to enable encrypted message reception."
+            );
+        } else {
+            e2ee.onMessage(function (err, event) {
+                if (err) return globalCallback(err, null);
+                if (!event) return;
+
+                // Filter self-messages unless selfListen is enabled
+                if (!ctx.globalOptions.selfListen && event.senderID === ctx.userID) return;
+
+                event.isE2EE = true;
+                globalCallback(null, event);
+            });
+
+            logger.success("listenE2EE", "Combined MQTT + E2EE (Signal/Noise) listener active.");
+        }
+
+        return emitter;
+    };
+};