@lazyneoaz/nkxchat 1.0.0

package/src/apis/getThemePictures.js

@@ -0,0 +1,87 @@
+"use strict";
+
+const utils = require("../utils");
+
+/**
+ * Fetches theme asset images (background, icon, previews) for a given theme ID.
+ * Uses the MWPThreadThemeProviderQuery GraphQL endpoint — the same doc_id used
+ * by fetchThemeData, but returns the raw full response so callers get every asset field.
+ *
+ * @param {string}   id         Numeric theme ID (e.g. "196241301102133").
+ * @param {Function} [callback]
+ * @returns {Promise<object>}   Full theme provider response including all image assets.
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThemePictures(id, callback) {
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc  = reject;
+    });
+
+    const done = callback || function (err, data) {
+      if (err) return rejectFunc(err);
+      resolveFunc(data);
+    };
+
+    if (!id) {
+      done(new Error("theme id is required"));
+      return promise;
+    }
+
+    const normalizedId = String(id);
+
+    const form = {
+      av:     ctx.userID,
+      __user: ctx.userID,
+      __a:    1,
+      __req:  utils.getSignatureID(),
+      fb_dtsg:  ctx.fb_dtsg,
+      lsd:      ctx.lsd || ctx.fb_dtsg,
+      jazoest:  ctx.jazoest,
+      fb_api_caller_class:      "RelayModern",
+      fb_api_req_friendly_name: "MWPThreadThemeProviderQuery",
+      doc_id:           "9734829906576883",
+      server_timestamps: true,
+      variables: JSON.stringify({ id: normalizedId }),
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then((resData) => {
+        if (resData && resData.errors) throw resData;
+
+        const themeData = resData && resData.data && resData.data.messenger_thread_theme;
+
+        const extractUri = (obj) => (obj && obj.image && obj.image.uri) || null;
+
+        const result = {
+          id:             normalizedId,
+          raw:            resData,
+          theme:          themeData || null,
+          backgroundImage: extractUri(themeData && themeData.background_asset),
+          iconImage:       extractUri(themeData && themeData.icon_asset),
+          name:           themeData ? (themeData.accessibility_label || themeData.name || "") : "",
+          gradient_colors: themeData ? (themeData.gradient_colors || []) : [],
+          fallback_color:  themeData ? (themeData.fallback_color || null) : null,
+          alternative_themes: themeData && Array.isArray(themeData.alternative_themes)
+            ? themeData.alternative_themes.map(a => ({
+                id:             a.id,
+                backgroundImage: extractUri(a.background_asset),
+                iconImage:       extractUri(a.icon_asset),
+                gradient_colors: a.gradient_colors || [],
+              }))
+            : [],
+        };
+
+        done(null, result);
+      })
+      .catch((err) => {
+        utils.error("getThemePictures", err.message || err);
+        done(err instanceof Error ? err : new Error(String(err.message || err)));
+      });
+
+    return promise;
+  };
+};

package/src/apis/getThreadColors.js

@@ -0,0 +1,119 @@
+"use strict";
+
+/**
+ * All known Messenger thread color theme IDs.
+ * Keys are human-readable names; values are Facebook's numeric theme_fbid strings.
+ *
+ * Use api.changeThreadColor(id, threadID) or api.setThreadThemeMqtt(threadID, id)
+ * to apply one of these colors.
+ */
+const THREAD_COLORS = {
+  // ── Core palette ─────────────────────────────────────────────────
+  MessengerBlue:       "196241301102133",
+  DefaultBlue:         "196241301102133",
+  Default:             "3259963564026002",
+  Viking:              "1928399724138152",
+  TealBlue:            "1928399724138152",
+  GoldenPoppy:         "174636906462322",
+  Yellow:              "174636906462322",
+  RadicalRed:          "2129984390566328",
+  Red:                 "2129984390566328",
+  Shocking:            "2058653964378557",
+  LavenderPurple:      "2058653964378557",
+  FreeSpeechGreen:     "2136751179887052",
+  Green:               "2136751179887052",
+  Pumpkin:             "175615189761153",
+  Orange:              "175615189761153",
+  LightCoral:          "980963458735625",
+  CoralPink:           "980963458735625",
+  MediumSlateBlue:     "234137870477637",
+  BrightPurple:        "234137870477637",
+  DeepSkyBlue:         "2442142322678320",
+  AquaBlue:            "2442142322678320",
+  BrilliantRose:       "169463077092846",
+  HotPink:             "169463077092846",
+  Aqua:                "417639218648241",
+  // ── Named themes ─────────────────────────────────────────────────
+  Mango:               "930060997172551",
+  Berry:               "164535220883264",
+  Berry2:              "724096885023603",
+  Citrus:              "370940413392601",
+  Citrus2:             "557344741607350",
+  Candy:               "205488546921017",
+  Candy2:              "624266884847972",
+  Earth:               "1833559466821043",
+  Support:             "365557122117011",
+  Music:               "339021464972092",
+  Pride:               "1652456634878319",
+  DoctorStrange:       "538280997628317",
+  LoFi:                "1060619084701625",
+  Sky:                 "3190514984517598",
+  LunarNewYear:        "357833546030778",
+  Celebration:         "627144732056021",
+  Chill:               "390127158985345",
+  StrangerThings:      "1059859811490132",
+  Dune:                "1455149831518874",
+  Care:                "275041734441112",
+  Astrology:           "3082966625307060",
+  JBalvin:             "184305226956268",
+  Birthday:            "621630955405500",
+  Cottagecore:         "539927563794799",
+  Ocean:               "736591620215564",
+  Love:                "741311439775765",
+  TieDye:              "230032715012014",
+  Monochrome:          "788274591712841",
+  Rocket:              "582065306070020",
+  Unicorn:             "273728810607574",
+  Tropical:            "262191918210707",
+  Maple:               "2533652183614000",
+  Sushi:               "909695489504566",
+  Lollipop:            "280333826736184",
+  Shadow:              "271607034185782",
+  Rose:                "1257453361255152",
+  Lavender:            "571193503540759",
+  Tulip:               "2873642949430623",
+  Classic:             "3273938616164733",
+  Peach:               "3022526817824329",
+  Honey:               "672058580051520",
+  Kiwi:                "3151463484918004",
+  Grape:               "193497045377796",
+  // ── Special / seasonal ───────────────────────────────────────────
+  NonBinary:               "737761000603635",
+  ThankfulForFriends:      "1318983195536293",
+  Transgender:             "504518465021637",
+  TaylorSwift:             "769129927636836",
+  NationalComingOutDay:    "788102625833584",
+  Autumn:                  "822549609168155",
+  Cyberpunk2077:           "780962576430091",
+  MothersDay:              "1288506208402340",
+  APAHM:                   "121771470870245",
+  Parenthood:              "810978360551741",
+  StarWars:                "1438011086532622",
+  GuardianOfTheGalaxy:     "101275642962533",
+  Bloom:                   "158263147151440",
+  BubbleTea:               "195296273246380",
+  Basketball:              "6026716157422736",
+  ElephantsAndFlowers:     "693996545771691",
+};
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Returns all available thread color themes.
+   *
+   * @param {string} [query]  Optional fuzzy search term. If provided, returns only
+   *                          themes whose name contains the query (case-insensitive).
+   * @returns {Object|Array}
+   *   - Without query: plain object { name → id }
+   *   - With query:    array of { name, id } matches
+   */
+  return function getThreadColors(query) {
+    if (!query) {
+      return { ...THREAD_COLORS };
+    }
+
+    const q = String(query).toLowerCase();
+    return Object.entries(THREAD_COLORS)
+      .filter(([name]) => name.toLowerCase().includes(q))
+      .map(([name, id]) => ({ name, id }));
+  };
+};

