channel-worker 2.0.2 → 2.1.0

package/lib/command-poller.js

@@ -334,6 +334,19 @@ class CommandPoller {
         else if (fs.statSync(src).isDirectory()) fs.cpSync(src, dest, { recursive: true });
       }
       console.log(`[commands] CC extension downloaded to ${extPath}`);
+
+      // Close running profiles so they reload with new extension on next launch
+      if (this.nst) {
+        try {
+          const running = await this.nst.getRunningBrowsers();
+          if (running.length > 0) {
+            console.log(`[commands] Closing ${running.length} running profiles to reload extension...`);
+            for (const b of running) {
+              try { await this.nst.stopProfile(b.profileId); } catch {}
+            }
+          }
+        } catch {}
+      }
     } finally {
       try { fs.unlinkSync(tmpArchive); } catch {}
       try { fs.rmSync(tmpExtract, { recursive: true, force: true }); } catch {}
@@ -1153,66 +1166,38 @@ class CommandPoller {
       });
       const offlineRenderers = renderers.filter(r => !runningRenderers.includes(r));
 
-      // 6. Pick target profile — launch new if under limit, else assign to running
-      let target = null;
+      // 6. Launch profiles up to parallel limit
       console.log(`[scene-dispatch] running=${runningRenderers.length}/${parallelLimit} offline=${offlineRenderers.length} queue=${queueCount} names=[${runningRenderers.map(r=>r.name)}]`);
 
