@dongdev/fca-unofficial 2.0.32 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dongdev/fca-unofficial",
-  "version": "2.0.32",
+  "version": "3.0.0",
   "description": "Unofficial Facebook Chat API for Node.js - Interact with Facebook Messenger programmatically",
   "main": "index.js",
   "types": "index.d.ts",

package/src/api/messaging/createThemeAI.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const log = require("npmlog");
+const { getType } = require("../../utils/format");
+const { parseAndCheckLogin } = require("../../utils/client");
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function createThemeAI(prompt, callback) {
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    if (getType(prompt) !== "String") {
+      return callback({ error: "Invalid prompt. Please provide a string." });
+    }
+
+    if (!prompt || prompt.trim().length === 0) {
+      return callback({ error: "Prompt cannot be empty." });
+    }
+
+    const form = {
+      av: ctx.userID,
+      fb_api_caller_class: "RelayModern",
+      fb_api_req_friendly_name: "useGenerateAIThemeMutation",
+      doc_id: "23873748445608673",
+      variables: JSON.stringify({
+        input: {
+          client_mutation_id: Math.round(Math.random() * 19).toString(),
+          actor_id: ctx.userID,
+          bypass_cache: true,
+          caller: "MESSENGER",
+          num_themes: 1,
+          prompt: prompt.trim()
+        }
+      }),
+      server_timestamps: true
+    };
+
+    defaultFuncs
+      .post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+      .then(parseAndCheckLogin(ctx, defaultFuncs))
+      .then(function (resData) {
+        if (resData.errors) {
+          throw resData;
+        }
+
+        if (!resData.data || !resData.data.xfb_generate_ai_themes_from_prompt) {
+          throw {
+            error: "Invalid response from Facebook API",
+            res: resData
+          };
+        }
+
+        const themes = resData.data.xfb_generate_ai_themes_from_prompt.themes;
+        if (!themes || !Array.isArray(themes) || themes.length === 0) {
+          throw {
+            error: "No themes generated",
+            res: resData
+          };
+        }
+
+        const theme = themes[0];
+        if (!theme || !theme.id || !theme.background_asset) {
+          throw {
+            error: "Invalid theme data",
+            res: resData
+          };
+        }
+
+        callback(null, {
+          id: theme.id,
+          accessibility_label: theme.accessibility_label || null,
+          background_asset: {
+            id: theme.background_asset.id,
+            image: {
+              url: theme.background_asset.image?.uri || null
+            }
+          }
+        });
+      })
+      .catch(function (err) {
+        log.error("createThemeAI", err);
+        return callback(err);
+      });
+
+    return returnPromise;
+  };
+};

package/src/api/messaging/sendMessage.js

