@vangbanlanhat/fca-unofficial 1.4.2

package/src/service/uploadAttachment.js

@@ -0,0 +1,318 @@
+"use strict";
+
+var fs = require("fs");
+var bluebird = require("bluebird");
+var utils = require("../utils");
+
+function stringifyUploadResponse(resData) {
+  if (resData instanceof Error) {
+    var errInfo = {
+      name: resData.name,
+      message: resData.message
+    };
+    if (resData.code !== undefined) errInfo.code = resData.code;
+    if (resData.statusCode !== undefined) errInfo.statusCode = resData.statusCode;
+    try {
+      return JSON.stringify(errInfo);
+    } catch (_) {
+      return String(resData.message || resData);
+    }
+  }
+
+  if (resData && typeof resData === "object") {
+    var commonErr = {
+      message: resData.message,
+      error: resData.error,
+      code: resData.code,
+      statusCode: resData.statusCode
+    };
+    if (
+      commonErr.message !== undefined ||
+      commonErr.error !== undefined ||
+      commonErr.code !== undefined ||
+      commonErr.statusCode !== undefined
+    ) {
+      try {
+        return JSON.stringify(commonErr);
+      } catch (_) {
+        return String(resData);
+      }
+    }
+  }
+
+  try {
+    return JSON.stringify(resData);
+  } catch (_) {
+    return String(resData);
+  }
+}
+
+function pickUploadRequestDebug(rawRes) {
+  var req = rawRes && rawRes.request ? rawRes.request : null;
+  var headers = req && req.headers ? req.headers : {};
+  var query = req && req.uri && req.uri.query && typeof req.uri.query === "object"
+    ? req.uri.query
+    : {};
+
+  return {
+    method: req && req.method ? req.method : undefined,
+    host: headers.host || headers.Host,
+    origin: headers.origin || headers.Origin,
+    referer: headers.referer || headers.Referer,
+    userAgent: headers["user-agent"] || headers["User-Agent"],
+    contentType: headers["content-type"] || headers["Content-Type"],
+    xFbLsd: headers["x-fb-lsd"] || headers["X-FB-LSD"],
+    xAsbdId: headers["x-asbd-id"] || headers["X-ASBD-ID"],
+    secFetchSite: headers["sec-fetch-site"] || headers["Sec-Fetch-Site"],
+    secFetchMode: headers["sec-fetch-mode"] || headers["Sec-Fetch-Mode"],
+    secFetchDest: headers["sec-fetch-dest"] || headers["Sec-Fetch-Dest"],
+    hasCookie: !!(headers.cookie || headers.Cookie),
+    queryKeys: Object.keys(query)
+  };
+}
+
+function extractUploadMetadata(resData) {
+  var rawMetadata =
+    resData &&
+    resData.payload
+      ? resData.payload.metadata
+      : null;
+
+  if (Array.isArray(rawMetadata)) {
+    return rawMetadata;
+  }
+
+  if (rawMetadata && typeof rawMetadata === "object") {
+    return Object.keys(rawMetadata)
+      .sort(function (a, b) {
+        return Number(a) - Number(b);
+      })
+      .map(function (key) {
+        return rawMetadata[key];
+      });
+  }
+
+  return [];
+}
+
+function extractStatusCode(err) {
+  if (!err) return null;
+  if (typeof err.statusCode === "number") return err.statusCode;
+
+  var message = "";
+  if (typeof err === "string") message += err;
+  if (err && typeof err.message === "string") message += " " + err.message;
+  if (err && typeof err.error === "string") message += " " + err.error;
+
+  var match = message.match(/status code:\s*(\d{3})/i);
+  return match ? Number(match[1]) : null;
+}
+
+function shouldTryLegacyHostFallback(err) {
+  var statusCode = extractStatusCode(err);
+  if (statusCode === 408 || statusCode === 429) return true;
+  if (typeof statusCode === "number" && statusCode >= 500 && statusCode < 600) return true;
+  return false;
+}
+
+module.exports = function createUploadAttachment(defaultFuncs, ctx, logger) {
+  function writeError(message) {
+    if (logger && typeof logger.error === "function") {
+      logger.error("uploadAttachment", message);
+    }
+    console.error("uploadAttachment", message);
+  }
+
+  return function uploadAttachment(attachments, callback) {
+    var uploads = [];
+
+    for (let i = 0; i < attachments.length; i++) {
+      let attachment = attachments[i];
+      let attachmentPath =
+        attachment && typeof attachment.path === "string"
+          ? attachment.path
+          : null;
+
+      if (!utils.isReadableStream(attachment)) {
+        throw {
+          error:
+            "Attachment should be a readable stream and not " +
+            utils.getType(attachment) +
+            "."
+        };
+      }
+
+      const form = {
+        farr: attachment,
+        voice_clip: "true"
+      };
+
+      uploads.push(
+        bluebird.resolve()
+          .then(function () {
+            return defaultFuncs.postFormData(
+              "https://www.facebook.com/ajax/mercury/upload.php",
+              ctx.jar,
+              form,
+              {}
+            );
+          })
+          .then(function (rawRes) {
+            return {
+              rawRes: rawRes,
+              uploadReqDebug: pickUploadRequestDebug(rawRes)
+            };
+          })
+          .then(function (bundle) {
+            return utils.parseAndCheckLogin(ctx, defaultFuncs)(bundle.rawRes)
+              .then(function (resData) {
+                return {
+                  resData: resData,
+                  uploadReqDebug: bundle.uploadReqDebug
+                };
+              });
+          })
+          .then(function (bundle) {
+            var resData = bundle.resData;
+            var uploadReqDebug = bundle.uploadReqDebug;
+
+            if (resData.error) {
+              throw resData;
+            }
+
+            var metadata = extractUploadMetadata(resData);
+            if (metadata.length) {
+              return metadata[0];
+            }
+
+            writeError("Raw upload response (empty metadata): " + stringifyUploadResponse(resData));
+            writeError("Upload request debug: " + stringifyUploadResponse(uploadReqDebug));
+
+            if (!attachmentPath) {
+              throw {
+                error: "Upload succeeded but did not return attachment metadata.",
+                res: resData
+              };
+            }
+
+            var fallbackForm = {
+              upload_1024: fs.createReadStream(attachmentPath),
+              voice_clip: "true"
+            };
+
+            return defaultFuncs
+              .postFormData(
+                "https://upload.facebook.com/ajax/mercury/upload.php",
+                ctx.jar,
+                fallbackForm,
+                {}
+              )
+              .then(function (fallbackRawRes) {
+                return {
+                  fallbackRawRes: fallbackRawRes,
+                  fallbackReqDebug: pickUploadRequestDebug(fallbackRawRes)
+                };
+              })
+              .then(function (fallbackBundle) {
+                return utils.parseAndCheckLogin(ctx, defaultFuncs)(fallbackBundle.fallbackRawRes)
+                  .then(function (fallbackData) {
+                    return {
+                      fallbackData: fallbackData,
+                      fallbackReqDebug: fallbackBundle.fallbackReqDebug
+                    };
+                  });
+              })
+              .then(function (fallbackBundle) {
+                var fallbackData = fallbackBundle.fallbackData;
+                var fallbackReqDebug = fallbackBundle.fallbackReqDebug;
+
+                if (fallbackData.error) {
+                  throw fallbackData;
+                }
+
+                var fallbackMetadata = extractUploadMetadata(fallbackData);
+                if (fallbackMetadata.length) {
+                  return fallbackMetadata[0];
+                }
+
+                writeError("Raw upload response (legacy fallback empty metadata): " + stringifyUploadResponse(fallbackData));
+                writeError("Legacy upload request debug: " + stringifyUploadResponse(fallbackReqDebug));
+
+                throw {
+                  error: "Upload succeeded but did not return attachment metadata.",
+                  res: fallbackData,
+                  firstRes: resData
+                };
+              });
+          })
+          .catch(function (primaryErr) {
+            if (!attachmentPath || !shouldTryLegacyHostFallback(primaryErr)) {
+              throw primaryErr;
+            }
+
+            var fallbackForm = {
+              upload_1024: fs.createReadStream(attachmentPath),
+              voice_clip: "true"
+            };
+
+            return defaultFuncs
+              .postFormData(
+                "https://upload.facebook.com/ajax/mercury/upload.php",
+                ctx.jar,
+                fallbackForm,
+                {}
+              )
+              .then(function (fallbackRawRes) {
+                return {
+                  fallbackRawRes: fallbackRawRes,
+                  fallbackReqDebug: pickUploadRequestDebug(fallbackRawRes)
+                };
+              })
+              .then(function (fallbackBundle) {
+                return utils.parseAndCheckLogin(ctx, defaultFuncs)(fallbackBundle.fallbackRawRes)
+                  .then(function (fallbackData) {
+                    return {
+                      fallbackData: fallbackData,
+                      fallbackReqDebug: fallbackBundle.fallbackReqDebug
+                    };
+                  });
+              })
+              .then(function (fallbackBundle) {
+                var fallbackData = fallbackBundle.fallbackData;
+                var fallbackReqDebug = fallbackBundle.fallbackReqDebug;
+
+                if (fallbackData.error) {
+                  throw fallbackData;
+                }
+
+                var fallbackMetadata = extractUploadMetadata(fallbackData);
+                if (fallbackMetadata.length) {
+                  return fallbackMetadata[0];
+                }
+
+                writeError("Raw upload response (legacy host fallback empty metadata): " + stringifyUploadResponse(fallbackData));
+                writeError("Legacy host request debug: " + stringifyUploadResponse(fallbackReqDebug));
+
+                throw {
+                  error: "Upload succeeded but did not return attachment metadata.",
+                  res: fallbackData,
+                  firstErr: primaryErr
+                };
+              });
+          })
+      );
+    }
+
+    bluebird
+      .all(uploads)
+      .then(function (resData) {
+        callback(null, resData);
+      })
+      .catch(function (err) {
+        if (logger && typeof logger.error === "function") {
+          logger.error("uploadAttachment", err);
+        }
+        callback(err);
+      });
+  };
+};

