channel-worker 2.2.5 → 2.3.0

package/lib/cache-server.js

@@ -0,0 +1,144 @@
+/**
+ * Local HTTP cache server.
+ *
+ * Extensions running in Nstbrowser profiles share this single daemon-side
+ * cache instead of each downloading the same S3 ref (~1MB master cast)
+ * separately. First request misses, fetches via API; subsequent requests
+ * across ALL profiles on this machine hit the in-memory cache.
+ *
+ * Endpoint: GET /cache/s3?file_key=<key>
+ *   → mirrors the channel-manager API /extension/resolve-s3-url response:
+ *     { success, data: { base64, content_type, size } }
+ */
+
+const http = require('http');
+const url = require('url');
+
+class CacheServer {
+  constructor(api, options = {}) {
+    this.api = api;
+    this.port = options.port || 8849;
+    this.host = options.host || '127.0.0.1';
+    this.maxEntries = options.maxEntries || 32; // ~32 × 1MB ≈ 32MB worst case
+    this.cache = new Map(); // file_key → { base64, contentType, size, ts }
+    this.server = null;
+    this.stats = { hits: 0, misses: 0, errors: 0 };
+  }
+
+  _evictIfNeeded() {
+    while (this.cache.size > this.maxEntries) {
+      // Drop oldest entry (Map preserves insertion order)
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+  }
+
+  async _resolveS3(fileKey) {
+    if (this.cache.has(fileKey)) {
+      this.stats.hits++;
+      // Touch — re-insert to mark as MRU
+      const entry = this.cache.get(fileKey);
+      this.cache.delete(fileKey);
+      this.cache.set(fileKey, entry);
+      return { ok: true, ...entry };
+    }
+    this.stats.misses++;
+    // Fetch via API client (extension/resolve-s3-url is POST)
+    const baseUrl = this.api.baseUrl;
+    const res = await fetch(`${baseUrl}/extension/resolve-s3-url`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'x-worker-token': this.api.workerToken },
+      body: JSON.stringify({ file_key: fileKey, as_base64: true }),
+    });
+    const json = await res.json();
+    if (!json.success || !json.data?.base64) {
+      this.stats.errors++;
+      return { ok: false, error: json.message || 'resolve failed' };
+    }
+    const entry = {
+      base64: json.data.base64,
+      contentType: json.data.content_type || 'image/png',
+      size: json.data.size || json.data.base64.length,
+      ts: Date.now(),
+    };
+    this.cache.set(fileKey, entry);
+    this._evictIfNeeded();
+    return { ok: true, ...entry };
+  }
+
+  _handleRequest(req, res) {
+    const parsed = url.parse(req.url, true);
+    if (req.method === 'GET' && parsed.pathname === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, cache: this.cache.size, stats: this.stats }));
+      return;
+    }
+    if (req.method === 'GET' && parsed.pathname === '/cache/s3') {
+      const fileKey = parsed.query.file_key;
+      if (!fileKey) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, message: 'file_key required' }));
+        return;
+      }
+      this._resolveS3(fileKey).then(result => {
+        if (!result.ok) {
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ success: false, message: result.error }));
+          return;
+        }
+        // CORS — extensions may treat localhost as cross-origin
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Cache-Control': 'no-store',
+        });
+        res.end(JSON.stringify({
+          success: true,
+          data: {
+            base64: result.base64,
+            content_type: result.contentType,
+            size: result.size,
+          },
+        }));
+      }).catch(err => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, message: err.message }));
+      });
+      return;
+    }
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: false, message: 'not found' }));
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => this._handleRequest(req, res));
+      this.server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          console.error(`[cache-server] Port ${this.port} is already in use. ` +
+            `Another daemon may be running, or a previous instance crashed and the OS hasn't released the port yet ` +
+            `(usually clears in 30-60s). On Windows: 'netstat -ano | findstr ${this.port}' then 'taskkill /PID <pid> /F'. ` +
+            `On Mac/Linux: 'lsof -ti:${this.port} | xargs kill -9'.`);
+        }
+        reject(err);
+      });
+      this.server.listen(this.port, this.host, () => {
+        console.log(`[cache-server] Listening on http://${this.host}:${this.port} (max ${this.maxEntries} entries)`);
+        resolve();
+      });
+    });
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+
+  url() {
+    return `http://${this.host}:${this.port}`;
+  }
+}
+
+module.exports = { CacheServer };

package/lib/command-poller.js

@@ -146,6 +146,7 @@ class CommandPoller {
             channelManagerApi: 'https://api.channel.tunasm.art',
             profileId: profile_id,
             workerToken: this.config.worker_token || '',
+            daemonUrl: this.config.daemon_url || '',
           }));
           extensionPath = uniqueExtPath;
           console.log(`[commands] Extension dir: ${uniqueExtPath}`);
@@ -222,6 +223,7 @@ class CommandPoller {
             profileId: nst_profile_id,
             workerToken: this.config.worker_token || '',
             workerType: 'veo3',
+            daemonUrl: this.config.daemon_url || '',
           }));
           extensionPath = uniqueExtPath;
           console.log(`[commands] Veo3 ext dir: ${uniqueExtPath}`);
@@ -1323,17 +1325,9 @@ class CommandPoller {
         const lastActivity = this._profileLastActivity[profileId]
           || (name && this._profileLastActivity[name])
           || 0;
-        // If not tracked: check if it has commands — if not, close it (orphaned profile)
-        if (!lastActivity) {
-          try {
-            const cmdCount = name ? await this.api.rendererHasCommands(name) : 0;
-            if (cmdCount > 0) continue; // has work, skip
-          } catch {}
-          // No commands + not tracked = orphaned, close
-          console.log(`[profile-timeout] Closing orphaned profile ${browser.name || profileId} (not tracked, no commands)`);
-          try { await this.nst.stopProfile(profileId); } catch {}
-          continue;
-        }
+        // Only close profiles that daemon has launched (tracked in _profileLastActivity).
+        // User-launched profiles have no tracking entry — leave them alone.
+        if (!lastActivity) continue;
         if ((now - lastActivity) > IDLE_TIMEOUT) {
           console.log(`[profile-timeout] Closing idle profile ${browser.name || profileId} (idle ${Math.round((now - lastActivity) / 1000)}s)`);
           try {

package/lib/daemon.js

@@ -4,6 +4,7 @@ const { JobPoller } = require('./job-poller');
 const { CommandPoller } = require('./command-poller');
 const { UpdateChecker, getLocalVersion } = require('./updater');
 const { checkAndUpdateExtension } = require('./extension-updater');
+const { CacheServer } = require('./cache-server');
 
 class Daemon {
   constructor(config) {
@@ -11,6 +12,9 @@ class Daemon {
     this.api = new ApiClient(config.api_url, config.worker_token);
     this.heartbeat = new Heartbeat(this.api, config.worker_id, 30000, config);
     this.poller = new JobPoller(this.api, config);
+    this.cacheServer = new CacheServer(this.api, { port: config.cache_port || 8849 });
+    // Pass daemon URL down so command-poller can write it into per-profile config
+    config.daemon_url = this.cacheServer.url();
     this.commandPoller = new CommandPoller(this.api, config);
     this.updateChecker = new UpdateChecker(5 * 60 * 1000); // check every 5min
     this.extCheckTimer = null;
@@ -28,6 +32,13 @@ class Daemon {
 ╚══════════════════════════════════════╝
 `);
 
+    // Start local cache server (extension shares this across all profiles)
+    try {
+      await this.cacheServer.start();
+    } catch (err) {
+      console.warn(`[daemon] Cache server failed to start (port in use?): ${err.message}`);
+    }
+
     // Register with dashboard
     try {
       await this.api.register({
@@ -98,6 +109,7 @@ class Daemon {
       this.commandPoller.stop();
       this.updateChecker.stop();
       if (this.extCheckTimer) clearInterval(this.extCheckTimer);
+      try { this.cacheServer.stop(); } catch {}
 
       // Mark offline
       try {

package/package.json

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