fca-phantom 1.0.0

package/phantom/dispatch/listenSpeed.js

@@ -0,0 +1,179 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools'); 
+const mqtt = require('mqtt');
+const websocket = require('websocket-stream');
+const HttpsProxyAgent = require('https-proxy-agent');
+const EventEmitter = require('events');
+
+function connectLightspeed(ctx, globalCallback) {
+    let client;
+    let isStopped = false;
+    const guard = (label, fn) => (...args) => {
+        try {
+            return fn(...args);
+        } catch (err) {
+            utils.error(`[Lightspeed] ${label} handler error:`, err && err.message ? err.message : err);
+        }
+    };
+
+    function startConnection(retryCount = 0) {
+        if (isStopped) return;
+
+        const chatOn = ctx.globalOptions.online;
+        const foreground = false;
+        const sessionID = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
+        const cookies = ctx.jar.getCookiesSync('https://www.facebook.com').join('; ');
+        const cid = ctx.clientID;
+
+        const username = {
+            u: ctx.userID,
+            s: sessionID,
+            chat_on: chatOn,
+            fg: foreground,
+            d: cid,
+            ct: 'websocket',
+            aid: '2220391788200892',
+            mqtt_sid: '',
+            cp: 3,
+            ecp: 10,
+            st: [],
+            pm: [],
+            dc: '',
+            no_auto_fg: true,
+            gas: null,
+            pack: [],
+            a: ctx.globalOptions.userAgent,
+        };
+        
+        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-loggingid': utils.getGUID(),
+            'x-dgw-regionhint': ctx.region || 'PRN',
+            'x-dgw-deviceid': ctx.clientID
+        });
+        const host = `wss://gateway.facebook.com/ws/lightspeed?${queryParams.toString()}`;
+        
+        // Generate a unique clientId per session, just like a real browser would
+        const lsClientId = 'mqttwsclient_' + Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+        const options = {
+            clientId: lsClientId,
+            protocolId: 'MQIsdp',
+            protocolVersion: 3,
+            username: JSON.stringify(username),
+            clean: true,
+            wsOptions: {
+                headers: {
+                    'Cookie': cookies,
+                    'Origin': 'https://www.facebook.com',
+                    'User-Agent': username.a,
+                    'Referer': 'https://www.facebook.com/',
+                    'Host': new URL(host).hostname
+                }
+            },
+            keepalive: 60, // 60s is standard; 10s was too aggressive (sent PING every 10 seconds)
+            reconnectPeriod: 0 
+        };
+        
+        if (ctx.globalOptions.proxy) {
+            options.wsOptions.agent = new HttpsProxyAgent(ctx.globalOptions.proxy);
+        }
+
+        try {
+            client = new mqtt.Client(_ => websocket(host, options.wsOptions), options);
+            utils.log("[Lightspeed] Attempting MQTT connection...");
+        } catch (err) {
+            utils.error("[Lightspeed] MQTT Client creation failed:", err.message);
+            reconnect(retryCount + 1);
+            return;
+        }
+
+        client.on('connect', guard("connect", () => {
+            utils.log("[Lightspeed] MQTT client connected. Attempting to subscribe to topics...");
+            retryCount = 0;
+
+
+            const topicsToSubscribe = [
+                "/t_ms", // Para sa mga messages at deltas
+                "/orca_presence", // Para sa online status
+                "/messaging_events" // Para sa ibang events
+            ];
+
+            topicsToSubscribe.forEach(topic => {
+                client.subscribe(topic, (err) => {
+                    if (err) {
+                        utils.error(`[Lightspeed] Failed to subscribe to topic ${topic}:`, err.message);
+                    } else {
+                        utils.log(`[Lightspeed] Subscribed to topic: ${topic}`);
+                    }
+                });
+            });
+
+        }));
+
+        client.on('message', guard("message", (topic, payload) => {
+            utils.log(`[Lightspeed] Payload Received on topic ${topic}:`);
+            globalCallback(null, { type: 'lightspeed_message', topic: topic.toString(), payload: payload });
+        }));
+
+        client.on('close', guard("close", () => {
+            utils.warn(`[Lightspeed] Connection closed.`);
+            if (!isStopped) {
+                reconnect(retryCount + 1);
+            }
+        }));
+
+        client.on('error', guard("error", (err) => {
+            utils.error("[Lightspeed] MQTT Connection Error:", err.message);
+        }));
+    }
+
+    function reconnect(retryCount) {
+        const delay = Math.min(3000 * Math.pow(2, retryCount), 60000);
+        utils.log(`[Lightspeed] Reconnecting in ${delay / 1000} seconds...`);
+        setTimeout(() => startConnection(retryCount), delay);
+    }
+
+    startConnection();
+
+    return {
+        stop: () => {
+            isStopped = true;
+            if (client) client.end(true);
+            utils.log("[Lightspeed] Listener has been manually stopped.");
+        }
+    };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return (callback) => {
+        class MessageEmitter extends EventEmitter {
+            constructor() {
+                super();
+                this.listener = null;
+            }
+            stop() {
+                if (this.listener) {
+                    this.listener.stop();
+                }
+                this.emit('stop');
+            }
+        }
+        const msgEmitter = new MessageEmitter();
+        const globalCallback = (error, message) => {
+            if (error) return msgEmitter.emit("error", error);
+            msgEmitter.emit("message", message);
+        };
+        if (typeof callback === 'function') {
+            msgEmitter.listener = connectLightspeed(ctx, callback);
+        } else {
+            msgEmitter.listener = connectLightspeed(ctx, globalCallback);
+        }
+        return msgEmitter;
+    };
+};

