shadowx-fca 8.0.0

package/src/listenNotification.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var utils = require('../utils');
+//NethWs3Dev
+var EventEmitter = require('node:events');
+
+function format(res, globalCallback) {
+  var checkMinutes = (date_1, date_2) => {
+    let ms_1 = date_1.getTime();
+    let ms_2 = date_2.getTime();
+    return Math.ceil((ms_2 - ms_1) / (60 * 1000));
+  }
+
+  for (let index of res.notifications_page.edges) {
+    if (index.node.row_type !== 'NOTIFICATION') continue;
+
+    var timestamp = index.node.notif.creation_time.timestamp;
+    if (checkMinutes(new Date(timestamp * 1000), new Date()) <= 1) 
+      globalCallback(null, {
+        id: res.node.notif.id,
+        noti_id: res.node.notif.notif_id,
+        body: index.node.notif.body.text,
+        url: index.node.notif.url,
+        timestamp: timestamp * 1000
+      });
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  let globalCallback, interval;
+
+  function MessageRepeat() {
+    interval = setInterval(function () {
+      return defaultFuncs
+        .post('https://www.facebook.com/api/graphql/', ctx.jar, {
+          fb_api_req_friendly_name: 'CometNotificationsRootQuery',
+          doc_id: 6663491207045267,
+          variables: JSON.stringify({
+            count: 5,
+            environment: 'MAIN_SURFACE',
+            filter_tokens: ['Cg8CZnQPA2FsbAE='],
+            scale: 1
+          }),
+          server_timestamps: !0
+        })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (res) {
+          if (res.error || res.errors) 
+            throw res;
+
+          return format(res.data.viewer, globalCallback);
+        })
+        .catch(function (err) {
+          utils.error('listenNotification', err);
+          clearInterval(interval);
+          interval = void 0;
+          return globalCallback(err);
+        });
+    }, 60 * 1000);
+  }
+
+  return function notification(callback) {
+    class MessageEmitter extends EventEmitter {
+      stop() {
+        globalCallback = () => {}
+
+        if (interval) {
+          clearInterval(interval);
+          interval = void 0;
+        }
+        Message.emit('stop', new Date());
+      }
+    }
+
+    var Message = new MessageEmitter();
+
+    if (typeof callback == 'function')
+      globalCallback = callback;
+    else 
+      globalCallback = (error, message) => error ? Message.emit('error', error) : Message.emit('message', message);
+
+    MessageRepeat();
+    return Message;
+  }
+}

package/src/logout.js

