fca-neokex-fix 1.0.1

package/src/apis/stickers.js

@@ -0,0 +1,257 @@
+"use strict";
+
+/**
+ * Sticker API Module
+ * Provides access to Facebook's GraphQL-based sticker endpoints.
+ * Made by @ChoruOfficial
+ */
+
+const utils = require('../utils');
+/**
+ * Format the sticker pack list (store or tray)
+ * @param {object} data - Raw GraphQL response
+ * @returns {{ packs: Array<{id: string, name: string, thumbnail: string}>, page_info: object, store_id?: string }}
+ */
+function formatPackList(data) {
+    const trayPacks = data?.data?.picker_plugins?.sticker_picker?.sticker_store?.tray_packs?.edges;
+    const storePacks = data?.data?.viewer?.sticker_store?.available_packs?.edges;
+    
+    const packData = storePacks || trayPacks;
+    if (!packData || !packData.edges) return { packs: [], page_info: { has_next_page: false } };
+
+    const formattedPacks = packData.edges.map(edge => edge.node ? ({
+        id: edge.node.id,
+        name: edge.node.name,
+        thumbnail: edge.node.thumbnail_image?.uri
+    }) : null).filter(Boolean);
+
+    return {
+        packs: formattedPacks,
+        page_info: packData.page_info,
+        store_id: data?.data?.viewer?.sticker_store?.id
+    };
+}
+
+/**
+ * Format search result stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerSearchResults(data) {
+    const stickers = data?.data?.sticker_search?.sticker_results?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format sticker pack content
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatStickerPackResults(data) {
+    const stickers = data?.data?.sticker_pack?.stickers?.edges;
+    if (!stickers) return [];
+    return stickers.map(edge => edge.node ? ({
+        type: "sticker",
+        ID: edge.node.id,
+        url: edge.node.image?.uri,
+        animatedUrl: edge.node.animated_image?.uri,
+        packID: edge.node.pack?.id,
+        label: edge.node.label || edge.node.accessibility_label,
+        stickerID: edge.node.id
+    }) : null).filter(Boolean);
+}
+
+/**
+ * Format AI-generated stickers
+ * @param {object} data - Raw GraphQL response
+ * @returns {Array<Object>}
+ */
+function formatAiStickers(data) {
+    const stickers = data?.data?.xfb_trending_generated_ai_stickers?.nodes;
+    if (!stickers) return [];
+    return stickers.map(node => ({
+        type: "sticker",
+        ID: node.id,
+        url: node.url,
+        label: node.label,
+        stickerID: node.id
+    })).filter(Boolean);
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+    /**
+     * Make a GraphQL request and handle login and error checking
+     * @param {object} form - Form data for the request
+     * @returns {Promise<object>}
+     */
+    async function makeRequest(form) {
+        const resData = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+            .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+        if (!resData) throw new Error("GraphQL request returned no data.");
+        if (resData.errors) {
+            utils.error("StickerAPI GraphQL Error", resData.errors[0].message);
+            throw resData.errors[0];
+        }
+        return resData;
+    }
+
+    return {
+        /**
+         * Search for stickers by keyword
+         * @param {string} query - Search term
+         * @returns {Promise<Array<Object>>}
+         */
+        search: async function(query) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerSearchResultsRootQuery',
+                variables: JSON.stringify({
+                    scale: 3,
+                    search_query: query,
+                    sticker_height: 128,
+                    sticker_width: 128,
+                    stickerInterface: "MESSAGES"
+                }),
+                doc_id: '24004987559125954'
+            };
+            const res = await makeRequest(form);
+            return formatStickerSearchResults(res);
+        },
+
+        /**
+         * List user's sticker packs
+         * @returns {Promise<Array<Object>>}
+         */
+        listPacks: async function() {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerCardQuery',
+                variables: JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+                doc_id: '10095807770482952'
+            };
+            const res = await makeRequest(form);
+            return formatPackList(res).packs;
+        },
+
+        /**
+         * Get all available sticker packs from the store (with pagination)
+         * @returns {Promise<Array<Object>>}
+         */
+        getStorePacks: async function() {
+            utils.log("Starting to fetch all sticker packs from store...");
+            let allPacks = [];
+
+            const initialForm = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStoreDialogQuery',
+                variables: JSON.stringify({}),
+                doc_id: '29237828849196584'
+            };
+            let res = await makeRequest(initialForm);
+            let { packs, page_info, store_id } = formatPackList(res);
+            allPacks.push(...packs);
+            utils.log(`Fetched first page with ${packs.length} packs.`);
+
+            while (page_info && page_info.has_next_page) {
+                utils.log("Fetching next page with cursor:", page_info.end_cursor);
+
+                const paginatedForm = {
+                    fb_api_caller_class: 'RelayModern',
+                    fb_api_req_friendly_name: 'CometStickersStorePackListPaginationQuery',
+                    variables: JSON.stringify({
+                        count: 20,
+                        cursor: page_info.end_cursor,
+                        id: store_id
+                    }),
+                    doc_id: '9898634630218439'
+                };
+                res = await makeRequest(paginatedForm);
+                let paginatedResult = formatPackList(res);
+                allPacks.push(...paginatedResult.packs);
+                page_info = paginatedResult.page_info;
+                utils.log(`Fetched ${paginatedResult.packs.length} more packs. Total now: ${allPacks.length}`);
+            }
+
+            utils.log(`Finished fetching. Total unique packs found: ${allPacks.length}`);
+            return allPacks;
+        },
+
+        /**
+         * Merge user's and store sticker packs into one list
+         * @returns {Promise<Array<Object>>}
+         */
+        listAllPacks: async function() {
+            const [myPacks, storePacks] = await Promise.all([
+                this.listPacks(),
+                this.getStorePacks()
+            ]);
+            const allPacksMap = new Map();
+            myPacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            storePacks.forEach(pack => allPacksMap.set(pack.id, pack));
+            return Array.from(allPacksMap.values());
+        },
+
+        /**
+         * Add a sticker pack by ID
+         * @param {string} packID - The ID of the sticker pack
+         * @returns {Promise<Object>}
+         */
+        addPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickersStorePackMutationAddMutation',
+                variables: JSON.stringify({
+                    input: {
+                        pack_id: packID,
+                        actor_id: ctx.userID,
+                        client_mutation_id: Math.round(Math.random() * 10).toString()
+                    }
+                }),
+                doc_id: '9877489362345320'
+            };
+            const res = await makeRequest(form);
+            return res.data.sticker_pack_add.sticker_pack;
+        },
+
+        /**
+         * Get all stickers in a pack
+         * @param {string} packID - Sticker pack ID
+         * @returns {Promise<Array<Object>>}
+         */
+        getStickersInPack: async function(packID) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerPackContentRootQuery',
+                variables: JSON.stringify({ packID, stickerWidth: 128, stickerHeight: 128, scale: 3 }),
+                doc_id: '23982341384707469'
+            };
+            const res = await makeRequest(form);
+            return formatStickerPackResults(res);
+        },
+
+        /**
+         * Get trending AI-generated stickers
+         * @param {{ limit?: number }} options - Options object
+         * @returns {Promise<Array<Object>>}
+         */
+        getAiStickers: async function({ limit = 10 } = {}) {
+            const form = {
+                fb_api_caller_class: 'RelayModern',
+                fb_api_req_friendly_name: 'CometStickerPickerStickerGeneratedCardQuery',
+                variables: JSON.stringify({ limit }),
+                doc_id: '24151467751156443'
+            };
+            const res = await makeRequest(form);
+            return formatAiStickers(res);
+        }
+    };
+};