package/phantom/dispatch/logout.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+
+/**
+ * @param {Object} defaultFuncs
+ * @param {Object} api
+ * @param {Object} ctx
+ * @returns {function(): Promise<void>}
+ */
+module.exports = function (defaultFuncs, api, ctx) {
+  /**
+   * Logs the current user out of Facebook.
+   * @returns {Promise<void>} A promise that resolves when logout is successful or rejects on error.
+   */
+  return async function logout() {
+    const form = {
+      pmid: "0",
+    };
+
+    try {
+      const resData = await defaultFuncs
+        .post(
+          "https://www.facebook.com/bluebar/modern_settings_menu/?help_type=364455653583099&show_contextual_help=1",
+          ctx.jar,
+          form,
+        )
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      const elem = resData.jsmods.instances[0][2][0].find(v => v.value === "logout");
+      if (!elem) {
+        throw { error: "Could not find logout form element." };
+      }
+      
+      const html = resData.jsmods.markup.find(v => v[0] === elem.markup.__m)[1].__html;
+      
+      const logoutForm = {
+        fb_dtsg: utils.getFrom(html, '"fb_dtsg" value="', '"'),
+        ref: utils.getFrom(html, '"ref" value="', '"'),
+        h: utils.getFrom(html, '"h" value="', '"'),
+      };
+
+      const logoutRes = await defaultFuncs
+        .post("https://www.facebook.com/logout.php", ctx.jar, logoutForm)
+        .then(utils.saveCookies(ctx.jar));
+
+      if (!logoutRes.headers || !logoutRes.headers.location) {
+        throw { error: "An error occurred when logging out." };
+      }
+
+      await defaultFuncs
+        .get(logoutRes.headers.location, ctx.jar)
+        .then(utils.saveCookies(ctx.jar));
+      
+      ctx.loggedIn = false;
+
+      // Clear sensitive session tokens so stale credentials cannot be reused
+      // if this ctx object is accidentally referenced again after logout.
+      ctx.fb_dtsg = undefined;
+      ctx.fb_dtsg_ag = undefined;
+      ctx.lsd = undefined;
+      ctx.access_token = undefined;
+
+      // Stop background timers that are owned by this session, if present.
+      if (typeof ctx._stopCycle === 'function') {
+        try { ctx._stopCycle(); } catch (_) {}
+      }
+      if (typeof ctx._stopRevive === 'function') {
+        try { ctx._stopRevive(); } catch (_) {}
+      }
+      if (typeof ctx._stopCookieBackup === 'function') {
+        try { ctx._stopCookieBackup(); } catch (_) {}
+      }
+      
+      // Stop auto backup
+      try {
+        const { stopAutoBackup } = require('../datastore/appStateBackup');
+        stopAutoBackup();
+      } catch (_) {}
+
+      // Invalidate the response cache so nothing stale is served after logout.
+      if (ctx.cache && typeof ctx.cache.clear === 'function') {
+        ctx.cache.clear();
+      }
+
+      utils.log("logout", "Logged out successfully.");
+
+    } catch (err) {
+      utils.error("logout", err);
+      throw err;
+    }
+  };
+};

