n8n-nodes-dhd-browser 1.0.0

package/README.md

@@ -0,0 +1,132 @@
+# n8n-nodes-dhd-browser
+
+n8n community node for creating and launching browser profiles with automatic proxy authentication.
+
+## Features
+
+- ✅ Create browser profiles with fingerprint configuration
+- ✅ Parse proxy strings or use separate proxy fields
+- ✅ Automatic proxy authentication injection (no manual login required)
+- ✅ Launch Chromium/Chrome with custom profiles
+- ✅ Support for fingerprinting (OS, Chrome version, User Agent, Timezone, etc.)
+- ✅ Modify Chrome Preferences automatically
+- ✅ Inject proxy authentication via Chrome DevTools Protocol
+
+## Installation
+
+```bash
+npm install n8n-nodes-dhd-browser
+```
+
+## How It Works
+
+This node implements the same approach used by professional browser automation tools:
+
+1. **Create Profile**: 
+   - Parses proxy configuration (from string or separate fields)
+   - Generates browser fingerprint
+   - Creates profile directory structure
+   - Modifies Chrome Preferences to set proxy server
+   - Saves profile configuration JSON
+
+2. **Launch Profile**:
+   - Loads profile configuration
+   - Launches Chromium with `--proxy-server` flag
+   - Connects via Chrome DevTools Protocol
+   - Injects `Proxy-Authorization` header automatically via `Network.setExtraHTTPHeaders()`
+   - Browser is ready to use without manual proxy login
+
+## Usage
+
+### Create Profile
+
+1. Set **Operation** to "Create Profile"
+2. Provide:
+   - **Profile Name**: Name for your profile
+   - **Profile Directory**: Base directory where profiles will be stored
+   - **Proxy Configuration**: Choose "Proxy String" or "Separate Fields"
+   - **Browser Fingerprint**: Configure OS, Chrome version, User Agent, etc.
+
+3. Output: Profile configuration path and details
+
+### Launch Profile
+
+1. Set **Operation** to "Launch Profile"
+2. Provide:
+   - **Profile Config Path**: Path to the `profile.config.json` file created by "Create Profile"
+   - **Chrome Executable Path**: Full path to Chrome/Chromium executable
+   - **Headless**: Whether to run in headless mode
+   - **Window Size**: Browser window size (e.g., "1920x1080")
+
+3. Output: Browser connection information (WebSocket endpoint, debug port)
+
+## Proxy Format
+
+### Proxy String Format
+```
+http://username:password@proxy.example.com:8080
+socks5://user:pass@192.168.1.1:1080
+```
+
+### Separate Fields
+- Proxy Type: http, https, socks4, socks5
+- Proxy Host: IP address or hostname
+- Proxy Port: Port number
+- Proxy Username: Authentication username
+- Proxy Password: Authentication password
+
+## Browser Fingerprint
+
+Configure fingerprint settings:
+- **OS**: Windows, macOS, Linux
+- **Chrome Version**: Chrome version to emulate (e.g., "120.0.0.0")
+- **User Agent**: Custom user agent (auto-generated if empty)
+- **Screen Resolution**: e.g., "1920x1080"
+- **Timezone**: e.g., "America/New_York", "Asia/Ho_Chi_Minh"
+- **Language**: Browser language, e.g., "en-US", "vi-VN"
+
+## Technical Details
+
+### Automatic Proxy Authentication
+
+The node uses Chrome DevTools Protocol to inject proxy authentication:
+
+1. Browser launches with `--proxy-server` flag
+2. Node connects to browser via DevTools Protocol (debug port)
+3. Enables Network domain: `Network.enable()`
+4. Sets extra HTTP headers: `Network.setExtraHTTPHeaders()` with `Proxy-Authorization: Basic base64(user:pass)`
+5. All requests automatically include authentication header
+
+This approach ensures:
+- ✅ No manual proxy login dialog
+- ✅ Authentication persists for entire browser session
+- ✅ Works with HTTP, HTTPS, SOCKS4, and SOCKS5 proxies
+
+### Chrome Preferences
+
+The node automatically modifies Chrome Preferences file to:
+- Set proxy server configuration
+- Store fingerprint settings
+- Configure default browser behavior
+
+## Requirements
+
+- Node.js >= 18
+- Chrome or Chromium browser installed
+- n8n >= 1.0.0
+
+## Dependencies
+
+- `puppeteer-core`: Browser automation
+- `chrome-remote-interface`: Chrome DevTools Protocol client
+- `fs-extra`: File system operations
+- `uuid`: Generate unique profile IDs
+
+## License
+
+MIT
+
+## Author
+
+DHD
+

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

