brave-real-launcher 1.2.32 → 1.2.34

package/.github/workflows/chrome-launcher-sync.yml

@@ -3,8 +3,8 @@ name: Chrome Launcher Sync & Publish
 on:
   # Automatic triggers
   schedule:
-    # Weekly trigger - Every Monday at 6 AM UTC (11:30 AM IST)
-    - cron: '0 6 * * 1'
+    # Daily trigger - Every day at 6 AM UTC (11:30 AM IST)
+    - cron: '0 6 * * *'
   
   # Manual trigger
   workflow_dispatch:

package/README.md

@@ -2,14 +2,17 @@
 
 Launch Brave Browser with ease from Node.js. Based on [chrome-launcher](https://github.com/GoogleChrome/chrome-launcher) but specifically adapted for Brave Browser with additional features.
 
-## Features
+## ✨ Features
 
 - 🦁 **Brave Browser Detection**: Automatically detects Brave Browser installations across all platforms
 - 🖥️ **Multi-Platform Support**: Linux (x64/ARM64), macOS (Intel/Apple Silicon), Windows (x64/ARM64)
 - 🐧 **Xvfb Support**: Built-in Xvfb support for headless operation on Linux
 - 🎯 **Launch Modes**: Headless mode, GUI mode, or automatic detection
 - 🔄 **Auto-Sync**: Automatically syncs with chrome-launcher updates while preserving Brave-specific features
-- 🛠️ **Full API Compatibility**: Drop-in replacement for chrome-launcher but for Brave
+- 📦 **uBlock Origin**: Automatic download and loading of uBlock Origin ad blocker
+- 🛡️ **Stealth Mode**: Anti-bot-detection capabilities for automation
+- ⬇️ **Auto-Install**: Automatically install Brave if not present (Windows/Linux/macOS)
+- 🔇 **P3A Disabled**: Private analytics notifications disabled by default
 
 ## Installation
 
@@ -17,23 +20,6 @@ Launch Brave Browser with ease from Node.js. Based on [chrome-launcher](https://
 npm install brave-real-launcher
 ```
 
-## Quick Start
-
-```javascript
-const { launch } = require('brave-real-launcher');
-
-// Launch Brave in headless mode
-const brave = await launch({
-  braveFlags: ['--headless', '--disable-gpu'],
-  logLevel: 'info'
-});
-
-console.log('Brave is running on port', brave.port);
-
-// Kill Brave
-brave.kill();
-```
-
 ## API
 
 ### `launch(options)`
@@ -41,116 +27,105 @@ brave.kill();
 Launches Brave Browser with the specified options.
 
 **Options:**
-- `bravePath?: string` - Path to Brave executable (auto-detected if not provided)
-- `braveFlags?: string[]` - Array of Brave flags to pass
-- `launchMode?: 'auto' | 'headless' | 'gui'` - Launch mode (default: 'auto')
-- `enableXvfb?: boolean` - Enable Xvfb on Linux (default: false)
-- `xvfbOptions?: XvfbOptions` - Xvfb configuration options
-- `port?: number` - Debug port (default: random)
-- `userDataDir?: string | boolean` - User data directory
-- `startingUrl?: string` - URL to navigate to on start
-- And more options compatible with chrome-launcher
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `bravePath` | `string` | auto-detected | Path to Brave executable |
+| `braveFlags` | `string[]` | `[]` | Array of Brave flags to pass |
+| `startingUrl` | `string` | `about:blank` | URL to navigate to on start |
+| `port` | `number` | random | Debug port |
+| `userDataDir` | `string\|boolean` | temp dir | User data directory |
+| `launchMode` | `'auto'\|'headless'\|'gui'` | `'auto'` | Launch mode |
+| `enableXvfb` | `boolean` | `false` | Enable Xvfb on Linux |
+| `autoLoadUBlock` | `boolean` | `false` | Auto-load uBlock Origin |
+| `enableStealth` | `boolean` | `false` | Enable stealth mode |
+| `autoInstall` | `boolean` | `false` | Auto-install Brave if not found |
+| `userAgent` | `string` | default | Custom user agent |
+| `logLevel` | `'verbose'\|'info'\|'error'\|'silent'` | `'silent'` | Log level |
+
+**Returns:** `LaunchedBrave` object with:
+- `pid`: Process ID
+- `port`: Debug port
+- `process`: Child process
+- `extensions`: Loaded extensions info
+- `kill()`: Function to kill browser
 
 ### `getBravePath()`
 
 Returns the path to the Brave Browser executable.
 
-### `XvfbManager`
-
-Manages Xvfb virtual display for headless environments.
-
-```javascript
-const { XvfbManager } = require('brave-real-launcher');
+## Platform Support
 
-const xvfb = new XvfbManager({
-  display: ':99',
-  width: 1920,
-  height: 1080
-});
+### Auto-Install Behavior
 
-await xvfb.start();
-// ... use Brave
-await xvfb.stop();
-```
+| Platform | Method | Skip if Installed |
+|----------|--------|-------------------|
+| **Windows** | Downloads installer, runs silently | ✅ Yes |
+| **Linux** | apt/dnf/yum/pacman | ✅ Yes |
+| **macOS** | Downloads DMG, mounts & copies | ✅ Yes |
 
-## Platform Support
+### Path Detection
 
-### Linux
-- x64 and ARM64 architectures
-- Detects installations in standard paths: `/opt/brave.com/brave/`, `/usr/bin/brave-browser`, etc.
-- Supports Flatpak and Snap installations
-- Built-in Xvfb support for headless environments
+| Platform | Detection Paths |
+|----------|-----------------|
+| **Windows** | `%LOCALAPPDATA%\BraveSoftware\...`, `%PROGRAMFILES%\...` |
+| **Linux** | `/usr/bin/brave-browser`, `/opt/brave.com/brave/...`, Flatpak, Snap |
+| **macOS** | `/Applications/Brave Browser.app/...` |
 
-### macOS  
-- Intel and Apple Silicon (M1/M2) support
-- Detects Brave Browser, Brave Browser Beta, Nightly, and Dev versions
-- Standard installation paths in `/Applications/`
+## Testing
 
-### Windows
-- x64 and ARM64 support  
-- Registry-based detection
-- Standard installation paths in Program Files and Local AppData
+```bash
+# Install dependencies
+npm install
 
-## Environment Variables
+# Build project
+npm run build
 
-- `BRAVE_PATH`: Path to Brave executable
-- `HEADLESS`: Force headless mode when set
-- `DISPLAY`: X11 display (Linux)
+# Run tests
+npm test
 
-## Examples
+# Test Brave detection
+npm run test:detection
 
-### Headless Mode with Xvfb
-```javascript
-const brave = await launch({
-  launchMode: 'headless',
-  enableXvfb: true,
-  xvfbOptions: { width: 1920, height: 1080 }
-});
+# Test with uBlock Origin
+node -e "const {launch} = require('./dist'); launch({autoLoadUBlock:true, startingUrl:'https://example.com', logLevel:'info'}).then(b => setTimeout(() => b.kill(), 5000))"
 ```
 
-### Custom Flags
-```javascript  
-const brave = await launch({
-  braveFlags: [
-    '--no-sandbox',
-    '--disable-dev-shm-usage',
-    '--disable-gpu'
-  ]
-});
-```
+## Environment Variables
 
-### Auto-Detection
-```javascript
-const brave = await launch({
-  launchMode: 'auto', // Automatically detects headless vs GUI environment
-  logLevel: 'verbose'
-});
-```
+| Variable | Description |
+|----------|-------------|
+| `BRAVE_PATH` | Path to Brave executable |
+| `HEADLESS` | Force headless mode when set |
+| `DISPLAY` | X11 display (Linux) |
 
 ## Development
 
-### Building
-
 ```bash
-npm run build
-```
+# Clone repository
+git clone https://github.com/user/brave-real-launcher.git
+cd brave-real-launcher
 
-### Testing
+# Install dependencies
+npm install
 
-```bash
-npm test
+# Build
+npm run build
+
+# Run CI tests
+npm run test:ci
 ```
 
 ## Auto-Sync with chrome-launcher
 
-This project automatically syncs with chrome-launcher updates while preserving Brave-specific functionality. The GitHub Action workflow:
+This project automatically syncs with chrome-launcher updates while preserving Brave-specific functionality:
 
-- Checks for chrome-launcher updates daily
-- Automatically integrates compatible changes
-- Preserves Brave-specific browser detection and features
-- Runs comprehensive tests across all supported platforms
-- Publishes updated versions to npm
+- ✅ Checks for chrome-launcher updates **daily**
+- ✅ Automatically integrates compatible changes
+- ✅ Preserves Brave-specific browser detection
+- ✅ Runs comprehensive tests
+- ✅ Publishes to npm automatically
 
 ## License
 
-Apache-2.0 - Based on chrome-launcher by The Chromium Authors
+Apache-2.0 - Based on chrome-launcher by The Chromium Authors

package/dist/brave-installer.d.ts

@@ -0,0 +1,57 @@
+export interface InstallerOptions {
+    silent?: boolean;
+    downloadDir?: string;
+    channel?: 'release' | 'beta' | 'nightly';
+}
+export interface InstallResult {
+    success: boolean;
+    bravePath?: string;
+    error?: string;
+}
+export declare class BraveInstaller {
+    private silent;
+    private downloadDir;
+    private channel;
+    constructor(options?: InstallerOptions);
+    /**
+     * Install Brave browser on the current platform
+     */
+    install(): Promise<InstallResult>;
+    /**
+     * Install Brave on Windows
+     */
+    private installWindows;
+    /**
+     * Install Brave on Linux
+     */
+    private installLinux;
+    /**
+     * Install Brave on macOS
+     */
+    private installMacOS;
+    /**
+     * Download file from URL
+     */
+    private downloadFile;
+    /**
+     * Detect Linux package manager
+     */
+    private detectLinuxPackageManager;
+    /**
+     * Find Brave on Windows
+     */
+    private findBraveWindows;
+    /**
+     * Find Brave on Linux
+     */
+    private findBraveLinux;
+    /**
+     * Delay helper
+     */
+    private delay;
+    /**
+     * Check if Brave is installed
+     */
+    static isInstalled(): boolean;
+}
+export default BraveInstaller;

package/dist/brave-installer.js

@@ -0,0 +1,352 @@
+/**
+ * @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';
+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.BraveInstaller = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const logger_js_1 = __importDefault(require("./logger.js"));
+const utils_js_1 = require("./utils.js");
+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'
+    }
+};
+class BraveInstaller {
+    constructor(options = {}) {
+        this.silent = options.silent || false;
+        this.downloadDir = options.downloadDir || path.join((0, os_1.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 = (0, utils_js_1.getPlatform)();
+        if (!this.silent) {
+            logger_js_1.default.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) {
+            logger_js_1.default.log('BraveInstaller', 'Downloading Brave installer for Windows...');
+        }
+        // Download installer
+        await this.downloadFile(downloadUrl, installerPath);
+        if (!this.silent) {
+            logger_js_1.default.log('BraveInstaller', 'Running Brave installer (silent mode)...');
+        }
+        // Run installer silently
+        try {
+            (0, child_process_1.execSync)(`"${installerPath}" /silent /install`, {
+                stdio: 'ignore',
+                timeout: 300000 // 5 minutes timeout
+            });
+        }
+        catch (error) {
+            // Try alternative silent flags
+            try {
+                (0, child_process_1.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) {
+                logger_js_1.default.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) {
+            logger_js_1.default.log('BraveInstaller', 'Installing Brave on Linux...');
+        }
+        // Detect package manager
+        const packageManager = this.detectLinuxPackageManager();
+        try {
+            if (packageManager === 'apt') {
+                // Debian/Ubuntu based
+                (0, child_process_1.execSync)('sudo apt install -y curl', { stdio: 'ignore' });
+                (0, child_process_1.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' });
+                (0, child_process_1.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' });
+                (0, child_process_1.execSync)('sudo apt update', { stdio: 'ignore' });
+                (0, child_process_1.execSync)('sudo apt install -y brave-browser', { stdio: 'ignore' });
+            }
+            else if (packageManager === 'dnf' || packageManager === 'yum') {
+                // Fedora/RHEL based
+                (0, child_process_1.execSync)('sudo dnf install -y dnf-plugins-core', { stdio: 'ignore' });
+                (0, child_process_1.execSync)('sudo dnf config-manager --add-repo https://brave-browser-rpm-release.s3.brave.com/brave-browser.repo', { stdio: 'ignore' });
+                (0, child_process_1.execSync)('sudo rpm --import https://brave-browser-rpm-release.s3.brave.com/brave-core.asc', { stdio: 'ignore' });
+                (0, child_process_1.execSync)('sudo dnf install -y brave-browser', { stdio: 'ignore' });
+            }
+            else if (packageManager === 'pacman') {
+                // Arch based
+                (0, child_process_1.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) {
+                    logger_js_1.default.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) {
+            logger_js_1.default.log('BraveInstaller', 'Downloading Brave for macOS...');
+        }
+        // Download DMG
+        await this.downloadFile(downloadUrl, dmgPath);
+        if (!this.silent) {
+            logger_js_1.default.log('BraveInstaller', 'Installing Brave...');
+        }
+        try {
+            // Mount DMG
+            const mountOutput = (0, child_process_1.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
+            (0, child_process_1.execSync)(`cp -R "${mountPoint}/Brave Browser.app" /Applications/`, { stdio: 'ignore' });
+            // Unmount DMG
+            (0, child_process_1.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) {
+                    logger_js_1.default.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 {
+            (0, child_process_1.execSync)('which apt', { stdio: 'ignore' });
+            return 'apt';
+        }
+        catch (e) { }
+        try {
+            (0, child_process_1.execSync)('which dnf', { stdio: 'ignore' });
+            return 'dnf';
+        }
+        catch (e) { }
+        try {
+            (0, child_process_1.execSync)('which yum', { stdio: 'ignore' });
+            return 'yum';
+        }
+        catch (e) { }
+        try {
+            (0, child_process_1.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 = (0, utils_js_1.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;
+        }
+    }
+}
+exports.BraveInstaller = BraveInstaller;
+exports.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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"}