channel-worker 2.5.25 → 2.5.27

package/package.json

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

package/scripts/warmup_youtube.js

@@ -109,9 +109,50 @@ async function collectResultVideoUrls(page) {
   }).catch(() => []);
 }
 
-// Watch one video: navigate, let it play for a random span, do a small scroll
-// (into comments/related) like a real viewer. Best-effort — a single failed
-// video never aborts the session.
+// 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
+// pre-rolls can chain, so this is called every tick of the watch loop.
+async function trySkipAd(page) {
+  return page.evaluate(() => {
+    // ONLY click inside the player's real skip-ad button (stable YT classes).
+    // A loose text match like /skip/i clicked random buttons every tick on
+    // videos with no ad — keep it strict to the ad-skip control.
+    const sels = [
+      '.ytp-ad-skip-button-modern',
+      '.ytp-ad-skip-button',
+      '.ytp-skip-ad-button',
+      '.ytp-ad-skip-button-container button',
+    ];
+    for (const s of sels) {
+      const btn = document.querySelector(s);
+      if (btn && btn.offsetParent !== null) { btn.click(); return true; }
+    }
+    // Strict text fallback — require an ad-specific phrase, NOT bare "skip"/"bỏ qua".
+    const phrases = /bỏ qua quảng cáo|skip ad\b|skip ads/i;
+    for (const b of document.querySelectorAll('.ytp-ad-skip-button-text, .ytp-ad-skip-button button, button')) {
+      const t = (b.innerText || b.textContent || '').trim();
+      if (t && phrases.test(t) && b.offsetParent !== null) { b.click(); return true; }
+    }
+    return false;
+  }).catch(() => false);
+}
+
+// True while an ad is ACTUALLY playing (pre/mid-roll). Relies on the player's
+// `ad-showing` class — the canonical signal YouTube toggles only during ad
+// playback. Do NOT key off .ytp-ad-module (a persistent container that exists
+// even with no ad → false positive that pinned the watch loop at "0s real").
+async function isAdShowing(page) {
+  return page.evaluate(() => {
+    const player = document.querySelector('#movie_player, .html5-video-player');
+    return !!(player && player.classList.contains('ad-showing'));
+  }).catch(() => false);
+}
+
+// Watch one video: navigate, SKIP any ads (so we watch the real video, not the
+// ad), then let the real content play for a random span — counting only
+// non-ad time toward the budget — with a small mid-view scroll like a real
+// 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 });
@@ -121,13 +162,31 @@ async function watchVideo(page, url, minSec, maxSec, log) {
       const v = document.querySelector('video');
       if (v && v.paused) { try { v.play(); } catch {} }
     }).catch(() => {});
+
     const watchMs = randInt(minSec, maxSec) * 1000;
-    log('info', `[warmup] watching ${url.slice(-11)} for ~${Math.round(watchMs / 1000)}s`);
-    // Split the watch time so we can scroll mid-view (human behaviour).
-    const half = Math.floor(watchMs / 2);
-    await page.waitForTimeout(half);
-    await organicScroll(page, randInt(1, 2));
-    await page.waitForTimeout(watchMs - half);
+    log('info', `[warmup] watching ${url.slice(-11)} for ~${Math.round(watchMs / 1000)}s of REAL video (skipping ads)`);
+
+    const TICK = 1000;
+    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;
+    let skips = 0;
+
+    while (realWatched < watchMs) {
+      const adOn = await isAdShowing(page);
+      if (adOn) {
+        if (await trySkipAd(page)) skips++;
+        adWaited += TICK;
+        if (adWaited >= MAX_AD_WAIT_MS) { log('warn', `[warmup] ${url.slice(-11)} ads exceeded ${MAX_AD_WAIT_MS/1000}s — moving on`); break; }
+      } else {
+        realWatched += TICK;
+        // Mid-view scroll once, roughly halfway through real watch time.
+        if (!scrolled && realWatched >= watchMs / 2) { await organicScroll(page, randInt(1, 2)); scrolled = true; }
+      }
+      await page.waitForTimeout(TICK);
+    }
+    if (skips) log('info', `[warmup] ${url.slice(-11)} — skipped ${skips} ad tick(s), real watch ${Math.round(realWatched/1000)}s`);
     return true;
   } catch (e) {
     log('warn', `[warmup] watch failed (${url.slice(-11)}): ${String(e.message || e).slice(0, 100)}`);