channel-worker 2.5.73 → 2.5.75

package/bin/cli.js

@@ -136,21 +136,55 @@ if (cmd === 'pair') {
   // Save merged config for next time
   saveConfig(config);
 
+  const singleton = require('../lib/singleton');
+
   if (args._daemon) {
-    // Actually run the daemon (spawned by ourselves)
-    const { Daemon } = require('../lib/daemon');
-    const daemon = new Daemon(config);
-    daemon.start();
+    // Actually run the daemon (spawned by ourselves). MỘT CONFIG_DIR = MỘT
+    // daemon: giành khoá trước, không giành được thì thoát chứ tuyệt đối không
+    // chạy chồng (xem lib/singleton.js — sự cố 3 daemon relabs03 04/09/2026).
+    (async () => {
+      const res = await singleton.acquire(CONFIG_DIR, {
+        // Chờ để nhường nhịp BÀN GIAO: con cũ nhả khoá rồi mới tắt hẳn.
+        waitMs: args.force ? 0 : 30000,
+        force: !!args.force,
+        info: { worker_id: config.worker_id, version: require('../package.json').version },
+      });
+      if (!res.ok) {
+        console.error(`[channel-worker] Đã có daemon khác giữ ${CONFIG_DIR} `
+          + `(PID ${res.holder.pid}, chạy từ ${res.holder.started_at}) — thoát để không chạy trùng. `
+          + 'Muốn thay: "channel-worker restart", hoặc "start --force".');
+        process.exit(0);
+      }
+      if (res.stolen) {
+        console.log(`[channel-worker] Tiếp quản khoá của PID ${res.stolen.pid} `
+          + `(${args.force ? 'ép bằng --force' : 'đã chết hoặc treo quá lâu'}).`);
+      }
+      // Ghi ĐÚNG pid của daemon thật — updater/restart trước đây ghi pid của
+      // tiến trình bọc, nên "stop" bắn trượt và để lại mồ côi.
+      fs.writeFileSync(path.join(CONFIG_DIR, 'daemon.pid'), String(process.pid));
+
+      const { Daemon } = require('../lib/daemon');
+      const daemon = new Daemon(config);
+      daemon.start();
+    })();
   } else {
     // Spawn detached background process and exit
+    const existing = singleton.readLock(CONFIG_DIR);
+    if (existing && !singleton.isStale(existing) && !args.force) {
+      console.error(`[channel-worker] Daemon đang chạy rồi (PID ${existing.pid}, từ ${existing.started_at}). `
+        + 'Dùng "channel-worker restart", hoặc thêm --force nếu thật sự muốn thêm một con nữa.');
+      process.exit(1);
+    }
+
     const { spawn } = require('child_process');
     const LOG_FILE = path.join(CONFIG_DIR, 'daemon.log');
     const logFd = fs.openSync(LOG_FILE, 'a');
 
-    const child = spawn(process.execPath, [__filename, 'start', '--_daemon'], {
+    const child = spawn(process.execPath, [__filename, 'start', '--_daemon', ...(args.force ? ['--force'] : [])], {
       detached: true,
       stdio: ['ignore', logFd, logFd],
       cwd: os.homedir(),
+      windowsHide: true,
     });
     child.unref();
 
@@ -182,19 +216,28 @@ if (cmd === 'pair') {
   })();
 
 } else if (cmd === 'stop') {
+  const singleton = require('../lib/singleton');
   const pidFile = path.join(CONFIG_DIR, 'daemon.pid');
-  if (!fs.existsSync(pidFile)) {
-    console.log('[channel-worker] No daemon running (no PID file).');
+  // Khoá là nguồn đáng tin hơn daemon.pid: pid file từng bị ghi đè bằng pid của
+  // tiến trình bọc (updater/restart cũ), bắn SIGTERM vào đó là trượt.
+  const lock = singleton.readLock(CONFIG_DIR);
+  const pid = (lock && lock.pid)
+    || (fs.existsSync(pidFile) ? parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10) : NaN);
+  if (!Number.isInteger(pid)) {
+    console.log('[channel-worker] No daemon running (no lock, no PID file).');
     process.exit(0);
   }
-  const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+  const cleanup = () => {
+    try { fs.unlinkSync(pidFile); } catch {}
+    try { fs.unlinkSync(singleton.lockPath(CONFIG_DIR)); } catch {}
+  };
   try {
     process.kill(pid, 'SIGTERM');
-    fs.unlinkSync(pidFile);
+    cleanup();
     console.log(`[channel-worker] Daemon stopped (PID: ${pid})`);
   } catch (err) {
     if (err.code === 'ESRCH') {
-      fs.unlinkSync(pidFile);
+      cleanup();
       console.log(`[channel-worker] Daemon was not running (stale PID: ${pid}). Cleaned up.`);
     } else {
       console.error(`[channel-worker] Failed to stop: ${err.message}`);
@@ -215,18 +258,27 @@ if (cmd === 'pair') {
 
 } else if (cmd === 'restart') {
   // Stop existing daemon, then start new one
+  const singleton = require('../lib/singleton');
   const pidFile = path.join(CONFIG_DIR, 'daemon.pid');
-  if (fs.existsSync(pidFile)) {
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+  const lock = singleton.readLock(CONFIG_DIR);
+  const pid = (lock && lock.pid)
+    || (fs.existsSync(pidFile) ? parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10) : NaN);
+  if (Number.isInteger(pid)) {
     try { process.kill(pid, 'SIGTERM'); } catch { /* already dead */ }
-    fs.unlinkSync(pidFile);
     console.log(`[channel-worker] Stopped old daemon (PID: ${pid})`);
   }
+  // Con vừa bị bắn có thể chưa kịp nhả khoá (hoặc bị SIGKILL trước đó) — dọn
+  // khoá của ĐÚNG pid vừa giết để con mới không bị chính nó chặn cửa.
+  if (lock && lock.pid === pid && !singleton.pidAlive(pid)) {
+    try { fs.unlinkSync(singleton.lockPath(CONFIG_DIR)); } catch {}
+  }
+  try { fs.unlinkSync(pidFile); } catch {}
   // Re-invoke start
   const { spawn } = require('child_process');
   const child = spawn(process.execPath, [__filename, 'start'], {
     stdio: 'inherit',
     cwd: process.cwd(),
+    windowsHide: true,
   });
   child.on('exit', (code) => process.exit(code));
 

package/lib/cache-server.js

@@ -119,11 +119,11 @@ class CacheServer {
     try {
       if (process.platform === 'win32') {
         const out = execSync(`tasklist /FI "PID eq ${pid}" /NH /FO CSV`,
-          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
         return /^"node\.exe"/i.test(out.trim());
       }
       const out = execSync(`ps -p ${pid} -o comm=`,
-        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
       return /node/i.test(out.trim());
     } catch {
       return false;
@@ -137,7 +137,7 @@ class CacheServer {
       if (process.platform === 'win32') {
         // netstat columns: Proto Local Foreign State PID
         const out = execSync(`netstat -ano -p TCP | findstr :${this.port} | findstr LISTENING`,
-          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
         const pids = new Set();
         for (const line of out.split('\n')) {
           const m = line.trim().match(/\s(\d+)\s*$/);
@@ -152,13 +152,13 @@ class CacheServer {
             continue;
           }
           console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
-          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' }); killed++; } catch {}
+          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore', windowsHide: true }); killed++; } catch {}
         }
         return killed;
       }
       // mac/linux
       const out = execSync(`lsof -ti:${this.port} -sTCP:LISTEN`,
-        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
       const pids = out.split('\n').map(s => s.trim()).filter(Boolean);
       let killed = 0;
       for (const pid of pids) {
@@ -168,7 +168,7 @@ class CacheServer {
           continue;
         }
         console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
-        try { execSync(`kill -9 ${pid}`, { stdio: 'ignore' }); killed++; } catch {}
+        try { execSync(`kill -9 ${pid}`, { stdio: 'ignore', windowsHide: true }); killed++; } catch {}
       }
       return killed;
     } catch {

package/lib/command-poller.js

@@ -558,7 +558,7 @@ class CommandPoller {
 
       // Extract
       fs.mkdirSync(tmpExtract, { recursive: true });
-      execSync(`tar -xzf "${tmpArchive}" -C "${tmpExtract}"`, { timeout: 30000 });
+      execSync(`tar -xzf "${tmpArchive}" -C "${tmpExtract}"`, { timeout: 30000, windowsHide: true });
 
       // Tar extracts into subfolder — find it (could be content-creator or content-creator-ext)
       const subdirs = fs.readdirSync(tmpExtract).filter(f => fs.statSync(path.join(tmpExtract, f)).isDirectory());
@@ -1338,16 +1338,24 @@ class CommandPoller {
     const logFile = path.join(configDir, 'daemon.log');
     const logFd = fs.openSync(logFile, 'a');
 
+    // Nhả khoá trước rồi mới đẻ con thay thế — và CHỈ con đang giữ khoá mới
+    // được đẻ. Nếu lệnh restart rơi vào một daemon thừa thì nó chỉ việc tắt,
+    // daemon thật vẫn chạy tiếp (xem lib/singleton.js).
+    const singleton = require('./singleton');
+    const wasOwner = singleton.release(configDir);
+    if (!wasOwner) {
+      console.log('[commands] Tiến trình này không giữ khoá daemon (bản thừa) — tắt, không spawn bản mới.');
+      process.exit(0);
+    }
+
     const child = spawn(process.execPath, [cliPath, 'start', '--_daemon'], {
       detached: true,
       stdio: ['ignore', logFd, logFd],
       cwd: os.homedir(),
+      windowsHide: true,
     });
     child.unref();
 
-    // Update PID file
-    const pidFile = path.join(configDir, 'daemon.pid');
-    fs.writeFileSync(pidFile, String(child.pid));
     console.log(`[commands] New daemon spawned (PID: ${child.pid}), exiting current process...`);
 
     process.exit(0);

package/lib/daemon.js

@@ -6,6 +6,9 @@ const { UpdateChecker, getLocalVersion } = require('./updater');
 const { checkAndUpdateExtension } = require('./extension-updater');
 const { CacheServer } = require('./cache-server');
 const { agentAddressForUser } = require('./nst-agent-locator');
+const singleton = require('./singleton');
+const os = require('os');
+const path = require('path');
 
 class Daemon {
   constructor(config) {
@@ -30,6 +33,47 @@ class Daemon {
     this.updateChecker = new UpdateChecker(5 * 60 * 1000); // check every 5min
     this.extCheckTimer = null;
     this.nstAgentTimer = null;
+    this.lockTimer = null;
+    this.configDir = path.join(os.homedir(), '.channel-worker');
+    this._evictLogged = false;
+  }
+
+  /** Đang bận = có job đang chạy, hoặc có phiên Playwright đang giữ profile. */
+  _isBusy() {
+    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;
+  }
+
+  /**
+   * Nhịp khoá singleton (30s):
+   *  - còn là chủ → làm tươi để đứa khác biết mình sống;
+   *  - khoá trống → giành lại (ai đó dọn tay), đừng tự sát vô cớ;
+   *  - khoá sang tay đứa khác → MÌNH LÀ MỒ CÔI: một daemon mới đã tiếp quản,
+   *    rút lui khi hết việc thay vì poll chồng lên nó. Đây là đường tự hội tụ
+   *    cho những máy đã lỡ có sẵn nhiều daemon.
+   */
+  async _tickLock() {
+    if (singleton.refresh(this.configDir)) return;
+    const lock = singleton.readLock(this.configDir);
+    if (!lock) {
+      await singleton.acquire(this.configDir, {
+        waitMs: 0,
+        info: { worker_id: this.config.worker_id, version: getLocalVersion() },
+      }).catch(() => {});
+      return;
+    }
+    if (lock.pid === process.pid) return;
+    if (!this._evictLogged) {
+      this._evictLogged = true;
+      console.warn(`[daemon] Khoá ${singleton.LOCK_FILE} đã sang PID ${lock.pid} — `
+        + `tiến trình này (PID ${process.pid}) là daemon THỪA, sẽ tự tắt khi hết việc.`);
+    }
+    if (this._isBusy()) return; // đang chạy dở thì để yên, nhịp sau tính tiếp
+    console.warn('[daemon] Hết việc — daemon thừa tự tắt để máy chỉ còn một con.');
+    if (this._shutdown) await this._shutdown();
+    else process.exit(0);
   }
 
   /**
@@ -147,6 +191,10 @@ class Daemon {
       console.log(`[daemon] NST agent watcher started (user "${this.config.nst_agent_user}", every 60s)`);
     }
 
+    // Nhịp khoá singleton — xem _tickLock().
+    this.lockTimer = setInterval(() => { this._tickLock().catch(() => {}); }, singleton.REFRESH_MS);
+    console.log(`[daemon] Singleton lock watcher started (every ${singleton.REFRESH_MS / 1000}s)`);
+
     // Start auto-update checker
     this.updateChecker.start();
     console.log('[daemon] Auto-update checker started (every 5min)');
@@ -177,7 +225,10 @@ class Daemon {
       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 {
@@ -190,6 +241,7 @@ class Daemon {
       process.exit(0);
     };
 
+    this._shutdown = shutdown;
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
   }

package/lib/extension-updater.js

@@ -41,7 +41,7 @@ async function checkAndUpdateExtension(api, extensionPath) {
 
     // Extract
     fs.mkdirSync(tmpExtract, { recursive: true });
-    execSync(`tar -xzf "${tmpArchive}" -C "${tmpExtract}"`, { timeout: 30000 });
+    execSync(`tar -xzf "${tmpArchive}" -C "${tmpExtract}"`, { timeout: 30000, windowsHide: true });
 
     // tar extracts into a subfolder named "channel-manager-ext"
     const extracted = path.join(tmpExtract, 'channel-manager-ext');

package/lib/nst-agent-locator.js

@@ -14,7 +14,11 @@
 
 const { execSync } = require('child_process');
 
-const sh = (cmd) => execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 });
+// windowsHide: mặc định của child_process là FALSE — mỗi execSync trên Windows
+// nháy một cửa sổ console đen. Hàm này chạy mỗi 60s (watcher agent NST) nên
+// nó chính là thủ phạm "cứ một lúc lại có cửa sổ đen bật lên rồi tắt" mà
+// chủ tịch thấy trên win-worker 04/09/2026.
+const sh = (cmd) => execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000, windowsHide: true });
 
 // PIDs of agent.exe, optionally narrowed to one owner. Owner filtering happens
 // in tasklist rather than in JS because listing owners needs WMI/CIM, which is

package/lib/singleton.js

@@ -0,0 +1,145 @@
+/**
+ * Một CONFIG_DIR = MỘT daemon. Không có khoá này thì `channel-worker start`
+ * (người gõ tay, scheduled task chạy lại, bộ tự-cập-nhật, lệnh restart_worker)
+ * đều đẻ thêm một daemon nữa mà không ai biết — `stop` chỉ giết được pid ghi
+ * trong daemon.pid, phần còn lại thành mồ côi poll song song cùng một hàng đợi.
+ *
+ * Sự cố thật 04/09/2026 trên relabs03: 3 daemon cùng sống (khởi động 00:42,
+ * 00:47, 00:52 — lệch đúng 5 phút = nhịp updater của từng con). Chúng có từ
+ * trước; khi 2.5.73 ra, MỖI con tự cài rồi tự spawn bản thay thế của riêng nó
+ * → 3 con cũ chết, 3 con mới sinh, sĩ số không bao giờ giảm. Dấu vết ở API:
+ * hai hàng `relabs03` trong `workers`, một hàng heartbeat đứng hình.
+ *
+ * Cách chống: khoá theo file trong chính CONFIG_DIR (nên 2 daemon 2 home trên
+ * win-worker vẫn chạy song song bình thường).
+ *  - chủ khoá làm tươi `refreshed_at` mỗi 30s → khoá cũ quá STALE_MS coi như
+ *    chết, chống cả ca pid bị hệ điều hành cấp lại cho tiến trình khác;
+ *  - `acquire` chờ tới `waitMs` để nhường nhịp bàn giao (con cũ nhả rồi mới
+ *    thoát), hết giờ thì con mới tự thoát chứ KHÔNG chạy chồng;
+ *  - `owns()` cho daemon tự soi: mất khoá vào tay đứa khác = mình là mồ côi,
+ *    tự rút lui lúc rảnh việc.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LOCK_FILE = 'daemon.lock';
+const REFRESH_MS = 30_000;
+// Chủ khoá làm tươi mỗi 30s; quá 6 nhịp không tươi = treo hoặc chết bất thường.
+const STALE_MS = 180_000;
+
+function lockPath(configDir) {
+  return path.join(configDir, LOCK_FILE);
+}
+
+function readLock(configDir) {
+  try {
+    const raw = fs.readFileSync(lockPath(configDir), 'utf-8');
+    const data = JSON.parse(raw);
+    if (!data || !Number.isInteger(data.pid)) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM = tiến trình có thật nhưng khác quyền → vẫn tính là sống.
+    return err.code === 'EPERM';
+  }
+}
+
+function isStale(lock, now = Date.now()) {
+  if (!lock) return true;
+  if (!pidAlive(lock.pid)) return true;
+  const refreshed = Date.parse(lock.refreshed_at || lock.started_at || '');
+  if (!Number.isFinite(refreshed)) return true;
+  return now - refreshed > STALE_MS;
+}
+
+function writeLock(configDir, info, { overwrite = false } = {}) {
+  fs.mkdirSync(configDir, { recursive: true });
+  const body = JSON.stringify({
+    pid: process.pid,
+    worker_id: info.worker_id || '',
+    version: info.version || '',
+    started_at: info.started_at || new Date().toISOString(),
+    refreshed_at: new Date().toISOString(),
+  });
+  // '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');
+  try {
+    fs.writeFileSync(fd, body);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Giành khoá cho tiến trình hiện tại.
+ * @returns {{ok: true, stolen?: object} | {ok: false, holder: object}}
+ */
+async function acquire(configDir, { waitMs = 0, force = false, info = {}, pollMs = 1000 } = {}) {
+  const started_at = new Date().toISOString();
+  const deadline = Date.now() + Math.max(0, waitMs);
+  for (;;) {
+    const lock = readLock(configDir);
+    if (!lock) {
+      try {
+        writeLock(configDir, { ...info, started_at });
+        return { ok: true };
+      } catch (err) {
+        if (err.code !== 'EEXIST') throw err;
+        continue; // đứa khác chen vào giữa hai nhịp — đọc lại rồi xử tiếp
+      }
+    }
+    if (lock.pid === process.pid) return { ok: true }; // đã là của mình
+    if (force || isStale(lock)) {
+      writeLock(configDir, { ...info, started_at }, { overwrite: true });
+      return { ok: true, stolen: lock };
+    }
+    if (Date.now() >= deadline) return { ok: false, holder: lock };
+    await sleep(pollMs);
+  }
+}
+
+function owns(configDir, pid = process.pid) {
+  const lock = readLock(configDir);
+  return !!lock && lock.pid === pid;
+}
+
+/** Làm tươi khoá. Trả false nếu khoá đã sang tay đứa khác. */
+function refresh(configDir) {
+  const lock = readLock(configDir);
+  if (!lock || lock.pid !== process.pid) return false;
+  try {
+    writeLock(configDir, lock, { overwrite: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Nhả khoá — CHỈ khi mình đang giữ, không bao giờ xoá khoá của đứa khác. */
+function release(configDir, pid = process.pid) {
+  const lock = readLock(configDir);
+  if (!lock || lock.pid !== pid) return false;
+  try {
+    fs.unlinkSync(lockPath(configDir));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  LOCK_FILE, REFRESH_MS, STALE_MS,
+  lockPath, readLock, pidAlive, isStale, acquire, owns, refresh, release,
+};

package/lib/updater.js

@@ -27,7 +27,7 @@ function isNewer(remote, local) {
 
 function installUpdate(version) {
   console.log(`[updater] Installing ${PKG_NAME}@${version}...`);
-  execSync(`npm install -g ${PKG_NAME}@${version}`, { stdio: 'inherit' });
+  execSync(`npm install -g ${PKG_NAME}@${version}`, { stdio: 'inherit', windowsHide: true });
   console.log(`[updater] Installed ${PKG_NAME}@${version}`);
 }
 
@@ -50,23 +50,34 @@ async function checkAndUpdate({ autoRestart = false } = {}) {
     const os = require('os');
 
     const CONFIG_DIR = path.join(os.homedir(), '.channel-worker');
-    const pidFile = path.join(CONFIG_DIR, 'daemon.pid');
     const LOG_FILE = path.join(CONFIG_DIR, 'daemon.log');
     const logFd = fs.openSync(LOG_FILE, 'a');
 
+    // Nhả khoá TRƯỚC khi spawn: con mới phải giành được khoá mới chạy. Nếu
+    // tiến trình này là daemon THỪA (không giữ khoá) thì release trả false —
+    // lúc đó `channel-worker start` sẽ từ chối đẻ thêm con, và mình vẫn thoát.
+    // Nhờ vậy mỗi vòng cập nhật là một lần TỰ RÚT SĨ SỐ về đúng một daemon,
+    // thay vì N con cũ đẻ ra N con mới như sự cố relabs03 04/09/2026.
+    const singleton = require('./singleton');
+    const wasOwner = singleton.release(CONFIG_DIR);
+    if (!wasOwner) {
+      console.log('[updater] Tiến trình này không giữ khoá daemon (bản thừa) — '
+        + 'thoát, không spawn bản thay thế.');
+    }
+
     // Spawn new daemon using global binary (picks up new version)
     const isWindows = process.platform === 'win32';
     const binName = isWindows ? 'channel-worker.cmd' : 'channel-worker';
-    const child = spawn(binName, ['start'], {
-      detached: true,
-      stdio: ['ignore', logFd, logFd],
-      cwd: os.homedir(),
-      shell: isWindows,
-    });
-    child.unref();
-
-    // Update PID file
-    fs.writeFileSync(pidFile, String(child.pid));
+    if (wasOwner) {
+      const child = spawn(binName, ['start'], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        cwd: os.homedir(),
+        shell: isWindows,
+        windowsHide: true,
+      });
+      child.unref();
+    }
 
     process.exit(0);
   }

package/package.json

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

package/scripts/upload_facebook.js

@@ -1686,7 +1686,6 @@ async function runOnce({ page, payload, log }) {
                 const closeDeadline = Date.now() + 60_000;
                 let modalClosed = false;
                 let closedPolls = 0;
-                let appliedPolls = 0;
                 let retryCount = 0;
                 const RETRY_AFTER_MS = 12_000;
                 let lastRetryAt = Date.now();
@@ -1696,23 +1695,21 @@ async function runOnce({ page, payload, log }) {
                   // nested form (no own dialog — its upload button, aria
                   // "Tải hình thu nhỏ tùy chỉnh lên…", only exists while the
                   // editor is showing).
-                  // Biến thể inline: panel không bao giờ đóng nhưng nút "Gỡ hình
-                  // thu nhỏ tùy chỉnh" đã hiện = thumb ĐÃ áp. Chỉ tin ở nhánh
-                  // nested (modal thật vẫn phải đóng sau Lưu như cũ) và đòi 2
-                  // mẫu liên tiếp như luật closedPolls; bấm Lưu chốt một nhịp
-                  // cuối phòng cohort nào đó vẫn cần Lưu để giữ trạng thái.
-                  if (thumbEditorVia === 'nested' && await isCustomThumbApplied(page)) {
-                    if (++appliedPolls >= 2) {
-                      for (const sel of saveCandidates) {
-                        const btn = await firstVisible(page.locator(sel), 1);
-                        if (btn) { await btn.click({ timeout: 1500 }).catch(() => {}); break; }
-                      }
-                      log('info', '[fb-pw] page-wall thumb — panel inline không đóng nhưng nút "Gỡ hình thu nhỏ" đang hiện → coi như dán xong');
-                      modalClosed = true; break;
-                    }
-                  } else {
-                    appliedPolls = 0;
-                  }
+                  // ĐÃ GỠ (2.5.75) — lối tắt "thấy nút Gỡ 2 nhịp thì coi như xong,
+                  // bấm Lưu chốt một cái rồi đi tiếp". Đo trên 20.000 dòng log
+                  // ngày 04/09/2026: lối tắt chạy 21 lượt thì 19 lượt kết thúc
+                  // bằng dump "composer closed after saving thumbnail", trong khi
+                  // đường thường (chờ editor đóng hẳn) chạy 98 lượt đăng ngon.
+                  // Chuỗi log lặp đúng một khuôn: NORMAL→PUBLISH, FAST→DUMP DUMP.
+                  //
+                  // Nút "Gỡ" hiện NGAY khi file vừa dán, lúc ảnh còn đang xử lý
+                  // (ảnh dump nào cũng thấy spinner), nên lối tắt cướp lượt của
+                  // những lần lẽ ra đóng bình thường sau 3-5s, rồi bấm Lưu lần
+                  // hai khi FB đang lưu dở — composer bị gỡ khỏi trang.
+                  //
+                  // Cohort inline thật (panel không bao giờ đóng) vẫn còn hai lớp
+                  // cứu phía dưới: nhánh hết-giờ-60s và cổng trước Đăng, cả hai
+                  // đều KHÔNG bấm thêm Lưu. Đó mới là đường đã nghiệm thu 03/09.
                   const still = await isThumbnailEditorVisible(page);
                   if (!still) {
                     // Require two consecutive closed samples. Facebook briefly
@@ -1726,7 +1723,8 @@ async function runOnce({ page, payload, log }) {
                   // Retry Lưu click after RETRY_AFTER_MS without progress —
                   // limit to 3 retries (so we still leave time for FB to
                   // finish processing on the last attempt).
-                  if (retryCount < 3 && Date.now() - lastRetryAt >= RETRY_AFTER_MS) {
+                  if (retryCount < 3 && Date.now() - lastRetryAt >= RETRY_AFTER_MS
+                      && !(await isCustomThumbApplied(page))) {
                     retryCount++;
                     lastRetryAt = Date.now();
                     log('info', `[fb-pw] thumb modal still open after ${retryCount * (RETRY_AFTER_MS / 1000)}s — re-clicking Lưu (retry ${retryCount}/3)`);