channel-worker 2.5.138 → 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));
     }
   }
 
@@ -1860,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
@@ -2270,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/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.138",
+  "version": "2.5.139",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {