n8n-nodes-nvk-browser 1.0.76 → 1.0.78

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

@@ -51,7 +51,8 @@ exports.createProfileFields = [
             rows: 4,
         },
         default: '',
-        description: 'Chrome Store extension IDs or local paths, one per line',
+        placeholder: 'nmmhkkegccagdldgiimedpiccmgmieda\nhttps://example.com/extension.crx\n./extensions/my-extension',
+        description: 'Extensions to install: Chrome Store ID (32 chars), URL (http://...), or local path. One extension per line. Examples:\n- Chrome Store ID: nmmhkkegccagdldgiimedpiccmgmieda\n- URL: https://example.com/extension.crx\n- Local path: ./extensions/my-extension or /absolute/path/to/extension',
         displayOptions: {
             show: {
                 resource: ['profile'],

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

@@ -95,8 +95,29 @@ class CreateProfile {
                 const extensionsInput = this.getNodeParameter('extensions', i) || '';
                 // Parse extensions
                 const extensions = ExtensionHandler_1.ExtensionHandler.parseExtensions(extensionsInput);
-                // Tạo profile
-                const profile = profileManager.createProfile(profileName, proxy, note, extensions);
+                // Validate extensions và lấy resolved paths
+                const extensionPaths = [];
+                if (extensions.length > 0) {
+                    console.log(`[CreateProfile] Validating ${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}`);
+                            }
+                            else {
+                                console.error(`[CreateProfile] ✗ Extension validation failed: ${ext} - ${validation.error || 'Unknown error'}`);
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[CreateProfile] ✗ Error validating extension "${ext}":`, 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 đè
@@ -180,6 +201,7 @@ class CreateProfile {
                             proxy: profile.proxy,
                             note: profile.note,
                             extensions: profile.extensions,
+                            extensionPaths: profile.extensionPaths,
                             createdAt: profile.createdAt,
                         },
                     },

package/dist/utils/BrowserManager.js

@@ -97,8 +97,38 @@ class BrowserManager {
             args.push(...ProxyHandler_1.ProxyHandler.getChromeProxyArgs(proxyConfig));
         }
         // Extension configuration
-        if (profile.extensions && profile.extensions.length > 0) {
-            args.push(...ExtensionHandler_1.ExtensionHandler.getExtensionArgs(profile.extensions));
+        // 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
+            }
         }
         // Window configuration
         if (windowConfig) {

package/dist/utils/ExtensionHandler.d.ts

@@ -1,9 +1,70 @@
+interface ExtensionValidationResult {
+    valid: boolean;
+    path?: string;
+    error?: string;
+    type?: 'store-id' | 'url' | 'local-path';
+}
 export declare class ExtensionHandler {
+    private static readonly CACHE_DIR_NAME;
+    private static readonly DOWNLOAD_TIMEOUT;
+    private static readonly MAX_RETRIES;
+    /**
+     * Parse extensions từ input string (mỗi extension một dòng)
+     */
     static parseExtensions(extensionInput: string): string[];
-    static validateExtension(extension: string): {
-        valid: boolean;
-        path?: string;
-        error?: string;
-    };
-    static getExtensionArgs(extensions: string[]): string[];
+    /**
+     * Xác định loại extension: Chrome Store ID, URL, hoặc Local Path
+     */
+    private static detectExtensionType;
+    /**
+     * Validate và resolve extension path
+     */
+    static validateExtension(extension: string, workspacePath?: string): Promise<ExtensionValidationResult>;
+    /**
+     * Lấy cache directory path
+     */
+    private static getCacheDir;
+    /**
+     * Đảm bảo cache directory tồn tại
+     */
+    private static ensureCacheDir;
+    /**
+     * Tạo cache key từ extension identifier
+     */
+    private static getCacheKey;
+    /**
+     * Kiểm tra extension đã được cache chưa
+     */
+    private static getCachedExtensionPath;
+    /**
+     * Download file từ URL
+     */
+    private static downloadFile;
+    /**
+     * Extract CRX file
+     * CRX format: Header (magic number + version + pub key len + sig len + pub key + sig) + ZIP content
+     */
+    private static extractCrxFile;
+    /**
+     * Extract ZIP buffer to directory
+     */
+    private static extractZipBuffer;
+    /**
+     * Manual ZIP extraction
+     * Supports stored (method 0) and deflated (method 8) compression
+     */
+    private static extractZipManually;
+    /**
+     * Download extension từ Chrome Web Store
+     */
+    private static downloadAndExtractChromeStoreExtension;
+    /**
+     * Download và extract extension từ URL
+     */
+    private static downloadAndExtractExtensionFromUrl;
+    /**
+     * Get Chrome arguments để load extensions
+     */
+    static getExtensionArgs(extensions: string[], workspacePath?: string): Promise<string[]>;
 }
+export {};

package/dist/utils/ExtensionHandler.js

@@ -26,7 +26,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionHandler = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const zlib = __importStar(require("zlib"));
+const crypto = __importStar(require("crypto"));
 class ExtensionHandler {
+    /**
+     * Parse extensions từ input string (mỗi extension một dòng)
+     */
     static parseExtensions(extensionInput) {
         if (!extensionInput || !extensionInput.trim()) {
             return [];
@@ -38,49 +45,500 @@ class ExtensionHandler {
             .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 };
+    /**
+     * Xác định loại extension: Chrome Store ID, URL, hoặc Local Path
+     */
+    static detectExtensionType(extension) {
+        // Chrome Store ID: 32 ký tự alphanumeric
+        if (/^[a-z0-9]{32}$/i.test(extension)) {
+            return 'store-id';
+        }
+        // URL: bắt đầu với http:// hoặc https://
+        if (/^https?:\/\//i.test(extension)) {
+            return 'url';
+        }
+        // Local path
+        return 'local-path';
+    }
+    /**
+     * Validate và resolve extension path
+     */
+    static async validateExtension(extension, workspacePath) {
+        const type = this.detectExtensionType(extension);
+        if (type === 'store-id') {
+            // Chrome Store ID - cần download
+            try {
+                const extensionPath = await this.downloadAndExtractChromeStoreExtension(extension, workspacePath);
+                return { valid: true, path: extensionPath, type: 'store-id' };
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                    error: `Failed to download Chrome Store extension: ${error instanceof Error ? error.message : String(error)}`,
+                    type: 'store-id',
+                };
+            }
+        }
+        if (type === 'url') {
+            // URL - cần download
+            try {
+                const extensionPath = await this.downloadAndExtractExtensionFromUrl(extension, workspacePath);
+                return { valid: true, path: extensionPath, type: 'url' };
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                    error: `Failed to download extension from URL: ${error instanceof Error ? error.message : String(error)}`,
+                    type: 'url',
+                };
+            }
+        }
+        // Local path
+        let resolvedPath;
+        if (path.isAbsolute(extension)) {
+            resolvedPath = extension;
+        }
+        else if (extension.startsWith('./') || extension.startsWith('../')) {
+            resolvedPath = path.resolve(extension);
+        }
+        else {
+            // Relative path từ workspace
+            const basePath = workspacePath || path.resolve(__dirname, '..');
+            resolvedPath = path.resolve(basePath, extension);
+        }
+        if (!fs.existsSync(resolvedPath)) {
+            return {
+                valid: false,
+                error: `Extension path does not exist: ${resolvedPath}`,
+                type: 'local-path',
+            };
+        }
+        // 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, type: 'local-path' };
+        }
+        // Có thể là CRX file - cần extract
+        if (resolvedPath.toLowerCase().endsWith('.crx')) {
+            try {
+                const extractedPath = await this.extractCrxFile(resolvedPath, workspacePath);
+                return { valid: true, path: extractedPath, type: 'local-path' };
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                    error: `Failed to extract CRX file: ${error instanceof Error ? error.message : String(error)}`,
+                    type: 'local-path',
+                };
+            }
+        }
+        return {
+            valid: false,
+            error: 'Extension directory does not contain manifest.json',
+            type: 'local-path',
+        };
+    }
+    /**
+     * Lấy cache directory path
+     */
+    static getCacheDir(workspacePath) {
+        const basePath = workspacePath || path.resolve(__dirname, '..');
+        return path.join(basePath, '..', this.CACHE_DIR_NAME);
+    }
+    /**
+     * Đảm bảo cache directory tồn tại
+     */
+    static ensureCacheDir(workspacePath) {
+        const cacheDir = this.getCacheDir(workspacePath);
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        return cacheDir;
+    }
+    /**
+     * Tạo cache key từ extension identifier
+     */
+    static getCacheKey(identifier) {
+        return crypto.createHash('md5').update(identifier).digest('hex');
+    }
+    /**
+     * Kiểm tra extension đã được cache chưa
+     */
+    static getCachedExtensionPath(cacheKey, workspacePath) {
+        const cacheDir = this.getCacheDir(workspacePath);
+        const cachedPath = path.join(cacheDir, cacheKey);
+        const manifestPath = path.join(cachedPath, 'manifest.json');
+        if (fs.existsSync(manifestPath)) {
+            console.log(`[ExtensionHandler] Using cached extension: ${cachedPath}`);
+            return cachedPath;
+        }
+        return null;
+    }
+    /**
+     * Download file từ URL
+     */
+    static async downloadFile(url, outputPath, retries = this.MAX_RETRIES) {
+        return new Promise((resolve, reject) => {
+            const attemptDownload = (downloadUrl, attempt) => {
+                console.log(`[ExtensionHandler] Downloading ${downloadUrl} (attempt ${attempt}/${retries})...`);
+                const file = fs.createWriteStream(outputPath);
+                const protocol = downloadUrl.startsWith('https:') ? https : http;
+                const request = protocol.get(downloadUrl, (response) => {
+                    // Handle redirects
+                    if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308) {
+                        file.close();
+                        fs.unlinkSync(outputPath);
+                        if (response.headers.location) {
+                            const redirectUrl = response.headers.location.startsWith('http')
+                                ? response.headers.location
+                                : new URL(response.headers.location, downloadUrl).href;
+                            return attemptDownload(redirectUrl, attempt);
+                        }
+                    }
+                    if (response.statusCode !== 200) {
+                        file.close();
+                        fs.unlinkSync(outputPath);
+                        if (attempt < retries) {
+                            return attemptDownload(downloadUrl, attempt + 1);
+                        }
+                        return reject(new Error(`Download failed with status ${response.statusCode}`));
+                    }
+                    response.pipe(file);
+                    file.on('finish', () => {
+                        file.close();
+                        console.log(`[ExtensionHandler] Downloaded to ${outputPath}`);
+                        resolve();
+                    });
+                });
+                request.on('error', (error) => {
+                    file.close();
+                    if (fs.existsSync(outputPath)) {
+                        fs.unlinkSync(outputPath);
+                    }
+                    if (attempt < retries) {
+                        console.log(`[ExtensionHandler] Download error, retrying... (${error.message})`);
+                        setTimeout(() => attemptDownload(downloadUrl, attempt + 1), 1000 * attempt);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+                request.setTimeout(this.DOWNLOAD_TIMEOUT, () => {
+                    request.destroy();
+                    file.close();
+                    if (fs.existsSync(outputPath)) {
+                        fs.unlinkSync(outputPath);
+                    }
+                    if (attempt < retries) {
+                        attemptDownload(downloadUrl, attempt + 1);
+                    }
+                    else {
+                        reject(new Error('Download timeout'));
+                    }
+                });
+            };
+            attemptDownload(url, 1);
+        });
+    }
+    /**
+     * Extract CRX file
+     * CRX format: Header (magic number + version + pub key len + sig len + pub key + sig) + ZIP content
+     */
+    static async extractCrxFile(crxPath, workspacePath) {
+        const cacheKey = this.getCacheKey(`local-crx-${crxPath}`);
+        const cachedPath = this.getCachedExtensionPath(cacheKey, workspacePath);
+        if (cachedPath) {
+            return cachedPath;
+        }
+        console.log(`[ExtensionHandler] Extracting CRX file: ${crxPath}`);
+        const cacheDir = this.ensureCacheDir(workspacePath);
+        const outputDir = path.join(cacheDir, cacheKey);
+        if (fs.existsSync(outputDir)) {
+            fs.rmSync(outputDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(outputDir, { recursive: true });
+        const crxBuffer = fs.readFileSync(crxPath);
+        // Check magic number (Cr24 = 0x43723234)
+        const magic = crxBuffer.readUInt32LE(0);
+        if (magic !== 0x34327243) {
+            throw new Error('Invalid CRX file: wrong magic number');
+        }
+        // Read version (4 bytes at offset 4)
+        const version = crxBuffer.readUInt32LE(4);
+        if (version === 2) {
+            // CRX v2: magic (4) + version (4) + pub key len (4) + sig len (4) + pub key + sig + zip
+            const pubKeyLen = crxBuffer.readUInt32LE(8);
+            const sigLen = crxBuffer.readUInt32LE(12);
+            const headerSize = 16 + pubKeyLen + sigLen;
+            const zipBuffer = crxBuffer.slice(headerSize);
+            await this.extractZipBuffer(zipBuffer, outputDir);
+        }
+        else if (version === 3) {
+            // CRX v3: similar but with additional header
+            const headerSize = crxBuffer.readUInt32LE(8);
+            const zipBuffer = crxBuffer.slice(headerSize);
+            await this.extractZipBuffer(zipBuffer, outputDir);
+        }
+        else {
+            // Try to find ZIP header manually (PK\x03\x04)
+            let zipStart = -1;
+            for (let i = 0; i < crxBuffer.length - 4; i++) {
+                if (crxBuffer[i] === 0x50 &&
+                    crxBuffer[i + 1] === 0x4b &&
+                    crxBuffer[i + 2] === 0x03 &&
+                    crxBuffer[i + 3] === 0x04) {
+                    zipStart = i;
+                    break;
                 }
-                return { valid: false, error: 'Extension directory does not contain manifest.json' };
             }
-            return { valid: false, error: 'Extension path does not exist' };
+            if (zipStart === -1) {
+                throw new Error('Invalid CRX file: ZIP content not found');
+            }
+            const zipBuffer = crxBuffer.slice(zipStart);
+            await this.extractZipBuffer(zipBuffer, outputDir);
+        }
+        // Validate manifest.json
+        const manifestPath = path.join(outputDir, 'manifest.json');
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error('Extracted extension does not contain manifest.json');
         }
-        // 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 };
+        console.log(`[ExtensionHandler] Extracted CRX to: ${outputDir}`);
+        return outputDir;
+    }
+    /**
+     * Extract ZIP buffer to directory
+     */
+    static async extractZipBuffer(zipBuffer, outputDir) {
+        // ZIP files are not zlib-compressed, they have their own format
+        // Use manual extraction
+        return this.extractZipManually(zipBuffer, outputDir);
+    }
+    /**
+     * Manual ZIP extraction
+     * Supports stored (method 0) and deflated (method 8) compression
+     */
+    static async extractZipManually(zipBuffer, outputDir) {
+        const files = [];
+        let offset = 0;
+        // First pass: collect all file entries
+        while (offset < zipBuffer.length - 4) {
+            // Look for local file header signature (0x04034b50 = "PK\x03\x04")
+            if (zipBuffer[offset] !== 0x50 || zipBuffer[offset + 1] !== 0x4b) {
+                offset++;
+                continue;
+            }
+            const signature = zipBuffer.readUInt32LE(offset);
+            if (signature !== 0x04034b50) {
+                offset++;
+                continue;
+            }
+            // Read file header
+            const version = zipBuffer.readUInt16LE(offset + 4);
+            const flags = zipBuffer.readUInt16LE(offset + 6);
+            const method = zipBuffer.readUInt16LE(offset + 8);
+            const compressedSize = zipBuffer.readUInt32LE(offset + 18);
+            const uncompressedSize = zipBuffer.readUInt32LE(offset + 22);
+            const fileNameLength = zipBuffer.readUInt16LE(offset + 26);
+            const extraFieldLength = zipBuffer.readUInt16LE(offset + 28);
+            if (offset + 30 + fileNameLength + extraFieldLength > zipBuffer.length) {
+                break;
             }
-            return { valid: false, error: 'Extension directory does not contain manifest.json' };
+            const fileName = zipBuffer
+                .slice(offset + 30, offset + 30 + fileNameLength)
+                .toString('utf-8')
+                .replace(/\\/g, '/'); // Normalize path separators
+            const dataOffset = offset + 30 + fileNameLength + extraFieldLength;
+            if (dataOffset + compressedSize > zipBuffer.length) {
+                break;
+            }
+            const fileData = zipBuffer.slice(dataOffset, dataOffset + compressedSize);
+            if (!fileName.endsWith('/')) {
+                files.push({
+                    name: fileName,
+                    data: fileData,
+                    method: method,
+                });
+            }
+            offset = dataOffset + compressedSize;
+        }
+        // Second pass: extract files
+        for (const file of files) {
+            try {
+                const filePath = path.join(outputDir, file.name);
+                const dir = path.dirname(filePath);
+                // Skip if path traversal attempt
+                if (!filePath.startsWith(path.resolve(outputDir))) {
+                    console.warn(`[ExtensionHandler] Skipping potentially dangerous path: ${file.name}`);
+                    continue;
+                }
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                let extractedData;
+                if (file.method === 0) {
+                    // Stored (no compression)
+                    extractedData = file.data;
+                }
+                else if (file.method === 8) {
+                    // Deflated - use zlib
+                    try {
+                        extractedData = zlib.inflateRawSync(file.data);
+                    }
+                    catch (error) {
+                        console.warn(`[ExtensionHandler] Failed to inflate ${file.name}, trying stored method`);
+                        extractedData = file.data;
+                    }
+                }
+                else {
+                    console.warn(`[ExtensionHandler] Unsupported compression method ${file.method} for ${file.name}, skipping`);
+                    continue;
+                }
+                fs.writeFileSync(filePath, extractedData);
+            }
+            catch (error) {
+                console.warn(`[ExtensionHandler] Error extracting file ${file.name}:`, error);
+                // Continue with other files
+            }
+        }
+        if (files.length === 0) {
+            throw new Error('No valid files found in ZIP archive');
         }
-        return { valid: false, error: 'Invalid extension format. Must be Chrome Store ID or valid path' };
     }
-    static getExtensionArgs(extensions) {
+    /**
+     * Download extension từ Chrome Web Store
+     */
+    static async downloadAndExtractChromeStoreExtension(extensionId, workspacePath) {
+        const cacheKey = this.getCacheKey(extensionId);
+        const cachedPath = this.getCachedExtensionPath(cacheKey, workspacePath);
+        if (cachedPath) {
+            return cachedPath;
+        }
+        console.log(`[ExtensionHandler] Downloading Chrome Store extension: ${extensionId}`);
+        const cacheDir = this.ensureCacheDir(workspacePath);
+        const tempCrxPath = path.join(cacheDir, `${cacheKey}.crx`);
+        const outputDir = path.join(cacheDir, cacheKey);
+        try {
+            // Chrome Web Store download URL
+            const downloadUrl = `https://clients2.google.com/service/update2/crx?response=redirect&x=id%3D${extensionId}%26uc`;
+            // Download CRX file
+            await this.downloadFile(downloadUrl, tempCrxPath);
+            // Extract CRX
+            const extractedPath = await this.extractCrxFile(tempCrxPath, workspacePath);
+            // Move to cache directory with proper name
+            if (extractedPath !== outputDir) {
+                if (fs.existsSync(outputDir)) {
+                    fs.rmSync(outputDir, { recursive: true, force: true });
+                }
+                fs.renameSync(extractedPath, outputDir);
+            }
+            // Clean up temp CRX file
+            if (fs.existsSync(tempCrxPath)) {
+                fs.unlinkSync(tempCrxPath);
+            }
+            return outputDir;
+        }
+        catch (error) {
+            // Clean up on error
+            if (fs.existsSync(tempCrxPath)) {
+                fs.unlinkSync(tempCrxPath);
+            }
+            if (fs.existsSync(outputDir)) {
+                fs.rmSync(outputDir, { recursive: true, force: true });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Download và extract extension từ URL
+     */
+    static async downloadAndExtractExtensionFromUrl(url, workspacePath) {
+        const cacheKey = this.getCacheKey(url);
+        const cachedPath = this.getCachedExtensionPath(cacheKey, workspacePath);
+        if (cachedPath) {
+            return cachedPath;
+        }
+        console.log(`[ExtensionHandler] Downloading extension from URL: ${url}`);
+        const cacheDir = this.ensureCacheDir(workspacePath);
+        const tempFilePath = path.join(cacheDir, `${cacheKey}.tmp`);
+        const outputDir = path.join(cacheDir, cacheKey);
+        try {
+            // Download file
+            await this.downloadFile(url, tempFilePath);
+            // Determine file type and extract
+            const fullBuffer = fs.readFileSync(tempFilePath);
+            const fileHeader = fullBuffer.slice(0, 4);
+            const headerStr = fileHeader.toString('ascii', 0, 4);
+            const isCrx = url.toLowerCase().endsWith('.crx') || headerStr === 'Cr24';
+            if (isCrx || tempFilePath.toLowerCase().endsWith('.crx')) {
+                // Extract CRX
+                const extractedPath = await this.extractCrxFile(tempFilePath, workspacePath);
+                if (extractedPath !== outputDir) {
+                    if (fs.existsSync(outputDir)) {
+                        fs.rmSync(outputDir, { recursive: true, force: true });
+                    }
+                    fs.renameSync(extractedPath, outputDir);
+                }
+            }
+            else {
+                // Try as ZIP
+                const zipBuffer = fs.readFileSync(tempFilePath);
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+                await this.extractZipManually(zipBuffer, outputDir);
+                // Validate manifest.json
+                const manifestPath = path.join(outputDir, 'manifest.json');
+                if (!fs.existsSync(manifestPath)) {
+                    throw new Error('Downloaded file does not contain manifest.json');
+                }
+            }
+            // Clean up temp file
+            if (fs.existsSync(tempFilePath)) {
+                fs.unlinkSync(tempFilePath);
+            }
+            return outputDir;
+        }
+        catch (error) {
+            // Clean up on error
+            if (fs.existsSync(tempFilePath)) {
+                fs.unlinkSync(tempFilePath);
+            }
+            if (fs.existsSync(outputDir)) {
+                fs.rmSync(outputDir, { recursive: true, force: true });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get Chrome arguments để load extensions
+     */
+    static async getExtensionArgs(extensions, workspacePath) {
         const args = [];
         const validPaths = [];
         for (const ext of extensions) {
-            const validation = this.validateExtension(ext);
-            if (validation.valid && validation.path) {
-                validPaths.push(validation.path);
+            try {
+                console.log(`[ExtensionHandler] Processing extension: ${ext}`);
+                const validation = await this.validateExtension(ext, workspacePath);
+                if (validation.valid && validation.path) {
+                    validPaths.push(validation.path);
+                    console.log(`[ExtensionHandler] ✓ Extension validated: ${validation.path}`);
+                }
+                else {
+                    console.error(`[ExtensionHandler] ✗ Extension validation failed: ${validation.error}`);
+                }
+            }
+            catch (error) {
+                console.error(`[ExtensionHandler] ✗ Error processing extension "${ext}":`, error);
             }
-            // Chrome Store IDs sẽ được load sau khi browser khởi động
         }
         if (validPaths.length > 0) {
             args.push(`--load-extension=${validPaths.join(',')}`);
+            console.log(`[ExtensionHandler] Load extensions: ${validPaths.length} extension(s)`);
         }
         return args;
     }
 }
+ExtensionHandler.CACHE_DIR_NAME = 'extensions-cache';
+ExtensionHandler.DOWNLOAD_TIMEOUT = 30000; // 30 seconds
+ExtensionHandler.MAX_RETRIES = 3;
 exports.ExtensionHandler = ExtensionHandler;

package/dist/utils/ProfileManager.d.ts

@@ -5,7 +5,7 @@ export declare class ProfileManager {
     private ensureProfilesDir;
     private getProfileMetadataPath;
     private getProfileDir;
-    createProfile(name: string, proxy?: string, note?: string, extensions?: string[]): ProfileData;
+    createProfile(name: string, proxy?: string, note?: string, extensions?: string[], extensionPaths?: string[]): ProfileData;
     private setProfileName;
     getProfile(profileId: string): ProfileData | null;
     getAllProfiles(): ProfileData[];

package/dist/utils/ProfileManager.js

@@ -43,7 +43,7 @@ class ProfileManager {
     getProfileDir(profileId) {
         return path.join(this.profilesDir, profileId);
     }
-    createProfile(name, proxy, note, extensions) {
+    createProfile(name, proxy, note, extensions, extensionPaths) {
         const profileId = (0, uuid_1.v4)();
         const profileDir = this.getProfileDir(profileId);
         // Tạo thư mục profile
@@ -54,6 +54,7 @@ class ProfileManager {
             proxy,
             note,
             extensions: extensions || [],
+            extensionPaths: extensionPaths || [],
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         };

package/dist/utils/types.d.ts

@@ -4,6 +4,7 @@ export interface ProfileData {
     proxy?: string;
     note?: string;
     extensions?: string[];
+    extensionPaths?: string[];
     createdAt: string;
     updatedAt: string;
 }

package/package.json

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