package/src/apis/story.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const utils = require('../utils');
+const { URL } = require('url');
+
+/**
+ * @namespace api.story
+ * @description A collection of functions for interacting with Facebook Stories.
+ * @license Ex-it
+ * @author Jonell Magallanes, ChoruOfficial
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * (Internal) Extracts the Story ID from a Facebook story URL.
+   * @param {string} url The Facebook story URL.
+   * @returns {string|null} The extracted Story ID or null if not found.
+   */
+  function getStoryIDFromURL(url) {
+      try {
+          const urlObject = new URL(url);
+          const pathParts = urlObject.pathname.split('/');
+          const storiesIndex = pathParts.indexOf('stories');
+          if (storiesIndex !== -1 && pathParts.length > storiesIndex + 2) {
+              return pathParts[storiesIndex + 2];
+          }
+          return null;
+      } catch (e) {
+          return null;
+      }
+  }
+
+  /**
+   * (Internal) The core function to send a reply or reaction to a story.
+   * @param {string} storyIdOrUrl The ID or URL of the story.
+   * @param {string} message The text message or emoji reaction.
+   * @param {boolean} isReaction True if the reply is a lightweight reaction.
+   * @returns {Promise<object>} The server's response.
+   */
+  async function sendStoryReply(storyIdOrUrl, message, isReaction) {
+    try {
+        const allowedReactions = ["❤️", "👍", "🤗", "😆", "😡", "😢", "😮"];
+
+        if (!storyIdOrUrl) throw new Error("Story ID or URL is required.");
+        if (!message) throw new Error("A message or reaction is required.");
+
+        let storyID = getStoryIDFromURL(storyIdOrUrl);
+        if (!storyID) storyID = storyIdOrUrl;
+
+        const variables = {
+            input: {
+                attribution_id_v2: "StoriesCometSuspenseRoot.react,comet.stories.viewer,via_cold_start",
+                message: message,
+                story_id: storyID,
+                story_reply_type: isReaction ? "LIGHT_WEIGHT" : "TEXT",
+                actor_id: ctx.userID,
+                client_mutation_id: Math.floor(Math.random() * 10 + 1).toString()
+            }
+        };
+
+        if (isReaction) {
+            if (!allowedReactions.includes(message)) {
+                throw new Error(`Invalid reaction. Please use one of: ${allowedReactions.join(" ")}`);
+            }
+            variables.input.lightweight_reaction_actions = {
+                offsets: [0],
+                reaction: message,
+            };
+        }
+
+        const form = {
+            av: ctx.userID,
+            __user: ctx.userID,
+            __a: "1",
+            fb_dtsg: ctx.fb_dtsg,
+            jazoest: ctx.jazoest,
+            fb_api_caller_class: "RelayModern",
+            fb_api_req_friendly_name: "useStoriesSendReplyMutation",
+            variables: JSON.stringify(variables),
+            doc_id: "9697491553691692"
+        };
+
+        const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+        if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+        
+        const storyReplyData = res.data?.data?.direct_message_reply;
+        if (!storyReplyData) throw new Error("Could not find 'direct_message_reply' in the response data.");
+        
+        return { success: true, result: storyReplyData };
+    } catch (err) {
+        console.error("Error in story reply API:", err);
+        throw err;
+    }
+  }
+
+  /**
+   * Creates a new text-based story.
+   * @param {string} message The text content of the story.
+   * @param {string} [fontName="classic"] The name of the font to use. Options: `headline`, `classic`, `casual`, `fancy`.
+   * @param {string} [backgroundName="blue"] The name of the background to use. Options: `orange`, `blue`, `green`, `modern`.
+   * @returns {Promise<{success: boolean, storyID: string}>} A promise that resolves with the new story's ID.
+   */
+  async function create(message, fontName = "classic", backgroundName = "blue") {
+    const fontMap = {
+        headline: "1919119914775364",
+        classic: "516266749248495",
+        casual: "516266749248495",
+        fancy: "1790435664339626"
+    };
+    const bgMap = {
+        orange: "2163607613910521",
+        blue: "401372137331149",
+        green: "367314917184744",
+        modern: "554617635055752"
+    };
+
+    const fontId = fontMap[fontName.toLowerCase()] || fontMap.classic;
+    const bgId = bgMap[backgroundName.toLowerCase()] || bgMap.blue;
+
+    const variables = {
+      input: {
+        audiences: [{ stories: { self: { target_id: ctx.userID } } }],
+        audiences_is_complete: true,
+        logging: { composer_session_id: "createStoriesText-" + Date.now() },
+        navigation_data: { attribution_id_v2: "StoriesCreateRoot.react,comet.stories.create" },
+        source: "WWW",
+        message: { ranges: [], text: message },
+        text_format_metadata: { inspirations_custom_font_id: fontId },
+        text_format_preset_id: bgId,
+        tracking: [null],
+        actor_id: ctx.userID,
+        client_mutation_id: "2"
+      }
+    };
+
+    const form = {
+        __a: "1",
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "StoriesCreateMutation",
+        variables: JSON.stringify(variables),
+        doc_id: "24226878183562473"
+    };
+
+    try {
+        const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form, {});
+        if (res.data.errors) throw new Error(JSON.stringify(res.data.errors));
+
+        const storyNode = res.data?.data?.story_create?.viewer?.actor?.story_bucket?.nodes[0]?.first_story_to_show;
+        if (!storyNode || !storyNode.id) throw new Error("Could not find the storyCardID in the response.");
+
+        return { success: true, storyID: storyNode.id };
+    } catch (error) {
+        throw error;
+    }
+  }
+
+  return {
+    /**
+     * Creates a new text-based story.
+     * @param {string} message The text content of the story.
+     * @param {string} [fontName="classic"] The font to use (`headline`, `classic`, `fancy`).
+     * @param {string} [backgroundName="blue"] The background to use (`orange`, `blue`, `green`, `modern`).
+     * @returns {Promise<{success: boolean, storyID: string}>}
+     */
+    create,
+    /**
+     * Reacts to a story with a specific emoji.
+     * @param {string} storyIdOrUrl The ID or full URL of the story to react to.
+     * @param {string} reaction The emoji to react with. Must be one of: ❤️, 👍, 🤗, 😆, 😡, 😢, 😮.
+     * @returns {Promise<{success: boolean, result: object}>}
+     */
+    react: (storyIdOrUrl, reaction) => sendStoryReply(storyIdOrUrl, reaction, true),
+    /**
+     * Sends a text message reply to a story.
+     * @param {string} storyIdOrUrl The ID or full URL of the story to reply to.
+     * @param {string} message The text message to send.
+     * @returns {Promise<{success: boolean, result: object}>}
+     */
+    msg: (storyIdOrUrl, message) => sendStoryReply(storyIdOrUrl, message, false)
+  };
+};

