@dongdev/fca-unofficial 3.0.25 → 3.0.28

package/src/api/messaging/setTitle.js

@@ -62,30 +62,30 @@ module.exports = function (defaultFuncs, api, ctx) {
       });
     return returnPromise;
   };
-  function setTitleMqtt(newTitle, threadID, callback) {
-    if (!ctx.mqttClient) {
-      throw new Error("Not connected to MQTT");
-    }
-    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
-    const reqID = ++ctx.wsReqNumber;
-    var resolveFunc = function () { };
-    var rejectFunc = function () { };
-    var returnPromise = new Promise(function (resolve, reject) {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-    const done = (err, data) => {
-      if (err) {
-        if (callback) callback(err);
-        return rejectFunc(err);
-      }
-      if (callback) callback(null, data);
-      resolveFunc(data);
-    };
-    var form = JSON.stringify({
-      "app_id": "2220391788200892",
-      "payload": JSON.stringify({
-        epoch_id: generateOfflineThreadingID(),
+  function setTitleMqtt(newTitle, threadID, callback) {
+    if (!ctx.mqttClient) {
+      throw new Error("Not connected to MQTT");
+    }
+    if (typeof ctx.wsReqNumber !== "number") ctx.wsReqNumber = 0;
+    const reqID = ++ctx.wsReqNumber;
+    var resolveFunc = function () { };
+    var rejectFunc = function () { };
+    var returnPromise = new Promise(function (resolve, reject) {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+    const done = (err, data) => {
+      if (err) {
+        if (callback) callback(err);
+        return rejectFunc(err);
+      }
+      if (callback) callback(null, data);
+      resolveFunc(data);
+    };
+    var form = JSON.stringify({
+      "app_id": "2220391788200892",
+      "payload": JSON.stringify({
+        epoch_id: generateOfflineThreadingID(),
         tasks: [
           {
             failure_count: null,
@@ -99,26 +99,26 @@ module.exports = function (defaultFuncs, api, ctx) {
             task_id: Math.random() * 1001 << 0
           }
         ],
-        version_id: '8798795233522156'
-      }),
-      "request_id": reqID,
-      "type": 3
-    });
-    ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
-      if (err) return done(err);
-      done(null, { success: true });
-    });
-    return returnPromise;
-  };
-  return function setTitle(newTitle, threadID, callback) {
-    if (ctx.mqttClient) {
-      try {
-        return setTitleMqtt(newTitle, threadID, callback);
-      } catch (e) {
-        return setTitleNoMqtt(newTitle, threadID, callback);
-      }
-    } else {
-      return setTitleNoMqtt(newTitle, threadID, callback);
-    }
-  };
-};
+        version_id: '8798795233522156'
+      }),
+      "request_id": reqID,
+      "type": 3
+    });
+    ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+      if (err) return done(err);
+      done(null, { success: true });
+    });
+    return returnPromise;
+  };
+  return function setTitle(newTitle, threadID, callback) {
+    if (ctx.mqttClient) {
+      try {
+        return setTitleMqtt(newTitle, threadID, callback);
+      } catch (e) {
+        return setTitleNoMqtt(newTitle, threadID, callback);
+      }
+    } else {
+      return setTitleNoMqtt(newTitle, threadID, callback);
+    }
+  };
+};

package/src/api/messaging/uploadAttachment.js

@@ -1,94 +1,492 @@
 "use strict";
+
+const axios = require("axios");
+const { wrapper } = require("axios-cookiejar-support");
+const { CookieJar } = require("tough-cookie");
+const FormData = require("form-data");
+const fs = require("fs");
+const path = require("path");
+const stream = require("stream");
+const { URL } = require("url");
 const log = require("npmlog");
