channel-worker 2.5.56 → 2.5.57

package/scripts/warmup_facebook.js

@@ -17,8 +17,11 @@
 // layout change) FAILS the session loudly (no silent bypass).
 
 const { assertAccountUsable } = require('./lib/fb-guard');
+const { humanType, humanWheel, humanClick, humanMove, cursorOf } = require('./lib/human');
+const { pick, clickHandle } = require('./lib/dom-pick');
 
 // ─── helpers ────────────────────────────────────────────────────────────────
+function chance(p) { return Math.random() < p; }
 function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
 function shuffle(arr) {
   const a = [...arr];
@@ -34,17 +37,13 @@ async function firstVisible(locator, max = 8) {
   return null;
 }
 
-async function typeHuman(page, text) {
-  for (const ch of text) {
-    await page.keyboard.type(ch);
-    await page.waitForTimeout(randInt(60, 160));
-  }
-}
+async function typeHuman(page, text) { await humanType(page, text); }
 
 async function organicScroll(page, rounds = null) {
   const n = rounds ?? randInt(2, 4);
   for (let i = 0; i < n; i++) {
-    await page.mouse.wheel(0, randInt(300, 850)).catch(() => {});
+    // Mostly down; now and then a short scroll back up to re-read something.
+    await humanWheel(page, chance(0.1) ? -randInt(120, 380) : randInt(300, 850));
     await page.waitForTimeout(randInt(500, 1500));
   }
 }
@@ -54,7 +53,7 @@ async function organicScroll(page, rounds = null) {
 async function dismissDialogs(page, log) {
   const verbs = ['Cho phép tất cả cookie', 'Allow all cookies', 'Để sau', 'Not now', 'Lúc khác', 'Không phải bây giờ', 'Bỏ qua', 'Skip', 'Đóng', 'Close', 'OK', 'Đã hiểu', 'Got it'];
   for (let round = 0; round < 3; round++) {
-    const hit = await page.evaluate((vs) => {
+    const { el } = await pick(page, (vs) => {
       const dlgs = document.querySelectorAll("[role='dialog']");
       for (const dlg of dlgs) {
         const r = dlg.getBoundingClientRect();
@@ -65,18 +64,16 @@ async function dismissDialogs(page, log) {
           for (const b of dlg.querySelectorAll("[role='button'], button")) {
             const t = (b.innerText || '').trim();
             if ((t === v || (b.getAttribute('aria-label') || '').trim() === v) && b.offsetParent !== null) {
-              b.setAttribute('__warm_dismiss__', '1');
-              return v;
+              return { el: b, verb: v };
             }
           }
         }
       }
-      return null;
-    }, verbs).catch(() => null);
-    if (!hit) break;
-    try { await page.locator("[__warm_dismiss__='1']").click({ timeout: 2500 }); } catch {}
-    await page.evaluate(() => document.querySelectorAll("[__warm_dismiss__]").forEach(e => e.removeAttribute('__warm_dismiss__'))).catch(() => {});
-    await page.waitForTimeout(800);
+      return { el: null };
+    }, verbs);
+    if (!el) break;
+    await clickHandle(page, el, { hoverMs: [300, 900], timeout: 2500, scroll: false });
+    await page.waitForTimeout(randInt(600, 1300));
   }
 }
 
@@ -85,7 +82,7 @@ async function dismissDialogs(page, log) {
 // text Reels|Thước phim), scoped to navigation so we don't hit a feed item.
 async function clickReelsEntry(page, log) {
   for (let attempt = 0; attempt < 3; attempt++) {
-    const found = await page.evaluate(() => {
+    const { el, data: found } = await pick(page, () => {
       const isReel = (el) => {
         const href = el.getAttribute('href') || '';
         const aria = (el.getAttribute('aria-label') || '').trim();
@@ -101,20 +98,17 @@ async function clickReelsEntry(page, log) {
         const r = a.getBoundingClientRect();
         if (r.width < 8 || r.height < 8) continue;
         if (a.offsetParent === null) continue;
-        if (isReel(a)) { a.setAttribute('__warm_reels__', '1'); return { href: a.getAttribute('href') || '', aria: (a.getAttribute('aria-label') || a.innerText || '').slice(0, 30) }; }
+        if (isReel(a)) return { el: a, href: a.getAttribute('href') || '', aria: (a.getAttribute('aria-label') || a.innerText || '').slice(0, 30) };
       }
-      return null;
-    }).catch(() => null);
-    if (found) {
-      try {
-        await page.locator("[__warm_reels__='1']").first().click({ timeout: 4000 });
-        await page.evaluate(() => document.querySelectorAll("[__warm_reels__]").forEach(e => e.removeAttribute('__warm_reels__'))).catch(() => {});
+      return { el: null };
+    });
+    if (el) {
+      if (await clickHandle(page, el, { hoverMs: [300, 900], scroll: false })) {
         await page.waitForTimeout(randInt(3000, 5000));
         log('info', `[warmup-fb] clicked Reels entry (aria="${found.aria}")`);
         return true;
-      } catch (e) {
-        log('info', `[warmup-fb] Reels click failed: ${String(e.message || e).slice(0, 80)}`);
       }
+      log('info', '[warmup-fb] Reels click failed');
     }
     await page.waitForTimeout(1500);
   }
@@ -141,7 +135,7 @@ async function focusFbSearch(page, log) {
       const box = await firstVisible(page.locator(sel), 3);
       if (box) {
         try {
-          await box.click({ timeout: 2500 });
+          await humanClick(page, box, { timeout: 2500, scroll: false });
           // CLEAR the previous keyword first. FB's search is a React-controlled
           // input — Ctrl+A+Backspace didn't reset its value (keywords appended:
           // "kw1kw2"). locator.fill('') dispatches the input events React needs,
@@ -155,7 +149,7 @@ async function focusFbSearch(page, log) {
           }
           if (cur && cur.trim()) { log('info', `[warmup-fb] search box not fully cleared (still "${cur.slice(0, 20)}") — typing anyway`); }
           // Re-focus so the subsequent human-typing lands in the box.
-          await box.click({ timeout: 2000 }).catch(() => {});
+          await humanClick(page, box, { timeout: 2000, scroll: false, hoverMs: [80, 250] }).catch(() => {});
           return true;
         } catch {}
       }
@@ -163,7 +157,7 @@ async function focusFbSearch(page, log) {
     // No visible input → click a search trigger to expand it, then retry.
     for (const sel of triggerSels) {
       const t = await firstVisible(page.locator(sel), 3);
-      if (t) { try { await t.click({ timeout: 2500 }); await page.waitForTimeout(1200); } catch {} break; }
+      if (t) { try { await humanClick(page, t, { timeout: 2500, scroll: false }); await page.waitForTimeout(randInt(900, 1600)); } catch {} break; }
     }
     await page.waitForTimeout(1000);
   }
@@ -174,7 +168,7 @@ async function focusFbSearch(page, log) {
 // results bias toward watchable reels/videos. Best-effort.
 async function clickResultsFilter(page, log) {
   const labels = ['Thước phim', 'Reels', 'Video', 'Videos'];
-  const found = await page.evaluate((labs) => {
+  const { el, data } = await pick(page, (labs) => {
     const els = document.querySelectorAll("[role='link'], [role='tab'], a, [role='button']");
     for (const lab of labs) {
       for (const el of els) {
@@ -182,21 +176,16 @@ async function clickResultsFilter(page, log) {
         if (t === lab && el.offsetParent !== null) {
           const r = el.getBoundingClientRect();
           if (r.width < 8 || r.height < 8) continue;
-          el.setAttribute('__warm_filter__', '1');
-          return lab;
+          return { el, lab };
         }
       }
     }
-    return null;
-  }, labels).catch(() => null);
-  if (found) {
-    try {
-      await page.locator("[__warm_filter__='1']").first().click({ timeout: 3000 });
-      await page.evaluate(() => document.querySelectorAll("[__warm_filter__]").forEach(e => e.removeAttribute('__warm_filter__'))).catch(() => {});
-      await page.waitForTimeout(randInt(2000, 3500));
-      log('info', `[warmup-fb] results filtered → "${found}"`);
-      return found;
-    } catch {}
+    return { el: null };
+  }, labels);
+  if (el && await clickHandle(page, el, { hoverMs: [300, 900], timeout: 3000, scroll: false })) {
+    await page.waitForTimeout(randInt(2000, 3500));
+    log('info', `[warmup-fb] results filtered → "${data.lab}"`);
+    return data.lab;
   }
   return null;
 }
@@ -221,28 +210,20 @@ async function collectResultUrls(page) {
 }
 
 // CLICK the result anchor matching `href` (natural — not a URL navigation).
-// Marks the element then clicks via Playwright (trusted). Returns true on click.
+// Picks the anchor as an ElementHandle (no DOM mark) and clicks it via
+// Playwright (trusted). Returns true on click.
 async function clickResultByHref(page, href) {
   const key = href.split('?')[0];
-  const found = await page.evaluate((k) => {
+  const { el } = await pick(page, (k) => {
     for (const a of document.querySelectorAll("a[href*='/reel/'], a[href*='/watch'], a[href*='/videos/']")) {
       let h = a.getAttribute('href') || '';
       if (h.startsWith('/')) h = 'https://www.facebook.com' + h;
-      if (h.split('?')[0] === k && a.offsetParent !== null) { a.setAttribute('__warm_click__', '1'); return true; }
+      if (h.split('?')[0] === k && a.offsetParent !== null) return { el: a };
     }
-    return false;
-  }, key).catch(() => false);
-  if (!found) return false;
-  const loc = page.locator("[__warm_click__='1']").first();
-  try {
-    await loc.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {});
-    await loc.click({ timeout: 4000 });
-    await page.evaluate(() => document.querySelectorAll("[__warm_click__]").forEach(e => e.removeAttribute('__warm_click__'))).catch(() => {});
-    return true;
-  } catch {
-    await page.evaluate(() => document.querySelectorAll("[__warm_click__]").forEach(e => e.removeAttribute('__warm_click__'))).catch(() => {});
-    return false;
-  }
+    return { el: null };
+  }, key);
+  if (!el) return false;
+  return clickHandle(page, el, { hoverMs: [300, 900] });
 }
 
 // Read the open reel/video's playback state — used to advance early when it
@@ -302,9 +283,11 @@ async function watchCurrent(page, minSec, maxSec, log) {
 
     const watchMs = randInt(minSec, maxSec) * 1000;
     log('info', `[warmup-fb] watching reel for ~${Math.round(watchMs / 1000)}s (url=${page.url().slice(-28)})`);
-    const TICK = 1000;
-    let watched = 0;          // counts ONLY progressing seconds
-    let scrolled = false, lastT = -1, frozenTicks = 0, adReChecks = 0;
+    // Poll at an uneven cadence (700-1400ms) and bank the elapsed step, not
+    // a flat 1000 — the old exact-1s heartbeat was itself a pattern.
+    let watched = 0;          // counts ONLY progressing time
+    let drifted = false, lastT = -1, frozenTicks = 0, adReChecks = 0;
+    const driftAt = randInt(25, 75) / 100;
     while (watched < watchMs) {
       const st = await readVideoState(page);
       // Non-looping video finished → go to next.
@@ -314,10 +297,19 @@ async function watchCurrent(page, minSec, maxSec, log) {
       }
       // Progress = currentTime moved forward, OR wrapped back (loop restart).
       const advanced = !!st && (st.currentTime > lastT + 0.2 || st.currentTime < lastT - 0.5);
+      const TICK = randInt(700, 1400);
       if (advanced) {
         watched += TICK;
         frozenTicks = 0;
-        if (!scrolled && watched >= watchMs / 2) { await organicScroll(page, randInt(1, 2)); scrolled = true; }
+        // Inside the reel viewer a wheel tick flips to the NEXT reel, so the
+        // old mid-watch "organic scroll" silently changed what was being
+        // watched. A viewer's hand drifts instead: small cursor move, once,
+        // at a random point.
+        if (!drifted && watched >= watchMs * driftAt) {
+          const c = cursorOf(page);
+          await humanMove(page, c.x + randInt(-90, 90), c.y + randInt(-60, 60)).catch(() => {});
+          drifted = true;
+        }
       } else {
         // Not progressing (frozen / buffering / paused-and-won't-play) — do NOT
         // count this second; bail after ~8s stuck.
@@ -326,7 +318,7 @@ async function watchCurrent(page, minSec, maxSec, log) {
       }
       lastT = st ? st.currentTime : lastT;
       // Re-check sponsored a couple times (a mid-scroll ad reel can swap in).
-      if (adReChecks < 2 && watched > 0 && watched % 8000 === 0) { adReChecks++; if (await isSponsoredReel(page)) { log('info', '[warmup-fb] became sponsored mid-watch — advancing'); break; } }
+      if (adReChecks < 2 && watched > 8000 * (adReChecks + 1)) { adReChecks++; if (await isSponsoredReel(page)) { log('info', '[warmup-fb] became sponsored mid-watch — advancing'); break; } }
       await page.waitForTimeout(TICK);
     }
     return watched > 0; // only a video with real progressing playback counts
@@ -343,8 +335,9 @@ async function run({ page, payload, log }) {
   if (!allKeywords.length) throw new Error('warmup-fb: no keywords provided');
 
   const cfg = payload.config || {};
-  const keywordsPerSession = Math.max(1, cfg.keywords_per_session ?? 5);
-  const videosPerKeyword = Math.max(1, cfg.videos_per_keyword ?? 3);
+  // Configured counts are a CENTRE, not a constant (see warmup_youtube).
+  const keywordsPerSession = Math.max(1, (cfg.keywords_per_session ?? 5) + randInt(-2, 1));
+  const videosPerKeyword = Math.max(1, (cfg.videos_per_keyword ?? 3) + randInt(-1, 1));
   const watchMin = Math.max(5, cfg.watch_time_min_sec ?? 30);
   const watchMax = Math.max(watchMin, cfg.watch_time_max_sec ?? 90);
   const sessionKeywords = shuffle(allKeywords).slice(0, keywordsPerSession);

package/scripts/warmup_youtube.js

@@ -16,7 +16,11 @@
 // whole session FAILS loudly (no silent bypass) so the user can investigate.
 
 // ─── helpers ────────────────────────────────────────────────────────────────
+const { humanType, humanWheel, humanClick } = require('./lib/human');
+const { pick: pickEl, clickHandle } = require('./lib/dom-pick');
+
 function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
+function chance(p) { return Math.random() < p; }
 function pick(arr) { return arr[randInt(0, arr.length - 1)]; }
 
 // Fisher-Yates shuffle (non-mutating) — used to pick a random keyword subset
@@ -41,19 +45,15 @@ async function firstVisible(locator, max = 8) {
 
 // Type a string into the focused element one character at a time with a small
 // random per-keystroke delay — mimics human cadence instead of an instant fill.
-async function typeHuman(page, text) {
-  for (const ch of text) {
-    await page.keyboard.type(ch);
-    await page.waitForTimeout(randInt(60, 160));
-  }
-}
+async function typeHuman(page, text) { await humanType(page, text); }
 
 // A few organic scroll nudges down the page (with pauses) before/while picking
 // a video. Wheel events look more human than a jump-to-element click.
 async function organicScroll(page, rounds = null) {
   const n = rounds ?? randInt(2, 4);
   for (let i = 0; i < n; i++) {
-    await page.mouse.wheel(0, randInt(300, 850)).catch(() => {});
+    // Mostly down; now and then a short scroll back up to re-read something.
+    await humanWheel(page, chance(0.1) ? -randInt(120, 380) : randInt(300, 850));
     await page.waitForTimeout(randInt(500, 1500));
   }
 }
@@ -73,7 +73,7 @@ async function focusSearchBox(page, log) {
       const box = await firstVisible(page.locator(sel), 3);
       if (box) {
         try {
-          await box.click({ timeout: 3000 });
+          await humanClick(page, box, { timeout: 3000, scroll: false });
           // Clear any leftover query from a previous keyword.
           await page.keyboard.down('Control'); await page.keyboard.press('A'); await page.keyboard.up('Control');
           await page.keyboard.press('Backspace');
@@ -109,6 +109,29 @@ async function collectResultVideoUrls(page) {
   }).catch(() => []);
 }
 
+// CLICK the result whose href carries this video id — the way a viewer gets
+// from search to watch. Until 2026-08-22 watchVideo did page.goto(url), which
+// YouTube logs as direct/typed traffic: no referrer from the results page, no
+// trusted click, and the search→click attribution warmup exists to build
+// never formed. Scrolls the anchor into view, cursor travels, clicks
+// off-centre. Returns true if the click navigated to that video.
+async function clickResultById(page, id) {
+  const { el } = await pickEl(page, (vid) => {
+    for (const a of document.querySelectorAll("ytd-video-renderer a#video-title, a#video-title-link, ytd-rich-item-renderer a#video-title-link, ytd-video-renderer a#thumbnail")) {
+      const href = a.getAttribute('href') || '';
+      if (!href.includes('v=' + vid)) continue;
+      const r = a.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8 || a.offsetParent === null) continue;
+      return { el: a };
+    }
+    return { el: null };
+  }, id);
+  if (!el) return false;
+  if (!(await clickHandle(page, el, { hoverMs: [300, 900] }))) return false;
+  try { await page.waitForURL((u) => u.href.includes('v=' + id), { timeout: 15000 }); } catch { return false; }
+  return true;
+}
+
 // Click "Bỏ qua quảng cáo" / "Skip Ad" if present + actionable. Returns true if
 // a skip was clicked this tick. The button only becomes clickable ~5s into a
 // skippable ad; non-skippable ads have no button (we wait them out). Multiple
@@ -128,7 +151,7 @@ async function trySkipAd(page) {
   for (const s of sels) {
     const loc = page.locator(s).first();
     if (await loc.isVisible().catch(() => false)) {
-      try { await loc.click({ timeout: 1500 }); return true; } catch { /* not yet clickable */ }
+      try { await humanClick(page, loc, { timeout: 1500, scroll: false, hoverMs: [120, 400] }); return true; } catch { /* not yet clickable */ }
     }
   }
   return false;
@@ -168,7 +191,14 @@ async function readVideoState(page) {
 // viewer. Best-effort — a single failed video never aborts the session.
 async function watchVideo(page, url, minSec, maxSec, log) {
   try {
-    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 45000 });
+    const id = (url.match(/v=([\w-]{11})/) || [])[1] || '';
+    const clicked = id ? await clickResultById(page, id) : false;
+    if (!clicked) {
+      // Anchor scrolled out / re-rendered — fall back to navigation rather
+      // than skip the video, but say so in the log.
+      log('info', `[warmup] ${url.slice(-11)} result anchor not clickable — falling back to goto`);
+      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 45000 });
+    }
     await page.waitForTimeout(randInt(2500, 4500));
     // Best-effort: make sure it's actually playing (autoplay sometimes pauses).
     await page.evaluate(() => {
@@ -183,7 +213,9 @@ async function watchVideo(page, url, minSec, maxSec, log) {
     const MAX_AD_WAIT_MS = 60_000; // cap total ad-waiting so a non-skippable ad reel can't hang the session
     let realWatched = 0;     // ms of actual (non-ad) playback counted
     let adWaited = 0;        // ms spent sitting through/again skipping ads
-    let scrolled = false;
+    // Nudge the page at a random point (not always halfway), sometimes twice.
+    const scrollAt = [randInt(20, 75) / 100, chance(0.35) ? randInt(60, 95) / 100 : 2];
+    let scrollIdx = 0;
     let skips = 0;
     let lastT = -1, stallTicks = 0;
 
@@ -207,10 +239,9 @@ async function watchVideo(page, url, minSec, maxSec, log) {
           else stallTicks = 0;
           lastT = st.currentTime;
         }
-        // Mid-view scroll once, roughly halfway through real watch time.
-        if (!scrolled && realWatched >= watchMs / 2) { await organicScroll(page, randInt(1, 2)); scrolled = true; }
+        if (scrollIdx < scrollAt.length && realWatched >= watchMs * scrollAt[scrollIdx]) { await organicScroll(page, randInt(1, 2)); scrollIdx++; }
       }
-      await page.waitForTimeout(TICK);
+      await page.waitForTimeout(randInt(700, 1400));
     }
     if (skips) log('info', `[warmup] ${url.slice(-11)} — skipped ${skips} ad tick(s), real watch ${Math.round(realWatched/1000)}s`);
     // Only count as a watched video if real (non-ad) content actually played.
@@ -228,8 +259,10 @@ async function run({ page, payload, log }) {
   if (!allKeywords.length) throw new Error('warmup: no keywords provided');
 
   const cfg = payload.config || {};
-  const keywordsPerSession = Math.max(1, cfg.keywords_per_session ?? 5);
-  const videosPerKeyword = Math.max(1, cfg.videos_per_keyword ?? 3);
+  // Configured counts are a CENTRE, not a constant: ±1-2 per session so
+  // "5 keywords × 3 videos, every time" stops being the session's shape.
+  const keywordsPerSession = Math.max(1, (cfg.keywords_per_session ?? 5) + randInt(-2, 1));
+  const videosPerKeyword = Math.max(1, (cfg.videos_per_keyword ?? 3) + randInt(-1, 1));
   const watchMin = Math.max(5, cfg.watch_time_min_sec ?? 30);
   const watchMax = Math.max(watchMin, cfg.watch_time_max_sec ?? 90);
 
@@ -278,11 +311,19 @@ async function run({ page, payload, log }) {
     const chosen = shuffle(urls).slice(0, videosPerKeyword);
     log('info', `[warmup] "${kw}" → ${urls.length} results, opening ${chosen.length}`);
 
-    for (const url of chosen) {
-      const ok = await watchVideo(page, url, watchMin, watchMax, log);
+    for (let i = 0; i < chosen.length; i++) {
+      const ok = await watchVideo(page, chosen[i], watchMin, watchMax, log);
       if (ok) videosWatched++;
-      // Brief idle between videos.
+      // Brief idle, then back to the results page so the next pick is a click
+      // on a result rather than a typed URL. Occasionally bail on the rest of
+      // this keyword — people do.
       await page.waitForTimeout(randInt(1500, 3500));
+      if (i < chosen.length - 1) {
+        if (chance(0.12)) { log('info', `[warmup] "${kw}" — leaving the remaining ${chosen.length - 1 - i} result(s) unwatched`); break; }
+        await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+        await page.waitForTimeout(randInt(1500, 3000));
+        await organicScroll(page, randInt(0, 2));
+      }
     }
   }