channel-worker 1.0.17 → 1.0.19

package/lib/command-poller.js

@@ -49,6 +49,9 @@ class CommandPoller {
         case 'save_file':
           await this.handleSaveFile(command);
           break;
+        case 'set_thumbnail':
+          await this.handleSetThumbnail(command);
+          break;
         default:
           // Other commands (scan_facebook_pages, etc.) handled by extension
           console.log(`[commands] Skipping ${command.type} — handled by extension`);
@@ -88,32 +91,41 @@ class CommandPoller {
       const baseExtPath = this.config.extension_path || '';
       let extensionPath = baseExtPath;
 
-      // Create per-profile extension dir with config.json containing profileId
+      // Create unique extension dir each launch → prevents Chromium bytecode cache
       if (baseExtPath && profile_id) {
         const fs = require('fs');
         const path = require('path');
-        const profileExtPath = baseExtPath + '-' + profile_id;
+        const ts = Date.now();
+        const uniqueExtPath = baseExtPath + '-' + profile_id + '-' + ts;
         try {
-          // Copy extension files to per-profile dir (if not exists or outdated)
-          if (!fs.existsSync(profileExtPath)) fs.mkdirSync(profileExtPath, { recursive: true });
+          fs.mkdirSync(uniqueExtPath, { recursive: true });
           const files = fs.readdirSync(baseExtPath);
           for (const f of files) {
             const src = path.join(baseExtPath, f);
-            const dst = path.join(profileExtPath, f);
-            if (fs.statSync(src).isFile()) {
-              // Copy if newer
-              const srcMtime = fs.statSync(src).mtimeMs;
-              const dstMtime = fs.existsSync(dst) ? fs.statSync(dst).mtimeMs : 0;
-              if (srcMtime > dstMtime) fs.copyFileSync(src, dst);
-            }
+            if (fs.statSync(src).isFile()) fs.copyFileSync(src, path.join(uniqueExtPath, f));
           }
           // Write profile-specific config.json
-          const config = { channelManagerApi: 'https://api.channel.tunasm.art', profileId: profile_id };
-          fs.writeFileSync(path.join(profileExtPath, 'config.json'), JSON.stringify(config));
-          extensionPath = profileExtPath;
-          console.log(`[commands] Extension dir: ${profileExtPath} (profile: ${profile_id})`);
+          fs.writeFileSync(path.join(uniqueExtPath, 'config.json'), JSON.stringify({
+            channelManagerApi: 'https://api.channel.tunasm.art',
+            profileId: profile_id,
+          }));
+          extensionPath = uniqueExtPath;
+          console.log(`[commands] Extension dir: ${uniqueExtPath}`);
+
+          // Cleanup old dirs (keep last 3)
+          const parent = path.dirname(baseExtPath);
+          const baseName = path.basename(baseExtPath);
+          const oldDirs = fs.readdirSync(parent)
+            .filter(d => d.startsWith(baseName + '-') && d !== path.basename(uniqueExtPath))
+            .map(d => path.join(parent, d))
+            .filter(d => fs.statSync(d).isDirectory())
+            .sort()
+            .slice(0, -3);
+          for (const d of oldDirs) {
+            try { fs.rmSync(d, { recursive: true }); } catch {}
+          }
         } catch (e) {
-          console.warn(`[commands] Per-profile ext dir failed: ${e.message}, using base`);
+          console.warn(`[commands] Unique ext dir failed: ${e.message}, using base`);
         }
       }
 
@@ -203,6 +215,125 @@ class CommandPoller {
     }
   }
 
+  async handleSetThumbnail(command) {
+    const { thumbnail_url, profile_id, file_path } = command.payload || {};
+    console.log(`[commands] Setting thumbnail for profile: ${profile_id}`);
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const WebSocket = require('ws');
+
+      // 1. Download thumbnail to disk
+      const dir = path.dirname(file_path);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      const res = await fetch(thumbnail_url);
+      if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+      const buffer = Buffer.from(await res.arrayBuffer());
+      fs.writeFileSync(file_path, buffer);
+      console.log(`[commands] Thumbnail saved: ${file_path} (${buffer.length} bytes)`);
+
+      // 2. Find running browser for this profile
+      if (!this.nst) {
+        const apiKey = await this.api.getSetting('nst_api_key');
+        if (apiKey) this.nst = new NstManager(apiKey);
+      }
+      const browsersRes = await fetch('http://localhost:8848/api/v2/browsers', {
+        headers: { 'x-api-key': this.nst?.apiKey || '' },
+      });
+      const browsersData = await browsersRes.json();
+      const browsers = browsersData?.data || [];
+      const browser = browsers.find(b => b.name === profile_id) || browsers[0];
+      if (!browser) throw new Error('No running browser found');
+
+      const debugPort = browser.remoteDebuggingPort;
+      console.log(`[commands] Browser debug port: ${debugPort}`);
+
+      // 3. Get WebSocket URL for YouTube Studio tab
+      const pagesRes = await fetch(`http://localhost:${debugPort}/json/list`);
+      const pages = await pagesRes.json();
+      const studioPage = pages.find(p => p.url?.includes('studio.youtube.com') && p.type === 'page');
+      if (!studioPage) throw new Error('YouTube Studio tab not found');
+
+      const wsUrl = studioPage.webSocketDebuggerUrl;
+      console.log(`[commands] Connecting CDP: ${wsUrl}`);
+
+      // 4. Use CDP to set thumbnail file
+      const result = await new Promise((resolve, reject) => {
+        const ws = new WebSocket(wsUrl);
+        let msgId = 1;
+
+        function send(method, params = {}) {
+          const id = msgId++;
+          return new Promise((res, rej) => {
+            const handler = (data) => {
+              const msg = JSON.parse(data);
+              if (msg.id === id) {
+                ws.removeListener('message', handler);
+                if (msg.error) rej(new Error(msg.error.message));
+                else res(msg.result);
+              }
+            };
+            ws.on('message', handler);
+            ws.send(JSON.stringify({ id, method, params }));
+          });
+        }
+
+        ws.on('open', async () => {
+          try {
+            await send('DOM.enable');
+            const doc = await send('DOM.getDocument');
+            const node = await send('DOM.querySelector', {
+              nodeId: doc.root.nodeId,
+              selector: '#file-loader',
+            });
+
+            if (!node?.nodeId) {
+              ws.close();
+              resolve({ success: false, error: '#file-loader not found' });
+              return;
+            }
+
+            await send('DOM.setFileInputFiles', {
+              nodeId: node.nodeId,
+              files: [file_path],
+            });
+
+            // Trigger change event
+            await send('Runtime.evaluate', {
+              expression: `
+                const inp = document.querySelector('#file-loader');
+                if (inp) {
+                  inp.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+                  inp.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+                }
+                'triggered'
+              `,
+            });
+
+            ws.close();
+            resolve({ success: true, file_path });
+          } catch (e) {
+            ws.close();
+            resolve({ success: false, error: e.message });
+          }
+        });
+
+        ws.on('error', (e) => reject(e));
+        setTimeout(() => { ws.close(); reject(new Error('CDP timeout')); }, 15000);
+      });
+
+      console.log(`[commands] Thumbnail CDP result:`, result);
+      await this.api.updateCommand(command._id, {
+        status: result.success ? 'done' : 'failed',
+        result,
+        error: result.error || null,
+      });
+    } catch (err) {
+      console.error(`[commands] Set thumbnail failed: ${err.message}`);
+      await this.api.updateCommand(command._id, { status: 'failed', error: err.message });
+    }
+  }
+
   async handleCloseProfile(command) {
     const { profile_id } = command.payload || {};
     console.log(`[commands] Closing profile: ${profile_id}`);

package/package.json

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