channel-worker 2.5.55 → 2.5.57

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,upload_facebook_photo_pw,warmup_youtube_pw,warmup_facebook_pw,warmup_tiktok_pw,nurture_facebook_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,upload_facebook_photo_pw,warmup_youtube_pw,warmup_facebook_pw,warmup_tiktok_pw,nurture_facebook_pw,fetch_facebook_reel_stats_pw,scrape_affiliate_products,ingest_shopee_product';
     return this.request('GET', `/workers/commands?worker_id=${workerId}&types=${encodeURIComponent(workerTypes)}`);
   }
 

package/lib/command-poller.js

@@ -321,6 +321,27 @@ class CommandPoller {
       // Always release the per-profile mutex — even on throw — or sibling
       // pw cmds for the same profile would hang forever.
       if (this._pwInFlight) this._pwInFlight.delete(profileId);
+
+      // CLOSE THE BROWSER HERE, not via a round-trip close_profile command.
+      // connectOverCDP only DETACHES Playwright, so the NST browser survives the
+      // script; the idle-timeout sweep skips it (it only closes profiles listed
+      // in _profileLastActivity, which the pw path never writes), and the API's
+      // close_profile only fires when the result reaches a terminal status with
+      // a live channel — a crash, a worker restart or a deleted channel leaks
+      // the profile forever. Sessions touch a DIFFERENT profile every time, so
+      // the leak is cumulative.
+      //
+      // Scoped to the browse-only scripts. Publish keeps its profile open on
+      // purpose: one profile serves several platform uploads back-to-back.
+      const CLOSE_AFTER = new Set(['nurture_facebook', 'warmup_facebook', 'warmup_youtube', 'warmup_tiktok', 'fetch_facebook_reel_stats']);
+      if (CLOSE_AFTER.has(scriptName) && this.nst) {
+        try {
+          await this.nst.stopProfile(profileId);
+          console.log(`[commands/pw] closed profile ${profileId} after ${scriptName}`);
+        } catch (e) {
+          console.warn(`[commands/pw] close after ${scriptName} failed: ${e.message}`);
+        }
+      }
     }
   }
 
