shadowx-fca 2.4.0 → 2.5.0

package/src/share.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const utils = require('../utils');
+
+function formatPreviewResult(data) {
+    if (data.errors) {
+        throw data.errors[0];
+    }
+    const previewData = data.data?.xma_preview_data;
+    if (!previewData) {
+        throw { error: "Could not generate a preview for this post." };
+    }
+    return {
+        postID: previewData.post_id,
+        header: previewData.header_title,
+        subtitle: previewData.subtitle_text,
+        title: previewData.title_text,
+        previewImage: previewData.preview_url,
+        favicon: previewData.favicon_url,
+        headerImage: previewData.header_image_url
+    };
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+    return async function getPostPreview(postID, callback) {
+        let cb;
+        const returnPromise = new Promise((resolve, reject) => {
+            cb = (err, data) => err ? reject(err) : resolve(data);
+        });
+        
+        if (typeof callback === 'function') cb = callback;
+        if (!postID) {
+            return cb({ error: "A postID is required to generate a preview." });
+        }
+
+        const variables = {
+            shareable_id: postID.toString(),
+            scale: 3,
+        };
+
+        const form = {
+            fb_api_caller_class: 'RelayModern',
+            fb_api_req_friendly_name: 'CometXMAProxyShareablePreviewQuery',
+            variables: JSON.stringify(variables),
+            doc_id: '28939050904374351'
+        };
+
+        try {
+            const resData = await defaultFuncs
+                .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+            
+            const result = formatPreviewResult(resData);
+            return cb(null, result);
+        } catch (err) {
+            utils.error("getPostPreview", err);
+            return cb(err);
+        }
+
+        return returnPromise;
+    };
+};

package/src/shareContact.js

@@ -1,11 +1,23 @@
 /* eslint-disable linebreak-style */
 "use strict";
 
-// fixed by kenneth panio
-
-var utils = require("../utils");
-
+const utils = require('../utils');
+
+/**
+ * @module shareContact
+ * @param {Object} defaultFuncs - The default functions provided by the API.
+ * @param {Object} api - The full API object.
+ * @param {Object} ctx - The context object.
+ * @returns {function(text: string, senderID: string, threadID: string, callback: Function): void} - A function to share a contact.
+ */
 module.exports = function(defaultFuncs, api, ctx) {
+  /**
+   * Shares a user's contact information into a specific thread via MQTT.
+   * @param {string} [text] - An optional message to send along with the contact card.
+   * @param {string} senderID - The Facebook user ID of the contact you want to share.
+   * @param {string} threadID - The ID of the thread where the contact will be shared.
+   * @param {Function} [callback] - An optional callback function to be executed.
+   */
   return function shareContact(text, senderID, threadID, callback) {
     if (!ctx.mqttClient) {
       throw new Error('Not connected to MQTT');
@@ -28,7 +40,7 @@ module.exports = function(defaultFuncs, api, ctx) {
       failure_count: null,
       label: '359',
       payload: JSON.stringify(queryPayload),
-      queue_name: 'messenger_contact_sharing',//xma_open_contact_share
+      queue_name: 'messenger_contact_sharing',
       task_id: Math.random() * 1001 << 0,
     };
 
@@ -52,59 +64,3 @@ module.exports = function(defaultFuncs, api, ctx) {
     ctx.mqttClient.publish('/ls_req', JSON.stringify(context), { qos: 1, retain: false });
   };
 };
-
-/*"use strict";
-
-
-var utils = require("../utils");
-
-// @NethWs3Dev
-
-
-module.exports = function (defaultFuncs, api, ctx) {
-	return async function shareContact(text, senderID, threadID, callback) {
-await utils.parseAndCheckLogin(ctx, defaultFuncs);
-        const mqttClient = ctx.mqttClient;
-
-        if (!mqttClient) {
-            throw new Error("Not connected to MQTT");
-        }
-		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);
-	data		};
-		}
-		let count_req = 0
-		var form = JSON.stringify({
-						"app_id": "2220391788200892",
-						"payload": JSON.stringify({
-								tasks: [{
-										label: '359',
-										payload: JSON.stringify({
-											"contact_id": senderID,
-											"sync_group": 1,
-											"text": text || "",
-											"thread_id": threadID
-										}),
-										queue_name: 'messenger_contact_sharing',
-										task_id: Math.random() * 1001 << 0,
-										failure_count: null,
-								}],
-								epoch_id: utils.generateOfflineThreadingID(),
-								version_id: '7214102258676893',
-						}),
-						"request_id": ++count_req,
-						"type": 3
-				});
-		mqttClient.publish('/ls_req',form)
-
-		return returnPromise;
-	};
-};*/

package/src/stickers.js

@@ -0,0 +1,117 @@
+"use strict";
+// sahilchat-fca — Sticker API
+// Author: S4hiilAns4ri (github.com/S4hiilAns4ri)
+
+const utils = require('../utils');
+
+function formatPackList(data) {
+  const trayPacks  = data?.data?.picker_plugins?.sticker_picker?.sticker_store?.tray_packs;
+  const storePacks = data?.data?.viewer?.sticker_store?.available_packs;
+  const packData   = storePacks || trayPacks;
+  if (!packData?.edges) return { packs: [], page_info: { has_next_page: false } };
+  return {
+    packs: packData.edges.map(e => e.node ? ({ id: e.node.id, name: e.node.name, thumbnail: e.node.thumbnail_image?.uri }) : null).filter(Boolean),
+    page_info : packData.page_info,
+    store_id  : data?.data?.viewer?.sticker_store?.id,
+  };
+}
+
+function formatStickerList(stickers) {
+  if (!stickers) return [];
+  return stickers.map(e => e.node ? ({
+    type         : "sticker",
+    stickerID    : e.node.id,
+    ID           : e.node.id,
+    url          : e.node.image?.uri,
+    animatedUrl  : e.node.animated_image?.uri,
+    packID       : e.node.pack?.id,
+    label        : e.node.label || e.node.accessibility_label,
+  }) : null).filter(Boolean);
+}
+
+module.exports = function(defaultFuncs, api, ctx) {
+  async function gql(form) {
+    const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+    if (!res)        throw new Error("GraphQL returned no data.");
+    if (res.errors)  throw new Error(res.errors[0].message);
+    return res;
+  }
+
+  return {
+    /**
+     * Search stickers by keyword.
+     * @param {string} query — Search term (e.g. "love", "happy")
+     * @returns {Promise<Array>}
+     */
+    search: async (query) => {
+      const res = await gql({
+        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',
+      });
+      return formatStickerList(res?.data?.sticker_search?.sticker_results?.edges);
+    },
+
+    /**
+     * List your sticker packs.
+     * @returns {Promise<Array>}
+     */
+    listPacks: async () => {
+      const res = await gql({
+        fb_api_caller_class    : 'RelayModern',
+        fb_api_req_friendly_name : 'CometStickerPickerCardQuery',
+        variables : JSON.stringify({ scale: 3, stickerInterface: "MESSAGES" }),
+        doc_id    : '10095807770482952',
+      });
+      return formatPackList(res).packs;
+    },
+
+    /**
+     * Get all stickers in a pack by packID.
+     * @param {string} packID
+     * @returns {Promise<Array>}
+     */
+    getStickersInPack: async (packID) => {
+      const res = await gql({
+        fb_api_caller_class    : 'RelayModern',
+        fb_api_req_friendly_name : 'CometStickerPickerPackContentRootQuery',
+        variables : JSON.stringify({ packID, stickerWidth: 128, stickerHeight: 128, scale: 3 }),
+        doc_id    : '23982341384707469',
+      });
+      return formatStickerList(res?.data?.sticker_pack?.stickers?.edges);
+    },
+
+    /**
+     * Add a sticker pack to your collection.
+     * @param {string} packID
+     * @returns {Promise<object>}
+     */
+    addPack: async (packID) => {
+      const res = await gql({
+        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',
+      });
+      return res.data.sticker_pack_add.sticker_pack;
+    },
+
+    /**
+     * Get trending AI-generated stickers.
+     * @param {number} [limit=10]
+     * @returns {Promise<Array>}
+     */
+    getAiStickers: async ({ limit = 10 } = {}) => {
+      const res = await gql({
+        fb_api_caller_class    : 'RelayModern',
+        fb_api_req_friendly_name : 'CometStickerPickerStickerGeneratedCardQuery',
+        variables : JSON.stringify({ limit }),
+        doc_id    : '24151467751156443',
+      });
+      const nodes = res?.data?.xfb_trending_generated_ai_stickers?.nodes || [];
+      return nodes.map(n => ({ type: "sticker", stickerID: n.id, ID: n.id, url: n.url, label: n.label }));
+    },
+  };
+};

package/src/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 S4hiilAns4ri, S4hiilAns4ri
+ */
+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/theme.js

@@ -0,0 +1,233 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Author: S4hiilAns4ri (github.com/S4hiilAns4ri) 
+   * 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;
+  };
+};