n8n-nodes-nvk-call-api 0.0.6 → 0.0.7

package/dist/nodes/NvkBrowserApi/NvkBrowserApi.description.js

@@ -65,6 +65,10 @@ exports.nvkBrowserApiDescription = {
                     name: 'Page Interaction',
                     value: 'pageInteraction',
                 },
+                {
+                    name: 'Browser Automation',
+                    value: 'browserAutomation',
+                },
             ],
             default: 'profileManagement',
         },
@@ -143,9 +147,166 @@ exports.nvkBrowserApiDescription = {
                     value: 'browserHttpRequest',
                     action: 'Make HTTP requests using Browser',
                 },
+                {
+                    name: 'Get Recaptcha Token',
+                    value: 'getRecaptchaToken',
+                    action: 'Get Recaptcha Token',
+                },
             ],
             default: 'moveAndClick',
         },
+        {
+            displayName: 'Operation',
+            name: 'operation',
+            type: 'options',
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                },
+            },
+            options: [
+                {
+                    name: 'Run Multiple Profiles',
+                    value: 'runMultipleProfiles',
+                    action: 'Run Multiple Profiles',
+                },
+            ],
+            default: 'runMultipleProfiles',
+        },
+        // Run Multiple Profiles Fields
+        {
+            displayName: 'Data',
+            name: 'data',
+            type: 'string',
+            typeOptions: {
+                rows: 10,
+            },
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: '',
+            required: true,
+            description: 'Enter data in format: line|profileId (one per line)',
+            placeholder: '1|212e2d01-0c8a-4373-9c9f-9153354de0a4\n2|212e2d01-0c8a-4373-9c9f-9153354de0a4',
+        },
+        {
+            displayName: 'Number of Threads',
+            name: 'numberOfThreads',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: 1,
+            description: 'Number of parallel threads to run',
+        },
+        {
+            displayName: 'Define Columns',
+            name: 'defineColumns',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: 3,
+            description: 'Number of columns in grid layout',
+        },
+        {
+            displayName: 'Define Rows',
+            name: 'defineRows',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: 2,
+            description: 'Number of rows in grid layout',
+        },
+        {
+            displayName: 'Win Scale',
+            name: 'winScale',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: 100,
+            description: 'Window scale percentage (100 = 100%)',
+        },
+        {
+            displayName: 'Webhook URL',
+            name: 'webhookUrl',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: '',
+            description: 'Webhook URL to send results to (optional)',
+        },
+        {
+            displayName: 'Webhook Method',
+            name: 'webhookMethod',
+            type: 'options',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            options: [
+                {
+                    name: 'GET',
+                    value: 'GET',
+                },
+                {
+                    name: 'POST',
+                    value: 'POST',
+                },
+            ],
+            default: 'POST',
+            description: 'HTTP method to use for webhook call',
+        },
+        {
+            displayName: 'Timeout (Milliseconds)',
+            name: 'timeout',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: 100000000,
+            description: 'Maximum timeout in milliseconds',
+        },
+        {
+            displayName: 'Wait For The Previous Session To Complete',
+            name: 'waitForPrevious',
+            type: 'boolean',
+            displayOptions: {
+                show: {
+                    resource: ['browserAutomation'],
+                    operation: ['runMultipleProfiles'],
+                },
+            },
+            default: true,
+            description: 'Whether to wait for previous session to complete before starting next',
+        },
         // Create Profile Fields
         {
             displayName: 'Profile Name',
@@ -396,7 +557,7 @@ exports.nvkBrowserApiDescription = {
                     operation: ['updateProfile'],
                 },
             },
