@lazyneoaz/metachat 1.0.8 → 1.0.10

package/src/apis/markAsSeen.js

@@ -10,8 +10,8 @@ const utils = require('../utils');
 module.exports = function (defaultFuncs, api, ctx) {
   /**
    * Marks all messages as "seen" up to a specific timestamp.
-   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in milliseconds) up to which messages should be marked as seen. If a function is provided, it's treated as the callback and the timestamp defaults to the current time.
-   * @param {Function} [callback] - The callback function.
+   * @param {number} [seen_timestamp=Date.now()] - The timestamp (in ms) up to which messages should be marked as seen.
+   * @param {Function} [callback] - Optional callback function.
    * @returns {Promise<void>} A Promise that resolves on success or rejects with an error.
    */
   return async function markAsSeen(seen_timestamp, callback) {
@@ -30,11 +30,9 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     if (!callback) {
-      callback = function (err, friendList) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(friendList);
+      callback = function (err) {
+        if (err) return rejectFunc(err);
+        resolveFunc();
       };
     }
 
@@ -56,13 +54,13 @@ module.exports = function (defaultFuncs, api, ctx) {
         throw resData;
       }
 
-      return callback();
+      callback(null);
     } catch (err) {
       utils.error("markAsSeen", err);
       if (utils.getType(err) == "Object" && err.error === "Not logged in.") {
         ctx.loggedIn = false;
       }
-      return callback(err);
+      callback(err);
     }
 
     return returnPromise;

package/src/apis/mqttDeltaValue.js

@@ -183,7 +183,7 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
       } catch (err) {
         return;
       }
-      if (!ctx.globalOptions.selfListen && fmtEvent2 && fmtEvent2.author && fmtEvent2.author.toString() === ctx.userID) return;
+      if (!ctx.globalOptions.selfListenEvent && fmtEvent2 && fmtEvent2.author && fmtEvent2.author.toString() === ctx.userID) return;
       if (!ctx.loggedIn) return;
       if (fmtEvent2) globalCallback(null, fmtEvent2);
       break;
