channel-worker 2.0.3 → 2.1.1

package/lib/api-client.js

@@ -86,6 +86,10 @@ class ApiClient {
     return this.request('POST', '/workers/scene-dispatch', { nst_profile_id: nstProfileId });
   }
 
+  async rendererHasCommands(nstProfileId) {
+    return this.request('GET', `/workers/renderer-has-commands?nst_profile_id=${encodeURIComponent(nstProfileId)}`);
+  }
+
   // Extension download
   async getExtensionVersion() {
     const data = await this.request('GET', '/extension-download/version');

package/lib/command-poller.js

@@ -1166,75 +1166,55 @@ 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;
-      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})`);
+      // 5b. Crash recovery — re-launch offline profiles that have assigned commands
+      for (const r of offlineRenderers) {
         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 + version (forces Chromium to reload SW)
-          let extensionPath = baseExtPath;
-          const fs = require('fs');
-          const extVersion = (() => { try { return JSON.parse(fs.readFileSync(path.join(baseExtPath, 'manifest.json'), 'utf8')).version; } catch { return '0'; } })();
-          const uniqueExtPath = baseExtPath + '-' + target.nst_profile_id + '-v' + extVersion;
-          try {
-            // Clean old version dirs for this profile
-            const parent = path.dirname(baseExtPath);
-            const prefix = path.basename(baseExtPath) + '-' + target.nst_profile_id;
+          const cmdCount = await this.api.rendererHasCommands(r.nst_profile_id);
+          if (cmdCount > 0) {
+            console.log(`[scene-dispatch] Crash recovery: ${r.name} has ${cmdCount} commands but not running — relaunching`);
             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: 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._launchRendererProfile(r);
+              runningRenderers.push(r);
+              console.log(`[scene-dispatch] ${r.name} recovered`);
+            } catch (err) {
+              console.error(`[scene-dispatch] Failed to recover ${r.name}: ${err.message}`);
+            }
           }
+        } catch {}
+      }
+
+      // 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)}]`);
 
-          await this.nst.launchProfile(target.nst_profile_id, { proxy: target.proxy || null, extensionPath });
-          console.log(`[scene-dispatch] ${target.name} launched`);
+      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._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}`);
@@ -1242,6 +1222,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.3",
+  "version": "2.1.1",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {