channel-worker 1.1.2 → 1.1.4

package/lib/command-poller.js

@@ -58,6 +58,9 @@ class CommandPoller {
         case 'set_file_input':
           await this.handleSetFileInput(command);
           break;
+        case 'click_and_upload':
+          await this.handleClickAndUpload(command);
+          break;
         case 'type_text':
           await this.handleTypeText(command);
           break;
@@ -550,6 +553,138 @@ class CommandPoller {
     }
   }
 
+  async handleClickAndUpload(command) {
+    const { profile_id, file_path, click_selector, click_fallback_text, url_match } = command.payload || {};
+    console.log(`[commands] Click and upload: ${click_selector} → ${file_path}`);
+    try {
+      const WebSocket = require('ws');
+      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 browser = ((await browsersRes.json())?.data || []).find(b => b.name === profile_id) || (await (await fetch('http://localhost:8848/api/v2/browsers', { headers: { 'x-api-key': this.nst?.apiKey || '' } })).json())?.data?.[0];
+      if (!browser) throw new Error('No running browser');
+
+      const pagesRes = await fetch(`http://localhost:${browser.remoteDebuggingPort}/json/list`);
+      const pages = await pagesRes.json();
+      const targetPage = pages.find(p => p.type === 'page' && (!url_match || p.url?.includes(url_match)));
+      if (!targetPage) throw new Error(`No tab matching ${url_match}`);
+
+      const result = await new Promise((resolve, reject) => {
+        const ws = new WebSocket(targetPage.webSocketDebuggerUrl);
+        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); msg.error ? rej(new Error(msg.error.message)) : res(msg.result); }
+            };
+            ws.on('message', handler);
+            ws.send(JSON.stringify({ id, method, params }));
+          });
+        }
+
+        ws.on('open', async () => {
+          try {
+            await send('Page.enable');
+            await send('DOM.enable');
+
+            // Enable file chooser interception
+            await send('Page.setInterceptFileChooserDialog', { enabled: true });
+
+            // Listen for file chooser
+            const chooserPromise = new Promise((res) => {
+              const handler = (data) => {
+                const msg = JSON.parse(data);
+                if (msg.method === 'Page.fileChooserOpened') {
+                  ws.removeListener('message', handler);
+                  res('opened');
+                }
+              };
+              ws.on('message', handler);
+              setTimeout(() => { ws.removeListener('message', handler); res('timeout'); }, 10000);
+            });
+
+            // Find element position and click via mouse
+            const rawSel = (click_selector || '');
+            const isXpath = rawSel.startsWith('xpath:');
+            const sel = rawSel.replace('xpath:', '').replace(/'/g, "\\'").replace(/"/g, '\\"');
+
+            const posResult = await send('Runtime.evaluate', {
+              expression: `
+                (function() {
+                  let el = null;
+                  if (${isXpath} && "${sel}") {
+                    el = document.evaluate("${sel}", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                  } else if ("${sel}") {
+                    el = document.querySelector("${sel}");
+                  }
+                  if (!el && "${click_fallback_text || ''}") {
+                    const allEls = document.querySelectorAll('[role="button"], button');
+                    for (const btn of allEls) {
+                      if (btn.textContent?.trim()?.toLowerCase() === "${(click_fallback_text || '').toLowerCase()}") { el = btn; break; }
+                    }
+                  }
+                  if (!el) return null;
+                  const rect = el.getBoundingClientRect();
+                  return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+                })()
+              `,
+              returnByValue: true,
+            });
+
+            const pos = posResult?.result?.value;
+            if (!pos) { ws.close(); resolve({ success: false, error: 'Element not found' }); return; }
+
+            // Click with mouse
+            await send('Input.dispatchMouseEvent', { type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1 });
+            await send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1 });
+            console.log(`[commands] Mouse clicked Upload at (${pos.x}, ${pos.y})`);
+
+            // Wait for file chooser
+            const chooserResult = await chooserPromise;
+            console.log(`[commands] File chooser: ${chooserResult}`);
+
+            if (chooserResult === 'opened') {
+              // File chooser intercepted — now set file via DOM.setFileInputFiles
+              // Find the file input that triggered the chooser
+              const doc = await send('DOM.getDocument');
+              const fileNode = await send('DOM.querySelector', { nodeId: doc.root.nodeId, selector: 'input[type="file"][accept*="image"]' });
+              if (!fileNode?.nodeId) {
+                // Fallback: any file input
+                const fallbackNode = await send('DOM.querySelector', { nodeId: doc.root.nodeId, selector: 'input[type="file"]' });
+                if (fallbackNode?.nodeId) {
+                  await send('DOM.setFileInputFiles', { nodeId: fallbackNode.nodeId, files: [file_path] });
+                }
+              } else {
+                await send('DOM.setFileInputFiles', { nodeId: fileNode.nodeId, files: [file_path] });
+              }
+              await send('Page.setInterceptFileChooserDialog', { enabled: false });
+              ws.close();
+              resolve({ success: true, method: 'file_chooser_intercepted' });
+            } else {
+              await send('Page.setInterceptFileChooserDialog', { enabled: false });
+              ws.close();
+              resolve({ success: false, error: 'File chooser timeout' });
+            }
+          } catch (e) { ws.close(); resolve({ success: false, error: e.message }); }
+        });
+        ws.on('error', (e) => reject(e));
+        setTimeout(() => { ws.close(); reject(new Error('CDP timeout')); }, 20000);
+      });
+
+      console.log(`[commands] Click and upload result:`, result);
+      await this.api.updateCommand(command._id, { status: result.success ? 'done' : 'failed', result, error: result.error || null });
+    } catch (err) {
+      console.error(`[commands] Click and upload failed: ${err.message}`);
+      await this.api.updateCommand(command._id, { status: 'failed', error: err.message });
+    }
+  }
+
   async handleTypeText(command) {
     const { text, profile_id, url_match, focus_selector, press_enter } = command.payload || {};
     console.log(`[commands] Typing text (${text?.length} chars) for profile: ${profile_id}`);

package/package.json

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