n8n-nodes-nvk-browser 1.0.0

package/dist/nodes/ProfileManagement/StartProfile/code.svg

@@ -0,0 +1,5 @@
+<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">
+  <polyline points="16 18 22 12 16 6"></polyline>
+  <polyline points="8 6 2 12 8 18"></polyline>
+</svg>
+

package/dist/nodes/ProfileManagement/StartProfile/profile.svg

@@ -0,0 +1,5 @@
+<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">
+  <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"></path>
+  <circle cx="12" cy="7" r="4"></circle>
+</svg>
+

package/dist/nodes/ProfileManagement/StopProfile/StopProfile.description.d.ts

@@ -0,0 +1,2 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const stopProfileFields: INodeProperties[];

package/dist/nodes/ProfileManagement/StopProfile/StopProfile.description.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopProfileFields = void 0;
+exports.stopProfileFields = [
+    {
+        displayName: 'Profile ID',
+        name: 'profileId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'ID of the profile to stop',
+        displayOptions: {
+            show: {
+                resource: ['profile'],
+                operation: ['stop'],
+            },
+        },
+    },
+];

package/dist/nodes/ProfileManagement/StopProfile/StopProfile.node.d.ts

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

package/dist/nodes/ProfileManagement/StopProfile/StopProfile.node.js

