fca-horidai-remastered 1.0.0 → 2.0.0

package/src/getAcceptList.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var utils = require('../utils');
+var log = require('npmlog');
+
+module.exports = function (http, api, ctx) {
+  return function getAcceptList(callback) {
+    var form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "FriendingCometFriendsBadgeCountClearMutation",
+      variables: JSON.stringify({
+        hasTopTab: true,
+        hasBookmark: true,
+        input: {
+          source: "friending_tab",
+          actor_id: ctx.userID,
+          client_mutation_id: Math.round(Math.random() * 19).toString()
+        }
+      }),
+      server_timestamps: true,
+      doc_id: "6500595106704138"
+    };
+
+    http.post('https://www.facebook.com/api/graphql/', ctx.jar, form, null, null)
+      .then(utils.parseAndCheckLogin(ctx, http))
+      .then(function (res) {
+        if (res.errors) {
+          return callback(JSON.stringify(res.errors, null, 2));
+        }
+        return callback(JSON.stringify(res.data, null, 2));
+      })
+      .catch(function (err) {
+        log.error('addFriends', err);
+        return callback(err);
+      });
+  };
+};

package/src/getThreadInfoDeprecated.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function getThreadInfo(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);
+      };
+    }
+
+    var form = {
+      client: "mercury"
+    };
+
+    api.getUserInfo(threadID, function (err, userRes) {
+      if (err) return callback(err);
+      var key = Object.keys(userRes).length > 0 ? "user_ids" : "thread_fbids";
+      form["threads[" + key + "][0]"] = threadID;
+
+      if (ctx.globalOptions.pageId) form.request_user_id = ctx.globalOptions.pageId;
+
+      defaultFuncs
+        .post("https://www.facebook.com/ajax/mercury/thread_info.php", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) throw resData;
+          else if (!resData.payload) throw { error: "Could not retrieve thread Info." };
+
+          var threadData = resData.payload.threads[0];
+          var userData = userRes[threadID];
+
+          if (threadData == null) throw { error: "ThreadData is null" };
+
+          threadData.name = userData != null && userData.name != null ? userData.name : threadData.name;
+          threadData.image_src = userData != null && userData.thumbSrc != null ? userData.thumbSrc : threadData.image_src;
+          callback(null, utils.formatThread(threadData));
+        })
+        .catch(function (err) {
+          log.error("getThreadInfo", err);
+          return callback(err);
+        });
+    });
+    return returnPromise;
+  };
+};

package/src/listenMqtt.js

@@ -212,7 +212,7 @@ function listenMqtt(defaultFuncs, api, ctx, globalCallback) {
         maxThreshold: 0.9,
         interval: 60 * 1000,
         logLevel: 'warn',
-        logFile: path.join(process.cwd(), 'Horizon_Database' ,'memory.log'),
+        logFile: path.join(process.cwd(), 'main/database_fca' ,'memory.log'),
         smartReleaseEnabled: true,
         allowLog: (global.Fca.Require.FastConfig.AntiStuckAndMemoryLeak.LogFile.Use || false)
       };

