@dongdev/fca-unofficial 2.0.29 → 2.0.31

package/CHANGELOG.md

@@ -122,3 +122,9 @@ Too lazy to write changelog, sorry! (will write changelog in the next release, t
 
 ## v2.0.28 - 2025-10-18
 - Hotfix / auto bump
+
+## v2.0.29 - 2025-10-19
+- Hotfix / auto bump
+
+## v2.0.30 - 2025-10-19
+- Hotfix / auto bump

package/func/checkUpdate.js

@@ -1,147 +1,120 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const https = require('https');
-const { spawn } = require('child_process');
-
-const PACKAGE_NAME = 'fca-unofficial';
-// Không thử cài đặt lại trong vòng 10 phút sau lần update gần nhất
-const LOCK_TTL_MS = 10 * 60 * 1000;
-// Không check quá 1 lần mỗi 12 giờ
-const CHECK_TTL_MS = 12 * 60 * 60 * 1000;
-
-const lockPath = path.join(os.tmpdir(), 'fca-unofficial-update.lock');
-const statePath = path.join(os.tmpdir(), 'fca-unofficial-update-state.json');
-
-function readJSON(p) {
-  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
-}
-function writeJSON(p, obj) {
-  try { fs.writeFileSync(p, JSON.stringify(obj)); } catch { }
+// func/checkUpdate.js
+const logger = require("./logger");
+const fs = require("fs");
+const path = require("path");
+const { exec } = require("child_process");
+const pkgName = "@dongdev/fca-unofficial";
+
+const TEMP_DIR = path.join(process.cwd(), "temp");
+const LOCK_FILE = path.join(TEMP_DIR, ".fca-update-lock.json");
+const RESTART_COOLDOWN_MS = 10 * 60 * 1000;
+
+function execPromise(cmd) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, { cwd: process.cwd() }, (error, stdout, stderr) => {
+      if (error) return reject({ error, stderr });
+      resolve({ stdout, stderr });
+    });
+  });
 }
 
