channel-worker 2.5.41 → 2.5.44

package/lib/api-client.js

@@ -173,6 +173,26 @@ class ApiClient {
   async postExtensionLog({ level = 'info', message = '', data = null, profile_id = '', job_id = null } = {}) {
     return this.request('POST', '/extension/log', { level, message, data, profile_id, job_id });
   }
+
+  // Persist a browser screenshot captured by a Playwright publish script.
+  // The API stores the bytes on the media server; only the returned path/URL
+  // is written into extension_log, never the base64 payload itself.
+  async uploadDebugScreenshot({ filePath, tag = 'failure', command_id = '', job_id = '', profile_id = '', platform = '' } = {}) {
+    const fs = require('fs');
+    const path = require('path');
+    if (!filePath) throw new Error('debug screenshot filePath required');
+    const file = fs.readFileSync(filePath);
+    return this.request('POST', '/extension/debug-screenshot', {
+      image_base64: file.toString('base64'),
+      content_type: 'image/png',
+      file_name: path.basename(filePath),
+      tag,
+      command_id,
+      job_id,
+      profile_id,
+      platform,
+    });
+  }
 }
 
 module.exports = { ApiClient };

package/lib/command-poller.js

@@ -286,6 +286,17 @@ class CommandPoller {
       this.api.postExtensionLog?.({ level, message, data, profile_id: profileId, job_id: payload.job_id || null })
         .catch(() => {});
     };
