bb-fca 2.0.0

package/src/deltas/apis/mqtt/realtime.ts

@@ -0,0 +1,169 @@
+import { EventEmitter } from 'events';
+import HttpsProxyAgent from 'https-proxy-agent';
+import { WebSocket } from 'undici';
+import utils = require('../../../utils');
+
+function formatNotification(data) {
+  if (!data.data || !data.data.viewer) return null;
+  const notifEdge =
+    data.data.viewer.notifications_page?.edges?.[1]?.node?.notif;
+  if (!notifEdge) return null;
+
+  return {
+    type: 'notification',
+    notifID: notifEdge.notif_id,
+    body: notifEdge.body?.text,
+    senderID: Object.keys(notifEdge.tracking.from_uids || {})[0],
+    url: notifEdge.url,
+    timestamp: notifEdge.creation_time.timestamp,
+    seenState: notifEdge.seen_state,
+  };
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function listenRealtime() {
+    const emitter: any = new EventEmitter();
+    let ws;
+    let reconnectTimeout;
+    let keepAliveInterval;
+
+    const subscriptions = [
+      '{"x-dgw-app-XRSS-method":"Falco","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:USER_ACTIVITY_UPDATE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9525970914181809","x-dgw-app-XRSS-routing_hint":"UserActivitySubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:ACTOR_GATEWAY_EXPERIENCE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24191710730466150","x-dgw-app-XRSS-routing_hint":"CometActorGatewayExperienceSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      `{"x-dgw-app-XRSS-method":"FBLQ:comet_notifications_live_query_experimental","x-dgw-app-XRSS-doc_id":"9784489068321501","x-dgw-app-XRSS-actor_id":"${ctx.userID}","x-dgw-app-XRSS-page_id":"${ctx.userID}","x-dgw-app-XRSS-request_stream_retry":"false","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}`,
+      '{"x-dgw-app-XRSS-method":"FBGQLS:FRIEND_REQUEST_CONFIRM_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9687616244672204","x-dgw-app-XRSS-routing_hint":"FriendingCometFriendRequestConfirmSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:FRIEND_REQUEST_RECEIVE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24047008371656912","x-dgw-app-XRSS-routing_hint":"FriendingCometFriendRequestReceiveSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:RTWEB_CALL_BLOCKED_SETTING_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"24429620016626810","x-dgw-app-XRSS-routing_hint":"RTWebCallBlockedSettingSubscription_CallBlockSettingSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"PresenceUnifiedJSON","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:MESSENGER_CHAT_TABS_NOTIFICATION_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"23885219097739619","x-dgw-app-XRSS-routing_hint":"MWChatTabsNotificationSubscription_MessengerChatTabsNotificationSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:BATCH_NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"30300156509571373","x-dgw-app-XRSS-routing_hint":"CometBatchNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"23864641996495578","x-dgw-app-XRSS-routing_hint":"CometNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+      '{"x-dgw-app-XRSS-method":"FBGQLS:NOTIFICATION_STATE_CHANGE_SUBSCRIBE","x-dgw-app-XRSS-doc_id":"9754477301332178","x-dgw-app-XRSS-routing_hint":"CometFriendNotificationsStateChangeSubscription","x-dgw-app-xrs-body":"true","x-dgw-app-XRS-Accept-Ack":"RSAck","x-dgw-app-XRSS-http_referer":"https://www.facebook.com/friends"}',
+    ];
+
+    async function handleMessage(data) {
+      try {
+        const text = await data.text();
+        const jsonStart = text.indexOf('{');
+        if (jsonStart !== -1) {
+          const jsonData = JSON.parse(text.substring(jsonStart));
+          if (jsonData.code === 200) {
+            utils.log('✅ Subscription success received.');
+            emitter.emit('success', jsonData);
+            return;
+          }
+
+          const formattedNotif = formatNotification(jsonData);
+          if (formattedNotif) {
+            emitter.emit('notification', formattedNotif);
+          } else {
+            emitter.emit('payload', jsonData);
+          }
+        }
+      } catch (err) {
+        utils.error('❌ Error parsing WebSocket message:', err);
+        emitter.emit('error', err);
+      }
+    }
+
+    async function connect() {
+      try {
+        const queryParams = new URLSearchParams({
+          'x-dgw-appid': '2220391788200892',
+          'x-dgw-appversion': '0',
+          'x-dgw-authtype': '1:0',
+          'x-dgw-version': '5',
+          'x-dgw-uuid': ctx.userID,
+          'x-dgw-tier': 'prod',
+          'x-dgw-deviceid': ctx.clientID,
+          'x-dgw-app-stream-group': 'group1',
+        });
+
+        const url = `wss://gateway.facebook.com/ws/realtime?${queryParams.toString()}`;
+        const cookies = ctx.jar
+          .getCookiesSync('https://www.facebook.com')
+          .join('; ');
+
+        const baseHeaders = {
+          Cookie: cookies,
+          Origin: 'https://www.facebook.com',
+          'User-Agent': ctx.globalOptions.userAgent,
+          Referer: 'https://www.facebook.com',
+          Host: new URL(url).hostname,
+          'Accept-Encoding': 'gzip, deflate, br',
+          'Accept-Language': 'en-US,en;q=0.9',
+        };
+
+        utils.log(
+          `📤 Headers for WebSocket handshake:\n${Object.entries(baseHeaders)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join('\n')}`,
+        );
+
+        const wsOptions: any = { headers: baseHeaders };
+        if (ctx.globalOptions.proxy) {
+          wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+        }
+
+        ws = new WebSocket(url, wsOptions);
+
+        ws.onopen = () => {
+          utils.log('✅ Connected via undici.WebSocket');
+          subscriptions.forEach((payload, index) => {
+            const prefix = Buffer.from([14, index, 0, payload.length]);
+            const suffix = Buffer.from([0, 0]);
+            const fullMessage = Buffer.concat([
+              prefix,
+              Buffer.from(payload),
+              suffix,
+            ]);
+            ws.send(fullMessage);
+          });
+
+          keepAliveInterval = setInterval(() => {
+            if (ws.readyState === ws.OPEN) {
+              ws.send('ping');
+              utils.log('🔁 Sent keep-alive ping.');
+            }
+          }, 10000);
+        };
+
+        ws.onmessage = (event) => {
+          if (event.data instanceof Blob) {
+            handleMessage(event.data);
+          } else {
+            utils.warn('Unknown message type:', typeof event.data);
+          }
+        };
+
+        ws.onerror = (err) => {
+          utils.error('WebSocket error:', err.message || err);
+          emitter.emit('error', err);
+        };
+
+        ws.onclose = () => {
+          utils.warn('🔌 WebSocket closed. Reconnecting...');
+          clearInterval(keepAliveInterval);
+          reconnectTimeout = setTimeout(connect, 1000);
+        };
+      } catch (err) {
+        utils.error('💥 Connection error:', err.message);
+        emitter.emit('error', err);
+        clearInterval(keepAliveInterval);
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = setTimeout(connect, 1000);
+      }
+    }
+
+    connect();
+
+    emitter.stop = () => {
+      clearInterval(keepAliveInterval);
+      clearTimeout(reconnectTimeout);
+      if (ws) ws.close();
+    };
+
+    return emitter;
+  };
+}

