@dongdev/fca-unofficial 2.0.31 → 3.0.0

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

package/src/utils/request.js

@@ -17,21 +17,39 @@ const client = wrapper(axios.create({
   jar,
   withCredentials: true,
   timeout: 60000,
-  validateStatus: s => s >= 200 && s < 600
+  validateStatus: s => s >= 200 && s < 600,
+  maxRedirects: 5,
+  maxContentLength: Infinity,
+  maxBodyLength: Infinity
 }));
 
 const delay = ms => new Promise(r => setTimeout(r, ms));
 
-async function requestWithRetry(fn, retries = 3) {
-  let err;
+async function requestWithRetry(fn, retries = 3, baseDelay = 1000) {
+  let lastError;
   for (let i = 0; i < retries; i++) {
-    try { return await fn(); } catch (e) {
-      err = e;
-      if (i === retries - 1) return e.response ? e.response : Promise.reject(e);
-      await delay((1 << i) * 1000 + Math.floor(Math.random() * 200));
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+      // Don't retry on client errors (4xx) except 429 (rate limit)
+      const status = e?.response?.status || e?.statusCode || 0;
+      if (status >= 400 && status < 500 && status !== 429) {
+        return e.response || Promise.reject(e);
+      }
+      // Don't retry on last attempt
+      if (i === retries - 1) {
+        return e.response || Promise.reject(e);
+      }
+      // Exponential backoff with jitter
+      const backoffDelay = Math.min(
+        baseDelay * Math.pow(2, i) + Math.floor(Math.random() * 200),
+        30000 // Max 30 seconds
+      );
+      await delay(backoffDelay);
     }
   }
-  throw err;
+  throw lastError || new Error("Request failed after retries");
 }
 
 function cfg(base = {}) {
@@ -69,12 +87,12 @@ function isPairArrayList(arr) {
 }
 
 function cleanGet(url) {
-  return requestWithRetry(() => client.get(url, cfg()));
+  return requestWithRetry(() => client.get(url, cfg()), 3, 1000);
 }
 
 function get(url, reqJar, qs, options, ctx, customHeader) {
   const headers = getHeaders(url, options, ctx, customHeader);
-  return requestWithRetry(() => client.get(url, cfg({ reqJar, headers, params: qs })));
+  return requestWithRetry(() => client.get(url, cfg({ reqJar, headers, params: qs })), 3, 1000);
 }
 
 function post(url, reqJar, form, options, ctx, customHeader) {
@@ -107,7 +125,7 @@ function post(url, reqJar, form, options, ctx, customHeader) {
     data = p.toString();
     headers["Content-Type"] = "application/x-www-form-urlencoded";
   }
-  return requestWithRetry(() => client.post(url, data, cfg({ reqJar, headers })));
+  return requestWithRetry(() => client.post(url, data, cfg({ reqJar, headers })), 3, 1000);
 }
 
 async function postFormData(url, reqJar, form, qs, options, ctx) {
@@ -160,7 +178,7 @@ async function postFormData(url, reqJar, form, qs, options, ctx) {
     }
   }
   const headers = { ...getHeaders(url, options, ctx), ...fd.getHeaders() };
-  return requestWithRetry(() => client.post(url, fd, cfg({ reqJar, headers, params: qs })));
+  return requestWithRetry(() => client.post(url, fd, cfg({ reqJar, headers, params: qs })), 3, 1000);
 }
 
 function makeDefaults(html, userID, ctx) {