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

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

@@ -12,6 +12,20 @@ exports.nvkBrowserApiDescription = {
     defaults: {
         name: 'NVK Browser Call API',
     },
+    codex: {
+        categories: ['Development'],
+        subcategories: {
+            Development: ['Browser Automation'],
+        },
+        resources: {
+            primaryDocumentation: [
+                {
+                    url: 'https://your-docs-url.com',
+                },
+            ],
+        },
+        alias: ['Run Multiple Profiles', 'requests', 'HTTP', 'HTTP requests', 'Make HTTP requests using Browser', 'HTTP requests using Browser', 'Get Network Response', 'Move And Click', 'Download Browser', 'Update Profile', 'Stop Profile', 'Delete Profile', 'Create profile', 'recaptcha', 'captcha', 'token', 'get recaptcha token', 'recaptcha solver', 'browser', 'automation', 'puppeteer'],
+    },
     inputs: ['main'],
     outputs: ['main'],
     credentials: [],
@@ -65,6 +79,10 @@ exports.nvkBrowserApiDescription = {
                     name: 'Page Interaction',
                     value: 'pageInteraction',
                 },
+                {
+                    name: 'Browser Automation',
+                    value: 'browserAutomation',
+                },
             ],
             default: 'profileManagement',
         },
@@ -143,9 +161,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 +571,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 +585,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: '',
-            description: 'Updated notes',
+            description: 'New note',
         },
         {
             displayName: 'Extensions',
@@ -426,7 +601,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: '',
-            description: 'Updated extensions',
+            description: 'New extensions (one per line)',
         },
         // Move and Click Fields
         {
@@ -444,12 +619,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 +630,7 @@ exports.nvkBrowserApiDescription = {
             },
             default: '',
             required: true,
-            description: 'CSS selector or Puppeteer locator code',
+            description: 'CSS selector for the element',
         },
         {
             displayName: 'Click Method',
@@ -472,19 +644,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 +666,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: 30000,
-            description: 'Maximum wait time',
+            description: 'Timeout in milliseconds',
         },
         {
             displayName: 'Tab Index',
@@ -523,7 +695,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 +705,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 +761,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 +773,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 +849,7 @@ exports.nvkBrowserApiDescription = {
             description: 'ID of the profile',
         },
         {
-            displayName: 'Request Name or URL',
+            displayName: 'Request Filter',
             name: 'requestFilter',
             type: 'string',
             displayOptions: {
@@ -709,24 +881,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 +900,7 @@ exports.nvkBrowserApiDescription = {
                 },
             },
             default: 30000,
-            description: 'Timeout for waiting',
+            description: 'Timeout in milliseconds',
         },
         {
             displayName: 'Wait For Request',
@@ -880,6 +1044,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.8",
   "description": "n8n node for NVK Browser automation API",
   "keywords": [
     "n8n-community-node-package",