channel-worker 2.5.41 → 2.5.43

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.43",
   "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 {}
 }
 
@@ -283,7 +395,7 @@ async function run({ page, payload, log }) {
   } = 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.02-overlay-proof-cta');
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
@@ -929,8 +1041,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 +1054,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),
@@ -1565,6 +1687,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 +1712,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 +1763,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 +1780,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');
@@ -1708,8 +1870,38 @@ async function run({ page, payload, 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);
@@ -2145,3 +2337,6 @@ async function run({ page, payload, log }) {
 }
 
 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 };

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.