channel-worker 2.5.137 → 2.5.139

package/bin/cli.js

@@ -285,6 +285,93 @@ if (cmd === 'pair') {
     }
   }
 
+} else if (cmd === 'drain') {
+  // Tắt NHẸ: daemon ngừng nhận việc mới, chờ việc đang chạy xong rồi tự tắt.
+  // Dùng thay `taskkill /f` / `stop` khi phát hành — xem lib/drain.js (soát
+  // 23/09/2026: 9/9 phiên nuôi "Timed out" còn log là bị giết giữa phiên lúc
+  // thay bản). Mã thoát: 0 = daemon đã tắt sạch (hoặc không có daemon);
+  // 2 = hết hạn, daemon QUAY LẠI làm việc, người quyết định dừng cứng hay chờ;
+  // 3 = daemon cũ tắt nhưng đã có daemon MỚI giữ khoá (watchdog/updater bật lại).
+  const singleton = require('../lib/singleton');
+  const drain = require('../lib/drain');
+  const lock = singleton.readLock(CONFIG_DIR);
+  if (args.cancel) {
+    drain.clearRequest(CONFIG_DIR);
+    console.log('[channel-worker] Đã huỷ yêu cầu xả — daemon nhận việc lại ở nhịp kế (≤5s).');
+    process.exit(0);
+  }
+  if (!lock || singleton.isStale(lock)) {
+    drain.clearRequest(CONFIG_DIR);
+    console.log(`[channel-worker] Không có daemon nào đang sống ở ${CONFIG_DIR} — không có gì để xả.`);
+    process.exit(0);
+  }
+  const timeoutMin = Number(args.timeout || drain.DEFAULT_TIMEOUT_MIN);
+  if (!Number.isFinite(timeoutMin) || timeoutMin <= 0) {
+    console.error('[channel-worker] --timeout phải là số phút > 0');
+    process.exit(1);
+  }
+  const req = drain.writeRequest(CONFIG_DIR, { timeoutMin });
+  console.log(`[channel-worker] Đã gửi yêu cầu xả tới daemon PID ${lock.pid} (hạn ${req.deadline_at}).`);
+  if (process.platform === 'win32') {
+    console.log('[channel-worker] Nhớ: watchdog bật lại daemon sau ≤5 phút nếu chưa có C:\\agents\\watchdog.pause.');
+  }
+  if (lock.supervisor === 'pm2') {
+    console.log('[channel-worker] Daemon này chạy dưới pm2: xả xong nó tự tắt nhưng pm2 dựng lại ngay (lệnh sẽ trả mã 3). '
+      + 'Trên máy pm2 cứ để bộ tự cập nhật lo — từ 2.5.139 nó tự xả trước khi cài.');
+  }
+  if (args['no-wait']) process.exit(0);
+
+  (async () => {
+    // Daemon soi yêu cầu mỗi 5s và tự quay lại làm việc khi hết hạn — chờ quá
+    // hạn thêm 30s là chắc chắn đã có kết cục.
+    const hardStop = Date.parse(req.deadline_at) + 30000;
+    let lastSay = 0;
+    let deadAt = 0;
+    for (;;) {
+      await new Promise((r) => setTimeout(r, 2000));
+      const cur = singleton.readLock(CONFIG_DIR);
+      const newHolder = cur && cur.pid !== lock.pid && !singleton.isStale(cur) ? cur : null;
+      if (!singleton.pidAlive(lock.pid)) {
+        // "Đã tắt" chỉ tin khi TIẾN TRÌNH chết thật — khoá nhả sớm hơn thế (tắt
+        // dở, hoặc bộ tự cập nhật nhả khoá rồi đẻ bản thay). Chết rồi thì soi
+        // thêm 2 nhịp: bản thay của updater giành khoá ngay sau đó, và báo
+        // "đã dừng" lúc ấy là để người phát hành cài đè lên cây một daemon MỚI
+        // đang nạp (đúng loại sự cố MODULE_NOT_FOUND 08/09).
+        if (newHolder) {
+          console.error(`[channel-worker] Daemon PID ${lock.pid} đã tắt, nhưng daemon MỚI PID ${newHolder.pid} đang giữ khoá `
+            + `(${newHolder.supervisor === 'pm2' ? 'pm2 dựng lại' : 'watchdog hoặc bộ tự cập nhật vừa bật lại'}) — chưa phải trạng thái "đã dừng".`);
+          process.exit(3);
+        }
+        if (!deadAt) deadAt = Date.now();
+        if (Date.now() - deadAt >= 4000) {
+          console.log(`[channel-worker] Xả xong — daemon PID ${lock.pid} đã tự tắt, không cắt việc nào.`);
+          process.exit(0);
+        }
+        continue;
+      }
+      if (Date.now() > hardStop) {
+        console.error(`[channel-worker] Quá hạn mà daemon PID ${lock.pid} vẫn sống `
+          + `(${cur && cur.pid === lock.pid ? 'vẫn giữ khoá — bản daemon cũ chưa biết lệnh drain?' : 'đã nhả khoá nhưng chưa thoát'}). `
+          + 'Kiểm "channel-worker logs".');
+        process.exit(2);
+      }
+      // Khoá đã nhả / sang tay khác mà tiến trình cũ còn sống = đang tắt dở →
+      // chờ nó thoát hẳn.
+      if (!cur || cur.pid !== lock.pid) continue;
+      const status = drain.readStatus(CONFIG_DIR);
+      if (!drain.readRequest(CONFIG_DIR)) {
+        console.error('[channel-worker] Daemon đã THÔI XẢ và quay lại làm việc (hết hạn hoặc bị huỷ). '
+          + `Việc còn dở lúc đó: ${drain.describeBusy(status && status.busy)}. `
+          + 'Chờ thêm: chạy lại "channel-worker drain". Chấp nhận cắt: "channel-worker stop".');
+        process.exit(2);
+      }
+      if (Date.now() - lastSay >= 30000) {
+        lastSay = Date.now();
+        console.log(`[channel-worker] … đang chờ: ${status ? drain.describeBusy(status.busy) : 'daemon chưa nhận yêu cầu (nhịp 5s)'}`);
+      }
+    }
+  })();
+
 } else if (cmd === 'logs') {
   const LOG_FILE = path.join(CONFIG_DIR, 'daemon.log');
   if (!fs.existsSync(LOG_FILE)) {
@@ -337,7 +424,9 @@ Commands:
   pair     Pair with dashboard using a one-time code (recommended)
   init     Configure worker manually
   start    Start the daemon in background
-  stop     Stop the daemon
+  stop     Stop the daemon (cắt ngang việc đang chạy)
+  drain    Xả: ngừng nhận việc mới, chờ việc đang chạy xong rồi tự tắt
+           (--timeout <phút>, mặc định 25 · --no-wait · --cancel)
   restart  Restart the daemon
   logs     Show recent daemon logs (--lines <n>, default 50)
   update   Check and install updates manually

package/lib/command-poller.js

@@ -21,6 +21,17 @@ class CommandPoller {
     this.timer = null;
     this.pollIntervalMs = 3000;
     this.nst = null;
+    // XẢ (lib/drain.js): tạm ngừng NHẬN việc mới, việc đang chạy vẫn chạy tiếp.
+    this._paused = false;
+    // Mọi lệnh đang xử lý, MỌI loại (không riêng _pw): id → type. poll() chạy
+    // theo setInterval, không chờ lệnh trước xong, nên một phiên nuôi 15 phút
+    // chạy song song với vài lượt lấy số liệu — daemon cần sổ này để biết lúc
+    // nào hết việc thật.
+    this._handling = new Map();
+    // Lượt poll đang bay (đã gửi GET /workers/commands, chưa về). API lật lệnh
+    // pending→running NGAY lúc trả về, nên một lượt đang bay lúc daemon quyết
+    // "rảnh rồi, tắt" sẽ mang về một lệnh đã bị nhận — tắt lúc đó là giết nó.
+    this._pollsInFlight = 0;
 
     // Init Nstbrowser if API key available
     if (config.nst_api_key) {
@@ -69,10 +80,25 @@ class CommandPoller {
     if (this._profileTimeoutTimer) { clearInterval(this._profileTimeoutTimer); this._profileTimeoutTimer = null; }
   }
 
+  // Không dừng timer: đồng bộ profile và đóng profile rảnh vẫn phải chạy trong
+  // lúc xả, chỉ riêng việc NHẬN lệnh / phát cảnh là ngừng.
+  pauseClaims() { this._paused = true; }
+  resumeClaims() { this._paused = false; }
+
   async poll() {
+    if (this._paused) return;
+    let command = null;
+    this._pollsInFlight++;
     try {
-      const command = await this.api.getNextCommand(this.config.worker_id);
+      try {
+        command = await this.api.getNextCommand(this.config.worker_id);
+      } finally {
+        this._pollsInFlight--;
+      }
       if (!command) return;
+      // Lượt poll đã gửi đi TRƯỚC lúc xả vẫn có thể nhận về một lệnh — nó được
+      // ghi sổ như mọi lệnh khác, và daemon chờ nó xong mới tắt.
+      this._handling.set(String(command._id), command.type);
 
       console.log(`[commands] Received: ${command.type} (${command._id})`);
 
@@ -146,6 +172,8 @@ class CommandPoller {
       if (this.config.verbose) {
         console.error(`[commands] Poll error: ${err.message}`);
       }
+    } finally {
+      if (command) this._handling.delete(String(command._id));
     }
   }
 
@@ -388,8 +416,29 @@ class CommandPoller {
         return;
       }
 
+      // Danh sách page đã liên kết với tài khoản Shopee — đi CHUNG lượt này vì
+      // nó dùng đúng phiên vừa mở, thêm một request chứ không thêm lần mở
+      // profile. LỖI MỀM: đọc hỏng thì mất phần cảnh báo liên kết, không được
+      // kéo theo cả lượt đồng bộ click/đơn (đó mới là việc chính).
+      let mediaAccounts = null;
+      let mediaError = null;
+      try {
+        const media = await report.fetchSocialMediaAccounts(conn.context, {
+          log: (message) => console.log(message),
+        });
+        if (media.status === 'ok') mediaAccounts = media.accounts;
+        else mediaError = media.reason || media.status;
+      } catch (err) {
+        mediaError = String(err.message || err).slice(0, 200);
+      }
+      if (mediaError) console.warn(`[shopee-report] không đọc được danh sách liên kết: ${mediaError}`);
+
       const saved = await this.api.affiliateReportResult(result.rows, {
         clicks: clickResult.rows,
+        // `null` = KHÔNG đọc được, khác hẳn `[]` = đọc được và tài khoản chưa
+        // liên kết page nào. API phải phân biệt để không xoá sạch bản ghi cũ
+        // chỉ vì một lượt đọc hỏng.
+        media_accounts: mediaAccounts,
         last_report_date: result.last_report_date,
         last_update_time: result.last_update_time,
         from: result.from,
@@ -406,6 +455,8 @@ class CommandPoller {
           click_saved: saved?.click_saved || 0,
           click_matched: saved?.click_matched || 0,
           click_unmatched: saved?.click_unmatched || 0,
+          media_accounts: mediaAccounts ? mediaAccounts.length : null,
+          media_error: mediaError || undefined,
           last_report_date: result.last_report_date,
         },
       });
@@ -1837,7 +1888,7 @@ class CommandPoller {
   // Processes ONE command per cycle — sequential, no race conditions.
 
   async _dispatchScenes() {
-    if (this._dispatching) return;
+    if (this._paused || this._dispatching) return;
     this._dispatching = true;
     try {
       // 1. Init Nstbrowser if needed
@@ -2247,7 +2298,7 @@ class CommandPoller {
   // generate_thumbnail command is pending, so Veo3 renderers stay untouched.
 
   async _dispatchChatgpt() {
-    if (this._chatgptDispatching) return;
+    if (this._paused || this._chatgptDispatching) return;
     this._chatgptDispatching = true;
     try {
       // Lazy-init NstManager — the daemon config often ships with an empty

package/lib/daemon.js

@@ -7,9 +7,19 @@ const { checkAndUpdateExtension } = require('./extension-updater');
 const { CacheServer } = require('./cache-server');
 const { agentAddressForUser } = require('./nst-agent-locator');
 const singleton = require('./singleton');
+const drain = require('./drain');
 const os = require('os');
 const path = require('path');
 
+// Bộ tự cập nhật thấy bản mới mà đang bận → xả tối đa ngần này rồi cài luôn.
+// Quá hạn mà còn việc = việc dài bất thường; cài luôn còn hơn kẹt mãi bản cũ.
+const UPDATE_DRAIN_MS = drain.DEFAULT_TIMEOUT_MIN * 60e3;
+// Lượt cài sau khi xả mà hỏng (registry chưa công bố tarball, cây cài cụt…)
+// thì chờ ngần này mới được xả lại để cập nhật. Không có nó, máy bận cứ quay
+// vòng: xả → cài hỏng → nhận việc 10 giây → xả tiếp — tệ hơn bản trước, vốn
+// cứ làm việc bình thường và thử lại 5 phút một lần.
+const UPDATE_RETRY_MS = 15 * 60e3;
+
 class Daemon {
   constructor(config) {
     this.config = config;
@@ -30,20 +40,45 @@ class Daemon {
     // Pass daemon URL down so command-poller can write it into per-profile config
     config.daemon_url = this.cacheServer.url();
     this.commandPoller = new CommandPoller(this.api, config);
-    this.updateChecker = new UpdateChecker(5 * 60 * 1000); // check every 5min
+    // Có bản mới mà đang bận thì KHÔNG khởi động lại ngang — xả trước (xem
+    // _tickDrain), rảnh rồi mới cài.
+    this.updateChecker = new UpdateChecker(5 * 60 * 1000, {
+      isBusy: () => this._isBusy(),
+      onDeferred: (r) => this._onUpdateDeferred(r),
+    });
+    this._updateRetryAt = 0;
     this.extCheckTimer = null;
     this.nstAgentTimer = null;
     this.lockTimer = null;
+    this.drainTimer = null;
     this.configDir = path.join(os.homedir(), '.channel-worker');
     this._evictLogged = false;
+    // Yêu cầu xả ghi trước mốc này là của đời daemon trước — xem drain.isForMe.
+    this.startedAt = Date.now();
+    this._drain = null;          // { reason: 'cli'|'update', since, deadline, latest }
+    this._drainFinishing = false;
   }
 
-  /** Đang bận = có job đang chạy, hoặc có phiên Playwright đang giữ profile. */
+  /**
+   * Đang bận = có job đang chạy, có phiên Playwright đang giữ profile, hoặc có
+   * lệnh nào đang xử lý dở (mọi loại — sổ _handling của command poller).
+   */
   _isBusy() {
+    const b = this._busyDetail();
+    return b.jobs > 0 || b.pw > 0 || b.commands.length > 0 || b.polls > 0;
+  }
+
+  _busyDetail() {
     const jobs = (this.poller && this.poller.running) ? this.poller.running.size : 0;
     const pw = (this.commandPoller && this.commandPoller._pwInFlight)
       ? this.commandPoller._pwInFlight.size : 0;
-    return jobs > 0 || pw > 0;
+    const commands = (this.commandPoller && this.commandPoller._handling)
+      ? [...this.commandPoller._handling.values()] : [];
+    // Lượt hỏi việc đang bay: API nhận lệnh/job ngay lúc trả về, tắt lúc này là
+    // giết một việc vừa bị nhận (xem CommandPoller._pollsInFlight).
+    const polls = ((this.commandPoller && this.commandPoller._pollsInFlight) || 0)
+      + ((this.poller && this.poller.pollsInFlight) || 0);
+    return { jobs, pw, commands, polls };
   }
 
   /**
@@ -76,6 +111,158 @@ class Daemon {
     else process.exit(0);
   }
 
+  // ─── XẢ: ngừng nhận việc mới, chờ việc đang chạy xong rồi mới tắt ──────────
+  // Hai đường vào:
+  //   'cli'    — người phát hành chạy `channel-worker drain` (ghi drain.request).
+  //              Xả xong thì TẮT. Hết hạn mà còn việc thì QUAY LẠI làm việc —
+  //              người quyết định dừng cứng hay chờ thêm, đàn không bao giờ đứng
+  //              im chỉ vì một lệnh xả bị bỏ quên.
+  //   'update' — bộ tự cập nhật thấy bản mới mà đang bận. Xả xong thì cài +
+  //              khởi động lại. Hết hạn thì cài luôn (cắt việc dài bất thường).
+  // Trong lúc xả: heartbeat, nhịp khoá, đồng bộ/đóng profile rảnh vẫn chạy;
+  // chỉ ngừng nhận lệnh, nhận job, phát cảnh, và tắt bộ tự cập nhật (một lượt
+  // cài + khởi động lại lọt vào giữa là cắt đúng việc đang chờ).
+  _enterDrain({ reason, deadline, latest = null }) {
+    if (this._drain) return;
+    this._drain = { reason, since: Date.now(), deadline, latest };
+    if (this.commandPoller.pauseClaims) this.commandPoller.pauseClaims();
+    if (this.poller.pause) this.poller.pause();
+    this.updateChecker.stop();
+    const why = reason === 'update' ? `để cập nhật lên ${latest}` : 'theo lệnh "channel-worker drain"';
+    console.log(`[daemon] XẢ ${why}: ngừng nhận việc mới, chờ ${drain.describeBusy(this._busyDetail())} `
+      + `— hạn ${new Date(deadline).toISOString()}`);
+    this._writeDrainStatus();
+  }
+
+  _resumeFromDrain(why) {
+    console.warn(`[daemon] Thôi xả (${why}) — nhận việc lại bình thường.`);
+    const wasCli = !!this._drain && this._drain.reason === 'cli';
+    this._drain = null;
+    // Chỉ dọn yêu cầu khi đang xả VÌ nó (hết hạn / huỷ) — đó là tín hiệu cho lệnh
+    // drain đang chờ. Thôi xả để cập nhật mà xoá luôn là nuốt mất lệnh drain
+    // người phát hành vừa gửi giữa lúc npm đang cài; để nguyên thì nhịp sau
+    // nhận nó và xả để TẮT.
+    if (wasCli) drain.clearRequest(this.configDir);
+    drain.clearStatus(this.configDir);
+    if (this.commandPoller.resumeClaims) this.commandPoller.resumeClaims();
+    if (this.poller.resume) this.poller.resume();
+    // Không bật lại lượt kiểm 10 giây đầu: vừa thôi xả vì cài hỏng mà kiểm ngay
+    // là quay lại đúng vòng xả-cài-hỏng.
+    this.updateChecker.start({ initialDelay: false });
+  }
+
+  _onUpdateDeferred(r, now = Date.now()) {
+    if (now < this._updateRetryAt) return; // vừa cài hỏng — đợi, đừng xả lại liên tục
+    this._enterDrain({ reason: 'update', deadline: now + UPDATE_DRAIN_MS, latest: r.latest });
+  }
+
+  _writeDrainStatus() {
+    if (!this._drain) return;
+    drain.writeStatus(this.configDir, {
+      pid: process.pid,
+      reason: this._drain.reason,
+      since: new Date(this._drain.since).toISOString(),
+      deadline: new Date(this._drain.deadline).toISOString(),
+      busy: this._busyDetail(),
+    });
+  }
+
+  async _tickDrain(now = Date.now()) {
+    if (this._drainFinishing) return;
+    // Lệnh drain là cho CHỦ KHOÁ. Daemon thừa (mất khoá) đã tự tắt lúc rảnh ở
+    // _tickLock; để nó nghe lệnh là nó xả xong trước rồi xoá mất yêu cầu, chủ
+    // khoá đang xả dở thấy "bị huỷ" và quay lại nhận việc.
+    if (!singleton.owns(this.configDir)) return;
+    const req = drain.readRequest(this.configDir);
+    if (req && !drain.isForMe(req, this.startedAt)) {
+      console.log(`[daemon] Bỏ yêu cầu xả cũ (${req.requested_at}) — của daemon đời trước.`);
+      drain.clearRequest(this.configDir);
+    } else if (req && (!this._drain || this._drain.reason !== 'cli')) {
+      // Người phát hành thắng bộ tự cập nhật: họ muốn daemon TẮT, không muốn
+      // nó tự cài rồi bật lại ngay dưới tay họ.
+      if (this._drain) {
+        this._drain.reason = 'cli';
+        this._drain.deadline = Date.parse(req.deadline_at);
+        console.log('[daemon] Lệnh drain đến giữa lúc xả để cập nhật — chuyển sang xả để TẮT.');
+      } else {
+        this._enterDrain({ reason: 'cli', deadline: Date.parse(req.deadline_at) });
+      }
+    } else if (!req && this._drain && this._drain.reason === 'cli') {
+      this._resumeFromDrain('yêu cầu xả đã bị huỷ');
+      return;
+    }
+    if (!this._drain) return;
+
+    this._writeDrainStatus();
+    if (!this._isBusy()) {
+      await this._finishDrain();
+      return;
+    }
+    if (now > this._drain.deadline) {
+      const left = drain.describeBusy(this._busyDetail());
+      if (this._drain.reason === 'update') {
+        console.warn(`[daemon] Hết hạn xả mà vẫn còn ${left} — cài bản mới luôn, việc đó sẽ bị cắt.`);
+        await this._finishDrain();
+      } else {
+        this._resumeFromDrain(`hết hạn xả, vẫn còn ${left}`);
+      }
+    }
+  }
+
+  async _finishDrain() {
+    this._drainFinishing = true;
+    try {
+      if (this._drain.reason === 'update') {
+        console.log('[daemon] Xả xong — cài bản mới rồi khởi động lại.');
+        // Cài xong thì check() tự process.exit. Tới được dòng sau = KHÔNG khởi
+        // động lại (registry chưa công bố tarball, cây cài hỏng…) → làm tiếp.
+        const r = await this.updateChecker.check({ ignoreBusy: true });
+        this._updateRetryAt = Date.now() + UPDATE_RETRY_MS;
+        this._resumeFromDrain(`chưa cập nhật được${r && r.error ? `: ${r.error}` : ''}, `
+          + `${UPDATE_RETRY_MS / 60e3} phút nữa mới xả lại để cập nhật`);
+        return;
+      }
+      console.log('[daemon] Xả xong — không còn việc dở, tự tắt.');
+      // shutdown nhả khoá rồi mới dọn drain.request (xem ghi chú ở đó).
+      if (this._shutdown) await this._shutdown();
+      else process.exit(0);
+    } finally {
+      this._drainFinishing = false;
+    }
+  }
+
+  /** Dừng mọi nhịp, nhả khoá, dọn file xả, báo offline — mọi thứ trừ process.exit. */
+  async _teardown() {
+    this.heartbeat.stop();
+    this.poller.stop();
+    this.commandPoller.stop();
+    this.updateChecker.stop();
+    if (this.extCheckTimer) clearInterval(this.extCheckTimer);
+    if (this.nstAgentTimer) clearInterval(this.nstAgentTimer);
+    if (this.lockTimer) clearInterval(this.lockTimer);
+    if (this.drainTimer) clearInterval(this.drainTimer);
+    try { this.cacheServer.stop(); } catch {}
+    // Nhả khoá để con kế tiếp vào ngay, khỏi phải chờ hết hạn STALE.
+    let wasOwner = false;
+    try { wasOwner = singleton.release(this.configDir); } catch {}
+    // Dọn file xả SAU khi nhả khoá: lệnh drain đang chờ thấy khoá nhả trước
+    // → "xả xong"; ngược thứ tự nó thấy yêu cầu biến mất khi khoá còn đó và
+    // báo nhầm "daemon thôi xả". Chỉ dọn khi CHÍNH mình là chủ khoá đang xả —
+    // daemon thừa tự tắt (kể cả con từng xả dở trước khi bị `start --force`
+    // cướp khoá) mà xoá thì yêu cầu gửi cho chủ khoá MỚI biến mất giữa chừng.
+    if (wasOwner && this._drain) {
+      drain.clearRequest(this.configDir);
+      drain.clearStatus(this.configDir);
+    }
+
+    // Mark offline
+    try {
+      await this.api.request('PUT', `/workers/${this.config.worker_id}`, {
+        status: 'offline',
+      });
+    } catch { /* ignore */ }
+  }
+
   /**
    * Point NST_API_ADDRESS at the agent of the Windows user we're paired with.
    *
@@ -195,6 +382,14 @@ class Daemon {
     this.lockTimer = setInterval(() => { this._tickLock().catch(() => {}); }, singleton.REFRESH_MS);
     console.log(`[daemon] Singleton lock watcher started (every ${singleton.REFRESH_MS / 1000}s)`);
 
+    // Nhịp xả — soi drain.request (lệnh "channel-worker drain") và theo dõi
+    // việc dở trong lúc xả. Trạng thái xả của đời trước là rác, dọn luôn.
+    drain.clearStatus(this.configDir);
+    this.drainTimer = setInterval(() => {
+      this._tickDrain().catch((e) => console.warn(`[daemon] nhịp xả lỗi: ${e.message}`));
+    }, drain.TICK_MS);
+    console.log(`[daemon] Drain watcher started (every ${drain.TICK_MS / 1000}s)`);
+
     // Start auto-update checker
     this.updateChecker.start();
     console.log('[daemon] Auto-update checker started (every 5min)');
@@ -219,24 +414,7 @@ class Daemon {
     // Graceful shutdown
     const shutdown = async () => {
       console.log('\n[daemon] Shutting down...');
-      this.heartbeat.stop();
-      this.poller.stop();
-      this.commandPoller.stop();
-      this.updateChecker.stop();
-      if (this.extCheckTimer) clearInterval(this.extCheckTimer);
-      if (this.nstAgentTimer) clearInterval(this.nstAgentTimer);
-      if (this.lockTimer) clearInterval(this.lockTimer);
-      try { this.cacheServer.stop(); } catch {}
-      // Nhả khoá để con kế tiếp vào ngay, khỏi phải chờ hết hạn STALE.
-      try { singleton.release(this.configDir); } catch {}
-
-      // Mark offline
-      try {
-        await this.api.request('PUT', `/workers/${this.config.worker_id}`, {
-          status: 'offline',
-        });
-      } catch { /* ignore */ }
-
+      await this._teardown();
       console.log('[daemon] Goodbye.');
       process.exit(0);
     };

package/lib/drain.js

@@ -0,0 +1,93 @@
+/**
+ * XẢ daemon: ngừng nhận việc mới, chờ việc đang chạy xong rồi mới tắt.
+ *
+ * Vì sao có (soát 23/09/2026): phát hành worker tắt daemon bằng
+ * `taskkill /f /im node.exe`, còn bộ tự cập nhật thấy bản mới là cài + khởi
+ * động lại ngay — cả hai đều không nhìn việc đang chạy. 9/9 phiên nuôi FB
+ * "Timed out … crash giữa chừng" còn log đều là daemon bị thay bằng bản mới
+ * GIỮA phiên (31 bản trong 10 ngày), và cùng cơ chế đã cắt ngang lượt đăng bài
+ * (kenh-71 lúc 22:29 ngày 23/09, đang ở khung soạn Reel).
+ *
+ * Giao tiếp qua FILE trong CONFIG_DIR, không qua tín hiệu: trên Windows
+ * `process.kill(pid, 'SIGTERM')` là TerminateProcess — không có cách nào nhờ
+ * tiến trình khác "tắt nhẹ nhàng". Người phát hành chạy `channel-worker drain`,
+ * lệnh đó ghi `drain.request`; daemon soi file mỗi TICK_MS.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const REQUEST_FILE = 'drain.request';
+const STATUS_FILE = 'drain.status';
+// Phiên nuôi dài nhất đo được 18 phút, lượt đăng FB có thể chờ nút Đăng 10 phút
+// cộng các bước trước — 25 phút phủ cả hai mà không treo lượt phát hành cả buổi.
+const DEFAULT_TIMEOUT_MIN = 25;
+const TICK_MS = 5000;
+
+const requestPath = (dir) => path.join(dir, REQUEST_FILE);
+const statusPath = (dir) => path.join(dir, STATUS_FILE);
+
+function writeRequest(dir, { timeoutMin = DEFAULT_TIMEOUT_MIN, now = Date.now() } = {}) {
+  const req = {
+    requested_at: new Date(now).toISOString(),
+    deadline_at: new Date(now + timeoutMin * 60e3).toISOString(),
+    by_pid: process.pid,
+  };
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(requestPath(dir), JSON.stringify(req));
+  return req;
+}
+
+function readRequest(dir) {
+  try {
+    const req = JSON.parse(fs.readFileSync(requestPath(dir), 'utf-8'));
+    if (!req || !Number.isFinite(Date.parse(req.requested_at)) || !Number.isFinite(Date.parse(req.deadline_at))) return null;
+    return req;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Yêu cầu có phải cho daemon này không. Yêu cầu ghi TRƯỚC lúc daemon khởi
+ * động là rác của đời trước (daemon cũ chết trước khi kịp dọn) — nghe theo nó
+ * thì daemon mới vừa lên đã tự tắt, và watchdog bật lại vô tận.
+ */
+function isForMe(req, startedAt) {
+  return !!req && Date.parse(req.requested_at) >= startedAt;
+}
+
+function clearRequest(dir) {
+  try { fs.unlinkSync(requestPath(dir)); } catch { /* đã không có */ }
+}
+
+function writeStatus(dir, status) {
+  try {
+    fs.writeFileSync(statusPath(dir), JSON.stringify({ ...status, at: new Date().toISOString() }));
+  } catch { /* trạng thái chỉ để người xem, hỏng thì thôi */ }
+}
+
+function readStatus(dir) {
+  try { return JSON.parse(fs.readFileSync(statusPath(dir), 'utf-8')); } catch { return null; }
+}
+
+function clearStatus(dir) {
+  try { fs.unlinkSync(statusPath(dir)); } catch { /* đã không có */ }
+}
+
+/** "2 lệnh (nurture_facebook_pw, upload_facebook_pw) · 1 job" — cho log và lệnh drain. */
+function describeBusy(busy) {
+  if (!busy) return 'không rõ';
+  const parts = [];
+  const cmds = busy.commands || [];
+  if (cmds.length) parts.push(`${cmds.length} lệnh (${cmds.join(', ')})`);
+  if (busy.jobs) parts.push(`${busy.jobs} job`);
+  if (busy.polls) parts.push(`${busy.polls} lượt hỏi việc đang bay`);
+  return parts.length ? parts.join(' · ') : 'không còn việc';
+}
+
+module.exports = {
+  REQUEST_FILE, STATUS_FILE, DEFAULT_TIMEOUT_MIN, TICK_MS,
+  requestPath, statusPath, writeRequest, readRequest, isForMe, clearRequest,
+  writeStatus, readStatus, clearStatus, describeBusy,
+};

package/lib/job-poller.js

@@ -8,8 +8,14 @@ class JobPoller {
     this.running = new Set(); // job IDs currently executing
     this.timer = null;
     this.pollIntervalMs = 5000;
+    this.paused = false; // XẢ: ngừng nhận job mới, job đang chạy vẫn chạy tiếp
+    // Lượt hỏi/nhận job đang bay — xem CommandPoller._pollsInFlight.
+    this.pollsInFlight = 0;
   }
 
+  pause() { this.paused = true; }
+  resume() { this.paused = false; }
+
   start() {
     console.log(`[poller] Started — max concurrent: ${this.config.max_concurrent}`);
     this.poll(); // immediate first poll
@@ -28,8 +34,11 @@ class JobPoller {
   }
 
   async poll() {
-    if (this.availableSlots <= 0) return;
+    if (this.paused || this.availableSlots <= 0) return;
 
+    this.pollsInFlight++;
+    let inFlight = true;
+    const settle = () => { if (inFlight) { inFlight = false; this.pollsInFlight--; } };
     try {
       const job = await this.api.getNextJob(this.config.worker_id);
       if (!job) return; // no jobs in queue
@@ -39,7 +48,7 @@ class JobPoller {
 
       // Claim the job
       await this.api.claimJob(jobId, this.config.worker_id);
-      this.running.add(jobId);
+      this.running.add(jobId); // từ đây `running` giữ nó trong sổ bận (finally trả lượt bay)
 
       console.log(`[poller] Claimed job ${jobId} (${this.running.size}/${this.config.max_concurrent} slots used)`);
 
@@ -56,6 +65,8 @@ class JobPoller {
       if (this.config.verbose) {
         console.error(`[poller] Poll error: ${err.message}`);
       }
+    } finally {
+      settle();
     }
   }
 }

package/lib/shopee-report.js

@@ -183,4 +183,78 @@ async function fetchClickReport(ctx, {
   }
 }
 
-module.exports = { fetchConversionReport, fetchClickReport, reportWindow };
+// Danh sách tài khoản mạng xã hội ĐÃ LIÊN KẾT với tài khoản affiliate — cùng
+// thứ trang `account_setting` hiện ở tab "Media Information".
+//
+// KHÔNG mở account_setting và KHÔNG bấm tab: đo thật 22/09/2026 trên phiên
+// Shopee1, endpoint này trả đủ dữ liệu khi gọi từ MỘT tab affiliate bất kỳ
+// (thử từ /dashboard). Đi đường DOM thì phải mở thêm trang, bấm đúng nhãn
+// tiếng Anh "Media Information", và nhãn đó đổi theo ngôn ngữ giao diện.
+//
+// Mỗi dòng có `user_id` là ID Facebook THẬT của page (vd 1298751909986110) —
+// đúng con số nằm trong link `facebook.com/profile.php?id=…`. Nhờ vậy việc so
+// khớp với kênh của mình không phải parse URL, vốn có nhiều biến thể
+// (?referral_source=…, /<handle>/, m.facebook.com…).
+//
+// `platform`: 6 = Facebook, 3 = TikTok (đo được trên tài khoản thật; các mã
+// khác giữ nguyên số để sau này đọc lại, không đoán tên).
+const SM_PLATFORM = { 6: 'facebook', 3: 'tiktok' };
+
+async function fetchSocialMediaAccounts(ctx, { timeoutMs = 45000, log = null } = {}) {
+  let page = findAffiliatePage(ctx.pages());
+  let opened = false;
+  if (!page) {
+    page = await ctx.newPage();
+    opened = true;
+  }
+
+  try {
+    if (!page.url().includes('affiliate.shopee.vn/')) {
+      await page.goto('https://affiliate.shopee.vn/offer/product_offer', {
+        waitUntil: 'domcontentloaded', timeout: timeoutMs,
+      }).catch(() => {});
+      await sleep(1500);
+    }
+    if (isBlockedState(page.url(), null)) {
+      return { status: 'needs_verify', accounts: [], reason: 'session at captcha/login — re-verify via VNC' };
+    }
+
+    const result = await page.evaluate(async () => {
+      try {
+        const r = await fetch('/api/v3/affiliates/social_media_accounts', { credentials: 'include' });
+        return { status: r.status, json: await r.json().catch(() => null) };
+      } catch (e) {
+        return { status: 0, error: String(e?.message || e) };
+      }
+    });
+
+    if (isBlockedState(page.url(), result) || result.json?.code === 90309999) {
+      return { status: 'needs_verify', accounts: [], reason: `blocked while reading media info (http ${result.status}, code ${result.json?.code})` };
+    }
+    if (result.status !== 200 || result.json?.code !== 0) {
+      return { status: 'failed', accounts: [], reason: result.json?.msg || result.error || `media info HTTP ${result.status}` };
+    }
+
+    const list = Array.isArray(result.json?.data?.accounts) ? result.json.data.accounts : [];
+    const accounts = list.map((row) => ({
+      media_user_id: String(row.user_id || row.unique_id || '').trim(),
+      media_name: String(row.user_name || '').trim(),
+      website_url: String(row.website_url || '').trim(),
+      platform_code: Number(row.platform) || 0,
+      platform: SM_PLATFORM[Number(row.platform)] || 'other',
+      link_status: Number(row.link_status) || 0,
+      facebook_page_type: Number(row.facebook_page_type) || 0,
+      partner_link_status: Number(row.partner_link_status) || 0,
+      follower_number: Number(row.follower_number) || 0,
+      // Shopee trả giây, không phải mili-giây.
+      verification_time: Number(row.verification_time) || 0,
+    })).filter((a) => a.media_user_id || a.website_url);
+
+    if (log) log(`[shopee-report] media: ${accounts.length} tài khoản liên kết (${accounts.filter((a) => a.platform === 'facebook').length} Facebook)`);
+    return { status: 'ok', accounts };
+  } finally {
+    if (opened) await page.close().catch(() => {});
+  }
+}
+
+module.exports = { fetchConversionReport, fetchClickReport, fetchSocialMediaAccounts, reportWindow, SM_PLATFORM };

package/lib/singleton.js

@@ -70,6 +70,10 @@ function writeLock(configDir, info, { overwrite = false } = {}) {
     version: info.version || '',
     started_at: info.started_at || new Date().toISOString(),
     refreshed_at: new Date().toISOString(),
+    // Ai dựng lại daemon khi nó tắt: 'pm2' thì `channel-worker drain` biết
+    // trước là xả xong pm2 sẽ bật lại ngay (relabs03). Làm tươi khoá chép
+    // nguyên giá trị cũ; lần ghi đầu đọc từ môi trường của chính daemon.
+    supervisor: info.supervisor !== undefined ? info.supervisor : (process.env.pm_id !== undefined ? 'pm2' : ''),
   });
   // 'wx' = tạo mới, thất bại nếu đã có → chính là phép thử nguyên tử.
   const fd = fs.openSync(lockPath(configDir), overwrite ? 'w' : 'wx');

package/lib/updater.js

@@ -38,18 +38,26 @@ function restartBlocker() {
 // Quyết định THUẦN của một lượt kiểm (test được, không đụng đĩa/mạng):
 //   'none'         — đang chạy bản mới nhất
 //   'blocked'      — có bản mới nhưng không khởi động lại được → KHÔNG cài
+//   'deferred-busy'— có bản mới nhưng daemon đang có việc dở → CHƯA cài, CHƯA
+//                    khởi động lại; daemon chuyển sang XẢ rồi quay lại (drain.js)
 //   'restart-only' — bản mới đã có sẵn trên đĩa → chỉ kiểm + khởi động lại
 //   'install'      — cài rồi kiểm rồi khởi động lại
 //
+// Vì sao có 'deferred-busy' (soát 23/09/2026): khởi động lại = process.exit, và
+// mọi việc đang chạy chết theo — 9/9 phiên nuôi FB "Timed out … crash giữa
+// chừng" còn log là daemon bị thay bằng bản mới giữa phiên. Cài khi bận cũng
+// không được: npm xoá cây đang chạy trước khi ghi cây mới.
+//
 // Vì sao phải có 'blocked' và 'restart-only' (sự cố 17-19/09/2026, win-worker):
 // worker-1 được bật tay qua start-worker.bat nên restart luôn chết EBUSY. Bản cũ
 // so bản ĐANG CHẠY (2.5.117) với registry (2.5.120) nên lượt nào cũng
 // `npm i -g` lại từ đầu rồi mới vấp EBUSY: 413 lần cài đè trong ~34 giờ, lên
 // đúng thư mục cài mà worker-2 đang chạy. Cài đè cây đang chạy chính là thứ đã
 // giết worker Windows nhiều lần (lib/ bị xoá giữa chừng).
-function planUpdate({ running, onDisk, latest, restartBlocked = '' }) {
+function planUpdate({ running, onDisk, latest, restartBlocked = '', busy = false }) {
   if (!latest || !isNewer(latest, running)) return 'none';
   if (restartBlocked) return 'blocked';
+  if (busy) return 'deferred-busy';
   if (onDisk && !isNewer(latest, onDisk)) return 'restart-only';
   return 'install';
 }
@@ -136,7 +144,7 @@ function verifyInstall() {
   return { ok: out.status === 0, detail: detail.slice(-600) };
 }
 
-async function checkAndUpdate({ autoRestart = false } = {}) {
+async function checkAndUpdate({ autoRestart = false, isBusy = null } = {}) {
   const local = getLocalVersion();
   const latest = await getLatestVersion();
 
@@ -148,7 +156,11 @@ async function checkAndUpdate({ autoRestart = false } = {}) {
   // update` gõ tay thì cứ cài như cũ.
   const onDisk = getInstalledVersion();
   const blocker = autoRestart ? restartBlocker() : '';
-  const plan = planUpdate({ running: local, onDisk, latest, restartBlocked: blocker });
+  const busy = !!(autoRestart && typeof isBusy === 'function' && isBusy());
+  const plan = planUpdate({ running: local, onDisk, latest, restartBlocked: blocker, busy });
+  if (plan === 'deferred-busy') {
+    return { updated: false, local, latest, deferredBusy: true };
+  }
   if (plan === 'blocked') {
     if (Date.now() - lastBlockedWarnAt > BLOCKED_WARN_EVERY_MS) {
       lastBlockedWarnAt = Date.now();
@@ -238,33 +250,52 @@ async function checkAndUpdate({ autoRestart = false } = {}) {
 }
 
 class UpdateChecker {
-  constructor(intervalMs = 5 * 60 * 1000) {
+  /**
+   * @param {object} [opts]
+   * @param {() => boolean} [opts.isBusy]     daemon còn việc dở không
+   * @param {(r: object) => void} [opts.onDeferred] có bản mới mà đang bận —
+   *   daemon chuyển sang XẢ, rảnh rồi gọi lại check({ ignoreBusy: true })
+   * @param {Function} [opts.checkFn]         thay checkAndUpdate (test)
+   */
+  constructor(intervalMs = 5 * 60 * 1000, { isBusy = null, onDeferred = null, checkFn = checkAndUpdate } = {}) {
     this.intervalMs = intervalMs;
     this.timer = null;
+    this.startTimer = null;
+    this.isBusy = isBusy;
+    this.onDeferred = onDeferred;
+    this.checkFn = checkFn;
   }
 
-  start() {
-    // Check on startup after 10s delay
-    setTimeout(() => this.check(), 10000);
+  start({ initialDelay = true } = {}) {
+    // Check on startup after 10s delay (bỏ qua khi daemon vừa thôi xả — xem
+    // Daemon._resumeFromDrain)
+    if (initialDelay) this.startTimer = setTimeout(() => this.check(), 10000);
     // Then periodically
     this.timer = setInterval(() => this.check(), this.intervalMs);
   }
 
   stop() {
+    // Dọn cả lượt kiểm 10s đầu: dừng ngay sau start() mà để nó chạy là một lượt
+    // cài + khởi động lại lọt ra giữa lúc daemon đang xả.
+    if (this.startTimer) { clearTimeout(this.startTimer); this.startTimer = null; }
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
     }
   }
 
-  async check() {
+  /** @param {{ignoreBusy?: boolean}} [opts] ignoreBusy = daemon đã xả xong (hoặc hết hạn xả) */
+  async check({ ignoreBusy = false } = {}) {
     try {
-      const result = await checkAndUpdate({ autoRestart: true });
-      if (!result.updated) {
-        // Silent — only log in verbose or when there's an update
+      const result = await this.checkFn({ autoRestart: true, isBusy: ignoreBusy ? null : this.isBusy });
+      if (result && result.deferredBusy) {
+        console.log(`[updater] Có bản ${result.latest} nhưng đang có việc dở — xả trước, rảnh rồi mới cài.`);
+        if (this.onDeferred) this.onDeferred(result);
       }
+      return result;
     } catch (err) {
       console.warn(`[updater] Check failed: ${err.message}`);
+      return { updated: false, error: err.message };
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channel-worker",
-  "version": "2.5.137",
+  "version": "2.5.139",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {

package/scripts/fetch_facebook_reel_stats.js

@@ -38,7 +38,7 @@ function parseViews(txt) {
 // 09/09 tìm được tab để so trước/sau. Bản riêng còn thiếu cả bộ lọc "anchor
 // của bài trong bảng tin" (gốc 2 link page lạ sáng 10/09) nên có thể quét
 // nhầm tab Reels của page KHÁC mà không hay.
-const { discoverReelsTabUrl, discoverReelsTabUrls, openReelsTabWithTiles, parsePageRef } = require('./upload_facebook').__testables;
+const { discoverReelsTabUrl, discoverReelsTabUrls, openReelsTabWithTiles, parsePageRef, readPageIdFromDom, readDelegatePageId } = require('./upload_facebook').__testables;
 
 // Số người theo dõi của page, đọc ngay trên chính trang đang đứng (header hiện
 // ở mọi tab của page/profile) — không tốn thêm lượt mở profile nào. Ô
@@ -821,6 +821,29 @@ async function run({ page, payload, log }) {
   // được với danh sách page đã liên kết bên Shopee. Không có thì bỏ qua, lượt
   // ghi số liệu không phụ thuộc vào nó.
   const pageRef = opened.verified ? parsePageRef(opened.url) : null;
+  // URL chỉ có TÊN RIÊNG thì chưa đủ để đối chiếu với Shopee: 6/8 page đang liên
+  // kết bên đó lưu dạng `profile.php?id=…`, không mang tên riêng. Thiếu số ID là
+  // kênh bị báo "chưa liên kết" oan. Đọc thêm từ chính trang đang mở (đã chứng
+  // minh có tile ⇒ đúng page của kênh). Đọc hỏng thì giữ nguyên tên riêng, không
+  // làm hỏng lượt ghi số liệu.
+  if (pageRef && !pageRef.id) {
+    const hit = await readPageIdFromDom(page).catch(() => null);
+    if (hit) {
+      pageRef.id = hit.id;
+      log('info', `[fb-stats] page id đọc từ trang: ${hit.id} (${hit.sources} nguồn khớp: ${hit.from.join(', ')})`);
+    } else {
+      log('warn', '[fb-stats] URL chỉ có tên riêng và KHÔNG đọc được id từ trang — kênh sẽ hiện "chưa rõ Page" thay vì báo sai liên kết');
+    }
+  }
+  // MÃ TRANG Shopee dùng để đối chiếu (`delegate_page_id`) — KHÁC profile id.
+  // Không có nó thì API không kết luận được kênh đã liên kết hay chưa, và cố
+  // tình để ở "chưa rõ" còn hơn báo sai. Xem readDelegatePageId.
+  if (pageRef) {
+    const dg = await readDelegatePageId(page, pageRef.id).catch(() => ({ id: '', checked: false }));
+    pageRef.delegate_id = dg.id;
+    pageRef.delegate_checked = dg.checked;
+    log('info', `[fb-stats] mã Trang (Shopee dùng): ${dg.id || (dg.checked ? 'không có — page kiểu cổ điển' : 'CHƯA rõ')}`);
+  }
   if (pageRef) log('info', `[fb-stats] page: ${pageRef.id ? `id ${pageRef.id}` : `handle ${pageRef.handle}`}`);
 
   const d = await log.apiRequest('POST', '/analytics/post-stats', {

package/scripts/upload_facebook.js

@@ -1990,6 +1990,115 @@ function parsePageRef(reelsTabUrl) {
   return { id: '', handle: seg, url: raw };
 }
 
+// ID page ĐỌC TỪ CHÍNH TRANG, cho ca URL chỉ có tên riêng (`/<handle>/?sk=reels_tab`).
+//
+// Vì sao cần: bên Shopee, 6/8 page đang liên kết được lưu dạng
+// `profile.php?id=…`, KHÔNG có tên riêng trong link. Kênh nào chỉ biết tên riêng
+// thì không có gì để so → bị báo "chưa liên kết" OAN (đo bằng
+// services/AffiliateMediaLink 22/09). Dạng tên riêng có thật: ca "Chuyện Nghề
+// Nhà Nông" 14/09 — dạng profile.php ra 0 tile, chỉ `/chuyennghenhanong/` chạy.
+//
+// CHỈ gọi khi đang đứng trên trang tab Reels ĐÃ chứng minh có tile. Đứng ở trang
+// khác thì mấy khoá dưới đây là của trang đó, không phải của page mình.
+//
+// Đo thật 22/09 trên 6 profile của đàn (Toc-xinh, Meo-luoi, Tam-cai-tao-nha,
+// Beo-banh-beo, duong-nhan-cung-anh, Do-nghe-len-hinh):
+//   `profile_id` == `actorID` == ID page trong URL ở CẢ 6/6.
+//   ⛔ `delegate_page_id` LUÔN là một số KHÁC (vd page 61591917189886 →
+//      delegate 1240255979169594). Bắt nhầm khoá này là ghi sai danh tính rồi
+//      báo sai liên kết cho đúng cái kênh mình định cứu.
+//
+// Cổng an toàn: phải có **ít nhất hai nguồn độc lập cùng ra một số** mới nhận.
+// Một khoá JSON đứng lẻ không đủ — trang Facebook đầy số 15-16 chữ số, và nếu
+// profile đang đăng nhập bằng tài khoản CÁ NHÂN quản lý page thì `userID` là của
+// người, không phải của page. Hai nguồn khớp nhau thì khả năng cùng sai rất thấp.
+const PAGE_ID_JSON_KEYS = ['profile_id', 'actorID', 'pageID'];
+
+async function readPageIdFromDom(page) {
+  const votes = await page.evaluate((keys) => {
+    const out = {};
+    const add = (src, v) => {
+      if (!/^\d{5,25}$/.test(String(v || ''))) return;
+      (out[src] = out[src] || []).push(String(v));
+    };
+    // Nguồn 1: anchor profile.php NGOÀI bảng tin. Anchor trong feed là của bài
+    // người khác — đúng cái bẫy đã đẻ ra 2 link sai sáng 10/09.
+    for (const a of document.querySelectorAll('a[href]')) {
+      const href = a.getAttribute('href') || '';
+      if (/[?&]__cft__|[?&]__tn__/.test(href)) continue;
+      if (a.closest("[role='feed'], [role='article'], [aria-posinset]")) continue;
+      const m = href.match(/profile\.php\?id=(\d{5,25})/);
+      if (m) add('anchor', m[1]);
+    }
+    // Nguồn 2..n: khoá JSON trong bundle. `delegate_page_id` cố ý KHÔNG có mặt.
+    const html = document.documentElement.innerHTML;
+    for (const key of keys) {
+      const re = new RegExp(`"${key}"\\s*:\\s*"?(\\d{5,25})"?`, 'g');
+      let m; let n = 0;
+      while ((m = re.exec(html)) && n < 8) { add(key, m[1]); n++; }
+    }
+    return out;
+  }, PAGE_ID_JSON_KEYS).catch(() => ({}));
+
+  // Đếm theo NGUỒN, không theo số lần xuất hiện: một khoá lặp 8 lần trong bundle
+  // vẫn chỉ là MỘT nguồn, không được tự nó đủ phiếu.
+  const bySource = new Map();
+  for (const [src, vals] of Object.entries(votes || {})) {
+    for (const v of new Set(vals)) {
+      if (!bySource.has(v)) bySource.set(v, new Set());
+      bySource.get(v).add(src);
+    }
+  }
+  let best = null;
+  for (const [id, srcs] of bySource) {
+    if (srcs.size < 2) continue;
+    if (!best || srcs.size > best.sources) best = { id, sources: srcs.size, from: [...srcs].sort() };
+  }
+  return best;
+}
+
+// MÃ TRANG mà Shopee dùng để đối chiếu — `delegate_page_id`.
+//
+// ⚠️ Page Facebook kiểu mới (New Pages Experience) mang HAI số: `profile id`
+// nằm trong URL (14 số, mở đầu `61…`) và `delegate_page_id` là ID Trang cổ
+// điển nằm sau nó (15-16 số, mở đầu `1…`). **Shopee lưu số THỨ HAI.**
+// Đo 22/09: page `chuyennghenhanong` (profile 61591308775391) hiện trên Shopee
+// là 1165088293355326 = đúng delegate của nó. So bằng profile id là KHÔNG BAO
+// GIỜ khớp — lỗi đã lỡ đưa lên prod một lần.
+//
+// Khác `profile_id`/`actorID` (là của NGƯỜI ĐANG XEM), `delegate_page_id` nói
+// về TRANG ĐANG MỞ: đo trên 3 page lạ, nó trả đúng delegate của trang đó.
+//
+// Trả { id, checked }:
+//   - đúng MỘT giá trị     → id = nó, checked = true
+//   - KHÔNG có giá trị nào → page kiểu CỔ ĐIỂN (profile id chính là khoá
+//     Shopee) → id rỗng, checked = true. Chỉ dám kết luận vậy khi profile id
+//     KHÔNG mang hình dạng page kiểu mới; nếu nó là `61…` mà không đọc được
+//     delegate thì đó là đọc HỤT, không phải page cổ điển.
+//   - NHIỀU giá trị        → profile quản nhiều page (đo thật ở
+//     `duong-nhan-cung-anh`: 2 delegate). Không đoán → checked = false, để bên
+//     API giữ trạng thái "chưa rõ" thay vì báo sai.
+const NEW_STYLE_PROFILE_ID = /^61\d{12}$/;
+
+async function readDelegatePageId(page, profileId = '') {
+  const found = await page.evaluate(() => {
+    const out = new Set();
+    const re = /"delegate_page_id"\s*:\s*"?(\d{5,25})"?/g;
+    const html = document.documentElement.innerHTML;
+    let m; let n = 0;
+    while ((m = re.exec(html)) && n < 20) { out.add(m[1]); n++; }
+    return [...out];
+  }).catch(() => null);
+
+  if (found === null) return { id: '', checked: false };
+  if (found.length === 1) return { id: found[0], checked: true };
+  if (found.length === 0) {
+    // Không có delegate. Chỉ coi là page cổ điển khi profile id không phải dạng mới.
+    return { id: '', checked: !NEW_STYLE_PROFILE_ID.test(String(profileId || '')) };
+  }
+  return { id: '', checked: false };   // nhiều page trong cùng profile — không đoán
+}
+
 async function hasVisibleReelComposer(page) {
   return page.evaluate(() => {
     for (const dlg of document.querySelectorAll("[role='dialog']")) {
@@ -4569,6 +4678,8 @@ module.exports.__testables = {
   pickReelsTabUrl,
   pickReelsTabUrls,
   parsePageRef,
+  readPageIdFromDom,
+  readDelegatePageId,
   discoverReelsTabUrls,
   openReelsTabWithTiles,
   networkIdVerdict,