@@ -193,7 +193,7 @@ function parseDelta(defaultFuncs, api, ctx, globalCallback, v) {
       var tid = v.delta.threadKey.threadFbId;
       if (mid && tid) {
         var form = {
-          av: ctx.globalOptions.pageID,
+          av: ctx.globalOptions.pageID || ctx.userID,
           queries: JSON.stringify({
             o0: {
               doc_id: "2848441488556444",

package/src/apis/nickname.js

@@ -70,14 +70,17 @@ module.exports = function (defaultFuncs, api, ctx) {
     participantID = participantID || ctx.userID;
 
     if (!threadID) {
-      return _callback(new Error("threadID is required to set a nickname."));
+      _callback(new Error("threadID is required to set a nickname."));
+      return returnPromise;
     }
     if (typeof nickname !== 'string') {
-      return _callback(new Error("nickname must be a string."));
+      _callback(new Error("nickname must be a string."));
+      return returnPromise;
     }
 
     if (!ctx.mqttClient) {
-      return _callback(new Error("Not connected to MQTT"));
+      _callback(new Error("Not connected to MQTT"));
+      return returnPromise;
     }
 
     ctx.wsReqNumber += 1;
@@ -99,7 +102,7 @@ module.exports = function (defaultFuncs, api, ctx) {
     };
 
     const context = {
-      app_id: ctx.appID,
+      app_id: ctx.appID || "2220391788200892",
       payload: {
         epoch_id: parseInt(utils.generateOfflineThreadingID()),
         tasks: [query],

package/src/apis/pinMessage.js

@@ -34,11 +34,13 @@ function extractAndSearchLightspeedRequest(allJsonData, options = {}) {
   }
 
 
-  try {
-    fs.writeFileSync(outputFile, JSON.stringify(lightReq, null, 2), "utf8");
-    utils.log(`pin.js: Saved lightspeed_web_request to ${outputFile}`);
-  } catch (err) {
-    utils.error("pin.js: Failed to write lightspeed_web_request.json", err);
+  if (outputFile) {
+    try {
+      fs.writeFileSync(outputFile, JSON.stringify(lightReq, null, 2), "utf8");
+      utils.log(`pin.js: Saved lightspeed_web_request to ${outputFile}`);
+    } catch (err) {
+      utils.error("pin.js: Failed to write lightspeed_web_request.json", err);
+    }
   }
 
 

package/src/apis/removeUserFromGroup.js

@@ -67,6 +67,7 @@ module.exports = (defaultFuncs, api, ctx) => {
           }
           if (jsonMsg.request_id !== reqID) return;
           responseHandled = true;
+          clearTimeout(timeout);
           ctx.mqttClient.removeListener("message", handleRes);
           callback(null, { success: true });
           resolveFunc({ success: true });

package/src/apis/sendEffect.js

@@ -213,9 +213,9 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
 
     try {
-      if (!effectName) return callback(new Error('effectName is required.'));
-      if (message === undefined || message === null) return callback(new Error('message is required.'));
-      if (!threadID) return callback(new Error('threadID is required.'));
+      if (!effectName) { callback(new Error('effectName is required.')); return returnPromise; }
+      if (message === undefined || message === null) { callback(new Error('message is required.')); return returnPromise; }
+      if (!threadID) { callback(new Error('threadID is required.')); return returnPromise; }
 
       const effectTag = resolveEffect(effectName);
       utils.log('sendEffect', `Effect "${effectTag}" → thread ${threadID}`);
@@ -280,7 +280,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         timestamp: v.timestamp    || p.timestamp,
       }), { threadID, messageID: messageAndOTID, timestamp: httpTs });
 
-      return callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
+      callback(null, { ...msgInfo, effect: effectTag, method: 'http' });
 
     } catch (err) {
       utils.error('sendEffect', err.message || err);

package/src/apis/setMessageReaction.js

@@ -5,20 +5,21 @@ const utils = require('../utils');
 
 module.exports = function (defaultFuncs, api, ctx) {
   return async (reaction, messageID) => {
-    if (!reaction) throw new Error("Please enter a valid emoji.");
-    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {}, {
+    if (reaction === undefined || reaction === null) throw new Error("Please enter a valid emoji.");
+    const action = reaction === "" ? "REMOVE_REACTION" : "ADD_REACTION";
+    const defData = await defaultFuncs.postFormData("https://www.facebook.com/webgraphql/mutation/", ctx.jar, {
       doc_id: "1491398900900362",
       variables: JSON.stringify({
-      data: {
-        client_mutation_id: ctx.clientMutationId++,
-        actor_id: ctx.userID,
-        action: reaction == "" ? "REMOVE_REACTION" : "ADD_REACTION",
-        message_id: messageID,
-        reaction
-      }
-    }),
+        data: {
+          client_mutation_id: ctx.clientMutationId++,
+          actor_id: ctx.userID,
+          action,
+          message_id: messageID,
+          reaction
+        }
+      }),
       dpr: 1
-    });
+    }, {});
     const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
     if (!resData) {
       throw new Error("setMessageReactionLegacy returned empty object.");

package/src/apis/setThreadTheme.js

@@ -35,17 +35,17 @@ module.exports = function (defaultFuncs, api, ctx) {
 
     // ── Hardcoded colour aliases (fast path — no API round trip needed) ──────
     const PALETTE = {
-      blue:    "196241301102133",
-      purple:  "370940413392601",
-      green:   "169463077092846",
-      pink:    "230032715012014",
-      orange:  "175615189761153",
-      red:     "2136751179887052",
-      yellow:  "2058653964378557",
-      teal:    "417639218648241",
-      black:   "539927563794799",
-      white:   "2873642392710980",
-      default: "196241301102133",
+      blue:    "196241301102133",  // DefaultBlue / MessengerBlue
+      purple:  "234137870477637",  // BrightPurple / MediumSlateBlue
+      green:   "2136751179887052", // FreeSpeechGreen / Green
+      pink:    "169463077092846",  // HotPink / BrilliantRose
+      orange:  "175615189761153",  // Pumpkin / Orange
+      red:     "2129984390566328", // RadicalRed / Red
+      yellow:  "174636906462322",  // GoldenPoppy / Yellow
+      teal:    "1928399724138152", // TealBlue / Viking
+      aqua:    "417639218648241",  // Aqua
+      black:   "271607034185782",  // Shadow (darkest solid theme)
+      default: "196241301102133",  // DefaultBlue
     };
 
     (async function worker() {

package/src/apis/unsendMessage.js

@@ -10,7 +10,7 @@ module.exports = function (defaultFuncs, api, ctx) {
     })
     const resData = await utils.parseAndCheckLogin(ctx, defaultFuncs)(defData);
     if (resData.error) {
-      throw new Error(resData);
+      throw new Error(JSON.stringify(resData));
     }
     return resData;
   };

package/src/app/MessengerBot.js

@@ -0,0 +1,239 @@
+"use strict";
+
+const EventEmitter = require("events");
+
+class MessengerContext {
+    constructor(bot, event) {
+        this.bot = bot;
+        this.event = event;
+    }
+
+    get threadID() { return this.event.threadID; }
+    get senderID() { return this.event.senderID; }
+    get messageID() { return this.event.messageID; }
+    get text() { return (this.event.body || "").trim(); }
+    get body() { return this.event.body; }
+    get message() { return this.event; }
+
+    reply(payload, callback) {
+        const tid = this.event.threadID;
+        if (tid == null) throw new Error("MessengerContext.reply: threadID is missing");
+        return this.bot.api.sendMessage(payload, tid, callback);
+    }
+
+    async replyAsync(payload) {
+        const r = this.reply(payload);
+        if (r && typeof r.then === "function") return r;
+        return Promise.resolve(r);
+    }
+}
+
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function emitIf(bot, channel, payload) {
+    if (bot.listenerCount(channel) > 0) bot.emit(channel, payload);
+}
+
+function emitGatewayEvents(bot, event) {
+    emitIf(bot, "update", event);
+    emitIf(bot, "raw", event);
+    const t = event.type;
+    if (!t) return;
+    if (t === "message" || t === "message_reply") {
+        emitIf(bot, "message", event);
+        emitIf(bot, "messageCreate", event);
+    }
+    if (t === "message_reply") {
+        emitIf(bot, "message_reply", event);
+    } else if (t !== "message") {
+        emitIf(bot, t, event);
+    }
+    switch (t) {
+        case "message_reaction":
+            emitIf(bot, "messageReactionAdd", event);
+            break;
+        case "message_unsend":
+            emitIf(bot, "messageDelete", event);
+            break;
+        case "typ":
+            emitIf(bot, event.isTyping ? "typingStart" : "typingStop", event);
+            break;
+        case "event":
+            emitIf(bot, "threadUpdate", event);
+            break;
+        case "ready":
+            emitIf(bot, "ready", event);
+            emitIf(bot, "shardReady", event);
+            break;
+    }
+}
+
+class MessengerBot extends EventEmitter {
+    constructor(api, options = {}) {
+        super();
+        this.api = api;
+        this.options = Object.assign({
+            commandPrefix: "/",
+            enableComposer: true,
+            autoListen: true,
+            stopOnSignals: false,
+            maxEventListeners: 64,
+        }, options);
+
+        if (this.options.maxEventListeners > 0) {
+            this.setMaxListeners(this.options.maxEventListeners);
+        }
+
+        this._middleware = [];
+        this._commands = new Map();
+        this._hears = [];
+        this._catchHandler = null;
+        this._mqttHandle = null;
+        this._signalHandlers = null;
+        this._client = null;
+    }
+
+    get client() {
+        if (!this._client) {
+            const { createFcaClient } = require("./createFcaClient");
+            this._client = createFcaClient(this.api);
+        }
+        return this._client;
+    }
+
+    use(fn) {
+        this._middleware.push(fn);
+        return this;
+    }
+
+    command(name, fn) {
+        this._commands.set(String(name).toLowerCase(), fn);
+        return this;
+    }
+
+    hears(trigger, fn) {
+        this._hears.push({ trigger, fn });
+        return this;
+    }
+
+    catch(fn) {
+        this._catchHandler = fn;
+        return this;
+    }
+
+    async _runComposer(event) {
+        if (!this.options.enableComposer) return;
+        if (event.type !== "message" && event.type !== "message_reply") return;
+
+        const ctx = new MessengerContext(this, event);
+        const prefix = this.options.commandPrefix || "/";
+
+        const body = event.body || "";
+        const trimmed = body.trim();
+
+        const pipeline = [...this._middleware];
+
+        if (trimmed.startsWith(prefix)) {
+            const withoutPrefix = trimmed.slice(prefix.length);
+            const cmdName = withoutPrefix.split(/\s+/)[0].toLowerCase();
+            if (this._commands.has(cmdName)) {
+                pipeline.push(this._commands.get(cmdName));
+            }
+        } else {
+            for (const { trigger, fn } of this._hears) {
+                if (typeof trigger === "string") {
+                    if (trimmed.toLowerCase().includes(trigger.toLowerCase())) {
+                        pipeline.push(fn);
+                    }
+                } else if (trigger instanceof RegExp) {
+                    if (trigger.test(trimmed)) {
+                        pipeline.push(fn);
+                    }
+                }
+            }
+        }
+
+        let idx = 0;
+        const next = async () => {
+            if (idx >= pipeline.length) return;
+            const fn = pipeline[idx++];
+            try {
+                await fn(ctx, next);
+            } catch (err) {
+                if (this._catchHandler) {
+                    this._catchHandler(err, ctx);
+                } else {
+                    this.emit("error", err);
+                }
+            }
+        };
+
+        await next();
+    }
+
+    startListening() {
+        if (this._mqttHandle) return;
+        this._mqttHandle = this.api.listenMqtt((err, event) => {
+            if (err) {
+                this.emit("error", err);
+                return;
+            }
+            emitGatewayEvents(this, event);
+            this._runComposer(event).catch((e) => this.emit("error", e));
+        });
+    }
+
+    stopListening() {
+        if (this._mqttHandle && typeof this._mqttHandle.stopListening === "function") {
+            this._mqttHandle.stopListening();
+        } else if (this.api && typeof this.api.stopListening === "function") {
+            this.api.stopListening();
+        }
+        this._mqttHandle = null;
+    }
+
+    async stop() {
+        if (this._signalHandlers) {
+            for (const [sig, handler] of Object.entries(this._signalHandlers)) {
+                process.removeListener(sig, handler);
+            }
+            this._signalHandlers = null;
+        }
+        this.stopListening();
+        this.removeAllListeners();
+    }
+
+    async launch(launchOptions = {}) {
+        const opts = Object.assign({}, this.options, launchOptions);
+        if (opts.stopOnSignals) {
+            const handler = async () => {
+                await this.stop();
+                process.exit(0);
+            };
+            this._signalHandlers = { SIGINT: handler, SIGTERM: handler };
+            process.once("SIGINT", handler);
+            process.once("SIGTERM", handler);
+        }
+        if (opts.autoListen !== false) {
+            this.startListening();
+        }
+    }
+}
+
+async function createMessengerBot(credentials, options = {}) {
+    const { login } = require("../engine/client");
+    const api = await login(credentials, options);
+    const bot = new MessengerBot(api, options);
+    if (options.autoListen !== false) {
+        bot.startListening();
+    }
+    return bot;
+}
+
+module.exports = {
+    MessengerBot,
+    MessengerContext,
+    createMessengerBot,
+};

package/src/app/broadcast.js

@@ -0,0 +1,48 @@
+"use strict";
+
+/**
+ * Broadcast a message to multiple threads.
+ * @param {object} api - The FCA api object.
+ * @param {string|object} message - Message body or message object.
+ * @param {string[]} threadIDs - Array of thread IDs to send to.
+ * @param {object} [options] - Options.
+ * @param {number} [options.delayMs=200] - Delay between sends in ms.
+ * @returns {Promise<{sent: string[], failed: string[]}>}
+ */
+async function broadcast(api, message, threadIDs, options = {}) {
+    if (!api || typeof api.sendMessage !== "function") {
+        throw new Error("broadcast: api must be a valid FCA api object");
+    }
+    if (!Array.isArray(threadIDs) || threadIDs.length === 0) {
+        throw new Error("broadcast: threadIDs must be a non-empty array");
+    }
+
+    const delayMs = typeof options.delayMs === "number" ? options.delayMs : 200;
+    const sent = [];
+    const failed = [];
+
+    for (const tid of threadIDs) {
+        try {
+            await new Promise((resolve, reject) => {
+                const result = api.sendMessage(message, tid, (err) => {
+                    if (err) reject(err);
+                    else resolve();
+                });
+                if (result && typeof result.then === "function") {
+                    result.then(resolve).catch(reject);
+                }
+            });
+            sent.push(tid);
+        } catch (err) {
+            failed.push(tid);
+        }
+
+        if (delayMs > 0 && threadIDs.indexOf(tid) < threadIDs.length - 1) {
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+    }
+
+    return { sent, failed };
+}
+
+module.exports = { broadcast };

package/src/app/config.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const CONFIG_FILE = "fca-config.json";
+
+const DEFAULT_CONFIG = {
+    checkUpdate: {
+        enabled: false,
+        install: false,
+        notifyIfCurrent: false,
+        packageName: "@lazyneoaz/metachat",
+        registryUrl: "https://registry.npmjs.org",
+        timeoutMs: 10000,
+    },
+    mqtt: {
+        enabled: true,
+        reconnectInterval: 3600,
+    },
+    credentials: {
+        email: "",
+        password: "",
+        twofactor: "",
+    },
+    antiGetInfo: {
+        AntiGetThreadInfo: false,
+        AntiGetUserInfo: false,
+    },
+    remoteControl: {
+        enabled: false,
+        url: "",
+        token: "",
+        autoReconnect: true,
+    },
+};
+
+function defaultConfig() {
+    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+}
+
+function loadConfig() {
+    const configPath = path.resolve(process.cwd(), CONFIG_FILE);
+    let fileConfig = {};
+    let created = false;
+
+    try {
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf8");
+            fileConfig = JSON.parse(raw);
+        } else {
+            try {
+                fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+                created = true;
+            } catch (_) {}
+        }
+    } catch (_) {}
+
+    const config = resolveConfig(fileConfig);
+    return { config, created };
+}
+
+function resolveConfig(partial = {}) {
+    const base = defaultConfig();
+    return deepMerge(base, partial);
+}
+
+function deepMerge(target, source) {
+    const out = Object.assign({}, target);
+    for (const key of Object.keys(source || {})) {
+        if (
+            source[key] !== null &&
+            typeof source[key] === "object" &&
+            !Array.isArray(source[key]) &&
+            typeof target[key] === "object" &&
+            target[key] !== null
+        ) {
+            out[key] = deepMerge(target[key], source[key]);
+        } else {
+            out[key] = source[key];
+        }
+    }
+    return out;
+}
+
+function writeConfigTemplate(destPath) {
+    const target = destPath || path.resolve(process.cwd(), "fca-config.example.json");
+    fs.writeFileSync(target, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+    return target;
+}
+
+module.exports = {
+    defaultConfig,
+    loadConfig,
+    resolveConfig,
+    writeConfigTemplate,
+};