n8n-nodes-nvk-browser 1.0.78 → 1.0.79

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

@@ -95,29 +95,48 @@ class CreateProfile {
                 const extensionsInput = this.getNodeParameter('extensions', i) || '';
                 // Parse extensions
                 const extensions = ExtensionHandler_1.ExtensionHandler.parseExtensions(extensionsInput);
-                // Validate extensions và lấy resolved paths
-                const extensionPaths = [];
+                // Tạo profile trước (để có profilePath)
+                const profile = profileManager.createProfile(profileName, proxy, note, extensions, [] // extensionPaths sẽ được set sau
+                );
+                const profilePath = profileManager.getProfilePath(profile.id);
+                // Validate và install extensions vào profile
+                const extensionInfos = [];
                 if (extensions.length > 0) {
-                    console.log(`[CreateProfile] Validating ${extensions.length} extension(s)...`);
+                    console.log(`[CreateProfile] Validating and installing ${extensions.length} extension(s)...`);
                     for (const ext of extensions) {
                         try {
-                            const validation = await ExtensionHandler_1.ExtensionHandler.validateExtension(ext, resolvedProfilesDir);
-                            if (validation.valid && validation.path) {
-                                extensionPaths.push(validation.path);
-                                console.log(`[CreateProfile] ✓ Extension validated: ${ext} -> ${validation.path}`);
+                            // Validate extension và lấy info
+                            const validation = await ExtensionHandler_1.ExtensionHandler.validateAndGetExtensionInfo(ext, resolvedProfilesDir);
+                            if (validation.valid && validation.path && validation.extensionId) {
+                                // Install extension vào profile Extensions directory
+                                const extensionInfo = await ExtensionHandler_1.ExtensionHandler.installExtensionToProfile(validation.path, profilePath, ext);
+                                extensionInfos.push({
+                                    extensionId: extensionInfo.extensionId,
+                                    version: extensionInfo.version,
+                                    path: extensionInfo.path,
+                                });
+                                console.log(`[CreateProfile] ✓ Extension installed: ${ext} -> ${extensionInfo.extensionId} v${extensionInfo.version}`);
                             }
                             else {
                                 console.error(`[CreateProfile] ✗ Extension validation failed: ${ext} - ${validation.error || 'Unknown error'}`);
                             }
                         }
                         catch (error) {
-                            console.error(`[CreateProfile] ✗ Error validating extension "${ext}":`, error);
+                            console.error(`[CreateProfile] ✗ Error installing extension "${ext}":`, error);
+                        }
+                    }
+                    console.log(`[CreateProfile] Successfully installed ${extensionInfos.length}/${extensions.length} extension(s)`);
+                    // Lưu extension configuration vào Preferences
+                    if (extensionInfos.length > 0) {
+                        try {
+                            profileManager.saveExtensionsToPreferences(profilePath, extensionInfos);
+                            console.log(`[CreateProfile] ✓ Extension configurations saved to Preferences`);
+                        }
+                        catch (error) {
+                            console.error(`[CreateProfile] ✗ Error saving extension configurations:`, error);
                         }
                     }
-                    console.log(`[CreateProfile] Successfully validated ${extensionPaths.length}/${extensions.length} extension(s)`);
                 }
-                // Tạo profile với cả extensionPaths đã resolve
-                const profile = profileManager.createProfile(profileName, proxy, note, extensions, extensionPaths);
                 // Lưu proxy authentication vào profile nếu có
                 // QUAN TRỌNG: Phải gọi SAU khi createProfile và setProfileName để Preferences file đã được tạo
                 // Nhưng phải đảm bảo không bị ghi đè

package/dist/utils/BrowserManager.js

@@ -31,7 +31,6 @@ 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");
 const ProfileManager_1 = require("./ProfileManager");
 class BrowserManager {
     constructor(browserPath, profilesDir) {
@@ -91,43 +90,25 @@ class BrowserManager {
             '--disable-dev-shm-usage',
             '--no-sandbox',
             '--disable-setuid-sandbox',
+            '--enable-extensions', // Cho phép extensions
         ];
         // Proxy configuration - KHÔNG bao gồm credentials trong URL
         if (proxyConfig) {
             args.push(...ProxyHandler_1.ProxyHandler.getChromeProxyArgs(proxyConfig));
         }
         // Extension configuration
-        // Sử dụng extensionPaths đã resolve thay vì validate lại
-        if (profile.extensionPaths && profile.extensionPaths.length > 0) {
-            // Kiểm tra paths còn tồn tại không
-            const validPaths = [];
-            for (const extPath of profile.extensionPaths) {
-                const manifestPath = path.join(extPath, 'manifest.json');
-                if (fs.existsSync(manifestPath)) {
-                    validPaths.push(extPath);
-                }
-                else {
-                    console.warn(`[BrowserManager] Extension path no longer valid (missing manifest.json): ${extPath}`);
-                }
-            }
-            if (validPaths.length > 0) {
-                args.push(`--load-extension=${validPaths.join(',')}`);
-                console.log(`[BrowserManager] Loading ${validPaths.length} extension(s) from cached paths`);
-            }
-            else {
-                console.warn(`[BrowserManager] No valid extension paths found, skipping extensions`);
-            }
-        }
-        else if (profile.extensions && profile.extensions.length > 0) {
-            // Fallback: Nếu không có extensionPaths, validate lại (cho backward compatibility)
-            console.log(`[BrowserManager] No extensionPaths found, validating extensions on-the-fly (legacy mode)`);
-            try {
-                const extensionArgs = await ExtensionHandler_1.ExtensionHandler.getExtensionArgs(profile.extensions, this.profilesDir);
-                args.push(...extensionArgs);
-            }
-            catch (error) {
-                console.error(`[BrowserManager] Error loading extensions:`, error);
-                // Continue without extensions rather than failing completely
+        // Extensions đã được install vào profile/Default/Extensions/ nên không cần --load-extension
+        // Chrome sẽ tự động load từ Preferences và Extensions directory
+        const extensionsDir = path.join(profilePath, 'Default', 'Extensions');
+        if (fs.existsSync(extensionsDir)) {
+            const extensionDirs = fs.readdirSync(extensionsDir).filter((dir) => {
+                const dirPath = path.join(extensionsDir, dir);
+                return fs.statSync(dirPath).isDirectory();
+            });
+            if (extensionDirs.length > 0) {
+                console.log(`[BrowserManager] Found ${extensionDirs.length} extension(s) installed in profile Extensions directory`);
+                // Extensions sẽ được load tự động từ Preferences và Extensions directory
+                // Không cần --load-extension vì đã có trong profile
             }
         }
         // Window configuration

package/dist/utils/ExtensionHandler.d.ts

@@ -3,6 +3,14 @@ interface ExtensionValidationResult {
     path?: string;
     error?: string;
     type?: 'store-id' | 'url' | 'local-path';
+    extensionId?: string;
+    version?: string;
+}
+interface ExtensionInfo {
+    extensionId: string;
+    version: string;
+    path: string;
+    manifest: any;
 }
 export declare class ExtensionHandler {
     private static readonly CACHE_DIR_NAME;
@@ -62,6 +70,40 @@ export declare class ExtensionHandler {
      * Download và extract extension từ URL
      */
     private static downloadAndExtractExtensionFromUrl;
+    /**
+     * Đọc và parse manifest.json từ extension path
+     */
+    private static readManifest;
+    /**
+     * Lấy extension ID từ manifest.json
+     * Nếu là Chrome Store ID thì dùng ID đó, nếu không thì generate từ manifest key
+     */
+    private static getExtensionId;
+    /**
+     * Lấy version từ manifest.json
+     */
+    private static getExtensionVersion;
+    /**
+     * Copy extension vào profile Extensions directory
+     * Structure: {profile}/Default/Extensions/{extension-id}/{version}/
+     */
+    static installExtensionToProfile(extensionPath: string, profilePath: string, originalExtensionInput?: string): Promise<ExtensionInfo>;
+    /**
+     * Copy directory recursively
+     */
+    private static copyDirectory;
+    /**
+     * Tạo verified_contents.json structure
+     */
+    private static createVerifiedContents;
+    /**
+     * Validate extension và lấy thông tin chi tiết
+     */
+    static validateAndGetExtensionInfo(extension: string, workspacePath?: string): Promise<ExtensionValidationResult & {
+        extensionId?: string;
+        version?: string;
+        manifest?: any;
+    }>;
     /**
      * Get Chrome arguments để load extensions
      */

package/dist/utils/ExtensionHandler.js

@@ -509,6 +509,198 @@ class ExtensionHandler {
             throw error;
         }
     }
+    /**
+     * Đọc và parse manifest.json từ extension path
+     */
+    static readManifest(extensionPath) {
+        const manifestPath = path.join(extensionPath, 'manifest.json');
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error('manifest.json not found');
+        }
+        const content = fs.readFileSync(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    /**
+     * Lấy extension ID từ manifest.json
+     * Nếu là Chrome Store ID thì dùng ID đó, nếu không thì generate từ manifest key
+     */
+    static getExtensionId(manifest, originalExtensionInput) {
+        // Nếu input là Chrome Store ID (32 chars), dùng nó
+        if (originalExtensionInput && /^[a-z0-9]{32}$/i.test(originalExtensionInput)) {
+            return originalExtensionInput.toLowerCase();
+        }
+        // Nếu manifest có key (public key), generate ID từ key theo cách Chrome làm
+        if (manifest.key) {
+            try {
+                // Chrome extension ID được generate từ public key PEM
+                // Format: Base32 encoding của first 128 bits (16 bytes) của SHA256(public key)
+                let keyData = manifest.key;
+                let keyString = '';
+                // Nếu key là string (PEM format hoặc base64)
+                if (typeof keyData === 'string') {
+                    keyString = keyData;
+                }
+                else if (Array.isArray(keyData) || Buffer.isBuffer(keyData)) {
+                    keyString = Buffer.from(keyData).toString('base64');
+                }
+                if (keyString) {
+                    // Parse PEM nếu có
+                    if (keyString.includes('-----BEGIN')) {
+                        // Extract base64 content từ PEM
+                        const pemMatch = keyString.match(/-----BEGIN[^-]+-----([\s\S]*)-----END[^-]+-----/);
+                        if (pemMatch) {
+                            keyString = pemMatch[1].replace(/\s/g, '');
+                        }
+                    }
+                    // SHA256 hash của public key
+                    const hash = crypto.createHash('sha256').update(keyString).digest();
+                    // Base32 encode first 16 bytes (128 bits)
+                    const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
+                    let extensionId = '';
+                    let bits = 0;
+                    let value = 0;
+                    for (let i = 0; i < 16; i++) {
+                        value = (value << 8) | hash[i];
+                        bits += 8;
+                        while (bits >= 5) {
+                            extensionId += base32Chars[(value >>> (bits - 5)) & 31];
+                            bits -= 5;
+                        }
+                    }
+                    if (bits > 0) {
+                        extensionId += base32Chars[(value << (5 - bits)) & 31];
+                    }
+                    // Chrome extension ID luôn là 32 ký tự
+                    return extensionId.substring(0, 32).toLowerCase();
+                }
+            }
+            catch (error) {
+                console.warn(`[ExtensionHandler] Could not generate ID from key:`, error);
+            }
+        }
+        // Fallback: Generate ID từ manifest (name + path hash) - luôn tạo 32 ký tự
+        const name = manifest.name || 'extension';
+        const version = manifest.version || '1.0.0';
+        // Dùng SHA256 và lấy 32 ký tự đầu tiên (hex)
+        const hash = crypto
+            .createHash('sha256')
+            .update(`${name}${version}${Date.now()}`)
+            .digest('hex')
+            .substring(0, 32);
+        return hash;
+    }
+    /**
+     * Lấy version từ manifest.json
+     */
+    static getExtensionVersion(manifest) {
+        return manifest.version || '1.0.0';
+    }
+    /**
+     * Copy extension vào profile Extensions directory
+     * Structure: {profile}/Default/Extensions/{extension-id}/{version}/
+     */
+    static async installExtensionToProfile(extensionPath, profilePath, originalExtensionInput) {
+        console.log(`[ExtensionHandler] Installing extension to profile: ${extensionPath} -> ${profilePath}`);
+        // Đọc manifest
+        const manifest = this.readManifest(extensionPath);
+        const extensionId = this.getExtensionId(manifest, originalExtensionInput);
+        const version = this.getExtensionVersion(manifest);
+        // Tạo Extensions directory structure
+        const extensionsDir = path.join(profilePath, 'Default', 'Extensions');
+        if (!fs.existsSync(extensionsDir)) {
+            fs.mkdirSync(extensionsDir, { recursive: true });
+        }
+        const extensionIdDir = path.join(extensionsDir, extensionId);
+        if (!fs.existsSync(extensionIdDir)) {
+            fs.mkdirSync(extensionIdDir, { recursive: true });
+        }
+        // Version directory (format: {version}_0)
+        const versionDir = path.join(extensionIdDir, `${version}_0`);
+        if (fs.existsSync(versionDir)) {
+            // Nếu đã tồn tại, xóa và copy lại
+            fs.rmSync(versionDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(versionDir, { recursive: true });
+        // Copy tất cả files từ extensionPath vào versionDir
+        this.copyDirectory(extensionPath, versionDir);
+        // Tạo _metadata directory và verified_contents.json
+        const metadataDir = path.join(versionDir, '_metadata');
+        fs.mkdirSync(metadataDir, { recursive: true });
+        // Tạo verified_contents.json (simplified version)
+        const verifiedContents = this.createVerifiedContents(extensionId, version, versionDir);
+        const verifiedContentsPath = path.join(metadataDir, 'verified_contents.json');
+        fs.writeFileSync(verifiedContentsPath, JSON.stringify(verifiedContents, null, 2), 'utf-8');
+        console.log(`[ExtensionHandler] ✓ Extension installed: ${extensionId} v${version} -> ${versionDir}`);
+        return {
+            extensionId,
+            version,
+            path: versionDir,
+            manifest,
+        };
+    }
+    /**
+     * Copy directory recursively
+     */
+    static copyDirectory(src, dest) {
+        if (!fs.existsSync(src)) {
+            throw new Error(`Source directory does not exist: ${src}`);
+        }
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                // Skip _metadata if copying from another profile
+                if (entry.name === '_metadata' && fs.existsSync(destPath)) {
+                    continue;
+                }
+                fs.mkdirSync(destPath, { recursive: true });
+                this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    /**
+     * Tạo verified_contents.json structure
+     */
+    static createVerifiedContents(extensionId, version, extensionPath) {
+        // Simplified verified_contents - Chrome sẽ tự verify khi cần
+        // Đây là format cơ bản, Chrome có thể tự generate lại khi cần
+        return [
+            {
+                description: 'treehash per file',
+                signed_content: {
+                    payload: '',
+                    signatures: [],
+                },
+            },
+        ];
+    }
+    /**
+     * Validate extension và lấy thông tin chi tiết
+     */
+    static async validateAndGetExtensionInfo(extension, workspacePath) {
+        const validation = await this.validateExtension(extension, workspacePath);
+        if (validation.valid && validation.path) {
+            try {
+                const manifest = this.readManifest(validation.path);
+                const extensionId = this.getExtensionId(manifest, extension);
+                const version = this.getExtensionVersion(manifest);
+                return {
+                    ...validation,
+                    extensionId,
+                    version,
+                };
+            }
+            catch (error) {
+                console.warn(`[ExtensionHandler] Could not read extension info:`, error);
+                return validation;
+            }
+        }
+        return validation;
+    }
     /**
      * Get Chrome arguments để load extensions
      */

package/dist/utils/ProfileManager.d.ts

@@ -29,4 +29,13 @@ export declare class ProfileManager {
      * Đảm bảo file tồn tại và có cấu trúc gologin đầy đủ
      */
     private initializePreferencesFile;
+    /**
+     * Lưu extension configuration vào Preferences file
+     */
+    saveExtensionsToPreferences(profilePath: string, extensions: Array<{
+        extensionId: string;
+        version: string;
+        path: string;
+        manifest?: any;
+    }>): void;
 }

package/dist/utils/ProfileManager.js

@@ -643,5 +643,88 @@ class ProfileManager {
             // Ignore errors - initialization is optional
         }
     }
+    /**
+     * Lưu extension configuration vào Preferences file
+     */
+    saveExtensionsToPreferences(profilePath, extensions) {
+        try {
+            const prefsPath = path.join(profilePath, 'Default', 'Preferences');
+            let prefs = {};
+            if (fs.existsSync(prefsPath)) {
+                try {
+                    const prefsContent = fs.readFileSync(prefsPath, 'utf-8');
+                    prefs = JSON.parse(prefsContent);
+                }
+                catch (error) {
+                    console.error(`[ProfileManager] Error reading Preferences:`, error);
+                    return;
+                }
+            }
+            // Khởi tạo extensions structure
+            if (!prefs.extensions) {
+                prefs.extensions = {};
+            }
+            if (!prefs.extensions.settings) {
+                prefs.extensions.settings = {};
+            }
+            if (!prefs.extensions.preferences) {
+                prefs.extensions.preferences = {};
+            }
+            // Lưu từng extension
+            const extensionIds = [];
+            for (const ext of extensions) {
+                const extensionId = ext.extensionId;
+                extensionIds.push(extensionId);
+                // Đọc manifest nếu chưa có
+                let manifest = ext.manifest;
+                if (!manifest) {
+                    try {
+                        const manifestPath = path.join(ext.path, 'manifest.json');
+                        if (fs.existsSync(manifestPath)) {
+                            const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+                            manifest = JSON.parse(manifestContent);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`[ProfileManager] Could not read manifest for ${extensionId}:`, error);
+                    }
+                }
+                // Tính relative path từ Default directory
+                const relativePath = path.relative(path.join(profilePath, 'Default'), ext.path).replace(/\\/g, '/');
+                // Cấu hình extension settings
+                prefs.extensions.settings[extensionId] = {
+                    location: 1,
+                    creation_flags: 1,
+                    path: relativePath,
+                    state: 1,
+                    incognito: 0,
+                    manifest: manifest || {},
+                    granted_permissions: manifest?.permissions || [],
+                    withheld_permissions: [],
+                    disable_reasons: 0,
+                    installation_timestamp: Date.now(),
+                    update_url: '',
+                };
+                console.log(`[ProfileManager] ✓ Configured extension ${extensionId} in Preferences`);
+            }
+            // Lưu danh sách extension IDs
+            prefs.extensions.preferences = {
+                ...prefs.extensions.preferences,
+                extensions: {
+                    ...(prefs.extensions.preferences.extensions || {}),
+                    ui: {
+                        developer_mode: false,
+                    },
+                },
+            };
+            // Lưu lại Preferences
+            fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2), 'utf-8');
+            console.log(`[ProfileManager] ✓ Saved ${extensionIds.length} extension(s) to Preferences`);
+        }
+        catch (error) {
+            console.error(`[ProfileManager] Error saving extensions to Preferences:`, error);
+            throw error;
+        }
+    }
 }
 exports.ProfileManager = ProfileManager;

package/package.json

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