@@ -0,0 +1,12 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class BrowserProfile implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    private createProfile;
+    private launchProfile;
+    private parseProxyString;
+    private generateFingerprint;
+    private modifyChromePreferences;
+    private injectProxyAuthentication;
+    private findAvailablePort;
+}

package/dist/nodes/BrowserProfile/BrowserProfile.node.js

@@ -0,0 +1,674 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserProfile = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const puppeteer = __importStar(require("puppeteer-core"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const uuid_1 = require("uuid");
+// @ts-expect-error - chrome-remote-interface doesn't have TypeScript definitions
+const chrome_remote_interface_1 = __importDefault(require("chrome-remote-interface"));
+class BrowserProfile {
+    constructor() {
+        this.description = {
+            displayName: 'Browser Profile',
+            name: 'browserProfile',
+            icon: 'file:browser.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Create and launch browser profile with automatic proxy authentication',
+            defaults: {
+                name: 'Browser Profile',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Create Profile',
+                            value: 'create',
+                            description: 'Create a new browser profile with fingerprint and proxy config',
+                            action: 'Create a new browser profile',
+                        },
+                        {
+                            name: 'Launch Profile',
+                            value: 'launch',
+                            description: 'Launch an existing browser profile with proxy authentication',
+                            action: 'Launch an existing browser profile',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // CREATE PROFILE OPTIONS
+                {
+                    displayName: 'Profile Name',
+                    name: 'profileName',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Name of the browser profile',
+                },
+                {
+                    displayName: 'Profile Directory',
+                    name: 'profileDir',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Directory path to store the profile (will be created if not exists)',
+                },
+                {
+                    displayName: 'Proxy Configuration',
+                    name: 'proxyConfig',
+                    type: 'options',
+                    default: 'string',
+                    options: [
+                        {
+                            name: 'Proxy String',
+                            value: 'string',
+                        },
+                        {
+                            name: 'Separate Fields',
+                            value: 'fields',
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'How to provide proxy configuration',
+                },
+                {
+                    displayName: 'Proxy String',
+                    name: 'proxyString',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'http://username:password@proxy.example.com:8080',
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['string'],
+                        },
+                    },
+                    description: 'Proxy string in format: type://user:pass@host:port',
+                },
+                {
+                    displayName: 'Proxy Type',
+                    name: 'proxyType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'HTTP',
+                            value: 'http',
+                        },
+                        {
+                            name: 'HTTPS',
+                            value: 'https',
+                        },
+                        {
+                            name: 'SOCKS4',
+                            value: 'socks4',
+                        },
+                        {
+                            name: 'SOCKS5',
+                            value: 'socks5',
+                        },
+                    ],
+                    default: 'http',
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['fields'],
+                        },
+                    },
+                    description: 'Type of proxy server',
+                },
+                {
+                    displayName: 'Proxy Host',
+                    name: 'proxyHost',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['fields'],
+                        },
+                    },
+                    description: 'Proxy server hostname or IP address',
+                },
+                {
+                    displayName: 'Proxy Port',
+                    name: 'proxyPort',
+                    type: 'number',
+                    default: 8080,
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['fields'],
+                        },
+                    },
+                    description: 'Proxy server port',
+                },
+                {
+                    displayName: 'Proxy Username',
+                    name: 'proxyUser',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['fields'],
+                        },
+                    },
+                    description: 'Username for proxy authentication',
+                },
+                {
+                    displayName: 'Proxy Password',
+                    name: 'proxyPass',
+                    type: 'string',
+                    typeOptions: {
+                        password: true,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                            proxyConfig: ['fields'],
+                        },
+                    },
+                    description: 'Password for proxy authentication',
+                },
+                {
+                    displayName: 'Browser Fingerprint',
+                    name: 'fingerprint',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: false,
+                    },
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Browser fingerprint configuration',
+                    options: [
+                        {
+                            displayName: 'Values',
+                            name: 'values',
+                            values: [
+                                {
+                                    displayName: 'Chrome Version',
+                                    name: 'chromeVersion',
+                                    type: 'string',
+                                    default: '120.0.0.0',
+                                    description: 'Chrome version to emulate',
+                                },
+                                {
+                                    displayName: 'Language',
+                                    name: 'language',
+                                    type: 'string',
+                                    default: 'en-US',
+                                    description: 'Browser language (e.g., en-US, vi-VN)',
+                                },
+                                {
+                                    displayName: 'OS',
+                                    name: 'os',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Windows 10', value: 'win10' },
+                                        { name: 'Windows 11', value: 'win' },
+                                        { name: 'macOS', value: 'mac' },
+                                        { name: 'Linux', value: 'linux' },
+                                    ],
+                                    default: 'win',
+                                },
+                                {
+                                    displayName: 'Screen Resolution',
+                                    name: 'resolution',
+                                    type: 'string',
+                                    default: '1920x1080',
+                                    description: 'Screen resolution (widthxheight)',
+                                },
+                                {
+                                    displayName: 'Timezone',
+                                    name: 'timezone',
+                                    type: 'string',
+                                    default: 'America/New_York',
+                                    description: 'Timezone (e.g., America/New_York, Asia/Ho_Chi_Minh)',
+                                },
+                                {
+                                    displayName: 'User Agent',
+                                    name: 'userAgent',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Custom user agent (leave empty to auto-generate)',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                // LAUNCH PROFILE OPTIONS
+                {
+                    displayName: 'Profile Config Path',
+                    name: 'profileConfigPath',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['launch'],
+                        },
+                    },
+                    description: 'Path to profile config JSON file (created by Create Profile operation)',
+                },
+                {
+                    displayName: 'Chrome Executable Path',
+                    name: 'chromePath',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['launch'],
+                        },
+                    },
+                    description: 'Path to Chrome/Chromium executable',
+                },
+                {
+                    displayName: 'Headless',
+                    name: 'headless',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['launch'],
+                        },
+                    },
+                    description: 'Whether to run browser in headless mode',
+                },
+                {
+                    displayName: 'Window Size',
+                    name: 'windowSize',
+                    type: 'string',
+                    default: '1920x1080',
+                    displayOptions: {
+                        show: {
+                            operation: ['launch'],
+                        },
+                    },
+                    description: 'Browser window size (widthxheight)',
+                },
+                {
+                    displayName: 'Return Browser Info',
+                    name: 'returnBrowserInfo',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['launch'],
+                        },
+                    },
+                    description: 'Whether to return browser connection information in output',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const operation = this.getNodeParameter('operation', 0);
+        const returnData = [];
+        // Create instance helper to access private methods
+        const instance = new BrowserProfile();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'create') {
+                    const result = await instance.createProfile(this, i);
+                    returnData.push({
+                        json: result,
+                    });
+                }
+                else if (operation === 'launch') {
+                    const result = await instance.launchProfile(this, i);
+                    returnData.push({
+                        json: result,
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+    async createProfile(context, itemIndex) {
+        const profileName = context.getNodeParameter('profileName', itemIndex);
+        const profileDir = context.getNodeParameter('profileDir', itemIndex);
+        const proxyConfig = context.getNodeParameter('proxyConfig', itemIndex);
+        // Parse proxy configuration
+        let proxyData;
+        if (proxyConfig === 'string') {
+            const proxyString = context.getNodeParameter('proxyString', itemIndex);
+            proxyData = this.parseProxyString(context, proxyString);
+        }
+        else {
+            proxyData = {
+                type: context.getNodeParameter('proxyType', itemIndex),
+                host: context.getNodeParameter('proxyHost', itemIndex),
+                port: context.getNodeParameter('proxyPort', itemIndex),
+                username: context.getNodeParameter('proxyUser', itemIndex),
+                password: context.getNodeParameter('proxyPass', itemIndex),
+            };
+        }
+        // Get fingerprint configuration
+        const fingerprintData = context.getNodeParameter('fingerprint.values', itemIndex, {});
+        // Generate fingerprint if needed
+        const fingerprint = this.generateFingerprint(fingerprintData);
+        // Create profile directory
+        const fullProfileDir = path.resolve(profileDir, profileName);
+        await fs.ensureDir(fullProfileDir);
+        await fs.ensureDir(path.join(fullProfileDir, 'Default'));
+        // Create profile config
+        const profileId = (0, uuid_1.v4)();
+        const profileConfig = {
+            id: profileId,
+            name: profileName,
+            profileDir: fullProfileDir,
+            proxy: {
+                type: proxyData.type,
+                host: proxyData.host,
+                port: proxyData.port,
+                username: proxyData.username,
+                password: proxyData.password,
+            },
+            fingerprint: fingerprint,
+            createdAt: new Date().toISOString(),
+        };
+        // Save profile config
+        const configPath = path.join(fullProfileDir, 'profile.config.json');
+        await fs.writeJSON(configPath, profileConfig, { spaces: 2 });
+        // Modify Chrome Preferences to set proxy
+        await this.modifyChromePreferences(fullProfileDir, proxyData);
+        return {
+            success: true,
+            profileId: profileId,
+            profileName: profileName,
+            profileDir: fullProfileDir,
+            configPath: configPath,
+            proxy: {
+                type: proxyData.type,
+                host: proxyData.host,
+                port: proxyData.port,
+            },
+            fingerprint: fingerprint,
+        };
+    }
+    async launchProfile(context, itemIndex) {
+        const configPath = context.getNodeParameter('profileConfigPath', itemIndex);
+        const chromePath = context.getNodeParameter('chromePath', itemIndex);
+        const headless = context.getNodeParameter('headless', itemIndex);
+        const windowSize = context.getNodeParameter('windowSize', itemIndex);
+        const returnBrowserInfo = context.getNodeParameter('returnBrowserInfo', itemIndex);
+        // Load profile config
+        const profileConfig = await fs.readJSON(configPath);
+        const { profileDir, proxy, fingerprint } = profileConfig;
+        // Parse window size
+        const [width, height] = windowSize.split('x').map(Number);
+        // Find available debug port
+        const debugPort = await this.findAvailablePort(context, 9222);
+        // Build proxy server string
+        const proxyServer = `${proxy.type}://${proxy.host}:${proxy.port}`;
+        // Launch browser with puppeteer
+        const browser = await puppeteer.launch({
+            executablePath: chromePath,
+            headless: headless,
+            userDataDir: profileDir,
+            args: [
+                `--proxy-server=${proxyServer}`,
+                `--remote-debugging-port=${debugPort}`,
+                `--window-size=${width},${height}`,
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-blink-features=AutomationControlled',
+            ],
+            defaultViewport: {
+                width: width,
+                height: height,
+            },
+        });
+        // Get browser pages
+        const pages = await browser.pages();
+        const page = pages[0] || (await browser.newPage());
+        // Set user agent and other fingerprint settings
+        if (fingerprint.userAgent) {
+            await page.setUserAgent(fingerprint.userAgent);
+        }
+        if (fingerprint.timezone) {
+            await page.emulateTimezone(fingerprint.timezone);
+        }
+        // Set extra HTTP headers including proxy authentication
+        const extraHeaders = {};
+        if (fingerprint.language) {
+            extraHeaders['Accept-Language'] = fingerprint.language;
+        }
+        // Add proxy authentication header
+        if (proxy.username && proxy.password) {
+            const credentials = Buffer.from(`${proxy.username}:${proxy.password}`).toString('base64');
+            extraHeaders['Proxy-Authorization'] = `Basic ${credentials}`;
+        }
+        if (Object.keys(extraHeaders).length > 0) {
+            await page.setExtraHTTPHeaders(extraHeaders);
+        }
+        // Also inject via DevTools Protocol for maximum compatibility
+        if (proxy.username && proxy.password) {
+            await this.injectProxyAuthentication(context, debugPort, proxy.username, proxy.password);
+        }
+        // Get browser info
+        const browserInfo = {
+            success: true,
+            profileId: profileConfig.id,
+            profileName: profileConfig.name,
+            debugPort: debugPort,
+            wsEndpoint: browser.wsEndpoint(),
+        };
+        if (returnBrowserInfo) {
+            return browserInfo;
+        }
+        // Return basic info and keep browser running
+        return {
+            success: true,
+            message: 'Browser launched successfully with proxy authentication',
+            profileId: profileConfig.id,
+            debugPort: debugPort,
+        };
+    }
+    parseProxyString(context, proxyString) {
+        // Parse proxy string format: type://user:pass@host:port or type://host:port
+        const urlMatch = proxyString.match(/^(\w+):\/\/(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$/);
+        if (!urlMatch) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Invalid proxy string format: ${proxyString}. Expected format: type://user:pass@host:port or type://host:port`);
+        }
+        return {
+            type: urlMatch[1],
+            username: urlMatch[2] || '',
+            password: urlMatch[3] || '',
+            host: urlMatch[4],
+            port: parseInt(urlMatch[5], 10),
+        };
+    }
+    generateFingerprint(fingerprintData) {
+        const os = fingerprintData.os || 'win';
+        const chromeVersion = fingerprintData.chromeVersion || '120.0.0.0';
+        const resolution = fingerprintData.resolution || '1920x1080';
+        // Generate user agent based on OS and Chrome version
+        let userAgent = fingerprintData.userAgent;
+        if (!userAgent) {
+            if (os === 'win') {
+                userAgent = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+            }
+            else if (os === 'mac') {
+                userAgent = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+            }
+            else {
+                userAgent = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
+            }
+        }
+        return {
+            os: os,
+            chromeVersion: chromeVersion,
+            userAgent: userAgent,
+            resolution: resolution,
+            timezone: (fingerprintData.timezone || 'America/New_York'),
+            language: (fingerprintData.language || 'en-US'),
+        };
+    }
+    async modifyChromePreferences(profileDir, proxyData) {
+        const prefsPath = path.join(profileDir, 'Default', 'Preferences');
+        let preferences = {};
+        // Try to read existing preferences
+        try {
+            if (await fs.pathExists(prefsPath)) {
+                const prefs = await fs.readJSON(prefsPath);
+                preferences = prefs;
+            }
+        }
+        catch (error) {
+            // If file doesn't exist or is invalid, create new preferences
+            preferences = {};
+        }
+        // Set proxy configuration in preferences
+        const proxyServer = `${proxyData.type}://${proxyData.host}:${proxyData.port}`;
+        preferences.proxy = {
+            mode: 'fixed_servers',
+            server: proxyServer,
+            bypass_list: [],
+        };
+        // Set fingerprint-related preferences
+        if (!preferences.profile) {
+            preferences.profile = {};
+        }
+        // Set default page zoom
+        preferences.default_zoom_level = 0;
+        // Save preferences
+        await fs.writeJSON(prefsPath, preferences, { spaces: 2 });
+    }
+    async injectProxyAuthentication(context, debugPort, username, password) {
+        if (!username || !password) {
+            // No authentication needed
+            return;
+        }
+        try {
+            // Wait for browser to be fully ready
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            // Connect to Chrome DevTools Protocol
+            const client = await (0, chrome_remote_interface_1.default)({ port: debugPort });
+            try {
+                // Enable Network domain
+                await client.Network.enable();
+                // Create base64 encoded credentials
+                const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+                const authHeader = `Basic ${credentials}`;
+                // Set extra HTTP headers with Proxy-Authorization
+                // This is the primary method - adds the header to all outgoing requests
+                await client.Network.setExtraHTTPHeaders({
+                    headers: {
+                        'Proxy-Authorization': authHeader,
+                    },
+                });
+                // Keep client reference to prevent garbage collection
+                // Store it in a way that keeps the connection alive
+                // The connection will be maintained as long as the browser is running
+                // Note: We don't close the client here because:
+                // 1. The connection needs to stay alive for the proxy auth to work
+                // 2. The browser process will clean up when it closes
+                // 3. Closing it immediately would stop the proxy authentication
+            }
+            catch (cdpError) {
+                // Try to close client if there's an error during setup
+                try {
+                    await client.close();
+                }
+                catch {
+                    // Ignore close errors
+                }
+                throw cdpError;
+            }
+        }
+        catch (error) {
+            // If CDP connection fails, throw error - proxy auth won't work without it
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new n8n_workflow_1.NodeApiError(context.getNode(), {
+                message: `Failed to inject proxy authentication via Chrome DevTools Protocol: ${errorMessage}. Make sure the browser is running and debug port ${debugPort} is accessible.`,
+            });
+        }
+    }
+    async findAvailablePort(context, startPort) {
+        for (let port = startPort; port < startPort + 100; port++) {
+            const isAvailable = await new Promise((resolve) => {
+                const server = net.createServer();
+                server.listen(port, () => {
+                    server.close(() => resolve(true));
+                });
+                server.on('error', () => resolve(false));
+            });
+            if (isAvailable) {
+                return port;
+            }
+        }
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Could not find available port for debugging. Please try again or check if ports are in use.');
+    }
+}
+exports.BrowserProfile = BrowserProfile;

package/dist/nodes/BrowserProfile/browser.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="2" y="4" width="20" height="16" rx="2"/>
+  <path d="M2 8h20"/>
+  <circle cx="6" cy="6" r="1" fill="currentColor"/>
+  <circle cx="9" cy="6" r="1" fill="currentColor"/>
+</svg>
+

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "n8n-nodes-dhd-browser",
+  "version": "1.0.0",
+  "description": "n8n node for creating and launching browser profiles with automatic proxy authentication",
+  "keywords": [
+    "n8n-community-node-package",
+    "browser",
+    "profile",
+    "proxy",
+    "chromium",
+    "automation"
+  ],
+  "license": "MIT",
+  "homepage": "",
+  "author": {
+    "name": "DHD",
+    "email": ""
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "main": "dist/BrowserProfile.node.js",
+  "scripts": {
+    "build": "tsc && gulp && gulp move:files",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes package.json --ignore-pattern credentials",
+    "lintfix": "eslint nodes package.json --ignore-pattern credentials --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/BrowserProfile/BrowserProfile.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.0",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "eslint-plugin-n8n-nodes-base": "~1.12.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^3.1.1",
+    "typescript": "~5.3.2"
+  },
+  "dependencies": {
+    "chrome-remote-interface": "^0.33.0",
+    "fs-extra": "^11.2.0",
+    "puppeteer-core": "^22.8.1",
+    "uuid": "^9.0.1"
+  }
+}