@@ -0,0 +1,115 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopProfile = void 0;
+const BrowserManager_1 = require("../../../utils/BrowserManager");
+const StopProfile_description_1 = require("./StopProfile.description");
+const path = __importStar(require("path"));
+class StopProfile {
+    constructor() {
+        this.description = {
+            displayName: 'Stop Profile',
+            name: 'stopProfile',
+            icon: 'file:profile.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Stop a running browser profile',
+            defaults: {
+                name: 'Stop Profile',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Profile',
+                            value: 'profile',
+                        },
+                    ],
+                    default: 'profile',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Stop',
+                            value: 'stop',
+                            description: 'Stop a profile',
+                            action: 'Stop a profile',
+                        },
+                    ],
+                    default: 'stop',
+                },
+                ...StopProfile_description_1.stopProfileFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const workspacePath = process.cwd();
+        const profilesDir = process.env.NVK_PROFILES_DIR || path.join(workspacePath, 'profiles');
+        const browserPath = process.env.NVK_BROWSER_PATH || path.join(workspacePath, 'browser-142', 'chrome.exe');
+        const resolvedBrowserPath = path.isAbsolute(browserPath)
+            ? browserPath
+            : path.resolve(workspacePath, browserPath);
+        const resolvedProfilesDir = path.isAbsolute(profilesDir)
+            ? profilesDir
+            : path.resolve(workspacePath, profilesDir);
+        BrowserManager_1.BrowserManager.resetInstance(); // Reset để đảm bảo dùng đúng paths
+        const browserManager = BrowserManager_1.BrowserManager.getInstance(resolvedBrowserPath, resolvedProfilesDir);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const profileId = this.getNodeParameter('profileId', i);
+                const stopped = await browserManager.stopProfile(profileId);
+                returnData.push({
+                    json: {
+                        success: stopped,
+                        profileId,
+                        message: stopped ? 'Profile stopped successfully' : 'Profile not running',
+                    },
+                });
+            }
+            catch (error) {
+                returnData.push({
+                    json: {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.StopProfile = StopProfile;

package/dist/nodes/ProfileManagement/StopProfile/click.svg

@@ -0,0 +1,5 @@
+<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">
+  <path d="M9 9l5 12 1.774-5.226L21 14 9 9z"></path>
+  <path d="M21 3l-3.5 3.5"></path>
+</svg>
+

package/dist/nodes/ProfileManagement/StopProfile/code.svg

@@ -0,0 +1,5 @@
+<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">
+  <polyline points="16 18 22 12 16 6"></polyline>
+  <polyline points="8 6 2 12 8 18"></polyline>
+</svg>
+

package/dist/nodes/ProfileManagement/StopProfile/profile.svg

@@ -0,0 +1,5 @@
+<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">
+  <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"></path>
+  <circle cx="12" cy="7" r="4"></circle>
+</svg>
+

package/dist/utils/BrowserManager.d.ts

@@ -0,0 +1,18 @@
+import { Page } from 'puppeteer-core';
+import { BrowserInstance, WindowConfig } from './types';
+export declare class BrowserManager {
+    private static instance;
+    private instances;
+    private browserPath;
+    private profilesManager;
+    private constructor();
+    static getInstance(browserPath?: string, profilesDir?: string): BrowserManager;
+    static resetInstance(): void;
+    startProfile(profileId: string, windowConfig?: WindowConfig): Promise<BrowserInstance>;
+    stopProfile(profileId: string): Promise<boolean>;
+    getInstance(profileId: string): BrowserInstance | undefined;
+    getAllInstances(): BrowserInstance[];
+    private getDebugPort;
+    private setWindowPosition;
+    getPage(profileId: string, tabIndex?: number): Promise<Page | null>;
+}

package/dist/utils/BrowserManager.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserManager = void 0;
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const ProxyHandler_1 = require("./ProxyHandler");
+const ExtensionHandler_1 = require("./ExtensionHandler");
+const ProfileManager_1 = require("./ProfileManager");
+class BrowserManager {
+    constructor(browserPath, profilesDir) {
+        this.instances = new Map();
+        this.browserPath = browserPath;
+        this.profilesManager = new ProfileManager_1.ProfileManager(profilesDir);
+    }
+    static getInstance(browserPath, profilesDir) {
+        if (!BrowserManager.instance) {
+            if (!browserPath || !profilesDir) {
+                throw new Error('BrowserManager must be initialized with browserPath and profilesDir');
+            }
+            BrowserManager.instance = new BrowserManager(browserPath, profilesDir);
+        }
+        return BrowserManager.instance;
+    }
+    static resetInstance() {
+        BrowserManager.instance = null;
+    }
+    async startProfile(profileId, windowConfig) {
+        // Kiểm tra xem profile đã đang chạy chưa
+        if (this.instances.has(profileId)) {
+            throw new Error(`Profile ${profileId} is already running`);
+        }
+        // Lấy thông tin profile
+        const profile = this.profilesManager.getProfile(profileId);
+        if (!profile) {
+            throw new Error(`Profile ${profileId} not found`);
+        }
+        const profilePath = this.profilesManager.getProfilePath(profileId);
+        // Chuẩn bị Chrome arguments
+        const args = [
+            `--user-data-dir=${profilePath}`,
+            '--remote-debugging-port=0',
+            '--disable-blink-features=AutomationControlled',
+            '--disable-dev-shm-usage',
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+        ];
+        // Proxy configuration
+        if (profile.proxy) {
+            const proxyConfig = ProxyHandler_1.ProxyHandler.parseProxyString(profile.proxy);
+            if (proxyConfig) {
+                args.push(...ProxyHandler_1.ProxyHandler.getChromeProxyArgs(proxyConfig));
+            }
+        }
+        // Extension configuration
+        if (profile.extensions && profile.extensions.length > 0) {
+            args.push(...ExtensionHandler_1.ExtensionHandler.getExtensionArgs(profile.extensions));
+        }
+        // Window configuration
+        if (windowConfig) {
+            if (windowConfig.scale) {
+                args.push(`--force-device-scale-factor=${windowConfig.scale}`);
+            }
+            if (windowConfig.headless) {
+                args.push('--headless=new');
+            }
+        }
+        // Khởi động Chrome
+        const browser = await puppeteer_core_1.default.launch({
+            executablePath: this.browserPath,
+            args,
+            headless: windowConfig?.headless || false,
+            defaultViewport: windowConfig?.size
+                ? {
+                    width: windowConfig.size.width,
+                    height: windowConfig.size.height,
+                }
+                : null,
+        });
+        // Lấy debug port từ browser
+        const targets = browser.targets();
+        const debugPort = await this.getDebugPort(browser);
+        // Tạo instance
+        const instance = {
+            profileId,
+            process: browser.process(),
+            browser,
+            pages: new Map(),
+            debugPort,
+        };
+        // Lưu instance
+        this.instances.set(profileId, instance);
+        // Set window position nếu có
+        if (windowConfig?.position && !windowConfig.headless) {
+            await this.setWindowPosition(browser, windowConfig.position);
+        }
+        return instance;
+    }
+    async stopProfile(profileId) {
+        const instance = this.instances.get(profileId);
+        if (!instance) {
+            return false;
+        }
+        try {
+            await instance.browser.close();
+            this.instances.delete(profileId);
+            return true;
+        }
+        catch (error) {
+            this.instances.delete(profileId);
+            return false;
+        }
+    }
+    getInstance(profileId) {
+        return this.instances.get(profileId);
+    }
+    getAllInstances() {
+        return Array.from(this.instances.values());
+    }
+    async getDebugPort(browser) {
+        try {
+            const endpoint = browser.wsEndpoint();
+            const match = endpoint.match(/localhost:(\d+)/);
+            if (match) {
+                return parseInt(match[1], 10);
+            }
+        }
+        catch (error) {
+            // Ignore
+        }
+        return 0;
+    }
+    async setWindowPosition(browser, position) {
+        try {
+            // Window position được set thông qua Chrome DevTools Protocol
+            const pages = await browser.pages();
+            if (pages.length > 0) {
+                const target = pages[0].target();
+                const client = await target.createCDPSession();
+                // Note: Window position setting via CDP may require additional setup
+                // For now, we'll rely on Chrome's default behavior
+                // The position parameter is stored but not actively used
+                await client.detach();
+            }
+        }
+        catch (error) {
+            // Ignore if not supported - window position is optional
+        }
+    }
+    async getPage(profileId, tabIndex = 0) {
+        const instance = this.instances.get(profileId);
+        if (!instance) {
+            return null;
+        }
+        // Kiểm tra cache
+        if (instance.pages.has(tabIndex)) {
+            return instance.pages.get(tabIndex);
+        }
+        // Lấy pages từ browser
+        const pages = await instance.browser.pages();
+        if (pages.length > tabIndex) {
+            const page = pages[tabIndex];
+            instance.pages.set(tabIndex, page);
+            return page;
+        }
+        // Tạo page mới nếu không có
+        const newPage = await instance.browser.newPage();
+        instance.pages.set(tabIndex, newPage);
+        return newPage;
+    }
+}
+BrowserManager.instance = null;
+exports.BrowserManager = BrowserManager;

package/dist/utils/ExtensionHandler.d.ts

@@ -0,0 +1,9 @@
+export declare class ExtensionHandler {
+    static parseExtensions(extensionInput: string): string[];
+    static validateExtension(extension: string): {
+        valid: boolean;
+        path?: string;
+        error?: string;
+    };
+    static getExtensionArgs(extensions: string[]): string[];
+}

package/dist/utils/ExtensionHandler.js

@@ -0,0 +1,86 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionHandler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ExtensionHandler {
+    static parseExtensions(extensionInput) {
+        if (!extensionInput || !extensionInput.trim()) {
+            return [];
+        }
+        // Mỗi extension một dòng
+        const lines = extensionInput
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line.length > 0);
+        return lines;
+    }
+    static validateExtension(extension) {
+        // Nếu là ID từ Chrome Store (thường là 32 ký tự alphanumeric)
+        if (/^[a-z]{32}$/i.test(extension)) {
+            return { valid: true };
+        }
+        // Nếu là đường dẫn local
+        if (path.isAbsolute(extension) || extension.startsWith('./') || extension.startsWith('../')) {
+            const resolvedPath = path.resolve(extension);
+            if (fs.existsSync(resolvedPath)) {
+                // Kiểm tra xem có phải là extension directory không
+                const manifestPath = path.join(resolvedPath, 'manifest.json');
+                if (fs.existsSync(manifestPath)) {
+                    return { valid: true, path: resolvedPath };
+                }
+                return { valid: false, error: 'Extension directory does not contain manifest.json' };
+            }
+            return { valid: false, error: 'Extension path does not exist' };
+        }
+        // Nếu là relative path từ workspace
+        const workspacePath = path.resolve(__dirname, '..', extension);
+        if (fs.existsSync(workspacePath)) {
+            const manifestPath = path.join(workspacePath, 'manifest.json');
+            if (fs.existsSync(manifestPath)) {
+                return { valid: true, path: workspacePath };
+            }
+            return { valid: false, error: 'Extension directory does not contain manifest.json' };
+        }
+        return { valid: false, error: 'Invalid extension format. Must be Chrome Store ID or valid path' };
+    }
+    static getExtensionArgs(extensions) {
+        const args = [];
+        const validPaths = [];
+        for (const ext of extensions) {
+            const validation = this.validateExtension(ext);
+            if (validation.valid && validation.path) {
+                validPaths.push(validation.path);
+            }
+            // Chrome Store IDs sẽ được load sau khi browser khởi động
+        }
+        if (validPaths.length > 0) {
+            args.push(`--load-extension=${validPaths.join(',')}`);
+        }
+        return args;
+    }
+}
+exports.ExtensionHandler = ExtensionHandler;

package/dist/utils/ProfileManager.d.ts

@@ -0,0 +1,14 @@
+import { ProfileData } from './types';
+export declare class ProfileManager {
+    private profilesDir;
+    constructor(profilesDir: string);
+    private ensureProfilesDir;
+    private getProfileMetadataPath;
+    private getProfileDir;
+    createProfile(name: string, proxy?: string, note?: string, extensions?: string[]): ProfileData;
+    getProfile(profileId: string): ProfileData | null;
+    getAllProfiles(): ProfileData[];
+    updateProfile(profileId: string, updates: Partial<ProfileData>): ProfileData | null;
+    deleteProfile(profileId: string): boolean;
+    getProfilePath(profileId: string): string;
+}

package/dist/utils/ProfileManager.js

@@ -0,0 +1,128 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+class ProfileManager {
+    constructor(profilesDir) {
+        this.profilesDir = profilesDir;
+        this.ensureProfilesDir();
+    }
+    ensureProfilesDir() {
+        if (!fs.existsSync(this.profilesDir)) {
+            fs.mkdirSync(this.profilesDir, { recursive: true });
+        }
+    }
+    getProfileMetadataPath(profileId) {
+        return path.join(this.profilesDir, profileId, 'profile.metadata.json');
+    }
+    getProfileDir(profileId) {
+        return path.join(this.profilesDir, profileId);
+    }
+    createProfile(name, proxy, note, extensions) {
+        const profileId = (0, uuid_1.v4)();
+        const profileDir = this.getProfileDir(profileId);
+        // Tạo thư mục profile
+        fs.mkdirSync(profileDir, { recursive: true });
+        const profileData = {
+            id: profileId,
+            name,
+            proxy,
+            note,
+            extensions: extensions || [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        // Lưu metadata
+        const metadataPath = this.getProfileMetadataPath(profileId);
+        fs.writeFileSync(metadataPath, JSON.stringify(profileData, null, 2), 'utf-8');
+        return profileData;
+    }
+    getProfile(profileId) {
+        const metadataPath = this.getProfileMetadataPath(profileId);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(metadataPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getAllProfiles() {
+        const profiles = [];
+        if (!fs.existsSync(this.profilesDir)) {
+            return profiles;
+        }
+        const dirs = fs.readdirSync(this.profilesDir);
+        for (const dir of dirs) {
+            const profilePath = path.join(this.profilesDir, dir);
+            if (fs.statSync(profilePath).isDirectory()) {
+                const profile = this.getProfile(dir);
+                if (profile) {
+                    profiles.push(profile);
+                }
+            }
+        }
+        return profiles;
+    }
+    updateProfile(profileId, updates) {
+        const profile = this.getProfile(profileId);
+        if (!profile) {
+            return null;
+        }
+        const updatedProfile = {
+            ...profile,
+            ...updates,
+            id: profileId,
+            updatedAt: new Date().toISOString(),
+        };
+        const metadataPath = this.getProfileMetadataPath(profileId);
+        fs.writeFileSync(metadataPath, JSON.stringify(updatedProfile, null, 2), 'utf-8');
+        return updatedProfile;
+    }
+    deleteProfile(profileId) {
+        const profileDir = this.getProfileDir(profileId);
+        if (!fs.existsSync(profileDir)) {
+            return false;
+        }
+        try {
+            // Xóa toàn bộ thư mục profile
+            fs.rmSync(profileDir, { recursive: true, force: true });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getProfilePath(profileId) {
+        return this.getProfileDir(profileId);
+    }
+}
+exports.ProfileManager = ProfileManager;

package/dist/utils/ProxyHandler.d.ts

@@ -0,0 +1,5 @@
+import { ProxyConfig } from './types';
+export declare class ProxyHandler {
+    static parseProxyString(proxyString: string): ProxyConfig | null;
+    static getChromeProxyArgs(proxyConfig: ProxyConfig | null): string[];
+}

package/dist/utils/ProxyHandler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyHandler = void 0;
+class ProxyHandler {
+    static parseProxyString(proxyString) {
+        if (!proxyString || !proxyString.trim()) {
+            return null;
+        }
+        // Format: http:127.0.0.1:8080:user:pass hoặc socks5:127.0.0.1:1080:user:pass
+        const parts = proxyString.split(':');
+        if (parts.length < 3) {
+            return null;
+        }
+        const type = parts[0].toLowerCase();
+        if (type !== 'http' && type !== 'socks5') {
+            return null;
+        }
+        const host = parts[1];
+        const port = parseInt(parts[2], 10);
+        if (isNaN(port)) {
+            return null;
+        }
+        const config = {
+            type,
+            host,
+            port,
+        };
+        if (parts.length >= 4) {
+            config.username = parts[3];
+        }
+        if (parts.length >= 5) {
+            config.password = parts[4];
+        }
+        return config;
+    }
+    static getChromeProxyArgs(proxyConfig) {
+        if (!proxyConfig) {
+            return [];
+        }
+        const args = [];
+        if (proxyConfig.type === 'http') {
+            args.push(`--proxy-server=http://${proxyConfig.host}:${proxyConfig.port}`);
+        }
+        else if (proxyConfig.type === 'socks5') {
+            args.push(`--proxy-server=socks5://${proxyConfig.host}:${proxyConfig.port}`);
+        }
+        return args;
+    }
+}
+exports.ProxyHandler = ProxyHandler;