channel-worker 2.5.62 → 2.5.66

package/bin/cli.js

@@ -117,6 +117,14 @@ if (cmd === 'pair') {
     nst_api_key: args['nst-key'] || saved.nst_api_key || '',
     extension_path: args.extension || saved.extension_path || DEFAULT_EXT_PATH,
     worker_token: args.token || saved.worker_token || '',
+    // Multi-user Windows: two sessions on one box collide on these ports.
+    // cache_port = this daemon's local cache server; nst_api_address = the
+    // Nstbrowser agent belonging to THIS session (2nd session gets 8849+).
+    cache_port: parseInt(args['cache-port'] || saved.cache_port || '8849', 10),
+    nst_api_address: args['nst-address'] || saved.nst_api_address || '',
+    // Windows user whose Nstbrowser agent this daemon drives. Preferred over a
+    // hard-coded nst_api_address: the agent's port depends on login order.
+    nst_agent_user: args['nst-user'] || saved.nst_agent_user || '',
     verbose: !!args.verbose,
   };
 

package/lib/cache-server.js

@@ -111,6 +111,25 @@ class CacheServer {
     res.end(JSON.stringify({ success: false, message: 'not found' }));
   }
 
+  // Is this PID a node process (i.e. plausibly a leaked daemon of ours)?
+  // On a multi-user Windows box the port may be held by Nstbrowser's agent.exe
+  // — the 2nd session's agent binds 8849 when 8848 is taken. Killing that would
+  // take down the whole browser fleet, so only ever kill our own kind.
+  _isOwnKind(pid) {
+    try {
+      if (process.platform === 'win32') {
+        const out = execSync(`tasklist /FI "PID eq ${pid}" /NH /FO CSV`,
+          { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return /^"node\.exe"/i.test(out.trim());
+      }
+      const out = execSync(`ps -p ${pid} -o comm=`,
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      return /node/i.test(out.trim());
+    } catch {
+      return false;
+    }
+  }
+
   // Find PID(s) holding our port and kill them. Cross-platform best-effort.
   // Used when bind fails with EADDRINUSE — typically a leaked previous daemon.
   _killPortHolder() {
@@ -124,23 +143,34 @@ class CacheServer {
           const m = line.trim().match(/\s(\d+)\s*$/);
           if (m) pids.add(m[1]);
         }
+        let killed = 0;
         for (const pid of pids) {
           if (Number(pid) === process.pid) continue;
+          if (!this._isOwnKind(pid)) {
+            console.warn(`[cache-server] Port ${this.port} held by non-node PID ${pid} `
+              + '(Nstbrowser agent?) — NOT killing. Set cache_port to a free port.');
+            continue;
+          }
           console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
-          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' }); } catch {}
+          try { execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' }); killed++; } catch {}
         }
-        return pids.size;
+        return killed;
       }
       // mac/linux
       const out = execSync(`lsof -ti:${this.port} -sTCP:LISTEN`,
         { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
       const pids = out.split('\n').map(s => s.trim()).filter(Boolean);
+      let killed = 0;
       for (const pid of pids) {
         if (Number(pid) === process.pid) continue;
+        if (!this._isOwnKind(pid)) {
+          console.warn(`[cache-server] Port ${this.port} held by non-node PID ${pid} — NOT killing.`);
+          continue;
+        }
         console.log(`[cache-server] Killing leaked PID ${pid} holding port ${this.port}`);
-        try { execSync(`kill -9 ${pid}`, { stdio: 'ignore' }); } catch {}
+        try { execSync(`kill -9 ${pid}`, { stdio: 'ignore' }); killed++; } catch {}
       }
-      return pids.length;
+      return killed;
     } catch {
       return 0;
     }

package/lib/daemon.js

@@ -5,10 +5,15 @@ const { CommandPoller } = require('./command-poller');
 const { UpdateChecker, getLocalVersion } = require('./updater');
 const { checkAndUpdateExtension } = require('./extension-updater');
 const { CacheServer } = require('./cache-server');
+const { agentAddressForUser } = require('./nst-agent-locator');
 
 class Daemon {
   constructor(config) {
     this.config = config;
+    // Point every NstManager instance (11 call sites in command-poller) at the
+    // Nstbrowser agent of THIS Windows session. On a multi-user box the second
+    // session's agent binds 8849+ because 8848 is taken machine-wide.
+    if (config.nst_api_address) process.env.NST_API_ADDRESS = config.nst_api_address;
     this.api = new ApiClient(config.api_url, config.worker_token);
     this.heartbeat = new Heartbeat(this.api, config.worker_id, 30000, config);
     this.poller = new JobPoller(this.api, config);
@@ -18,9 +23,45 @@ class Daemon {
     this.commandPoller = new CommandPoller(this.api, config);
     this.updateChecker = new UpdateChecker(5 * 60 * 1000); // check every 5min
     this.extCheckTimer = null;
+    this.nstAgentTimer = null;
+  }
+
+  /**
+   * Point NST_API_ADDRESS at the agent of the Windows user we're paired with.
+   *
+   * `nst_api_address` (a hard-coded port) still wins when set, but it goes
+   * stale the moment login order changes: agents claim 8848, 8849, … first
+   * come first served, so yesterday's port can be the other person's agent
+   * today. Pinning to `nst_agent_user` and re-reading the port survives that.
+   */
+  async _resolveNstAgent({ quiet = false } = {}) {
+    if (this.config.nst_api_address) return;
+    const user = this.config.nst_agent_user;
+    if (!user) return;
+    let found = null;
+    try {
+      found = await agentAddressForUser(user);
+    } catch (err) {
+      if (!quiet) console.warn(`[daemon] NST agent lookup failed: ${err.message}`);
+      return;
+    }
+    if (!found) {
+      if (!quiet) {
+        console.warn(`[daemon] No Nstbrowser agent for Windows user "${user}" — `
+          + 'NST commands will fail until that user is logged in.');
+      }
+      return;
+    }
+    if (process.env.NST_API_ADDRESS !== found.address) {
+      const before = process.env.NST_API_ADDRESS || '(none)';
+      process.env.NST_API_ADDRESS = found.address;
+      console.log(`[daemon] NST agent for "${user}": ${found.address} `
+        + `(pid ${found.pid}, session ${found.sessionId}/${found.sessionName}) [was ${before}]`);
+    }
   }
 
   async start() {
+    await this._resolveNstAgent();
     const version = getLocalVersion();
     console.log(`
 ╔══════════════════════════════════════╗
@@ -31,6 +72,8 @@ class Daemon {
 ║  Concurrent: ${String(this.config.max_concurrent).padEnd(22)}║
 ╚══════════════════════════════════════╝
 `);
+    console.log(`[daemon] cache server port: ${this.config.cache_port || 8849}`);
+    console.log(`[daemon] NST agent: ${process.env.NST_API_ADDRESS || 'http://localhost:8848/api/v2 (default)'}`);
 
     // Start local cache server (extension shares this across all profiles)
     try {
@@ -80,6 +123,14 @@ class Daemon {
     this.commandPoller.start();
     console.log('[daemon] Command poller started (every 3s)');
 
+    // Re-read the agent's port — it moves when that user logs out and back in.
+    if (this.config.nst_agent_user && !this.config.nst_api_address) {
+      this.nstAgentTimer = setInterval(() => {
+        this._resolveNstAgent({ quiet: true }).catch(() => {});
+      }, 60000);
+      console.log(`[daemon] NST agent watcher started (user "${this.config.nst_agent_user}", every 60s)`);
+    }
+
     // Start auto-update checker
     this.updateChecker.start();
     console.log('[daemon] Auto-update checker started (every 5min)');
@@ -109,6 +160,7 @@ class Daemon {
       this.commandPoller.stop();
       this.updateChecker.stop();
       if (this.extCheckTimer) clearInterval(this.extCheckTimer);
+      if (this.nstAgentTimer) clearInterval(this.nstAgentTimer);
       try { this.cacheServer.stop(); } catch {}
 
       // Mark offline

package/lib/nst-agent-locator.js

@@ -0,0 +1,161 @@
+/**
+ * Locate the Nstbrowser agent belonging to a specific Windows user.
+ *
+ * On a box where two people are logged in at once, each session runs its own
+ * `agent.exe`. They pick their port by first-come-first-served: whoever logs
+ * in first takes 8848, the next one lands on 8849. So a hard-coded port in
+ * config silently points at the OTHER person's agent whenever the login order
+ * flips — commands go to the wrong desktop, and two daemons can end up driving
+ * the same profile.
+ *
+ * Pinning to the *user* instead of the port survives that: find agent.exe owned
+ * by the user, then read whichever port that PID is listening on.
+ */
+
+const { execSync } = require('child_process');
+
+const sh = (cmd) => execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 });
+
+// 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
+// an order of magnitude slower and is disabled on some hardened boxes.
+function parseTasklistCsv(out) {
+  const pids = [];
+  for (const line of String(out).split('\n')) {
+    // "agent.exe","37700","RDP-Tcp#103","3","131,584 K"
+    const m = line.match(/^"[^"]*","(\d+)","([^"]*)","(\d+)"/);
+    if (m) pids.push({ pid: m[1], sessionName: m[2], sessionId: m[3] });
+  }
+  return pids;
+}
+
+function agentPids(username = null) {
+  const filters = ['/FI "IMAGENAME eq agent.exe"'];
+  if (username) filters.push(`/FI "USERNAME eq ${username}"`);
+  try {
+    return parseTasklistCsv(sh(`tasklist ${filters.join(' ')} /NH /FO CSV`));
+  } catch {
+    return [];
+  }
+}
+
+// Every TCP port in LISTENING state, keyed by the PID holding it.
+function parseListening(out) {
+  const byPid = new Map();
+  for (const line of String(out).split('\n')) {
+    if (!/LISTENING/.test(line)) continue;
+    // "  TCP    0.0.0.0:8849   0.0.0.0:0   LISTENING   37700"  (or "[::]:8848")
+    const m = line.match(/^\s*TCP\s+(.+?):(\d+)\s+\S+\s+LISTENING\s+(\d+)\s*$/);
+    if (!m) continue;
+    const [, host, port, pid] = m;
+    if (!byPid.has(pid)) byPid.set(pid, []);
+    byPid.get(pid).push({ host, port: Number(port) });
+  }
+  return byPid;
+}
+
+function listeningPortsByPid() {
+  try {
+    return parseListening(sh('netstat -ano -p TCP'));
+  } catch {
+    return new Map();
+  }
+}
+
+/**
+ * All Nstbrowser agents running on this machine.
+ * → [{ pid, sessionId, sessionName, port, address }]
+ */
+function listAgents(username = null) {
+  if (process.platform !== 'win32') return [];
+  const pids = agentPids(username);
+  if (!pids.length) return [];
+  const ports = listeningPortsByPid();
+  const agents = [];
+  for (const p of pids) {
+    const bound = ports.get(p.pid) || [];
+    // The agent's HTTP API is the lowest port it listens on; it opens a couple
+    // of internal ones too, and those sort above the API port in practice.
+    const api = bound.map(b => b.port).sort((a, b) => a - b)[0];
+    if (!api) continue;
+    agents.push({
+      pid: p.pid,
+      sessionId: p.sessionId,
+      sessionName: p.sessionName,
+      port: api,
+      address: `http://127.0.0.1:${api}/api/v2`,
+    });
+  }
+  return agents;
+}
+
+/**
+ * The agent belonging to `username`, or null.
+ *
+ * A port answering on 127.0.0.1 is not proof it is the agent — our own cache
+ * server binds loopback explicitly, and Windows routes localhost to the most
+ * specific listener, so a wildcard-bound agent can sit behind it invisibly.
+ * The caller should verify with probeIsNstAgent() before trusting the address.
+ */
+function resolveAgentForUser(username) {
+  if (!username) return null;
+  const found = listAgents(username);
+  if (!found.length) return null;
+  // Two agent.exe for one user shouldn't happen; take the lowest port if it does.
+  return found.sort((a, b) => a.port - b.port)[0];
+}
+
+/**
+ * Does `address` actually speak the Nstbrowser API?
+ * The agent answers an unauthenticated request with 401; anything else on that
+ * port (our cache server, say) answers 404 or refuses the connection.
+ */
+async function probeIsNstAgent(address) {
+  try {
+    const res = await fetch(`${address}/profiles?page=1&limit=1`, { method: 'GET' });
+    return res.status === 401 || res.status === 200;
+  } catch {
+    return false;
+  }
+}
+
+// This machine's LAN IPv4 — the fallback when loopback is shadowed.
+function lanAddress(port) {
+  const os = require('os');
+  for (const list of Object.values(os.networkInterfaces() || {})) {
+    for (const ni of list || []) {
+      if (ni.family === 'IPv4' && !ni.internal) return `http://${ni.address}:${port}/api/v2`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Reachable API address of `username`'s agent, or null.
+ * Tries loopback first, then the LAN address — the agent binds 0.0.0.0, so a
+ * loopback-specific listener on the same port (our cache server) hides it from
+ * 127.0.0.1 while the LAN address still reaches it.
+ */
+async function agentAddressForUser(username) {
+  const agent = resolveAgentForUser(username);
+  if (!agent) return null;
+  for (const addr of [agent.address, lanAddress(agent.port)]) {
+    if (addr && await probeIsNstAgent(addr)) return { ...agent, address: addr };
+  }
+  return null;
+}
+
+// listAgents() shells out twice; launches call it on every profile open, so
+// hold the answer briefly. Agents only move port on logout/login.
+let _agentCache = { at: 0, agents: [] };
+function listAgentsCached(ttlMs = 60000, now = Date.now()) {
+  if (now - _agentCache.at < ttlMs) return _agentCache.agents;
+  const agents = listAgents();
+  _agentCache = { at: now, agents };
+  return agents;
+}
+
+module.exports = {
+  listAgents, listAgentsCached, resolveAgentForUser, agentAddressForUser, probeIsNstAgent, lanAddress,
+  parseTasklistCsv, parseListening,
+};

package/lib/nst-manager.js

@@ -1,3 +1,5 @@
+const { listAgentsCached, lanAddress } = require('./nst-agent-locator');
+
 function nstLaunchError(response, { profileId = '', runningCount = 0 } = {}) {
   const raw = String(response?.msg || 'Failed to connect browser').trim();
   if (!/exceeded plan limits/i.test(raw)) return new Error(raw);
@@ -22,7 +24,10 @@ function nstLaunchError(response, { profileId = '', runningCount = 0 } = {}) {
 class NstManager {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
-    this.baseUrl = options.apiAddress || 'http://localhost:8848/api/v2';
+    // Multi-user Windows: each logged-in session runs its OWN Nstbrowser agent,
+    // and the second one lands on 8849+ because 8848 is already taken machine-wide.
+    // NST_API_ADDRESS lets a daemon target its own session's agent.
+    this.baseUrl = options.apiAddress || process.env.NST_API_ADDRESS || 'http://localhost:8848/api/v2';
   }
 
   async api(path, options = {}) {
@@ -190,6 +195,49 @@ class NstManager {
     }
   }
 
+  // Which port is THIS manager talking to?
+  get _port() {
+    const m = String(this.baseUrl).match(/:(\d+)(?:\/|$)/);
+    return m ? Number(m[1]) : null;
+  }
+
+  // Ask one peer agent what it currently has open. Tries loopback then LAN:
+  // the agent binds 0.0.0.0, so a loopback-specific listener on the same port
+  // (another daemon's cache server) can hide it from 127.0.0.1.
+  async _peerBrowsers(agent) {
+    for (const addr of [agent.address, lanAddress(agent.port)]) {
+      if (!addr) continue;
+      try {
+        const res = await fetch(`${addr}/browsers`, { headers: { 'x-api-key': this.apiKey } });
+        if (res.status === 404) continue; // not the agent — something else holds this port
+        const data = await res.json();
+        if (data && data.data) return data.data;
+      } catch { /* try the next address */ }
+    }
+    return null;
+  }
+
+  /**
+   * Is `profileId` already open in ANOTHER session's agent on this machine?
+   *
+   * Both daemons see the same cloud-synced profile list, so both can be told to
+   * open the same profile. Letting that happen puts two browsers on one account:
+   * whichever closes last writes its cookie jar over the other's, which reads as
+   * a random logout. Cheaper to refuse the launch than to re-login the account.
+   */
+  async findProfileOnPeerAgents(profileId) {
+    if (process.platform !== 'win32') return null;
+    let agents = [];
+    try { agents = listAgentsCached(); } catch { return null; }
+    const myPort = this._port;
+    for (const a of agents) {
+      if (a.port === myPort) continue;
+      const list = await this._peerBrowsers(a);
+      if (list && list.some(b => b.profileId === profileId)) return a;
+    }
+    return null;
+  }
+
   // Launch browser — skip if already running, set proxy if provided
   async launchProfile(profileIdOrName, options = {}) {
     let profileId = profileIdOrName;
@@ -258,6 +306,20 @@ class NstManager {
       console.log(`[nst] Loading extension: ${options.extensionPath}`);
     }
 
+    const peer = await this.findProfileOnPeerAgents(profileId);
+    if (peer) {
+      const err = new Error(
+        `NST_PROFILE_ON_PEER_AGENT: profile ${profileId} đang mở ở agent khác trên cùng máy `
+        + `(pid ${peer.pid}, session ${peer.sessionId}/${peer.sessionName}, cổng ${peer.port}). `
+        + 'Mở song song cùng một profile ở hai phiên Windows sẽ ghi đè cookie của nhau '
+        + '→ tài khoản bị đăng xuất. Đóng bên kia trước, hoặc giao việc cho đúng worker.',
+      );
+      err.code = 'NST_PROFILE_ON_PEER_AGENT';
+      err.profileId = profileId;
+      err.peerPort = peer.port;
+      throw err;
+    }
+
     console.log(`[nst] Connecting browser for profile: ${profileId}`);
     const apiUrl = `${this.baseUrl}/connect/${profileId}?config=${encodeURIComponent(JSON.stringify(connectConfig))}`;
     const rawRes = await fetch(apiUrl, { headers: { 'x-api-key': this.apiKey } });

package/package.json

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

package/scripts/upload_facebook.js

@@ -22,12 +22,22 @@ const path = require('path');
 const { downloadToTemp, safeUnlink } = require('./lib/download');
 
 const FB_HOME_URL = 'https://www.facebook.com/';
+const FB_REEL_CREATE_URL = 'https://www.facebook.com/reels/create/';
 const REEL_CREATE_SELECTORS = [
   "a[aria-label='Tạo thước phim']",
   "a[aria-label='Create reel']",
   "a[aria-label='Create a reel']",
   "a[href*='/reels/create']",
 ];
+const REEL_ENTRY_SELECTORS = [
+  "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Thước phim']",
+  "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reel']",
+  "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reels']",
+  "div[role='region'][aria-label='Create post'] [aria-label='Reel']",
+  "div[role='region'][aria-label='Create post'] [aria-label='Reels']",
+  "div[role='region'][aria-label='Create post'] [aria-label='Create reel']",
+  "div[role='region'][aria-label='Create post'] [aria-label='Create a reel']",
+];
 // Residential proxies can leave Facebook's final "Đang tải..." state active
 // well past three minutes. The API only declares a publish command stale after
 // 20 minutes, so give the real upload enough room instead of failing while FB
@@ -91,6 +101,18 @@ async function navigateFacebookHome(page, log) {
   throw lastError || new Error('FB home navigation failed');
 }
 
+// Some Facebook cohorts render the Page-wall create-post widget as icon-only
+// controls (no Reel text/aria-label). In that layout there is no safe DOM
+// selector that distinguishes the composer trigger from the sidebar Reels feed.
+// Navigate to Facebook's dedicated CREATE route instead. This is only called
+// before a file is selected, so repeating it cannot create a duplicate post.
+async function navigateFacebookReelCreate(page, log) {
+  log('warn', '[fb-pw] Reel entry unavailable — hard navigating to /reels/create/ before upload…');
+  await page.goto(FB_REEL_CREATE_URL, { waitUntil: 'commit', timeout: 60_000 });
+  await page.waitForLoadState('domcontentloaded', { timeout: 60_000 }).catch(() => {});
+  await pause(page, 7000);
+}
+
 // FB drops a "Thông báo mới" toast at the BOTTOM-LEFT of the wall (e.g. "… và
 // 96 người khác thích thước phim của bạn") that lands ON TOP of the Reels
 // composer's bottom CTA. Playwright's hit-target check then blocks every
@@ -513,7 +535,7 @@ async function runOnce({ page, payload, log }) {
   } = payload || {};
   if (!video_url) throw new Error('No video_url provided');
 
-  log('info', '[fb-pw] selectors version=2026.08.06-composer-retry-metadata-poll');
+  log('info', '[fb-pw] selectors version=2026.08.28-icon-only-create-route-fallback');
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
@@ -625,15 +647,8 @@ async function runOnce({ page, payload, log }) {
     //    instead of opening the composer (observed on the brain-made-simple
     //    page wall — clicked feed link, played random viral reel).
     log('info', '[fb-pw] click "Thước phim" entry inside "Tạo bài viết"…');
-    const reelEntryCandidates = [
-      // Scoped to the create-post widget — this is the only correct trigger.
-      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Thước phim']",
-      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reel']",
-      "div[role='region'][aria-label='Tạo bài viết'] [aria-label='Reels']",
-      "div[role='region'][aria-label='Create post'] [aria-label='Reels']",
-    ];
     let reelOpened = false;
-    for (const sel of reelEntryCandidates) {
+    for (const sel of REEL_ENTRY_SELECTORS) {
       const btn = await firstVisible(page.locator(sel), 5);
       if (!btn) continue;
       try {
@@ -647,26 +662,46 @@ async function runOnce({ page, payload, log }) {
     // text/aria starts with "Thước phim"/"Reel" but is NOT in the sidebar.
     if (!reelOpened) {
       const probed = await page.evaluate(() => {
-        const regions = document.querySelectorAll("[role='region'], [aria-label='Tạo bài viết']");
-        for (const region of regions) {
+        // Nhánh aria TỪNG chỉ dò tiếng Việt. Tài khoản để tiếng Anh mà mục
+        // Thước phim chỉ có ICON (không chữ) thì `t` rỗng, `al` là "Reel" —
+        // trượt cả hai vế, coi như không có mục nào, rơi xuống /reels/create/.
+        // Đúng cảnh kênh 6a2e66b3 (profile kenh-26) hỏng suốt từ 27/08.
+        const wantText = /^thước phim$|^reels?$/i;
+        const wantAria = /^(thước phim|reels?|create (a )?reel|tạo thước phim)$/i;
+        const inventory = [];
+        let regionSeen = 0;
+        const allRegions = [];
+        for (const region of document.querySelectorAll("[role='region'], [aria-label='Tạo bài viết']")) {
           const aria = (region.getAttribute('aria-label') || '').toLowerCase();
+          if (allRegions.length < 10 && aria) allRegions.push(aria.slice(0, 30));
           if (!/tạo bài viết|create post/.test(aria)) continue;
-          const btns = region.querySelectorAll("[role='button'], button, a");
-          for (const b of btns) {
+          regionSeen++;
+          for (const b of region.querySelectorAll("[role='button'], button, a")) {
             const t = (b.innerText || b.textContent || '').trim();
             const al = (b.getAttribute('aria-label') || '').trim();
-            const sig = (t + '|' + al).toLowerCase();
-            if (/^thước phim|^reels?$/i.test(t.trim()) || /thước phim/i.test(al)) {
-              const r = b.getBoundingClientRect();
-              if (r.width < 8 || r.height < 8) continue;
+            const r = b.getBoundingClientRect();
+            if (r.width < 8 || r.height < 8) continue;
+            // Gom lại để nếu vẫn trượt thì log NÓI RA nhãn thật, khỏi đoán mò
+            // vòng sau (lần này mất một buổi mới dựng lại được).
+            if (inventory.length < 12) inventory.push(`t="${t.slice(0, 24)}" al="${al.slice(0, 24)}"`);
+            if (wantText.test(t) || wantAria.test(al)) {
               b.setAttribute('__fbpw_reel_entry__', '1');
               return { selector: "[__fbpw_reel_entry__='1']", text: t.slice(0, 40), aria: al.slice(0, 40) };
             }
           }
         }
-        return null;
+        return { miss: true, inventory, regionSeen, allRegions };
       }).catch(() => null);
-      if (probed) {
+      if (probed && probed.miss) {
+        // Phân biệt "có widget mà thiếu mục" với "không thấy widget nào" —
+        // hai chuyện cần hai cách xử lý khác hẳn.
+        if (!probed.regionSeen) {
+          log('warn', `[fb-pw] KHÔNG thấy widget "Tạo bài viết"/"Create post" nào trên trang chủ — các region đang có: ${JSON.stringify(probed.allRegions)}`);
+        } else {
+          log('warn', `[fb-pw] có widget "Tạo bài viết" nhưng KHÔNG có mục Thước phim — nút đang có: ${JSON.stringify(probed.inventory)}`);
+        }
+      }
+      if (probed && probed.selector) {
         try {
           await page.locator(probed.selector).click({ timeout: 3000 });
           log('info', `[fb-pw] Thước phim clicked via region-probe (text="${probed.text}" aria="${probed.aria}")`);
@@ -676,10 +711,13 @@ async function runOnce({ page, payload, log }) {
         }
       }
     }
+    let usedCreateRoute = false;
     if (!reelOpened) {
-      await dumpInventory(page, log, 'no-reel-entry');
-      await dumpFailure(page, 'no-reel-entry', log);
-      throw new Error('FB home: "Thước phim" entry not found in "Tạo bài viết" widget (sidebar Reels feed link doesn\'t count — it navigates instead of opening composer)');
+      // English/icon-only Page layouts expose Live video, Photo/video and Reel
+      // as bare SVG controls. The old code failed here even though the official
+      // create route was usable. Go there before touching any file input.
+      usedCreateRoute = true;
+      await navigateFacebookReelCreate(page, log);
     }
     await pause(page, 4000);
     const afterUrl = page.url();
@@ -687,6 +725,17 @@ async function runOnce({ page, payload, log }) {
     // Sanity check: clicking the sidebar Reels link navigates to /reel/<id>.
     // That means we clicked the wrong button — fail fast so the user knows.
     if (/\/reel\/\d+/.test(afterUrl)) {
+      // HAI nguyên nhân hoàn toàn khác nhau, trước đây gộp chung một câu báo
+      // "wrong button matched" — và câu đó gửi người đọc đi tìm lỗi DOM không
+      // hề tồn tại (kênh 6a2e66b3 hỏng suốt từ 27/08 vì hiểu nhầm chỗ này):
+      //   a) BẤM nhầm nút  → đúng là lỗi layout, sửa selector.
+      //   b) Không có nút nào để bấm, phải đi thẳng /reels/create/, rồi CHÍNH
+      //      Facebook đá về feed → tài khoản này không mở được trình tạo
+      //      Thước phim. Sửa selector bao nhiêu cũng vô ích.
+      await dumpFailure(page, 'reel-create-bounced', log).catch(() => {});
+      if (usedCreateRoute) {
+        throw new Error(`FB không mở được trình tạo Thước phim cho tài khoản này: widget "Tạo bài viết" không có mục Thước phim, và /reels/create/ bị Facebook đá về feed (${afterUrl}). Đây KHÔNG phải lỗi selector — cần người đăng nhập profile này và thử tạo Thước phim bằng tay (tài khoản có thể chưa đủ điều kiện đăng Reels, hoặc đang đăng nhập sai trang).`);
+      }
       throw new Error(`FB Thước phim click navigated to Reels feed (${afterUrl}) — wrong button matched, should be composer modal. Check "Tạo bài viết" widget layout on this Page.`);
     }
 
@@ -748,10 +797,7 @@ async function runOnce({ page, payload, log }) {
       // stuck client-side router. No video has been selected yet, so this
       // cannot create a duplicate post.
       if (!reelsRoot) {
-        log('warn', '[fb-pw] create link still produced no composer — hard navigating to /reels/create/…');
-        await page.goto('https://www.facebook.com/reels/create/', { waitUntil: 'commit', timeout: 60_000 });
-        await page.waitForLoadState('domcontentloaded', { timeout: 60_000 }).catch(() => {});
-        await pause(page, 7000);
+        await navigateFacebookReelCreate(page, log);
         await dismissBsOnboarding(page, log).catch(() => {});
         reelsRoot = await findComposerRoot(8000);
       }
@@ -2721,6 +2767,9 @@ module.exports.__testables = {
   hasVisibleReelComposer,
   SAFE_RETRY_COMPOSER_CLOSED,
   navigateFacebookHome,
+  navigateFacebookReelCreate,
   PUBLISH_ENABLE_TIMEOUT_MS,
   REEL_CREATE_SELECTORS,
+  REEL_ENTRY_SELECTORS,
+  FB_REEL_CREATE_URL,
 };