@lazyneoaz/metachat 1.0.9 → 1.0.10

package/index.js

@@ -1,2 +1,56 @@
 "use strict";
-module.exports = require('./src/engine/client');
+
+const { login, loginAsync, loginLegacy, DEFAULT_OPTIONS } = require('./src/engine/client');
+
+const { MessengerBot, MessengerContext, createMessengerBot } = require('./src/app/MessengerBot');
+const { createFcaClient, attachClientFacade, createMessagesDomain, createThreadsDomain, createUsersDomain, createAccountDomain, createRealtimeDomain, createHttpDomain, createSchedulerDomain } = require('./src/app/createFcaClient');
+const { defaultConfig, loadConfig, resolveConfig, writeConfigTemplate } = require('./src/app/config');
+const { broadcast } = require('./src/app/broadcast');
+const { attachThreadInfoRealtimeSync } = require('./src/app/threadSync');
+const { checkForPackageUpdate, runConfiguredUpdateCheck } = require('./src/app/updateCheck');
+const { createDefaultContext, createFcaState, createApiFacade, createRequestHelper } = require('./src/app/state');
+
+const { normalizeCookieHeaderString, setJarFromPairs } = require('./src/utils/formatters/value/formatCookie');
+const { createAuthCore } = require('./src/utils/auth-helpers');
+
+module.exports = login;
+
+module.exports.login = login;
+module.exports.loginAsync = loginAsync;
+module.exports.loginLegacy = loginLegacy;
+module.exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+
+module.exports.MessengerBot = MessengerBot;
+module.exports.MessengerContext = MessengerContext;
+module.exports.createMessengerBot = createMessengerBot;
+
+module.exports.createFcaClient = createFcaClient;
+module.exports.attachClientFacade = attachClientFacade;
+
+module.exports.createMessagesDomain = createMessagesDomain;
+module.exports.createThreadsDomain = createThreadsDomain;
+module.exports.createUsersDomain = createUsersDomain;
+module.exports.createAccountDomain = createAccountDomain;
+module.exports.createRealtimeDomain = createRealtimeDomain;
+module.exports.createHttpDomain = createHttpDomain;
+module.exports.createSchedulerDomain = createSchedulerDomain;
+
+module.exports.defaultConfig = defaultConfig;
+module.exports.loadConfig = loadConfig;
+module.exports.resolveConfig = resolveConfig;
+module.exports.writeConfigTemplate = writeConfigTemplate;
+
+module.exports.broadcast = broadcast;
+module.exports.attachThreadInfoRealtimeSync = attachThreadInfoRealtimeSync;
+
+module.exports.checkForPackageUpdate = checkForPackageUpdate;
+module.exports.runConfiguredUpdateCheck = runConfiguredUpdateCheck;
+
+module.exports.createDefaultContext = createDefaultContext;
+module.exports.createFcaState = createFcaState;
+module.exports.createApiFacade = createApiFacade;
+module.exports.createRequestHelper = createRequestHelper;
+
+module.exports.normalizeCookieHeaderString = normalizeCookieHeaderString;
+module.exports.setJarFromPairs = setJarFromPairs;
+module.exports.createAuthCore = createAuthCore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyneoaz/metachat",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "type": "commonjs",
   "types": "src/types/index.d.ts",
   "description": "Advanced Facebook Chat API client for building Messenger bots — real-time messaging, thread management, MQTT, and session stability.",

package/src/apis/gcmember.js