package/src/utils/base-parts/auth.js

@@ -0,0 +1,286 @@
+"use strict";
+
+var bluebird = require("bluebird");
+var log = require("npmlog");
+
+var network = require("./network");
+var parsing = require("./parsing");
+
+function formatCookie(arr, url) {
+  return arr[0] + "=" + arr[1] + "; Path=" + arr[3] + "; Domain=" + url + ".com";
+}
+
+function makeDefaults(html, userID, ctx) {
+  var reqCounter = 1;
+  var fb_dtsg = parsing.getFrom(html, 'name="fb_dtsg" value="', '"');
+  var lsd = parsing.getFrom(html, '["LSD",[],{"token":"', '"');
+  if (!lsd) {
+    lsd = parsing.getFrom(html, 'name="lsd" value="', '"');
+  }
+
+  var ttstamp = "2";
+  for (var i = 0; i < fb_dtsg.length; i++) {
+    ttstamp += fb_dtsg.charCodeAt(i);
+  }
+  var revision = parsing.getFrom(html, 'revision":', ",");
+
+  function mergeWithDefaults(obj) {
+    var newObj = {
+      av: userID,
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+      fb_dtsg: ctx.fb_dtsg ? ctx.fb_dtsg : fb_dtsg,
+      jazoest: ctx.ttstamp ? ctx.ttstamp : ttstamp,
+      lsd: ctx.lsd ? ctx.lsd : lsd
+    };
+
+    if (!obj) return newObj;
+
+    for (var prop in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+        if (!newObj[prop]) {
+          newObj[prop] = obj[prop];
+        }
+      }
+    }
+
+    return newObj;
+  }
+
+  function resolveCtx(ctxx) {
+    if (ctxx && (ctxx.jar || ctxx.userID || ctxx.globalOptions || ctxx.region)) {
+      return ctxx;
+    }
+    return ctx;
+  }
+
+  function postWithDefaults(url, jar, form, ctxx, customHeader) {
+    return network.post(
+      url,
+      jar,
+      mergeWithDefaults(form),
+      ctx.globalOptions,
+      resolveCtx(ctxx),
+      customHeader
+    );
+  }
+
+  function getWithDefaults(url, jar, qs, ctxx, customHeader) {
+    return network.get(
+      url,
+      jar,
+      mergeWithDefaults(qs),
+      ctx.globalOptions,
+      resolveCtx(ctxx),
+      customHeader
+    );
+  }
+
+  function postFormDataWithDefault(url, jar, form, qs, ctxx) {
+    return network.postFormData(
+      url,
+      jar,
+      mergeWithDefaults(form),
+      mergeWithDefaults(qs),
+      ctx.globalOptions,
+      ctxx || ctx
+    );
+  }
+
+  return {
+    get: getWithDefaults,
+    post: postWithDefaults,
+    postFormData: postFormDataWithDefault
+  };
+}
+
+function parseAndCheckLogin(ctx, defaultFuncs, retryCount) {
+  if (retryCount == undefined) {
+    retryCount = 0;
+  }
+  return function (data) {
+    return bluebird.try(function () {
+      log.verbose("parseAndCheckLogin", data.body);
+
+      function isMercuryUploadRequest() {
+        var pathname = data && data.request && data.request.uri
+          ? data.request.uri.pathname
+          : "";
+        return typeof pathname === "string" && pathname.indexOf("/ajax/mercury/upload.php") !== -1;
+      }
+
+      function hasUploadMetadata(parsed) {
+        var metadata = parsed && parsed.payload ? parsed.payload.metadata : null;
+        if (Array.isArray(metadata)) return metadata.length > 0;
+        return !!(metadata && typeof metadata === "object" && Object.keys(metadata).length);
+      }
+
+      function tryParseUploadPayloadFromNon200() {
+        if (!isMercuryUploadRequest()) return null;
+        if (!data || typeof data.body !== "string" || data.body.trim() === "") return null;
+
+        try {
+          var parsedUpload = JSON.parse(parsing.makeParsable(data.body));
+          if (parsedUpload && !parsedUpload.error && hasUploadMetadata(parsedUpload)) {
+            return parsedUpload;
+          }
+        } catch (_) {
+          return null;
+        }
+
+        return null;
+      }
+
+      if (data.statusCode >= 500 && data.statusCode < 600) {
+        if (retryCount >= 5) {
+          throw {
+            error:
+              "Request retry failed. Check the `res` and `statusCode` property on this error.",
+            statusCode: data.statusCode,
+            res: data.body
+          };
+        }
+        retryCount++;
+        var retryTime = Math.floor(Math.random() * 5000);
+        log.warn(
+          "parseAndCheckLogin",
+          "Got status code " +
+          data.statusCode +
+          " - " +
+          retryCount +
+          ". attempt to retry in " +
+          retryTime +
+          " milliseconds..."
+        );
+        var url =
+          data.request.uri.protocol +
+          "//" +
+          data.request.uri.hostname +
+          data.request.uri.pathname;
+        var reqHeaders = data.request && data.request.headers ? data.request.headers : {};
+        var reqContentType = reqHeaders["content-type"] || reqHeaders["Content-Type"] || "";
+        if (
+          String(reqContentType).split(";")[0] ===
+          "multipart/form-data"
+        ) {
+          return bluebird
+            .delay(retryTime)
+            .then(function () {
+              return defaultFuncs.postFormData(
+                url,
+                ctx.jar,
+                data.request.formData,
+                {}
+              );
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount));
+        } else {
+          return bluebird
+            .delay(retryTime)
+            .then(function () {
+              return defaultFuncs.post(url, ctx.jar, data.request.formData);
+            })
+            .then(parseAndCheckLogin(ctx, defaultFuncs, retryCount));
+        }
+      }
+      if (data.statusCode !== 200) {
+        var parsedUploadFromNon200 = tryParseUploadPayloadFromNon200();
+        if (parsedUploadFromNon200) {
+          log.warn(
+            "parseAndCheckLogin",
+            "Parsed mercury upload payload from non-200 status " + data.statusCode
+          );
+          return parsedUploadFromNon200;
+        }
+
+        throw new Error(
+          "parseAndCheckLogin got status code: " +
+          data.statusCode +
+          ". Bailing out of trying to parse response."
+        );
+      }
+
+      var res = null;
+      try {
+        res = JSON.parse(parsing.makeParsable(data.body));
+      } catch (e) {
+        throw {
+          error: "JSON.parse error. Check the `detail` property on this error.",
+          detail: e,
+          res: data.body
+        };
+      }
+
+      if (res.redirect && data.request.method === "GET") {
+        return defaultFuncs
+          .get(res.redirect, ctx.jar)
+          .then(parseAndCheckLogin(ctx, defaultFuncs));
+      }
+
+      if (
+        res.jsmods &&
+        res.jsmods.require &&
+        Array.isArray(res.jsmods.require[0]) &&
+        res.jsmods.require[0][0] === "Cookie"
+      ) {
+        res.jsmods.require[0][3][0] = res.jsmods.require[0][3][0].replace(
+          "_js_",
+          ""
+        );
+        var cookie = formatCookie(res.jsmods.require[0][3], "facebook");
+        var cookie2 = formatCookie(res.jsmods.require[0][3], "messenger");
+        ctx.jar.setCookie(cookie, "https://www.facebook.com");
+        ctx.jar.setCookie(cookie2, "https://www.messenger.com");
+      }
+
+      if (res.jsmods && Array.isArray(res.jsmods.require)) {
+        var arr = res.jsmods.require;
+        for (var idx in arr) {
+          if (arr[idx][0] === "DTSG" && arr[idx][1] === "setToken") {
+            ctx.fb_dtsg = arr[idx][3][0];
+            ctx.ttstamp = "2";
+            for (var j = 0; j < ctx.fb_dtsg.length; j++) {
+              ctx.ttstamp += ctx.fb_dtsg.charCodeAt(j);
+            }
+          }
+        }
+      }
+
+      if (res.error === 1357001) {
+        throw { error: "Not logged in." };
+      }
+      return res;
+    });
+  };
+}
+
+function saveCookies(jar) {
+  return function (res) {
+    var cookies = res.headers["set-cookie"] || [];
+    cookies.forEach(function (c) {
+      if (c.indexOf(".facebook.com") > -1) {
+        jar.setCookie(c, "https://www.facebook.com");
+      }
+      var c2 = c.replace(/domain=\.facebook\.com/, "domain=.messenger.com");
+      jar.setCookie(c2, "https://www.messenger.com");
+    });
+    return res;
+  };
+}
+
+function getAppState(jar) {
+  return jar
+    .getCookies("https://www.facebook.com")
+    .concat(jar.getCookies("https://facebook.com"))
+    .concat(jar.getCookies("https://www.messenger.com"));
+}
+
+module.exports = {
+  makeDefaults,
+  parseAndCheckLogin,
+  saveCookies,
+  getAppState,
+  formatCookie
+};