@@ -56,13 +56,12 @@ module.exports = function (defaultFuncs, api, ctx) {
   }
 
   function publishWithAck(content, text, reqID, callback) {
-    const mqttClient = ctx.mqttClient;
     return new Promise((resolve, reject) => {
       let done = false;
       const cleanup = () => {
         if (done) return;
         done = true;
-        mqttClient.removeListener("message", handleRes);
+        ctx.mqttClient.removeListener("message", handleRes);
       };
       const handleRes = (topic, message) => {
         if (topic !== "/ls_resp") return;
@@ -80,8 +79,8 @@ module.exports = function (defaultFuncs, api, ctx) {
         callback && callback(undefined, bodies);
         resolve(bodies);
       };
-      mqttClient.on("message", handleRes);
-      mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, err => {
+      ctx.mqttClient.on("message", handleRes);
+      ctx.mqttClient.publish("/ls_req", JSON.stringify(content), { qos: 1, retain: false }, err => {
         if (err) {
           cleanup();
           callback && callback(err);

package/src/api/socket/core/connectMqtt.js

@@ -12,11 +12,20 @@ module.exports = function createListenMqtt(deps) {
     function scheduleReconnect(delayMs) {
       const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
       const ms = typeof delayMs === "number" ? delayMs : d;
-      if (ctx._reconnectTimer) return; // debounce
+      if (ctx._reconnectTimer) {
+        logger("mqtt reconnect already scheduled", "warn");
+        return; // debounce
+      }
+      if (ctx._ending) {
+        logger("mqtt reconnect skipped - ending", "warn");
+        return;
+      }
       logger(`mqtt will reconnect in ${ms}ms`, "warn");
       ctx._reconnectTimer = setTimeout(() => {
         ctx._reconnectTimer = null;
-        listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        if (!ctx._ending) {
+          listenMqtt(defaultFuncs, api, ctx, globalCallback);
+        }
       }, ms);
     }
     function isEndingLikeError(msg) {
@@ -88,20 +97,29 @@ module.exports = function createListenMqtt(deps) {
       }
 
       if (/Not logged in|Not logged in.|blocked the login|401|403/i.test(msg)) {
-        try { mqttClient.end(true); } catch (_) { }
+        try {
+          if (mqttClient && mqttClient.connected) {
+            mqttClient.end(true);
+          }
+        } catch (_) { }
         return emitAuth(ctx, api, globalCallback,
           /blocked/i.test(msg) ? "login_blocked" : "not_logged_in",
           msg
         );
       }
       logger(`mqtt error: ${msg}`, "error");
-      try { mqttClient.end(true); } catch (_) { }
+      try {
+        if (mqttClient && mqttClient.connected) {
+          mqttClient.end(true);
+        }
+      } catch (_) { }
       if (ctx._ending || ctx._cycling) return;
 
-      if (ctx.globalOptions.autoReconnect) {
+      if (ctx.globalOptions.autoReconnect && !ctx._ending) {
         const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
         logger(`mqtt autoReconnect listenMqtt() in ${d}ms`, "warn");
-        setTimeout(() => listenMqtt(defaultFuncs, api, ctx, globalCallback), d);
+        // Use scheduleReconnect to prevent multiple reconnections
+        scheduleReconnect(d);
       } else {
         globalCallback({ type: "stop_listen", error: msg || "Connection refused" }, null);
       }
@@ -128,8 +146,16 @@ module.exports = function createListenMqtt(deps) {
       mqttClient.publish("/set_client_settings", JSON.stringify({ make_user_available_when_in_foreground: true }), { qos: 1 });
       const d = (ctx._mqttOpt && ctx._mqttOpt.reconnectDelayMs) || 2000;
       const rTimeout = setTimeout(function () {
+        if (ctx._ending) {
+          logger("mqtt t_ms timeout skipped - ending", "warn");
+          return;
+        }
         logger(`mqtt t_ms timeout, cycling in ${d}ms`, "warn");
-        try { mqttClient.end(true); } catch (_) { }
+        try {
+          if (mqttClient && mqttClient.connected) {
+            mqttClient.end(true);
+          }
+        } catch (_) { }
         scheduleReconnect(d);
       }, 5000);
 
@@ -141,9 +167,15 @@ module.exports = function createListenMqtt(deps) {
     });
 
     mqttClient.on("message", function (topic, message) {
+      if (ctx._ending) return; // Ignore messages if ending
       try {
         let jsonMessage = Buffer.isBuffer(message) ? Buffer.from(message).toString() : message;
-        try { jsonMessage = JSON.parse(jsonMessage); } catch (_) { jsonMessage = {}; }
+        try {
+          jsonMessage = JSON.parse(jsonMessage);
+        } catch (parseErr) {
+          logger(`mqtt message parse error for topic ${topic}: ${parseErr && parseErr.message ? parseErr.message : String(parseErr)}`, "warn");
+          jsonMessage = {};
+        }
 
         if (jsonMessage.type === "jewel_requests_add") {
           globalCallback(null, { type: "friend_request_received", actorFbId: jsonMessage.from.toString(), timestamp: Date.now().toString() });
@@ -186,11 +218,26 @@ module.exports = function createListenMqtt(deps) {
           }
         }
       } catch (ex) {
-        logger(`mqtt message parse error: ${ex && ex.message ? ex.message : ex}`, "error");
+        const errMsg = ex && ex.message ? ex.message : String(ex || "Unknown error");
+        logger(`mqtt message handler error: ${errMsg}`, "error");
+        // Don't crash on message parsing errors, just log and continue
       }
     });
 
-    mqttClient.on("close", function () { });
-    mqttClient.on("disconnect", () => { });
+    mqttClient.on("close", function () {
+      if (ctx._ending || ctx._cycling) {
+        logger("mqtt close expected", "info");
+        return;
+      }
+      logger("mqtt connection closed", "warn");
+    });
+
+    mqttClient.on("disconnect", () => {
+      if (ctx._ending || ctx._cycling) {
+        logger("mqtt disconnect expected", "info");
+        return;
+      }
+      logger("mqtt disconnected", "warn");
+    });
   };
 };

package/src/api/socket/core/emitAuth.js

@@ -1,9 +1,35 @@
 "use strict";
 module.exports = function createEmitAuth({ logger }) {
   return function emitAuth(ctx, api, globalCallback, reason, detail) {
-    try { if (ctx._autoCycleTimer) clearInterval(ctx._autoCycleTimer); } catch (_) { }
-    try { ctx._ending = true; } catch (_) { }
-    try { if (ctx.mqttClient) ctx.mqttClient.end(true); } catch (_) { }
+    // Clean up all timers
+    try {
+      if (ctx._autoCycleTimer) {
+        clearInterval(ctx._autoCycleTimer);
+        ctx._autoCycleTimer = null;
+      }
+    } catch (_) { }
+    try {
+      if (ctx._reconnectTimer) {
+        clearTimeout(ctx._reconnectTimer);
+        ctx._reconnectTimer = null;
+      }
+    } catch (_) { }
+
+    try {
+      ctx._ending = true;
+      ctx._cycling = false;
+    } catch (_) { }
+
+    // Clean up MQTT client
+    try {
+      if (ctx.mqttClient) {
+        ctx.mqttClient.removeAllListeners();
+        if (ctx.mqttClient.connected) {
+          ctx.mqttClient.end(true);
+        }
+      }
+    } catch (_) { }
+
     ctx.mqttClient = undefined;
     ctx.loggedIn = false;
 
@@ -11,12 +37,16 @@ module.exports = function createEmitAuth({ logger }) {
     logger(`auth change -> ${reason}: ${msg}`, "error");
 
     if (typeof globalCallback === "function") {
-      globalCallback({
-        type: "account_inactive",
-        reason,
-        error: msg,
-        timestamp: Date.now()
-      }, null);
+      try {
+        globalCallback({
+          type: "account_inactive",
+          reason,
+          error: msg,
+          timestamp: Date.now()
+        }, null);
+      } catch (cbErr) {
+        logger(`emitAuth callback error: ${cbErr && cbErr.message ? cbErr.message : String(cbErr)}`, "error");
+      }
     }
   };
 };

package/src/api/socket/core/parseDelta.js

@@ -1,5 +1,6 @@
 "use strict";
 const { formatDeltaEvent, formatMessage, _formatAttachment, formatDeltaMessage, formatDeltaReadReceipt, formatID, getType, decodeClientPayload } = require("../../../utils/format");
+const logger = require("../../../func/logger");
 module.exports = function createParseDelta(deps) {
   const { markDelivery, parseAndCheckLogin } = deps;
   return function parseDelta(defaultFuncs, api, ctx, globalCallback, { delta }) {
@@ -21,9 +22,11 @@ module.exports = function createParseDelta(deps) {
           }
         } else {
           const attachment = delta.attachments[i];
-          if (attachment.mercury.attach_type === "photo") {
+          if (attachment && attachment.mercury && attachment.mercury.attach_type === "photo") {
             api.resolvePhotoUrl(attachment.fbid, (err, url) => {
-              if (!err) attachment.mercury.metadata.url = url;
+              if (!err && attachment.mercury && attachment.mercury.metadata) {
+                attachment.mercury.metadata.url = url;
+              }
               resolveAttachmentUrl(i + 1);
             });
           } else {
@@ -166,7 +169,10 @@ module.exports = function createParseDelta(deps) {
                   mentions: mobj,
                   timestamp: parseInt(fetchData.timestamp_precise)
                 };
-              }).catch(err => {}).finally(() => {
+              }).catch(err => {
+                const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+                logger(`parseDelta message_reply fetch error: ${errMsg}`, "warn");
+              }).finally(() => {
                 if (ctx.globalOptions.autoMarkDelivery) {
                   markDelivery(ctx, api, callbackToReturn.threadID, callbackToReturn.messageID);
                 }
@@ -313,7 +319,10 @@ module.exports = function createParseDelta(deps) {
             } else {
               return;
             }
-          }).catch(err => {});
+          }).catch(err => {
+            const errMsg = err && err.message ? err.message : String(err || "Unknown error");
+            logger(`parseDelta ForcedFetch error: ${errMsg}`, "warn");
+          });
         }
         break;
       }

package/src/api/socket/listenMqtt.js

@@ -61,6 +61,10 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   let conf = mqttConf(ctx, opts);
 
   function getSeqIDWrapper() {
+    if (ctx._ending && !ctx._cycling) {
+      logger("mqtt getSeqID skipped - ending", "warn");
+      return Promise.resolve();
+    }
     const form = {
       av: ctx.globalOptions.pageID,
       queries: JSON.stringify({
@@ -75,8 +79,25 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
     };
     logger("mqtt getSeqID call", "info");
     return getSeqIDFactory(defaultFuncs, api, ctx, globalCallback, form)
-      .then(() => { logger("mqtt getSeqID done", "info"); ctx._cycling = false; })
-      .catch(e => { logger(`mqtt getSeqID error: ${e && e.message ? e.message : e}`, "error"); });
+      .then(() => {
+        logger("mqtt getSeqID done", "info");
+        ctx._cycling = false;
+      })
+      .catch(e => {
+        ctx._cycling = false;
+        const errMsg = e && e.message ? e.message : String(e || "Unknown error");
+        logger(`mqtt getSeqID error: ${errMsg}`, "error");
+        // Don't reconnect if we're ending
+        if (ctx._ending) return;
+        // Retry after delay if autoReconnect is enabled
+        if (ctx.globalOptions.autoReconnect) {
+          const d = conf.reconnectDelayMs;
+          logger(`mqtt getSeqID will retry in ${d}ms`, "warn");
+          setTimeout(() => {
+            if (!ctx._ending) getSeqIDWrapper();
+          }, d);
+        }
+      });
   }
 
   function isConnected() {
@@ -84,30 +105,70 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   }
 
   function unsubAll(cb) {
-    if (!isConnected()) return cb && cb();
+    if (!isConnected()) {
+      if (cb) setTimeout(cb, 0);
+      return;
+    }
     let pending = topics.length;
-    if (!pending) return cb && cb();
+    if (!pending) {
+      if (cb) setTimeout(cb, 0);
+      return;
+    }
     let fired = false;
+    const timeout = setTimeout(() => {
+      if (!fired) {
+        fired = true;
+        logger("unsubAll timeout, proceeding anyway", "warn");
+        if (cb) cb();
+      }
+    }, 5000); // 5 second timeout
+
     topics.forEach(t => {
-      ctx.mqttClient.unsubscribe(t, () => {
-        if (--pending === 0 && !fired) { fired = true; cb && cb(); }
-      });
+      try {
+        ctx.mqttClient.unsubscribe(t, () => {
+          if (--pending === 0 && !fired) {
+            clearTimeout(timeout);
+            fired = true;
+            if (cb) cb();
+          }
+        });
+      } catch (err) {
+        logger(`unsubAll error for topic ${t}: ${err && err.message ? err.message : String(err)}`, "warn");
+        if (--pending === 0 && !fired) {
+          clearTimeout(timeout);
+          fired = true;
+          if (cb) cb();
+        }
+      }
     });
   }
 
   function endQuietly(next) {
     const finish = () => {
-      try { ctx.mqttClient && ctx.mqttClient.removeAllListeners(); } catch (_) { }
+      try {
+        if (ctx.mqttClient) {
+          ctx.mqttClient.removeAllListeners();
+        }
+      } catch (_) { }
       ctx.mqttClient = undefined;
       ctx.lastSeqId = null;
       ctx.syncToken = undefined;
       ctx.t_mqttCalled = false;
       ctx._ending = false;
+      ctx._cycling = false;
+      if (ctx._reconnectTimer) {
+        clearTimeout(ctx._reconnectTimer);
+        ctx._reconnectTimer = null;
+      }
       next && next();
     };
     try {
       if (ctx.mqttClient) {
-        if (isConnected()) { try { ctx.mqttClient.publish("/browser_close", "{}"); } catch (_) { } }
+        if (isConnected()) {
+          try {
+            ctx.mqttClient.publish("/browser_close", "{}", { qos: 0 });
+          } catch (_) { }
+        }
         ctx.mqttClient.end(true, finish);
       } else finish();
     } catch (_) { finish(); }
@@ -120,7 +181,10 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
   }
 
   function forceCycle() {
-    if (ctx._cycling) return;
+    if (ctx._cycling) {
+      logger("mqtt force cycle already in progress", "warn");
+      return;
+    }
     ctx._cycling = true;
     ctx._ending = true;
     logger("mqtt force cycle begin", "warn");
@@ -140,6 +204,11 @@ module.exports = function (defaultFuncs, api, ctx, opts) {
           logger("mqtt auto-cycle cleared", "info");
         }
 
+        if (ctx._reconnectTimer) {
+          clearTimeout(ctx._reconnectTimer);
+          ctx._reconnectTimer = null;
+        }
+
         ctx._ending = true;
         unsubAll(() => endQuietly(() => {
           logger("mqtt stopped", "info");

package/src/utils/client.js

@@ -85,31 +85,85 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
     return `${n}=${v}; Domain=.${service}.com; Path=/; Secure`;
   };
 
-  const maybeAutoLogin = async (resData) => {
+  const maybeAutoLogin = async (resData, resConfig) => {
+    // Prevent infinite loop if auto login is already in progress
     if (ctx.auto_login) {
-      const e = new Error("Not logged in.");
+      const e = new Error("Not logged in. Auto login already in progress.");
       e.error = "Not logged in.";
       e.res = resData;
       throw e;
     }
+    // Check if performAutoLogin function exists
     if (typeof ctx.performAutoLogin !== "function") {
-      const e = new Error("Not logged in.");
+      const e = new Error("Not logged in. Auto login function not available.");
       e.error = "Not logged in.";
       e.res = resData;
       throw e;
     }
+    // Set flag to prevent concurrent auto login attempts
     ctx.auto_login = true;
-    logger("Login session expired", "warn");
-    const ok = await ctx.performAutoLogin();
-    if (ok) {
-      logger("Auto login successful! Restarting...");
-      ctx.auto_login = false;
-      process.exit(1);
-    } else {
+    logger("Login session expired, attempting auto login...", "warn");
+
+    try {
+      const ok = await ctx.performAutoLogin();
+      if (ok) {
+        logger("Auto login successful! Retrying request...", "info");
+        ctx.auto_login = false;
+
+        // After successful auto login, retry the original request
+        if (resConfig) {
+          const url = buildUrl(resConfig);
+          const method = String(resConfig?.method || "GET").toUpperCase();
+          const ctype = String(headerOf(resConfig?.headers, "content-type") || "").toLowerCase();
+          const isMultipart = ctype.includes("multipart/form-data");
+          const payload = resConfig?.data;
+          const params = resConfig?.params;
+
+          try {
+            let newData;
+            if (method === "GET") {
+              newData = await http.get(url, ctx.jar, params || null, ctx.globalOptions, ctx);
+            } else if (isMultipart) {
+              newData = await http.postFormData(url, ctx.jar, payload, params, ctx.globalOptions, ctx);
+            } else {
+              newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
+            }
+            // Retry parsing with the new response
+            return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+          } catch (retryErr) {
+            logger(`Auto login retry failed: ${retryErr && retryErr.message ? retryErr.message : String(retryErr)}`, "error");
+            const e = new Error("Not logged in. Auto login retry failed.");
+            e.error = "Not logged in.";
+            e.res = resData;
+            e.originalError = retryErr;
+            throw e;
+          }
+        } else {
+          // No config available, can't retry
+          const e = new Error("Not logged in. Auto login successful but cannot retry request.");
+          e.error = "Not logged in.";
+          e.res = resData;
+          throw e;
+        }
+      } else {
+        ctx.auto_login = false;
+        const e = new Error("Not logged in. Auto login failed.");
+        e.error = "Not logged in.";
+        e.res = resData;
+        throw e;
+      }
+    } catch (autoLoginErr) {
       ctx.auto_login = false;
-      const e = new Error("Not logged in.");
+      // If error already has the right format, rethrow it
+      if (autoLoginErr.error === "Not logged in.") {
+        throw autoLoginErr;
+      }
+      // Otherwise, wrap it
+      logger(`Auto login error: ${autoLoginErr && autoLoginErr.message ? autoLoginErr.message : String(autoLoginErr)}`, "error");
+      const e = new Error("Not logged in. Auto login error.");
       e.error = "Not logged in.";
       e.res = resData;
+      e.originalError = autoLoginErr;
       throw e;
     }
   };
@@ -121,9 +175,15 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
         err.statusCode = status;
         err.res = res?.data;
         err.error = "Request retry failed. Check the `res` and `statusCode` property on this error.";
+        logger(`parseAndCheckLogin: Max retries (5) reached for status ${status}`, "error");
         throw err;
       }
-      const retryTime = Math.floor(Math.random() * 5000);
+      // Exponential backoff with jitter
+      const retryTime = Math.min(
+        Math.floor(Math.random() * (1000 * Math.pow(2, retryCount))) + 1000,
+        10000 // Max 10 seconds
+      );
+      logger(`parseAndCheckLogin: Retrying request (attempt ${retryCount + 1}/5) after ${retryTime}ms for status ${status}`, "warn");
       await delay(retryTime);
       const url = buildUrl(res?.config);
       const method = String(res?.config?.method || "GET").toUpperCase();
@@ -132,16 +192,22 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
       const payload = res?.config?.data;
       const params = res?.config?.params;
       retryCount += 1;
-      if (method === "GET") {
-        const newData = await http.get(url, ctx.jar, params || null, ctx.globalOptions, ctx);
-        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
-      }
-      if (isMultipart) {
-        const newData = await http.postFormData(url, ctx.jar, payload, params, ctx.globalOptions, ctx);
-        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
-      } else {
-        const newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
-        return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+      try {
+        if (method === "GET") {
+          const newData = await http.get(url, ctx.jar, params || null, ctx.globalOptions, ctx);
+          return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+        }
+        if (isMultipart) {
+          const newData = await http.postFormData(url, ctx.jar, payload, params, ctx.globalOptions, ctx);
+          return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+        } else {
+          const newData = await http.post(url, ctx.jar, payload, ctx.globalOptions, ctx);
+          return await parseAndCheckLogin(ctx, http, retryCount)(newData);
+        }
+      } catch (retryErr) {
+        if (retryCount >= 5) throw retryErr;
+        // Continue retry loop
+        return await parseAndCheckLogin(ctx, http, retryCount)(res);
       }
     }
     if (status === 404) return;
@@ -192,17 +258,24 @@ function parseAndCheckLogin(ctx, http, retryCount = 0) {
     const resData = parsed;
     const resStr = JSON.stringify(resData);
     if (resStr.includes("XCheckpointFBScrapingWarningController") || resStr.includes("601051028565049")) {
-      await maybeAutoLogin(resData);
+      return await maybeAutoLogin(resData, res?.config);
     }
     if (resStr.includes("https://www.facebook.com/login.php?") || String(parsed?.redirect || "").includes("login.php?")) {
-      await maybeAutoLogin(resData);
+      return await maybeAutoLogin(resData, res?.config);
     }
     if (resStr.includes("1501092823525282")) {
       logger("Bot checkpoint 282 detected, please check the account!", "error");
-      process.exit(0);
+      const err = new Error("Checkpoint 282 detected");
+      err.error = "checkpoint_282";
+      err.res = resData;
+      throw err;
     }
     if (resStr.includes("828281030927956")) {
       logger("Bot checkpoint 956 detected, please check the account!", "error");
+      const err = new Error("Checkpoint 956 detected");
+      err.error = "checkpoint_956";
+      err.res = resData;
+      throw err;
     }
     return parsed;
   };