channel-worker 2.5.27 → 2.5.29

package/lib/api-client.js

@@ -68,7 +68,7 @@ class ApiClient {
   async getNextCommand(workerId) {
     // Daemon-handled types. `_pw` variants route to the Playwright pipeline
     // (lib/playwright-runner → scripts/<base>.js) instead of the extension.
-    const workerTypes = 'launch_profile,close_profile,launch_veo3_profile,set_profile_proxy,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats,restart_worker,upload_youtube_pw,upload_tiktok_pw,upload_facebook_pw,warmup_youtube_pw,scrape_affiliate_products,ingest_shopee_product';
+    const workerTypes = 'launch_profile,close_profile,launch_veo3_profile,set_profile_proxy,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats,restart_worker,upload_youtube_pw,upload_tiktok_pw,upload_facebook_pw,warmup_youtube_pw,warmup_facebook_pw,warmup_tiktok_pw,scrape_affiliate_products,ingest_shopee_product';
     return this.request('GET', `/workers/commands?worker_id=${workerId}&types=${encodeURIComponent(workerTypes)}`);
   }
 

package/package.json

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

package/scripts/warmup_facebook.js

@@ -0,0 +1,342 @@
+// Facebook page warmup — algorithm seeding for new channels.
+//
+// Runs on the channel's own NST profile (logged-in FB session, own residential
+// proxy → FB sees organic per-account activity, not one IP crawling many).
+// One run = one "session". Natural flow (per requirement — NO deep-linking to
+// search URLs):
+//   home (facebook.com) → scroll a bit → click the "Reels" entry → from there
+//   use the top search bar to search each niche keyword → open + watch a few
+//   result reels/videos → back.
+//
+// Contract: run({ page, payload, log }) → { keywords_searched, videos_watched,
+// duration_sec }. payload = { keywords[], config{...}, platform:'facebook' }.
+//
+// NOT a publish/engagement flow — only search + watch + scroll (no like /
+// follow / comment). Best-effort per keyword/video; the search box + Reels
+// entry are hard requirements — their absence (not logged in / consent wall /
+// layout change) FAILS the session loudly (no silent bypass).
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
+function shuffle(arr) {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) { const j = randInt(0, i); [a[i], a[j]] = [a[j], a[i]]; }
+  return a;
+}
+
+async function firstVisible(locator, max = 8) {
+  const n = Math.min(await locator.count().catch(() => 0), max);
+  for (let i = 0; i < n; i++) {
+    if (await locator.nth(i).isVisible().catch(() => false)) return locator.nth(i);
+  }
+  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 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(() => {});
+    await page.waitForTimeout(randInt(500, 1500));
+  }
+}
+
+// Dismiss FB cross-sell / cookie / "not now" popups that overlay the page.
+// Best-effort — never throws. Avoids touching the composer or search.
+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 dlgs = document.querySelectorAll("[role='dialog']");
+      for (const dlg of dlgs) {
+        const r = dlg.getBoundingClientRect();
+        if (r.width < 8 || r.height < 8) continue;
+        const aria = (dlg.getAttribute('aria-label') || '').toLowerCase();
+        if (/tạo bài viết|create post|thước phim|reel/i.test(aria)) continue; // never the composer/reels
+        for (const v of vs) {
+          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 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);
+  }
+}
+
+// Click the "Reels" entry in the left nav / shortcut bar (organic entry — NOT a
+// direct URL). Matches the nav link to the reels surface (href /reel/ + aria/
+// 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 isReel = (el) => {
+        const href = el.getAttribute('href') || '';
+        const aria = (el.getAttribute('aria-label') || '').trim();
+        const txt = (el.innerText || '').trim();
+        const hrefReel = /\/reel(s)?\b|\/reel\//i.test(href);
+        const labelReel = /^reels?$|^thước phim$/i.test(aria) || /^reels?$|^thước phim$/i.test(txt);
+        return (hrefReel && (labelReel || aria === '' )) || (labelReel && (hrefReel || /reel/i.test(href)));
+      };
+      // Prefer links inside navigation regions (left rail / shortcut bar).
+      const navs = [...document.querySelectorAll("[role='navigation'] a, [role='banner'] a, a")];
+      for (const a of navs) {
+        if (!a.getAttribute) continue;
+        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) }; }
+      }
+      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(() => {});
+        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)}`);
+      }
+    }
+    await page.waitForTimeout(1500);
+  }
+  return false;
+}
+
+// Focus the FB top-bar search input. FB sometimes renders a collapsed button
+// that expands into an input on click — handle both. Returns true if focused.
+async function focusFbSearch(page, log) {
+  const inputSels = [
+    "input[aria-label*='Tìm kiếm']",
+    "input[aria-label*='earch']",
+    "input[type='search']",
+    "[role='banner'] input[type='text']",
+  ];
+  const triggerSels = [
+    "[aria-label='Tìm kiếm trên Facebook']",
+    "[aria-label='Search Facebook']",
+    "[role='banner'] [role='button'][aria-label*='earch']",
+    "[role='banner'] [aria-label*='Tìm kiếm']",
+  ];
+  for (let attempt = 0; attempt < 3; attempt++) {
+    for (const sel of inputSels) {
+      const box = await firstVisible(page.locator(sel), 3);
+      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');
+          return true;
+        } catch {}
+      }
+    }
+    // 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; }
+    }
+    await page.waitForTimeout(1000);
+  }
+  return false;
+}
+
+// On a search-results page, click the "Reels" filter tab (fallback "Videos") so
+// 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 els = document.querySelectorAll("[role='link'], [role='tab'], a, [role='button']");
+    for (const lab of labs) {
+      for (const el of els) {
+        const t = (el.innerText || '').trim();
+        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 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 null;
+}
+
+// Collect watchable result hrefs (reels/videos) on the current results page.
+async function collectResultUrls(page) {
+  return page.evaluate(() => {
+    const out = []; const seen = new Set();
+    for (const a of document.querySelectorAll("a[href*='/reel/'], a[href*='/watch'], a[href*='/videos/']")) {
+      let href = a.getAttribute('href') || '';
+      if (!href) continue;
+      if (href.startsWith('/')) href = 'https://www.facebook.com' + href;
+      if (!/facebook\.com/.test(href)) continue;
+      const key = href.split('?')[0];
+      if (seen.has(key)) continue;
+      const r = a.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8) continue;
+      seen.add(key); out.push(href);
+    }
+    return out;
+  }).catch(() => []);
+}
+
+// CLICK the result anchor matching `href` (natural — not a URL navigation).
+// Marks the element then clicks via Playwright (trusted). Returns true on click.
+async function clickResultByHref(page, href) {
+  const key = href.split('?')[0];
+  const found = await page.evaluate((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; }
+    }
+    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;
+  }
+}
+
+// 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.
+async function watchCurrent(page, minSec, maxSec, log) {
+  try {
+    await page.waitForTimeout(randInt(2500, 4500)); // let the reel viewer mount
+    await dismissDialogs(page, log);
+    const hasVideo = await page.evaluate(() => {
+      const v = document.querySelector('video');
+      if (!v) return false;
+      if (v.paused) { try { v.play(); } catch {} }
+      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);
+    return true;
+  } catch (e) {
+    log('info', `[warmup-fb] watch failed: ${String(e.message || e).slice(0, 90)}`);
+    return false;
+  }
+}
+
+// ─── main ─────────────────────────────────────────────────────────────────
+async function run({ page, payload, log }) {
+  const t0 = Date.now();
+  const allKeywords = Array.isArray(payload?.keywords) ? payload.keywords.filter(Boolean) : [];
+  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);
+  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);
+  log('info', `[warmup-fb] session start — ${sessionKeywords.length}/${allKeywords.length} keywords, ${videosPerKeyword} videos/keyword, watch ${watchMin}-${watchMax}s`);
+
+  page.on('dialog', (d) => { d.accept().catch(() => {}); });
+
+  // 1) Land on the FB home feed (organic entry — not a deep link).
+  await page.goto('https://www.facebook.com/', { waitUntil: 'domcontentloaded', timeout: 60000 });
+  await page.waitForTimeout(randInt(3000, 5000));
+  await dismissDialogs(page, log);
+  await organicScroll(page, randInt(1, 3));
+
+  // 2) Click the "Reels" entry (left nav / shortcut) — natural navigation.
+  const reelsOk = await clickReelsEntry(page, log);
+  if (!reelsOk) {
+    throw new Error('warmup-fb: "Reels" entry not found on FB home — check the profile is logged in to Facebook and the left-nav Reels shortcut is present');
+  }
+  await dismissDialogs(page, log);
+  await organicScroll(page, randInt(1, 2));
+
+  const keywordsSearched = [];
+  let videosWatched = 0;
+
+  for (const kw of sessionKeywords) {
+    // 3) Search the keyword via the top bar (from the Reels surface).
+    const focused = await focusFbSearch(page, log);
+    if (!focused) {
+      throw new Error('warmup-fb: search box not found — FB layout/login issue (cannot warm up without searching)');
+    }
+    log('info', `[warmup-fb] searching: "${kw}"`);
+    await typeHuman(page, kw);
+    await page.waitForTimeout(randInt(500, 1100));
+    await page.keyboard.press('Enter');
+    await page.waitForTimeout(randInt(3000, 5000));
+    await dismissDialogs(page, log);
+    keywordsSearched.push(kw);
+
+    // 4) Bias results toward reels/videos, then CLICK + watch a few (no URL nav).
+    await clickResultsFilter(page, log);
+    await organicScroll(page, randInt(1, 3));
+    const urls = await collectResultUrls(page);
+    if (!urls.length) {
+      log('info', `[warmup-fb] no reel/video results for "${kw}" — next keyword`);
+      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]));
+      if (!next) break;
+      watched.add(next.split('?')[0]);
+      const clicked = await clickResultByHref(page, next);
+      if (!clicked) { log('info', `[warmup-fb] couldn't click result ${next.slice(-24)} — 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
+      // if goBack didn't return to results).
+      await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+      await page.waitForTimeout(randInt(1500, 2800));
+      if (/\/reel\//.test(page.url())) { await page.keyboard.press('Escape').catch(() => {}); await page.waitForTimeout(1200); }
+    }
+    // Next keyword searches from the persistent top-bar (no home bounce).
+    await page.waitForTimeout(randInt(1000, 2000));
+  }
+
+  const durationSec = Math.round((Date.now() - t0) / 1000);
+  log('info', `[warmup-fb] session done — keywords=${keywordsSearched.length} videos=${videosWatched} duration=${durationSec}s`);
+  return { keywords_searched: keywordsSearched, videos_watched: videosWatched, duration_sec: durationSec };
+}
+
+module.exports = { run };

package/scripts/warmup_youtube.js

@@ -114,28 +114,24 @@ async function collectResultVideoUrls(page) {
 // 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; }
+  // Use Playwright's real .click() (trusted pointer event) — a synthetic
+  // el.click() from page.evaluate is ignored by YouTube's player, so the ad
+  // never actually skipped (saw 52 "skips" with the ad still playing). The
+  // skip button only becomes clickable ~5s into the ad; an early click times
+  // out → return false → retried next tick.
+  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 loc = page.locator(s).first();
+    if (await loc.isVisible().catch(() => false)) {
+      try { await loc.click({ timeout: 1500 }); return true; } catch { /* not yet clickable */ }
     }
-    return false;
-  }).catch(() => false);
+  }
+  return false;
 }
 
 // True while an ad is ACTUALLY playing (pre/mid-roll). Relies on the player's
@@ -187,7 +183,8 @@ async function watchVideo(page, url, minSec, maxSec, log) {
       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;
+    // Only count as a watched video if real (non-ad) content actually played.
+    return realWatched > 0;
   } catch (e) {
     log('warn', `[warmup] watch failed (${url.slice(-11)}): ${String(e.message || e).slice(0, 100)}`);
     return false;