package/phantom/dispatch/markAsDelivered.js

@@ -0,0 +1,92 @@
+"use strict";
+
+/**
+ * markAsDelivered — Advanced Delivery Receipt Handler for Phantom SDK
+ *
+ * Features:
+ *  - Batch delivery receipt: mark multiple messages in one call
+ *  - Exponential-backoff retry on transient failures
+ *  - Full callback + Promise dual API
+ *  - Validates threadID and messageID presence
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function sendReceipt(defaultFuncs, ctx, threadID, messageID, retries, baseMs) {
+  const form = {};
+  form["message_ids[0]"]            = messageID;
+  form[`thread_ids[${threadID}][0]`] = messageID;
+
+  let lastErr;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const resData = await defaultFuncs
+        .post("https://www.facebook.com/ajax/mercury/delivery_receipts.php", ctx.jar, form)
+        .then(utils.saveCookies ? utils.saveCookies(ctx.jar) : r => r)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (resData?.error) throw new Error(JSON.stringify(resData.error));
+      return { success: true, threadID, messageID };
+    } catch (err) {
+      lastErr = err;
+      if (attempt >= retries || /auth|checkpoint|fatal/i.test(err.message)) throw err;
+      const wait = baseMs * Math.pow(2, attempt - 1) + Math.random() * 200;
+      utils.warn("markAsDelivered", `Retry ${attempt}/${retries} for msg ${messageID} in ${Math.round(wait)}ms`);
+      await new Promise(r => setTimeout(r, wait));
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * Mark one or more messages as delivered.
+   *
+   * @param {string}          threadID    Thread that contains the message(s)
+   * @param {string|string[]} messageID   Single message ID or array for batch
+   * @param {object}          [options]   { retries, concurrency }
+   * @param {Function}        [callback]  Node-style (err, result) callback
+   * @returns {Promise<object|object[]>}
+   */
+  return async function markAsDelivered(threadID, messageID, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    options = options || {};
+
+    const retries     = options.retries     || 3;
+    const concurrency = options.concurrency || 4;
+    const baseMs      = 400;
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+
+    function done(err, data) {
+      if (callback) return err ? callback(err) : callback(null, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    }
+
+    if (!threadID) { done(new Error("markAsDelivered: threadID is required")); return promise; }
+    if (!messageID) { done(new Error("markAsDelivered: messageID is required")); return promise; }
+
+    const ids = Array.isArray(messageID) ? messageID.filter(Boolean) : [messageID].filter(Boolean);
+
+    try {
+      const results = [];
+      for (let i = 0; i < ids.length; i += concurrency) {
+        const batch   = ids.slice(i, i + concurrency);
+        const settled = await Promise.allSettled(batch.map(mid => sendReceipt(defaultFuncs, ctx, threadID, mid, retries, baseMs)));
+        for (const r of settled) {
+          if (r.status === 'fulfilled') results.push(r.value);
+          else results.push({ success: false, threadID, messageID: batch[results.length % batch.length], error: r.reason?.message });
+        }
+      }
+      const out = ids.length === 1 ? results[0] : { success: results.every(r => r.success), results };
+      done(null, out);
+    } catch (err) {
+      utils.error("markAsDelivered", err.message || err);
+      done(err);
+    }
+
+    return promise;
+  };
+};

package/phantom/dispatch/markAsRead.js

