fca-priyansh 19.0.1 → 20.0.0

package/src/changeThreadEmoji.js

@@ -1,42 +1,42 @@
-"use strict";
-
-var utils = require("../utils");
-var log = require("npmlog");
-
-module.exports = function (defaultFuncs, api, ctx) {
-  return function changeThreadEmoji(emoji, threadID, callback) {
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-
-    if (!callback) {
-      callback = function (err) {
-        if (err) return rejectFunc(err);
-        resolveFunc();
-      };
-    }
-    var form = {
-      emoji_choice: emoji,
-      thread_or_other_fbid: threadID
-    };
-
-    defaultFuncs
-      .post("https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg", ctx.jar, form)
-      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
-      .then(function (resData) {
-        if (resData.error === 1357031) throw { error: "Trying to change emoji of a chat that doesn't exist. Have at least one message in the thread before trying to change the emoji." };
-        if (resData.error) throw resData;
-
-        return callback();
-      })
-      .catch(function (err) {
-        log.error("changeThreadEmoji", err);
-        return callback(err);
-      });
-
-    return returnPromise;
-  };
-};
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function changeThreadEmoji(emoji, threadID, callback) {
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err) {
+        if (err) return rejectFunc(err);
+        resolveFunc();
+      };
+    }
+    var form = {
+      emoji_choice: emoji,
+      thread_or_other_fbid: threadID
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/messaging/save_thread_emoji/?source=thread_settings&__pc=EXP1%3Amessengerdotcom_pkg", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.error === 1357031) throw { error: "Trying to change emoji of a chat that doesn't exist. Have at least one message in the thread before trying to change the emoji." };
+        if (resData.error) throw resData;
+
+        return callback();
+      })
+      .catch(function (err) {
+        log.error("changeThreadEmoji", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/changeThreadTheme.js

@@ -0,0 +1,263 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Change thread theme using MQTT (more reliable than HTTP)
+   * Made by Choru Official - Ported to fca-updated format
+   * 
+   * Features:
+   * - List all available themes: api.changeThreadTheme("list", threadID)
+   * - Set theme by name: api.changeThreadTheme("love", threadID)
+   * - Set theme by ID: api.changeThreadTheme("168332145275126", threadID)
+   * - Partial name match: api.changeThreadTheme("dark", threadID) -> finds "Dark Mode"
+   * 
+   * @param {string} themeName - Theme name, theme ID, or "list" to show all themes
+   * @param {string} threadID - Thread ID to change theme
+   * @param {function} callback - Optional callback(err, result)
+   * @returns {Promise} Promise that resolves with theme data or list
+   */
+  return function changeThreadTheme(themeName, threadID, callback) {
+    var resolveFunc = function () {};
+    var rejectFunc = function () {};
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    // Validate parameters
+    if (!threadID) {
+      return callback({ error: "threadID is required to change theme." });
+    }
+
+    if (!themeName) {
+      return callback({ error: "themeName (or 'list') is required." });
+    }
+
+    // Check MQTT connection (required for theme change)
+    if (!ctx.mqttClient || !ctx.mqttClient.connected) {
+      return callback({ 
+        error: "MQTT not connected. Theme changes require MQTT connection. Make sure bot is fully started with listenMqtt active." 
+      });
+    }
+
+    /**
+     * Fetch all available themes from Facebook GraphQL
+     */
+    function fetchAllThemes(cb) {
+      log.info("changeThreadTheme", "Fetching available themes from Facebook...");
+      
+      var form = {
+        fb_api_caller_class: "RelayModern",
+        fb_api_req_friendly_name: "MWPThreadThemeQuery_AllThemesQuery",
+        variables: JSON.stringify({ version: "default" }),
+        server_timestamps: true,
+        doc_id: "24474714052117636"
+      };
+
+      defaultFuncs
+        .post("https://www.facebook.com/api/graphql/", ctx.jar, form, null, {
+          "x-fb-friendly-name": "MWPThreadThemeQuery_AllThemesQuery",
+          "x-fb-lsd": ctx.lsd || ctx.fb_dtsg,
+          "referer": "https://www.facebook.com/messages/t/" + threadID
+        })
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.errors) {
+            return cb({ error: "GraphQL error: " + JSON.stringify(resData.errors) });
+          }
+
+          if (!resData.data || !resData.data.messenger_thread_themes) {
+            return cb({ error: "Could not retrieve themes from Facebook." });
+          }
+
+          var themes = resData.data.messenger_thread_themes
+            .map(function (themeData) {
+              if (!themeData || !themeData.id) return null;
+
+              return {
+                id: themeData.id,
+                name: themeData.accessibility_label,
+                description: themeData.description,
+                appColorMode: themeData.app_color_mode,
+                fallbackColor: themeData.fallback_color,
+                gradientColors: themeData.gradient_colors,
+                backgroundImage: themeData.background_asset?.image?.uri,
+                iconAsset: themeData.icon_asset?.image?.uri,
+                // Color details
+                composerBackgroundColor: themeData.composer_background_color,
+                composerTintColor: themeData.composer_tint_color,
+                titleBarBackgroundColor: themeData.title_bar_background_color,
+                titleBarTextColor: themeData.title_bar_text_color,
+                hotLikeColor: themeData.hot_like_color,
+                inboundMessageGradientColors: themeData.inbound_message_gradient_colors,
+                messageTextColor: themeData.message_text_color
+              };
+            })
+            .filter(Boolean);
+
+          log.info("changeThreadTheme", "Successfully fetched " + themes.length + " themes");
+          cb(null, themes);
+        })
+        .catch(function (err) {
+          log.error("changeThreadTheme", "Failed to fetch themes:", err);
+          cb({ error: "Failed to fetch theme list: " + (err.message || err) });
+        });
+    }
+
+    /**
+     * Set thread theme using MQTT publish
+     */
+    function setThemeViaMqtt(themeID, actualThemeName, cb) {
+      log.info("changeThreadTheme", "Setting theme '" + actualThemeName + "' (ID: " + themeID + ") for thread " + threadID);
+
+      var currentEpochId = parseInt(utils.generateOfflineThreadingID());
+      var publishedCount = 0;
+      var errors = [];
+
+      // Helper to create and publish MQTT message
+      function createAndPublish(label, queueName, payload, done) {
+        currentEpochId = parseInt(utils.generateOfflineThreadingID());
+        ctx.wsReqNumber += 1;
+        ctx.wsTaskNumber += 1;
+
+        var requestId = ctx.wsReqNumber;
+
+        var queryPayload = {
+          thread_key: threadID.toString(),
+          theme_fbid: themeID.toString(),
+          sync_group: 1
+        };
+
+        // Merge additional payload
+        Object.keys(payload).forEach(function(key) {
+          queryPayload[key] = payload[key];
+        });
+
+        var query = {
+          failure_count: null,
+          label: label,
+          payload: JSON.stringify(queryPayload),
+          queue_name: queueName,
+          task_id: ctx.wsTaskNumber
+        };
+
+        var context = {
+          app_id: ctx.appID || "2220391788200892",
+          payload: {
+            epoch_id: currentEpochId,
+            tasks: [query],
+            version_id: "24631415369801570"
+          },
+          request_id: requestId,
+          type: 3
+        };
+
+        context.payload = JSON.stringify(context.payload);
+
+        log.info("changeThreadTheme", "Publishing MQTT message: label=" + label + ", queueName=" + queueName);
+
+        ctx.mqttClient.publish("/ls_req", JSON.stringify(context), { qos: 1, retain: false }, function (err) {
+          if (err) {
+            log.error("changeThreadTheme", "MQTT publish failed for " + queueName + ":", err);
+            errors.push("Failed to publish " + queueName + ": " + err.message);
+          } else {
+            publishedCount++;
+            log.info("changeThreadTheme", "Successfully published " + queueName);
+          }
+          done();
+        });
+      }
+
+      // Publish all required MQTT messages in parallel
+      var pending = 4;
+      function checkComplete() {
+        pending--;
+        if (pending === 0) {
+          if (errors.length > 0) {
+            return cb({ error: "Some MQTT publishes failed: " + errors.join(", ") });
+          }
+
+          var eventData = {
+            type: "thread_theme_update",
+            threadID: threadID,
+            themeID: themeID,
+            themeName: actualThemeName,
+            senderID: ctx.userID,
+            timestamp: Date.now()
+          };
+
+          log.info("changeThreadTheme", "✅ Theme changed successfully!");
+          cb(null, eventData);
+        }
+      }
+
+      // Publish 4 different MQTT messages (required by Facebook)
+      createAndPublish("1013", "ai_generated_theme", {}, checkComplete);
+      createAndPublish("1037", "msgr_custom_thread_theme", {}, checkComplete);
+      createAndPublish("1028", "thread_theme_writer", {}, checkComplete);
+      createAndPublish("43", "thread_theme", { source: null, payload: null }, checkComplete);
+    }
+
+    /**
+     * Main logic
+     */
+    fetchAllThemes(function (err, themes) {
+      if (err) {
+        return callback(err);
+      }
+
+      // If user wants to list themes
+      if (themeName.toLowerCase() === "list") {
+        log.info("changeThreadTheme", "Returning list of " + themes.length + " available themes");
+        return callback(null, themes);
+      }
+
+      // Find matching theme
+      var normalizedThemeName = themeName.toLowerCase();
+      var matchedTheme = null;
+
+      // 1. Try exact ID match
+      if (!isNaN(normalizedThemeName)) {
+        matchedTheme = themes.find(function (t) {
+          return t.id === normalizedThemeName;
+        });
+      }
+
+      // 2. Try exact name match
+      if (!matchedTheme) {
+        matchedTheme = themes.find(function (t) {
+          return t.name.toLowerCase() === normalizedThemeName;
+        });
+      }
+
+      // 3. Try partial name match
+      if (!matchedTheme) {
+        matchedTheme = themes.find(function (t) {
+          return t.name.toLowerCase().includes(normalizedThemeName);
+        });
+      }
+
+      if (!matchedTheme) {
+        log.warn("changeThreadTheme", "Theme '" + themeName + "' not found");
+        return callback({
+          error: "Theme \"" + themeName + "\" not found. Use api.changeThreadTheme('list', threadID) to see available themes."
+        });
+      }
+
+      // Set the theme
+      setThemeViaMqtt(matchedTheme.id, matchedTheme.name, callback);
+    });
+
+    return returnPromise;
+  };
+};