@@ -1243,8 +1264,23 @@ class CommandPoller {
     const { profile_id } = command.payload || {};
     console.log(`[commands] Closing profile: ${profile_id}`);
     try {
-      if (profile_id && this.nst && typeof this.nst.closeProfile === 'function') {
-        await this.nst.closeProfile(profile_id).catch((e) => console.warn(`[commands] nst.closeProfile failed: ${e.message}`));
+      // NstManager exposes stopProfile — there has never been a closeProfile.
+      // The old `typeof this.nst.closeProfile === 'function'` guard made every
+      // close_profile command a silent no-op that still reported 'done', so
+      // browsers accumulated until the machine crawled (measured 2026-08-22 on
+      // win-worker: 22 profiles / 203 nstchrome procs / 18.4 GB).
+      if (profile_id) {
+        if (!this.nst) {
+          try {
+            const apiKey = await this.api.getSetting('nst_api_key');
+            if (apiKey) { const NstManager = require('./nst-manager'); this.nst = new NstManager(apiKey); }
+          } catch {}
+        }
+        if (!this.nst) {
+          console.warn('[commands] close_profile skipped — NST API key not configured');
+        } else {
+          await this.nst.stopProfile(profile_id).catch((e) => console.warn(`[commands] nst.stopProfile failed: ${e.message}`));
+        }
       }
     } finally {
       // Release the lease so another machine can pick up the profile if

package/lib/nst-manager.js

@@ -110,12 +110,21 @@ class NstManager {
 
     const platform = (options.os || 'windows').toLowerCase() === 'mac' ? 'MacOS' : 'Windows';
     console.log(`[nst] WARNING: Profile "${name}" NOT FOUND after 3 retries — creating new profile (${platform})...`);
+    // Only pin the noise flags. Everything else (CPU count, RAM, kernel
+    // version, UA, locale/timezone) is left to Nstbrowser's own randomiser.
+    // Previously this hard-coded hardwareConcurrency=8 / deviceMemory=8 /
+    // kernel 132 / en-US for EVERY profile, and NST honoured it — measured
+    // 2026-08-22 on win-worker: 22 running browsers, 22/22 identical on
+    // (chrome, cpu, ram, language, timezone, screen). Same machine fingerprint
+    // across a fleet of accounts is exactly what lets a platform cluster them.
+    // localization 'BasedOnProxy' lets NST derive locale + timezone from the
+    // proxy's geo, so a VN account on a VN proxy stops claiming it only speaks
+    // English. All FB/YT selectors are already bilingual (vi + en).
     const res = await this.api('/profiles', {
       method: 'POST',
       body: JSON.stringify({
         name,
         platform,
-        kernelMilestone: '132',
         fingerprint: {
           flags: {
             audio: 'Noise',
@@ -123,15 +132,7 @@ class NstManager {
             fonts: 'Masked',
             gpu: 'Allow',
             webgl: 'Noise',
-            localization: 'Custom',
-          },
-          hardwareConcurrency: 8,
-          deviceMemory: 8,
-          localization: {
-            basedOnProxy: false,
-            languages: ['en-US', 'en'],
-            locale: 'en-US',
-            timezone: 'America/New_York',
+            localization: 'BasedOnProxy',
           },
         },
       }),
@@ -201,28 +202,17 @@ class NstManager {
       }
     }
 
-    // Update profile language to en-US (Custom) before launch
-    try {
-      for (const method of ['PATCH', 'PUT']) {
-        const res = await fetch(`${this.baseUrl}/profiles/${profileId}`, {
-          method,
-          headers: { 'Content-Type': 'application/json', 'x-api-key': this.apiKey },
-          body: JSON.stringify({
-            fingerprint: {
-              flags: { localization: 'Custom' },
-              localization: { basedOnProxy: false, languages: ['en-US', 'en'], locale: 'en-US' },
-            },
-          }),
-        });
-        if (res.ok) { console.log(`[nst] Profile language set to en-US Custom (${method})`); break; }
-      }
-    } catch {}
-
+    // NOTE: this used to PATCH every profile back to en-US "Custom" right
+    // before launch (and pass --lang=en-US), which overrode whatever the
+    // profile had been given by hand and made 22/22 running browsers claim
+    // they only speak English while sitting on VN proxies with VN accounts.
+    // Removed 2026-08-22 — locale now follows the profile/proxy. Facebook and
+    // YouTube Studio render in the ACCOUNT's language regardless of the
+    // browser, and every selector in scripts/ is bilingual anyway.
     const connectConfig = {
       headless: false,
       autoClose: false,
       args: {
-        '--lang': 'en-US',
         '--disable-features': 'Translate',
       },
     };
@@ -231,7 +221,13 @@ class NstManager {
     if (options.proxy) {
       await this.setProxy(profileId, options.proxy);
       connectConfig.proxy = options.proxy;
-      connectConfig.args['--proxy-bypass-list'] = 'api.channel.tunasm.art,*.amazonaws.com,localhost,127.0.0.1';
+      // Only the worker's own API + loopback bypass the proxy. `*.amazonaws.com`
+      // used to be here too, which sent every in-browser request to any AWS
+      // host (Facebook/YouTube serve plenty of media off AWS CDNs) out the REAL
+      // IP alongside the proxied ones — a same-session IP leak. Video/thumbnail
+      // downloads don't go through the browser (lib/download.js uses node http),
+      // so nothing here depends on the AWS bypass.
+      connectConfig.args['--proxy-bypass-list'] = 'api.channel.tunasm.art,localhost,127.0.0.1';
       console.log(`[nst] Proxy: ${options.proxy} (saved to profile + bypass: api.channel.tunasm.art)`);
     }
 

package/package.json

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

package/scripts/lib/dom-pick.js

@@ -0,0 +1,53 @@
+// Pick an element inside the page WITHOUT leaving a trace in the DOM.
+//
+// The old pattern was: page.evaluate(() => el.setAttribute('__nur_like__','1'))
+// then page.locator("[__nur_like__='1']").click(), then remove the attribute.
+// That writes a custom attribute with a self-describing name onto Facebook's
+// own DOM for a few seconds — right on the button that is about to be clicked.
+// Facebook instruments its DOM (MutationObserver integrity checks); a foreign
+// attribute with a stable prefix is a fingerprint, and `data-nur-watched=done`
+// was never removed at all.
+//
+// This helper runs the same picking logic but returns the element as a
+// Playwright ElementHandle via evaluateHandle. Nothing is written to the page;
+// handle.click() / hover() are the same trusted input events a locator sends.
+//
+// pick(page, fn, arg) → { el: ElementHandle|null, data: {...} }
+//   fn runs in the page and must return { el: Element|null, ...anything }.
+//   Everything except `el` comes back JSON-serialised in `data`.
+const { humanClick } = require('./human');
+
+async function pick(page, fn, arg) {
+  let h;
+  try {
+    h = await page.evaluateHandle(fn, arg);
+  } catch {
+    return { el: null, data: {} };
+  }
+  let el = null, data = {};
+  try {
+    const prop = await h.getProperty('el');
+    el = prop.asElement();
+    if (!el) await prop.dispose().catch(() => {});
+    data = await h.evaluate((o) => { const { el: _e, ...rest } = o || {}; return rest; }).catch(() => ({}));
+  } finally {
+    await h.dispose().catch(() => {});
+  }
+  return { el, data };
+}
+
+// Click an ElementHandle: scroll into view, cursor travels there (lib/human),
+// hover a beat, click off-centre. Always disposes the handle.
+async function clickHandle(page, el, { hoverMs = [400, 1200], timeout = 4000, scroll = true } = {}) {
+  if (!el) return false;
+  try {
+    await humanClick(page, el, { hoverMs, timeout, scroll });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    await el.dispose().catch(() => {});
+  }
+}
+
+module.exports = { pick, clickHandle };

package/scripts/lib/human.js

@@ -0,0 +1,147 @@
+// Human-shaped input for the Playwright scripts. One place, used by every
+// browse/publish script so the fleet shares one behaviour instead of five
+// slightly different robots.
+//
+// What the old code looked like to a platform, measured 2026-08-22:
+//   - mouse.move(x, y) with no steps → the cursor TELEPORTS. A session had
+//     1-2 moves total, each landing dead-centre on the button it then clicked.
+//   - locator.click() → always the exact centre of the bounding box.
+//   - mouse.wheel(0, 250..900) → ONE wheel event per scroll. A real wheel
+//     sends a burst of ~100-120px notches; a trackpad sends dozens of tiny ones.
+//   - keyboard.type(ch) + uniform 60-160ms → no pauses at word boundaries,
+//     never a typo, a flat distribution no human produces.
+//   - waitForTimeout(4000) → the same 4000 every run.
+//
+// Everything here is plain Playwright input (trusted events). Nothing touches
+// the page's DOM.
+
+function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
+function rand(min, max) { return min + Math.random() * (max - min); }
+function chance(p) { return Math.random() < p; }
+
+// Log-normal-ish: most values near `mid`, a long tail to the right (the
+// "thinking pause"), hard floor at `min`.
+function skewed(min, mid, max) {
+  const u = Math.random(), v = Math.random();
+  const z = Math.sqrt(-2 * Math.log(u || 1e-9)) * Math.cos(2 * Math.PI * v); // N(0,1)
+  const x = mid * Math.exp(0.45 * z);
+  return Math.max(min, Math.min(max, x));
+}
+
+// A fixed wait turned into a jittered one: 4000 → 2800..5600.
+function jit(ms, lo = 0.7, hi = 1.4) { return Math.round(ms * rand(lo, hi)); }
+async function pause(page, ms, lo, hi) { await page.waitForTimeout(jit(ms, lo, hi)); }
+
+// Playwright doesn't expose where the cursor is, so remember it per page.
+const POS = new WeakMap();
+function cursorOf(page) {
+  if (!POS.has(page)) POS.set(page, { x: randInt(200, 600), y: randInt(200, 500) });
+  return POS.get(page);
+}
+
+// Move along a quadratic Bézier with a random control point, variable step
+// timing, a small overshoot on long hops, and a settle wobble at the end.
+async function humanMove(page, x, y) {
+  const from = cursorOf(page);
+  const dist = Math.hypot(x - from.x, y - from.y);
+  if (dist < 2) return;
+  const steps = Math.max(8, Math.min(45, Math.round(dist / 12) + randInt(-3, 6)));
+  // Control point off the straight line, proportional to distance.
+  const bend = dist * rand(0.08, 0.25) * (chance(0.5) ? 1 : -1);
+  const mx = (from.x + x) / 2, my = (from.y + y) / 2;
+  const nx = -(y - from.y) / dist, ny = (x - from.x) / dist; // unit normal
+  const cx = mx + nx * bend, cy = my + ny * bend;
+  // Long hops overshoot a little and come back.
+  const over = dist > 250 && chance(0.6) ? rand(0.02, 0.06) : 0;
+  const tx = x + (x - from.x) * over, ty = y + (y - from.y) * over;
+  for (let i = 1; i <= steps; i++) {
+    // Ease-in-out so the cursor accelerates then brakes.
+    let t = i / steps; t = t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    const px = (1 - t) * (1 - t) * from.x + 2 * (1 - t) * t * cx + t * t * tx;
+    const py = (1 - t) * (1 - t) * from.y + 2 * (1 - t) * t * cy + t * t * ty;
+    await page.mouse.move(px + rand(-0.8, 0.8), py + rand(-0.8, 0.8)).catch(() => {});
+    if (i < steps) await page.waitForTimeout(randInt(4, 18));
+  }
+  if (over) {
+    await page.waitForTimeout(randInt(30, 90));
+    for (let i = 1; i <= 4; i++) {
+      const t = i / 4;
+      await page.mouse.move(tx + (x - tx) * t, ty + (y - ty) * t).catch(() => {});
+      await page.waitForTimeout(randInt(8, 20));
+    }
+  }
+  POS.set(page, { x, y });
+}
+
+// Where inside a box a person clicks: near the middle, but not AT it.
+// Horizontal spread wider than vertical (text buttons are wide).
+function pointIn(box) {
+  const gx = Math.max(-0.38, Math.min(0.38, skewed(0, 0.12, 0.38) * (chance(0.5) ? 1 : -1)));
+  const gy = Math.max(-0.3, Math.min(0.3, skewed(0, 0.1, 0.3) * (chance(0.5) ? 1 : -1)));
+  return { x: box.x + box.width * (0.5 + gx), y: box.y + box.height * (0.5 + gy) };
+}
+
+// Click an ElementHandle or Locator: scroll into view, travel there, hover a
+// beat, press/release with a human hold time. Falls back to target.click()
+// when the box can't be read (detached, zero-size) so callers keep working.
+async function humanClick(page, target, { hoverMs = [250, 900], timeout = 4000, scroll = true } = {}) {
+  if (scroll) await target.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {});
+  const box = await target.boundingBox().catch(() => null);
+  if (!box || box.width < 2 || box.height < 2) {
+    await target.click({ timeout });
+    return;
+  }
+  const p = pointIn(box);
+  await humanMove(page, p.x, p.y);
+  await page.waitForTimeout(randInt(hoverMs[0], hoverMs[1]));
+  // Tiny drift while "deciding" — people rarely hold a pixel.
+  if (chance(0.5)) await page.mouse.move(p.x + rand(-1.5, 1.5), p.y + rand(-1.5, 1.5)).catch(() => {});
+  await page.mouse.down();
+  await page.waitForTimeout(randInt(55, 140));
+  await page.mouse.up();
+}
+
+// Scroll by ~`dy` the way a wheel does it: a burst of notches that starts
+// quick and decelerates, with an occasional mid-burst hesitation. Direction
+// follows the sign of dy. Returns the total delta actually sent.
+async function humanWheel(page, dy) {
+  const dir = dy < 0 ? -1 : 1;
+  let left = Math.abs(dy), sent = 0;
+  const notch = randInt(80, 140);
+  let n = 0;
+  while (left > 0) {
+    // First notches full size, tail ones shrink (flick + coast).
+    const k = n < 3 ? 1 : Math.max(0.25, 1 - (n - 2) * rand(0.12, 0.22));
+    const d = Math.min(left, Math.round(notch * k * rand(0.85, 1.15)));
+    if (d <= 0) break;
+    await page.mouse.wheel(0, dir * d).catch(() => {});
+    sent += d; left -= d; n++;
+    await page.waitForTimeout(n < 3 ? randInt(15, 45) : randInt(30, 110));
+    if (chance(0.08)) await page.waitForTimeout(randInt(150, 450)); // hand hesitates
+    if (n > 14) break; // never a 40-notch burst
+  }
+  return sent * dir;
+}
+
+// Type with a human cadence: skewed per-key delay, longer pauses after a
+// space / punctuation, a rare typo fixed with Backspace. Uses keyboard.type
+// for the character itself so IME/Unicode (Vietnamese) goes through unchanged.
+async function humanType(page, text, { typo = 0.025, base = 95 } = {}) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (typo > 0 && chance(typo) && /[a-z]/i.test(ch)) {
+      const wrong = String.fromCharCode(ch.charCodeAt(0) + (chance(0.5) ? 1 : -1));
+      await page.keyboard.type(wrong);
+      await page.waitForTimeout(skewed(120, 260, 700));
+      await page.keyboard.press('Backspace');
+      await page.waitForTimeout(skewed(80, 160, 400));
+    }
+    await page.keyboard.type(ch);
+    let d = skewed(35, base, 420);
+    if (ch === ' ') d += skewed(0, 60, 350);
+    else if (/[.,!?;:\n]/.test(ch)) d += skewed(80, 220, 900);
+    await page.waitForTimeout(Math.round(d));
+  }
+}
+
+module.exports = { randInt, rand, chance, skewed, jit, pause, cursorOf, humanMove, humanClick, humanWheel, humanType };