channel-worker 1.6.19 → 2.0.0

package/lib/api-client.js

@@ -73,6 +73,19 @@ class ApiClient {
     return this.request('PUT', `/workers/commands/${commandId}`, data);
   }
 
+  // Scene dispatch
+  async getRenderers() {
+    return this.request('GET', '/workers/renderers');
+  }
+
+  async getSceneQueueCount() {
+    return this.request('GET', '/workers/scene-queue-count');
+  }
+
+  async sceneDispatch(nstProfileId) {
+    return this.request('POST', '/workers/scene-dispatch', { nst_profile_id: nstProfileId });
+  }
+
   // Extension download
   async getExtensionVersion() {
     const data = await this.request('GET', '/extension-download/version');

package/lib/command-poller.js

@@ -25,13 +25,21 @@ class CommandPoller {
     console.log('[commands] Polling for commands (every 3s)');
     this.poll();
     this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+
+    // Scene dispatcher — processes queued scene commands sequentially
+    console.log('[scene-dispatch] Started (every 5s)');
+    this._dispatchTimer = setInterval(() => this._dispatchScenes(), 5000);
+    this._dispatching = false;
+
+    // Profile timeout — close idle profiles after 3 minutes with no work
+    this._profileTimeoutTimer = setInterval(() => this._checkProfileTimeouts(), 60000);
+    this._profileLastActivity = {}; // { nst_profile_id: timestamp }
   }
 
   stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
+    if (this.timer) { clearInterval(this.timer); this.timer = null; }
+    if (this._dispatchTimer) { clearInterval(this._dispatchTimer); this._dispatchTimer = null; }
+    if (this._profileTimeoutTimer) { clearInterval(this._profileTimeoutTimer); this._profileTimeoutTimer = null; }
   }
 
   async poll() {
@@ -1107,6 +1115,143 @@ class CommandPoller {
       });
     }
   }
+  // ─── Scene Dispatcher ────────────────────────────────────────────────────────
+  // Polls queued scene commands, checks Nstbrowser for running profiles,
+  // assigns command to a profile (launching if under parallel limit).
+  // Processes ONE command per cycle — sequential, no race conditions.
+
+  async _dispatchScenes() {
+    if (this._dispatching) return;
+    this._dispatching = true;
+    try {
+      // 1. Check if there are queued commands
+      const queueCount = await this.api.getSceneQueueCount();
+      if (!queueCount) { this._dispatching = false; return; }
+
+      // 2. Init Nstbrowser if needed
+      if (!this.nst) {
+        const apiKey = await this.api.getSetting('nst_api_key');
+        if (apiKey) this.nst = new NstManager(apiKey);
+        else { this._dispatching = false; return; }
+      }
+
+      // 3. Get parallel limit + renderers
+      const parallelLimit = parseInt(await this.api.getSetting('veo3_parallel_limit')) || 1;
+      const renderers = await this.api.getRenderers();
+      if (!renderers?.length) { this._dispatching = false; return; }
+
+      // 4. Get running browsers from Nstbrowser (source of truth)
+      const running = await this.nst.getRunningBrowsers();
+      const runningIds = new Set(running.map(b => b.profileId));
+
+      // 5. Match renderers to running profiles
+      const runningRenderers = renderers.filter(r => {
+        const profileId = this.nst.isUUID(r.nst_profile_id)
+          ? r.nst_profile_id
+          : this._resolvedProfiles?.[r.nst_profile_id];
+        return profileId && runningIds.has(profileId);
+      });
+      const offlineRenderers = renderers.filter(r => !runningRenderers.includes(r));
+
+      // 6. Pick target profile
+      let target = null;
+
+      if (runningRenderers.length > 0) {
+        // Assign to a running renderer (round-robin by name for simplicity)
+        target = runningRenderers[0]; // TODO: could pick least loaded
+      }
+
+      if (!target && runningRenderers.length < parallelLimit && offlineRenderers.length > 0) {
+        // Under limit — launch a new profile
+        target = offlineRenderers[0];
+        console.log(`[scene-dispatch] Launching ${target.name} (running: ${runningRenderers.length}/${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`);
+        } catch (err) {
+          console.error(`[scene-dispatch] Failed to launch ${target.name}: ${err.message}`);
+          target = runningRenderers[0] || null; // fallback to running
+        }
+      }
+
+      if (!target) {
+        // At limit, no running renderers available — wait for next cycle
+        this._dispatching = false;
+        return;
+      }
+
+      // 7. Claim command and assign to profile
+      const cmd = await this.api.sceneDispatch(target.nst_profile_id);
+      if (cmd) {
+        this._profileLastActivity[target.nst_profile_id] = Date.now();
+        console.log(`[scene-dispatch] Assigned ${cmd.type} → ${target.name} (queue: ${queueCount - 1})`);
+      }
+    } catch (err) {
+      console.error(`[scene-dispatch] Error: ${err.message}`);
+    }
+    this._dispatching = false;
+  }
+
+  // ─── Profile Timeout ───────────────────────────────────────────────────────
+  // Close profiles that have been idle (no commands assigned) for too long.
+
+  async _checkProfileTimeouts() {
+    try {
+      if (!this.nst) return;
+
+      const IDLE_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+      const now = Date.now();
+      const running = await this.nst.getRunningBrowsers();
+      if (running.length === 0) return;
+
+      // Check if there are any queued commands — if so, don't close anything
+      const queueCount = await this.api.getSceneQueueCount();
+      if (queueCount > 0) return;
+
+      for (const browser of running) {
+        const profileId = browser.profileId;
+        const lastActivity = this._profileLastActivity[profileId] || 0;
+        if (lastActivity && (now - lastActivity) > IDLE_TIMEOUT) {
+          console.log(`[profile-timeout] Closing idle profile ${browser.name || profileId} (idle ${Math.round((now - lastActivity) / 1000)}s)`);
+          try {
+            await this.nst.stopProfile(profileId);
+            delete this._profileLastActivity[profileId];
+          } catch (e) {
+            console.warn(`[profile-timeout] Failed to close ${profileId}: ${e.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`[profile-timeout] Error: ${err.message}`);
+    }
+  }
 }
 
 module.exports = { CommandPoller };

package/lib/nst-manager.js

@@ -153,14 +153,8 @@ class NstManager {
     console.log(`[nst] Running browsers: ${running.map(b => b.name || b.profileId).join(', ') || 'none'}`);
     const isRunning = running.some(b => b.profileId === profileId);
     if (isRunning) {
-      console.log(`[nst] Profile ${profileId} already running — stopping first`);
-      try {
-        await this.stopProfile(profileId);
-        console.log(`[nst] Stop command sent, waiting 3s...`);
-        await new Promise(r => setTimeout(r, 3000));
-      } catch (e) {
-        console.warn(`[nst] Stop failed: ${e.message} — continuing anyway`);
-      }
+      console.log(`[nst] Profile ${profileId} already running — skipping launch`);
+      return { profileId, alreadyRunning: true };
     }
 
     // Update profile language to en-US (Custom) before launch

package/package.json

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