package/src/pinMessage.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { generateOfflineThreadingID, getCurrentTimestamp } = require('../utils');
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function pinMessage(pinMode, messageID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    ctx.wsTaskNumber += 1;
+
+    const taskLabel = pinMode ? '430' : '431';
+    const queueNamePrefix = pinMode ? 'pin_msg_v2_' : 'unpin_msg_v2_';
+
+    const taskPayload = {
+      thread_key: threadID,
+      message_id: messageID,
+      timestamp_ms: getCurrentTimestamp(),
+    };
+
+    const task = {
+      failure_count: null,
+      label: taskLabel,
+      payload: JSON.stringify(taskPayload),
+      queue_name: `${queueNamePrefix}${threadID}`,
+      task_id: ctx.wsTaskNumber,
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: '25095469420099952',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    if (isCallable(callback)) {
+        // to be implemented
+    }
+
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/refreshFb_dtsg.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const utils = require("../utils");
+const log = require("npmlog");
+
+module.exports = function (defaultFuncs, api, ctx) {
+	/**
+	 * Refreshes the fb_dtsg and jazoest values.
+	 * @param {Function} callback
+	 * @returns {Promise}
+	 * @description if you don't update the value of fb_dtsg and jazoest for a long time an error "Please try closing and re-opening your browser window" will appear
+	 * @description you should refresh it every 48h or less
+	 */
+	return function refreshFb_dtsg(obj, callback) {
+		let resolveFunc = function () { };
+		let rejectFunc = function () { };
+		const returnPromise = new Promise(function (resolve, reject) {
+			resolveFunc = resolve;
+			rejectFunc = reject;
+		});
+
+		if (utils.getType(obj) === "Function" || utils.getType(obj) === "AsyncFunction") {
+			callback = obj;
+			obj = {};
+		}
+
+		if (!obj) {
+			obj = {};
+		}
+
+		if (utils.getType(obj) !== "Object") {
+			throw new utils.CustomError("the first parameter must be an object or a callback function");
+		}
+
+		if (!callback) {
+			callback = function (err, friendList) {
+				if (err) {
+					return rejectFunc(err);
+				}
+				resolveFunc(friendList);
+			};
+		}
+
+		if (Object.keys(obj).length == 0) {
+			utils
+				.get('https://m.facebook.com/', ctx.jar, null, ctx.globalOptions, { noRef: true })
+				.then(function (resData) {
+					const html = resData.body;
+					const fb_dtsg = utils.getFrom(html, 'name="fb_dtsg" value="', '"');
+					const jazoest = utils.getFrom(html, 'name="jazoest" value="', '"');
+					if (!fb_dtsg) {
+						throw new utils.CustomError("Could not find fb_dtsg in HTML after requesting https://www.facebook.com/");
+					}
+					ctx.fb_dtsg = fb_dtsg;
+					ctx.jazoest = jazoest;
+					callback(null, {
+						data: {
+							fb_dtsg: fb_dtsg,
+							jazoest: jazoest
+						},
+						message: "refreshed fb_dtsg and jazoest"
+					});
+				})
+				.catch(function (err) {
+					log.error("refreshFb_dtsg", err);
+					return callback(err);
+				});
+		}
+		else {
+			Object.keys(obj).forEach(function (key) {
+				ctx[key] = obj[key];
+			});
+			callback(null, {
+				data: obj,
+				message: "refreshed " + Object.keys(obj).join(", ")
+			});
+		}
+
+		return returnPromise;
+	};
+};

package/src/sendComment.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var utils = require("../utils");
+var log = require("npmlog");
+var bluebird = require("bluebird");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  function getGUID() {
+    let _0x161e32 = Date.now(),
+      _0x4ec135 = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
+        /[xy]/g,
+        function (_0x32f946) {
+          let _0x141041 = Math.floor((_0x161e32 + Math.random() * 16) % 16);
+          _0x161e32 = Math.floor(_0x161e32 / 16);
+          let _0x31fcdd = (
+            _0x32f946 == "x" ? _0x141041 : (_0x141041 & 0x3) | 0x8
+          ).toString(16);
+          return _0x31fcdd;
+        },
+      );
+    return _0x4ec135;
+  }
+
+  function uploadAttachment(attachment, callback) {
+    var uploads = [];
+
+    // create an array of promises
+    if (!utils.isReadableStream(attachment)) {
+      throw {
+        error:
+          "Attachment should be a readable stream and not " +
+          utils.getType(attachment) +
+          ".",
+      };
+    }
+
+    var form = {
+      file: attachment,
+      av: api.getCurrentUserID(),
+      profile_id: api.getCurrentUserID(),
+      source: "19",
+      target_id: api.getCurrentUserID(),
+      __user: api.getCurrentUserID(),
+      __a: "1",
+    };
+
+    uploads.push(
+      defaultFuncs
+        .postFormData(
+          "https://www.facebook.com/ajax/ufi/upload",
+          ctx.jar,
+          form,
+          {},
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+        .then(function (resData) {
+          if (resData.error) {
+            throw resData;
+          }
+
+          // We have to return the data unformatted unless we want to change it
+          // back in sendMessage.
+          return resData.payload;
+        }),
+    );
+
+    // resolve all promises
+    bluebird
+      .all(uploads)
+      .then(function (resData) {
+        callback(null, resData);
+      })
+      .catch(function (err) {
+        log.error("uploadAttachment", err);
+        return callback(err);
+      });
+  }
+
+  async function sendCommentToFb(postId, text, fileID) {
+    const feedback_id = Buffer.from("feedback:" + postId).toString("base64");
+
+    const ss1 = getGUID();
+    const ss2 = getGUID();
+
+    const form = {
+      av: api.getCurrentUserID(),
+      fb_api_req_friendly_name: "CometUFICreateCommentMutation",
+      fb_api_caller_class: "RelayModern",
+      doc_id: "4744517358977326",
+      variables: JSON.stringify({
+        displayCommentsFeedbackContext: null,
+        displayCommentsContextEnableComment: null,
+        displayCommentsContextIsAdPreview: null,
+        displayCommentsContextIsAggregatedShare: null,
+        displayCommentsContextIsStorySet: null,
+        feedLocation: "TIMELINE",
+        feedbackSource: 0,
+        focusCommentID: null,
+        includeNestedComments: false,
+        input: {
+          attachments: fileID ? [{ media: { id: fileID } }] : null,
+          feedback_id: feedback_id,
+          formatting_style: null,
+          message: {
+            ranges: [],
+            text: text,
+          },
+          is_tracking_encrypted: true,
+          tracking: [],
+          feedback_source: "PROFILE",
+          idempotence_token: "client:" + ss1,
+          session_id: ss2,
+          actor_id: api.getCurrentUserID(),
+          client_mutation_id: Math.round(Math.random() * 19),
+        },
+        scale: 3,
+        useDefaultActor: false,
+        UFI2CommentsProvider_commentsKey: "ProfileCometTimelineRoute",
+      }),
+    };
+
+    const res = JSON.parse(
+      await api.httpPost("https://www.facebook.com/api/graphql/", form),
+    );
+    return res;
+  }
+
+  return async function sendComment(content, postId, callback) {
+    if (typeof content === "object") {
+      var text = content.body || "";
+      if (content.attachment) {
+        if (!utils.isReadableStream(content.attachment)) {
+          throw new Error("Attachment must be a ReadableStream");
+        }
+
+        uploadAttachment(content.attachment, async function (err, files) {
+          if (err) {
+            return callback(err);
+          }
+
+          await sendCommentToFb(postId, text, files[0].fbid)
+            .then((res) => {
+              return callback(null, res);
+            })
+            .catch((err) => {
+              return callback(err);
+            });
+        });
+      }
+    } else if (typeof content === "string") {
+      var text = content;
+      await sendCommentToFb(postId, text, null)
+        .then((res) => {
+          return callback(null, res);
+        })
+        .catch((err) => {
+          return callback(err);
+        });
+    } else throw new Error("Invalid content");
+  };
+};

package/src/setMessageReactionMqtt.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { generateOfflineThreadingID, getCurrentTimestamp } = require('../utils');
+
+function isCallable(func) {
+  try {
+    Reflect.apply(func, null, []);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function setMessageReactionMqtt(reaction, messageID, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error('Not connected to MQTT');
+    }
+
+    ctx.wsReqNumber += 1;
+    let taskNumber = ++ctx.wsTaskNumber;
+
+    const taskPayload = {
+      thread_key: threadID,
+      timestamp_ms: getCurrentTimestamp(),
+      message_id: messageID,
+      reaction: 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: taskNumber,
+    };
+
+    const content = {
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        data_trace_id: null,
+        epoch_id: parseInt(generateOfflineThreadingID()),
+        tasks: [task],
+        version_id: '7158486590867448',
+      }),
+      request_id: ctx.wsReqNumber,
+      type: 3,
+    };
+
+    if (isCallable(callback)) {
+      ctx["tasks"].set(taskNumber, {
+        type: 'set_message_reaction',
+        callback: callback
+      });
+    }
+    ctx.mqttClient.publish('/ls_req', JSON.stringify(content), { qos: 1, retain: false });
+  };
+};

