channel-worker 2.5.39 → 2.5.41

package/lib/command-poller.js

@@ -1443,6 +1443,33 @@ class CommandPoller {
       const domQ = typeof queueInfo === 'number' ? queueCount : (queueInfo?.dom_count || 0);
       if (!queueCount) { this._dispatching = false; return; }
 
+      // 4b. WHO can actually claim that queue. An idea pinned to one renderer
+      //     produces commands only that profile may claim — a raw total told us
+      //     "there's work, open another profile", the freshly-opened profile
+      //     claimed nothing, the round-robin below closed it as idle, and the
+      //     next cycle reopened it: a browser blinking open/closed every 5s
+      //     (observed on i5-pc: idea pinned to veo3-pro1, veo3-pro4 flapping).
+      //     unpinned_count === null means an older API that doesn't report the
+      //     breakdown → fall back to the previous "everything is claimable".
+      const unpinnedCount = (queueInfo && typeof queueInfo.unpinned_count === 'number')
+        ? queueInfo.unpinned_count
+        : null;
+      const pinnedMap = (queueInfo && queueInfo.pinned && typeof queueInfo.pinned === 'object')
+        ? queueInfo.pinned
+        : {};
+      const pinnedFor = (r) => {
+        const id = String(r?.nst_profile_id || '');
+        if (!id) return 0;
+        if (typeof pinnedMap[id] === 'number') return pinnedMap[id];
+        const lower = id.toLowerCase();
+        for (const k of Object.keys(pinnedMap)) {
+          if (k.toLowerCase() === lower) return pinnedMap[k];
+        }
+        return 0;
+      };
+      // Can this renderer claim anything at all right now?
+      const canClaim = (r) => (unpinnedCount === null) || unpinnedCount > 0 || pinnedFor(r) > 0;
+
       // 5. Parallel limit — sourced from THIS daemon's Worker.parallel_limit
       //    via /workers/me. Replaces the legacy global Settings
       //    (flowkit_max_concurrent / veo3_parallel_limit) which throttled
@@ -1456,12 +1483,16 @@ class CommandPoller {
       let parallelLimit = 2; // sane default if /workers/me fails or is
                              // unavailable on an older API; effective limit
                              // is still bounded by server-side enforcement.
+      let independentAccounts = false; // when true: renderers are SEPARATE Flow
+                             // accounts → run all concurrently, skip the
+                             // shared-account round-robin close-idle rotation.
       try {
         if (this.api.getMyWorker) {
           const me = await this.api.getMyWorker();
           if (me && typeof me.parallel_limit === 'number') {
             parallelLimit = Math.max(0, me.parallel_limit);
           }
+          if (me && me.independent_accounts) independentAccounts = true;
         }
       } catch (e) {
         if (this.config.verbose) console.warn('[scene-dispatch] getMyWorker failed, using default:', e.message);
@@ -1472,7 +1503,19 @@ class CommandPoller {
         && (!r.pause_until || new Date(r.pause_until).getTime() > Date.now());
       let stillOffline = renderers.filter(r => !runningRenderers.includes(r) && !isPaused(r));
       const pausedCount = renderers.filter(isPaused).length;
-      console.log(`[scene-dispatch] running=${runningRenderers.length} cap=${parallelLimit} (flowkit=${flowkitQ} dom=${domQ}) offline=${stillOffline.length} paused=${pausedCount} queue=${queueCount} names=[${runningRenderers.map(r=>r.name)}]`);
+      const pinSummary = unpinnedCount === null
+        ? 'pins=n/a'
+        : `unpinned=${unpinnedCount} pins=${JSON.stringify(pinnedMap)}`;
+      console.log(`[scene-dispatch] running=${runningRenderers.length} cap=${parallelLimit} (flowkit=${flowkitQ} dom=${domQ}) offline=${stillOffline.length} paused=${pausedCount} queue=${queueCount} ${pinSummary} names=[${runningRenderers.map(r=>r.name)}]`);
+
+      // Offline renderers that could actually claim something. Everything else
+      // must stay closed — opening it would only produce the flap described
+      // above (open → claim nothing → closed as idle → reopen).
+      let launchable = stillOffline.filter(canClaim);
+      if (stillOffline.length > launchable.length) {
+        const blocked = stillOffline.filter(r => !canClaim(r)).map(r => r.name || r.nst_profile_id);
+        console.log(`[scene-dispatch] not launching [${blocked.join(',')}] — the whole queue is pinned to another renderer`);
+      }
 
       // ROUND-ROBIN ROTATION — when a running renderer just finished its
       // scene (no in-flight cmd) AND there's at least one OFFLINE sibling
@@ -1483,7 +1526,13 @@ class CommandPoller {
       // browser idle on Flow page keeps refreshing tokens / pinging
       // telemetry → Veo flags "2 concurrent sessions per account" → captcha.
       // Closing it = 0 idle sessions, only 1 active at a time.
-      if (queueCount > 0 && stillOffline.length > 0 && runningRenderers.length > 0) {
+      // Round-robin close-idle is a SHARED-ACCOUNT safety (keep ≤1 Flow session
+      // live per Google account). With independent_accounts every renderer is
+      // its own account → skip it entirely and let them all run concurrently.
+      // Rotate only when there is a sibling that can actually take over the
+      // remaining work — rotating toward a renderer the queue is not pinned to
+      // just closes a useful profile and opens a useless one.
+      if (!independentAccounts && queueCount > 0 && launchable.length > 0 && runningRenderers.length > 0) {
         const stoppedNames = [];
         for (const r of [...runningRenderers]) {
           // Skip externally-launched profiles (user opened manually via NST UI)
@@ -1516,7 +1565,9 @@ class CommandPoller {
       // the launcher picks the round-robin partner, not the one that just
       // finished. API populates last_command_assigned_at on every claim,
       // so this naturally implements turn-taking across siblings.
-      stillOffline = stillOffline.slice().sort((a, b) => {
+      // Re-filter first: the round-robin above may have pushed a just-closed
+      // renderer back into stillOffline.
+      launchable = stillOffline.filter(canClaim).slice().sort((a, b) => {
         const ta = a.last_command_assigned_at ? new Date(a.last_command_assigned_at).getTime() : 0;
         const tb = b.last_command_assigned_at ? new Date(b.last_command_assigned_at).getTime() : 0;
         return ta - tb;
@@ -1536,11 +1587,11 @@ class CommandPoller {
       const needNew = Math.max(0, queueCount);
       const neededLaunches = Math.min(
         parallelLimit - runningRenderers.length,
-        stillOffline.length,
+        launchable.length,
         needNew,
       );
       for (let li = 0; li < Math.max(0, neededLaunches); li++) {
-        const toLaunch = stillOffline[li];
+        const toLaunch = launchable[li];
         console.log(`[scene-dispatch] Launching ${toLaunch.name} (${runningRenderers.length + li + 1}/${parallelLimit})`);
         try {
           await this._launchRendererProfile(toLaunch);
@@ -1786,14 +1837,33 @@ class CommandPoller {
       const running = await this.nst.getRunningBrowsers();
       if (running.length === 0) return;
 
-      // Check if there are any queued commands — if so, don't close anything
+      // Check if there are any queued commands — if so, don't close anything.
+      // Exception: a queue that is ENTIRELY pinned to specific renderers keeps
+      // every other open profile idle forever, so it must not block the idle
+      // close (each profile is still spared individually below if the queue
+      // holds work pinned to it).
       const qi = await this.api.getSceneQueueCount();
       const queueCount = typeof qi === 'number' ? qi : (qi?.total || 0);
-      if (queueCount > 0) return;
+      const unpinnedCount = (qi && typeof qi.unpinned_count === 'number') ? qi.unpinned_count : null;
+      const pinnedMap = (qi && qi.pinned && typeof qi.pinned === 'object') ? qi.pinned : {};
+      const pinnedForId = (id) => {
+        if (!id) return 0;
+        if (typeof pinnedMap[id] === 'number') return pinnedMap[id];
+        const lower = String(id).toLowerCase();
+        for (const k of Object.keys(pinnedMap)) {
+          if (k.toLowerCase() === lower) return pinnedMap[k];
+        }
+        return 0;
+      };
+      // Old API (no breakdown) → previous behaviour: any queue blocks closing.
+      if (queueCount > 0 && (unpinnedCount === null || unpinnedCount > 0)) return;
 
       for (const browser of running) {
         const profileId = browser.profileId;
         const name = browser.name?.toLowerCase();
+        // Queue holds work pinned to THIS profile → it's about to be claimed,
+        // leave the browser open.
+        if (pinnedForId(profileId) > 0 || pinnedForId(name) > 0) continue;
         // Match by UUID or name (renderers use name as nst_profile_id)
         const lastActivity = this._profileLastActivity[profileId]
           || (name && this._profileLastActivity[name])

package/package.json

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