package/src/apis/theme.js

@@ -0,0 +1,233 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Made by Choru Official 
+   * Mqtt & Graph
+   * Manages or sets the custom theme for a Facebook thread.
+   * If only a theme name/keyword is provided, it attempts to find and set the matching theme.
+   * If "list" is provided as the themeName, it lists available themes.
+   *
+   * @param {string} themeName The name or partial name of the theme (case-insensitive), or "list" to list themes.
+   * @param {string} threadID The ID of the thread.
+   * @param {Function} [callback] Optional callback function.
+   * @param {string} [initiatorID] The ID of the user who initiated the theme change (e.g., from event.senderID).
+   * @returns {Promise<void|Array<object>|object>} A promise that resolves on success (for setting theme, with a detailed event object), or with an array of themes (for listing), or rejects on error.
+   */
+  return async function theme(themeName, threadID, callback, initiatorID) {
+    let _callback;
+    let _initiatorID;
+
+    let _resolveFunc;
+    let _rejectFunc;
+    const finalReturnPromise = new Promise((resolve, reject) => {
+        _resolveFunc = resolve;
+        _rejectFunc = reject;
+    });
+
+    if (utils.getType(callback) === "Function" || utils.getType(callback) === "AsyncFunction") {
+        _callback = callback;
+        _initiatorID = initiatorID;
+    } else if (utils.getType(threadID) === "Function" || utils.getType(threadID) === "AsyncFunction") {
+        _callback = threadID;
+        threadID = null;
+        _initiatorID = callback;
+    } else if (utils.getType(callback) === "string") {
+        _initiatorID = callback;
+        _callback = undefined;
+    } else {
+        _callback = undefined;
+        _initiatorID = undefined;
+    }
+
+    if (!_callback) {
+      _callback = function (_err, _data) {
+        if (_err) _rejectFunc(_err);
+        else _resolveFunc(_data);
+      };
+    }
+
+    _initiatorID = _initiatorID || ctx.userID;
+
+    threadID = threadID || ctx.threadID;
+
+    if (!threadID) {
+      return _callback(new Error("threadID is required to manage themes."));
+    }
+    if (!themeName) {
+      return _callback(new Error("themeName (or 'list') is required."));
+    }
+
+    if (!ctx.mqttClient) {
+      return _callback(new Error("Not connected to MQTT"));
+    }
+
+    const fetchThemes = async () => {
+      const form = {
+        fb_api_caller_class: 'RelayModern',
+        fb_api_req_friendly_name: 'MWPThreadThemeQuery_AllThemesQuery',
+        variables: JSON.stringify({ version: "default" }),
+        server_timestamps: true,
+        doc_id: '24474714052117636',
+      };
+
+      try {
+        const resData = await defaultFuncs
+          .post("https://www.facebook.com/api/graphql/", ctx.jar, form, null, {
+            "x-fb-friendly-name": "MWPThreadThemeQuery_AllThemesQuery",
+            "x-fb-lsd": ctx.lsd,
+            "referer": `https://www.facebook.com/messages/t/${threadID}`
+          })
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+        if (resData.errors) {
+          throw new Error(JSON.stringify(resData.errors));
+        }
+        if (!resData.data || !resData.data.messenger_thread_themes) {
+          throw new Error("Could not retrieve thread themes from response.");
+        }
+        return resData.data.messenger_thread_themes.map(themeData => {
+          if (!themeData || !themeData.id) return null;
+
+          return {
+            id: themeData.id,
+            name: themeData.accessibility_label,
+            description: themeData.description,
+            appColorMode: themeData.app_color_mode,
+            composerBackgroundColor: themeData.composer_background_color,
+            backgroundGradientColors: themeData.background_gradient_colors,
+            titleBarButtonTintColor: themeData.title_bar_button_tint_color,
+            inboundMessageGradientColors: themeData.inbound_message_gradient_colors,
+            titleBarTextColor: themeData.title_bar_text_color,
+            composerTintColor: themeData.composer_tint_color,
+            titleBarAttributionColor: themeData.title_bar_attribution_color,
+            composerInputBackgroundColor: themeData.composer_input_background_color,
+            hotLikeColor: themeData.hot_like_color,
+            backgroundImage: themeData.background_asset?.image?.uri,
+            messageTextColor: themeData.message_text_color,
+            inboundMessageTextColor: themeData.inbound_message_text_color,
+            primaryButtonBackgroundColor: themeData.primary_button_background_color,
+            titleBarBackgroundColor: themeData.title_bar_background_color,
+            tertiaryTextColor: themeData.tertiary_text_color,
+            reactionPillBackgroundColor: themeData.reaction_pill_background_color,
+            secondaryTextColor: themeData.secondary_text_color,
+            fallbackColor: themeData.fallback_color,
+            gradientColors: themeData.gradient_colors,
+            normalThemeId: themeData.normal_theme_id,
+            iconAsset: themeData.icon_asset?.image?.uri,
+          };
+        }).filter(Boolean);
+      } catch (fetchErr) {
+        throw new Error(`Failed to fetch theme list: ${fetchErr.message || fetchErr}`);
+      }
+    };
+
+    const setThreadTheme = async (themeIDToSet, actualThemeName, initiatorID) => {
+      let currentEpochId = parseInt(utils.generateOfflineThreadingID());
+
+      const createAndPublish = (label, queueName, payload) => {
+        currentEpochId = parseInt(utils.generateOfflineThreadingID());
+        ctx.wsReqNumber += 1;
+        ctx.wsTaskNumber += 1;
+
+        const request_id = ctx.wsReqNumber;
+
+        const queryPayload = {
+          thread_key: threadID.toString(),
+          theme_fbid: themeIDToSet.toString(),
+          sync_group: 1,
+          ...payload
+        };
+
+        const query = {
+          failure_count: null,
+          label: label,
+          payload: JSON.stringify(queryPayload),
+          queue_name: queueName,
+          task_id: ctx.wsTaskNumber,
+        };
+
+        const context = {
+          app_id: ctx.appID,
+          payload: {
+            epoch_id: currentEpochId,
+            tasks: [query],
+            version_id: '24631415369801570',
+          },
+          request_id: request_id,
+          type: 3,
+        };
+        context.payload = JSON.stringify(context.payload);
+
+        return new Promise((res, rej) => {
+          ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false }, err => {
+            if (err) {
+              return rej(new Error(`MQTT publish failed for request ${request_id}: ${err.message}`));
+            }
+            res();
+          });
+        });
+      };
+
+      try {
+        await Promise.all([
+          createAndPublish('1013', `ai_generated_theme`, {}),
+          createAndPublish('1037', `msgr_custom_thread_theme`, {}),
+          createAndPublish('1028', `thread_theme_writer`, {}),
+          createAndPublish('43', `thread_theme`, { source: null, payload: null })
+        ]);
+
+        return {
+            type: "thread_theme_update",
+            threadID: threadID,
+            themeID: themeIDToSet,
+            themeName: actualThemeName,
+            senderID: initiatorID,
+            BotID: ctx.userID,
+            timestamp: Date.now(),
+        };
+
+      } catch (publishErr) {
+        throw new Error(`Failed to publish theme change MQTT messages: ${publishErr.message || publishErr}`);
+      }
+    };
+
+    try {
+      if (themeName.toLowerCase() === "list") {
+        const themes = await fetchThemes();
+        _callback(null, themes);
+      } else {
+        const themes = await fetchThemes();
+        const normalizedThemeName = themeName.toLowerCase();
+
+        let matchedTheme = null;
+
+        if (!isNaN(normalizedThemeName)) {
+            matchedTheme = themes.find(t => t.id === normalizedThemeName);
+        }
+        if (!matchedTheme) {
+            matchedTheme = themes.find(t => t.name.toLowerCase() === normalizedThemeName);
+        }
+
+        if (!matchedTheme) {
+          matchedTheme = themes.find(t => t.name.toLowerCase().includes(normalizedThemeName));
+        }
+
+        if (!matchedTheme) {
+          throw new Error(`Theme "${themeName}" not found. Try '/theme list' for available themes.`);
+        }
+
+        const themeEventObject = await setThreadTheme(matchedTheme.id, matchedTheme.name, _initiatorID);
+
+        _callback(null, themeEventObject);
+      }
+    } catch (err) {
+      const finalError = err instanceof Error ? err : new Error(err.message || err.error || 'An unknown error occurred during theme operation.');
+      _callback(finalError);
+    }
+
+    return finalReturnPromise;
+  };
+};