-            default: 'http:127.0.0.1:8080:user:pass hoặc socks5:127.0.0.1:1080:user:pass',
+            default: '',
             description: 'New proxy configuration',
         },
         {
@@ -410,7 +571,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: '',
-            description: 'Updated notes',
+            description: 'New note',
         },
         {
             displayName: 'Extensions',
@@ -426,7 +587,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: '',
-            description: 'Updated extensions',
+            description: 'New extensions (one per line)',
         },
         // Move and Click Fields
         {
@@ -444,12 +605,9 @@ exports.nvkBrowserApiDescription = {
             description: 'ID of the profile',
         },
         {
-            displayName: 'Selector or Puppeteer Locator Code',
+            displayName: 'Selector',
             name: 'selector',
             type: 'string',
-            typeOptions: {
-                rows: 4,
-            },
             displayOptions: {
                 show: {
                     resource: ['pageInteraction'],
@@ -458,7 +616,7 @@ exports.nvkBrowserApiDescription = {
             },
             default: '',
             required: true,
-            description: 'CSS selector or Puppeteer locator code',
+            description: 'CSS selector for the element',
         },
         {
             displayName: 'Click Method',
@@ -472,19 +630,19 @@ exports.nvkBrowserApiDescription = {
             },
             options: [
                 {
-                    name: 'Puppeteer Locator',
+                    name: 'Puppeteer',
                     value: 'puppeteer',
                 },
                 {
-                    name: 'Standard',
-                    value: 'standard',
+                    name: 'Coordinates',
+                    value: 'coordinates',
                 },
             ],
             default: 'puppeteer',
-            description: 'Method for clicking',
+            description: 'Method to use for clicking',
         },
         {
-            displayName: 'Timeout (Milliseconds)',
+            displayName: 'Timeout',
             name: 'timeout',
             type: 'number',
             displayOptions: {
@@ -494,7 +652,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: 30000,
-            description: 'Maximum wait time',
+            description: 'Timeout in milliseconds',
         },
         {
             displayName: 'Tab Index',
@@ -523,7 +681,7 @@ exports.nvkBrowserApiDescription = {
             description: 'Whether to auto-start profile if not running',
         },
         {
-            displayName: 'Wait Before Click (Milliseconds)',
+            displayName: 'Wait For Click',
             name: 'waitForClick',
             type: 'number',
             displayOptions: {
@@ -533,10 +691,10 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: 500,
-            description: 'Delay before clicking',
+            description: 'Wait time before click in milliseconds',
         },
         {
-            displayName: 'Mouse Button',
+            displayName: 'Button',
             name: 'button',
             type: 'options',
             displayOptions: {
@@ -589,7 +747,7 @@ exports.nvkBrowserApiDescription = {
             description: 'Whether to upload a binary file',
         },
         {
-            displayName: 'Binary Property',
+            displayName: 'Input Data Field Name',
             name: 'binaryPropertyName',
             type: 'string',
             displayOptions: {
@@ -601,7 +759,7 @@ exports.nvkBrowserApiDescription = {
             },
             default: 'data',
             required: true,
-            description: 'Name of the binary property containing the file',
+            description: 'Name of the binary property',
         },
         // Run JavaScript Fields
         {
@@ -677,7 +835,7 @@ exports.nvkBrowserApiDescription = {
             description: 'ID of the profile',
         },
         {
-            displayName: 'Request Name or URL',
+            displayName: 'Request Filter',
             name: 'requestFilter',
             type: 'string',
             displayOptions: {
@@ -709,24 +867,16 @@ exports.nvkBrowserApiDescription = {
                     name: 'Exact',
                     value: 'exact',
                 },
-                {
-                    name: 'Starts With',
-                    value: 'startsWith',
-                },
-                {
-                    name: 'Ends With',
-                    value: 'endsWith',
-                },
                 {
                     name: 'Regex',
                     value: 'regex',
                 },
             ],
             default: 'contains',
-            description: 'How to match the request filter',
+            description: 'Type of matching to use',
         },
         {
-            displayName: 'Timeout (Milliseconds)',
+            displayName: 'Timeout',
             name: 'timeout',
             type: 'number',
             displayOptions: {
@@ -736,7 +886,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: 30000,
-            description: 'Timeout for waiting',
+            description: 'Timeout in milliseconds',
         },
         {
             displayName: 'Wait For Request',
@@ -880,6 +1030,99 @@ exports.nvkBrowserApiDescription = {
             default: 'formData',
             description: 'Type of body content',
         },
+        // Get Recaptcha Token Fields
+        {
+            displayName: 'Profile ID',
+            name: 'profileId',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: '',
+            required: true,
+            description: 'ID of the profile',
+        },
+        {
+            displayName: 'Site Key',
+            name: 'siteKey',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: '',
+            description: 'reCAPTCHA site key (auto-detect if empty)',
+        },
+        {
+            displayName: 'Tab Index',
+            name: 'tabIndex',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: 0,
+            description: 'Browser tab index',
+        },
+        {
+            displayName: 'Timeout',
+            name: 'timeout',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: 10000,
+            description: 'Timeout in milliseconds',
+        },
+        {
+            displayName: 'Action',
+            name: 'action',
+            type: 'string',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: 'FLOW_GENERATION',
+            description: 'reCAPTCHA action parameter',
+        },
+        {
+            displayName: 'Max Retries',
+            name: 'maxRetries',
+            type: 'number',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: 3,
+            description: 'Maximum number of retry attempts',
+        },
+        {
+            displayName: 'Auto Start Profile',
+            name: 'autoStart',
+            type: 'boolean',
+            displayOptions: {
+                show: {
+                    resource: ['pageInteraction'],
+                    operation: ['getRecaptchaToken'],
+                },
+            },
+            default: false,
+            description: 'Whether to auto-start profile if not running',
+        },
         // n8n Binary File - Input Data Field Name
         {
             displayName: 'Input Data Field Name',

package/dist/nodes/NvkBrowserApi/NvkBrowserApi.node.js

@@ -14,6 +14,16 @@ class NvkBrowserApi {
                 const environment = this.getNodeParameter('environment', i);
                 const resource = this.getNodeParameter('resource', i);
                 const operation = this.getNodeParameter('operation', i);
+                // Handle Run Multiple Profiles - No API call, process locally in n8n
+                if (resource === 'browserAutomation' && operation === 'runMultipleProfiles') {
+                    const result = await runMultipleProfiles.call(this, i);
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                // All other operations - Call API as before
                 let baseUrl;
                 if (environment === 'docker') {
                     baseUrl = 'http://host.docker.internal:3000';
@@ -151,6 +161,23 @@ class NvkBrowserApi {
                             };
                             break;
                         }
+                        case 'getRecaptchaToken': {
+                            endpoint = '/api/recaptcha/get-token';
+                            body = {
+                                profileId: this.getNodeParameter('profileId', i),
+                                tabIndex: this.getNodeParameter('tabIndex', i, 0),
+                                timeout: this.getNodeParameter('timeout', i, 10000),
+                                action: this.getNodeParameter('action', i, 'FLOW_GENERATION'),
+                                maxRetries: this.getNodeParameter('maxRetries', i, 3),
+                                autoStart: this.getNodeParameter('autoStart', i, false),
+                            };
+                            // Site key là optional
+                            const siteKey = this.getNodeParameter('siteKey', i, '');
+                            if (siteKey && siteKey.trim() !== '') {
+                                body.siteKey = siteKey.trim();
+                            }
+                            break;
+                        }
                         case 'browserHttpRequest': {
                             endpoint = '/api/browser/request';
                             const method = this.getNodeParameter('method', i, 'GET');
@@ -313,3 +340,227 @@ class NvkBrowserApi {
     }
 }
 exports.NvkBrowserApi = NvkBrowserApi;
+/**
+ * Run Multiple Profiles - Process locally in n8n without API call
+ */
+async function runMultipleProfiles(itemIndex) {
+    // Get parameters
+    const data = this.getNodeParameter('data', itemIndex, '');
+    const numberOfThreads = this.getNodeParameter('numberOfThreads', itemIndex, 1);
+    const defineColumns = this.getNodeParameter('defineColumns', itemIndex, 3);
+    const defineRows = this.getNodeParameter('defineRows', itemIndex, 2);
+    const winScale = this.getNodeParameter('winScale', itemIndex, 100);
+    const webhookUrl = this.getNodeParameter('webhookUrl', itemIndex, '');
+    const webhookMethod = this.getNodeParameter('webhookMethod', itemIndex, 'POST');
+    const timeout = this.getNodeParameter('timeout', itemIndex, 100000000);
+    const waitForPrevious = this.getNodeParameter('waitForPrevious', itemIndex, true);
+    // Parse data into lines
+    const lines = data.trim().split('\n').filter((line) => line.trim() !== '');
+    const totalLines = lines.length;
+    // Calculate window size and position for grid layout
+    const screenWidth = 1920; // Default screen width
+    const screenHeight = 1080; // Default screen height
+    const windowWidth = Math.floor((screenWidth / defineColumns) * (winScale / 100));
+    const windowHeight = Math.floor((screenHeight / defineRows) * (winScale / 100));
+    // Prepare tasks
+    const tasks = lines.map((line, index) => {
+        const parts = line.split('|').map((p) => p.trim());
+        // Calculate grid position
+        const row = Math.floor(index / defineColumns);
+        const col = index % defineColumns;
+        const x = col * windowWidth;
+        const y = row * windowHeight;
+        return {
+            line,
+            parts,
+            threadId: index,
+            winPosition: `${x},${y}`,
+            winSize: `${windowWidth},${windowHeight}`,
+        };
+    });
+    const results = [];
+    let completedLines = 0;
+    // Helper function to send individual result to webhook
+    const sendToWebhook = async (result, index, total) => {
+        if (!webhookUrl || webhookUrl.trim() === '') {
+            return;
+        }
+        const cleanWebhookUrl = webhookUrl.trim();
+        try {
+            const payload = {
+                ...result,
+                index: index + 1,
+                total,
+                timestamp: new Date().toISOString(),
+            };
+            console.log(`Sending result ${index + 1}/${total} to webhook (${webhookMethod}):`, cleanWebhookUrl);
+            if (webhookMethod === 'GET') {
+                // For GET, send each field as separate query parameter
+                const params = new URLSearchParams();
+                // Add basic fields
+                params.append('line', result.line);
+                params.append('threadId', String(result.threadId));
+                params.append('winPosition', result.winPosition);
+                params.append('winSize', result.winSize);
+                params.append('winScale', String(winScale)); // Add winScale from main params
+                params.append('success', String(result.success));
+                params.append('index', String(index + 1));
+                params.append('total', String(total));
+                params.append('timestamp', new Date().toISOString());
+                // Add response as JSON string (if exists)
+                if (result.response) {
+                    params.append('response', JSON.stringify(result.response));
+                }
+                // Add error if exists
+                if (result.error) {
+                    params.append('error', result.error);
+                }
+                const urlWithParams = `${cleanWebhookUrl}?${params.toString()}`;
+                await this.helpers.request({
+                    method: 'GET',
+                    url: urlWithParams,
+                    json: true,
+                    headers: {
+                        'User-Agent': 'n8n-nvk-browser-api',
+                    },
+                    timeout: 30000,
+                    resolveWithFullResponse: false,
+                });
+            }
+            else {
+                // For POST, send full payload in body
+                await this.helpers.request({
+                    method: 'POST',
+                    url: cleanWebhookUrl,
+                    body: payload,
+                    json: true,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'User-Agent': 'n8n-nvk-browser-api',
+                    },
+                    timeout: 30000,
+                    resolveWithFullResponse: false,
+                });
+            }
+            console.log(`✓ Result ${index + 1}/${total} sent successfully`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`✗ Failed to send result ${index + 1}/${total}:`, errorMessage);
+        }
+    };
+    // Process tasks
+    if (waitForPrevious) {
+        // Sequential processing - wait for each to complete
+        for (let taskIndex = 0; taskIndex < tasks.length; taskIndex++) {
+            const task = tasks[taskIndex];
+            try {
+                const result = await processProfileTask(task);
+                results.push(result);
+                completedLines++;
+                // Send to webhook immediately after processing
+                await sendToWebhook(result, taskIndex, tasks.length);
+            }
+            catch (error) {
+                const errorResult = {
+                    line: task.line,
+                    threadId: task.threadId,
+                    winPosition: task.winPosition,
+                    winSize: task.winSize,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                results.push(errorResult);
+                completedLines++;
+                // Send error result to webhook too
+                await sendToWebhook(errorResult, taskIndex, tasks.length);
+            }
+        }
+    }
+    else {
+        // Parallel processing with thread limit
+        const processInBatches = async (tasks, batchSize) => {
+            for (let i = 0; i < tasks.length; i += batchSize) {
+                const batch = tasks.slice(i, i + batchSize);
+                const batchPromises = batch.map(async (task, batchIndex) => {
+                    const taskIndex = i + batchIndex;
+                    try {
+                        const result = await processProfileTask(task);
+                        results.push(result);
+                        completedLines++;
+                        // Send to webhook immediately after processing
+                        await sendToWebhook(result, taskIndex, tasks.length);
+                        return result;
+                    }
+                    catch (error) {
+                        const errorResult = {
+                            line: task.line,
+                            threadId: task.threadId,
+                            winPosition: task.winPosition,
+                            winSize: task.winSize,
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        };
+                        results.push(errorResult);
+                        completedLines++;
+                        // Send error result to webhook too
+                        await sendToWebhook(errorResult, taskIndex, tasks.length);
+                        return errorResult;
+                    }
+                });
+                await Promise.all(batchPromises);
+            }
+        };
+        await processInBatches(tasks, numberOfThreads);
+    }
+    // Prepare final response
+    const finalResponse = {
+        totalLines,
+        completedLines,
+        results,
+        timeout,
+        defineColumn: defineColumns,
+        defineRow: defineRows,
+        message: `All ${completedLines} threads completed with grid ${defineColumns}x${defineRows}, maximum timeout ${timeout}ms`,
+    };
+    // Add webhook summary if webhook was used
+    if (webhookUrl && webhookUrl.trim() !== '') {
+        finalResponse.webhookSummary = {
+            enabled: true,
+            url: webhookUrl.trim(),
+            method: webhookMethod,
+            totalSent: completedLines,
+            message: `Sent ${completedLines} individual results to webhook`,
+        };
+    }
+    else {
+        finalResponse.webhookSummary = {
+            enabled: false,
+            message: 'No webhook URL provided',
+        };
+    }
+    return finalResponse;
+}
+/**
+ * Process a single profile task
+ */
+async function processProfileTask(task) {
+    // Simulate processing - parse the data
+    const responseData = [];
+    // Parse each part from the line (separated by |)
+    task.parts.forEach((part, index) => {
+        const obj = {};
+        obj[`part${index + 1}`] = part;
+        responseData.push(obj);
+    });
+    // Simulate some delay (optional)
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return {
+        line: task.line,
+        threadId: task.threadId,
+        winPosition: task.winPosition,
+        winSize: task.winSize,
+        success: true,
+        response: responseData,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-nvk-call-api",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "n8n node for NVK Browser automation API",
   "keywords": [
     "n8n-community-node-package",