+    // Publish scripts attach screenshots to warning logs through this helper.
+    // Keep the command/job identity here so the API and idea Publish History
+    // can associate an artifact with the exact platform attempt.
+    log.uploadDebugScreenshot = (filePath, meta = {}) => this.api.uploadDebugScreenshot({
+      filePath,
+      tag: meta.tag || 'failure',
+      command_id: String(command._id),
+      job_id: payload.job_id || '',
+      profile_id: profileId,
+      platform: scriptName.replace(/^upload_/, ''),
+    });
 
     try {
       const result = await runPlaywrightScript({

package/package.json

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

package/scripts/upload_facebook.js

@@ -35,11 +35,11 @@ async function isActionable(el) {
   return true;
 }
 
-async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button' } = {}) {
+async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button', clickOpts = null } = {}) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await isActionable(loc)) {
-      await loc.click();
+      await loc.click(clickOpts || undefined);
       return;
     }
     await loc.page().waitForTimeout(800);
@@ -47,6 +47,106 @@ async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button' } =
   throw new Error(`${label} never became actionable within ${timeoutMs}ms`);
 }
 
+// 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
+// click — "<b>96 người khác</b> from <div data-visualcompletion='ignore'>
+// subtree intercepts pointer events" — and the job dies at step 1 even though
+// the button is visible + enabled. Same story for the feed hover-cards behind
+// the modal. This mutes whatever sits over the button's centre point: from
+// elementFromPoint, walk up to the outermost ancestor that still does NOT
+// contain the target (= the toast/hover-card portal root) and kill its
+// pointer-events. Muted nodes are tagged so we can restore them right after
+// the click — leaving a portal permanently dead could break a later step that
+// renders into the same container. Returns how many layers were muted.
+async function muteClickInterceptors(page, selector) {
+  return page.evaluate((sel) => {
+    const el = document.querySelector(sel);
+    if (!el) return 0;
+    const r = el.getBoundingClientRect();
+    const cx = r.x + r.width / 2;
+    const cy = r.y + r.height / 2;
+    let muted = 0;
+    for (let pass = 0; pass < 4; pass++) {
+      const top = document.elementFromPoint(cx, cy);
+      if (!top || top === el || el.contains(top) || top.contains(el)) break;
+      let root = top;
+      while (root.parentElement && root.parentElement !== document.body && !root.parentElement.contains(el)) {
+        root = root.parentElement;
+      }
+      if (root === document.body || root.contains(el)) break;
+      // Already muted and STILL on top (a stylesheet !important beats our
+      // inline style) — muting again would overwrite the saved original with
+      // 'none' and leave the node permanently dead after the restore.
+      if (root.hasAttribute('__fbpw_muted__')) break;
+      root.setAttribute('__fbpw_muted__', root.style.pointerEvents || '_');
+      root.style.pointerEvents = 'none';
+      muted++;
+    }
+    return muted;
+  }, selector).catch(() => 0);
+}
+
+async function unmuteClickInterceptors(page) {
+  return page.evaluate(() => {
+    document.querySelectorAll('[__fbpw_muted__]').forEach((el) => {
+      const prev = el.getAttribute('__fbpw_muted__');
+      el.style.pointerEvents = prev === '_' ? '' : prev;
+      el.removeAttribute('__fbpw_muted__');
+    });
+  }).catch(() => {});
+}
+
+// Click that survives FB's overlay noise. Order of escalation:
+//   1. park the cursor in a corner (a mouse resting over the feed behind the
+//      modal keeps a hover-card alive right on top of the CTA),
+//   2. native click — highest fidelity,
+//   3. on failure, mute whatever intercepts the click point and retry natively,
+//   4. last resort, JS-dispatch el.click() (bypasses hit-testing entirely).
+// `jsFallback:false` for actions that must never fire twice (publish) — those
+// call sites run their own guarded fallback.
+// `landedCheck` guards the escalation: Playwright can report a timeout for a
+// click that DID register (the node detaches mid-action). Callers pass a probe
+// for "the UI already moved on" so we don't fire a second click on top of it.
+async function resilientClick(page, loc, selector, { timeout = 10_000, log, label = 'button', jsFallback = true, attempts = 3, landedCheck = null } = {}) {
+  try { await loc.scrollIntoViewIfNeeded({ timeout: 3000 }); } catch {}
+  await page.mouse.move(2, 2).catch(() => {});
+  let lastErr = null;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      await loc.click({ timeout });
+      await unmuteClickInterceptors(page);
+      return 'native';
+    } catch (e) {
+      lastErr = e;
+      if (landedCheck && await landedCheck().catch(() => false)) {
+        if (log) log('info', `[fb-pw] ${label} click reported a timeout but the UI advanced → treating as clicked`);
+        await unmuteClickInterceptors(page);
+        return 'landed';
+      }
+      const muted = await muteClickInterceptors(page, selector);
+      if (log) log('warn', `[fb-pw] ${label} click attempt ${attempt + 1}/${attempts} failed (${e.message.split('\n')[0].slice(0, 70)}) — muted ${muted} overlay layer(s)`);
+      await page.waitForTimeout(500);
+    }
+  }
+  if (jsFallback) {
+    const ok = await page.evaluate((sel) => {
+      const el = document.querySelector(sel);
+      if (!el) return false;
+      el.scrollIntoView({ block: 'center' });
+      el.click();
+      return true;
+    }, selector).catch(() => false);
+    if (ok) {
+      if (log) log('info', `[fb-pw] ${label} clicked via JS-dispatch fallback`);
+      await unmuteClickInterceptors(page);
+      return 'js';
+    }
+  }
+  await unmuteClickInterceptors(page);
+  throw lastErr || new Error(`${label}: click failed`);
+}
+
 // Same inventory dump as iter-2 (kept for failure diagnostics).
 async function dumpInventory(page, log, tag) {
   try {
@@ -119,7 +219,19 @@ async function dumpFailure(page, tag, log) {
     fs.mkdirSync(dir, { recursive: true });
     const png = path.join(dir, `fb-${tag}-${Date.now()}.png`);
     await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
-    log('warn', `[fb-pw] dump ${tag} — url=${page.url()} screenshot=${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[fb-pw] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[fb-pw] dump ${tag} — url=${page.url()} screenshot=${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
   } catch {}
 }
 
@@ -236,10 +348,17 @@ async function setVideoFile(page, inputHandle, filePath, log, tag = 'fb-pw') {
 // throw no-advance. Poll until a bottom-half publish-verb button is present
 // AND enabled. Returns true once enabled; false on timeout, or fast-false if no
 // publish button ever appears (we're not actually on the final step).
-async function waitForPublishEnabled(page, verbs, log, timeoutMs, tag = 'fb-pw') {
+async function waitForPublishEnabled(page, verbs, log, timeoutMs, tag = 'fb-pw', { onPoll = null } = {}) {
   const deadline = Date.now() + timeoutMs;
   let announced = false, sawPresent = false, absent = 0;
   while (Date.now() < deadline) {
+    // The final metadata form mounts lazily on some FB cohorts. The first
+    // fillMetadata() immediately after Tiếp can run before its textbox exists,
+    // leaving the form blank and Đăng disabled forever. Let the caller retry
+    // its idempotent metadata fill while we wait for video processing.
+    if (onPoll) await onPoll().catch((e) => {
+      log('warn', `[${tag}] final metadata retry failed: ${e.message.slice(0, 100)}`);
+    });
     const st = await page.evaluate((vbs) => {
       const dlgs = document.querySelectorAll("[role='dialog']");
       const roots = dlgs.length ? Array.from(dlgs) : [document];
@@ -262,28 +381,53 @@ async function waitForPublishEnabled(page, verbs, log, timeoutMs, tag = 'fb-pw')
     }, verbs).catch(() => ({ present: false, enabled: false }));
     if (st.enabled) {
       if (announced) log('info', `[${tag}] "Đăng" is now enabled — video finished processing`);
-      return true;
+      return { enabled: true, sawPresent: true };
     }
     if (st.present) {
       sawPresent = true;
       if (!announced) { log('info', `[${tag}] final step: "Đăng" disabled (video still processing) — waiting up to ${Math.round(timeoutMs / 1000)}s…`); announced = true; }
     } else if (!sawPresent && ++absent >= 4) {
-      return false; // no publish CTA after ~10s → not the final step
+      return { enabled: false, sawPresent: false }; // no publish CTA after ~10s → not the final step
     }
     await page.waitForTimeout(2500);
   }
   log('warn', `[${tag}] "Đăng" never became enabled within ${Math.round(timeoutMs / 1000)}s`);
-  return false;
+  return { enabled: false, sawPresent };
+}
+
+const SAFE_RETRY_COMPOSER_CLOSED = 'FB_SAFE_RETRY_COMPOSER_CLOSED';
+
+function safeComposerRetryError(message) {
+  const err = new Error(message);
+  err.code = SAFE_RETRY_COMPOSER_CLOSED;
+  return err;
 }
 
-async function run({ page, payload, log }) {
+async function hasVisibleReelComposer(page) {
+  return page.evaluate(() => {
+    for (const dlg of document.querySelectorAll("[role='dialog']")) {
+      const r = dlg.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8) continue;
+      const cs = getComputedStyle(dlg);
+      if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') continue;
+      const aria = dlg.getAttribute('aria-label') || '';
+      const text = (dlg.innerText || '').slice(0, 500);
+      const signature = `${aria}\n${text}`;
+      if (/Chỉnh sửa hình thu nhỏ|Edit thumbnail/i.test(signature)) continue;
+      if (/Tạo thước phim|Chỉnh sửa thước phim|Cài đặt thước phim|Create (?:a )?reel|Edit reel|Reel settings/i.test(signature)) return true;
+    }
+    return false;
+  }).catch(() => false);
+}
+
+async function runOnce({ page, payload, log }) {
   const {
     video_url, title, description = '', tags = [],
     visibility = 'public', format = 'short',
   } = payload || {};
   if (!video_url) throw new Error('No video_url provided');
 
-  log('info', '[fb-pw] selectors version=2026.06.19d-reels-link-fallback');
+  log('info', '[fb-pw] selectors version=2026.08.06-composer-retry-metadata-poll');
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
@@ -730,6 +874,13 @@ async function run({ page, payload, log }) {
           "[role='textbox'][aria-placeholder*='Mô tả thước phim']",
           "[role='textbox'][aria-placeholder*='Mô tả']",
           "[role='textbox'][aria-placeholder*='Describe your reel']",
+          // Newer Lexical/contenteditable cohorts expose data-placeholder
+          // instead of aria-placeholder. Scope these to a dialog so a feed
+          // comment box can never receive the reel caption.
+          "[role='dialog'] [contenteditable='true'][data-placeholder*='Mô tả thước phim']",
+          "[role='dialog'] [contenteditable='true'][data-placeholder*='Mô tả']",
+          "[role='dialog'] [contenteditable='true'][data-placeholder*='Describe your reel']",
+          "[role='dialog'] [contenteditable='true'][aria-label*='Mô tả thước phim']",
           // BS composer description — legacy.
           "[role='textbox'][aria-label*='Mô tả']",
           "[role='textbox'][aria-label*='hộp thoại']",
@@ -744,11 +895,61 @@ async function run({ page, payload, log }) {
             const descText = (fbCaption || description || title || '').toString().slice(0, 2100);
             if (!descText) break;
             await f.type(descText, { delay: 12 });
+            // Blur commits the Lexical/React value and re-runs the form's
+            // validation. Without this, the text can be visible while Đăng
+            // remains disabled against the previous empty state.
+            await page.keyboard.press('Tab').catch(() => {});
             fillState.description = true;
             log('info', `[fb-pw] description filled (${descText.length} chars) via "${sel}"`);
             break;
           } catch (e) { log('info', `[fb-pw] desc via "${sel}" failed: ${e.message.slice(0, 80)}`); }
         }
+        // Attribute shapes move frequently. Last-resort probe the visible Reel
+        // dialog for an editable whose combined accessibility signature names
+        // the description, tag it, and let Playwright type through the normal
+        // input path. This specifically covers the production cohort where the
+        // placeholder rendered after step 3 but none of the static selectors
+        // matched it on the first pass.
+        if (!fillState.description) {
+          const probe = await page.evaluate(() => {
+            document.querySelectorAll('[__fbpw_desc__]').forEach((el) => el.removeAttribute('__fbpw_desc__'));
+            const dialogs = [...document.querySelectorAll("[role='dialog']")];
+            for (const dlg of dialogs) {
+              const dr = dlg.getBoundingClientRect();
+              if (dr.width < 8 || dr.height < 8) continue;
+              const ds = `${dlg.getAttribute('aria-label') || ''}\n${(dlg.innerText || '').slice(0, 500)}`;
+              if (!/thước phim|reel/i.test(ds)) continue;
+              for (const el of dlg.querySelectorAll("[role='textbox'], [contenteditable='true'], textarea, input")) {
+                const r = el.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                const sig = [
+                  el.getAttribute('aria-placeholder'), el.getAttribute('data-placeholder'),
+                  el.getAttribute('placeholder'), el.getAttribute('aria-label'),
+                  el.textContent,
+                ].filter(Boolean).join('|');
+                if (!/Mô tả(?: thước phim)?|Describe (?:your )?reel/i.test(sig)) continue;
+                el.setAttribute('__fbpw_desc__', '1');
+                return "[__fbpw_desc__='1']";
+              }
+            }
+            return null;
+          }).catch(() => null);
+          if (probe) {
+            try {
+              const f = page.locator(probe);
+              const descText = (fbCaption || description || title || '').toString().slice(0, 2100);
+              await f.click({ timeout: 3000 });
+              await f.type(descText, { delay: 12 });
+              await page.keyboard.press('Tab').catch(() => {});
+              fillState.description = true;
+              log('info', `[fb-pw] description filled (${descText.length} chars) via dynamic-probe`);
+            } catch (e) {
+              log('info', `[fb-pw] desc dynamic-probe failed: ${e.message.slice(0, 80)}`);
+            } finally {
+              await page.evaluate(() => document.querySelectorAll('[__fbpw_desc__]').forEach((el) => el.removeAttribute('__fbpw_desc__'))).catch(() => {});
+            }
+          }
+        }
       }
 
       // Tags (Thêm thẻ) — comma-separated; STRIP leading "#" since FB's tag
@@ -929,8 +1130,12 @@ async function run({ page, payload, log }) {
           if (!bestEl) bestEl = tryScope(null);
           if (!bestEl) return null;
           // Tag the element so Playwright can find it back. data-attribute is
-          // safe + ignored by FB's React reconciliation.
+          // safe + ignored by FB's React reconciliation. Clear stale markers
+          // FIRST: a click that threw never reached the cleanup below, so an
+          // old node could still carry the marker → the locator would resolve
+          // to 2 elements and every later click dies on strict mode.
           const marker = '__fbpw_target__';
+          document.querySelectorAll(`[${marker}]`).forEach((n) => n.removeAttribute(marker));
           bestEl.setAttribute(marker, '1');
           return { selector: `[${marker}='1']`, tag: bestEl.tagName.toLowerCase() };
         }, { verb: v, bottomHalf: requireBottomHalf });
@@ -938,17 +1143,23 @@ async function run({ page, payload, log }) {
           const loc = page.locator(found.selector);
           return {
             hit: {
-              click: async (opts) => {
-                // scrollIntoViewIfNeeded handles off-screen primary actions
-                // (e.g. Chia sẻ ngay at y=-274 after a step jump). Then
-                // Playwright's click auto-waits visible+stable.
-                try { await loc.scrollIntoViewIfNeeded({ timeout: 3000 }); } catch {}
-                await loc.click({ timeout: opts?.timeout || 5000 });
+              click: async (opts = {}) => {
+                // resilientClick handles scroll-into-view (off-screen primary
+                // actions like Chia sẻ ngay at y=-274 after a step jump) and,
+                // more importantly, FB's toast/hover-card overlays that cover
+                // the CTA and make Playwright's hit-target check fail forever.
+                await resilientClick(page, loc, found.selector, {
+                  timeout: opts?.timeout || 10_000,
+                  log,
+                  label: opts?.label || v,
+                  jsFallback: opts?.jsFallback !== false,
+                  landedCheck: opts?.landedCheck || null,
+                });
                 // Remove the marker so subsequent findByVerbs gets a fresh
                 // element instead of clinging to the now-stale node.
-                await page.evaluate((sel) => {
-                  document.querySelectorAll(sel).forEach((el) => el.removeAttribute(sel.replace(/[\[\]'=1]/g, '')));
-                }, found.selector).catch(() => {});
+                await page.evaluate(() => {
+                  document.querySelectorAll('[__fbpw_target__]').forEach((el) => el.removeAttribute('__fbpw_target__'));
+                }).catch(() => {});
               },
               isVisible: async () => loc.isVisible().catch(() => false),
               isEnabled: async () => loc.isEnabled().catch(() => true),
@@ -1047,15 +1258,32 @@ async function run({ page, payload, log }) {
             // Wait for the thumb-edit modal to mount. Header text =
             // "Chỉnh sửa hình thu nhỏ".
             await page.evaluate(() => document.querySelectorAll("[__fbpw_thumb_edit__]").forEach((el) => el.removeAttribute('__fbpw_thumb_edit__'))).catch(() => {});
+            const thumbDialogReady = await page.evaluate(() => {
+              document.querySelectorAll('[__fbpw_thumb_dialog__]').forEach((el) => el.removeAttribute('__fbpw_thumb_dialog__'));
+              for (const dlg of document.querySelectorAll("[role='dialog']")) {
+                const r = dlg.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                const cs = getComputedStyle(dlg);
+                if (cs.visibility === 'hidden' || cs.display === 'none' || cs.opacity === '0') continue;
+                const sig = `${dlg.getAttribute('aria-label') || ''}\n${(dlg.innerText || '').slice(0, 300)}`;
+                if (!/Chỉnh sửa hình thu nhỏ|Edit thumbnail/i.test(sig)) continue;
+                dlg.setAttribute('__fbpw_thumb_dialog__', '1');
+                return true;
+              }
+              return false;
+            }).catch(() => false);
+            if (!thumbDialogReady) throw new Error('thumbnail editor dialog did not mount');
 
             // Click "Tải lên" button — opens OS file picker. Use filechooser
-            // race to inject the file path directly.
+            // race to inject the file path directly. Scope every action to the
+            // exact thumbnail dialog: Facebook can simultaneously keep its
+            // Notifications dialog and the outer Reel composer in the DOM.
             const uploadCandidates = [
-              "[role='dialog'] div[role='button']:has-text('Tải lên')",
-              "[role='dialog'] button:has-text('Tải lên')",
-              "[role='dialog'] [aria-label='Tải lên']",
-              "[role='dialog'] [aria-label*='Tải hình thu nhỏ']",
-              "[role='dialog'] div[role='button']:has-text('Upload')",
+              "[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Tải lên')",
+              "[__fbpw_thumb_dialog__='1'] button:has-text('Tải lên')",
+              "[__fbpw_thumb_dialog__='1'] [aria-label='Tải lên']",
+              "[__fbpw_thumb_dialog__='1'] [aria-label*='Tải hình thu nhỏ']",
+              "[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Upload')",
             ];
             let uploaded = false;
             for (const sel of uploadCandidates) {
@@ -1079,7 +1307,7 @@ async function run({ page, payload, log }) {
             // Fallback — direct setInputFiles on a hidden image-accepting
             // file input inside the modal.
             if (!uploaded) {
-              const directInput = page.locator("[role='dialog'] input[type='file'][accept*='image']").last();
+              const directInput = page.locator("[__fbpw_thumb_dialog__='1'] input[type='file'][accept*='image']").last();
               if (await directInput.count().catch(() => 0) > 0) {
                 try {
                   await directInput.setInputFiles(thumbPath);
@@ -1095,10 +1323,10 @@ async function run({ page, payload, log }) {
             if (uploaded) {
               // Click "Lưu" to save the new thumbnail.
               const saveCandidates = [
-                "[role='dialog'] div[role='button']:has-text('Lưu')",
-                "[role='dialog'] button:has-text('Lưu')",
-                "[role='dialog'] [aria-label='Lưu']",
-                "[role='dialog'] div[role='button']:has-text('Save')",
+                "[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Lưu')",
+                "[__fbpw_thumb_dialog__='1'] button:has-text('Lưu')",
+                "[__fbpw_thumb_dialog__='1'] [aria-label='Lưu']",
+                "[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Save')",
               ];
               let saved = false;
               for (const sel of saveCandidates) {
@@ -1158,13 +1386,21 @@ async function run({ page, payload, log }) {
                   await page.waitForTimeout(1000);
                 }
                 if (modalClosed) {
+                  // Closing the nested thumbnail editor is NOT enough. In the
+                  // 2026-08-05 failure Facebook unmounted the OUTER composer at
+                  // the same moment, leaving us on the Page feed. Retrying is
+                  // safe here because the publish branch has not run yet.
+                  if (!(await hasVisibleReelComposer(page))) {
+                    await dumpFailure(page, 'composer-closed-after-thumb-save', log);
+                    throw safeComposerRetryError('FB Reel composer closed after saving thumbnail (before publish)');
+                  }
                   thumbApplied = true;
                   log('info', `[fb-pw] page-wall thumb — modal closed after save (retries=${retryCount})`);
                 } else {
                   log('warn', '[fb-pw] page-wall thumb — modal still open 60s after Lưu click; trying ESC + click Hủy fallback');
                   await page.keyboard.press('Escape').catch(() => {});
                   await page.waitForTimeout(800);
-                  const cancel = await firstVisible(page.locator("[role='dialog'] div[role='button']:has-text('Hủy'), [role='dialog'] button:has-text('Hủy')"), 2);
+                  const cancel = await firstVisible(page.locator("[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Hủy'), [__fbpw_thumb_dialog__='1'] button:has-text('Hủy')"), 2);
                   if (cancel) await cancel.click({ timeout: 2000 }).catch(() => {});
                   await page.waitForTimeout(1500);
                 }
@@ -1173,11 +1409,12 @@ async function run({ page, payload, log }) {
               }
             } else {
               log('warn', '[fb-pw] page-wall thumb upload failed — closing modal via Hủy to continue');
-              const cancel = await firstVisible(page.locator("[role='dialog'] div[role='button']:has-text('Hủy'), [role='dialog'] button:has-text('Hủy')"), 2);
+              const cancel = await firstVisible(page.locator("[__fbpw_thumb_dialog__='1'] div[role='button']:has-text('Hủy'), [__fbpw_thumb_dialog__='1'] button:has-text('Hủy')"), 2);
               if (cancel) await cancel.click({ timeout: 2000 }).catch(() => {});
               await page.waitForTimeout(1500);
             }
           } catch (e) {
+            if (e?.code === SAFE_RETRY_COMPOSER_CLOSED) throw e;
             log('warn', `[fb-pw] page-wall thumb flow failed: ${e.message.slice(0, 100)}`);
           }
           customThumbDone = thumbApplied;
@@ -1565,6 +1802,23 @@ async function run({ page, payload, log }) {
           // the user re-posted → duplicate reel. So: if the button vanished
           // after we clicked, it went through.
           const publishBtnGone = async () => !(await findByVerbs(publishVerbs, { requireBottomHalf: true }));
+          // Marker-free twin of publishBtnGone, for use DURING a click retry:
+          // findByVerbs re-tags __fbpw_target__, which would yank the marker
+          // out from under the locator we're mid-click on.
+          const publishBtnGoneDom = async () => page.evaluate((verbs) => {
+            const scopes = [...document.querySelectorAll("[role='dialog']")];
+            for (const s of (scopes.length ? scopes : [document.body])) {
+              for (const b of s.querySelectorAll("button, [role='button']")) {
+                if (!verbs.includes((b.innerText || '').trim())) continue;
+                const r = b.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                if (r.y < window.innerHeight * 0.4) continue;
+                if (b.getAttribute('aria-disabled') === 'true' || b.disabled) continue;
+                return false;
+              }
+            }
+            return true;
+          }, publishVerbs).catch(() => false);
           for (let attempt = 0; attempt < 3 && !clickedPublish; attempt++) {
             const target = attempt === 0 ? pub : await findByVerbs(publishVerbs, { requireBottomHalf: true });
             if (!target) {
@@ -1573,7 +1827,16 @@ async function run({ page, payload, log }) {
             }
             attemptedClick = true;
             try {
-              await target.hit.click({ timeout: 15000 });
+              // jsFallback:false — publish must never fire twice. The guarded
+              // JS-dispatch below (attempt 3, after publishBtnGone checks) owns
+              // that escalation; the generic one inside resilientClick would
+              // bypass those guards. Overlay-muting + landedCheck still apply.
+              await target.hit.click({
+                timeout: 15000,
+                label: `Đăng(${step + 1})`,
+                jsFallback: false,
+                landedCheck: publishBtnGoneDom,
+              });
               clickedPublish = true;
             } catch (ce) {
               log('warn', `[fb-pw] publish click attempt ${attempt + 1}/3 threw: ${ce.message.slice(0, 90)}`);
@@ -1615,6 +1878,10 @@ async function run({ page, payload, log }) {
                   for (const b of btns) {
                     const t = (b.innerText || '').trim();
                     if (t === v) {
+                      // Clear stale markers first — a previous confirm attempt
+                      // that threw left its tag behind, and two tagged nodes
+                      // make the locator fail on strict mode.
+                      document.querySelectorAll('[__fbpw_confirm__]').forEach((n) => n.removeAttribute('__fbpw_confirm__'));
                       b.setAttribute('__fbpw_confirm__', '1');
                       return { selector: "[__fbpw_confirm__='1']", verb: v };
                     }
@@ -1628,8 +1895,18 @@ async function run({ page, payload, log }) {
           if (confirmHit) {
             log('info', `[fb-pw] confirming publish via dialog button "${confirmHit.verb}"`);
             const cLoc = page.locator(confirmHit.selector);
-            try { await cLoc.scrollIntoViewIfNeeded({ timeout: 2000 }); } catch {}
-            await cLoc.click({ timeout: 5000 }).catch((e) => log('warn', `[fb-pw] confirm click failed: ${e.message.slice(0, 80)}`));
+            // Was a plain 5s click: it failed on nearly EVERY run ("confirm
+            // click failed: Timeout 5000ms exceeded") because the new-post
+            // toast covers this dialog's CTA too. Escalate the same way —
+            // mute the overlay, then JS-dispatch. The confirm button lives in
+            // a dialog that disappears once it fires, so the fallback can't
+            // double-publish (querySelector returns null on the second pass).
+            await resilientClick(page, cLoc, confirmHit.selector, {
+              timeout: 8000,
+              log,
+              label: `confirm "${confirmHit.verb}"`,
+              attempts: 2,
+            }).catch((e) => log('warn', `[fb-pw] confirm click failed: ${e.message.split('\n')[0].slice(0, 80)}`));
             await page.waitForTimeout(3000);
           } else {
             log('info', '[fb-pw] no confirmation dialog detected after 8s — assuming direct publish');
@@ -1701,15 +1978,59 @@ async function run({ page, payload, log }) {
         if (!pubWaitDone) {
           pubWaitDone = true;
           log('info', `[fb-pw] no "Tiếp" + no enabled publish at step ${step + 1} — waiting for "Đăng" to enable (large-video processing)…`);
-          if (await waitForPublishEnabled(page, publishVerbs, log, 180_000)) { step--; continue; }
+          const waitResult = await waitForPublishEnabled(page, publishVerbs, log, 180_000, 'fb-pw', {
+            // Idempotent: once the field is filled, fillState makes this a
+            // no-op. Until then it catches a lazily-mounted final form that
+            // the first post-Tiếp pass raced past.
+            onPoll: fillMetadata,
+          });
+          if (waitResult.enabled) { step--; continue; }
+          await dumpInventory(page, log, `no-advance-${step + 1}`);
+          await dumpFailure(page, `no-advance-${step + 1}`, log);
+          if (!fillState.description) {
+            throw new Error(`FB final description field not found at step ${step + 1}`);
+          }
+          if (waitResult.sawPresent) {
+            throw new Error(`FB publish remained disabled for 180s at step ${step + 1}`);
+          }
         }
         await dumpInventory(page, log, `no-advance-${step + 1}`);
         await dumpFailure(page, `no-advance-${step + 1}`, log);
         throw new Error(`FB composer step ${step + 1}: neither publish nor Tiếp button found`);
       }
       log('info', `[fb-pw] click "${next.verb}" via "${next.sel}" (step ${step + 1})`);
+      // The composer's dialog aria-label names the current wizard step ("Tạo
+      // thước phim" → "Chỉnh sửa thước phim" → …). Snapshot it so a click that
+      // registered-then-timed-out is recognised instead of re-fired.
+      const composerStepLabel = async () => page.evaluate(() => {
+        const out = [];
+        document.querySelectorAll("[role='dialog']").forEach((d) => {
+          const r = d.getBoundingClientRect();
+          if (r.width < 8 || r.height < 8) return;
+          out.push(d.getAttribute('aria-label') || '');
+        });
+        return out.join('|');
+      }).catch(() => '');
+      const stepLabelBefore = await composerStepLabel();
       try {
-        await waitAndClick(next.hit, { timeoutMs: 180_000, log, label: `Tiếp(${step + 1})` });
+        await waitAndClick(next.hit, {
+          timeoutMs: 180_000,
+          log,
+          label: `Tiếp(${step + 1})`,
+          // 5s was too tight: FB's new-notification toast parks itself over the
+          // composer's bottom CTA and Playwright burns the whole budget on
+          // blocked retries. Give the click room + let it escalate (mute the
+          // overlay, then JS-dispatch), with landedCheck so we never advance
+          // the wizard twice.
+          clickOpts: {
+            timeout: 12_000,
+            label: `Tiếp(${step + 1})`,
+            landedCheck: async () => {
+              const now = await composerStepLabel();
+              return !!now && now !== stepLabelBefore;
+            },
+          },
+        });
       } catch (e) {
         await dumpInventory(page, log, `tiep-not-clickable-${step + 1}`);
         await dumpFailure(page, `tiep-not-clickable-${step + 1}`, log);
@@ -2144,4 +2465,33 @@ async function run({ page, payload, log }) {
   }
 }
 
+async function run(args) {
+  const { page, log } = args;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    try {
+      return await runOnce(args);
+    } catch (e) {
+      const safeRetry = e?.code === SAFE_RETRY_COMPOSER_CLOSED;
+      if (!safeRetry || attempt === 2) throw e;
+      log('warn', `[fb-pw] composer vanished before publish — retrying the full upload once (${attempt}/1)`);
+      // Force a clean React tree before runOnce returns to facebook.com and
+      // opens a fresh composer. The first attempt's finally has already removed
+      // its downloaded temp files; runOnce downloads clean copies on retry.
+      await page.goto('about:blank', { waitUntil: 'domcontentloaded', timeout: 15_000 }).catch(() => {});
+      await page.waitForTimeout(1200);
+    }
+  }
+  throw new Error('FB upload exhausted safe retries');
+}
+
 module.exports = { run };
+// Exposed so the overlay-click escalation can be exercised against a synthetic
+// page (toast covering the CTA) without driving the whole upload flow.
+module.exports.__testables = {
+  resilientClick,
+  muteClickInterceptors,
+  unmuteClickInterceptors,
+  waitForPublishEnabled,
+  hasVisibleReelComposer,
+  SAFE_RETRY_COMPOSER_CLOSED,
+};

package/scripts/upload_facebook_photo.js

@@ -47,7 +47,19 @@ async function dumpFailure(page, tag, log) {
     fs.mkdirSync(dir, { recursive: true });
     const png = path.join(dir, `fbphoto-${tag}-${Date.now()}.png`);
     await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
-    log('warn', `[fbphoto] screenshot: ${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[fbphoto] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[fbphoto] screenshot: ${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
   } catch { /* ignore */ }
 }
 

package/scripts/upload_youtube.js

@@ -119,7 +119,19 @@ async function dumpFailure(page, tag, log) {
     const url = page.url();
     const title = await page.title().catch(() => '');
     const bodyHead = await page.evaluate(() => (document.body?.innerText || '').slice(0, 400)).catch(() => '');
-    log('warn', `[yt-pw] page dump on ${tag} — url=${url} | title=${title.slice(0, 80)} | head=${bodyHead.replace(/\s+/g, ' ').slice(0, 200)} | screenshot=${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[yt-pw] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[yt-pw] page dump on ${tag} — url=${url} | title=${title.slice(0, 80)} | head=${bodyHead.replace(/\s+/g, ' ').slice(0, 200)} | screenshot=${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
 
     // Snapshot of every VISIBLE interactive element — so when Studio renames
     // an id or swaps a tag we see what's there instead.