@@ -0,0 +1,119 @@
+"use strict";
+
+/**
+ * markAsRead — Advanced Read/Unread Marker for Phantom SDK
+ *
+ * Features:
+ *  - MQTT path (primary) with configurable timeout (default 8s)
+ *  - HTTP legacy fallback via change_read_status.php
+ *  - GraphQL MQTT-based alternative for newer endpoints
+ *  - Batch marking: pass array of threadIDs
+ *  - Mark as unread (read=false) support
+ *  - Full callback + Promise dual API
+ */
+
+const utils = require('../datastore/models/matrix/tools');
+
+async function markViaMqtt(ctx, threadID, read, timeoutMs) {
+  if (!ctx.mqttClient) throw new Error("markAsRead: MQTT client not connected");
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`markAsRead: MQTT publish timed out after ${timeoutMs}ms`)), timeoutMs);
+    ctx.mqttClient.publish(
+      "/mark_thread",
+      JSON.stringify({ threadID, mark: "read", state: read }),
+      { qos: 1, retain: false },
+      err => {
+        clearTimeout(timer);
+        if (err) reject(err);
+        else resolve({ success: true, threadID, read, method: 'mqtt' });
+      }
+    );
+  });
+}
+
+async function markViaHttp(defaultFuncs, ctx, threadID, read) {
+  const form = {
+    "source":               "PagesManagerMessagesInterface",
+    "request_user_id":      ctx.globalOptions?.pageID || ctx.userID,
+    [`ids[${threadID}]`]:   read,
+    "watermarkTimestamp":   Date.now(),
+    "shouldSendReadReceipt": true,
+    "commerce_last_message_type": "",
+  };
+
+  const resData = await defaultFuncs
+    .post("https://www.facebook.com/ajax/mercury/change_read_status.php", ctx.jar, form)
+    .then(utils.saveCookies ? utils.saveCookies(ctx.jar) : r => r)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+  if (resData?.error) throw new Error(JSON.stringify(resData.error));
+  return { success: true, threadID, read, method: 'http' };
+}
+
+async function markOne(defaultFuncs, ctx, threadID, read, timeoutMs) {
+  // Pages use HTTP; normal accounts prefer MQTT
+  if (ctx.globalOptions?.pageID) {
+    return markViaHttp(defaultFuncs, ctx, threadID, read);
+  }
+  try {
+    return await markViaMqtt(ctx, threadID, read, timeoutMs);
+  } catch (mqttErr) {
+    utils.warn("markAsRead", `MQTT failed for ${threadID} — HTTP fallback: ${mqttErr.message}`);
+    return markViaHttp(defaultFuncs, ctx, threadID, read);
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  /**
+   * Mark one or more threads as read (or unread).
+   *
+   * @param {string|string[]} threadID   Single thread ID or array
+   * @param {boolean}         [read=true]  true=read, false=unread
+   * @param {object}          [options]   { timeout, concurrency }
+   * @param {Function}        [callback]  Node-style (err, result) callback
+   * @returns {Promise<object|object[]>}
+   */
+  return async function markAsRead(threadID, read, options, callback) {
+    // Arg normalisation
+    if (typeof read     === 'function') { callback = read;    read = true;  options = {}; }
+    if (typeof read     === 'object' && !Array.isArray(read)) { options = read; read = true; }
+    if (typeof options  === 'function') { callback = options; options = {}; }
+    if (read === undefined || read === null) read = true;
+    options = options || {};
+
+    const timeoutMs   = options.timeout     || 8000;
+    const concurrency = options.concurrency || 5;
+
+    let resolveFunc, rejectFunc;
+    const promise = new Promise((res, rej) => { resolveFunc = res; rejectFunc = rej; });
+
+    function done(err, data) {
+      if (callback) return err ? callback(err) : callback(null, data);
+      if (err) rejectFunc(err); else resolveFunc(data);
+    }
+
+    const ids = Array.isArray(threadID) ? threadID.filter(Boolean) : [threadID].filter(Boolean);
+    if (!ids.length) { done(new Error("markAsRead: threadID is required")); return promise; }
+
+    try {
+      const results = [];
+      for (let i = 0; i < ids.length; i += concurrency) {
+        const batch   = ids.slice(i, i + concurrency);
+        const settled = await Promise.allSettled(batch.map(tid => markOne(defaultFuncs, ctx, tid, read, timeoutMs)));
+        for (const r of settled) {
+          if (r.status === 'fulfilled') results.push(r.value);
+          else results.push({ success: false, threadID: batch[results.length % batch.length], error: r.reason?.message });
+        }
+      }
+      const out = ids.length === 1 ? results[0] : { success: results.every(r => r.success), results };
+      done(null, out);
+    } catch (err) {
+      utils.error("markAsRead", err.message || err);
+      done(err);
+    }
+
+    return promise;
+  };
+};

package/phantom/dispatch/markAsReadAll.js

@@ -0,0 +1,215 @@
+"use strict";
+
+const utils = require('../datastore/models/matrix/tools');
+const { globalShield } = require('../datastore/models/matrix/ghost');
+
+const MARK_ALL_CACHE = new Map();
+const MARK_ALL_TTL = 30 * 1000;
+const OPERATION_HISTORY = [];
+const MAX_HISTORY = 100;
+
+async function retryOp(fn, retries = 4, base = 500, label = 'markAsReadAll') {
+  for (let i = 0; i < retries; i++) {
+    try { return await fn(); } catch (err) {
+      const isTransient = /network|timeout|ECONNRESET|ETIMEDOUT|503|429/i.test(String(err?.message || err));
+      if (!isTransient || i === retries - 1) throw err;
+      const delay = base * Math.pow(2, i) + Math.random() * 300;
+      utils.warn('markAsReadAll', `Retry ${i + 1}/${retries} in ${Math.round(delay)}ms — ${err.message || err}`);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+}
+
+async function httpMarkAllRead(defaultFuncs, ctx, folder = 'inbox') {
+  const res = await defaultFuncs.post(
+    'https://www.facebook.com/ajax/mercury/mark_folder_as_read.php',
+    ctx.jar,
+    { folder }
+  ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res && res.error) throw res;
+  return { success: true, folder, method: 'http', timestamp: Date.now() };
+}
+
+async function mqttMarkAllRead(ctx, folder = 'inbox') {
+  if (!ctx.mqttClient) throw new Error('MQTT not connected');
+  return new Promise((resolve, reject) => {
+    const reqID = ++ctx.wsReqNumber;
+    const taskID = ++ctx.wsTaskNumber;
+
+    const form = JSON.stringify({
+      app_id: '2220391788200892',
+      payload: JSON.stringify({
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [{
+          failure_count: null,
+          label: '21',
+          payload: JSON.stringify({
+            sync_group: 1,
+            folder: folder === 'inbox' ? 1 : 2,
+            mark_as_read: true
+          }),
+          queue_name: 'mark_folder_read',
+          task_id: taskID
+        }],
+        version_id: '8798795233522156'
+      }),
+      request_id: reqID,
+      type: 3
+    });
+
+    let handled = false;
+    const onResp = (topic, message) => {
+      if (topic !== '/ls_resp' || handled) return;
+      let j;
+      try { j = JSON.parse(message.toString()); j.payload = JSON.parse(j.payload); } catch { return; }
+      if (j.request_id !== reqID) return;
+      handled = true;
+      clearTimeout(timer);
+      ctx.mqttClient.removeListener('message', onResp);
+      resolve({ success: true, folder, method: 'mqtt', timestamp: Date.now() });
+    };
+
+    const timer = setTimeout(() => {
+      if (!handled) {
+        handled = true;
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(new Error('MQTT timeout for markAsReadAll'));
+      }
+    }, 15000);
+
+    ctx.mqttClient.on('message', onResp);
+    ctx.mqttClient.publish('/ls_req', form, { qos: 1, retain: false }, (err) => {
+      if (err && !handled) {
+        handled = true;
+        clearTimeout(timer);
+        ctx.mqttClient.removeListener('message', onResp);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function graphqlMarkAllRead(defaultFuncs, ctx) {
+  const form = {
+    fb_api_caller_class: 'RelayModern',
+    fb_api_req_friendly_name: 'MessengerMarkAllAsReadMutation',
+    doc_id: '5044869612218012',
+    variables: JSON.stringify({
+      input: {
+        actor_id: ctx.userID,
+        client_mutation_id: String(Math.round(Math.random() * 10000))
+      }
+    })
+  };
+  const res = await defaultFuncs.post('https://www.facebook.com/api/graphql/', ctx.jar, form)
+    .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+  if (res?.errors) throw new Error(JSON.stringify(res.errors));
+  return { success: true, method: 'graphql', timestamp: Date.now() };
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+
+  function recordHistory(op) {
+    OPERATION_HISTORY.unshift({ ...op, ts: Date.now() });
+    if (OPERATION_HISTORY.length > MAX_HISTORY) OPERATION_HISTORY.length = MAX_HISTORY;
+  }
+
+  return async function markAsReadAll(options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    if (typeof options === 'string') options = { folder: options };
+    if (!options || typeof options !== 'object') options = {};
+
+    const {
+      folder = 'inbox',
+      folders = null,
+      preferMqtt = true,
+      useGraphQL = false,
+      skipCache = false
+    } = options;
+
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (typeof callback !== 'function') {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      const foldersToMark = folders && Array.isArray(folders) ? folders : [folder];
+
+      if (!skipCache) {
+        const cacheKey = `markAll_${foldersToMark.sort().join('+')}`;
+        const cached = MARK_ALL_CACHE.get(cacheKey);
+        if (cached && (Date.now() - cached.ts < MARK_ALL_TTL)) {
+          utils.log('markAsReadAll', 'Cache hit — skipping redundant request');
+          return callback(null, cached.result);
+        }
+      }
+
+      await globalShield.addSmartDelay();
+
+      const results = [];
+      const errors = [];
+
+      for (const f of foldersToMark) {
+        try {
+          let result;
+
+          if (useGraphQL) {
+            result = await retryOp(() => graphqlMarkAllRead(defaultFuncs, ctx));
+          } else if (preferMqtt && ctx.mqttClient) {
+            try {
+              result = await retryOp(() => mqttMarkAllRead(ctx, f));
+            } catch (mqttErr) {
+              utils.warn('markAsReadAll', `MQTT failed for folder "${f}", falling back to HTTP:`, mqttErr.message);
+              result = await retryOp(() => httpMarkAllRead(defaultFuncs, ctx, f));
+            }
+          } else {
+            result = await retryOp(() => httpMarkAllRead(defaultFuncs, ctx, f));
+          }
+
+          results.push({ folder: f, ...result });
+        } catch (folderErr) {
+          errors.push({ folder: f, error: folderErr.message || String(folderErr) });
+        }
+      }
+
+      const finalResult = {
+        success: errors.length === 0,
+        results,
+        errors: errors.length ? errors : undefined,
+        markedFolders: results.map(r => r.folder),
+        timestamp: Date.now()
+      };
+
+      const cacheKey = `markAll_${foldersToMark.sort().join('+')}`;
+      MARK_ALL_CACHE.set(cacheKey, { result: finalResult, ts: Date.now() });
+
+      recordHistory({ action: 'markAsReadAll', folders: foldersToMark, success: finalResult.success });
+
+      utils.log('markAsReadAll', `Marked ${results.length} folder(s) as read${errors.length ? `, ${errors.length} failed` : ''}`);
+
+      if (errors.length === foldersToMark.length) {
+        return callback(new Error(`markAsReadAll: all ${foldersToMark.length} folder(s) failed`));
+      }
+
+      callback(null, finalResult);
+    } catch (err) {
+      utils.error('markAsReadAll', err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+
+  Object.assign(module.exports, {
+    getHistory: (limit = 20) => OPERATION_HISTORY.slice(0, limit),
+    clearCache: () => { MARK_ALL_CACHE.clear(); return { success: true }; }
+  });
+};