@@ -43,24 +43,30 @@ module.exports = function (defaultFuncs, api, ctx) {
 
 
         if (!validActions.includes(action)) {
-            return _callback(null, { type: "error_gc", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+            _callback(null, { type: "error_gc", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+            return returnPromise;
         }
         if (!userIDs || userIDs.length === 0) {
-            return _callback(null, { type: "error_gc", error: "userIDs is required." });
+            _callback(null, { type: "error_gc", error: "userIDs is required." });
+            return returnPromise;
         }
         if (!threadID) {
-            return _callback(null, { type: "error_gc", error: "threadID is required." });
+            _callback(null, { type: "error_gc", error: "threadID is required." });
+            return returnPromise;
         }
         if (!ctx.mqttClient) {
-            return _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
+            _callback(null, { type: "error_gc", error: "Not connected to MQTT" });
+            return returnPromise;
         }
 
         const threadInfo = await api.getThreadInfo(threadID);
         if (!threadInfo) {
-            return _callback(null, { type: "error_gc", error: "Could not retrieve thread information." });
+            _callback(null, { type: "error_gc", error: "Could not retrieve thread information." });
+            return returnPromise;
         }
         if (threadInfo.isGroup === false) {
-            return _callback(null, { type: "error_gc", error: "This feature is only for group chats, not private messages." });
+            _callback(null, { type: "error_gc", error: "This feature is only for group chats, not private messages." });
+            return returnPromise;
         }
         
         const currentMembers = threadInfo.participantIDs;
@@ -74,7 +80,8 @@ module.exports = function (defaultFuncs, api, ctx) {
         if (action === 'add') {
             const usersToAdd = usersToModify.filter(id => !currentMembers.includes(id));
             if (usersToAdd.length === 0) {
-                return _callback(null, { type: "error_gc", error: "All specified users are already in the group." });
+                _callback(null, { type: "error_gc", error: "All specified users are already in the group." });
+                return returnPromise;
             }
             finalUsers = usersToAdd;
             queryPayload = { thread_key: parseInt(threadID), contact_ids: finalUsers.map(id => parseInt(id)), sync_group: 1 };
@@ -83,7 +90,8 @@ module.exports = function (defaultFuncs, api, ctx) {
         } else { // action is 'remove'
             const userToRemove = usersToModify[0];
             if (!currentMembers.includes(userToRemove)) {
-                return _callback(null, { type: "error_gc", error: `User with ID ${userToRemove} is not in this group chat.` });
+                _callback(null, { type: "error_gc", error: `User with ID ${userToRemove} is not in this group chat.` });
+                return returnPromise;
             }
             finalUsers = [userToRemove];
             queryPayload = { thread_id: threadID, contact_id: userToRemove, sync_group: 1 };
@@ -113,8 +121,7 @@ module.exports = function (defaultFuncs, api, ctx) {
           return _callback(null, gcmemberInfo);
         });
     } catch (err) {
-      
-        return _callback(null, { type: "error_gc", error: err.message || "An unknown error occurred." });
+        _callback(null, { type: "error_gc", error: err.message || "An unknown error occurred." });
     }
 
     return returnPromise;

package/src/apis/gcrule.js

@@ -41,18 +41,21 @@ module.exports = function (defaultFuncs, api, ctx) {
         action = action ? action.toLowerCase() : "";
 
         if (!validActions.includes(action)) {
-            return _callback(null, { type: "error_gc_rule", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+            _callback(null, { type: "error_gc_rule", error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+            return returnPromise;
         }
-        if (!userID) return _callback(null, { type: "error_gc_rule", error: "userID is required." });
-        if (!threadID) return _callback(null, { type: "error_gc_rule", error: "threadID is required." });
-        if (!ctx.mqttClient) return _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" });
+        if (!userID) { _callback(null, { type: "error_gc_rule", error: "userID is required." }); return returnPromise; }
+        if (!threadID) { _callback(null, { type: "error_gc_rule", error: "threadID is required." }); return returnPromise; }
+        if (!ctx.mqttClient) { _callback(null, { type: "error_gc_rule", error: "Not connected to MQTT" }); return returnPromise; }
         
         const threadInfo = await api.getThreadInfo(threadID);
         if (!threadInfo) {
-            return _callback(null, { type: "error_gc_rule", error: "Could not retrieve thread information." });
+            _callback(null, { type: "error_gc_rule", error: "Could not retrieve thread information." });
+            return returnPromise;
         }
         if (threadInfo.isGroup === false) {
-            return _callback(null, { type: "error_gc_rule", error: "This feature is only for group chats." });
+            _callback(null, { type: "error_gc_rule", error: "This feature is only for group chats." });
+            return returnPromise;
         }
 
         const adminIDs = threadInfo.adminIDs || [];
@@ -60,11 +63,13 @@ module.exports = function (defaultFuncs, api, ctx) {
 
         if (action === 'admin') {
             if (isCurrentlyAdmin) {
-                return _callback(null, { type: "error_gc_rule", error: `User is already an admin.` });
+                _callback(null, { type: "error_gc_rule", error: `User is already an admin.` });
+                return returnPromise;
             }
         } else { // action is 'unadmin'
             if (!isCurrentlyAdmin) {
-                return _callback(null, { type: "error_gc_rule", error: `User is not an admin.` });
+                _callback(null, { type: "error_gc_rule", error: `User is not an admin.` });
+                return returnPromise;
             }
         }
 
@@ -111,7 +116,7 @@ module.exports = function (defaultFuncs, api, ctx) {
         });
 
     } catch (err) {
-        return _callback(null, { type: "error_gc_rule", error: err.message || "An unknown error occurred." });
+        _callback(null, { type: "error_gc_rule", error: err.message || "An unknown error occurred." });
     }
     
     return returnPromise;

package/src/apis/getAccess.js

@@ -52,7 +52,9 @@ module.exports = function (defaultFuncs, api, ctx) {
                   Origin: url
                 })
                 .then(function (res) {
-                  var { payload } = JSON.parse(res.body.split(';').pop() || '{}');
+                  var parsed;
+                  try { parsed = JSON.parse(res.body.split(';').pop() || '{}'); } catch(e) { parsed = {}; }
+                  var { payload } = parsed;
                   if (payload && !payload.codeConfirmed)
                     throw {
                       error: 'submitCode',

package/src/apis/getBotInitialData.js

@@ -23,7 +23,7 @@ module.exports = (defaultFuncs, api, ctx) => {
       customUserAgent: utils.windowsUserAgent
   }, (err, data) => {
   
-      if (err) throw err;
+      if (err) return callback(err);
       const profileMatch = data.match(/"CurrentUserInitialData",\[\],\{(.*?)\},(.*?)\]/);
       if (profileMatch && profileMatch[1]){
         const accountJson = JSON.parse(`{${profileMatch[1]}}`);

package/src/apis/getThreadInfo.js

@@ -263,7 +263,7 @@ module.exports = function (defaultFuncs, api, ctx) {
             
             const threadInfo = formatThreadGraphQLResponse(responseData.data);
             if (threadInfo) {
-                threadInfos[threadInfo.threadID || threadID[threadID.length - 1 - i]] = threadInfo;
+                threadInfos[threadInfo.threadID || threadIDs[i]] = threadInfo;
             }
         }
 

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/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;

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