package/src/apis/getThreadHistory.js

@@ -0,0 +1,239 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+/**
+ * Formats a single attachment object from a GraphQL response.
+ * @param {Object} attachment The raw attachment object.
+ * @returns {Object} A formatted attachment object.
+ */
+function formatAttachmentsGraphQLResponse(attachment) {
+    switch (attachment.__typename) {
+        case "MessageImage":
+            return {
+                type: "photo",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                thumbnailUrl: attachment.thumbnail.uri,
+                previewUrl: attachment.preview.uri,
+                previewWidth: attachment.preview.width,
+                previewHeight: attachment.preview.height,
+                largePreviewUrl: attachment.large_preview.uri,
+                largePreviewHeight: attachment.large_preview.height,
+                largePreviewWidth: attachment.large_preview.width,
+                url: attachment.large_preview.uri,
+                width: attachment.original_dimensions.x,
+                height: attachment.original_dimensions.y,
+                name: attachment.filename
+            };
+        case "MessageAnimatedImage":
+            return {
+                type: "animated_image",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                previewUrl: attachment.preview_image.uri,
+                previewWidth: attachment.preview_image.width,
+                previewHeight: attachment.preview_image.height,
+                url: attachment.animated_image.uri,
+                width: attachment.animated_image.width,
+                height: attachment.animated_image.height,
+                name: attachment.filename,
+                facebookUrl: attachment.animated_image.uri,
+            };
+        case "MessageVideo":
+            return {
+                type: "video",
+                ID: attachment.legacy_attachment_id,
+                filename: attachment.filename,
+                duration: attachment.playable_duration_in_ms,
+                thumbnailUrl: attachment.large_image.uri,
+                previewUrl: attachment.large_image.uri,
+                previewWidth: attachment.large_image.width,
+                previewHeight: attachment.large_image.height,
+                url: attachment.playable_url,
+                width: attachment.original_dimensions.x,
+                height: attachment.original_dimensions.y,
+                videoType: attachment.video_type.toLowerCase(),
+            };
+        case "MessageFile":
+            return {
+                type: "file",
+                ID: attachment.message_file_fbid,
+                filename: attachment.filename,
+                url: attachment.url,
+                isMalicious: attachment.is_malicious,
+                contentType: attachment.content_type,
+                name: attachment.filename,
+            };
+        case "MessageAudio":
+            return {
+                type: "audio",
+                ID: attachment.url_shimhash,
+                filename: attachment.filename,
+                duration: attachment.playable_duration_in_ms,
+                audioType: attachment.audio_type,
+                url: attachment.playable_url,
+                isVoiceMail: attachment.is_voicemail,
+            };
+        default:
+            return {
+                type: "unknown",
+                error: "Don't know about attachment type " + attachment.__typename,
+            };
+    }
+}
+
+/**
+ * Formats a share (extensible) attachment from a GraphQL response.
+ * @param {Object} attachment The raw extensible attachment object.
+ * @returns {Object} A formatted share attachment object.
+ */
+function formatExtensibleAttachment(attachment) {
+    if (attachment.story_attachment) {
+        return {
+            type: "share",
+            ID: attachment.legacy_attachment_id,
+            url: attachment.story_attachment.url,
+            title: attachment.story_attachment.title_with_entities.text,
+            description: attachment.story_attachment.description && attachment.story_attachment.description.text,
+            source: attachment.story_attachment.source == null ? null : attachment.story_attachment.source.text,
+            image: attachment.story_attachment.media?.image?.uri,
+            width: attachment.story_attachment.media?.image?.width,
+            height: attachment.story_attachment.media?.image?.height,
+            playable: attachment.story_attachment.media?.is_playable,
+            duration: attachment.story_attachment.media?.playable_duration_in_ms,
+            playableUrl: attachment.story_attachment.media?.playable_url,
+            subattachments: attachment.story_attachment.subattachments,
+            properties: attachment.story_attachment.properties.reduce((obj, cur) => {
+                obj[cur.key] = cur.value.text;
+                return obj;
+            }, {}),
+        };
+    }
+    return { type: "unknown", error: "Don't know what to do with extensible_attachment." };
+}
+
+/**
+ * Formats the response from a GraphQL message history query.
+ * @param {Object} data The raw GraphQL response data.
+ * @returns {Array<Object>} An array of formatted message objects.
+ */
+function formatMessagesGraphQLResponse(data) {
+    const messageThread = data.o0.data.message_thread;
+    if (!messageThread) return [];
+
+    const threadID = messageThread.thread_key.thread_fbid ? messageThread.thread_key.thread_fbid : messageThread.thread_key.other_user_id;
+
+    return messageThread.messages.nodes.map(d => {
+        switch (d.__typename) {
+            case "UserMessage":
+                const mentions = {};
+                if (d.message?.ranges) {
+                    d.message.ranges.forEach(e => {
+                        mentions[e.entity.id] = d.message.text.substring(e.offset, e.offset + e.length);
+                    });
+                }
+                return {
+                    type: "message",
+                    attachments: d.sticker ? [{
+                        type: "sticker",
+                        ID: d.sticker.id,
+                        url: d.sticker.url,
+                        packID: d.sticker.pack?.id,
+                        frameCount: d.sticker.frame_count,
+                        frameRate: d.sticker.frame_rate,
+                        framesPerRow: d.sticker.frames_per_row,
+                        framesPerCol: d.sticker.frames_per_col,
+                        stickerID: d.sticker.id,
+                    }] : (d.blob_attachments || []).map(formatAttachmentsGraphQLResponse).concat(d.extensible_attachment ? [formatExtensibleAttachment(d.extensible_attachment)] : []),
+                    body: d.message?.text || "",
+                    isGroup: messageThread.thread_type === "GROUP",
+                    messageID: d.message_id,
+                    senderID: d.message_sender.id,
+                    threadID: threadID,
+                    timestamp: d.timestamp_precise,
+                    mentions: mentions,
+                    isUnread: d.unread,
+                    messageReactions: d.message_reactions?.map(r => ({ reaction: r.reaction, userID: r.user.id })) || [],
+                };
+            case "ThreadNameMessage":
+            case "ThreadImageMessage":
+            case "ParticipantLeftMessage":
+            case "ParticipantsAddedMessage":
+            case "GenericAdminTextMessage": {
+
+
+                return {
+                    type: "event",
+                    messageID: d.message_id,
+                    threadID: threadID,
+                    isGroup: messageThread.thread_type === "GROUP",
+                    senderID: d.message_sender.id,
+                    author: d.message_sender.id,
+                    timestamp: d.timestamp_precise,
+                    snippet: d.snippet,
+                    logMessageType: utils.getAdminTextMessageType(d.extensible_message_admin_text_type || d.__typename),
+                    logMessageData: d.extensible_message_admin_text || d,
+                };
+            }
+            default:
+                return { type: "unknown", error: "Unknown message type " + d.__typename, raw: d };
+        }
+    });
+}
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(threadID: string, amount: number, timestamp: number | null): Promise<Array<Object>>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+    /**
+     * Retrieves the message history for a specific thread.
+     * @param {string} threadID The ID of the thread to fetch history from.
+     * @param {number} amount The number of messages to retrieve.
+     * @param {number | null} timestamp The timestamp to start fetching messages before.
+     * @returns {Promise<Array<Object>>} A promise that resolves with an array of formatted message objects.
+     */
+    return async function getThreadHistory(threadID, amount, timestamp) {
+        if (!threadID || !amount) {
+            throw new Error("getThreadHistory: threadID and amount are required.");
+        }
+
+        const form = {
+            av: ctx.globalOptions.pageID,
+            queries: JSON.stringify({
+                o0: {
+                    doc_id: "1498317363570230",
+                    query_params: {
+                        id: threadID,
+                        message_limit: amount,
+                        load_messages: 1,
+                        load_read_receipts: false,
+                        before: timestamp || null,
+                    },
+                },
+            }),
+        };
+
+        try {
+            const resData = await defaultFuncs.post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form);
+            const parsedData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(resData);
+
+            if (parsedData.error || (Array.isArray(parsedData) && parsedData[parsedData.length - 1].error_results !== 0)) {
+                throw parsedData;
+            }
+            
+            if (!Array.isArray(parsedData) || !parsedData[0] || !parsedData[0].o0 || !parsedData[0].o0.data) {
+                throw { error: "getThreadHistory: Malformed response from GraphQL.", res: parsedData };
+            }
+
+            return formatMessagesGraphQLResponse(parsedData[0]);
+        } catch (err) {
+            utils.error("getThreadHistory", err);
+            throw err;
+        }
+    };
+};