package/src/comment.js

@@ -0,0 +1,244 @@
+"use strict";
+
+/**
+ * Comment API Module
+ * Create comments on Facebook posts with support for attachments, mentions, stickers, and URLs
+ * 
+ * @author Priyansh Rajput
+ * @github https://github.com/priyanshufsdev
+ * @license MIT
+ */
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+/**
+ * Handle upload of attachments (images/videos) for comment
+ * @param {object} defaultFuncs - Default functions for API requests
+ * @param {object} ctx - Context object
+ * @param {object} msg - Message object containing attachments
+ * @param {object} form - Form object to populate
+ * @returns {Promise<void>}
+ */
+async function handleUpload(defaultFuncs, ctx, msg, form) {
+  if (!msg.attachments || msg.attachments.length === 0) {
+    return;
+  }
+
+  var uploads = msg.attachments.map(function(item) {
+    if (!utils.isReadableStream(item)) {
+      throw new Error('Attachments must be a readable stream.');
+    }
+    
+    return defaultFuncs
+      .postFormData('https://www.facebook.com/ajax/ufi/upload/', ctx.jar, {
+        profile_id: ctx.userID,
+        source: 19,
+        target_id: ctx.userID,
+        file: item
+      })
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function(res) {
+        if (res.error || !res.payload || !res.payload.fbid) {
+          throw res;
+        }
+        return { media: { id: res.payload.fbid } };
+      });
+  });
+
+  var results = await Promise.all(uploads);
+  results.forEach(function(result) {
+    form.input.attachments.push(result);
+  });
+}
+
+/**
+ * Handle URL attachment for comment
+ * @param {object} msg - Message object
+ * @param {object} form - Form object
+ */
+function handleURL(msg, form) {
+  if (typeof msg.url === 'string') {
+    form.input.attachments.push({
+      link: {
+        external: {
+          url: msg.url
+        }
+      }
+    });
+  }
+}
+
+/**
+ * Handle mentions in comment body
+ * @param {object} msg - Message object
+ * @param {object} form - Form object
+ */
+function handleMentions(msg, form) {
+  if (!msg.mentions) return;
+
+  for (var i = 0; i < msg.mentions.length; i++) {
+    var item = msg.mentions[i];
+    var tag = item.tag;
+    var id = item.id;
+    var fromIndex = item.fromIndex;
+    
+    if (typeof tag !== 'string' || !id) {
+      log.warn('comment', 'Mentions must have a string "tag" and an "id".');
+      continue;
+    }
+    
+    var offset = msg.body.indexOf(tag, fromIndex || 0);
+    if (offset < 0) {
+      log.warn('comment', 'Mention for "' + tag + '" not found in message string.');
+      continue;
+    }
+    
+    form.input.message.ranges.push({
+      entity: { id: id },
+      length: tag.length,
+      offset: offset
+    });
+  }
+}
+
+/**
+ * Handle sticker attachment for comment
+ * @param {object} msg - Message object
+ * @param {object} form - Form object
+ */
+function handleSticker(msg, form) {
+  if (msg.sticker) {
+    form.input.attachments.push({
+      media: {
+        id: String(msg.sticker)
+      }
+    });
+  }
+}
+
+/**
+ * Submit final comment form to GraphQL endpoint
+ * @param {object} defaultFuncs - Default functions
+ * @param {object} ctx - Context object
+ * @param {object} form - Fully constructed form object
+ * @returns {Promise<object>}
+ */
+async function createContent(defaultFuncs, ctx, form) {
+  var res = await defaultFuncs
+    .post('https://www.facebook.com/api/graphql/', ctx.jar, {
+      fb_api_caller_class: 'RelayModern',
+      fb_api_req_friendly_name: 'useCometUFICreateCommentMutation',
+      variables: JSON.stringify(form),
+      server_timestamps: true,
+      doc_id: 6993516810709754
+    })
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  
+  if (res.errors) {
+    throw res;
+  }
+  
+  var commentEdge = res.data.comment_create.feedback_comment_edge;
+  return {
+    id: commentEdge.node.id,
+    url: commentEdge.node.feedback.url,
+    count: res.data.comment_create.feedback.total_comment_count
+  };
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  /**
+   * Create a comment on a Facebook post
+   * Can also reply to an existing comment
+   * 
+   * @param {string|object} msg - Message to post (string or object with body, attachments, mentions, etc.)
+   * @param {string} postID - ID of the post to comment on
+   * @param {string} replyCommentID - Optional: ID of comment to reply to
+   * @param {function} callback - Optional callback function
+   * @returns {Promise<object>}
+   */
+  return function createCommentPost(msg, postID, replyCommentID, callback) {
+    var resolveFunc = function() {};
+    var rejectFunc = function() {};
+    var returnPromise = new Promise(function(resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    // Handle optional parameters
+    if (typeof replyCommentID === 'function') {
+      callback = replyCommentID;
+      replyCommentID = null;
+    }
+    
+    if (!callback) {
+      callback = function(err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    // Validation
+    if (typeof msg !== 'string' && typeof msg !== 'object') {
+      var error = 'Message must be a string or an object.';
+      log.error('comment', error);
+      return callback({ error: error });
+    }
+    
+    if (typeof postID !== 'string') {
+      var error2 = 'postID must be a string.';
+      log.error('comment', error2);
+      return callback({ error: error2 });
+    }
+
+    // Prepare message object
+    var messageObject = typeof msg === 'string' ? { body: msg } : msg;
+    messageObject.mentions = messageObject.mentions || [];
+    messageObject.attachments = messageObject.attachments || [];
+    
+    // Build form
+    var form = {
+      feedLocation: 'NEWSFEED',
+      feedbackSource: 1,
+      groupID: null,
+      input: {
+        client_mutation_id: Math.round(Math.random() * 19).toString(),
+        actor_id: ctx.userID,
+        attachments: [],
+        feedback_id: Buffer.from('feedback:' + postID).toString('base64'),
+        message: {
+          ranges: [],
+          text: messageObject.body || ''
+        },
+        reply_comment_parent_fbid: replyCommentID || null,
+        is_tracking_encrypted: true,
+        tracking: [],
+        feedback_source: 'NEWS_FEED',
+        idempotence_token: 'client:' + utils.getGUID(),
+        session_id: utils.getGUID()
+      },
+      scale: 1,
+      useDefaultActor: false
+    };
+
+    // Process all handlers and create comment
+    handleUpload(defaultFuncs, ctx, messageObject, form)
+      .then(function() {
+        handleURL(messageObject, form);
+        handleMentions(messageObject, form);
+        handleSticker(messageObject, form);
+        return createContent(defaultFuncs, ctx, form);
+      })
+      .then(function(info) {
+        log.info('comment', 'Comment created successfully: ' + info.id);
+        callback(null, info);
+      })
+      .catch(function(err) {
+        log.error('comment', err);
+        callback(err);
+      });
+
+    return returnPromise;
+  };
+};