-      if (runningRenderers.length < parallelLimit && offlineRenderers.length > 0) {
-        // Under limit — launch a new profile first
-        target = offlineRenderers[0];
-        console.log(`[scene-dispatch] Launching ${target.name} (running: ${runningRenderers.length}/${parallelLimit})`);
+      const neededLaunches = Math.min(parallelLimit - runningRenderers.length, offlineRenderers.length, queueCount);
+      for (let li = 0; li < neededLaunches; li++) {
+        const toLaunch = offlineRenderers[li];
+        console.log(`[scene-dispatch] Launching ${toLaunch.name} (running: ${runningRenderers.length + li}/${parallelLimit})`);
         try {
-          await this.nst.ensureProfile(target.nst_profile_id, { os: target.os || 'windows', proxy: target.proxy || null });
-
-          const path = require('path');
-          const os_mod = require('os');
-          const defaultCCExtPath = path.join(os_mod.homedir(), 'content-creator-ext');
-          const baseExtPath = this.config.content_creator_ext_path || defaultCCExtPath;
-          await this._ensureContentCreatorExt(baseExtPath);
-
-          // Create unique ext dir per profile
-          let extensionPath = baseExtPath;
-          const fs = require('fs');
-          const uniqueExtPath = baseExtPath + '-' + target.nst_profile_id;
-          try {
-            if (fs.existsSync(uniqueExtPath)) fs.rmSync(uniqueExtPath, { recursive: true });
-            fs.mkdirSync(uniqueExtPath, { recursive: true });
-            fs.cpSync(baseExtPath, uniqueExtPath, { recursive: true });
-            fs.writeFileSync(path.join(uniqueExtPath, 'config.json'), JSON.stringify({
-              channelManagerApi: this.api.baseUrl,
-              profileId: target.nst_profile_id,
-              workerToken: this.config.worker_token || '',
-              workerType: 'veo3',
-            }));
-            extensionPath = uniqueExtPath;
-          } catch (e) {
-            console.warn(`[scene-dispatch] Ext dir failed: ${e.message}, using base`);
-          }
-
-          await this.nst.launchProfile(target.nst_profile_id, { proxy: target.proxy || null, extensionPath });
-          console.log(`[scene-dispatch] ${target.name} launched`);
+          await this._launchRendererProfile(toLaunch);
+          runningRenderers.push(toLaunch); // now considered running
+          console.log(`[scene-dispatch] ${toLaunch.name} launched`);
         } catch (err) {
-          console.error(`[scene-dispatch] Failed to launch ${target.name}: ${err.message}`);
-          target = runningRenderers[0] || null; // fallback to running
+          console.error(`[scene-dispatch] Failed to launch ${toLaunch.name}: ${err.message}`);
         }
       }
 
-      // Fallback: assign to least loaded running renderer
-      if (!target && runningRenderers.length > 0) {
-        target = runningRenderers[0]; // extension processes commands sequentially per profile
-      }
-
-      if (!target) {
-        // No renderers available at all — wait for next cycle
+      if (runningRenderers.length === 0) {
         this._dispatching = false;
         return;
       }
 
-      // 7. Claim command and assign to profile
-      const cmd = await this.api.sceneDispatch(target.nst_profile_id);
-      if (cmd) {
+      // 7. Assign queued commands round-robin across running renderers
+      let assigned = 0;
+      for (let qi = 0; qi < queueCount; qi++) {
+        const target = runningRenderers[qi % runningRenderers.length];
+        const cmd = await this.api.sceneDispatch(target.nst_profile_id);
+        if (!cmd) break; // queue empty
         this._profileLastActivity[target.nst_profile_id] = Date.now();
-        console.log(`[scene-dispatch] Assigned ${cmd.type} → ${target.name} (queue: ${queueCount - 1})`);
+        assigned++;
+      }
+      if (assigned > 0) {
+        console.log(`[scene-dispatch] Assigned ${assigned} commands across ${runningRenderers.length} renderers`);
       }
     } catch (err) {
       console.error(`[scene-dispatch] Error: ${err.message}`);
@@ -1220,6 +1205,44 @@ class CommandPoller {
     this._dispatching = false;
   }
 
+  async _launchRendererProfile(renderer) {
+    await this.nst.ensureProfile(renderer.nst_profile_id, { os: renderer.os || 'windows', proxy: renderer.proxy || null });
+
+    const path = require('path');
+    const os_mod = require('os');
+    const fs = require('fs');
+    const defaultCCExtPath = path.join(os_mod.homedir(), 'content-creator-ext');
+    const baseExtPath = this.config.content_creator_ext_path || defaultCCExtPath;
+    await this._ensureContentCreatorExt(baseExtPath);
+
+    let extensionPath = baseExtPath;
+    const extVersion = (() => { try { return JSON.parse(fs.readFileSync(path.join(baseExtPath, 'manifest.json'), 'utf8')).version; } catch { return '0'; } })();
+    const uniqueExtPath = baseExtPath + '-' + renderer.nst_profile_id + '-v' + extVersion;
+    try {
+      const parent = path.dirname(baseExtPath);
+      const prefix = path.basename(baseExtPath) + '-' + renderer.nst_profile_id;
+      try {
+        fs.readdirSync(parent)
+          .filter(d => d.startsWith(prefix) && d !== path.basename(uniqueExtPath))
+          .forEach(d => { try { fs.rmSync(path.join(parent, d), { recursive: true }); } catch {} });
+      } catch {}
+      if (fs.existsSync(uniqueExtPath)) fs.rmSync(uniqueExtPath, { recursive: true });
+      fs.mkdirSync(uniqueExtPath, { recursive: true });
+      fs.cpSync(baseExtPath, uniqueExtPath, { recursive: true });
+      fs.writeFileSync(path.join(uniqueExtPath, 'config.json'), JSON.stringify({
+        channelManagerApi: this.api.baseUrl,
+        profileId: renderer.nst_profile_id,
+        workerToken: this.config.worker_token || '',
+        workerType: 'veo3',
+      }));
+      extensionPath = uniqueExtPath;
+    } catch (e) {
+      console.warn(`[scene-dispatch] Ext dir failed: ${e.message}, using base`);
+    }
+
+    await this.nst.launchProfile(renderer.nst_profile_id, { proxy: renderer.proxy || null, extensionPath });
+  }
+
   // ─── Profile Timeout ───────────────────────────────────────────────────────
   // Close profiles that have been idle (no commands assigned) for too long.
 

package/package.json

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