package/src/setStoryReaction.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var utils = require('../utils');
+var log = require('npmlog');
+
+module.exports = function (http, api, ctx) {
+  return function setStoryReaction(storyID, react, callback) {
+    var cb;
+    var rtPromise = new Promise(function (resolve, reject) {
+      cb = error => error ? reject(error) : resolve();
+    });
+
+    if (typeof react == 'function') {
+      callback = react;
+      react = null;
+    }
+    if (typeof callback == 'function') cb = callback;
+    if (typeof react != 'string') react = '👍';
+
+    var form = {
+      fb_api_req_friendly_name: 'useStoriesSendReplyMutation',
+      variables: JSON.stringify({
+        input: {
+          attribution_id_v2: `StoriesCometSuspenseRoot.react,comet.stories.viewer,unexpected,${Date.now()},538296,,;CometHomeRoot.react,comet.home,via_cold_start,${Date.now()},850302,4748854339,`,
+          lightweight_reaction_actions: {
+            offsets: [0],
+            reaction: react
+          },
+          message: react,
+          story_id: storyID,
+          story_reply_type: "LIGHT_WEIGHT",
+          actor_id: ctx.userID,
+          client_mutation_id: Math.round(Math.random() * 19).toString()
+        }
+      }),
+      doc_id: 4826141330837571
+    }
+
+    http
+      .post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+      .then(utils.parseAndCheckLogin(ctx, http))
+      .then(function (res) {
+        if (res.errors) throw res;
+        return cb();
+      })
+      .catch(function (err) {
+        log.error('setPostReaction', err);
+        return cb(err);
+      });
+
+    return rtPromise;
+  }
+}