brave-real-launcher 1.2.31 → 1.2.33

package/dist/brave-installer.mjs

@@ -0,0 +1,323 @@
+/**
+ * @license Copyright 2024 Brave Real Launcher Contributors.
+ * Licensed under the Apache License, Version 2.0
+ *
+ * Brave Browser Installer
+ * Auto-installs Brave browser on Windows, Linux, and macOS
+ */
+'use strict';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import log from './logger.mjs';
+import { getPlatform } from './utils.mjs';
+const BRAVE_DOWNLOAD_URLS = {
+    win32: {
+        release: 'https://laptop-updates.brave.com/latest/winx64',
+        beta: 'https://laptop-updates.brave.com/latest/winx64-beta',
+        nightly: 'https://laptop-updates.brave.com/latest/winx64-nightly'
+    },
+    darwin: {
+        release: 'https://laptop-updates.brave.com/latest/osx',
+        beta: 'https://laptop-updates.brave.com/latest/osx-beta',
+        nightly: 'https://laptop-updates.brave.com/latest/osx-nightly'
+    }
+};
+export class BraveInstaller {
+    constructor(options = {}) {
+        this.silent = options.silent || false;
+        this.downloadDir = options.downloadDir || path.join(homedir(), '.brave-real-launcher', 'downloads');
+        this.channel = options.channel || 'release';
+        if (!fs.existsSync(this.downloadDir)) {
+            fs.mkdirSync(this.downloadDir, { recursive: true });
+        }
+    }
+    /**
+     * Install Brave browser on the current platform
+     */
+    async install() {
+        const platform = getPlatform();
+        if (!this.silent) {
+            log.log('BraveInstaller', `Installing Brave Browser on ${platform}...`);
+        }
+        try {
+            switch (platform) {
+                case 'win32':
+                    return await this.installWindows();
+                case 'linux':
+                    return await this.installLinux();
+                case 'darwin':
+                    return await this.installMacOS();
+                default:
+                    return { success: false, error: `Unsupported platform: ${platform}` };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Install Brave on Windows
+     */
+    async installWindows() {
+        const installerPath = path.join(this.downloadDir, 'BraveBrowserSetup.exe');
+        const downloadUrl = BRAVE_DOWNLOAD_URLS.win32[this.channel];
+        if (!this.silent) {
+            log.log('BraveInstaller', 'Downloading Brave installer for Windows...');
+        }
+        // Download installer
+        await this.downloadFile(downloadUrl, installerPath);
+        if (!this.silent) {
+            log.log('BraveInstaller', 'Running Brave installer (silent mode)...');
+        }
+        // Run installer silently
+        try {
+            execSync(`"${installerPath}" /silent /install`, {
+                stdio: 'ignore',
+                timeout: 300000 // 5 minutes timeout
+            });
+        }
+        catch (error) {
+            // Try alternative silent flags
+            try {
+                execSync(`"${installerPath}" --system-level --do-not-launch-chrome`, {
+                    stdio: 'ignore',
+                    timeout: 300000
+                });
+            }
+            catch (e) {
+                // Installation might still succeed, continue checking
+            }
+        }
+        // Wait for installation to complete
+        await this.delay(5000);
+        // Find Brave installation
+        const bravePath = this.findBraveWindows();
+        if (bravePath) {
+            if (!this.silent) {
+                log.log('BraveInstaller', `Brave installed successfully at: ${bravePath}`);
+            }
+            // Cleanup installer
+            try {
+                fs.unlinkSync(installerPath);
+            }
+            catch (e) { }
+            return { success: true, bravePath };
+        }
+        return { success: false, error: 'Installation completed but Brave not found' };
+    }
+    /**
+     * Install Brave on Linux
+     */
+    async installLinux() {
+        if (!this.silent) {
+            log.log('BraveInstaller', 'Installing Brave on Linux...');
+        }
+        // Detect package manager
+        const packageManager = this.detectLinuxPackageManager();
+        try {
+            if (packageManager === 'apt') {
+                // Debian/Ubuntu based
+                execSync('sudo apt install -y curl', { stdio: 'ignore' });
+                execSync('sudo curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg', { stdio: 'ignore' });
+                execSync('echo "deb [signed-by=/usr/share/keyrings/brave-browser-archive-keyring.gpg] https://brave-browser-apt-release.s3.brave.com/ stable main" | sudo tee /etc/apt/sources.list.d/brave-browser-release.list', { stdio: 'ignore' });
+                execSync('sudo apt update', { stdio: 'ignore' });
+                execSync('sudo apt install -y brave-browser', { stdio: 'ignore' });
+            }
+            else if (packageManager === 'dnf' || packageManager === 'yum') {
+                // Fedora/RHEL based
+                execSync('sudo dnf install -y dnf-plugins-core', { stdio: 'ignore' });
+                execSync('sudo dnf config-manager --add-repo https://brave-browser-rpm-release.s3.brave.com/brave-browser.repo', { stdio: 'ignore' });
+                execSync('sudo rpm --import https://brave-browser-rpm-release.s3.brave.com/brave-core.asc', { stdio: 'ignore' });
+                execSync('sudo dnf install -y brave-browser', { stdio: 'ignore' });
+            }
+            else if (packageManager === 'pacman') {
+                // Arch based
+                execSync('yay -S --noconfirm brave-bin', { stdio: 'ignore' });
+            }
+            else {
+                return { success: false, error: `Unsupported package manager. Please install Brave manually.` };
+            }
+            // Find Brave installation
+            const bravePath = this.findBraveLinux();
+            if (bravePath) {
+                if (!this.silent) {
+                    log.log('BraveInstaller', `Brave installed successfully at: ${bravePath}`);
+                }
+                return { success: true, bravePath };
+            }
+            return { success: false, error: 'Installation completed but Brave not found' };
+        }
+        catch (error) {
+            return { success: false, error: `Linux installation failed: ${error.message}` };
+        }
+    }
+    /**
+     * Install Brave on macOS
+     */
+    async installMacOS() {
+        var _a;
+        const dmgPath = path.join(this.downloadDir, 'Brave-Browser.dmg');
+        const downloadUrl = BRAVE_DOWNLOAD_URLS.darwin[this.channel];
+        if (!this.silent) {
+            log.log('BraveInstaller', 'Downloading Brave for macOS...');
+        }
+        // Download DMG
+        await this.downloadFile(downloadUrl, dmgPath);
+        if (!this.silent) {
+            log.log('BraveInstaller', 'Installing Brave...');
+        }
+        try {
+            // Mount DMG
+            const mountOutput = execSync(`hdiutil attach "${dmgPath}" -nobrowse`, { encoding: 'utf-8' });
+            const mountPoint = ((_a = mountOutput.split('\t').pop()) === null || _a === void 0 ? void 0 : _a.trim()) || '/Volumes/Brave Browser';
+            // Copy to Applications
+            execSync(`cp -R "${mountPoint}/Brave Browser.app" /Applications/`, { stdio: 'ignore' });
+            // Unmount DMG
+            execSync(`hdiutil detach "${mountPoint}"`, { stdio: 'ignore' });
+            // Cleanup
+            try {
+                fs.unlinkSync(dmgPath);
+            }
+            catch (e) { }
+            const bravePath = '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser';
+            if (fs.existsSync(bravePath)) {
+                if (!this.silent) {
+                    log.log('BraveInstaller', `Brave installed successfully at: ${bravePath}`);
+                }
+                return { success: true, bravePath };
+            }
+            return { success: false, error: 'Installation completed but Brave not found' };
+        }
+        catch (error) {
+            return { success: false, error: `macOS installation failed: ${error.message}` };
+        }
+    }
+    /**
+     * Download file from URL
+     */
+    downloadFile(url, destPath) {
+        return new Promise((resolve, reject) => {
+            const followRedirect = (url, redirectCount = 0) => {
+                if (redirectCount > 10) {
+                    reject(new Error('Too many redirects'));
+                    return;
+                }
+                const protocol = url.startsWith('https') ? https : http;
+                protocol.get(url, {
+                    headers: { 'User-Agent': 'brave-real-launcher' }
+                }, (response) => {
+                    if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308) {
+                        const redirectUrl = response.headers.location;
+                        if (redirectUrl) {
+                            followRedirect(redirectUrl, redirectCount + 1);
+                            return;
+                        }
+                    }
+                    if (response.statusCode !== 200) {
+                        reject(new Error(`Download failed: ${response.statusCode}`));
+                        return;
+                    }
+                    const file = fs.createWriteStream(destPath);
+                    response.pipe(file);
+                    file.on('finish', () => {
+                        file.close();
+                        resolve();
+                    });
+                    file.on('error', (err) => {
+                        fs.unlinkSync(destPath);
+                        reject(err);
+                    });
+                }).on('error', reject);
+            };
+            followRedirect(url);
+        });
+    }
+    /**
+     * Detect Linux package manager
+     */
+    detectLinuxPackageManager() {
+        try {
+            execSync('which apt', { stdio: 'ignore' });
+            return 'apt';
+        }
+        catch (e) { }
+        try {
+            execSync('which dnf', { stdio: 'ignore' });
+            return 'dnf';
+        }
+        catch (e) { }
+        try {
+            execSync('which yum', { stdio: 'ignore' });
+            return 'yum';
+        }
+        catch (e) { }
+        try {
+            execSync('which pacman', { stdio: 'ignore' });
+            return 'pacman';
+        }
+        catch (e) { }
+        return 'unknown';
+    }
+    /**
+     * Find Brave on Windows
+     */
+    findBraveWindows() {
+        const paths = [
+            `${process.env.LOCALAPPDATA}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+            `${process.env.PROGRAMFILES}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+            `${process.env['PROGRAMFILES(X86)']}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
+        ];
+        for (const p of paths) {
+            if (p && fs.existsSync(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find Brave on Linux
+     */
+    findBraveLinux() {
+        const paths = [
+            '/usr/bin/brave-browser',
+            '/usr/bin/brave-browser-stable',
+            '/opt/brave.com/brave/brave',
+            '/snap/bin/brave'
+        ];
+        for (const p of paths) {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+    /**
+     * Delay helper
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Check if Brave is installed
+     */
+    static isInstalled() {
+        const platform = getPlatform();
+        const installer = new BraveInstaller({ silent: true });
+        switch (platform) {
+            case 'win32':
+                return installer.findBraveWindows() !== null;
+            case 'linux':
+                return installer.findBraveLinux() !== null;
+            case 'darwin':
+                return fs.existsSync('/Applications/Brave Browser.app/Contents/MacOS/Brave Browser');
+            default:
+                return false;
+        }
+    }
+}
+export default BraveInstaller;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brave-installer.js","sourceRoot":"","sources":["../src/brave-installer.ts"],"names":[],"mappings":"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"}

package/dist/brave-launcher.d.ts

@@ -5,6 +5,7 @@ import * as childProcess from 'child_process';
 import * as fs from 'fs';
 import { XvfbManager, XvfbOptions } from './utils.js';
 import { ChildProcess } from 'child_process';
+import { ExtensionInfo } from './extension-manager.js';
 type JSONLike = {
     [property: string]: JSONLike;
 } | readonly JSONLike[] | string | number | boolean | null;
@@ -27,6 +28,11 @@ export interface Options {
     launchMode?: 'auto' | 'headless' | 'gui';
     xvfbOptions?: XvfbOptions;
     enableXvfb?: boolean;
+    extensions?: string[];
+    autoLoadUBlock?: boolean;
+    autoInstall?: boolean;
+    enableStealth?: boolean;
+    userAgent?: string;
 }
 export interface RemoteDebuggingPipes {
     incoming: NodeJS.ReadableStream;
@@ -39,6 +45,7 @@ export interface LaunchedBrave {
     remoteDebuggingPipes: RemoteDebuggingPipes | null;
     kill: () => void;
     xvfbManager?: XvfbManager;
+    extensions?: ExtensionInfo[];
 }
 export interface ModuleOverrides {
     fs?: typeof fs;
@@ -71,6 +78,13 @@ declare class Launcher {
     private launchMode;
     private enableXvfb;
     private xvfbOptions;
+    private extensions;
+    private autoLoadUBlock;
+    private autoInstall;
+    private enableStealth;
+    private userAgent?;
+    private extensionManager?;
+    loadedExtensions: ExtensionInfo[];
     braveProcess?: childProcess.ChildProcess;
     userDataDir?: string;
     port?: number;
@@ -79,6 +93,7 @@ declare class Launcher {
     xvfbManager?: XvfbManager;
     constructor(opts?: Options, moduleOverrides?: ModuleOverrides);
     private get flags();
+    private getExtensionPaths;
     private determineEffectiveLaunchMode;
     static defaultFlags(): string[];
     /** Returns the highest priority brave installation. */
@@ -87,8 +102,14 @@ declare class Launcher {
     static getInstallations(): string[];
     makeTmpDir(): string;
     private setupXvfb;
+    /**
+     * Load uBlock Origin extension
+     */
+    private loadUBlockOrigin;
     prepare(): void;
     private setBrowserPrefs;
+    private setLocalStatePrefs;
+    private deepMerge;
     launch(): Promise<void>;
     private spawnProcess;
     private cleanup;