@cexy/hoonfca 1.0.0 → 1.0.1

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;
+  };
+};

package/src/apis/unfriend.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function unfriend(userID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      const form = {
+        uid: userID,
+        unref: "bd_friends_tab",
+        floc: "friends_tab",
+        "nctr[_mod]": "pagelet_timeline_app_collection_" + ctx.userID + ":2356318349:2"
+      };
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/profile/removefriendconfirm.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.error) {
+        throw res;
+      }
+
+      callback(null, true);
+    } catch (err) {
+      utils.error("unfriend", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/unsendMessage.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const utils = require('../utils');
+
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return async (messageID) => {
+    const defData = await defaultFuncs.post("https://www.facebook.com/messaging/unsend_message/", ctx.jar, {
+      message_id: messageID
+    })
+    const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
+    if (resData.error) {
+      throw new Error(resData);
+    }
+    return resData;
+  };
+};

package/src/engine/client.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const utils = require("../utils");
+const setOptionsModel = require('./models/setOptions');
+const buildAPIModel = require('./models/buildAPI');
+const loginHelperModel = require('./models/loginHelper');
+
+let globalOptions = {};
+let ctx = null;
+let defaultFuncs = null;
+let api = null;
+
+const fbLink = (ext) => ("https://www.facebook.com" + (ext ? '/' + ext : ''));
+const ERROR_RETRIEVING = "Error retrieving userID. This can be caused by many factors, including being blocked by Facebook for logging in from an unknown location. Try logging in with a browser to verify.";
+
+/**
+ * Initiates the login process for a Facebook account.
+ *
+ * @param {object} credentials The user's login credentials (e.g., email/password or appState cookies).
+ * @param {object} [options={}] Optional login configurations.
+ * @param {function} [callback] Optional callback function. If omitted, returns a Promise.
+ * @returns {Promise|void} Returns Promise if no callback provided, otherwise void.
+ */
+async function login(credentials, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    }
+    
+    let promiseCallback = null;
+    let rejectFunc = null;
+    let resolveFunc = null;
+    let returnPromise = null;
+
+    if (typeof callback !== "function") {
+        returnPromise = new Promise(function (resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        promiseCallback = function (error, api) {
+            if (error) return rejectFunc(error);
+            return resolveFunc(api);
+        };
+        callback = promiseCallback;
+    }
+
+    if ('logging' in options) {
+        utils.logOptions(options.logging);
+    }
+    const defaultOptions = {
+        selfListen: false,
+        listenEvents: true,
+        listenTyping: false,
+        simulateTyping: true,
+        updatePresence: false,
+        forceLogin: false,
+        autoMarkDelivery: false,
+        autoMarkRead: true,
+        autoReconnect: true,
+        online: true,
+        emitReady: false,
+        userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    };
+    Object.assign(globalOptions, defaultOptions, options);
+
+    await setOptionsModel(globalOptions, options);
+
+    loginHelperModel(
+        credentials,
+        globalOptions,
+        (loginError, loginApi) => {
+            if (loginError) {
+                return callback(loginError);
+            }
+            api = loginApi;
+            ctx = loginApi.ctx;
+            defaultFuncs = loginApi.defaultFuncs;
+            return callback(null, loginApi);
+        },
+        setOptionsModel,
+        buildAPIModel,
+        api,
+        fbLink, 
+        ERROR_RETRIEVING
+    );
+
+    return returnPromise;
+}
+
+module.exports = {
+    login
+};