n8n-nodes-nvk-browser 1.0.0 → 1.0.3

package/dist/nodes/PageInteraction/MoveAndClick/MoveAndClick.description.js

@@ -22,7 +22,23 @@ exports.moveAndClickFields = [
         type: 'string',
         required: true,
         default: '',
-        description: 'CSS selector of the element to click',
+        description: 'For Puppeteer: CSS selector, XPath (with >XPATH> prefix), or code pattern with targetPage.locator()/page.locator() and puppeteer.Locator.race(). Examples: "textarea", ">XPATH>/html/body/div", or code with Locator.race(). For Javascript: CSS selector only.',
+        typeOptions: {
+            rows: 4,
+        },
+        displayOptions: {
+            show: {
+                resource: ['page'],
+                operation: ['moveAndClick'],
+            },
+        },
+    },
+    {
+        displayName: 'Timeout (Milliseconds)',
+        name: 'timeout',
+        type: 'number',
+        default: 30000,
+        description: 'Timeout in milliseconds for waiting for the element',
         displayOptions: {
             show: {
                 resource: ['page'],
@@ -35,10 +51,6 @@ exports.moveAndClickFields = [
         name: 'clickMethod',
         type: 'options',
         options: [
-            {
-                name: 'Use GhostCursor',
-                value: 'ghostcursor',
-            },
             {
                 name: 'Use Puppeteer',
                 value: 'puppeteer',
@@ -61,13 +73,13 @@ exports.moveAndClickFields = [
         displayName: 'Wait For Click (Milliseconds)',
         name: 'waitForClick',
         type: 'number',
-        default: 0,
+        default: 500,
         description: 'Wait time before clicking in milliseconds',
         displayOptions: {
             show: {
                 resource: ['page'],
                 operation: ['moveAndClick'],
-                clickMethod: ['javascript'],
+                clickMethod: ['puppeteer'],
             },
         },
     },
@@ -95,7 +107,7 @@ exports.moveAndClickFields = [
             show: {
                 resource: ['page'],
                 operation: ['moveAndClick'],
-                clickMethod: ['javascript'],
+                clickMethod: ['puppeteer'],
             },
         },
     },
@@ -112,7 +124,7 @@ exports.moveAndClickFields = [
             show: {
                 resource: ['page'],
                 operation: ['moveAndClick'],
-                clickMethod: ['javascript'],
+                clickMethod: ['puppeteer'],
             },
         },
     },
@@ -129,4 +141,17 @@ exports.moveAndClickFields = [
             },
         },
     },
+    {
+        displayName: 'Auto Start Profile',
+        name: 'autoStart',
+        type: 'boolean',
+        default: false,
+        description: 'Automatically start the profile if it is not running',
+        displayOptions: {
+            show: {
+                resource: ['page'],
+                operation: ['moveAndClick'],
+            },
+        },
+    },
 ];

package/dist/nodes/PageInteraction/MoveAndClick/MoveAndClick.node.js

@@ -22,11 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.MoveAndClick = void 0;
 const BrowserManager_1 = require("../../../utils/BrowserManager");
 const MoveAndClick_description_1 = require("./MoveAndClick.description");
 const path = __importStar(require("path"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 class MoveAndClick {
     constructor() {
         this.description = {
@@ -86,69 +90,214 @@ class MoveAndClick {
         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 selector = this.getNodeParameter('selector', i);
                 const clickMethod = this.getNodeParameter('clickMethod', i) || 'puppeteer';
-                const waitForClick = this.getNodeParameter('waitForClick', i) || 0;
-                const button = this.getNodeParameter('button', i) || 'left';
-                const clickCount = this.getNodeParameter('clickCount', i) || 1;
+                const timeout = this.getNodeParameter('timeout', i) || 30000;
                 const tabIndex = this.getNodeParameter('tabIndex', i) || 0;
-                const instance = browserManager.getInstance(profileId);
+                const autoStart = this.getNodeParameter('autoStart', i) || false;
+                let instance = browserManager.getInstance(profileId);
+                // Auto start profile nếu chưa chạy và option được bật
+                if (!instance && autoStart) {
+                    instance = await browserManager.startProfileIfNotRunning(profileId);
+                }
                 if (!instance) {
-                    throw new Error(`Profile ${profileId} is not running`);
+                    throw new Error(`Profile ${profileId} is not running. Enable "Auto Start Profile" to start it automatically.`);
                 }
                 const page = await browserManager.getPage(profileId, tabIndex);
                 if (!page) {
                     throw new Error(`Could not get page for profile ${profileId}`);
                 }
-                // Wait for element if needed
-                await page.waitForSelector(selector, { timeout: 30000 });
+                // Set default timeout
+                page.setDefaultTimeout(timeout);
                 if (clickMethod === 'javascript') {
-                    // Wait before clicking
-                    if (waitForClick > 0) {
-                        await page.waitForTimeout(waitForClick);
-                    }
+                    // Use Javascript Click - simple implementation
+                    await page.waitForSelector(selector, { timeout });
                     // JavaScript click
-                    const buttonMap = {
-                        left: 0,
-                        middle: 1,
-                        right: 2,
-                    };
-                    await page.evaluate((sel, btn, count) => {
+                    await page.evaluate((sel) => {
                         // This code runs in browser context, so DOM APIs are available
                         // eslint-disable-next-line @typescript-eslint/no-implied-eval
                         const element = document.querySelector(sel);
                         if (element) {
-                            for (let i = 0; i < count; i++) {
-                                const event = new MouseEvent('click', {
-                                    view: window,
-                                    bubbles: true,
-                                    cancelable: true,
-                                    button: btn,
-                                });
-                                element.dispatchEvent(event);
-                            }
+                            const event = new MouseEvent('click', {
+                                view: window,
+                                bubbles: true,
+                                cancelable: true,
+                                button: 0,
+                            });
+                            element.dispatchEvent(event);
                         }
-                    }, selector, buttonMap[button] || 0, clickCount);
+                    }, selector);
                 }
                 else if (clickMethod === 'puppeteer') {
-                    // Puppeteer native click
-                    await page.click(selector);
-                }
-                else if (clickMethod === 'ghostcursor') {
-                    // GhostCursor simulation (simplified - would need ghost-cursor package)
-                    const element = await page.$(selector);
-                    if (element) {
-                        const box = await element.boundingBox();
-                        if (box) {
-                            // Move mouse to center of element
-                            await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
-                            await page.waitForTimeout(100);
-                            await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+                    // Use Puppeteer - support Locator.race() pattern
+                    const waitForClick = this.getNodeParameter('waitForClick', i) || 500;
+                    const button = this.getNodeParameter('button', i) || 'left';
+                    const clickCount = this.getNodeParameter('clickCount', i) || 1;
+                    // Parse selector - check if it's code with Locator.race() or simple selector
+                    const selectorTrimmed = selector.trim();
+                    // Check if selector contains Locator.race pattern or is a code block
+                    if (selectorTrimmed.includes('Locator.race') || selectorTrimmed.includes('puppeteer.Locator')) {
+                        // Execute as code - user provided full code
+                        // Extract the selector part from the code or execute the code directly
+                        try {
+                            // Parse selectors from the code pattern
+                            const locators = [];
+                            // Parse CSS selectors (lines with targetPage.locator('...') or page.locator('...'))
+                            const cssMatches = selector.match(/(?:targetPage|page)\.locator\(['"]([^'"]+)['"]\)/g);
+                            if (cssMatches) {
+                                cssMatches.forEach(match => {
+                                    const cssSel = match.match(/['"]([^'"]+)['"]/)?.[1];
+                                    if (cssSel && !cssSel.startsWith('::-p-xpath')) {
+                                        // Use page.locator if available, otherwise fallback
+                                        if (typeof page.locator === 'function') {
+                                            locators.push(page.locator(cssSel));
+                                        }
+                                    }
+                                });
+                            }
+                            // Parse XPath selectors (::-p-xpath(...))
+                            const xpathMatches = selector.match(/::-p-xpath\(([^)]+)\)/g);
+                            if (xpathMatches) {
+                                xpathMatches.forEach(match => {
+                                    const xpath = match.match(/::-p-xpath\(([^)]+)\)/)?.[1];
+                                    if (xpath && typeof page.locator === 'function') {
+                                        locators.push(page.locator(`::-p-xpath(${xpath})`));
+                                    }
+                                });
+                            }
+                            // Also check for >CSS> and >XPATH> prefixes
+                            if (selector.includes('>CSS>') || selector.includes('>XPATH>')) {
+                                const parts = selector.split(/\s+/);
+                                parts.forEach(part => {
+                                    if (part.startsWith('>CSS>') && typeof page.locator === 'function') {
+                                        const cssSel = part.replace('>CSS>', '');
+                                        locators.push(page.locator(cssSel));
+                                    }
+                                    else if (part.startsWith('>XPATH>') && typeof page.locator === 'function') {
+                                        const xpath = part.replace('>XPATH>', '');
+                                        locators.push(page.locator(`::-p-xpath(${xpath})`));
+                                    }
+                                });
+                            }
+                            if (locators.length > 0 && typeof page.locator === 'function') {
+                                // Use Locator.race() if multiple locators and API is available
+                                let locator;
+                                if (locators.length > 1) {
+                                    // Check if Locator.race is available
+                                    const LocatorClass = puppeteer_core_1.default.Locator;
+                                    if (LocatorClass && typeof LocatorClass.race === 'function') {
+                                        locator = LocatorClass.race(locators);
+                                        if (typeof locator.setTimeout === 'function') {
+                                            locator = locator.setTimeout(timeout);
+                                        }
+                                    }
+                                    else {
+                                        // Fallback: try first locator
+                                        locator = locators[0];
+                                        if (typeof locator.setTimeout === 'function') {
+                                            locator = locator.setTimeout(timeout);
+                                        }
+                                    }
+                                }
+                                else {
+                                    locator = locators[0];
+                                    if (typeof locator.setTimeout === 'function') {
+                                        locator = locator.setTimeout(timeout);
+                                    }
+                                }
+                                // Wait before clicking if specified
+                                if (waitForClick > 0) {
+                                    await page.waitForTimeout(waitForClick);
+                                }
+                                // Click with options
+                                const clickOptions = {
+                                    button: button,
+                                    clickCount: clickCount,
+                                };
+                                if (typeof locator.click === 'function') {
+                                    await locator.click(clickOptions);
+                                }
+                                else {
+                                    throw new Error('Locator.click is not available');
+                                }
+                            }
+                            else {
+                                // Fallback to simple selector parsing
+                                throw new Error('Could not parse selector from code or Locator API not available');
+                            }
+                        }
+                        catch (error) {
+                            // If code parsing fails, try to use as simple selector
+                            await page.waitForSelector(selector, { timeout });
+                            if (waitForClick > 0) {
+                                await page.waitForTimeout(waitForClick);
+                            }
+                            await page.click(selector, {
+                                button: button,
+                                clickCount: clickCount,
+                            });
+                        }
+                    }
+                    else {
+                        // Simple selector - parse CSS or XPath prefixes
+                        // Try to use Locator API if available, otherwise fallback to traditional API
+                        if (typeof page.locator === 'function') {
+                            let locator;
+                            if (selectorTrimmed.startsWith('>CSS>')) {
+                                const cssSel = selectorTrimmed.replace('>CSS>', '').trim();
+                                locator = page.locator(cssSel);
+                            }
+                            else if (selectorTrimmed.startsWith('>XPATH>')) {
+                                const xpath = selectorTrimmed.replace('>XPATH>', '').trim();
+                                locator = page.locator(`::-p-xpath(${xpath})`);
+                            }
+                            else if (selectorTrimmed.startsWith('::-p-xpath')) {
+                                // Already in XPath format
+                                locator = page.locator(selectorTrimmed);
+                            }
+                            else {
+                                // Default to CSS selector
+                                locator = page.locator(selectorTrimmed);
+                            }
+                            // Set timeout if method exists
+                            if (typeof locator.setTimeout === 'function') {
+                                locator = locator.setTimeout(timeout);
+                            }
+                            // Wait before clicking if specified
+                            if (waitForClick > 0) {
+                                await page.waitForTimeout(waitForClick);
+                            }
+                            // Click with options
+                            const clickOptions = {
+                                button: button,
+                                clickCount: clickCount,
+                            };
+                            if (typeof locator.click === 'function') {
+                                await locator.click(clickOptions);
+                            }
+                            else {
+                                // Fallback to traditional API
+                                await page.waitForSelector(selectorTrimmed, { timeout });
+                                if (waitForClick > 0) {
+                                    await page.waitForTimeout(waitForClick);
+                                }
+                                await page.click(selectorTrimmed, clickOptions);
+                            }
+                        }
+                        else {
+                            // Fallback to traditional API
+                            await page.waitForSelector(selectorTrimmed, { timeout });
+                            if (waitForClick > 0) {
+                                await page.waitForTimeout(waitForClick);
+                            }
+                            await page.click(selectorTrimmed, {
+                                button: button,
+                                clickCount: clickCount,
+                            });
                         }
                     }
                 }

package/dist/nodes/PageInteraction/RunJavaScript/RunJavaScript.description.js

@@ -59,4 +59,17 @@ exports.runJavaScriptFields = [
             },
         },
     },
+    {
+        displayName: 'Auto Start Profile',
+        name: 'autoStart',
+        type: 'boolean',
+        default: false,
+        description: 'Automatically start the profile if it is not running',
+        displayOptions: {
+            show: {
+                resource: ['page'],
+                operation: ['runJavaScript'],
+            },
+        },
+    },
 ];

package/dist/nodes/PageInteraction/RunJavaScript/RunJavaScript.node.js

@@ -86,16 +86,20 @@ class RunJavaScript {
         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 tabIndex = this.getNodeParameter('tabIndex', i) || 0;
                 const javascriptCode = this.getNodeParameter('javascriptCode', i);
-                const instance = browserManager.getInstance(profileId);
+                const autoStart = this.getNodeParameter('autoStart', i) || false;
+                let instance = browserManager.getInstance(profileId);
+                // Auto start profile nếu chưa chạy và option được bật
+                if (!instance && autoStart) {
+                    instance = await browserManager.startProfileIfNotRunning(profileId);
+                }
                 if (!instance) {
-                    throw new Error(`Profile ${profileId} is not running`);
+                    throw new Error(`Profile ${profileId} is not running. Enable "Auto Start Profile" to start it automatically.`);
                 }
                 const page = await browserManager.getPage(profileId, tabIndex);
                 if (!page) {

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

@@ -88,7 +88,6 @@ class DeleteProfile {
             ? profilesDir
             : path.resolve(workspacePath, profilesDir);
         const profileManager = new ProfileManager_1.ProfileManager(resolvedProfilesDir);
-        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 {

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

@@ -87,7 +87,6 @@ class StartProfile {
         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 {

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

@@ -86,7 +86,6 @@ class StopProfile {
         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 {

package/dist/utils/BrowserManager.d.ts

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

package/dist/utils/BrowserManager.js

@@ -1,9 +1,34 @@
 "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.BrowserManager = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const ProxyHandler_1 = require("./ProxyHandler");
 const ExtensionHandler_1 = require("./ExtensionHandler");
@@ -12,19 +37,25 @@ class BrowserManager {
     constructor(browserPath, profilesDir) {
         this.instances = new Map();
         this.browserPath = browserPath;
+        this.profilesDir = profilesDir;
         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);
+        // Tạo key từ paths để có thể có nhiều BrowserManager với paths khác nhau
+        const key = `${browserPath}:${profilesDir}`;
+        if (!BrowserManager.instances.has(key)) {
+            BrowserManager.instances.set(key, new BrowserManager(browserPath, profilesDir));
         }
-        return BrowserManager.instance;
+        return BrowserManager.instances.get(key);
     }
-    static resetInstance() {
-        BrowserManager.instance = null;
+    static resetInstance(browserPath, profilesDir) {
+        if (browserPath && profilesDir) {
+            const key = `${browserPath}:${profilesDir}`;
+            BrowserManager.instances.delete(key);
+        }
+        else {
+            BrowserManager.instances.clear();
+        }
     }
     async startProfile(profileId, windowConfig) {
         // Kiểm tra xem profile đã đang chạy chưa
@@ -37,6 +68,8 @@ class BrowserManager {
             throw new Error(`Profile ${profileId} not found`);
         }
         const profilePath = this.profilesManager.getProfilePath(profileId);
+        // Set profile name trong Chrome preferences
+        this.setProfileName(profilePath, profile.name);
         // Chuẩn bị Chrome arguments
         const args = [
             `--user-data-dir=${profilePath}`,
@@ -169,6 +202,64 @@ class BrowserManager {
         instance.pages.set(tabIndex, newPage);
         return newPage;
     }
+    setProfileName(profilePath, profileName) {
+        try {
+            // Set profile name trong Local State file
+            const localStatePath = path.join(profilePath, 'Local State');
+            let localState = {};
+            if (fs.existsSync(localStatePath)) {
+                try {
+                    const content = fs.readFileSync(localStatePath, 'utf-8');
+                    localState = JSON.parse(content);
+                }
+                catch (error) {
+                    // File exists but invalid JSON, start fresh
+                }
+            }
+            // Set profile name trong Chrome profile structure
+            if (!localState.profile) {
+                localState.profile = {};
+            }
+            localState.profile.name = profileName;
+            // Cũng set trong profile info
+            if (!localState.profile.info_cache) {
+                localState.profile.info_cache = {};
+            }
+            localState.profile.info_cache.Default = {
+                name: profileName,
+                is_using_default_name: false,
+            };
+            // Write back
+            fs.writeFileSync(localStatePath, JSON.stringify(localState, null, 2), 'utf-8');
+            // Cũng set trong Preferences file nếu có
+            const prefsPath = path.join(profilePath, 'Default', 'Preferences');
+            if (fs.existsSync(prefsPath)) {
+                try {
+                    const prefsContent = fs.readFileSync(prefsPath, 'utf-8');
+                    const prefs = JSON.parse(prefsContent);
+                    if (!prefs.profile) {
+                        prefs.profile = {};
+                    }
+                    prefs.profile.name = profileName;
+                    fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2), 'utf-8');
+                }
+                catch (error) {
+                    // Ignore preferences errors
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors - profile name is optional
+        }
+    }
+    async startProfileIfNotRunning(profileId, windowConfig) {
+        // Kiểm tra xem profile đã đang chạy chưa
+        if (this.instances.has(profileId)) {
+            return this.instances.get(profileId);
+        }
+        // Nếu chưa chạy, start nó
+        return await this.startProfile(profileId, windowConfig);
+    }
 }
-BrowserManager.instance = null;
+BrowserManager.instances = new Map();
 exports.BrowserManager = BrowserManager;

package/dist/utils/ProfileManager.d.ts

@@ -6,6 +6,7 @@ export declare class ProfileManager {
     private getProfileMetadataPath;
     private getProfileDir;
     createProfile(name: string, proxy?: string, note?: string, extensions?: string[]): ProfileData;
+    private setProfileName;
     getProfile(profileId: string): ProfileData | null;
     getAllProfiles(): ProfileData[];
     updateProfile(profileId: string, updates: Partial<ProfileData>): ProfileData | null;

package/dist/utils/ProfileManager.js

@@ -60,8 +60,66 @@ class ProfileManager {
         // Lưu metadata
         const metadataPath = this.getProfileMetadataPath(profileId);
         fs.writeFileSync(metadataPath, JSON.stringify(profileData, null, 2), 'utf-8');
+        // Set profile name trong Chrome files ngay khi tạo
+        this.setProfileName(profileDir, name);
         return profileData;
     }
+    setProfileName(profilePath, profileName) {
+        try {
+            // Set profile name trong Local State file
+            const localStatePath = path.join(profilePath, 'Local State');
+            let localState = {};
+            if (fs.existsSync(localStatePath)) {
+                try {
+                    const content = fs.readFileSync(localStatePath, 'utf-8');
+                    localState = JSON.parse(content);
+                }
+                catch (error) {
+                    // File exists but invalid JSON, start fresh
+                }
+            }
+            // Set profile name trong Chrome profile structure
+            if (!localState.profile) {
+                localState.profile = {};
+            }
+            localState.profile.name = profileName;
+            // Cũng set trong profile info
+            if (!localState.profile.info_cache) {
+                localState.profile.info_cache = {};
+            }
+            localState.profile.info_cache.Default = {
+                name: profileName,
+                is_using_default_name: false,
+            };
+            // Write back
+            fs.writeFileSync(localStatePath, JSON.stringify(localState, null, 2), 'utf-8');
+            // Tạo Default directory nếu chưa có
+            const defaultDir = path.join(profilePath, 'Default');
+            if (!fs.existsSync(defaultDir)) {
+                fs.mkdirSync(defaultDir, { recursive: true });
+            }
+            // Cũng set trong Preferences file
+            const prefsPath = path.join(defaultDir, 'Preferences');
+            let prefs = {};
+            if (fs.existsSync(prefsPath)) {
+                try {
+                    const prefsContent = fs.readFileSync(prefsPath, 'utf-8');
+                    prefs = JSON.parse(prefsContent);
+                }
+                catch (error) {
+                    // Ignore
+                }
+            }
+            if (!prefs.profile) {
+                prefs.profile = {};
+            }
+            prefs.profile.name = profileName;
+            fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Ignore errors - profile name is optional
+        }
+    }
     getProfile(profileId) {
         const metadataPath = this.getProfileMetadataPath(profileId);
         if (!fs.existsSync(metadataPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-nvk-browser",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "n8n nodes for managing Chrome browser profiles and page interactions",
   "keywords": [
     "n8n-community-node-package",