brave-real-launcher 1.2.0 → 1.2.2

package/.github/workflows/main.yml

@@ -72,8 +72,37 @@ jobs:
       run: |
         echo "🔍 Checking for chrome-launcher updates..."
         
-        # Chrome-launcher की latest version fetch करें
-        CHROME_VERSION=$(curl -s https://api.github.com/repos/GoogleChrome/chrome-launcher/releases/latest | jq -r .tag_name | sed 's/v//')
+        # Chrome-launcher की latest version fetch करें with error handling
+        echo "🔍 Fetching chrome-launcher latest release..."
+        
+        # Fetch chrome-launcher version with multiple methods
+        CHROME_VERSION=""
+        
+        # Method 1: Try GitHub API
+        if command -v jq >/dev/null 2>&1; then
+          CHROME_API_RESPONSE=$(curl -s "https://api.github.com/repos/GoogleChrome/chrome-launcher/releases/latest")
+          if echo "$CHROME_API_RESPONSE" | jq -e '.tag_name' >/dev/null 2>&1; then
+            CHROME_VERSION=$(echo "$CHROME_API_RESPONSE" | jq -r .tag_name | sed 's/v//')
+            echo "✅ Found chrome-launcher version via GitHub API: $CHROME_VERSION"
+          fi
+        fi
+        
+        # Method 2: Fallback to NPM registry
+        if [ -z "$CHROME_VERSION" ] || [ "$CHROME_VERSION" = "null" ]; then
+          echo "⚠️ GitHub API failed, trying NPM registry..."
+          CHROME_VERSION=$(curl -s "https://registry.npmjs.org/chrome-launcher/latest" | jq -r .version 2>/dev/null || echo "")
+          if [ -n "$CHROME_VERSION" ] && [ "$CHROME_VERSION" != "null" ]; then
+            echo "✅ Found chrome-launcher version via NPM: $CHROME_VERSION"
+          fi
+        fi
+        
+        # Method 3: Final fallback - use current version
+        if [ -z "$CHROME_VERSION" ] || [ "$CHROME_VERSION" = "null" ]; then
+          echo "⚠️ All methods failed, using current version as fallback"
+          CHROME_VERSION=$(node -e "console.log(require('./package.json').version)")
+          echo "📦 Fallback to current version: $CHROME_VERSION"
+        fi
+        
         CURRENT_VERSION=$(node -e "console.log(require('./package.json').version)")
         
         echo "chrome_version=$CHROME_VERSION" >> $GITHUB_OUTPUT
@@ -102,10 +131,27 @@ jobs:
     - name: 🔄 Sync with Chrome-Launcher
       if: steps.sync-check.outputs.should_sync == 'true'
       run: |
-        echo "🔄 Syncing brave-real-launcher with chrome-launcher v${{ steps.sync-check.outputs.chrome_version }}"
+        echo "🔢 Syncing brave-real-launcher with chrome-launcher v${{ steps.sync-check.outputs.chrome_version }}"
+        
+        # Validate chrome version before using it
+        CHROME_VER="${{ steps.sync-check.outputs.chrome_version }}"
+        if [ "$CHROME_VER" = "null" ] || [ -z "$CHROME_VER" ]; then
+          echo "❌ Invalid chrome version detected: $CHROME_VER"
+          echo "🔄 Skipping sync due to invalid version"
+          exit 0
+        fi
+        
+        # Validate version format (should be x.y.z)
+        if ! echo "$CHROME_VER" | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+          echo "❌ Invalid version format: $CHROME_VER"
+          echo "🔄 Skipping sync due to invalid version format"
+          exit 0
+        fi
+        
+        echo "✅ Valid chrome version: $CHROME_VER"
         
         # Package.json version को update करें
-        npm version ${{ steps.sync-check.outputs.chrome_version }} --no-git-tag-version
+        npm version "$CHROME_VER" --no-git-tag-version
         
         # Git configuration
         git config user.name "🤖 Brave Sync Bot"
@@ -198,55 +244,136 @@ jobs:
         npm audit --audit-level high || echo "⚠️ Some security issues found but continuing..."
         echo "✅ Security audit completed!"
 
-    # Step 10: Determine publish strategy
-    - name: 🎯 Determine Publish Strategy
-      id: publish-check
+    # Step 10: Smart Version Management & Publish Strategy
+    - name: 🔢 Smart Version Management
+      id: version-manager
       run: |
-        echo "🎯 Determining publish strategy..."
+        echo "🔢 Smart version management starting..."
         
+        # Get current status
         PUBLISH_MODE="${{ github.event.inputs.publish_mode || 'auto' }}"
-        SHOULD_PUBLISH="false"
-        REASON=""
+        SYNC_PERFORMED="${{ steps.sync-check.outputs.should_sync }}"
+        CHROME_VERSION="${{ steps.sync-check.outputs.chrome_version }}"
         
-        # Current और NPM version check करें
+        # Current version from package.json
         CURRENT_VERSION=$(node -e "console.log(require('./package.json').version)")
+        
+        # NPM published version
+        echo "📎 Checking NPM registry..."
         NPM_VERSION=$(npm view brave-real-launcher version 2>/dev/null || echo "0.0.0")
         
-        echo "Current version: $CURRENT_VERSION"
+        echo "=== Version Status ==="
+        echo "Local version: $CURRENT_VERSION"
         echo "NPM version: $NPM_VERSION"
+        echo "Chrome-launcher version: $CHROME_VERSION"
+        echo "Sync performed: $SYNC_PERFORMED"
+        echo "Publish mode: $PUBLISH_MODE"
+        
+        # Smart version determination
+        NEW_VERSION=""
+        SHOULD_PUBLISH="false"
+        REASON=""
         
-        # Publish logic
         if [ "$PUBLISH_MODE" = "skip" ]; then
+          SHOULD_PUBLISH="false"
           REASON="Publish mode set to skip"
-        elif [ "$PUBLISH_MODE" = "force" ]; then
+          NEW_VERSION="$CURRENT_VERSION"
+        
+        elif [ "$SYNC_PERFORMED" = "true" ]; then
+          # Chrome-launcher sync हुआ है - use chrome version
+          NEW_VERSION="$CHROME_VERSION"
           SHOULD_PUBLISH="true"
-          REASON="Force publish requested"
-        elif [ "$PUBLISH_MODE" = "auto" ]; then
-          if [ "$CURRENT_VERSION" != "$NPM_VERSION" ]; then
-            # Only publish on main/master branch for auto mode
-            if [[ "${{ github.ref }}" == "refs/heads/main" || "${{ github.ref }}" == "refs/heads/master" ]]; then
+          REASON="Synced with chrome-launcher v$CHROME_VERSION"
+          
+          # Update package.json with chrome version
+          if [ "$NEW_VERSION" != "$CURRENT_VERSION" ]; then
+            echo "🔄 Updating package.json to chrome-launcher version: $NEW_VERSION"
+            npm version "$NEW_VERSION" --no-git-tag-version
+          fi
+        
+        else
+          # Regular update - सिर्फ main/master branch पर publish करें
+          if [[ "${{ github.ref }}" == "refs/heads/main" || "${{ github.ref }}" == "refs/heads/master" ]]; then
+            
+            if [ "$NPM_VERSION" = "0.0.0" ]; then
+              # First publish
+              NEW_VERSION="$CURRENT_VERSION"
               SHOULD_PUBLISH="true"
-              REASON="Version updated from $NPM_VERSION to $CURRENT_VERSION"
+              REASON="First publish"
             else
-              REASON="Version changed but not on main branch"
+              # Auto-increment करें अगर NPM version >= current version
+              if [ "$(printf '%s\n' "$NPM_VERSION" "$CURRENT_VERSION" | sort -V | tail -n1)" = "$NPM_VERSION" ]; then
+                # NPM version is same or newer, increment
+                echo "🔢 Auto-incrementing patch version..."
+                
+                # Parse NPM version and increment
+                IFS='.' read -r major minor patch <<< "$NPM_VERSION"
+                NEW_PATCH=$((patch + 1))
+                NEW_VERSION="${major}.${minor}.${NEW_PATCH}"
+                
+                echo "📈 Version increment: $NPM_VERSION → $NEW_VERSION"
+                
+                # Update package.json
+                npm version "$NEW_VERSION" --no-git-tag-version
+                
+                SHOULD_PUBLISH="true"
+                REASON="Auto-incremented from $NPM_VERSION to $NEW_VERSION"
+              else
+                # Current version is newer
+                NEW_VERSION="$CURRENT_VERSION"
+                SHOULD_PUBLISH="true"
+                REASON="Local version newer than NPM: $CURRENT_VERSION > $NPM_VERSION"
+              fi
             fi
+            
           else
-            REASON="No version change detected"
+            # Not on main branch
+            NEW_VERSION="$CURRENT_VERSION"
+            SHOULD_PUBLISH="false"
+            REASON="Not on main/master branch"
+          fi
+        fi
+        
+        # Force publish override
+        if [ "$PUBLISH_MODE" = "force" ]; then
+          if [ -z "$NEW_VERSION" ] || [ "$NEW_VERSION" = "$CURRENT_VERSION" ]; then
+            # Force के लिए increment करें
+            IFS='.' read -r major minor patch <<< "$([ "$NPM_VERSION" != "0.0.0" ] && echo "$NPM_VERSION" || echo "$CURRENT_VERSION")"
+            NEW_PATCH=$((patch + 1))
+            NEW_VERSION="${major}.${minor}.${NEW_PATCH}"
+            npm version "$NEW_VERSION" --no-git-tag-version
           fi
+          SHOULD_PUBLISH="true"
+          REASON="Force publish requested - v$NEW_VERSION"
+        fi
+        
+        # Commit version changes if made
+        if [ "$NEW_VERSION" != "$CURRENT_VERSION" ]; then
+          echo "📁 Committing version change..."
+          git config user.name "🤖 Brave Version Manager"
+          git config user.email "action@github.com"
+          git add package.json package-lock.json
+          git commit -m "🔢 Version update: $CURRENT_VERSION → $NEW_VERSION" || echo "No changes to commit"
+          git push || echo "Nothing to push"
         fi
         
+        # Output results
         echo "should_publish=$SHOULD_PUBLISH" >> $GITHUB_OUTPUT
         echo "reason=$REASON" >> $GITHUB_OUTPUT
-        echo "current_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
-        echo "npm_version=$NPM_VERSION" >> $GITHUB_OUTPUT
+        echo "final_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+        echo "version_changed=$([ "$NEW_VERSION" != "$CURRENT_VERSION" ] && echo "true" || echo "false")" >> $GITHUB_OUTPUT
         
-        echo "📋 Publish decision: $SHOULD_PUBLISH ($REASON)"
+        echo "=== Final Decision ==="
+        echo "📋 Should publish: $SHOULD_PUBLISH"
+        echo "📋 Final version: $NEW_VERSION"
+        echo "📋 Reason: $REASON"
 
     # Step 11: Publish to NPM
     - name: 🚀 Publish to NPM
-      if: steps.publish-check.outputs.should_publish == 'true'
+      if: steps.version-manager.outputs.should_publish == 'true'
       run: |
-        echo "🚀 Publishing brave-real-launcher v${{ steps.publish-check.outputs.current_version }} to NPM..."
+        FINAL_VERSION="${{ steps.version-manager.outputs.final_version }}"
+        echo "🚀 Publishing brave-real-launcher v$FINAL_VERSION to NPM..."
         
         # Verify we have NPM token
         if [ -z "$NPM_TOKEN" ]; then
@@ -263,12 +390,12 @@ jobs:
           git config user.name "🤖 Brave Publish Bot"
           git config user.email "action@github.com"
           
-          TAG_NAME="v${{ steps.publish-check.outputs.current_version }}"
+          TAG_NAME="v$FINAL_VERSION"
           git tag "$TAG_NAME" || echo "Tag might already exist"
           git push origin "$TAG_NAME" || echo "Failed to push tag"
         fi
         
-        echo "🎉 Successfully published brave-real-launcher v${{ steps.publish-check.outputs.current_version }}!"
+        echo "🎉 Successfully published brave-real-launcher v$FINAL_VERSION!"
       env:
         NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -280,19 +407,20 @@ jobs:
         echo "=================================="
         echo "📋 Execution Summary:"
         echo "• Chrome-launcher version: ${{ steps.sync-check.outputs.chrome_version }}"
-        echo "• Our version: ${{ steps.publish-check.outputs.current_version }}"
+        echo "• Final version: ${{ steps.version-manager.outputs.final_version }}"
+        echo "• Version changed: ${{ steps.version-manager.outputs.version_changed }}"
         echo "• Sync performed: ${{ steps.sync-check.outputs.should_sync }}"
         echo "• Sync mode: ${{ steps.sync-check.outputs.sync_mode }}"
-        echo "• Publish performed: ${{ steps.publish-check.outputs.should_publish }}"
-        echo "• Publish reason: ${{ steps.publish-check.outputs.reason }}"
+        echo "• Publish performed: ${{ steps.version-manager.outputs.should_publish }}"
+        echo "• Publish reason: ${{ steps.version-manager.outputs.reason }}"
         echo "• Build: ✅ Success"
         echo "• Tests: ✅ Passed" 
         echo "• Security: ✅ Checked"
         echo "=================================="
         
         # Set workflow status
-        if [ "${{ steps.publish-check.outputs.should_publish }}" = "true" ]; then
-          echo "🚀 Package published successfully!"
+        if [ "${{ steps.version-manager.outputs.should_publish }}" = "true" ]; then
+          echo "🚀 Package published successfully as v${{ steps.version-manager.outputs.final_version }}!"
         else
-          echo "📦 Package ready but not published (${{ steps.publish-check.outputs.reason }})"
-        fi
+          echo "📦 Package ready but not published (${{ steps.version-manager.outputs.reason }})"
+        fi

package/dist/brave-finder.mjs

@@ -0,0 +1,341 @@
+/**
+ * @license Copyright 2016 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import escapeRegExp from 'escape-string-regexp';
+import log from 'lighthouse-logger';
+import which from 'which';
+import { getWSLLocalAppDataPath, toWSLPath, BravePathNotSetError } from './utils.mjs.mjs';
+const newLineRegex = /\r?\n/;
+/**
+ * check for macOS default app paths first to avoid waiting for the slow lsregister command
+ */
+export function darwinFast() {
+    const priorityOptions = [
+        process.env.BRAVE_PATH,
+        process.env.LIGHTHOUSE_BRAVE_PATH,
+        // Brave Browser paths
+        '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+        '/Applications/Brave Browser Beta.app/Contents/MacOS/Brave Browser Beta',
+        '/Applications/Brave Browser Nightly.app/Contents/MacOS/Brave Browser Nightly',
+        '/Applications/Brave Browser Dev.app/Contents/MacOS/Brave Browser Dev',
+    ];
+    for (const bravePath of priorityOptions) {
+        if (bravePath && canAccess(bravePath))
+            return bravePath;
+    }
+    return darwin()[0];
+}
+export function darwin() {
+    const suffixes = [
+        '/Contents/MacOS/Brave Browser',
+        '/Contents/MacOS/Brave Browser Beta',
+        '/Contents/MacOS/Brave Browser Nightly',
+        '/Contents/MacOS/Brave Browser Dev'
+    ];
+    const LSREGISTER = '/System/Library/Frameworks/CoreServices.framework' +
+        '/Versions/A/Frameworks/LaunchServices.framework' +
+        '/Versions/A/Support/lsregister';
+    const installations = [];
+    const customBravePath = resolveBravePath();
+    if (customBravePath) {
+        installations.push(customBravePath);
+    }
+    // Look for Brave Browser installations
+    try {
+        execSync(`${LSREGISTER} -dump` +
+            ' | grep -i \'brave browser\\( beta\\| nightly\\| dev\\)\\?\\.app\'' +
+            ' | awk \'{$1=""; print $0}\'')
+            .toString()
+            .split(newLineRegex)
+            .forEach((inst) => {
+            suffixes.forEach(suffix => {
+                const execPath = path.join(inst.substring(0, inst.indexOf('.app') + 4).trim(), suffix);
+                if (canAccess(execPath) && installations.indexOf(execPath) === -1) {
+                    installations.push(execPath);
+                }
+            });
+        });
+    }
+    catch (e) {
+        // lsregister might not be available or might fail
+        log.warn('BraveLauncher', 'lsregister command failed, checking default paths');
+    }
+    // Retains one per line to maintain readability.
+    // clang-format off
+    const home = escapeRegExp(process.env.HOME || homedir());
+    const priorities = [
+        { regex: new RegExp(`^${home}/Applications/.*Brave Browser\\.app`), weight: 50 },
+        { regex: new RegExp(`^${home}/Applications/.*Brave Browser Beta\\.app`), weight: 51 },
+        { regex: new RegExp(`^${home}/Applications/.*Brave Browser Nightly\\.app`), weight: 52 },
+        { regex: new RegExp(`^${home}/Applications/.*Brave Browser Dev\\.app`), weight: 53 },
+        { regex: /^\/Applications\/.*Brave Browser\.app/, weight: 100 },
+        { regex: /^\/Applications\/.*Brave Browser Beta\.app/, weight: 101 },
+        { regex: /^\/Applications\/.*Brave Browser Nightly\.app/, weight: 102 },
+        { regex: /^\/Applications\/.*Brave Browser Dev\.app/, weight: 103 },
+        { regex: /^\/Volumes\/.*Brave Browser\.app/, weight: -2 },
+        { regex: /^\/Volumes\/.*Brave Browser Beta\.app/, weight: -1 },
+    ];
+    if (process.env.LIGHTHOUSE_BRAVE_PATH) {
+        priorities.unshift({ regex: new RegExp(escapeRegExp(process.env.LIGHTHOUSE_BRAVE_PATH)), weight: 150 });
+    }
+    if (process.env.BRAVE_PATH) {
+        priorities.unshift({ regex: new RegExp(escapeRegExp(process.env.BRAVE_PATH)), weight: 151 });
+    }
+    // clang-format on
+    return sort(installations, priorities);
+}
+function resolveBravePath() {
+    if (canAccess(process.env.BRAVE_PATH)) {
+        return process.env.BRAVE_PATH;
+    }
+    if (canAccess(process.env.LIGHTHOUSE_BRAVE_PATH)) {
+        log.warn('BraveLauncher', 'LIGHTHOUSE_BRAVE_PATH is deprecated, use BRAVE_PATH env variable instead.');
+        return process.env.LIGHTHOUSE_BRAVE_PATH;
+    }
+    return undefined;
+}
+/**
+ * Look for linux executables in 3 ways
+ * 1. Look into BRAVE_PATH env variable
+ * 2. Look into the directories where .desktop are saved on gnome based distro's
+ * 3. Look for brave-browser & brave executables by using the which command
+ * Support for both x64 and ARM64 architectures
+ */
+export function linux() {
+    let installations = [];
+    // 1. Look into BRAVE_PATH env variable
+    const customBravePath = resolveBravePath();
+    if (customBravePath) {
+        installations.push(customBravePath);
+    }
+    // 2. Look into the directories where .desktop are saved on gnome based distro's
+    const desktopInstallationFolders = [
+        path.join(homedir(), '.local/share/applications/'),
+        '/usr/share/applications/',
+    ];
+    desktopInstallationFolders.forEach(folder => {
+        installations = installations.concat(findBraveExecutables(folder));
+    });
+    // 3. Look for brave-browser, brave, and other brave executables by using the which command
+    const executables = [
+        'brave-browser',
+        'brave-browser-stable',
+        'brave-browser-beta',
+        'brave-browser-nightly',
+        'brave-browser-dev',
+        'brave',
+        'brave-stable',
+        'brave-beta',
+        'brave-nightly',
+        'brave-dev',
+        // Flatpak versions
+        'flatpak run com.brave.Browser',
+        // Snap versions  
+        'brave',
+    ];
+    // Check standard installation paths for different architectures
+    const standardPaths = [
+        '/usr/bin/brave-browser',
+        '/usr/bin/brave-browser-stable',
+        '/usr/bin/brave-browser-beta',
+        '/usr/bin/brave-browser-nightly',
+        '/usr/bin/brave',
+        '/opt/brave.com/brave/brave',
+        '/opt/brave.com/brave-beta/brave-beta',
+        '/opt/brave.com/brave-nightly/brave-nightly',
+        '/opt/brave.com/brave-dev/brave-dev',
+        '/snap/bin/brave',
+        // ARM64 specific paths
+        '/usr/lib/aarch64-linux-gnu/brave/brave',
+        '/opt/brave-browser/brave',
+        // Additional paths for different distros
+        '/usr/local/bin/brave',
+        '/usr/local/bin/brave-browser',
+    ];
+    standardPaths.forEach(bravePath => {
+        if (canAccess(bravePath)) {
+            installations.push(bravePath);
+        }
+    });
+    executables.forEach((executable) => {
+        try {
+            const bravePath = which.sync(executable, { nothrow: true });
+            if (bravePath && canAccess(bravePath)) {
+                installations.push(bravePath);
+            }
+        }
+        catch (e) {
+            // Not installed.
+        }
+    });
+    if (!installations.length) {
+        throw new BravePathNotSetError();
+    }
+    const priorities = [
+        { regex: /brave-wrapper$/, weight: 51 },
+        { regex: /brave-browser-stable$/, weight: 50 },
+        { regex: /brave-browser$/, weight: 49 },
+        { regex: /brave-stable$/, weight: 48 },
+        { regex: /brave$/, weight: 47 },
+        { regex: /brave-browser-beta$/, weight: 46 },
+        { regex: /brave-beta$/, weight: 45 },
+        { regex: /brave-browser-nightly$/, weight: 44 },
+        { regex: /brave-nightly$/, weight: 43 },
+        { regex: /brave-browser-dev$/, weight: 42 },
+        { regex: /brave-dev$/, weight: 41 },
+    ];
+    if (process.env.LIGHTHOUSE_BRAVE_PATH) {
+        priorities.unshift({ regex: new RegExp(escapeRegExp(process.env.LIGHTHOUSE_BRAVE_PATH)), weight: 100 });
+    }
+    if (process.env.BRAVE_PATH) {
+        priorities.unshift({ regex: new RegExp(escapeRegExp(process.env.BRAVE_PATH)), weight: 101 });
+    }
+    return sort(uniq(installations.filter(Boolean)), priorities);
+}
+export function wsl() {
+    // Manually populate the environment variables assuming it's the default config
+    process.env.LOCALAPPDATA = getWSLLocalAppDataPath(`${process.env.PATH}`);
+    process.env.PROGRAMFILES = toWSLPath('C:/Program Files', '/mnt/c/Program Files');
+    process.env['PROGRAMFILES(X86)'] =
+        toWSLPath('C:/Program Files (x86)', '/mnt/c/Program Files (x86)');
+    return win32();
+}
+export function win32() {
+    const installations = [];
+    // Brave Browser installation paths for different architectures
+    const suffixes = [
+        // Standard x64 installations
+        `${path.sep}BraveSoftware${path.sep}Brave-Browser${path.sep}Application${path.sep}brave.exe`,
+        `${path.sep}BraveSoftware${path.sep}Brave-Browser-Beta${path.sep}Application${path.sep}brave.exe`,
+        `${path.sep}BraveSoftware${path.sep}Brave-Browser-Nightly${path.sep}Application${path.sep}brave.exe`,
+        `${path.sep}BraveSoftware${path.sep}Brave-Browser-Dev${path.sep}Application${path.sep}brave.exe`,
+        // Alternative paths
+        `${path.sep}Brave${path.sep}Application${path.sep}brave.exe`,
+        `${path.sep}Brave-Browser${path.sep}Application${path.sep}brave.exe`,
+    ];
+    const prefixes = [
+        process.env.LOCALAPPDATA,
+        process.env.PROGRAMFILES,
+        process.env['PROGRAMFILES(X86)'],
+        // Additional paths for ARM64 and other architectures
+        process.env.PROGRAMW6432,
+    ].filter(Boolean);
+    const customBravePath = resolveBravePath();
+    if (customBravePath) {
+        installations.push(customBravePath);
+    }
+    // Check standard installation paths
+    prefixes.forEach(prefix => suffixes.forEach(suffix => {
+        const bravePath = path.join(prefix, suffix);
+        if (canAccess(bravePath)) {
+            installations.push(bravePath);
+        }
+    }));
+    // Check Windows Registry for Brave installations
+    try {
+        const registryPaths = getWindowsRegistryBravePaths();
+        registryPaths.forEach(regPath => {
+            if (canAccess(regPath)) {
+                installations.push(regPath);
+            }
+        });
+    }
+    catch (e) {
+        log.warn('BraveLauncher', 'Failed to read Windows registry for Brave paths');
+    }
+    return installations;
+}
+function getWindowsRegistryBravePaths() {
+    const paths = [];
+    // Registry keys where Brave might be registered
+    const registryKeys = [
+        'HKEY_LOCAL_MACHINE\\SOFTWARE\\BraveSoftware\\Brave',
+        'HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\BraveSoftware\\Brave',
+        'HKEY_CURRENT_USER\\SOFTWARE\\BraveSoftware\\Brave',
+        'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\brave.exe',
+    ];
+    registryKeys.forEach(key => {
+        try {
+            const result = execSync(`reg query "${key}" /ve 2>nul`, { encoding: 'utf-8' });
+            const match = result.match(/REG_SZ\s+(.+)/);
+            if (match && match[1]) {
+                const bravePath = match[1].trim();
+                if (bravePath && canAccess(bravePath)) {
+                    paths.push(bravePath);
+                }
+            }
+        }
+        catch (e) {
+            // Registry key doesn't exist or access denied
+        }
+    });
+    return paths;
+}
+function sort(installations, priorities) {
+    const defaultPriority = 10;
+    return installations
+        // assign priorities
+        .map((inst) => {
+        for (const pair of priorities) {
+            if (pair.regex.test(inst)) {
+                return { path: inst, weight: pair.weight };
+            }
+        }
+        return { path: inst, weight: defaultPriority };
+    })
+        // sort based on priorities
+        .sort((a, b) => (b.weight - a.weight))
+        // remove priority flag
+        .map(pair => pair.path);
+}
+function canAccess(file) {
+    if (!file) {
+        return false;
+    }
+    try {
+        fs.accessSync(file);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function uniq(arr) {
+    return Array.from(new Set(arr));
+}
+function findBraveExecutables(folder) {
+    const argumentsRegex = /(^[^ ]+).*/; // Take everything up to the first space
+    const braveExecRegex = '^Exec=\\/.*\\/(brave|brave-browser|brave-browser-stable|brave-browser-beta|brave-browser-nightly)-.*';
+    let installations = [];
+    if (canAccess(folder)) {
+        // Output of the grep & print looks like:
+        //    /opt/brave.com/brave/brave --profile-directory
+        //    /home/user/Downloads/brave-linux/brave-wrapper %U
+        let execPaths;
+        // Some systems do not support grep -R so fallback to -r.
+        try {
+            execPaths = execSync(`grep -ER "${braveExecRegex}" ${folder} | awk -F '=' '{print $2}'`, { stdio: 'pipe' });
+        }
+        catch (e) {
+            try {
+                execPaths = execSync(`grep -Er "${braveExecRegex}" ${folder} | awk -F '=' '{print $2}'`, { stdio: 'pipe' });
+            }
+            catch (e2) {
+                return installations;
+            }
+        }
+        execPaths = execPaths.toString()
+            .split(newLineRegex)
+            .map((execPath) => execPath.replace(argumentsRegex, '$1'));
+        execPaths.forEach((execPath) => canAccess(execPath) && installations.push(execPath));
+    }
+    return installations;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brave-finder.js","sourceRoot":"","sources":["../src/brave-finder.ts"],"names":[],"mappings":"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"}