@pmtuan0206/n8n-nodes-netproxy-cur 0.1.0

package/README.md

@@ -0,0 +1,171 @@
+# n8n-nodes-netproxy
+
+An n8n community node for routing HTTP requests through residential proxies with automatic rotation and failover capabilities.
+
+## Features
+
+- **Multi-Format Proxy Support**: Automatically parses proxies in multiple formats:
+  - `socks5://user:pass@host:port`
+  - `http://user:pass@host:port`
+  - `https://user:pass@host:port`
+  - `host:port:user:pass` (defaults to HTTP)
+  - `host:port` (no auth, defaults to HTTP)
+
+- **Proxy Rotation Strategies**:
+  - **Random**: Pick a random proxy for each request
+  - **Round Robin**: Rotate proxies in order
+  - **Auto-Switch on Dead**: Automatically try next proxy if current one fails
+  - **Stop on Dead**: Stop execution if proxy fails
+
+- **Operations**:
+  - **Request**: Make HTTP requests through proxies (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+  - **Test Connection**: Test proxy connection and get external IP
+
+- **Resilience**:
+  - Automatic retry with failover
+  - Connection timeout handling
+  - Clear error messages for authentication failures
+
+## Installation
+
+### For n8n Cloud or Self-Hosted
+
+1. Install the package:
+   ```bash
+   npm install n8n-nodes-netproxy
+   ```
+
+2. Restart your n8n instance.
+
+### For Local Development
+
+1. Clone this repository:
+   ```bash
+   git clone <repository-url>
+   cd n8n-nodes-netproxy
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Build the node:
+   ```bash
+   npm run build
+   ```
+
+4. Link the package locally:
+   ```bash
+   npm link
+   ```
+
+5. In your n8n installation directory, link the package:
+   ```bash
+   npm link n8n-nodes-netproxy
+   ```
+
+6. Restart n8n to load the node.
+
+## Usage
+
+### Basic Setup
+
+1. Add the **NetProxy HTTP Request** node to your workflow.
+
+2. Choose your **Operation**:
+   - **Request**: For making HTTP requests through proxies
+   - **Test Connection**: For testing proxy connectivity
+
+3. Configure **Proxy Source**:
+   - **Manual Input (List)**: Paste proxies directly in the node
+   - **Credentials**: Use stored credentials (more secure)
+
+4. Select **Rotation Strategy** based on your needs.
+
+### Proxy Format Examples
+
+```
+socks5://user:pass@192.168.1.1:1080
+http://user:pass@192.168.1.1:8080
+https://user:pass@192.168.1.1:8443
+192.168.1.1:8080:user:pass
+192.168.1.1:8080
+```
+
+### Example Workflow: Web Scraping
+
+1. Add **NetProxy HTTP Request** node
+2. Set Operation to **Request**
+3. Set Method to **GET**
+4. Enter target URL
+5. Paste proxy list
+6. Set Rotation Strategy to **Random** or **Round Robin**
+
+### Example Workflow: Test Proxy
+
+1. Add **NetProxy HTTP Request** node
+2. Set Operation to **Test Connection**
+3. Paste proxy list
+4. Execute to see your external IP
+
+## Configuration
+
+### Request Operation
+
+- **URL**: The target URL for the HTTP request
+- **Method**: HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+- **Headers**: Custom HTTP headers (optional)
+- **Body**: Request body (JSON, Raw, or Form-Data)
+- **Timeout**: Request timeout in seconds (default: 10)
+
+### Rotation Strategies
+
+- **Random**: Best for distributing load across proxies
+- **Round Robin**: Best for sequential processing
+- **Auto-Switch on Dead**: Best for reliability when some proxies may be down
+- **Stop on Dead**: Best for strict validation requirements
+
+## Error Handling
+
+The node provides clear error messages for:
+
+- **407 Proxy Authentication Required**: Invalid proxy credentials
+- **Connection Timeout**: Proxy server not responding
+- **Connection Refused**: Proxy server is down
+- **Dead Proxy**: Proxy failed and failover attempted (if enabled)
+
+## Security
+
+- Proxy credentials are never logged in execution output
+- Use **Credentials** option for sensitive proxy lists
+- All inputs are sanitized (trimmed) before processing
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Linting
+
+```bash
+npm run lint
+```
+
+### Formatting
+
+```bash
+npm run format
+```
+
+## License
+
+MIT
+
+## Author
+
+netproxy.io
+

package/dist/credentials/NetProxyApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class NetProxyApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    description: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/NetProxyApi.credentials.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetProxyApi = void 0;
+class NetProxyApi {
+    constructor() {
+        this.name = 'netProxyApi';
+        this.displayName = 'NetProxy API';
+        this.description = 'Store proxy list securely for NetProxy node';
+        this.properties = [
+            {
+                displayName: 'Proxy List',
+                name: 'proxyList',
+                type: 'string',
+                typeOptions: {
+                    rows: 5,
+                },
+                default: '',
+                description: 'Paste proxies here (one per line). Formats: socks5://user:pass@host:port, http://user:pass@host:port, or host:port:user:pass',
+            },
+        ];
+    }
+}
+exports.NetProxyApi = NetProxyApi;

package/dist/nodes/NetProxy/NetProxy.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class NetProxy implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/NetProxy/NetProxy.node.js

@@ -0,0 +1,541 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetProxy = void 0;
+const axios_1 = __importStar(require("axios"));
+const hpagent_1 = require("hpagent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const utils_1 = require("./utils");
+// Standalone helper functions (moved outside class to avoid 'this' context issues)
+function selectProxy(proxies, strategy, staticData) {
+    if (proxies.length === 0) {
+        throw new Error('No proxies available');
+    }
+    if (strategy === 'random') {
+        return proxies[Math.floor(Math.random() * proxies.length)];
+    }
+    else if (strategy === 'roundRobin' || strategy === 'failover') {
+        const index = staticData.roundRobinIndex % proxies.length;
+        staticData.roundRobinIndex = (staticData.roundRobinIndex + 1) % proxies.length;
+        return proxies[index];
+    }
+    else {
+        // Default to first proxy
+        return proxies[0];
+    }
+}
+function createProxyAgent(proxy) {
+    const proxyUrl = proxy.auth
+        ? `${proxy.protocol}://${proxy.auth.username}:${proxy.auth.password}@${proxy.host}:${proxy.port}`
+        : `${proxy.protocol}://${proxy.host}:${proxy.port}`;
+    if (proxy.protocol === 'socks5') {
+        return new socks_proxy_agent_1.SocksProxyAgent(proxyUrl);
+    }
+    else if (proxy.protocol === 'https') {
+        return new hpagent_1.HttpsProxyAgent({
+            proxy: proxyUrl,
+        });
+    }
+    else {
+        // HTTP proxy
+        return new hpagent_1.HttpProxyAgent({
+            proxy: proxyUrl,
+        });
+    }
+}
+async function testConnection(proxies, rotationStrategy, staticData) {
+    const selectedProxy = selectProxy(proxies, rotationStrategy, staticData);
+    const agent = createProxyAgent(selectedProxy);
+    const testUrl = 'https://api.ipify.org?format=json';
+    try {
+        const response = await axios_1.default.get(testUrl, {
+            httpsAgent: agent,
+            httpAgent: agent,
+            timeout: 10000,
+        });
+        return {
+            success: true,
+            ip: response.data.ip,
+            proxy: `${selectedProxy.host}:${selectedProxy.port}`,
+            protocol: selectedProxy.protocol,
+        };
+    }
+    catch (error) {
+        if (rotationStrategy === 'failover' && proxies.length > 1) {
+            // Try next proxy
+            const nextProxy = selectProxy(proxies, 'roundRobin', staticData);
+            const nextAgent = createProxyAgent(nextProxy);
+            try {
+                const response = await axios_1.default.get(testUrl, {
+                    httpsAgent: nextAgent,
+                    httpAgent: nextAgent,
+                    timeout: 10000,
+                });
+                return {
+                    success: true,
+                    ip: response.data.ip,
+                    proxy: `${nextProxy.host}:${nextProxy.port}`,
+                    protocol: nextProxy.protocol,
+                    warning: `Original proxy failed, switched to backup`,
+                };
+            }
+            catch (retryError) {
+                throw new Error(`All proxies failed. Last error: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+            }
+        }
+        throw new Error(`Proxy test failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function makeRequest(executeFunctions, itemIndex, proxies, rotationStrategy, staticData) {
+    const url = executeFunctions.getNodeParameter('url', itemIndex);
+    const method = executeFunctions.getNodeParameter('method', itemIndex).toUpperCase();
+    const timeout = executeFunctions.getNodeParameter('timeout', itemIndex) * 1000 || 10000;
+    const sendHeaders = executeFunctions.getNodeParameter('sendHeaders', itemIndex, false);
+    const sendBody = executeFunctions.getNodeParameter('sendBody', itemIndex, false);
+    const config = {
+        method: method,
+        url,
+        timeout,
+    };
+    // Add headers
+    if (sendHeaders) {
+        const headerParameters = executeFunctions.getNodeParameter('headerParameters', itemIndex, {});
+        config.headers = {};
+        if (headerParameters.header && Array.isArray(headerParameters.header)) {
+            for (const header of headerParameters.header) {
+                config.headers[header.name] = header.value;
+            }
+        }
+    }
+    // Add body
+    if (sendBody) {
+        const bodyContentType = executeFunctions.getNodeParameter('bodyContentType', itemIndex);
+        const body = executeFunctions.getNodeParameter('body', itemIndex);
+        if (bodyContentType === 'json') {
+            try {
+                config.data = JSON.parse(body);
+                config.headers = config.headers || {};
+                config.headers['Content-Type'] = 'application/json';
+            }
+            catch (e) {
+                throw new Error('Invalid JSON in body');
+            }
+        }
+        else if (bodyContentType === 'raw') {
+            config.data = body;
+        }
+        else if (bodyContentType === 'formData') {
+            // Parse form data (simple key=value format)
+            const formData = {};
+            const pairs = body.split('&');
+            for (const pair of pairs) {
+                const [key, value] = pair.split('=');
+                if (key && value) {
+                    formData[decodeURIComponent(key)] = decodeURIComponent(value);
+                }
+            }
+            config.data = formData;
+        }
+    }
+    // Select proxy and create agent
+    let selectedProxy = selectProxy(proxies, rotationStrategy, staticData);
+    let agent = createProxyAgent(selectedProxy);
+    config.httpsAgent = agent;
+    config.httpAgent = agent;
+    // Make request with failover logic
+    const maxRetries = rotationStrategy === 'failover' ? proxies.length : 1;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const response = await (0, axios_1.default)(config);
+            return {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                data: response.data,
+                proxy: `${selectedProxy.host}:${selectedProxy.port}`,
+                protocol: selectedProxy.protocol,
+            };
+        }
+        catch (error) {
+            lastError = error;
+            // Handle specific error cases
+            if (error instanceof axios_1.AxiosError) {
+                if (error.response?.status === 407) {
+                    throw new Error(`Proxy authentication failed for ${selectedProxy.host}:${selectedProxy.port}. Please check credentials.`);
+                }
+                if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT') {
+                    if (rotationStrategy === 'failover' && attempt < maxRetries - 1) {
+                        // Try next proxy
+                        selectedProxy = selectProxy(proxies, 'roundRobin', staticData);
+                        agent = createProxyAgent(selectedProxy);
+                        config.httpsAgent = agent;
+                        config.httpAgent = agent;
+                        continue;
+                    }
+                    else if (rotationStrategy === 'stopOnDead') {
+                        throw new Error(`Proxy ${selectedProxy.host}:${selectedProxy.port} is dead. Stopping execution.`);
+                    }
+                }
+            }
+            // If not failover or last attempt, throw error
+            if (rotationStrategy !== 'failover' || attempt === maxRetries - 1) {
+                throw new Error(`Request failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    throw lastError || new Error('Request failed after all retries');
+}
+class NetProxy {
+    constructor() {
+        this.description = {
+            displayName: 'NetProxy HTTP Request',
+            name: 'netProxy',
+            icon: 'file:NetProxy.png',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Route HTTP requests through NetProxy.io residential proxies with auto-rotation',
+            defaults: {
+                name: 'NetProxy HTTP Request',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'netProxyApi',
+                    required: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Request',
+                            value: 'request',
+                            description: 'Make an HTTP request through proxy',
+                        },
+                        {
+                            name: 'Test Connection',
+                            value: 'testConnection',
+                            description: 'Test proxy connection and get external IP',
+                        },
+                    ],
+                    default: 'request',
+                },
+                {
+                    displayName: 'Proxy Source',
+                    name: 'proxySource',
+                    type: 'options',
+                    default: 'manual',
+                    options: [
+                        {
+                            name: 'Manual Input (List)',
+                            value: 'manual',
+                        },
+                        {
+                            name: 'Credentials',
+                            value: 'credentials',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Proxy List',
+                    name: 'proxyList',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            proxySource: ['manual'],
+                        },
+                    },
+                    description: 'Paste proxies here (one per line). Formats: socks5://user:pass@host:port, http://user:pass@host:port, or host:port:user:pass',
+                },
+                {
+                    displayName: 'Rotation Strategy',
+                    name: 'rotationStrategy',
+                    type: 'options',
+                    default: 'random',
+                    options: [
+                        {
+                            name: 'Random',
+                            value: 'random',
+                            description: 'Pick a random proxy for each request',
+                        },
+                        {
+                            name: 'Round Robin',
+                            value: 'roundRobin',
+                            description: 'Rotate proxies in order',
+                        },
+                        {
+                            name: 'Auto-Switch on Dead',
+                            value: 'failover',
+                            description: 'Try next proxy if current one fails',
+                        },
+                        {
+                            name: 'Stop on Dead',
+                            value: 'stopOnDead',
+                            description: 'Stop execution if proxy fails',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Request URL',
+                    name: 'url',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                        },
+                    },
+                    description: 'The URL to make the request to',
+                },
+                {
+                    displayName: 'Method',
+                    name: 'method',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'GET',
+                            value: 'GET',
+                        },
+                        {
+                            name: 'POST',
+                            value: 'POST',
+                        },
+                        {
+                            name: 'PUT',
+                            value: 'PUT',
+                        },
+                        {
+                            name: 'PATCH',
+                            value: 'PATCH',
+                        },
+                        {
+                            name: 'DELETE',
+                            value: 'DELETE',
+                        },
+                        {
+                            name: 'HEAD',
+                            value: 'HEAD',
+                        },
+                        {
+                            name: 'OPTIONS',
+                            value: 'OPTIONS',
+                        },
+                    ],
+                    default: 'GET',
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Send Headers',
+                    name: 'sendHeaders',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Header Parameters',
+                    name: 'headerParameters',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                            sendHeaders: [true],
+                        },
+                    },
+                    placeholder: 'Add Header',
+                    options: [
+                        {
+                            displayName: 'Header',
+                            name: 'header',
+                            values: [
+                                {
+                                    displayName: 'Name',
+                                    name: 'name',
+                                    type: 'string',
+                                    default: '',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Send Body',
+                    name: 'sendBody',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Body Content Type',
+                    name: 'bodyContentType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'JSON',
+                            value: 'json',
+                        },
+                        {
+                            name: 'Raw',
+                            value: 'raw',
+                        },
+                        {
+                            name: 'Form-Data',
+                            value: 'formData',
+                        },
+                    ],
+                    default: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                            sendBody: [true],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Body',
+                    name: 'body',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                            sendBody: [true],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Timeout (seconds)',
+                    name: 'timeout',
+                    type: 'number',
+                    default: 10,
+                    displayOptions: {
+                        show: {
+                            operation: ['request'],
+                        },
+                    },
+                    description: 'Request timeout in seconds',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        // Get proxy list
+        const proxySource = this.getNodeParameter('proxySource', 0);
+        let proxyListString = '';
+        if (proxySource === 'credentials') {
+            const credentials = await this.getCredentials('netProxyApi');
+            proxyListString = credentials?.proxyList || '';
+        }
+        else {
+            proxyListString = this.getNodeParameter('proxyList', 0) || '';
+        }
+        const parsedProxies = (0, utils_1.parseProxyList)(proxyListString);
+        if (parsedProxies.length === 0) {
+            throw new Error('No valid proxies found. Please provide at least one valid proxy.');
+        }
+        const rotationStrategy = this.getNodeParameter('rotationStrategy', 0);
+        // Get static data for round-robin tracking
+        const staticData = this.getWorkflowStaticData('global');
+        if (!staticData.roundRobinIndex) {
+            staticData.roundRobinIndex = 0;
+        }
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'testConnection') {
+                    const result = await testConnection(parsedProxies, rotationStrategy, staticData);
+                    returnData.push({
+                        json: result,
+                    });
+                }
+                else if (operation === 'request') {
+                    const result = await makeRequest(this, i, parsedProxies, rotationStrategy, staticData);
+                    returnData.push({
+                        json: result,
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                            success: false,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.NetProxy = NetProxy;

package/dist/nodes/NetProxy/NetProxy.png

@@ -0,0 +1 @@
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==

package/dist/nodes/NetProxy/utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Utility functions for parsing and validating proxy strings
+ */
+export interface ParsedProxy {
+    host: string;
+    port: number;
+    auth?: {
+        username: string;
+        password: string;
+    };
+    protocol: 'http' | 'https' | 'socks5';
+}
+/**
+ * Parses a proxy string in various formats into a standardized object
+ * Supported formats:
+ * 1. socks5://user:pass@host:port
+ * 2. http://user:pass@host:port
+ * 3. https://user:pass@host:port
+ * 4. host:port:user:pass (defaults to http)
+ * 5. host:port (no auth, defaults to http)
+ *
+ * @param proxyString - The proxy string to parse
+ * @returns ParsedProxy object or null if parsing fails
+ */
+export declare function parseProxyString(proxyString: string): ParsedProxy | null;
+/**
+ * Parses multiple proxy strings from a multiline string
+ * @param proxyListString - Multiline string containing proxy strings (one per line)
+ * @returns Array of ParsedProxy objects (invalid entries are filtered out)
+ */
+export declare function parseProxyList(proxyListString: string): ParsedProxy[];

package/dist/nodes/NetProxy/utils.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Utility functions for parsing and validating proxy strings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProxyString = parseProxyString;
+exports.parseProxyList = parseProxyList;
+/**
+ * Parses a proxy string in various formats into a standardized object
+ * Supported formats:
+ * 1. socks5://user:pass@host:port
+ * 2. http://user:pass@host:port
+ * 3. https://user:pass@host:port
+ * 4. host:port:user:pass (defaults to http)
+ * 5. host:port (no auth, defaults to http)
+ *
+ * @param proxyString - The proxy string to parse
+ * @returns ParsedProxy object or null if parsing fails
+ */
+function parseProxyString(proxyString) {
+    if (!proxyString || typeof proxyString !== 'string') {
+        return null;
+    }
+    // Trim whitespace
+    const trimmed = proxyString.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Format 1 & 2: Protocol-prefixed with auth (socks5://user:pass@host:port or http://user:pass@host:port)
+    const protocolWithAuthRegex = /^(socks5|http|https):\/\/(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$/;
+    const matchProtocolWithAuth = trimmed.match(protocolWithAuthRegex);
+    if (matchProtocolWithAuth) {
+        const [, protocol, username, password, host, port] = matchProtocolWithAuth;
+        const parsed = {
+            host: host.trim(),
+            port: parseInt(port, 10),
+            protocol: protocol === 'socks5' ? 'socks5' : protocol === 'https' ? 'https' : 'http',
+        };
+        if (username && password) {
+            parsed.auth = {
+                username: username.trim(),
+                password: password.trim(),
+            };
+        }
+        if (isValidProxy(parsed)) {
+            return parsed;
+        }
+    }
+    // Format 3: host:port:user:pass (no protocol, defaults to http)
+    const hostPortUserPassRegex = /^([^:]+):(\d+):([^:]+):(.+)$/;
+    const matchHostPortUserPass = trimmed.match(hostPortUserPassRegex);
+    if (matchHostPortUserPass) {
+        const [, host, port, username, password] = matchHostPortUserPass;
+        const parsed = {
+            host: host.trim(),
+            port: parseInt(port, 10),
+            protocol: 'http',
+            auth: {
+                username: username.trim(),
+                password: password.trim(),
+            },
+        };
+        if (isValidProxy(parsed)) {
+            return parsed;
+        }
+    }
+    // Format 4: host:port (no auth, no protocol, defaults to http)
+    const hostPortRegex = /^([^:]+):(\d+)$/;
+    const matchHostPort = trimmed.match(hostPortRegex);
+    if (matchHostPort) {
+        const [, host, port] = matchHostPort;
+        const parsed = {
+            host: host.trim(),
+            port: parseInt(port, 10),
+            protocol: 'http',
+        };
+        if (isValidProxy(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+/**
+ * Validates a parsed proxy object
+ * @param proxy - The parsed proxy object to validate
+ * @returns true if valid, false otherwise
+ */
+function isValidProxy(proxy) {
+    if (!proxy.host || !proxy.port) {
+        return false;
+    }
+    if (proxy.port < 1 || proxy.port > 65535) {
+        return false;
+    }
+    if (proxy.auth && (!proxy.auth.username || !proxy.auth.password)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Parses multiple proxy strings from a multiline string
+ * @param proxyListString - Multiline string containing proxy strings (one per line)
+ * @returns Array of ParsedProxy objects (invalid entries are filtered out)
+ */
+function parseProxyList(proxyListString) {
+    if (!proxyListString || typeof proxyListString !== 'string') {
+        return [];
+    }
+    const lines = proxyListString
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const parsedProxies = [];
+    for (const line of lines) {
+        const parsed = parseProxyString(line);
+        if (parsed) {
+            parsedProxies.push(parsed);
+        }
+    }
+    return parsedProxies;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pmtuan0206/n8n-nodes-netproxy-cur",
+  "version": "0.1.0",
+  "description": "Route HTTP requests through NetProxy.io residential proxies with auto-rotation and failover",
+  "keywords": [
+    "n8n-community-node",
+    "netproxy",
+    "proxy",
+    "socks5",
+    "http-proxy",
+    "proxy-rotation"
+  ],
+  "license": "MIT",
+  "homepage": "https://netproxy.io",
+  "author": {
+    "name": "netproxy.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json",
+    "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/NetProxy/NetProxy.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/NetProxyApi.credentials.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "eslint-plugin-n8n-nodes-base": "^1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^2.7.1",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "hpagent": "^1.2.0",
+    "n8n-nodes-base": "*",
+    "socks-proxy-agent": "^8.0.2"
+  }
+}
+