@@ -0,0 +1,22 @@
+"use strict";
+var utils = require("../utils");
+var logger = require("../logger");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function logout(callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        if (api.stopListening) {
+            try { api.stopListening(); } catch (_) { }
+        }
+        defaultFuncs.post("https://www.facebook.com/logout.php", ctx.jar, {
+            ref: "mb",
+            h: ctx.fb_dtsg || ""
+        })
+            .then(() => {
+                ctx.loggedIn = false;
+                logger.info("SHADOWX", "Logged out successfully.");
+                cb(null, true);
+            })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/markAsDelivered.js

@@ -0,0 +1,17 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function markAsDelivered(threadID, messageID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var form = {
+            "message_ids[0]": messageID,
+            "status": 1,
+            "thread_fbid": threadID
+        };
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/delivery_receipts.php", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/markAsRead.js

@@ -0,0 +1,14 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function markAsRead(threadID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var form = { ids: {} };
+        form.ids[threadID] = true;
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/change_read_status.php", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/markAsReadAll.js

@@ -0,0 +1,15 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function markAsReadAll(callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/mark_folder_as_read.php", ctx.jar, {
+            folder: "inbox",
+            __user: ctx.userID
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/markAsSeen.js

@@ -0,0 +1,15 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function markAsSeen(seen_timestamp, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        seen_timestamp = seen_timestamp || Date.now();
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/mark_seen.php", ctx.jar, {
+            seen_timestamp: seen_timestamp
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/metaTheme.js

@@ -0,0 +1,185 @@
+/**
+ * ===========================================================
+ * 💫 META THEME GENERATOR MODULE 💫
+ * ===========================================================
+ * 🔰 Owner & Developer
+ * 🧠 Description:
+ *   This module generates beautiful Messenger AI themes 
+ *   using Meta's hidden GraphQL endpoints. It allows you to 
+ *   create unique chat themes based on your custom prompt 
+ *   or optional image inspiration.
+ * -----------------------------------------------------------
+ * ⚙️ Features:
+ *   • Generate AI-based Messenger chat themes.
+ *   • Custom prompt & optional image URL input.
+ *   • Returns structured theme data with full color mapping.
+ * -----------------------------------------------------------
+ * 🕊️ 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 metaTheme(prompt, options, callback) {
+        var resolveFunc = function () { };
+        var rejectFunc = function () { };
+        var returnPromise = new Promise(function (resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+
+        // Handle optional parameters
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        
+        if (!callback) {
+            callback = function (err, data) {
+                if (err) return rejectFunc(err);
+                resolveFunc(data);
+            };
+        }
+
+        if (!prompt || typeof prompt !== 'string') {
+            return callback({ error: "Prompt is required and must be a string" });
+        }
+
+        // Parse options
+        const numThemes = options.numThemes || 1;
+        const imageUrl = options.imageUrl || null;
+
+        const inputData = {
+            client_mutation_id: Math.floor(Math.random() * 10).toString(),
+            actor_id: ctx.userID,
+            bypass_cache: true,
+            caller: "MESSENGER",
+            num_themes: Math.min(numThemes, 5), // Limit to max 5 themes
+            prompt: prompt
+        };
+
+        // Add image URL if provided
+        if (imageUrl) {
+            inputData.image_url = imageUrl;
+        }
+
+        const form = {
+            av: ctx.userID,
+            __aaid: 0,
+            __user: ctx.userID,
+            __a: 1,
+            __req: utils.getSignatureID(),
+            __hs: "20358.HYP:comet_pkg.2.1...0",
+            dpr: 1,
+            __ccg: "EXCELLENT",
+            __rev: "1027673511",
+            __s: utils.getSignatureID(),
+            __hsi: "7554561631547849479",
+            __comet_req: 15,
+            fb_dtsg: ctx.fb_dtsg,
+            jazoest: ctx.ttstamp,
+            lsd: ctx.fb_dtsg,
+            __spin_r: "1027673511",
+            __spin_b: "trunk",
+            __spin_t: Date.now(),
+            __crn: "comet.fbweb.MWInboxHomeRoute",
+            qpl_active_flow_ids: "25309433,521485406",
+            fb_api_caller_class: "RelayModern",
+            fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+            variables: JSON.stringify({ input: inputData }),
+            server_timestamps: true,
+            doc_id: "23873748445608673",
+            fb_api_analytics_tags: JSON.stringify(["qpl_active_flow_ids=25309433,521485406"])
+        };
+
+        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.xfb_generate_ai_themes_from_prompt) {
+                    const themeData = resData.data.xfb_generate_ai_themes_from_prompt;
+                    if (themeData.success && themeData.themes && themeData.themes.length > 0) {
+                        const themes = themeData.themes.map((theme, index) => ({
+                            success: true,
+                            themeId: theme.id,
+                            name: theme.accessibility_label,
+                            description: theme.description,
+                            serialNumber: index + 1,
+                            colors: {
+                                composerBackground: theme.composer_background_color,
+                                backgroundGradient: theme.background_gradient_colors,
+                                titleBarButton: theme.title_bar_button_tint_color,
+                                inboundMessageGradient: theme.inbound_message_gradient_colors,
+                                titleBarText: theme.title_bar_text_color,
+                                composerTint: theme.composer_tint_color,
+                                messageText: theme.message_text_color,
+                                primaryButton: theme.primary_button_background_color,
+                                titleBarBackground: theme.title_bar_background_color,
+                                fallback: theme.fallback_color,
+                                gradient: theme.gradient_colors
+                            },
+                            backgroundImage: theme.background_asset ? theme.background_asset.image.uri : null,
+                            iconImage: theme.icon_asset ? theme.icon_asset.image.uri : null,
+                            images: {
+                                background: theme.background_asset ? theme.background_asset.image.uri : null,
+                                icon: theme.icon_asset ? theme.icon_asset.image.uri : null
+                            },
+                            alternativeThemes: theme.alternative_themes ? theme.alternative_themes.map(alt => ({
+                                id: alt.id,
+                                name: alt.accessibility_label,
+                                backgroundImage: alt.background_asset ? alt.background_asset.image.uri : null,
+                                iconImage: alt.icon_asset ? alt.icon_asset.image.uri : null
+                            })) : []
+                        }));
+
+                        const result = {
+                            success: true,
+                            count: themes.length,
+                            themes: themes,
+                            // For backward compatibility, include first theme data at root level
+                            ...themes[0]
+                        };
+                        return callback(null, result);
+                    } else {
+                        throw new Error("No themes generated for the given prompt");
+                    }
+                } else {
+                    throw new Error("Invalid response from AI theme generation");
+                }
+            })
+            .catch(function (err) {
+                log.error("metaTheme", err);
+                
+                // Check for specific error conditions
+                let errorMessage = "An error occurred while generating themes";
+                
+                if (err.message && err.message.includes("not authorized")) {
+                    errorMessage = "Your account is not authorized to generate AI themes. This feature may not be available for your account type.";
+                } else if (err.message && err.message.includes("rate limit")) {
+                    errorMessage = "Rate limit exceeded. Please wait a moment before trying again.";
+                } else if (err.message && err.message.includes("Invalid")) {
+                    errorMessage = "Invalid request parameters. Please check your input.";
+                } else if (err.statusCode === 403) {
+                    errorMessage = "Access denied. Your account may not support Meta AI theme generation.";
+                } else if (err.statusCode === 429) {
+                    errorMessage = "Too many requests. Please wait before trying again.";
+                }
+                
+                return callback({ 
+                    error: errorMessage,
+                    originalError: err.message || err,
+                    statusCode: err.statusCode || null
+                });
+            });
+
+        return returnPromise;
+    };
+};
+

package/src/muteThread.js

@@ -0,0 +1,52 @@
+"use strict";
+var utils = require("../utils");
+module.exports = function (defaultFuncs, api, ctx) {
+    return function muteThread(threadID, muteSeconds, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+        var mqttClient = ctx.mqttClient || global.mqttClient;
+
+        if (mqttClient) {
+            ctx.wsReqNumber = (ctx.wsReqNumber || 0) + 1;
+            ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+            var muteExpireTime = muteSeconds === 0
+                ? 0
+                : muteSeconds === -1
+                    ? -1
+                    : Math.floor(Date.now() / 1000) + muteSeconds;
+            var payload = {
+                thread_key: String(threadID),
+                mute_expire_time_ms: muteExpireTime === -1 ? -1 : muteExpireTime * 1000,
+                sync_group: 1
+            };
+            var content = {
+                app_id: '2220391788200892',
+                payload: JSON.stringify({
+                    data_trace_id: null,
+                    epoch_id: parseInt(utils.generateOfflineThreadingID()),
+                    tasks: [{
+                        failure_count: null,
+                        label: '52',
+                        payload: JSON.stringify(payload),
+                        queue_name: String(threadID),
+                        task_id: ctx.wsTaskNumber
+                    }],
+                    version_id: '7158486590867448'
+                }),
+                request_id: ctx.wsReqNumber,
+                type: 3
+            };
+            mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+            cb(null, true);
+            return promise;
+        }
+
+        defaultFuncs.post("https://www.facebook.com/ajax/mercury/change_mute_thread.php", ctx.jar, {
+            thread_fbid: threadID,
+            mute_settings: typeof muteSeconds === "number" ? muteSeconds : -1
+        })
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+            .then(resData => { if (resData && resData.error) throw resData; cb(null, true); })
+            .catch(err => cb(err));
+        return promise;
+    };
+};

package/src/note.js

@@ -0,0 +1,228 @@
+
+"use strict";
+
+const utils = require('../utils');
+
+/**
+ * @description Enhanced module for interacting with Facebook Messenger Notes with additional features
+ * @param {Object} defaultFuncs The default functions provided by the API wrapper
+ * @param {Object} api The full API object
+ * @param {Object} ctx The context object containing the user's session state
+ * @returns {Object} An object containing enhanced methods for note management
+ */
+module.exports = function(defaultFuncs, api, ctx) {
+
+  /**
+   * @callback notesCallback
+   * @param {Error|null} error An error object if the request fails, otherwise null
+   * @param {Object} [data] The data returned from the API
+   */
+
+  /**
+   * Enhanced check note function with additional user info
+   */
+  function checkNoteAdvanced(callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogQuery",
+      variables: JSON.stringify({ scale: 2 }),
+      doc_id: "30899655739648624",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const currentNote = resData?.data?.viewer?.actor?.msgr_user_rich_status;
+
+        // Enhanced response with additional metadata
+        const enhancedResponse = {
+          note: currentNote,
+          hasActiveNote: !!currentNote,
+          userId: ctx.userID,
+          timestamp: Date.now(),
+          expiresAt: currentNote ? (currentNote.created_time * 1000) + (24 * 60 * 60 * 1000) : null
+        };
+
+        callback(null, enhancedResponse);
+      })
+      .catch(err => {
+        utils.error && utils.error("notesv2.checkNoteAdvanced", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Create note with enhanced privacy options and validation
+   */
+  function createNoteAdvanced(text, options = {}, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    // Validate input
+    if (!text || text.trim().length === 0) {
+      return callback(new Error("Note text cannot be empty"));
+    }
+
+    if (text.length > 280) {
+      return callback(new Error("Note text cannot exceed 280 characters"));
+    }
+
+    const {
+      privacy = "FRIENDS",
+      duration = 86400,
+      noteType = "TEXT_NOTE"
+    } = options;
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 1000000).toString(),
+        actor_id: ctx.userID,
+        description: text.trim(),
+        duration: duration,
+        note_type: noteType,
+        privacy: privacy,
+        session_id: utils.getGUID(),
+      },
+    };
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "MWInboxTrayNoteCreationDialogCreationStepContentMutation",
+      variables: JSON.stringify(variables),
+      doc_id: "24060573783603122",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const status = resData?.data?.xfb_rich_status_create?.status;
+        if (!status) throw new Error("Could not find note status in the server response.");
+
+        // Enhanced response
+        const enhancedResponse = {
+          ...status,
+          createdAt: Date.now(),
+          expiresAt: Date.now() + (duration * 1000),
+          characterCount: text.trim().length,
+          privacy: privacy
+        };
+
+        callback(null, enhancedResponse);
+      })
+      .catch(err => {
+        utils.error && utils.error("notesv2.createNoteAdvanced", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Delete note with confirmation
+   */
+  function deleteNoteAdvanced(noteID, callback) {
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    if (!noteID) {
+      return callback(new Error("Note ID is required"));
+    }
+
+    const variables = {
+      input: {
+        client_mutation_id: Math.round(Math.random() * 1000000).toString(),
+        actor_id: ctx.userID,
+        rich_status_id: noteID,
+      },
+    };
+
+    const form = {
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useMWInboxTrayDeleteNoteMutation",
+      variables: JSON.stringify(variables),
+      doc_id: "9532619970198958",
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(resData => {
+        if (resData && resData.errors) throw resData.errors[0];
+        const deletedStatus = resData?.data?.xfb_rich_status_delete;
+        if (!deletedStatus) throw new Error("Could not find deletion status in the server response.");
+
+        const enhancedResponse = {
+          ...deletedStatus,
+          deletedAt: Date.now(),
+          noteId: noteID
+        };
+
+        callback(null, enhancedResponse);
+      })
+      .catch(err => {
+        utils.error && utils.error("notesv2.deleteNoteAdvanced", err);
+        callback(err);
+      });
+  }
+
+  /**
+   * Update existing note (delete old and create new)
+   */
+  function updateNote(oldNoteID, newText, options = {}, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+
+    if (typeof callback !== 'function') {
+      callback = () => {};
+    }
+
+    deleteNoteAdvanced(oldNoteID, (err, deleted) => {
+      if (err) {
+        return callback(err);
+      }
+
+      // Wait a bit before creating new note
+      setTimeout(() => {
+        createNoteAdvanced(newText, options, (err, created) => {
+          if (err) {
+            return callback(err);
+          }
+          callback(null, { 
+            deleted, 
+            created,
+            updatedAt: Date.now()
+          });
+        });
+      }, 1000);
+    });
+  }
+
+  return {
+    // Enhanced functions
+    checkAdvanced: checkNoteAdvanced,
+    createAdvanced: createNoteAdvanced,
+    deleteAdvanced: deleteNoteAdvanced,
+    update: updateNote,
+
+    // Backward compatibility
+    check: checkNoteAdvanced,
+    create: createNoteAdvanced,
+    delete: deleteNoteAdvanced,
+    recreate: updateNote
+  };
+};

package/src/pin.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var utils = require("../utils");
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function pin(action, threadID, messageID, callback) {
+        var { promise, callback: cb } = utils.wrapCallback(callback);
+
+        var mqttClient = ctx.mqttClient || global.mqttClient;
+        if (!mqttClient) {
+            cb({ error: "MQTT not connected. Call api.listen() first." });
+            return promise;
+        }
+
+        ctx.wsReqNumber  = (ctx.wsReqNumber  || 0) + 1;
+        ctx.wsTaskNumber = (ctx.wsTaskNumber || 0) + 1;
+
+        var isPinning = action === "pin" || action === true || action === 1;
+
+        var taskPayload = {
+            thread_key:   String(threadID),
+            message_id:   String(messageID),
+            timestamp_ms: Date.now(),
+        };
+
+        var envelope = {
+            app_id: "2220391788200892",
+            payload: JSON.stringify({
+                data_trace_id: null,
+                epoch_id:      parseInt(utils.generateOfflineThreadingID()),
+                tasks: [{
+                    failure_count: null,
+                    label:         isPinning ? "430" : "431",
+                    payload:       JSON.stringify(taskPayload),
+                    queue_name:    (isPinning ? "pin_msg_v2_" : "unpin_msg_v2_") + String(threadID),
+                    task_id:       ctx.wsTaskNumber,
+                }],
+                version_id: "25095469420099952",
+            }),
+            request_id: ctx.wsReqNumber,
+            type: 3,
+        };
+
+        try {
+            mqttClient.publish("/ls_req", JSON.stringify(envelope), { qos: 1 });
+            cb(null, true);
+        } catch (e) {
+            cb(e);
+        }
+
+        return promise;
+    };
+};