-function isLockFresh() {
-  try {
-    const st = fs.statSync(lockPath);
-    return (Date.now() - st.mtimeMs) < LOCK_TTL_MS;
-  } catch { return false; }
-}
-function acquireLock() {
-  if (isLockFresh()) return false;
-  try { fs.writeFileSync(lockPath, String(Date.now())); return true; } catch { return false; }
-}
-function releaseLock() {
-  try { fs.unlinkSync(lockPath); } catch { }
+function ensureTemp() {
+  try { fs.mkdirSync(TEMP_DIR, { recursive: true }); } catch { }
 }
 
-function semverCompare(a, b) {
-  const pa = String(a).replace(/^v/, '').split('.').map(n => parseInt(n || 0, 10));
-  const pb = String(b).replace(/^v/, '').split('.').map(n => parseInt(n || 0, 10));
-  for (let i = 0; i < 3; i++) {
-    const da = pa[i] || 0, db = pb[i] || 0;
-    if (da > db) return 1;
-    if (da < db) return -1;
-  }
-  return 0;
+function readLock() {
+  try { return JSON.parse(fs.readFileSync(LOCK_FILE, "utf8")); } catch { return null; }
 }
 
-function getLatestVersion(pkgName) {
-  return new Promise((resolve, reject) => {
-    const url = `https://registry.npmjs.org/${encodeURIComponent(pkgName)}/latest`;
-    https.get(url, res => {
-      let d = '';
-      res.setEncoding('utf8');
-      res.on('data', c => d += c);
-      res.on('end', () => {
-        try {
-          const j = JSON.parse(d);
-          resolve(j.version || null);
-        } catch (e) { reject(e); }
-      });
-    }).on('error', reject);
-  });
+function writeLock(data) {
+  ensureTemp();
+  try { fs.writeFileSync(LOCK_FILE, JSON.stringify(data)); } catch { }
 }
 
-function runNpmInstallLatest(pkgName, cwd) {
-  return new Promise((resolve, reject) => {
-    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    const child = spawn(bin, ['i', `${pkgName}@latest`], {
-      cwd,
-      stdio: 'inherit',
-      env: process.env
-    });
-    child.on('exit', code => {
-      if (code === 0) resolve();
-      else reject(new Error(`npm install exited with ${code}`));
-    });
-    child.on('error', reject);
-  });
+function clearLock() {
+  try { fs.unlinkSync(LOCK_FILE); } catch { }
 }
 
-// options: { cwd, pkg, restart }
-async function checkUpdate(options = {}) {
-  if (global.__FCA_UPDATE_CHECKED__) return;
-  global.__FCA_UPDATE_CHECKED__ = true;
-
-  const pkg = options.pkg || PACKAGE_NAME;
-  const cwd = options.cwd || process.cwd();
-  const shouldRestart = options.restart !== false;
-
-  // Giới hạn tần suất check
-  const state = readJSON(statePath) || {};
-  const now = Date.now();
-  if (state.lastCheck && now - state.lastCheck < CHECK_TTL_MS) return;
-  state.lastCheck = now;
-  writeJSON(statePath, state);
-
-  // Đọc version hiện tại
-  let currentVersion = null;
-  const installedPkgJson = path.join(cwd, 'node_modules', pkg, 'package.json');
-  const rootPkgJson = path.join(cwd, 'package.json');
-
-  const installed = readJSON(installedPkgJson);
-  if (installed && installed.version) {
-    currentVersion = installed.version;
-  } else {
-    // fallback: nếu lib đang là chính dự án
-    const root = readJSON(rootPkgJson);
-    if (root && root.name === pkg && root.version) {
-      currentVersion = root.version;
-    }
+function getInstalledVersion() {
+  try {
+    const p = require.resolve(`${pkgName}/package.json`, { paths: [process.cwd(), __dirname] });
+    return JSON.parse(fs.readFileSync(p, "utf8")).version;
+  } catch {
+    return null;
   }
-  if (!currentVersion) return; // Không xác định được version hiện tại => bỏ
+}
 
-  let latestVersion = null;
+async function getInstalledVersionByNpm() {
   try {
-    latestVersion = await getLatestVersion(pkg);
+    const { stdout } = await execPromise(`npm ls ${pkgName} --json --depth=0`);
+    const json = JSON.parse(stdout || "{}");
+    const v = json?.dependencies?.[pkgName]?.version;
+    return v || null;
   } catch {
-    return; // network lỗi => bỏ qua, tránh spam
+    return null;
   }
-  if (!latestVersion) return;
+}
+
+async function _checkAndUpdateVersionImpl() {
+  const lock = readLock();
+  if (lock && Date.now() - (lock.ts || 0) < RESTART_COOLDOWN_MS) {
+    logger("Skip auto-update due to recent attempt", "info");
+    return;
+  }
+
+  logger("Checking version...", "info");
+  const latest = (await execPromise(`npm view ${pkgName} version`)).stdout.trim();
 
-  // Nếu đã mới nhất => thôi
-  if (semverCompare(currentVersion, latestVersion) >= 0) return;
+  let installed = getInstalledVersion();
+  if (!installed) installed = await getInstalledVersionByNpm();
+
+  if (installed && installed === latest) {
+    clearLock();
+    logger(`You're already on the latest version - ${latest}`, "info");
+    return;
+  }
+
+  if (lock && lock.latest === latest && Date.now() - (lock.ts || 0) < RESTART_COOLDOWN_MS) {
+    logger("Update already attempted recently, skipping restart loop", "info");
+    return;
+  }
 
-  // Đã có lock mới => bỏ để tránh loop
-  if (!acquireLock()) return;
+  logger(`New version available (${latest}). Current version (${installed || "not installed"}). Updating...`, "info");
 
   try {
-    await runNpmInstallLatest(pkg, cwd);
-
-    // Sau khi cài xong, chỉ restart đúng 1 lần
-    if (shouldRestart) {
-      if (global.__FCA_RESTARTING__) return;
-      global.__FCA_RESTARTING__ = true;
-      // Dùng exit code riêng để process manager có thể phân biệt
-      setTimeout(() => process.exit(222), 300);
-    }
+    const { stderr } = await execPromise(`npm i ${pkgName}@latest`);
+    if (stderr) logger(stderr, "error");
   } catch (e) {
-    // Không restart khi cài thất bại để tránh loop
-  } finally {
-    // Không xóa lock ngay để tránh ngay-lập-tức retry sau restart
-    // Lock TTL sẽ tự hết hạn
-    // releaseLock(); // cố tình KHÔNG gọi
+    logger(`Error running npm install: ${e.error || e}. Trying to install from GitHub...`, "error");
+    try {
+      const { stderr } = await execPromise("npm i https://github.com/Donix-VN/fca-unofficial");
+      if (stderr) logger(stderr, "error");
+    } catch (gitErr) {
+      writeLock({ ts: Date.now(), latest, status: "failed" });
+      logger(`Error installing from GitHub: ${gitErr.error || gitErr}`, "error");
+      throw (gitErr.error || gitErr);
+    }
+  }
+
+  let after = getInstalledVersion();
+  if (!after) after = await getInstalledVersionByNpm();
+
+  if (after && after === latest) {
+    writeLock({ ts: Date.now(), latest, status: "updated" });
+    logger(`Updated fca to the latest version: ${latest}, Restart to apply`, "info");
+    process.exit(1);
+  } else {
+    writeLock({ ts: Date.now(), latest, status: "mismatch" });
+    logger(`Installed but version mismatch (have: ${after || "unknown"}, want: ${latest}). Skip restart to avoid loop`, "error");
+  }
+}
+
+function checkAndUpdateVersion(callback) {
+  if (typeof callback === "function") {
+    _checkAndUpdateVersionImpl().then(() => callback(null)).catch(err => callback(err));
+    return;
   }
+  return _checkAndUpdateVersionImpl();
 }
 
-module.exports = checkUpdate;
+module.exports = { checkAndUpdateVersion };

package/package.json

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

package/src/api/action/refreshFb_dtsg.js

@@ -3,67 +3,44 @@
 const log = require("npmlog");
 const { getFrom } = require("../../utils/constants");
 const { get } = require("../../utils/request")
-module.exports = function(defaultFuncs, api, ctx) {
+const { getType } = require("../../utils/format");
+module.exports = function (defaultFuncs, api, ctx) {
   return function refreshFb_dtsg(obj, callback) {
-    let resolveFunc, rejectFunc;
-    const returnPromise = new Promise((resolve, reject) => {
-      resolveFunc = resolve;
-      rejectFunc = reject;
-    });
-    if (
-      getType(obj) === "Function" ||
-      getType(obj) === "AsyncFunction"
-    ) {
+    if (typeof obj === "function") {
       callback = obj;
       obj = {};
     }
     if (!obj) obj = {};
     if (getType(obj) !== "Object") {
-      throw Error(
-        "The first parameter must be an object or a callback function"
-      );
+      throw new CustomError("The first parameter must be an object or a callback function");
     }
+    let resolveFunc, rejectFunc;
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
     if (!callback) {
-      callback = (err, data) => (err ? rejectFunc(err) : resolveFunc(data));
+      callback = (err, data) => err ? rejectFunc(err) : resolveFunc(data);
     }
     if (Object.keys(obj).length === 0) {
-      get(
-        "https://www.facebook.com/",
-        ctx.jar,
-        null,
-        ctx.globalOptions,
-        {
-          noRef: true
-        }
-      )
-        .then(resData => {
-          const fb_dtsg = getFrom(
-            resData.body,
-            '["DTSGInitData",[],{"token":"',
-            '","'
-          );
-          const jazoest = getFrom(resData.body, "jazoest=", '",');
-          if (!fb_dtsg) {
-            throw Error(
-              "Could not find fb_dtsg in HTML after requesting Facebook."
-            );
-          }
-          ctx.fb_dtsg = fb_dtsg;
-          ctx.jazoest = jazoest;
-          callback(null, {
-            data: { fb_dtsg, jazoest },
-            message: "Refreshed fb_dtsg and jazoest"
-          });
-        })
-        .catch(err => {
-          log.error("refreshFb_dtsg", err);
-          callback(err);
+      get("https://www.facebook.com/", ctx.jar, null, ctx.globalOptions, { noRef: true }).then(({ data }) => {
+        const fb_dtsg = getFrom(data, '["DTSGInitData",[],{"token":"', '","');
+        const jazoest = getFrom(data, "jazoest=", '",');
+        if (!fb_dtsg) throw new Error("Could not find fb_dtsg in HTML after requesting Facebook.");
+        Object.assign(ctx, { fb_dtsg, jazoest });
+        callback(null, {
+          data: { fb_dtsg, jazoest },
+          message: "Refreshed fb_dtsg and jazoest",
         });
+      }).catch(err => {
+        console.error("refreshFb_dtsg", err);
+        callback(err);
+      });
     } else {
       Object.assign(ctx, obj);
       callback(null, {
         data: obj,
-        message: "Refreshed " + Object.keys(obj).join(", ")
+        message: `Refreshed ${Object.keys(obj).join(", ")}`,
       });
     }
     return returnPromise;