package/src/deltas/apis/mqtt/sendMessageMqtt.ts

@@ -0,0 +1,206 @@
+import utils = require('../../../utils');
+const delay = async (ms) => await new Promise((res) => setTimeout(res, ms));
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  /**
+   * Uploads an attachment to Facebook's servers.
+   * @param {Array<Stream>} attachments An array of readable streams.
+   * @param {Function} callback The callback function.
+   */
+  function uploadAttachment(attachments, callback) {
+    callback = callback || function() {};
+    var uploads = [];
+    for (var i = 0; i < attachments.length; i++) {
+      if (!utils.isReadableStream(attachments[i])) {
+        throw {
+          error:
+            'Attachment should be a readable stream and not ' +
+            utils.getType(attachments[i]) +
+            '.',
+        };
+      }
+      var form = {
+        upload_1024: attachments[i],
+        voice_clip: 'true',
+      };
+      uploads.push(
+        defaultFuncs
+          .postFormData(
+            'https://upload.facebook.com/ajax/mercury/upload.php',
+            ctx.jar,
+            form,
+            {},
+          )
+          .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+          .then((resData) => {
+            if (resData.error) throw resData;
+            return resData.payload.metadata[0];
+          }),
+      );
+    }
+    Promise.all(uploads)
+      .then((resData) => callback(null, resData))
+      .catch((err) => {
+        utils.error('uploadAttachment', err);
+        return callback(err);
+      });
+  }
+
+  function getSendPayload(threadID, msg, otid) {
+    const isString = typeof msg === 'string';
+    const body = isString ? msg : msg.body || '';
+    otid = otid.toString() || utils.generateOfflineThreadingID().toString();
+    let payload: any = {
+      thread_id: threadID.toString(),
+      otid,
+      source: 0,
+      send_type: 1,
+      sync_group: 1,
+      text: body,
+      initiating_source: 1,
+      skip_url_preview_gen: 0,
+    };
+    if (typeof msg === 'object') {
+      if (msg.sticker) {
+        payload.send_type = 2;
+        payload.sticker_id = msg.sticker;
+        payload.text = null;
+      }
+      if (msg.attachment) {
+        payload.send_type = 3;
+        payload.attachment_fbids = Array.isArray(msg.attachment)
+          ? msg.attachment
+          : [msg.attachment];
+      }
+    }
+    return payload;
+  }
+
+  /**
+   * Sends a message to a thread via MQTT with optional sequential editing.
+   * @param {object|string} msg The message to send. Can be a string or an object.
+   * @param {string} msg.body The main text of the message.
+   * @param {*} [msg.attachment] An attachment to send.
+   * @param {*} [msg.sticker] A sticker to send.
+   * @param {*} [msg.emoji] An emoji to send.
+   * @param {string} threadID The ID of the thread.
+   * @param {string} [replyToMessage] The ID of the message to reply to.
+   */
+
+  return async (msg, threadID, replyToMessage, callback) => {
+    if (typeof msg !== 'string' && typeof msg !== 'object') {
+      throw new Error(
+        'Message should be of type string or object, not ' +
+          utils.getType(msg) +
+          '.',
+      );
+    }
+
+    if (typeof threadID !== 'string' && typeof threadID !== 'number') {
+      throw new Error('threadID must be a string or number.');
+    }
+
+    if (!callback && typeof threadID === 'function') {
+      throw new Error('Pass a threadID as a second argument.');
+    }
+
+    if (!callback && typeof replyToMessage === 'function') {
+      callback = replyToMessage;
+      replyToMessage = null;
+    }
+
+    let resolveFunc: Function = () => {};
+    let rejectFunc: Function = () => {};
+    let returnPromise = new Promise<any>((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    const timestamp = Date.now();
+    const otid = utils.generateOfflineThreadingID();
+    const epoch_id = utils.generateOfflineThreadingID();
+    const payload = getSendPayload(threadID, msg, otid);
+
+    const tasks = [
+      {
+        label: '46',
+        payload,
+        queue_name: threadID.toString(),
+        task_id: 0,
+        failure_count: null,
+      },
+      {
+        label: '21',
+        payload: {
+          thread_id: threadID.toString(),
+          last_read_watermark_ts: timestamp,
+          sync_group: 1,
+        },
+        queue_name: threadID.toString(),
+        task_id: 1,
+        failure_count: null,
+      },
+    ];
+
+    if (replyToMessage) {
+      tasks[0].payload.reply_metadata = {
+        reply_source_id: replyToMessage,
+        reply_source_type: 1,
+        reply_type: 0,
+      };
+    }
+
+    const form: any = {
+      app_id: '2220391788200892',
+      payload: {
+        tasks,
+        epoch_id,
+        version_id: '6120284488008082',
+        data_trace_id: null,
+      },
+      request_id: 1,
+      type: 3,
+    };
+
+    if (msg.attachment) {
+      try {
+        const files = await new Promise<any>((resolve, reject) => {
+          uploadAttachment(
+            Array.isArray(msg.attachment) ? msg.attachment : [msg.attachment],
+            (err, files) => {
+              if (err) return reject(err);
+              return resolve(files);
+            },
+          );
+        });
+        form.payload.tasks[0].payload.attachment_fbids = files.map(
+          (file) => Object.values(file)[0],
+        );
+      } catch (err) {
+        utils.error('Attachment upload failed:', err);
+        throw new Error(err);
+      }
+    }
+
+    form.payload.tasks.forEach((task) => {
+      task.payload = JSON.stringify(task.payload);
+    });
+    form.payload = JSON.stringify(form.payload);
+    await ctx.mqttClient.publish('/ls_req', JSON.stringify(form), {
+      qos: 1,
+      retain: false,
+    });
+    callback(null, {
+      threadID,
+      type: replyToMessage ? 'message_reply' : 'message',
+    });
+    return returnPromise;
+  };
+}

package/src/deltas/apis/mqtt/setMessageReactionMqtt.ts

@@ -0,0 +1,61 @@
+// @ChoruOfficial
+'use strict';
+
+import utils = require("../../../utils");
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export default function(defaultFuncs: any, api: any, ctx: any) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: Date.now(),
+      message_id: messageID,
+      reaction,
+      actor_id: ctx.userID,
+      reaction_style: null,
+      sync_group: 1,
+      send_attribution: Math.random() < 0.5 ? 65537 : 524289
+    };
+
+    const task = {
+      failure_count: null,
+      label: '29',
+      payload: JSON.stringify(taskPayload),
+      queue_name: JSON.stringify(['reaction', messageID]),
+      task_id: ctx.wsTaskNumber
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(utils.generateOfflineThreadingID()), // ✅ fixed here
+        tasks: [task],
+        version_id: '7158486590867448',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    /*if (isCallable(callback)) {
+      ctx.reqCallbacks[ctx.wsReqNumber] = callback;
+    }*/
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/deltas/apis/posting/comment.ts

@@ -0,0 +1,205 @@
+import utils = require("../../../utils");
+
+/**
+ * Handles the upload of attachments (images/videos) for a comment.
+ * @param {object} defaultFuncs - The default functions for making API requests.
+ * @param {object} ctx - The context object.
+ * @param {object} msg - The message object, containing attachments.
+ * @param {object} form - The main form object to be populated.
+ * @returns {Promise<void>}
+ */
+async function handleUpload(defaultFuncs, ctx, msg, form) {
+    if (!msg.attachments || msg.attachments.length === 0) {
+        return;
+    }
+
+    const uploads = msg.attachments.map(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(res => {
+                if (res.error || !res.payload?.fbid) {
+                    throw res;
+                }
+                return { media: { id: res.payload.fbid } };
+            });
+    });
+
+    const results = await Promise.all(uploads);
+    form.input.attachments.push(...results);
+}
+
+/**
+ * Handles a URL attachment for a comment.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleURL(msg, form) {
+    if (typeof msg.url === 'string') {
+        form.input.attachments.push({
+            link: {
+                external: {
+                    url: msg.url
+                }
+            }
+        });
+    }
+}
+
+/**
+ * Handles mentions in the comment body.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleMentions(msg, form) {
+    if (!msg.mentions) return;
+
+    for (const item of msg.mentions) {
+        const { tag, id, fromIndex } = item;
+        if (typeof tag !== 'string' || !id) {
+            utils.warn('createCommentPost', 'Mentions must have a string "tag" and an "id".');
+            continue;
+        }
+        const offset = msg.body.indexOf(tag, fromIndex || 0);
+        if (offset < 0) {
+            utils.warn('createCommentPost', `Mention for "${tag}" not found in message string.`);
+            continue;
+        }
+        form.input.message.ranges.push({
+            entity: { id },
+            length: tag.length,
+            offset
+        });
+    }
+}
+
+/**
+ * Handles a sticker attachment for a comment.
+ * @param {object} msg - The message object.
+ * @param {object} form - The main form object.
+ */
+function handleSticker(msg, form) {
+    if (msg.sticker) {
+        form.input.attachments.push({
+            media: {
+                id: String(msg.sticker)
+            }
+        });
+    }
+}
+
+/**
+ * Submits the final comment form to the GraphQL endpoint.
+ * @param {object} defaultFuncs - The default functions.
+ * @param {object} ctx - The context object.
+ * @param {object} form - The fully constructed form object.
+ * @returns {Promise<object>} A promise that resolves with the comment info.
+ */
+async function createContent(defaultFuncs, ctx, form) {
+    const 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;
+    }
+
+    const 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
+    };
+}
+
+/**
+ * Creates a comment on a Facebook post. Can also reply to an existing comment.
+ * @param {string|object} msg - The message to post. Can be a string or an object with `body`, `attachments`, `mentions`, etc.
+ * @param {string} postID - The ID of the post to comment on.
+ * @param {string} [replyCommentID] - (Optional) The ID of the comment to reply to.
+ * @param {function} [callback] - (Optional) A callback function.
+ * @returns {Promise<object>} A promise that resolves with the new comment's information.
+ */
+export default function(defaultFuncs: any, api: any, ctx: any) {
+    return async function createCommentPost(msg, postID, replyCommentID, callback) {
+        let cb;
+        const returnPromise = new Promise<any>((resolve, reject) => {
+            cb = (error, info) => info ? resolve(info) : reject(error);
+        });
+
+        if (typeof replyCommentID === 'function') {
+            callback = replyCommentID;
+            replyCommentID = null;
+        }
+        if (typeof callback === 'function') {
+            cb = callback;
+        }
+
+        if (typeof msg !== 'string' && typeof msg !== 'object') {
+            const error = 'Message must be a string or an object.';
+            utils.error('createCommentPost', error);
+            return cb(error);
+        }
+        if (typeof postID !== 'string') {
+            const error = 'postID must be a string.';
+            utils.error('createCommentPost', error);
+            return cb(error);
+        }
+
+        let messageObject = typeof msg === 'string' ? { body: msg } : { ...msg };
+        messageObject.mentions = messageObject.mentions || [];
+        messageObject.attachments = messageObject.attachments || [];
+
+        const 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
+        };
+
+        try {
+            await handleUpload(defaultFuncs, ctx, messageObject, form);
+            handleURL(messageObject, form);
+            handleMentions(messageObject, form);
+            handleSticker(messageObject, form);
+            const info = await createContent(defaultFuncs, ctx, form);
+            cb(null, info);
+        } catch (err) {
+            utils.error('createCommentPost', err);
+            cb(err);
+        }
+
+        return returnPromise;
+    };
+};