channel-worker 2.5.30 → 2.5.32

package/package.json

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

package/scripts/warmup_facebook.js

@@ -140,8 +140,20 @@ async function focusFbSearch(page, log) {
       if (box) {
         try {
           await box.click({ timeout: 2500 });
-          await page.keyboard.down('Control'); await page.keyboard.press('A'); await page.keyboard.up('Control');
-          await page.keyboard.press('Backspace');
+          // 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,
+          // reliably emptying it; verify + fall back to mass-Backspace.
+          await box.fill('').catch(() => {});
+          let cur = await box.evaluate(el => (el.value != null ? el.value : (el.textContent || ''))).catch(() => '');
+          if (cur && cur.trim()) {
+            await page.keyboard.press('End').catch(() => {});
+            for (let i = 0; i < cur.length + 8; i++) await page.keyboard.press('Backspace').catch(() => {});
+            cur = await box.evaluate(el => (el.value != null ? el.value : (el.textContent || ''))).catch(() => '');
+          }
+          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(() => {});
           return true;
         } catch {}
       }
@@ -231,8 +243,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 +273,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)}`);

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; }
       }