channel-worker 2.5.22 → 2.5.24

package/package.json

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

package/scripts/upload_facebook.js

@@ -283,7 +283,7 @@ async function run({ page, payload, log }) {
   } = payload || {};
   if (!video_url) throw new Error('No video_url provided');
 
-  log('info', '[fb-pw] selectors version=2026.06.19c-posturl-network-first');
+  log('info', '[fb-pw] selectors version=2026.06.19d-reels-link-fallback');
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
@@ -454,9 +454,31 @@ async function run({ page, payload, log }) {
       .filter({ has: page.locator(":scope :text-matches('^Tạo thước phim$|^Create reel$|^Create a reel$', 'i')") })
       .first();
     if (!(await reelsDialog.isVisible({ timeout: 6000 }).catch(() => false))) {
-      await dumpInventory(page, log, 'no-reels-modal');
-      await dumpFailure(page, 'no-reels-modal', log);
-      throw new Error('FB Reels modal "Tạo thước phim" did not open after clicking Thước phim entry');
+      // FALLBACK: some accounts render a different UI from the create-post
+      // "Thước phim" entry → the composer modal never mounts. Click the Reels
+      // link (any <a href*='/reels'>) instead, then re-wait for the modal.
+      log('warn', '[fb-pw] Reels modal not open — fallback: click <a href*="/reels"> then re-wait…');
+      let xpClicked = false;
+      try {
+        const reelsLink = page.locator("xpath=//a[contains(@href, '/reels')]").first();
+        if (await reelsLink.isVisible({ timeout: 3000 }).catch(() => false)) {
+          await reelsLink.click({ timeout: 4000 });
+          xpClicked = true;
+          log('info', '[fb-pw] clicked Reels link via xpath //a[contains(@href,"/reels")]');
+        } else {
+          log('warn', '[fb-pw] fallback: no visible <a href*="/reels"> found');
+        }
+      } catch (e) { log('warn', `[fb-pw] fallback Reels-link click failed: ${e.message.slice(0, 80)}`); }
+      if (xpClicked) {
+        await page.waitForTimeout(5000);
+        await dismissBsOnboarding(page, log).catch(() => {});
+      }
+      if (!(await reelsDialog.isVisible({ timeout: 8000 }).catch(() => false))) {
+        await dumpInventory(page, log, 'no-reels-modal');
+        await dumpFailure(page, 'no-reels-modal', log);
+        throw new Error('FB Reels modal "Tạo thước phim" did not open (kể cả sau fallback xpath //a[href*="/reels"])');
+      }
+      log('info', '[fb-pw] Reels modal opened after xpath /reels fallback');
     }
     // Candidates inside the modal only:
     //   - "Tải lên" — the explicit blue upload button at the bottom (preferred)

package/scripts/warmup_youtube.js

@@ -0,0 +1,212 @@
+// YouTube channel warmup — algorithm seeding for new channels.
+//
+// Runs on the channel's own NST profile (logged-in YouTube session, own
+// residential proxy → platform sees organic per-channel activity, not one IP
+// crawling many channels). One run = one "session": search a handful of niche
+// keywords in the real search box (typed char-by-char), open a few result
+// videos, and watch each for a random span before going back. This builds
+// search + watch history so YouTube indexes the channel for the right niche
+// BEFORE it ever uploads.
+//
+// Contract: run({ page, payload, log }) → { keywords_searched, videos_watched,
+// duration_sec }. payload = { keywords: string[], config: {...}, youtube_handle }.
+//
+// NOT a publish flow — no uploads, no idea state. Best-effort per keyword, but
+// if the search box itself can't be found (layout change / not logged in) the
+// whole session FAILS loudly (no silent bypass) so the user can investigate.
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
+function pick(arr) { return arr[randInt(0, arr.length - 1)]; }
+
+// Fisher-Yates shuffle (non-mutating) — used to pick a random keyword subset
+// + randomize which result videos we open, so the pattern isn't identical
+// every session.
+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;
+}
+
+// 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));
+  }
+}
+
+// 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(() => {});
+    await page.waitForTimeout(randInt(500, 1500));
+  }
+}
+
+// Locate + focus the YouTube search box. Tries the common selectors across
+// the (frequently A/B-tested) home layouts. Returns true if focused.
+async function focusSearchBox(page, log) {
+  const candidates = [
+    "input#search",
+    "input[name='search_query']",
+    "ytd-searchbox input#search",
+    "div#search-input input",
+    "input[aria-label*='earch']",
+  ];
+  for (let attempt = 0; attempt < 3; attempt++) {
+    for (const sel of candidates) {
+      const box = await firstVisible(page.locator(sel), 3);
+      if (box) {
+        try {
+          await box.click({ timeout: 3000 });
+          // 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');
+          return true;
+        } catch { /* try next selector */ }
+      }
+    }
+    await page.waitForTimeout(1500);
+  }
+  return false;
+}
+
+// Collect candidate watch-video hrefs from the current search results page.
+// Skips Shorts (/shorts/ — different FYP surface) + ads/mixes. Returns absolute
+// /watch?v= URLs in DOM order; caller shuffles + slices.
+async function collectResultVideoUrls(page) {
+  return page.evaluate(() => {
+    const out = [];
+    const seen = new Set();
+    const anchors = document.querySelectorAll(
+      "ytd-video-renderer a#video-title, ytd-video-renderer a#thumbnail, a#video-title-link, ytd-rich-item-renderer a#video-title-link",
+    );
+    for (const a of anchors) {
+      const href = a.getAttribute('href') || '';
+      if (!href.includes('/watch?v=')) continue; // skip shorts / channels / playlists
+      const m = href.match(/v=([\w-]{11})/);
+      if (!m) continue;
+      if (seen.has(m[1])) continue;
+      seen.add(m[1]);
+      out.push('https://www.youtube.com' + href.split('&')[0]);
+    }
+    return out;
+  }).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.
+async function watchVideo(page, url, minSec, maxSec, log) {
+  try {
+    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(() => {
+      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);
+    return true;
+  } catch (e) {
+    log('warn', `[warmup] watch failed (${url.slice(-11)}): ${String(e.message || e).slice(0, 100)}`);
+    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: 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);
+
+  // Pick a random subset for THIS session so repeated runs vary.
+  const sessionKeywords = shuffle(allKeywords).slice(0, keywordsPerSession);
+  log('info', `[warmup] session start — ${sessionKeywords.length}/${allKeywords.length} keywords, ${videosPerKeyword} videos/keyword, watch ${watchMin}-${watchMax}s`);
+
+  page.on('dialog', (d) => { d.accept().catch(() => {}); });
+
+  // Land on the home feed first (organic entry point).
+  await page.goto('https://www.youtube.com/', { waitUntil: 'domcontentloaded', timeout: 60000 });
+  await page.waitForTimeout(randInt(2500, 4500));
+  await organicScroll(page, randInt(1, 3));
+
+  const keywordsSearched = [];
+  let videosWatched = 0;
+
+  for (const kw of sessionKeywords) {
+    // Always return to home so the search box is in its canonical spot.
+    if (!page.url().match(/youtube\.com\/?($|\?|#)/)) {
+      await page.goto('https://www.youtube.com/', { waitUntil: 'domcontentloaded', timeout: 60000 }).catch(() => {});
+      await page.waitForTimeout(randInt(1500, 3000));
+    }
+
+    const focused = await focusSearchBox(page, log);
+    if (!focused) {
+      // The search box is the one hard requirement — its absence means the
+      // page isn't a logged-in YouTube (proxy block / consent wall / layout
+      // change). Fail the session loudly rather than pretend success.
+      throw new Error('warmup: YouTube search box not found — check the profile is logged in to YouTube and not on a consent/captcha wall');
+    }
+
+    log('info', `[warmup] searching: "${kw}"`);
+    await typeHuman(page, kw);
+    await page.waitForTimeout(randInt(400, 1000));
+    await page.keyboard.press('Enter');
+    await page.waitForTimeout(randInt(3000, 5000));
+    keywordsSearched.push(kw);
+
+    await organicScroll(page, randInt(2, 4));
+    const urls = await collectResultVideoUrls(page);
+    if (!urls.length) {
+      log('warn', `[warmup] no result videos for "${kw}" — skipping to next keyword`);
+      continue;
+    }
+    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);
+      if (ok) videosWatched++;
+      // Brief idle between videos.
+      await page.waitForTimeout(randInt(1500, 3500));
+    }
+  }
+
+  const durationSec = Math.round((Date.now() - t0) / 1000);
+  log('info', `[warmup] session done — keywords=${keywordsSearched.length} videos=${videosWatched} duration=${durationSec}s`);
+  return {
+    keywords_searched: keywordsSearched,
+    videos_watched: videosWatched,
+    duration_sec: durationSec,
+  };
+}
+
+module.exports = { run };