channel-worker 2.5.29 → 2.5.31

package/package.json

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

package/scripts/warmup_facebook.js

@@ -231,8 +231,25 @@ async function clickResultByHref(page, href) {
   }
 }
 
+// Read the open reel/video's playback state — used to advance early when it
+// ENDS or STALLS instead of idling until watch_time elapses.
+async function readVideoState(page) {
+  return page.evaluate(() => {
+    const v = document.querySelector('video');
+    if (!v) return null;
+    if (v.paused && !v.ended) { try { v.play(); } catch {} }
+    return {
+      ended: !!v.ended,
+      currentTime: Number(v.currentTime) || 0,
+      duration: (isFinite(v.duration) && v.duration > 0) ? v.duration : 0,
+      loop: !!v.loop,
+    };
+  }).catch(() => null);
+}
+
 // Watch whatever reel/video is currently open (after clicking a result): ensure
-// the <video> plays, watch a random span with a mid-view scroll. Best-effort.
+// the <video> plays, watch a random span — but ADVANCE EARLY if a non-looping
+// video ends/stalls (don't sit on a finished video). Mid-view scroll. Best-effort.
 async function watchCurrent(page, minSec, maxSec, log) {
   try {
     await page.waitForTimeout(randInt(2500, 4500)); // let the reel viewer mount
@@ -244,12 +261,27 @@ async function watchCurrent(page, minSec, maxSec, log) {
       return true;
     }).catch(() => false);
     if (!hasVideo) { log('info', '[warmup-fb] no <video> after click — skipping'); return false; }
+
     const watchMs = randInt(minSec, maxSec) * 1000;
     log('info', `[warmup-fb] watching reel for ~${Math.round(watchMs / 1000)}s (url=${page.url().slice(-28)})`);
-    const half = Math.floor(watchMs / 2);
-    await page.waitForTimeout(half);
-    await organicScroll(page, randInt(1, 2));
-    await page.waitForTimeout(watchMs - half);
+    const TICK = 1000;
+    let watched = 0, scrolled = false, lastT = -1, stallTicks = 0;
+    while (watched < watchMs) {
+      const st = await readVideoState(page);
+      // A non-looping video that ended/stalled → stop waiting, go to next.
+      if (st && !st.loop) {
+        if (st.ended || (st.duration > 0 && st.currentTime >= st.duration - 0.6)) {
+          log('info', `[warmup-fb] reel ended at ${Math.round(st.currentTime)}s — advancing`);
+          break;
+        }
+        if (Math.abs(st.currentTime - lastT) < 0.15) { stallTicks++; if (stallTicks >= 6) { log('info', '[warmup-fb] reel stalled — advancing'); break; } }
+        else stallTicks = 0;
+        lastT = st.currentTime;
+      }
+      if (!scrolled && watched >= watchMs / 2) { await organicScroll(page, randInt(1, 2)); scrolled = true; }
+      await page.waitForTimeout(TICK);
+      watched += TICK;
+    }
     return true;
   } catch (e) {
     log('info', `[warmup-fb] watch failed: ${String(e.message || e).slice(0, 90)}`);
@@ -289,6 +321,7 @@ async function run({ page, payload, log }) {
 
   const keywordsSearched = [];
   let videosWatched = 0;
+  const watchedGlobal = new Set(); // dedupe reels across ALL keywords this session
 
   for (const kw of sessionKeywords) {
     // 3) Search the keyword via the top bar (from the Reels surface).
@@ -313,15 +346,25 @@ async function run({ page, payload, log }) {
       continue; // top-bar search persists; next keyword searches from here
     }
     log('info', `[warmup-fb] "${kw}" → ${urls.length} results, opening up to ${videosPerKeyword}`);
-    const watched = new Set();
     for (let n = 0; n < videosPerKeyword; n++) {
       // Re-collect each iteration — clicking + goBack mutates the DOM.
       const current = await collectResultUrls(page);
-      const next = current.find(u => !watched.has(u.split('?')[0]));
+      const next = current.find(u => !watchedGlobal.has(u.split('?')[0]));
       if (!next) break;
-      watched.add(next.split('?')[0]);
+      watchedGlobal.add(next.split('?')[0]);
+      const urlBefore = page.url();
       const clicked = await clickResultByHref(page, next);
       if (!clicked) { log('info', `[warmup-fb] couldn't click result ${next.slice(-24)} — skipping`); continue; }
+      // Verify the click actually navigated into a reel/video — otherwise we'd
+      // re-watch whatever was already open (saw the same reel id reused across
+      // keywords). Wait up to 8s for the URL to change to /reel/ or /watch.
+      let navigated = false;
+      for (let w = 0; w < 8; w++) {
+        await page.waitForTimeout(1000);
+        const u = page.url();
+        if (u !== urlBefore && /\/(reel|watch|videos)\//.test(u)) { navigated = true; break; }
+      }
+      if (!navigated) { log('info', `[warmup-fb] click didn't navigate (still ${page.url().slice(-30)}) — skipping`); continue; }
       const ok = await watchCurrent(page, watchMin, watchMax, log);
       if (ok) videosWatched++;
       // Back to the results list for the next pick (Escape closes a reel overlay

package/scripts/warmup_youtube.js

@@ -145,6 +145,23 @@ async function isAdShowing(page) {
   }).catch(() => false);
 }
 
+// Read the main <video> playback state. Used to advance early when a video
+// ENDS or STALLS instead of sitting idle on a finished video until watch_time
+// elapses (the "video chạy hết rồi không nhảy" report). Returns null if no video.
+async function readVideoState(page) {
+  return page.evaluate(() => {
+    const v = document.querySelector('video');
+    if (!v) return null;
+    if (v.paused && !v.ended) { try { v.play(); } catch {} } // nudge autoplay
+    return {
+      ended: !!v.ended,
+      currentTime: Number(v.currentTime) || 0,
+      duration: (isFinite(v.duration) && v.duration > 0) ? v.duration : 0,
+      loop: !!v.loop,
+    };
+  }).catch(() => null);
+}
+
 // 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
@@ -168,6 +185,7 @@ async function watchVideo(page, url, minSec, maxSec, log) {
     let adWaited = 0;        // ms spent sitting through/again skipping ads
     let scrolled = false;
     let skips = 0;
+    let lastT = -1, stallTicks = 0;
 
     while (realWatched < watchMs) {
       const adOn = await isAdShowing(page);
@@ -177,6 +195,18 @@ async function watchVideo(page, url, minSec, maxSec, log) {
         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;
+        // Advance early if the (non-looping) video ENDED or STALLED, instead of
+        // idling on a finished video until watch_time runs out.
+        const st = await readVideoState(page);
+        if (st && !st.loop) {
+          if (st.ended || (st.duration > 0 && st.currentTime >= st.duration - 0.6)) {
+            log('info', `[warmup] ${url.slice(-11)} ended at ${Math.round(st.currentTime)}s — advancing`);
+            break;
+          }
+          if (Math.abs(st.currentTime - lastT) < 0.15) { stallTicks++; if (stallTicks >= 6) { log('info', `[warmup] ${url.slice(-11)} stalled — advancing`); break; } }
+          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; }
       }