-const { parseAndCheckLogin } = require("../../utils/client");
-const { getType } = require("../../utils/format");
-const { isReadableStream } = require("../../utils/constants");
-module.exports = function(defaultFuncs, api, ctx) {
-  function upload(attachments, callback) {
-    callback = callback || function() {};
-    const uploads = [];
-
-    // create an array of promises
-    for (let i = 0; i < attachments.length; i++) {
-      if (!isReadableStream(attachments[i])) {
-        throw {
-          error:
-            "Attachment should be a readable stream and not " +
-            getType(attachments[i]) +
-            "."
-        };
-      }
 
-      const form = {
-        farr: attachments[i]
-      };
+let http = null;
+let cookieJar = new CookieJar();
+let tokenCache = null;
+let tokenCacheTime = 0;
+const TOKEN_CACHE_TTL = 5 * 60 * 1000;
 
-      uploads.push(
-        defaultFuncs
-          .postFormData(
-            "https://www.facebook.com/ajax/mercury/upload.php",
-            ctx.jar,
-            form,
-            {}
-          )
-          .then(parseAndCheckLogin(ctx, defaultFuncs))
-          .then(function(resData) {
-            if (resData.error) {
-              throw resData;
-            }
+const DEFAULT_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36";
+
+function cleanJSON(x) {
+  if (typeof x !== "string") return x;
+  const s = x.replace(/^for\s*\(;;\);\s*/i, "");
+  try { return JSON.parse(s); } catch { return s; }
+}
+
+function pick(re, html, i = 1) {
+  const m = html && html.match(re);
+  return m ? m[i] : "";
+}
 
-            // We have to return the data unformatted unless we want to change it
-            // back in sendMessage.
-            return resData.payload.metadata[0];
-          })
-      );
-    }
-
-    // resolve all promises
-    Promise.all(uploads)
-      .then(function(resData) {
-        callback(null, resData);
-      })
-      .catch(function(err) {
-        log.error("uploadAttachment", err);
-        return callback(err);
+function getFrom(html, a, b) {
+  const i = html.indexOf(a);
+  if (i < 0) return;
+  const start = i + a.length;
+  const j = html.indexOf(b, start);
+  return j < 0 ? undefined : html.slice(start, j);
+}
+
+function respFinalUrl(res) {
+  return (res && (res.url || res.requestUrl)) || "";
+}
+
+function detectCheckpoint(res) {
+  const url = String(respFinalUrl(res) || "");
+  const body = typeof res?.body === "string" ? res.body : "";
+  const hit =
+    /\/checkpoint\//i.test(url) ||
+    /(?:href|action)\s*=\s*["']https?:\/\/[^"']*\/checkpoint\//i.test(body) ||
+    /"checkpoint"|checkpoint_title|checkpointMain|id="checkpoint"/i.test(body) ||
+    (/login\.php/i.test(url) && /checkpoint/i.test(body));
+  return { hit, url: url || (body.match(/https?:\/\/[^"']*\/checkpoint\/[^"'<>]*/i)?.[0] || "") };
+}
+
+function checkpointError(res) {
+  const d = detectCheckpoint(res);
+  if (!d.hit) return null;
+  const e = new Error("Checkpoint required");
+  e.code = "CHECKPOINT";
+  e.checkpoint = true;
+  e.url = d.url || "https://www.facebook.com/checkpoint/";
+  e.status = res?.statusCode || res?.status;
+  return e;
+}
+
+async function httpGet(pageUrl, ua, headers = {}) {
+  const host = new URL(pageUrl).hostname;
+  const referer = `https://${host}/`;
+  const baseHeaders = {
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language": "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Cache-Control": "max-age=0",
+    Connection: "keep-alive",
+    Host: host,
+    Origin: `https://${host}`,
+    Referer: referer,
+    "Sec-Ch-Prefers-Color-Scheme": "dark",
+    "Sec-Ch-Ua": '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+    "Sec-Ch-Ua-Full-Version-List": '"Google Chrome";v="143.0.7499.182", "Chromium";v="143.0.7499.182", "Not A(Brand";v="24.0.0.0"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Model": '""',
+    "Sec-Ch-Ua-Platform": '"Windows"',
+    "Sec-Ch-Ua-Platform-Version": '"19.0.0"',
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "same-origin",
+    "Sec-Fetch-User": "?1",
+    "Upgrade-Insecure-Requests": "1",
+    "User-Agent": ua || DEFAULT_UA,
+    "x-fb-rlafr": "0"
+  };
+  const res = await http.get(pageUrl, {
+    headers: { ...baseHeaders, ...headers },
+    timeout: 30000
+  });
+  const cp = checkpointError(res);
+  if (cp) throw cp;
+  return typeof res.data === "string" ? res.data : String(res.data || "");
+}
+
+async function getTokens(ua, forceRefresh = false) {
+  const now = Date.now();
+  if (!forceRefresh && tokenCache && (now - tokenCacheTime) < TOKEN_CACHE_TTL) {
+    return tokenCache;
+  }
+  try {
+    const html = await httpGet("https://www.facebook.com/", ua, { Referer: "https://www.facebook.com/" });
+    const fb_dtsg = getFrom(html, '"DTSGInitData",[],{"token":"', '",') || html.match(/name="fb_dtsg"\s+value="([^"]+)"/)?.[1] || "";
+    const jazoest = getFrom(html, 'name="jazoest" value="', '"') || getFrom(html, "jazoest=", '",') || html.match(/name="jazoest"\s+value="([^"]+)"/)?.[1] || "";
+    const lsd = getFrom(html, '["LSD",[],{"token":"', '"}') || html.match(/name="lsd"\s+value="([^"]+)"/)?.[1] || "";
+    const spin_r = pick(/"__spin_r":(\d+)/, html) || "";
+    const spin_t = pick(/"__spin_t":(\d+)/, html) || "";
+    const rev = pick(/"__rev":(\d+)/, html) || "";
+
+    if (!fb_dtsg || !lsd) {
+      // Cố gắng fallback nếu regex fail, nhưng thường là do cookie die
+      if (!tokenCache) throw new Error("Failed to fetch fb_dtsg or LSD from Facebook");
+    }
+
+    tokenCache = { lsd, fb_dtsg, jazoest, spin_r, spin_t, rev };
+    tokenCacheTime = now;
+    return tokenCache;
+  } catch (e) {
+    if (tokenCache) {
+      log.warn("[uploadAttachment] Token fetch failed, using cached tokens: " + (e.message || e));
+      return tokenCache;
+    }
+    throw e;
+  }
+}
+
+function getType(obj) { return Object.prototype.toString.call(obj).slice(8, -1); }
+function isReadableStream(obj) { return obj instanceof stream.Readable && (getType(obj._read) === "Function" || getType(obj._read) === "AsyncFunction") && getType(obj._readableState) === "Object"; }
+function fromBuffer(buf) { return stream.Readable.from(buf); }
+function parseDataUrl(s) { const m = /^data:([^;,]+)?(;base64)?,(.*)$/i.exec(s); if (!m) return null; const mime = m[1] || "application/octet-stream"; const isB64 = !!m[2]; const data = isB64 ? Buffer.from(m[3], "base64") : Buffer.from(decodeURIComponent(m[3]), "utf8"); return { mime, data }; }
+
+function filenameFromUrl(u, headers) {
+  try {
+    const urlObj = new URL(u);
+    let filename = path.basename(urlObj.pathname) || `file-${Date.now()}`;
+    const cd = headers && (headers["content-disposition"] || headers["Content-Disposition"]);
+    if (cd) {
+      const m = /filename\*?=(?:UTF-8''|")?([^";\n]+)/i.exec(cd);
+      if (m) filename = decodeURIComponent(m[1].replace(/"/g, ""));
+    }
+    return filename;
+  } catch {
+    return `file-${Date.now()}`;
+  }
+}
+
+async function normalizeOne(input, ua) {
+  if (!input) throw new Error("Invalid input");
+  if (Buffer.isBuffer(input)) return { stream: fromBuffer(input), filename: `file-${Date.now()}.bin`, contentType: "application/octet-stream" };
+  if (typeof input === "string") {
+    if (/^https?:\/\//i.test(input)) {
+      const resp = await http.get(input, {
+        headers: {
+          "User-Agent": ua,
+          Accept: "*/*",
+          "Accept-Encoding": "gzip, deflate, br",
+          "Cache-Control": "no-cache"
+        },
+        timeout: 30000,
+        responseType: "stream"
       });
+      const s = resp.data;
+      const filename = filenameFromUrl(input, resp.headers);
+      return { stream: s, filename };
+    }
+    if (input.startsWith("data:")) {
+      const p = parseDataUrl(input);
+      if (!p) throw new Error("Bad data URL");
+      return { stream: fromBuffer(p.data), filename: `file-${Date.now()}`, contentType: p.mime };
+    }
+    if (fs.existsSync(input) && fs.statSync(input).isFile()) {
+      return { stream: fs.createReadStream(input), filename: path.basename(input) };
+    }
+    throw new Error(`Unsupported string input: ${input}`);
+  }
+  if (isReadableStream(input)) {
+    return { stream: input, filename: `file-${Date.now()}` };
+  }
+  if (typeof input === "object") {
+    if (input.buffer && Buffer.isBuffer(input.buffer)) {
+      const filename = input.filename || `file-${Date.now()}.bin`;
+      const contentType = input.contentType || "application/octet-stream";
+      return { stream: fromBuffer(input.buffer), filename, contentType };
+    }
+    if (input.data && Buffer.isBuffer(input.data)) {
+      const filename = input.filename || `file-${Date.now()}.bin`;
+      const contentType = input.contentType || "application/octet-stream";
+      return { stream: fromBuffer(input.data), filename, contentType };
+    }
+    if (input.stream && isReadableStream(input.stream)) {
+      const filename = input.filename || `file-${Date.now()}`;
+      const contentType = input.contentType;
+      return { stream: input.stream, filename, contentType };
+    }
+    if (input.url) {
+      return normalizeOne(String(input.url), ua);
+    }
+    if (input.path && fs.existsSync(input.path) && fs.statSync(input.path).isFile()) {
+      return { stream: fs.createReadStream(input.path), filename: input.filename || path.basename(input.path), contentType: input.contentType };
+    }
   }
+  throw new Error("Unrecognized input");
+}
 
-  return function uploadAttachment(attachments, callback) {
-    if (
-      !attachments &&
-      !isReadableStream(attachments) &&
-      !getType(attachments) === "Array" &&
-      getType(attachments) === "Array" && !attachments.length
-    )
-      throw { error: "Please pass an attachment or an array of attachments." };
-
-    let resolveFunc = function() {};
-    let rejectFunc = function() {};
-    const returnPromise = new Promise(function(resolve, reject) {
+function mapAttachmentDetails(data) {
+  const out = [];
+  if (!data || typeof data !== "object") return out;
+
+  const stack = [data];
+  while (stack.length) {
+    const cur = stack.pop();
+    if (!cur || typeof cur !== "object") continue;
+    const id = cur.video_id || cur.image_id || cur.audio_id || cur.file_id || cur.fbid || cur.id || cur.upload_id || cur.gif_id;
+    const idKey =
+      cur.video_id ? "video_id" :
+        cur.image_id ? "image_id" :
+          cur.audio_id ? "audio_id" :
+            cur.file_id ? "file_id" :
+              cur.gif_id ? "gif_id" :
+                cur.fbid ? "fbid" :
+                  id ? "id" : null;
+    const filename = cur.filename || cur.file_name || cur.name || cur.original_filename;
+    const filetype = cur.filetype || cur.mime_type || cur.type || cur.content_type;
+    let thumbnail = cur.thumbnail_src || cur.thumbnail_url || cur.preview_url || cur.thumbSrc || cur.thumb_url || cur.image_preview_url || cur.large_preview_url;
+    if (!thumbnail) {
+      const m = cur.media || cur.thumbnail || cur.thumb || cur.image_data || cur.video_data || cur.preview;
+      thumbnail = m?.thumbnail_src || m?.thumbnail_url || m?.src || m?.uri || m?.url;
+    }
+    if (idKey) {
+      const o = {};
+      o[idKey] = id;
+      if (filename) o.filename = filename;
+      if (filetype) o.filetype = filetype;
+      if (thumbnail) o.thumbnail_src = thumbnail;
+      out.push(o);
+    }
+    if (Array.isArray(cur)) {
+      for (const v of cur) stack.push(v);
+    } else {
+      for (const k of Object.keys(cur)) stack.push(cur[k]);
+    }
+  }
+
+  if (!out.length && data.payload && Array.isArray(data.payload.metadata)) {
+    return data.payload.metadata.slice();
+  }
+
+  return out;
+}
+
+function pLimit(n) {
+  let active = 0;
+  const queue = [];
+  const next = () => {
+    active--;
+    if (queue.length) queue.shift()();
+  };
+  return fn => new Promise((resolve, reject) => {
+    const run = () => {
+      active++;
+      fn().then(v => { resolve(v); next(); }).catch(e => { reject(e); next(); });
+    };
+    if (active < n) run(); else queue.push(run);
+  });
+}
+
+// Hàm upload core xử lý request
+async function singleUpload(urlBase, file, ua, tokens, retries = 2) {
+  const form = new FormData();
+  // QUAN TRỌNG: Chỉ append file, KHÔNG append fb_dtsg vào body nữa
+  form.append("farr", file.stream, { filename: file.filename, contentType: file.contentType });
+
+  const headers = {
+    ...form.getHeaders(),
+    Accept: "*/*",
+    "Accept-Language": "vi,en-US;q=0.9,en;q=0.8,fr-FR;q=0.7,fr;q=0.6",
+    "Accept-Encoding": "gzip, deflate, br",
+    "User-Agent": ua,
+    "x-asbd-id": "359341",
+    "x-fb-lsd": tokens.lsd || "",
+    "x-fb-friendly-name": "MercuryUpload",
+    "x-fb-request-analytics-tags": JSON.stringify({
+      network_tags: {
+        product: "256002347743983",
+        purpose: "none",
+        request_category: "graphql",
+        retry_attempt: "0"
+      },
+      application_tags: "graphservice"
+    }),
+    "sec-ch-prefers-color-scheme": "dark",
+    "sec-ch-ua": '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    Origin: "https://www.facebook.com",
+    Referer: "https://www.facebook.com/",
+    "x-fb-rlafr": "0",
+    Connection: "keep-alive"
+  };
+
+  // Build URL với query string tokens
+  const finalUrl = new URL(urlBase);
+  finalUrl.searchParams.set("fb_dtsg", tokens.fb_dtsg);
+  finalUrl.searchParams.set("jazoest", tokens.jazoest);
+  finalUrl.searchParams.set("lsd", tokens.lsd);
+  finalUrl.searchParams.set("__aaid", "0");
+  finalUrl.searchParams.set("__ccg", "EXCELLENT");
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const res = await http.post(finalUrl.toString(), form, {
+        headers,
+        timeout: 120000,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      });
+      return res;
+    } catch (e) {
+      if (attempt === retries) throw e;
+      if (e.code === "ETIMEDOUT" || e.code === "ECONNRESET" || (e.response && e.response.status >= 500)) {
+        await new Promise(r => setTimeout(r, (attempt + 1) * 1000));
+        continue;
+      }
+      throw e;
+    }
+  }
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+  const ua = ctx?.options?.userAgent || DEFAULT_UA;
+  cookieJar = ctx.jar instanceof CookieJar ? ctx.jar : new CookieJar();
+
+  // Axios instance
+  http = wrapper(axios.create({
+    timeout: 60000,
+    headers: {
+      "User-Agent": ua,
+      "Accept-Language": "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7",
+      "Accept-Encoding": "gzip, deflate, br",
+      Connection: "keep-alive"
+    },
+    maxRedirects: 5,
+    validateStatus: () => true
+  }));
+  http.defaults.withCredentials = true;
+  http.defaults.jar = cookieJar;
+
+  async function uploadCore(link, opts, callback) {
+    if (typeof opts === "function") { callback = opts; opts = undefined; }
+    const options = {
+      concurrency: Math.max(1, Math.min(5, Number(opts?.concurrency || 3))),
+      mode: opts?.mode === "single" ? "single" : "parallel"
+    };
+
+    let resolveFunc = function () { };
+    let rejectFunc = function () { };
+    const returnPromise = new Promise(function (resolve, reject) {
       resolveFunc = resolve;
       rejectFunc = reject;
     });
-
     if (!callback) {
-      callback = function(err, info) {
-        if (err) {
-          return rejectFunc(err);
-        }
-        resolveFunc(info);
+      callback = function (err, data) {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
       };
     }
 
-    if (getType(attachments) !== "Array") attachments = [attachments];
+    (async () => {
+      try {
+        const inputsArr = Array.isArray(link) ? link : [link];
+        if (!inputsArr.length) {
+          const e = new Error("No files to upload");
+          callback(e);
+          return;
+        }
+
+        let tokens = await getTokens(ua);
+        const normAll = await Promise.all(inputsArr.map(x => normalizeOne(x, ua)));
+
+        // Base QS setup
+        const qs = [];
+        const userId = (ctx && (ctx.userID || ctx.userId)) ? String(ctx.userID || ctx.userId) : "";
+        if (userId) qs.push(`__user=${encodeURIComponent(userId)}`);
+        qs.push("__a=1");
+        qs.push("dpr=1");
+        const reqId = Math.floor(Math.random() * 36 ** 2).toString(36);
+        qs.push(`__req=${encodeURIComponent(reqId)}`);
+        if (tokens.spin_r) qs.push(`__spin_r=${encodeURIComponent(tokens.spin_r)}`);
+        if (tokens.spin_t) qs.push(`__spin_t=${encodeURIComponent(tokens.spin_t)}`);
+        if (tokens.rev) qs.push(`__rev=${encodeURIComponent(tokens.rev)}`);
+        qs.push("__spin_b=trunk");
+        qs.push("__comet_req=15");
 
-    upload(attachments, (err, info) => {
-      if (err) {
-        return callback(err);
+        const baseUrl = `https://www.facebook.com/ajax/mercury/upload.php?${qs.join("&")}`;
+
+        if (options.mode === "single") {
+          const f = normAll[0];
+          const res = await singleUpload(baseUrl, f, ua, tokens);
+
+          const cp = checkpointError(res);
+          if (cp) { tokenCache = null; throw cp; }
+
+          const data = cleanJSON(res.data);
+          const ids = mapAttachmentDetails(data);
+
+          if (!ids.length) {
+            const e = new Error("UploadFb returned no metadata/ids");
+            e.code = "NO_METADATA";
+            e.status = res.status;
+            e.body = typeof data === "string" ? data.slice(0, 500) : data;
+            throw e;
+          }
+          log.info(`[uploadAttachment] success ${ids.length} item(s) status ${res.status}`);
+          callback(null, { status: res.status, ids, raw: data });
+          return;
+        }
+
+        // Parallel mode
+        const limit = pLimit(options.concurrency);
+        const tasks = normAll.map(f => () => singleUpload(baseUrl, f, ua, tokens));
+        const results = await Promise.all(tasks.map(t => limit(t)));
+
+        const ids = [];
+        const errors = [];
+        for (let i = 0; i < results.length; i++) {
+          const res = results[i];
+          try {
+            const cp = checkpointError(res);
+            if (cp) { tokenCache = null; throw cp; }
+
+            const data = cleanJSON(res.data);
+            const fileIds = mapAttachmentDetails(data);
+            if (!fileIds.length) {
+              log.warn(`[uploadAttachment] File ${i + 1} returned no metadata/ids`);
+              continue;
+            }
+            ids.push(...fileIds);
+          } catch (e) {
+            errors.push({ index: i, error: e });
+            log.error(`[uploadAttachment] Upload ${i + 1} failed: ${e.message || e}`);
+          }
+        }
+
+        if (ids.length === 0 && errors.length > 0) {
+          throw errors[0].error;
+        }
+
+        log.info(`[uploadAttachment] success ${ids.length}/${normAll.length} item(s)`);
+        callback(null, { status: 200, ids, raw: null, errors: errors.length > 0 ? errors : undefined });
+      } catch (e) {
+        if (e.code === "CHECKPOINT" || (e.response && [401, 403].includes(e.response.status))) {
+          tokenCache = null;
+          try {
+            await getTokens(ua, true);
+            log.info("[uploadAttachment] Tokens refreshed after error");
+          } catch (refreshErr) {
+            log.error("[uploadAttachment] Token refresh failed: " + (refreshErr.message || refreshErr));
+          }
+        }
+        log.error(`[uploadAttachment] error ${e.code || e.status || ""} ${e.message || e}`);
+        callback(e);
       }
-      callback(null, info);
+    })().catch(err => {
+      log.error("[uploadAttachment] Unhandled promise rejection: " + (err.message || err));
+      rejectFunc(err);
     });
 
     return returnPromise;
+  }
+
+  return function uploadAttachment(attachments, callback) {
+    if (!attachments) throw { error: "Please pass an attachment or an array of attachments." };
+
+    if (typeof callback === "function") {
+      return uploadCore(attachments, { mode: "parallel" }, (err, result) => {
+        if (err) return callback(err);
+        callback(null, result && Array.isArray(result.ids) ? result.ids : []);
+      }).then(result => (result && Array.isArray(result.ids) ? result.ids : []));
+    }
+
+    return uploadCore(attachments, { mode: "parallel" }).then(result => result && Array.isArray(result.ids) ? result.ids : []);
   };
-};
+};