channel-worker 2.3.4 → 2.4.0

package/lib/api-client.js

@@ -83,6 +83,13 @@ class ApiClient {
     return this.request('GET', '/workers/scene-queue-count');
   }
 
+  // ChatGPT subscription dispatch — returns { count, profile_id } so the
+  // daemon knows whether to launch a dedicated capture profile (distinct
+  // from the Veo3/FlowKit renderers pool).
+  async getChatgptQueue() {
+    return this.request('GET', '/workers/chatgpt-queue-count');
+  }
+
   async sceneDispatch(nstProfileId) {
     return this.request('POST', '/workers/scene-dispatch', { nst_profile_id: nstProfileId });
   }

package/lib/command-poller.js

@@ -31,14 +31,21 @@ class CommandPoller {
     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);
+    // ChatGPT-subscription dispatcher — launches the configured profile when
+    // a thumbnail command is waiting, independent from the scene renderers pool.
+    console.log('[chatgpt-dispatch] Started (every 5s)');
+    this._chatgptDispatchTimer = setInterval(() => this._dispatchChatgpt(), 5000);
+    this._chatgptDispatching = false;
+
+    // Profile timeout — close idle profiles after 30s with no work
+    this._profileTimeoutTimer = setInterval(() => this._checkProfileTimeouts(), 10000);
     this._profileLastActivity = {}; // { nst_profile_id: timestamp }
   }
 
   stop() {
     if (this.timer) { clearInterval(this.timer); this.timer = null; }
     if (this._dispatchTimer) { clearInterval(this._dispatchTimer); this._dispatchTimer = null; }
+    if (this._chatgptDispatchTimer) { clearInterval(this._chatgptDispatchTimer); this._chatgptDispatchTimer = null; }
     if (this._profileTimeoutTimer) { clearInterval(this._profileTimeoutTimer); this._profileTimeoutTimer = null; }
   }
 
@@ -1227,6 +1234,35 @@ class CommandPoller {
       const stillOffline = renderers.filter(r => !runningRenderers.includes(r));
       console.log(`[scene-dispatch] running=${runningRenderers.length}/${parallelLimit} (flowkit=${flowkitQ} dom=${domQ}) offline=${stillOffline.length} queue=${queueCount} names=[${runningRenderers.map(r=>r.name)}]`);
 
+      // 5b. Close excess profiles — when parallelLimit drops (e.g., after a DOM→FlowKit
+      //     switch), idle profiles over the cap should shut down instead of staying open
+      //     and getting throttled at /flowkit/claim-command.
+      if (runningRenderers.length > parallelLimit) {
+        const excess = runningRenderers.length - parallelLimit;
+        const idleRenderers = [];
+        for (const r of runningRenderers) {
+          // Only daemon-launched profiles are eligible — skip manual launches
+          if (!this._profileLastActivity[r.nst_profile_id]) continue;
+          try {
+            const c = await this.api.rendererHasCommands(r.nst_profile_id);
+            if (c === 0) idleRenderers.push(r);
+          } catch {}
+        }
+        const toClose = idleRenderers.slice(0, excess);
+        for (const r of toClose) {
+          console.log(`[scene-dispatch] Closing excess profile ${r.name} (over cap ${parallelLimit})`);
+          try {
+            await this.nst.stopProfile(r.nst_profile_id);
+            delete this._profileLastActivity[r.nst_profile_id];
+            if (r.name) delete this._profileLastActivity[r.name.toLowerCase()];
+            const idx = runningRenderers.indexOf(r);
+            if (idx >= 0) runningRenderers.splice(idx, 1);
+          } catch (e) {
+            console.warn(`[scene-dispatch] Failed to close excess ${r.name}: ${e.message}`);
+          }
+        }
+      }
+
       // Count how many running profiles are actually free (no commands)
       let freeRunning = 0;
       for (const r of runningRenderers) {
@@ -1314,6 +1350,47 @@ class CommandPoller {
     await this.nst.launchProfile(renderer.nst_profile_id, { proxy: renderer.proxy || null, extensionPath, forceRelaunch: options.forceRelaunch });
   }
 
+  // ─── ChatGPT Subscription Dispatch ─────────────────────────────────────────
+  // Separate dispatcher for the dedicated ChatGPT profile (configured via
+  // Setting: chatgpt_sub_profile_id). Launches the profile on-demand when a
+  // generate_thumbnail command is pending, so Veo3 renderers stay untouched.
+
+  async _dispatchChatgpt() {
+    if (this._chatgptDispatching) return;
+    this._chatgptDispatching = true;
+    try {
+      if (!this.nst) return;
+      const queue = await this.api.getChatgptQueue().catch(() => null);
+      if (!queue || !queue.profile_id || queue.count <= 0) return;
+
+      const profileId = queue.profile_id;
+      // Skip launch if already running (check via Nstbrowser running list).
+      let alreadyRunning = false;
+      try {
+        const running = await this.nst.getRunningBrowsers();
+        alreadyRunning = running.some(b => b.profileId === profileId || (b.name && b.name.toLowerCase() === profileId.toLowerCase()));
+      } catch {}
+      if (alreadyRunning) {
+        this._profileLastActivity[profileId] = Date.now();
+        return;
+      }
+
+      console.log(`[chatgpt-dispatch] Launching ${profileId} (queue=${queue.count})`);
+      try {
+        // Reuse _launchRendererProfile contract — it just needs { nst_profile_id, os, proxy }.
+        await this._launchRendererProfile({ nst_profile_id: profileId, os: 'windows', proxy: null });
+        this._profileLastActivity[profileId] = Date.now();
+        console.log(`[chatgpt-dispatch] ${profileId} launched`);
+      } catch (err) {
+        console.error(`[chatgpt-dispatch] Failed to launch ${profileId}: ${err.message}`);
+      }
+    } catch (err) {
+      console.error(`[chatgpt-dispatch] Error: ${err.message}`);
+    } finally {
+      this._chatgptDispatching = false;
+    }
+  }
+
   // ─── Profile Timeout ───────────────────────────────────────────────────────
   // Close profiles that have been idle (no commands assigned) for too long.
 
@@ -1321,7 +1398,7 @@ class CommandPoller {
     try {
       if (!this.nst) return;
 
-      const IDLE_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+      const IDLE_TIMEOUT = 30 * 1000; // 30s — matches old extension-side behavior
       const now = Date.now();
       const running = await this.nst.getRunningBrowsers();
       if (running.length === 0) return;

package/package.json

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