chore: version bump

deps(rust)(deps): bump the rust-dependencies group in /src-tauri with 2 updates

.cursor/rules/always-test-before-summary.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+Before finishing the task and showing summary, always run "pnpm format && pnpm lint && pnpm test" at the root of the project to ensure that you don't finish with broken application.

.cursor/rules/no-useless-comments.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+Don't leave comments that don't add value

.cursor/rules/no-useless-duplication.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+Do not duplicate code unless you have a very good reason to do so. It is important that the same logic is not duplicated multiple times

.cursor/rules/tests-and-linting-after-changes.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+After your changes, instead of running specific tests or linting specific files, run "pnpm format && pnpm lint && pnpm test". It means that you first format the code, then lint it, then test it, so that no part is broken after your changes.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,14 +1,14 @@
 # ✨ Pull Request
 
-### 📓 Referenced Issue
+## 📓 Referenced Issue
 
 <!-- Please link the related issue. Use # before the issue number and use the verbs 'fixes', 'resolves' to auto-link it, for eg, Fixes: #<issue-number> -->
 
-### ℹ️ About the PR
+## ℹ️ About the PR
 
 <!-- Please provide a description of your solution if it is not clear in the related issue or if the PR has a breaking change. If there is an interesting topic to discuss or you have questions or there is an issue with Tauri, Rust, or another library that you have used. -->
 
-### 🔄 Type of Change
+## 🔄 Type of Change
 
 <!-- Mark the relevant option with an "x". -->
 
@@ -19,11 +19,11 @@
 - [ ] 🧹 Code cleanup/refactoring
 - [ ] ⚡ Performance improvement
 
-### 🖼️ Testing Scenarios / Screenshots
+## 🖼️ Testing Scenarios / Screenshots
 
 <!-- Please include screenshots or gif to showcase the final output. Also, try to explain the testing you did to validate your change. -->
 
-### ✅ Checklist
+## ✅ Checklist
 
 <!-- Mark completed items with an "x". -->
 
@@ -36,11 +36,11 @@
 - [ ] New and existing unit tests pass locally with my changes
 - [ ] Any dependent changes have been merged and published
 
-### 🧪 How Has This Been Tested?
+## 🧪 How Has This Been Tested?
 
 <!-- Please describe the tests that you ran to verify your changes. -->
 
-### 📱 Platform Testing
+## 📱 Platform Testing
 
 <!-- Which platforms have you tested on? -->
 
@@ -49,6 +49,6 @@
 - [ ] Windows (if applicable)
 - [ ] Linux (if applicable)
 
-### 📋 Additional Notes
+## 📋 Additional Notes
 
 <!-- Any additional information that reviewers should know about this PR. -->

.github/dependabot.yml

@@ -1,28 +1,53 @@
 version: 2
 updates:
-  # Enable version updates for Node.js dependencies
+  # Frontend dependencies (root package.json)
   - package-ecosystem: "npm"
     directory: "/"
     schedule:
       interval: "weekly"
+      day: "saturday"
+      time: "09:00"
     allow:
       - dependency-type: "all"
     groups:
-      all:
+      frontend-dependencies:
         patterns:
           - "*"
     ignore:
       - dependency-name: "eslint"
         versions: ">= 9"
+    commit-message:
+      prefix: "deps"
+      include: "scope"
 
-  # Enable version updates for rust
+  # Rust dependencies
   - package-ecosystem: "cargo"
     directory: "/src-tauri"
     schedule:
       interval: "weekly"
+      day: "saturday"
+      time: "09:00"
     allow:
       - dependency-type: "all"
     groups:
-      all:
+      rust-dependencies:
         patterns:
           - "*"
+    commit-message:
+      prefix: "deps(rust)"
+      include: "scope"
+
+  # GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "saturday"
+      time: "09:00"
+    groups:
+      github-actions:
+        patterns:
+          - "*"
+    commit-message:
+      prefix: "ci"
+      include: "scope"

.github/workflows/codeql.yml

@@ -0,0 +1,61 @@
+name: "CodeQL"
+
+on:
+  workflow_call:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  schedule:
+    - cron: "16 13 * * 5"
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      security-events: write
+      packages: read
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: actions
+            build-mode: none
+          - language: javascript-typescript
+            build-mode: none
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
+
+      - name: Set up pnpm package manager
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda #v4.1.0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
+        with:
+          node-version-file: .node-version
+          cache: "pnpm"
+
+      - name: Install dependencies from lockfile
+        run: pnpm install --frozen-lockfile
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@b1e4dc3db58c9601794e22a9f6d28d45461b9dbf #v3.29.0
+        with:
+          queries: security-extended
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+
+      - if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          pnpm run build
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@b1e4dc3db58c9601794e22a9f6d28d45461b9dbf #v3.29.0
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/dependabot-automerge.yml

@@ -1,34 +1,82 @@
-# Automatically squashes and merges Dependabot dependency upgrades if tests pass
+name: Dependabot Automerge
 
-name: Dependabot Auto-merge
-
-on: pull_request_target
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened]
 
 permissions:
   pull-requests: write
   contents: write
+  checks: read
 
 jobs:
-  dependabot:
-    runs-on: ubuntu-latest
-
+  security-scan:
+    name: Security Vulnerability Scan
     if: ${{ github.actor == 'dependabot[bot]' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/pnpm-lock.yaml
+        ./
+    permissions:
+      security-events: write
+      contents: read
+      actions: read
+
+  lint-js:
+    name: Lint JavaScript/TypeScript
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    uses: ./.github/workflows/lint-js.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  lint-rust:
+    name: Lint Rust
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    uses: ./.github/workflows/lint-rs.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  codeql:
+    name: CodeQL
+    uses: ./.github/workflows/codeql.yml
+    secrets: inherit
+    permissions:
+      security-events: write
+      contents: read
+      packages: read
+      actions: read
+
+  spellcheck:
+    name: Spell Check
+    uses: ./.github/workflows/spellcheck.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  dependabot-automerge:
+    name: Dependabot Automerge
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
+    runs-on: ubuntu-latest
     steps:
-      - name: Fetch Dependabot metadata
-        id: dependabot-metadata
-        uses: dependabot/fetch-metadata@v2
+      - name: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@08eff52bf64351f401fb50d4972fa95b9f2c2d1b #v2.4.0
         with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
+          compat-lookup: true
+          github-token: "${{ secrets.SECRET_DEPENDABOT_GITHUB_TOKEN }}"
 
-      - name: Approve Dependabot PR
-        run: gh pr review --approve "$PR_URL"
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Auto-merge (squash) Dependabot PR
-        if: ${{ steps.dependabot-metadata.outputs.update-type != 'version-update:semver-major' }}
-        run: gh pr merge --auto --squash "$PR_URL"
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Auto-merge minor and patch updates
+        uses: ridedott/merge-me-action@338053c6f9b9311a6be80208f6f0723981e40627 #v2.10.122
+        with:
+          GITHUB_TOKEN: ${{ secrets.SECRET_DEPENDABOT_GITHUB_TOKEN }}
+          PRESET: DEPENDABOT_MINOR
+          MERGE_METHOD: SQUASH
+    timeout-minutes: 10

.github/workflows/lint-js.yml

@@ -3,6 +3,7 @@
 name: Lint Node.js
 
 on:
+  workflow_call:
   push:
     branches:
       - main
@@ -12,13 +13,18 @@ on:
     paths-ignore:
       - "src-tauri/**"
       - "README.md"
+      - ".github/workflows/lint-rs.yml"
+      - ".github/workflows/osv.yml"
+
+permissions:
+  contents: read
 
 jobs:
   build:
     strategy:
       fail-fast: true
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [macos-latest]
 
     runs-on: ${{ matrix.os }}
 
@@ -28,13 +34,13 @@ jobs:
         run: git config --global core.autocrlf false
 
       - name: Checkout repository code
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
 
       - name: Set up pnpm package manager
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda #v4.1.0
 
-      - name: Set up Node.js v22
-        uses: actions/setup-node@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
         with:
           node-version-file: .node-version
           cache: "pnpm"
@@ -48,4 +54,4 @@ jobs:
           pnpm install --frozen-lockfile
 
       - name: Run lint step
-        run: pnpm lint
+        run: pnpm run lint:js

.github/workflows/lint-rs.yml

@@ -3,6 +3,7 @@
 name: Lint Rust
 
 on:
+  workflow_call:
   push:
     branches:
       - main
@@ -11,18 +12,27 @@ on:
   pull_request:
     paths-ignore:
       - "src/**"
+      - "nodecar/**"
       - "package.json"
-      - "package-lock.json"
-      - "yarn.lock"
       - "pnpm-lock.yaml"
+      - "yarn.lock"
       - "README.md"
+      - ".github/workflows/lint-js.yml"
+      - ".github/workflows/osv.yml"
+      - "next.config.js"
+      - "tailwind.config.js"
+      - "tsconfig.json"
+      - "biome.json"
+
+permissions:
+  contents: read
 
 jobs:
   build:
     strategy:
       fail-fast: true
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [macos-latest]
 
     runs-on: ${{ matrix.os }}
 
@@ -32,22 +42,26 @@ jobs:
         run: git config --global core.autocrlf false
 
       - name: Checkout repository code
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
 
       - name: Set up pnpm package manager
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda #v4.1.0
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
         with:
           node-version-file: .node-version
           cache: "pnpm"
 
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b #master
         with:
+          toolchain: stable
           components: rustfmt, clippy
 
+      - name: Install cargo-audit
+        run: cargo install cargo-audit
+
       - name: Install dependencies (Ubuntu only)
         if: matrix.os == 'ubuntu-latest'
         run: |
@@ -60,7 +74,7 @@ jobs:
       - name: Install nodecar dependencies
         working-directory: ./nodecar
         run: |
-          pnpm install --ignore-workspace --frozen-lockfile
+          pnpm install --frozen-lockfile
 
       - name: Build nodecar binary
         shell: bash
@@ -69,7 +83,7 @@ jobs:
           if [[ "${{ matrix.os }}" == "ubuntu-latest" ]]; then
             pnpm run build:linux-x64
           elif [[ "${{ matrix.os }}" == "macos-latest" ]]; then
-            pnpm run build:aarch64
+            pnpm run build:mac-aarch64
           elif [[ "${{ matrix.os }}" == "windows-latest" ]]; then
             pnpm run build:win-x64
           fi
@@ -100,3 +114,7 @@ jobs:
       - name: Run Rust unit tests
         run: cargo test
         working-directory: src-tauri
+
+      - name: Run cargo audit security check
+        run: cargo audit
+        working-directory: src-tauri

.github/workflows/osv.yml

@@ -0,0 +1,74 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# A sample workflow which sets up periodic OSV-Scanner scanning for vulnerabilities,
+# in addition to a PR check which fails if new vulnerabilities are introduced.
+#
+# For more examples and options, including how to ignore specific vulnerabilities,
+# see https://google.github.io/osv-scanner/github-action/
+
+# Security vulnerability scanning for Donut Browser
+# Scans dependencies in package managers (npm/pnpm, Cargo) for known vulnerabilities
+# Runs on schedule and when dependencies change
+
+name: Security Vulnerability Scan
+
+on:
+  pull_request:
+    branches: ["main"]
+    paths:
+      - "package.json"
+      - "pnpm-lock.yaml"
+      - "src-tauri/Cargo.toml"
+      - "src-tauri/Cargo.lock"
+      - "nodecar/package.json"
+      - "nodecar/pnpm-lock.yaml"
+      - ".github/workflows/osv.yml"
+  merge_group:
+    branches: ["main"]
+  schedule:
+    # Run weekly on Tuesdays at 2:20 PM UTC
+    - cron: "20 14 * * 2"
+  push:
+    branches: ["main"]
+    paths:
+      - "package.json"
+      - "pnpm-lock.yaml"
+      - "src-tauri/Cargo.toml"
+      - "src-tauri/Cargo.lock"
+      - "nodecar/package.json"
+      - "nodecar/pnpm-lock.yaml"
+
+permissions:
+  security-events: write
+  contents: read
+  actions: read
+
+jobs:
+  scan-scheduled:
+    name: Scheduled Security Scan
+    if: ${{ github.event_name == 'push' || github.event_name == 'schedule' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/pnpm-lock.yaml
+        ./
+
+  scan-pr:
+    name: PR Security Scan
+    if: ${{ github.event_name == 'pull_request' || github.event_name == 'merge_group' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/pnpm-lock.yaml
+        ./

.github/workflows/pr-checks.yml

@@ -0,0 +1,54 @@
+name: Pull Request Checks
+
+on:
+  pull_request:
+    branches: ["main"]
+  merge_group:
+    branches: ["main"]
+
+permissions:
+  security-events: write
+  contents: read
+  actions: read
+
+jobs:
+  lint-js:
+    name: Lint JavaScript/TypeScript
+    uses: ./.github/workflows/lint-js.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  lint-rust:
+    name: Lint Rust
+    uses: ./.github/workflows/lint-rs.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  security-scan:
+    name: Security Vulnerability Scan
+    if: ${{ github.event_name == 'pull_request' || github.event_name == 'merge_group' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=nodecar/pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        ./
+
+  pr-status:
+    name: PR Status Check
+    runs-on: ubuntu-latest
+    needs: [lint-js, lint-rust, security-scan]
+    if: always()
+    steps:
+      - name: Check all jobs succeeded
+        run: |
+          if [[ "${{ needs.lint-js.result }}" != "success" || "${{ needs.lint-rust.result }}" != "success" || "${{ needs.security-scan.result }}" != "success" ]]; then
+            echo "One or more checks failed"
+            exit 1
+          fi
+          echo "All checks passed!"

.github/workflows/release.yml

@@ -8,9 +8,58 @@ on:
 env:
   TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
   TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+  STABLE_RELEASE: "true"
 
 jobs:
+  security-scan:
+    name: Security Vulnerability Scan
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/pnpm-lock.yaml
+        ./
+    permissions:
+      security-events: write
+      contents: read
+      actions: read
+
+  lint-js:
+    name: Lint JavaScript/TypeScript
+    uses: ./.github/workflows/lint-js.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  lint-rust:
+    name: Lint Rust
+    uses: ./.github/workflows/lint-rs.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  codeql:
+    name: CodeQL
+    uses: ./.github/workflows/codeql.yml
+    secrets: inherit
+    permissions:
+      security-events: write
+      contents: read
+      packages: read
+      actions: read
+
+  spellcheck:
+    name: Spell Check
+    uses: ./.github/workflows/spellcheck.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
   release:
+    needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
     permissions:
       contents: write
     strategy:
@@ -22,33 +71,32 @@ jobs:
             arch: "aarch64"
             target: "aarch64-apple-darwin"
             pkg_target: "latest-macos-arm64"
-            nodecar_script: "build:aarch64"
+            nodecar_script: "build:mac-aarch64"
           - platform: "macos-latest"
             args: "--target x86_64-apple-darwin"
             arch: "x86_64"
             target: "x86_64-apple-darwin"
             pkg_target: "latest-macos-x64"
-            nodecar_script: "build:x86_64"
-          # Future platforms can be added here:
-          # - platform: "ubuntu-20.04"
-          #   args: "--target x86_64-unknown-linux-gnu"
-          #   arch: "x86_64"
-          #   target: "x86_64-unknown-linux-gnu"
-          #   pkg_target: "latest-linux-x64"
-          #   nodecar_script: "build:linux-x64"
-          # - platform: "ubuntu-20.04"
-          #   args: "--target aarch64-unknown-linux-gnu"
-          #   arch: "aarch64"
-          #   target: "aarch64-unknown-linux-gnu"
-          #   pkg_target: "latest-linux-arm64"
-          #   nodecar_script: "build:linux-arm64"
+            nodecar_script: "build:mac-x86_64"
+          - platform: "ubuntu-22.04"
+            args: "--target x86_64-unknown-linux-gnu"
+            arch: "x86_64"
+            target: "x86_64-unknown-linux-gnu"
+            pkg_target: "latest-linux-x64"
+            nodecar_script: "build:linux-x64"
+          - platform: "ubuntu-22.04-arm"
+            args: "--target aarch64-unknown-linux-gnu"
+            arch: "aarch64"
+            target: "aarch64-unknown-linux-gnu"
+            pkg_target: "latest-linux-arm64"
+            nodecar_script: "build:linux-arm64"
           # - platform: "windows-latest"
           #   args: "--target x86_64-pc-windows-msvc"
           #   arch: "x86_64"
           #   target: "x86_64-pc-windows-msvc"
           #   pkg_target: "latest-win-x64"
           #   nodecar_script: "build:win-x64"
-          # - platform: "windows-latest"
+          # - platform: "windows-11-arm"
           #   args: "--target aarch64-pc-windows-msvc"
           #   arch: "aarch64"
           #   target: "aarch64-pc-windows-msvc"
@@ -57,29 +105,30 @@ jobs:
 
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
         with:
           node-version-file: .node-version
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda #v4.1.0
 
       - name: Setup Rust
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b #master
         with:
+          toolchain: stable
           targets: ${{ matrix.target }}
 
       - name: Install dependencies (Ubuntu only)
-        if: matrix.platform == 'ubuntu-20.04'
+        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev pkg-config xdg-utils
 
       - name: Rust cache
-        uses: swatinem/rust-cache@v2
+        uses: swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 #v2.7.8
         with:
           workdir: ./src-tauri
 
@@ -89,7 +138,7 @@ jobs:
       - name: Install nodecar dependencies
         working-directory: ./nodecar
         run: |
-          pnpm install --ignore-workspace --frozen-lockfile
+          pnpm install --frozen-lockfile
 
       - name: Build nodecar sidecar
         shell: bash
@@ -111,13 +160,21 @@ jobs:
         run: pnpm build
 
       - name: Build Tauri app
-        uses: tauri-apps/tauri-action@v0
+        uses: tauri-apps/tauri-action@42e9df6c59070d114bf90dcd3943a1b8f138b113 #v0.5.20
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REF_NAME: ${{ github.ref_name }}
         with:
           tagName: ${{ github.ref_name }}
           releaseName: "Donut Browser ${{ github.ref_name }}"
           releaseBody: "See the assets to download this version and install."
-          releaseDraft: true
+          releaseDraft: false
           prerelease: false
           args: ${{ matrix.args }}
+
+      - name: Commit CHANGELOG.md
+        uses: stefanzweifel/git-auto-commit-action@778341af668090896ca464160c2def5d1d1a3eb0 #v6.0.1
+        with:
+          branch: main
+          commit_message: "docs: update CHANGELOG.md for ${{ github.ref_name }} [skip ci]"
+          file_pattern: CHANGELOG.md

.github/workflows/rolling-release.yml

@@ -10,7 +10,55 @@ env:
   TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
 
 jobs:
+  security-scan:
+    name: Security Vulnerability Scan
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/pnpm-lock.yaml
+        ./
+    permissions:
+      security-events: write
+      contents: read
+      actions: read
+
+  lint-js:
+    name: Lint JavaScript/TypeScript
+    uses: ./.github/workflows/lint-js.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  lint-rust:
+    name: Lint Rust
+    uses: ./.github/workflows/lint-rs.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
+  codeql:
+    name: CodeQL
+    uses: ./.github/workflows/codeql.yml
+    secrets: inherit
+    permissions:
+      security-events: write
+      contents: read
+      packages: read
+      actions: read
+
+  spellcheck:
+    name: Spell Check
+    uses: ./.github/workflows/spellcheck.yml
+    secrets: inherit
+    permissions:
+      contents: read
+
   rolling-release:
+    needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
     permissions:
       contents: write
     strategy:
@@ -22,33 +70,64 @@ jobs:
             arch: "aarch64"
             target: "aarch64-apple-darwin"
             pkg_target: "latest-macos-arm64"
-            nodecar_script: "build:aarch64"
+            nodecar_script: "build:mac-aarch64"
           - platform: "macos-latest"
             args: "--target x86_64-apple-darwin"
             arch: "x86_64"
             target: "x86_64-apple-darwin"
             pkg_target: "latest-macos-x64"
-            nodecar_script: "build:x86_64"
+            nodecar_script: "build:mac-x86_64"
+          - platform: "ubuntu-22.04"
+            args: "--target x86_64-unknown-linux-gnu"
+            arch: "x86_64"
+            target: "x86_64-unknown-linux-gnu"
+            pkg_target: "latest-linux-x64"
+            nodecar_script: "build:linux-x64"
+          - platform: "ubuntu-22.04-arm"
+            args: "--target aarch64-unknown-linux-gnu"
+            arch: "aarch64"
+            target: "aarch64-unknown-linux-gnu"
+            pkg_target: "latest-linux-arm64"
+            nodecar_script: "build:linux-arm64"
+          - platform: "windows-latest"
+            args: "--target x86_64-pc-windows-msvc"
+            arch: "x86_64"
+            target: "x86_64-pc-windows-msvc"
+            pkg_target: "latest-win-x64"
+            nodecar_script: "build:win-x64"
+          - platform: "windows-11-arm"
+            args: "--target aarch64-pc-windows-msvc"
+            arch: "aarch64"
+            target: "aarch64-pc-windows-msvc"
+            pkg_target: "latest-win-arm64"
+            nodecar_script: "build:win-arm64"
 
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
 
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
         with:
           node-version-file: .node-version
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda #v4.1.0
 
       - name: Setup Rust
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b #master
         with:
+          toolchain: stable
           targets: ${{ matrix.target }}
 
+      - name: Install dependencies (Ubuntu only)
+        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev pkg-config xdg-utils
+
       - name: Rust cache
-        uses: swatinem/rust-cache@v2
+        uses: swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 #v2.7.8
         with:
           workdir: ./src-tauri
 
@@ -58,7 +137,7 @@ jobs:
       - name: Install nodecar dependencies
         working-directory: ./nodecar
         run: |
-          pnpm install --ignore-workspace --frozen-lockfile
+          pnpm install --frozen-lockfile
 
       - name: Build nodecar sidecar
         shell: bash
@@ -70,23 +149,35 @@ jobs:
         shell: bash
         run: |
           mkdir -p src-tauri/binaries
-          cp nodecar/dist/nodecar src-tauri/binaries/nodecar-${{ matrix.target }}
+          if [[ "${{ matrix.platform }}" == "windows-latest" ]]; then
+            cp nodecar/dist/nodecar.exe src-tauri/binaries/nodecar-${{ matrix.target }}.exe
+          else
+            cp nodecar/dist/nodecar src-tauri/binaries/nodecar-${{ matrix.target }}
+          fi
 
       - name: Build frontend
         run: pnpm build
 
-      - name: Get commit hash
-        id: commit
-        run: echo "hash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+      - name: Generate nightly timestamp
+        id: timestamp
+        shell: bash
+        run: |
+          TIMESTAMP=$(date -u +"%Y-%m-%d")
+          COMMIT_HASH=$(echo "${GITHUB_SHA}" | cut -c1-7)
+          echo "timestamp=${TIMESTAMP}-${COMMIT_HASH}" >> $GITHUB_OUTPUT
+          echo "Generated timestamp: ${TIMESTAMP}-${COMMIT_HASH}"
 
       - name: Build Tauri app
-        uses: tauri-apps/tauri-action@v0
+        uses: tauri-apps/tauri-action@42e9df6c59070d114bf90dcd3943a1b8f138b113 #v0.5.20
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BUILD_TAG: "nightly-${{ steps.timestamp.outputs.timestamp }}"
+          GITHUB_REF_NAME: "nightly-${{ steps.timestamp.outputs.timestamp }}"
+          GITHUB_SHA: ${{ github.sha }}
         with:
-          tagName: "alpha-${{ steps.commit.outputs.hash }}"
-          releaseName: "Donut Browser Alpha (Build ${{ steps.commit.outputs.hash }})"
-          releaseBody: "⚠️ **Alpha Release** - This is an automatically generated pre-release build from the latest main branch. Use with caution.\n\nCommit: ${{ github.sha }}\nBuild: ${{ steps.commit.outputs.hash }}"
+          tagName: "nightly-${{ steps.timestamp.outputs.timestamp }}"
+          releaseName: "Donut Browser Nightly (Build ${{ steps.timestamp.outputs.timestamp }})"
+          releaseBody: "⚠️ **Nightly Release** - This is an automatically generated pre-release build from the latest main branch. Use with caution.\n\nCommit: ${{ github.sha }}\nBuild: ${{ steps.timestamp.outputs.timestamp }}"
           releaseDraft: false
           prerelease: true
           args: ${{ matrix.args }}

.github/workflows/spellcheck.yml

@@ -0,0 +1,26 @@
+name: Spell Check
+
+permissions:
+  contents: read
+
+on:
+  workflow_call:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CLICOLOR: 1
+
+jobs:
+  spelling:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
+      - name: Spell Check Repo
+        uses: crate-ci/typos@b1ae8d918b6e85bd611117d3d9a3be4f903ee5e4 #v1.33.1

.gitignore

@@ -5,6 +5,10 @@
 /.pnp
 .pnp.js
 
+# npm/yarn lock files (project uses pnpm only)
+**/package-lock.json
+**/yarn.lock
+
 # testing
 /coverage
 
@@ -30,8 +34,8 @@ yarn-error.log*
 .pnpm-debug.log*
 
 # nodecar
-nodecar/dist
-nodecar/node_modules
+**/dist
+**/node_modules
 
 # local env files
 .env*.local
@@ -42,4 +46,7 @@ nodecar/node_modules
 # typescript
 *.tsbuildinfo
 
+# eslint
+.eslintcache
+
 !**/.gitkeep

.husky/pre-commit

@@ -1 +1 @@
-pnpm lint-staged
+pnpm exec lint-staged

.node-version

@@ -1,2 +1,2 @@
-22
+23
 

.nvmrc

@@ -0,0 +1 @@
+23 

.vscode/extensions.json

@@ -0,0 +1,11 @@
+{
+  "recommendations": [
+    "biomejs.biome",
+    "streetsidesoftware.code-spell-checker",
+    "usernamehw.errorlens",
+    "heybourn.headwind",
+    "yoavbls.pretty-ts-errors",
+    "rust-lang.rust-analyzer",
+    "bradlc.vscode-tailwindcss"
+  ]
+}

.vscode/settings.json

@@ -1,23 +1,87 @@
 {
   "cSpell.words": [
+    "ahooks",
+    "appimage",
+    "appindicator",
+    "applescript",
+    "autoconfig",
     "autologin",
+    "biomejs",
+    "cdylib",
     "CFURL",
+    "checkin",
+    "CLICOLOR",
     "clippy",
+    "cmdk",
+    "codegen",
+    "devedition",
+    "doesn",
     "donutbrowser",
+    "dpkg",
+    "dtolnay",
+    "dyld",
+    "elif",
+    "esbuild",
+    "eslintcache",
+    "frontmost",
+    "gifs",
+    "gsettings",
+    "icns",
+    "idletime",
+    "KHTML",
     "launchservices",
+    "libatk",
+    "libayatana",
+    "libcairo",
+    "libgdk",
+    "libglib",
+    "libpango",
+    "librsvg",
+    "libwebkit",
+    "libxdo",
     "mountpoint",
+    "msvc",
+    "msys",
+    "Mullvad",
+    "mullvadbrowser",
     "nodecar",
+    "nodemon",
     "ntlm",
+    "objc",
+    "orhun",
+    "osascript",
+    "pixbuf",
+    "plasmohq",
     "propertylist",
+    "reqwest",
+    "ridedott",
     "rlib",
     "rustc",
+    "SARIF",
     "serde",
     "shadcn",
     "signon",
+    "sonner",
     "sspi",
     "staticlib",
+    "stefanzweifel",
+    "subdirs",
+    "swatinem",
     "sysinfo",
     "systempreferences",
-    "turbopack"
+    "taskkill",
+    "tauri",
+    "titlebar",
+    "Torbrowser",
+    "turbopack",
+    "unlisten",
+    "unminimize",
+    "unrs",
+    "urlencoding",
+    "vercel",
+    "winreg",
+    "wiremock",
+    "xattr",
+    "zhom"
   ]
 }

AI_INSTRUCTIONS.md

@@ -0,0 +1,6 @@
+# Instructions for AI Agents
+
+- After your changes, instead of running specific tests or linting specific files, run "pnpm format && pnpm lint && pnpm test". It means that you first format the code, then lint it, then test it, so that no part is broken after your changes.
+- Don't leave comments that don't add value
+- Do not duplicate code unless you have a very good reason to do so. It is important that the same logic is not duplicated multiple times
+- Before finishing the task and showing summary, always run "pnpm format && pnpm lint && pnpm test" at the root of the project to ensure that you don't finish with broken application.

CODE_OF_CONDUCT.md

@@ -23,6 +23,6 @@ Examples of unacceptable behavior by participants include:
 
 ## Enforcement
 
-Violations of the Code of Conduct may be reported by pinging @zhom on Github. All reports will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. Further details of specific enforcement policies may be posted separately.
+Violations of the Code of Conduct may be reported to contact at donutbrowser dot com. All reports will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. Further details of specific enforcement policies may be posted separately.
 
 We hold the right and responsibility to remove comments or other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any members for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

CONTRIBUTING.md

@@ -50,7 +50,7 @@ After having the above dependencies installed, proceed through the following ste
 
    ```bash
    cd nodecar
-   pnpm install --ignore-workspace --frozen-lockfile
+   pnpm install --frozen-lockfile
    cd ..
    ```
 

README.md

@@ -6,15 +6,21 @@
 <br>
 
 <p align="center">
-  <a href="https://github.com/zhom/donutbrowser/releases/latest" target="_blank"><img alt="GitHub release" src="https://img.shields.io/github/v/release/zhom/donutbrowser">
+  <a style="text-decoration: none;" href="https://github.com/zhom/donutbrowser/releases/latest" target="_blank"><img alt="GitHub release" src="https://img.shields.io/github/v/release/zhom/donutbrowser">
   </a>
-  <a href="https://github.com/zhom/donutbrowser/issues" target="_blank">
+  <a style="text-decoration: none;" href="https://github.com/zhom/donutbrowser/issues" target="_blank">
     <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat" alt="PRs Welcome">
   </a>
-  <a href="https://github.com/zhom/donutbrowser/blob/main/LICENSE" target="_blank">
+  <a style="text-decoration: none;" href="https://github.com/zhom/donutbrowser/blob/main/LICENSE" target="_blank">
     <img src="https://img.shields.io/badge/license-AGPL--3.0-blue.svg" alt="License">
   </a>
-  <a href="https://github.com/zhom/donutbrowser/stargazers" target="_blank">
+  <a href="https://app.codacy.com/gh/zhom/donutbrowser/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade">
+    <img src="https://app.codacy.com/project/badge/Grade/b9c9beafc92d4bc8bc7c5b42c6c4ba81"/>
+  </a>
+  <a href="https://app.fossa.com/projects/git%2Bgithub.com%2Fzhom%2Fdonutbrowser?ref=badge_shield&issueType=security" alt="FOSSA Status">
+    <img src="https://app.fossa.com/api/projects/git%2Bgithub.com%2Fzhom%2Fdonutbrowser.svg?type=shield&issueType=security"/>
+  </a>
+  <a style="text-decoration: none;" href="https://github.com/zhom/donutbrowser/stargazers" target="_blank">
     <img src="https://img.shields.io/github/stars/zhom/donutbrowser?style=social" alt="GitHub stars">
   </a>
 </p>
@@ -23,17 +29,32 @@
 
 > A free and open source browser orchestrator built with [Tauri](https://v2.tauri.app/).
 
-![Donut Browser Preview](assets/preview.png)
+<picture>
+ <source media="(prefers-color-scheme: dark)" srcset="assets/preview-dark.png" />
+ <source media="(prefers-color-scheme: light)" srcset="assets/preview.png" />
+ <img alt="Preview" src="assets/preview.png" />
+</picture>
+
+## Features
+
+- Create unlimited number of local browser profiles completely isolated from each other
+- Proxy support with basic auth for all browsers except for TOR Browser
+- Import profiles from your existing browsers
+- Automatic updates both for browsers and for the app itself
+- Set Donut Browser as your default browser to control in which profile to open links
 
 ## Download
 
+> As of right now, the app is not signed by Apple. You need to have Gatekeeper disabled to run it. The app automatically checks for updates on each launch.
+> For Linux, .deb and .rpm packages are available as well as standalone .AppImage files.
+
 The app can be downloaded from the [releases page](https://github.com/zhom/donutbrowser/releases/latest).
 
 ## Supported Platforms
 
 - ✅ **macOS** (Intel & Apple Silicon)
+- ✅ **Linux** (x64 & arm64)
 - 🔄 **Windows** (Planned)
-- 🔄 **Linux** (Planned)
 
 ## Development
 
@@ -52,6 +73,20 @@ Have questions or want to contribute? We'd love to hear from you!
 - **Issues**: [GitHub Issues](https://github.com/zhom/donutbrowser/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/zhom/donutbrowser/discussions)
 
+## Star History
+
+<a href="https://www.star-history.com/#zhom/donutbrowser&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zhom/donutbrowser&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zhom/donutbrowser&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=zhom/donutbrowser&type=Date" />
+ </picture>
+</a>
+
+## Contact
+
+Have an urgent question or want to report a security vulnerability? Send an email to contact at donutbrowser dot com and we'll get back to you as fast as possible.
+
 ## License
 
 This project is licensed under the AGPL-3.0 License - see the [LICENSE](LICENSE) file for details.

SECURITY.md

@@ -0,0 +1,40 @@
+# Security Policy
+
+## Reporting Security Issues
+
+Thanks for helping make Donut Browser safe for everyone! ❤️
+
+We take the security of Donut Browser seriously. If you believe you have found a security vulnerability in Donut Browser, please report it to us through coordinated disclosure.
+
+**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.**
+
+Instead, please send an email to **contact at donutbrowser dot com** with the subject line "Security Vulnerability Report".
+
+Please include as much of the information listed below as you can to help us better understand and resolve the issue:
+
+- The type of issue (e.g., buffer overflow, injection attack, privilege escalation, or cross-site scripting)
+- Full paths of source file(s) related to the manifestation of the issue
+- The location of the affected source code (tag/branch/commit or direct URL)
+- Any special configuration required to reproduce the issue
+- Step-by-step instructions to reproduce the issue
+- Proof-of-concept or exploit code (if possible)
+- Impact of the issue, including how an attacker might exploit the issue
+- Your assessment of the severity level
+
+This information will help us triage your report more quickly.
+
+## What to Expect
+
+- **Response Time**: We will acknowledge receipt of your vulnerability report within 72 hours.
+- **Investigation**: We will investigate the issue and provide you with updates on our progress.
+- **Resolution**: We aim to resolve critical security issues as fast as possible, but no longer than in 30 days after the initial report.
+- **Disclosure**: We will coordinate with you on the timing of any public disclosure.
+
+## Contact
+
+For urgent security matters, please contact us at **contact at donutbrowser dot com**.
+
+For general questions about this security policy, you can also reach out through:
+
+- [GitHub Issues](https://github.com/zhom/donutbrowser/issues) (for non-security questions only)
+- [GitHub Discussions](https://github.com/zhom/donutbrowser/discussions)

components.json

@@ -4,7 +4,7 @@
   "rsc": true,
   "tsx": true,
   "tailwind": {
-    "config": "",
+    "config": "tailwind.config.js",
     "css": "src/styles/globals.css",
     "baseColor": "zinc",
     "cssVariables": true,
@@ -18,4 +18,4 @@
     "hooks": "@/hooks"
   },
   "iconLibrary": "lucide"
-}
+}

eslint.config.mjs

@@ -68,48 +68,7 @@ const eslintConfig = tseslint.config(
       "react-hooks/exhaustive-deps": "off",
       "react-hooks/rules-of-hooks": "off",
       // typescript-eslint rules - some handled by TypeScript compiler or disabled for project needs
-      "@typescript-eslint/adjacent-overload-signatures": "off",
-      "@typescript-eslint/array-type": "off",
-      "@typescript-eslint/ban-types": "off",
-      "@typescript-eslint/consistent-type-exports": "off",
-      "@typescript-eslint/consistent-type-imports": "off",
-      "@typescript-eslint/default-param-last": "off",
-      "@typescript-eslint/dot-notation": "off",
-      "@typescript-eslint/explicit-function-return-type": "off",
-      "@typescript-eslint/explicit-member-accessibility": "off",
-      "@typescript-eslint/naming-convention": "off",
-      "@typescript-eslint/no-dupe-class-members": "off",
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-empty-interface": "off",
       "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-extra-non-null-assertion": "off",
-      "@typescript-eslint/no-extraneous-class": "off",
-      "@typescript-eslint/no-inferrable-types": "off",
-      "@typescript-eslint/no-invalid-void-type": "off",
-      "@typescript-eslint/no-loss-of-precision": "off",
-      "@typescript-eslint/no-misused-new": "off",
-      "@typescript-eslint/no-namespace": "off",
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "@typescript-eslint/no-redeclare": "off",
-      "@typescript-eslint/no-require-imports": "off",
-      "@typescript-eslint/no-restricted-imports": "off",
-      "@typescript-eslint/no-restricted-types": "off",
-      "@typescript-eslint/no-this-alias": "off",
-      "@typescript-eslint/no-unnecessary-type-constraint": "off",
-      "@typescript-eslint/no-unsafe-declaration-merging": "off",
-      "@typescript-eslint/no-unused-vars": "off",
-      "@typescript-eslint/no-use-before-define": "off",
-      "@typescript-eslint/no-useless-constructor": "off",
-      "@typescript-eslint/no-useless-empty-export": "off",
-      "@typescript-eslint/only-throw-error": "off",
-      "@typescript-eslint/parameter-properties": "off",
-      "@typescript-eslint/prefer-as-const": "off",
-      "@typescript-eslint/prefer-enum-initializers": "off",
-      "@typescript-eslint/prefer-for-of": "off",
-      "@typescript-eslint/prefer-function-type": "off",
-      "@typescript-eslint/prefer-literal-enum-member": "off",
-      "@typescript-eslint/prefer-namespace-keyword": "off",
-      "@typescript-eslint/prefer-optional-chain": "off",
       "@typescript-eslint/require-await": "off",
       // Custom rules
       "@typescript-eslint/restrict-template-expressions": [
@@ -127,7 +86,7 @@ const eslintConfig = tseslint.config(
         tsconfigRootDir: import.meta.dirname,
       },
     },
-  },
+  }
 );
 
 export default eslintConfig;

nodecar/copy-binary.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Determine file extension based on platform
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" || "$OSTYPE" == "cygwin" ]]; then
+    EXT=".exe"
+else
+    EXT=""
+fi
+
+# If architecture provided in the command line, use it to rename the binary in TARGET_TRIPLE
+if [ -n "$1" ]; then
+    TARGET_TRIPLE="$1"
+else
+    RUST_INFO=$(rustc -vV)
+    TARGET_TRIPLE=$(echo "$RUST_INFO" | grep -o 'host: [^ ]*' | cut -d' ' -f2)
+fi
+
+# Check if target triple was found
+if [ -z "$TARGET_TRIPLE" ]; then
+    echo "Failed to determine platform target triple" >&2
+    exit 1
+fi
+
+# Copy the file with target triple suffix
+cp "dist/nodecar${EXT}" "../src-tauri/binaries/nodecar-${TARGET_TRIPLE}${EXT}"
+
+# Also copy a generic version for Tauri to find
+cp "dist/nodecar${EXT}" "../src-tauri/binaries/nodecar${EXT}"

nodecar/eslint.config.mjs

@@ -66,48 +66,7 @@ const eslintConfig = tseslint.config(
       "react-hooks/exhaustive-deps": "off",
       "react-hooks/rules-of-hooks": "off",
       // typescript-eslint rules - some handled by TypeScript compiler or disabled for project needs
-      "@typescript-eslint/adjacent-overload-signatures": "off",
-      "@typescript-eslint/array-type": "off",
-      "@typescript-eslint/ban-types": "off",
-      "@typescript-eslint/consistent-type-exports": "off",
-      "@typescript-eslint/consistent-type-imports": "off",
-      "@typescript-eslint/default-param-last": "off",
-      "@typescript-eslint/dot-notation": "off",
-      "@typescript-eslint/explicit-function-return-type": "off",
-      "@typescript-eslint/explicit-member-accessibility": "off",
-      "@typescript-eslint/naming-convention": "off",
-      "@typescript-eslint/no-dupe-class-members": "off",
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-empty-interface": "off",
       "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-extra-non-null-assertion": "off",
-      "@typescript-eslint/no-extraneous-class": "off",
-      "@typescript-eslint/no-inferrable-types": "off",
-      "@typescript-eslint/no-invalid-void-type": "off",
-      "@typescript-eslint/no-loss-of-precision": "off",
-      "@typescript-eslint/no-misused-new": "off",
-      "@typescript-eslint/no-namespace": "off",
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "@typescript-eslint/no-redeclare": "off",
-      "@typescript-eslint/no-require-imports": "off",
-      "@typescript-eslint/no-restricted-imports": "off",
-      "@typescript-eslint/no-restricted-types": "off",
-      "@typescript-eslint/no-this-alias": "off",
-      "@typescript-eslint/no-unnecessary-type-constraint": "off",
-      "@typescript-eslint/no-unsafe-declaration-merging": "off",
-      "@typescript-eslint/no-unused-vars": "off",
-      "@typescript-eslint/no-use-before-define": "off",
-      "@typescript-eslint/no-useless-constructor": "off",
-      "@typescript-eslint/no-useless-empty-export": "off",
-      "@typescript-eslint/only-throw-error": "off",
-      "@typescript-eslint/parameter-properties": "off",
-      "@typescript-eslint/prefer-as-const": "off",
-      "@typescript-eslint/prefer-enum-initializers": "off",
-      "@typescript-eslint/prefer-for-of": "off",
-      "@typescript-eslint/prefer-function-type": "off",
-      "@typescript-eslint/prefer-literal-enum-member": "off",
-      "@typescript-eslint/prefer-namespace-keyword": "off",
-      "@typescript-eslint/prefer-optional-chain": "off",
       "@typescript-eslint/require-await": "off",
       // Custom rules
       "@typescript-eslint/restrict-template-expressions": [

nodecar/package.json

@@ -2,32 +2,38 @@
   "name": "nodecar",
   "version": "1.0.0",
   "description": "",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
   "scripts": {
     "watch": "nodemon --exec ts-node --esm ./src/index.ts --watch src",
     "dev": "node --loader ts-node/esm ./src/index.ts",
-    "start": "node --loader ts-node/esm ./src/index.ts",
-    "build": "tsc && pkg ./dist/index.js --targets latest-macos-arm64 --output dist/nodecar",
-    "build:aarch64": "tsc && pkg ./dist/index.js --targets latest-macos-arm64 --output dist/nodecar",
-    "build:x86_64": "tsc && pkg ./dist/index.js --targets latest-macos-x64 --output dist/nodecar",
-    "build:linux-x64": "tsc && pkg ./dist/index.js --targets latest-linux-x64 --output dist/nodecar",
-    "build:linux-arm64": "tsc && pkg ./dist/index.js --targets latest-linux-arm64 --output dist/nodecar",
-    "build:win-x64": "tsc && pkg ./dist/index.js --targets latest-win-x64 --output dist/nodecar",
-    "build:win-arm64": "tsc && pkg ./dist/index.js --targets latest-win-arm64 --output dist/nodecar"
+    "start": "tsc && node ./dist/index.js",
+    "test": "tsc && node ./dist/test-proxy.js",
+    "rename-binary": "sh ./copy-binary.sh",
+    "build": "tsc && pkg ./dist/index.js --targets latest-macos-arm64 --output dist/nodecar && pnpm rename-binary",
+    "build:mac-aarch64": "tsc && pkg ./dist/index.js --targets latest-macos-arm64 --output dist/nodecar && pnpm rename-binary",
+    "build:mac-x86_64": "tsc && pkg ./dist/index.js --targets latest-macos-x64 --output dist/nodecar && pnpm rename-binary",
+    "build:linux-x64": "tsc && pkg ./dist/index.js --targets latest-linux-x64 --output dist/nodecar && pnpm rename-binary",
+    "build:linux-arm64": "tsc && pkg ./dist/index.js --targets latest-linux-arm64 --output dist/nodecar && pnpm rename-binary",
+    "build:win-x64": "tsc && pkg ./dist/index.js --targets latest-win-x64 --output dist/nodecar && pnpm rename-binary",
+    "build:win-arm64": "tsc && pkg ./dist/index.js --targets latest-win-arm64 --output dist/nodecar && pnpm rename-binary"
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.6.1",
+  "license": "AGPL-3.0",
   "dependencies": {
-    "@types/node": "^22.15.17",
-    "@yao-pkg/pkg": "^6.4.1",
-    "commander": "^13.1.0",
+    "@types/node": "^24.0.1",
+    "@yao-pkg/pkg": "^6.5.1",
+    "commander": "^14.0.0",
     "dotenv": "^16.5.0",
     "get-port": "^7.1.0",
     "nodemon": "^3.1.10",
-    "proxy-chain": "^2.5.8",
+    "proxy-chain": "^2.5.9",
+    "tmp": "^0.2.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.0"
+  },
+  "devDependencies": {
+    "@types/tmp": "^0.2.6"
   }
 }

nodecar/rename-binary.js

@@ -1,14 +0,0 @@
-import { execSync } from "child_process";
-import fs from "fs";
-
-const ext = process.platform === "win32" ? ".exe" : "";
-
-const rustInfo = execSync("rustc -vV");
-const targetTriple = /host: (\S+)/g.exec(rustInfo)[1];
-if (!targetTriple) {
-  console.error("Failed to determine platform target triple");
-}
-fs.renameSync(
-  `dist/nodecar${ext}`,
-  `../src-tauri/binaries/nodecar-${targetTriple}${ext}`
-);

nodecar/src/index.ts

@@ -1,8 +1,8 @@
 import { program } from "commander";
 import {
   startProxyProcess,
-  stopProxyProcess,
   stopAllProxyProcesses,
+  stopProxyProcess,
 } from "./proxy-runner";
 import { listProxyConfigs } from "./proxy-storage";
 import { runProxyWorker } from "./proxy-worker";
@@ -11,79 +11,127 @@ import { runProxyWorker } from "./proxy-worker";
 program
   .command("proxy")
   .argument("<action>", "start, stop, or list proxies")
-  .option(
-    "-u, --upstream <url>",
-    "upstream proxy URL (protocol://[username:password@]host:port)"
-  )
+  .option("--host <host>", "upstream proxy host")
+  .option("--proxy-port <port>", "upstream proxy port", Number.parseInt)
+  .option("--type <type>", "proxy type (http, https, socks4, socks5)")
+  .option("--username <username>", "proxy username")
+  .option("--password <password>", "proxy password")
   .option(
     "-p, --port <number>",
     "local port to use (random if not specified)",
-    Number.parseInt
+    Number.parseInt,
   )
   .option("--ignore-certificate", "ignore certificate errors for HTTPS proxies")
   .option("--id <id>", "proxy ID for stop command")
+  .option(
+    "-u, --upstream <url>",
+    "upstream proxy URL (protocol://[username:password@]host:port)",
+  )
   .description("manage proxy servers")
   .action(
     async (
       action: string,
       options: {
-        upstream?: string;
+        host?: string;
+        proxyPort?: number;
+        type?: string;
+        username?: string;
+        password?: string;
         port?: number;
         ignoreCertificate?: boolean;
         id?: string;
-      }
+        upstream?: string;
+      },
     ) => {
       if (action === "start") {
-        if (!options.upstream) {
-          console.error("Error: Upstream proxy URL is required");
-          console.log(
-            "Example: proxy start -u http://username:password@proxy.example.com:8080"
+        let upstreamUrl: string;
+
+        // Build upstream URL from individual components if provided
+        if (options.host && options.proxyPort && options.type) {
+          const protocol =
+            options.type === "socks4" || options.type === "socks5"
+              ? options.type
+              : "http";
+          const auth =
+            options.username && options.password
+              ? `${encodeURIComponent(options.username)}:${encodeURIComponent(
+                  options.password,
+                )}@`
+              : "";
+          upstreamUrl = `${protocol}://${auth}${options.host}:${options.proxyPort}`;
+        } else if (options.upstream) {
+          upstreamUrl = options.upstream;
+        } else {
+          console.error(
+            "Error: Either --upstream URL or --host, --proxy-port, and --type are required",
           );
+          console.log(
+            "Example: proxy start --host datacenter.proxyempire.io --proxy-port 9000 --type http --username user --password pass",
+          );
+          process.exit(1);
           return;
         }
 
         try {
-          const config = await startProxyProcess(options.upstream, {
+          const config = await startProxyProcess(upstreamUrl, {
             port: options.port,
             ignoreProxyCertificate: options.ignoreCertificate,
           });
-          console.log(JSON.stringify(config));
-        } catch (error: any) {
-          console.error(`Failed to start proxy: ${error.message}`);
+
+          // Output the configuration as JSON for the Rust side to parse
+          console.log(
+            JSON.stringify({
+              id: config.id,
+              localPort: config.localPort,
+              localUrl: config.localUrl,
+              upstreamUrl: config.upstreamUrl,
+            }),
+          );
+
+          // Exit successfully to allow the process to detach
+          process.exit(0);
+        } catch (error: unknown) {
+          console.error(
+            `Failed to start proxy: ${
+              error instanceof Error ? error.message : JSON.stringify(error)
+            }`,
+          );
+          process.exit(1);
         }
       } else if (action === "stop") {
         if (options.id) {
           const stopped = await stopProxyProcess(options.id);
-          console.log(`{
-            "success": ${stopped}}`);
+          console.log(JSON.stringify({ success: stopped }));
         } else if (options.upstream) {
           // Find proxies with this upstream URL
           const configs = listProxyConfigs().filter(
-            (config) => config.upstreamUrl === options.upstream
+            (config) => config.upstreamUrl === options.upstream,
           );
 
           if (configs.length === 0) {
             console.error(`No proxies found for ${options.upstream}`);
+            process.exit(1);
             return;
           }
 
           for (const config of configs) {
             const stopped = await stopProxyProcess(config.id);
-            console.log(`{
-            "success": ${stopped}}`);
+            console.log(JSON.stringify({ success: stopped }));
           }
         } else {
           await stopAllProxyProcesses();
-          console.log(`{
-            "success": true}`);
+          console.log(JSON.stringify({ success: true }));
         }
+        process.exit(0);
       } else if (action === "list") {
         const configs = listProxyConfigs();
         console.log(JSON.stringify(configs));
+        process.exit(0);
       } else {
         console.error("Invalid action. Use 'start', 'stop', or 'list'");
+        process.exit(1);
       }
-    }
+    },
   );
 
 // Command for proxy worker (internal use)

nodecar/src/proxy-runner.ts

@@ -1,14 +1,14 @@
-import { spawn } from "child_process";
-import path from "path";
+import { spawn } from "node:child_process";
+import path from "node:path";
 import getPort from "get-port";
 import {
   type ProxyConfig,
-  saveProxyConfig,
-  getProxyConfig,
   deleteProxyConfig,
-  isProcessRunning,
   generateProxyId,
+  getProxyConfig,
+  isProcessRunning,
   listProxyConfigs,
+  saveProxyConfig,
 } from "./proxy-storage";
 
 /**
@@ -19,50 +19,53 @@ import {
  */
 export async function startProxyProcess(
   upstreamUrl: string,
-  options: { port?: number; ignoreProxyCertificate?: boolean } = {}
+  options: { port?: number; ignoreProxyCertificate?: boolean } = {},
 ): Promise<ProxyConfig> {
   // Generate a unique ID for this proxy
   const id = generateProxyId();
 
   // Get a random available port if not specified
-  const port = options.port || (await getPort());
+  const port = options.port ?? (await getPort());
 
   // Create the proxy configuration
   const config: ProxyConfig = {
     id,
     upstreamUrl,
     localPort: port,
-    ignoreProxyCertificate: options.ignoreProxyCertificate || false,
+    ignoreProxyCertificate: options.ignoreProxyCertificate ?? false,
   };
 
   // Save the configuration before starting the process
   saveProxyConfig(config);
 
   // Build the command arguments
-  const args = ["proxy-worker", "start", "--id", id];
+  const args = [
+    path.join(__dirname, "index.js"),
+    "proxy-worker",
+    "start",
+    "--id",
+    id,
+  ];
 
-  // Spawn the process
-  const child = spawn(
-    process.execPath,
-    [path.join(__dirname, "index.js"), ...args],
-    {
-      detached: true,
-      stdio: "ignore",
-    }
-  );
+  // Spawn the process with proper detachment
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"], // Completely ignore all stdio
+    cwd: process.cwd(),
+  });
 
   // Unref the child to allow the parent to exit independently
   child.unref();
 
-  // Store the process ID
+  // Store the process ID and local URL
   config.pid = child.pid;
-  config.localUrl = `http://localhost:${port}`;
+  config.localUrl = `http://127.0.0.1:${port}`;
 
   // Update the configuration with the process ID
   saveProxyConfig(config);
 
-  // Wait a bit to ensure the proxy has started
-  await new Promise((resolve) => setTimeout(resolve, 500));
+  // Give the worker a moment to start before returning
+  await new Promise((resolve) => setTimeout(resolve, 100));
 
   return config;
 }
@@ -75,7 +78,9 @@ export async function startProxyProcess(
 export async function stopProxyProcess(id: string): Promise<boolean> {
   const config = getProxyConfig(id);
 
-  if (!config || !config.pid) {
+  if (!config?.pid) {
+    // Try to delete the config anyway in case it exists without a PID
+    deleteProxyConfig(id);
     return false;
   }
 
@@ -83,10 +88,16 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
     // Check if the process is running
     if (isProcessRunning(config.pid)) {
       // Send SIGTERM to the process
-      process.kill(config.pid);
+      process.kill(config.pid, "SIGTERM");
 
       // Wait a bit to ensure the process has terminated
-      await new Promise((resolve) => setTimeout(resolve, 300));
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      // If still running, send SIGKILL
+      if (isProcessRunning(config.pid)) {
+        process.kill(config.pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
     }
 
     // Delete the configuration
@@ -95,6 +106,8 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
     return true;
   } catch (error) {
     console.error(`Error stopping proxy ${id}:`, error);
+    // Delete the configuration even if stopping failed
+    deleteProxyConfig(id);
     return false;
   }
 }
@@ -106,7 +119,6 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
 export async function stopAllProxyProcesses(): Promise<void> {
   const configs = listProxyConfigs();
 
-  for (const config of configs) {
-    await stopProxyProcess(config.id);
-  }
+  const stopPromises = configs.map((config) => stopProxyProcess(config.id));
+  await Promise.all(stopPromises);
 }

nodecar/src/proxy-storage.ts

@@ -1,8 +1,7 @@
-import fs from "fs";
-import path from "path";
-import os from "os";
+import fs from "node:fs";
+import path from "node:path";
+import tmp from "tmp";
 
-// Define the proxy configuration type
 export interface ProxyConfig {
   id: string;
   upstreamUrl: string;
@@ -12,10 +11,11 @@ export interface ProxyConfig {
   pid?: number;
 }
 
-// Path to store proxy configurations
-const STORAGE_DIR = path.join(os.tmpdir(), "donutbrowser", "proxies");
+const STORAGE_DIR = tmp.dirSync({
+  prefix: "donutbrowser-proxies-",
+  unsafeCleanup: true,
+}).name;
 
-// Ensure storage directory exists
 if (!fs.existsSync(STORAGE_DIR)) {
   fs.mkdirSync(STORAGE_DIR, { recursive: true });
 }
@@ -88,7 +88,7 @@ export function listProxyConfigs(): ProxyConfig[] {
         try {
           const content = fs.readFileSync(
             path.join(STORAGE_DIR, file),
-            "utf-8"
+            "utf-8",
           );
           return JSON.parse(content) as ProxyConfig;
         } catch (error) {
@@ -111,14 +111,18 @@ export function listProxyConfigs(): ProxyConfig[] {
 export function updateProxyConfig(config: ProxyConfig): boolean {
   const filePath = path.join(STORAGE_DIR, `${config.id}.json`);
 
-  if (!fs.existsSync(filePath)) {
-    return false;
-  }
-
   try {
+    fs.readFileSync(filePath, "utf-8");
     fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
     return true;
   } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      console.error(
+        `Config ${config.id} was deleted while the app was running`,
+      );
+      return false;
+    }
+
     console.error(`Error updating proxy config ${config.id}:`, error);
     return false;
   }
@@ -135,7 +139,7 @@ export function isProcessRunning(pid: number): boolean {
     // but checks if it exists
     process.kill(pid, 0);
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

nodecar/src/proxy-worker.ts

@@ -1,5 +1,5 @@
 import { Server } from "proxy-chain";
-import { getProxyConfig } from "./proxy-storage";
+import { getProxyConfig, updateProxyConfig } from "./proxy-storage";
 
 /**
  * Run a proxy server as a worker process
@@ -8,44 +8,68 @@ import { getProxyConfig } from "./proxy-storage";
 export async function runProxyWorker(id: string): Promise<void> {
   // Get the proxy configuration
   const config = getProxyConfig(id);
-  
+
   if (!config) {
     console.error(`Proxy configuration ${id} not found`);
     process.exit(1);
   }
-  
+
   // Create a new proxy server
   const server = new Server({
     port: config.localPort,
-    host: "localhost",
+    host: "127.0.0.1",
     prepareRequestFunction: () => {
       return {
         upstreamProxyUrl: config.upstreamUrl,
-        ignoreUpstreamProxyCertificate: config.ignoreProxyCertificate || false,
+        ignoreUpstreamProxyCertificate: config.ignoreProxyCertificate ?? false,
       };
     },
   });
-  
-  // Handle process termination
-  process.on("SIGTERM", async () => {
-    console.log(`Proxy worker ${id} received SIGTERM, shutting down...`);
-    await server.close(true);
+
+  // Handle process termination gracefully
+  const gracefulShutdown = async (signal: string) => {
+    console.log(`Proxy worker ${id} received ${signal}, shutting down...`);
+    try {
+      await server.close(true);
+      console.log(`Proxy worker ${id} shut down successfully`);
+    } catch (error) {
+      console.error(`Error during shutdown for proxy ${id}:`, error);
+    }
     process.exit(0);
+  };
+
+  process.on("SIGTERM", () => void gracefulShutdown("SIGTERM"));
+  process.on("SIGINT", () => void gracefulShutdown("SIGINT"));
+
+  // Handle uncaught exceptions
+  process.on("uncaughtException", (error) => {
+    console.error(`Uncaught exception in proxy worker ${id}:`, error);
+    process.exit(1);
   });
-  
-  process.on("SIGINT", async () => {
-    console.log(`Proxy worker ${id} received SIGINT, shutting down...`);
-    await server.close(true);
-    process.exit(0);
+
+  process.on("unhandledRejection", (reason) => {
+    console.error(`Unhandled rejection in proxy worker ${id}:`, reason);
+    process.exit(1);
   });
-  
+
   // Start the server
   try {
     await server.listen();
+
+    // Update the config with the actual port (in case it was auto-assigned)
+    config.localPort = server.port;
+    config.localUrl = `http://127.0.0.1:${server.port}`;
+    updateProxyConfig(config);
+
     console.log(`Proxy worker ${id} started on port ${server.port}`);
     console.log(`Forwarding to upstream proxy: ${config.upstreamUrl}`);
+
+    // Keep the process alive
+    setInterval(() => {
+      // Do nothing, just keep the process alive
+    }, 60000);
   } catch (error) {
     console.error(`Failed to start proxy worker ${id}:`, error);
     process.exit(1);
   }
-}
+}

nodecar/src/proxy.ts

@@ -1,73 +0,0 @@
-import { 
-  startProxyProcess, 
-  stopProxyProcess, 
-  stopAllProxyProcesses 
-} from "./proxy-runner";
-import { listProxyConfigs } from "./proxy-storage";
-
-// Type definitions
-interface ProxyOptions {
-  port?: number;
-  ignoreProxyCertificate?: boolean;
-}
-
-/**
- * Start a local proxy server that forwards to an upstream proxy
- * @param upstreamProxyUrl The upstream proxy URL (protocol://[username:password@]host:port)
- * @param options Optional configuration
- * @returns Promise resolving to the local proxy URL
- */
-export async function startProxy(
-  upstreamProxyUrl: string,
-  options: ProxyOptions = {}
-): Promise<string> {
-  const config = await startProxyProcess(upstreamProxyUrl, {
-    port: options.port,
-    ignoreProxyCertificate: options.ignoreProxyCertificate,
-  });
-  
-  return config.localUrl || `http://localhost:${config.localPort}`;
-}
-
-/**
- * Stop a specific proxy by its upstream URL
- * @param upstreamProxyUrl The upstream proxy URL to stop
- * @returns Promise resolving to true if proxy was found and stopped, false otherwise
- */
-export async function stopProxy(upstreamProxyUrl: string): Promise<boolean> {
-  // Find all proxies with this upstream URL
-  const configs = listProxyConfigs().filter(
-    config => config.upstreamUrl === upstreamProxyUrl
-  );
-  
-  if (configs.length === 0) {
-    return false;
-  }
-  
-  // Stop all matching proxies
-  let success = true;
-  for (const config of configs) {
-    const stopped = await stopProxyProcess(config.id);
-    if (!stopped) {
-      success = false;
-    }
-  }
-  
-  return success;
-}
-
-/**
- * Get a list of all active proxy upstream URLs
- * @returns Array of upstream proxy URLs
- */
-export function getActiveProxies(): string[] {
-  return listProxyConfigs().map(config => config.upstreamUrl);
-}
-
-/**
- * Stop all active proxies
- * @returns Promise that resolves when all proxies are stopped
- */
-export async function stopAllProxies(): Promise<void> {
-  await stopAllProxyProcesses();
-}

package.json

@@ -1,21 +1,27 @@
 {
   "name": "donutbrowser",
   "private": true,
-  "version": "0.1.0",
+  "license": "AGPL-3.0",
+  "version": "0.5.3",
   "type": "module",
   "scripts": {
     "dev": "next dev --turbopack",
     "build": "next build",
     "start": "next start",
-    "lint": "biome check src/ && tsc --noEmit && next lint",
-    "lint:rust": "cd src-tauri && cargo clippy --all-targets --all-features -- -D warnings -D clippy::all",
+    "test": "pnpm test:rust",
+    "test:rust": "cd src-tauri && cargo test",
+    "lint": "pnpm lint:js && pnpm lint:rust",
+    "lint:js": "biome check src/ && tsc --noEmit && next lint",
+    "lint:rust": "cd src-tauri && cargo clippy --all-targets --all-features -- -D warnings -D clippy::all && cargo fmt --all",
     "tauri": "tauri",
     "shadcn:add": "pnpm dlx shadcn@latest add",
-    "prepare": "husky",
-    "format:js": "biome check src/ --fix",
+    "prepare": "husky && husky install",
     "format:rust": "cd src-tauri && cargo clippy --fix --allow-dirty --all-targets --all-features -- -D warnings -D clippy::all && cargo fmt --all",
-    "format:biome": "biome check src/ --fix",
-    "format": "pnpm format:js && pnpm format:rust"
+    "format:js": "biome check src/ --fix",
+    "format": "pnpm format:js && pnpm format:rust",
+    "cargo": "cd src-tauri && cargo",
+    "unused-exports:js": "ts-unused-exports tsconfig.json",
+    "check-unused-commands": "cd src-tauri && cargo run --bin check_unused_commands"
   },
   "dependencies": {
     "@radix-ui/react-checkbox": "^1.3.2",
@@ -30,46 +36,52 @@
     "@radix-ui/react-tooltip": "^1.2.7",
     "@tanstack/react-table": "^8.21.3",
     "@tauri-apps/api": "^2.5.0",
+    "@tauri-apps/plugin-deep-link": "^2.3.0",
+    "@tauri-apps/plugin-dialog": "^2.2.2",
     "@tauri-apps/plugin-fs": "~2.3.0",
     "@tauri-apps/plugin-opener": "^2.2.7",
+    "ahooks": "^3.8.5",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "next": "^15.3.2",
+    "next": "^15.3.3",
     "next-themes": "^0.4.6",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-icons": "^5.5.0",
-    "sonner": "^2.0.3",
-    "tailwind-merge": "^3.3.0"
+    "sonner": "^2.0.5",
+    "tailwind-merge": "^3.3.1",
+    "tauri-plugin-macos-permissions-api": "^2.3.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.27.0",
-    "@next/eslint-plugin-next": "^15.3.2",
-    "@tailwindcss/postcss": "^4.1.7",
+    "@eslint/js": "^9.29.0",
+    "@next/eslint-plugin-next": "^15.3.3",
+    "@tailwindcss/postcss": "^4.1.10",
     "@tauri-apps/cli": "^2.5.0",
-    "@types/node": "^22.15.21",
-    "@types/react": "^19.1.5",
-    "@types/react-dom": "^19.1.5",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "@vitejs/plugin-react": "^4.5.0",
-    "eslint": "^9.27.0",
-    "eslint-config-next": "^15.3.2",
+    "@types/node": "^24.0.1",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@typescript-eslint/eslint-plugin": "^8.34.0",
+    "@typescript-eslint/parser": "^8.34.0",
+    "@vitejs/plugin-react": "^4.5.2",
+    "eslint": "^9.29.0",
+    "eslint-config-next": "^15.3.3",
     "eslint-plugin-react-hooks": "^5.2.0",
     "husky": "^9.1.7",
-    "lint-staged": "^15.3.0",
-    "tailwindcss": "^4.1.7",
-    "tw-animate-css": "^1.3.0",
+    "lint-staged": "^16.1.1",
+    "tailwindcss": "^4.1.10",
+    "ts-unused-exports": "^11.0.1",
+    "tw-animate-css": "^1.3.4",
     "typescript": "~5.8.3",
-    "typescript-eslint": "^8.32.1"
+    "typescript-eslint": "^8.34.0"
   },
-  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977",
+  "packageManager": "pnpm@10.11.1",
   "lint-staged": {
-    "src/**/*.{js,jsx,ts,tsx,json,css,md}": [
-      "biome check --fix"
+    "**/*.{js,jsx,ts,tsx,json,css,md}": [
+      "biome check --fix",
+      "eslint --cache --fix"
     ],
     "src-tauri/**/*.rs": [
       "cd src-tauri && cargo fmt --all",

pnpm-workspace.yaml

@@ -1,5 +1,9 @@
+packages:
+  - "nodecar"
+
 onlyBuiltDependencies:
-  - '@biomejs/biome'
-  - '@tailwindcss/oxide'
+  - "@biomejs/biome"
+  - "@tailwindcss/oxide"
   - esbuild
   - sharp
+  - unrs-resolver

src-tauri/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "donutbrowser"
-version = "0.1.0"
-description = "A Tauri App"
+version = "0.5.3"
+description = "Simple Yet Powerful Browser Orchestrator"
 authors = ["zhom@github"]
 edition = "2021"
+default-run = "donutbrowser"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -20,11 +21,13 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 serde_json = "1"
 serde = { version = "1", features = ["derive"] }
-tauri = { version = "2", features = ["devtools"] }
+tauri = { version = "2", features = ["devtools", "test"] }
 tauri-plugin-opener = "2"
 tauri-plugin-fs = "2"
 tauri-plugin-shell = "2"
 tauri-plugin-deep-link = "2"
+tauri-plugin-dialog = "2"
+tauri-plugin-macos-permissions = "2"
 directories = "6"
 reqwest = { version = "0.12", features = ["json", "stream"] }
 tokio = { version = "1", features = ["full"] }
@@ -34,13 +37,39 @@ base64 = "0.22"
 zip = "4"
 async-trait = "0.1"
 futures-util = "0.3"
+urlencoding = "2.1"
+
+[target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
+tauri-plugin-single-instance = { version = "2", features = ["deep-link"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation="0.10"
+objc2 = "0.6.1"
+objc2-app-kit = { version = "0.3.1", features = ["NSWindow"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winreg = "0.55"
+windows = { version = "0.61", features = [
+  "Win32_Foundation",
+  "Win32_System_ProcessStatus",
+  "Win32_System_Threading",
+  "Win32_System_Diagnostics_Debug",
+  "Win32_System_SystemInformation",
+  "Win32_Security",
+  "Win32_Storage_FileSystem",
+  "Win32_System_Registry",
+  "Win32_UI_Shell",
+] }
 
 [dev-dependencies]
 tempfile = "3.13.0"
 tokio-test = "0.4.4"
+wiremock = "0.6"
+hyper = { version = "1.0", features = ["full"] }
+hyper-util = { version = "0.1", features = ["full"] }
+http-body-util = "0.1"
+tower = "0.5"
+tower-http = { version = "0.6", features = ["fs", "trace"] }
 
 [features]
 # by default Tauri runs in production mode

src-tauri/Info.plist

@@ -2,47 +2,57 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>NSCameraUsageDescription</key>
+	<string>Donut Browser needs camera access to enable camera functionality in web browsers. Each website will still ask for your permission individually.</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Donut Browser needs microphone access to enable microphone functionality in web browsers. Each website will still ask for your permission individually.</string>
+	<key>NSLocalNetworkUsageDescription</key>
+	<string>Donut Browser has proxy functionality that requires local network access. You can deny this functionality if you don't plan on setting proxies for browser profiles.</string>
 	<key>CFBundleDisplayName</key>
 	<string>Donut Browser</string>
 	<key>CFBundleName</key>
 	<string>Donut Browser</string>
 	<key>CFBundleIdentifier</key>
 	<string>com.donutbrowser</string>
+    <key>CFBundleURLName</key>
+    <string>com.donutbrowser</string>
 	<key>CFBundleExecutable</key>
 	<string>donutbrowser</string>
 	<key>CFBundleVersion</key>
 	<string>1</string>
-	<key>CFBundleShortVersionString</key>
-	<string>0.1.0</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleIconFile</key>
-	<string>icon.icns</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
 	<key>CFBundleIconFile</key>
 	<string>icon.icns</string>
+	<key>LSApplicationCategoryType</key>
+	<string>public.app-category.productivity</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright © 2025 Donut Browser</string>
+	<key>CFBundleDocumentTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleTypeName</key>
+			<string>HTML document</string>
+			<key>CFBundleTypeRole</key>
+			<string>Viewer</string>
+			<key>LSHandlerRank</key>
+			<string>Default</string>
+			<key>LSItemContentTypes</key>
+			<array>
+				<string>public.html</string>
+				<string>public.xhtml</string>
+			</array>
+		</dict>
+	</array>
 	<key>CFBundleURLTypes</key>
 	<array>
 		<dict>
 			<key>CFBundleURLName</key>
-			<string>Web Browser</string>
+			<string>Web site URL</string>
 			<key>CFBundleURLSchemes</key>
 			<array>
 				<string>http</string>
 				<string>https</string>
 			</array>
-			<key>CFBundleURLIconFile</key>
-			<string>icon.icns</string>
-			<key>LSHandlerRank</key>
-			<string>Owner</string>
 		</dict>
 	</array>
-	<key>LSApplicationCategoryType</key>
-	<string>public.app-category.productivity</string>
-	<key>NSHumanReadableCopyright</key>
-	<string>Copyright © 2025 Donut Browser</string>
-	<key>LSMinimumSystemVersion</key>
-	<string>10.13</string>
 </dict>
 </plist> 

src-tauri/assets/template.pac

@@ -1,14 +1,3 @@
 function FindProxyForURL(url, host) {
-  const proxyString = "{{proxy_url}}";
-
-  // Split the proxy string to get the credentials part
-  const parts = proxyString.split(" ")[1].split("@");
-  if (parts.length > 1) {
-    const credentials = parts[0];
-    const encodedCredentials = encodeURIComponent(credentials);
-    // Replace the original credentials with encoded ones
-    return proxyString.replace(credentials, encodedCredentials);
-  }
-
-  return proxyString;
+  return "{{proxy_url}}";
 }

src-tauri/build.rs

@@ -5,5 +5,26 @@ fn main() {
     println!("cargo:rustc-link-lib=framework=CoreServices");
   }
 
+  // Inject build version based on environment variables set by CI
+  if let Ok(build_tag) = std::env::var("BUILD_TAG") {
+    // Custom BUILD_TAG takes highest priority (used for nightly builds)
+    println!("cargo:rustc-env=BUILD_VERSION={build_tag}");
+  } else if let Ok(tag_name) = std::env::var("GITHUB_REF_NAME") {
+    // This is set by GitHub Actions to the tag name (e.g., "v1.0.0")
+    println!("cargo:rustc-env=BUILD_VERSION={tag_name}");
+  } else if std::env::var("STABLE_RELEASE").is_ok() {
+    // Fallback for stable releases - use CARGO_PKG_VERSION with 'v' prefix
+    let version = std::env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
+    println!("cargo:rustc-env=BUILD_VERSION=v{version}");
+  } else if let Ok(commit_hash) = std::env::var("GITHUB_SHA") {
+    // For nightly builds, use timestamp format or fallback to commit hash
+    let short_hash = &commit_hash[0..7.min(commit_hash.len())];
+    println!("cargo:rustc-env=BUILD_VERSION=nightly-{short_hash}");
+  } else {
+    // Development build fallback
+    let version = std::env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "0.1.0".to_string());
+    println!("cargo:rustc-env=BUILD_VERSION=dev-{version}");
+  }
+
   tauri_build::build()
 }

src-tauri/capabilities/default.json

@@ -6,6 +6,11 @@
   "permissions": [
     "core:default",
     "core:event:default",
+    "core:window:default",
+    "core:window:allow-start-dragging",
+    "core:window:allow-close",
+    "core:window:allow-minimize",
+    "core:window:allow-toggle-maximize",
     "opener:default",
     "fs:default",
     "shell:allow-execute",
@@ -13,6 +18,17 @@
     "shell:allow-open",
     "shell:allow-spawn",
     "shell:allow-stdin-write",
-    "deep-link:default"
+    "deep-link:default",
+    "deep-link:allow-register",
+    "deep-link:allow-unregister",
+    "deep-link:allow-is-registered",
+    "deep-link:allow-get-current",
+    "dialog:default",
+    "dialog:allow-open",
+    "macos-permissions:default",
+    "macos-permissions:allow-request-microphone-permission",
+    "macos-permissions:allow-request-camera-permission",
+    "macos-permissions:allow-check-microphone-permission",
+    "macos-permissions:allow-check-camera-permission"
   ]
 }

src-tauri/donutbrowser.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=Donut Browser
+Comment=Simple Yet Powerful Browser Orchestrator
+Exec=donutbrowser %u
+Icon=donutbrowser
+StartupNotify=true
+NoDisplay=false
+Categories=Network;WebBrowser;Productivity;
+MimeType=x-scheme-handler/http;x-scheme-handler/https;text/html;application/xhtml+xml;
+StartupWMClass=donutbrowser
+Keywords=browser;web;internet;productivity;

src-tauri/entitlements.plist

@@ -12,5 +12,21 @@
     <true/>
     <key>com.apple.security.files.downloads.read-write</key>
     <true/>
+    <key>com.apple.security.device.camera</key>
+    <true/>
+    <key>com.apple.security.device.audio-output</key>
+    <true/>
+    <key>com.apple.security.device.microphone</key>
+    <true/>
+    <key>com.apple.security.device.audio-input</key>
+    <true/>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
 </dict>
 </plist> 

src-tauri/src/auto_updater.rs

@@ -1,3 +1,4 @@
+use crate::api_client::is_browser_version_nightly;
 use crate::browser_runner::{BrowserProfile, BrowserRunner};
 use crate::browser_version_service::{BrowserVersionInfo, BrowserVersionService};
 use crate::settings_manager::SettingsManager;
@@ -5,6 +6,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::PathBuf;
+use tauri::Emitter;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct UpdateNotification {
@@ -45,32 +47,32 @@ impl AutoUpdater {
   pub async fn check_for_updates(
     &self,
   ) -> Result<Vec<UpdateNotification>, Box<dyn std::error::Error + Send + Sync>> {
-    // Check if auto-updates are enabled
-    let settings = self
-      .settings_manager
-      .load_settings()
-      .map_err(|e| format!("Failed to load settings: {e}"))?;
-    if !settings.auto_updates_enabled {
-      return Ok(Vec::new());
-    }
+    let mut notifications = Vec::new();
+    let mut browser_versions: HashMap<String, Vec<BrowserVersionInfo>> = HashMap::new();
 
+    // Group profiles by browser
     let profiles = self
       .browser_runner
       .list_profiles()
       .map_err(|e| format!("Failed to list profiles: {e}"))?;
-    let mut notifications = Vec::new();
-    let mut browser_versions: HashMap<String, Vec<BrowserVersionInfo>> = HashMap::new();
-
-    // Group profiles by browser type
     let mut browser_profiles: HashMap<String, Vec<BrowserProfile>> = HashMap::new();
+
     for profile in profiles {
+      // Only check supported browsers
+      if !self
+        .version_service
+        .is_browser_supported(&profile.browser)
+        .unwrap_or(false)
+      {
+        continue;
+      }
+
       browser_profiles
         .entry(profile.browser.clone())
         .or_default()
         .push(profile);
     }
 
-    // Check each browser type
     for (browser, profiles) in browser_profiles {
       // Get cached versions first, then try to fetch if needed
       let versions = if let Some(cached) = self
@@ -97,7 +99,26 @@ impl AutoUpdater {
       // Check each profile for updates
       for profile in profiles {
         if let Some(update) = self.check_profile_update(&profile, &versions)? {
-          notifications.push(update);
+          // Apply chromium threshold logic
+          if browser == "chromium" {
+            // For chromium, only show notifications if there are 50+ new versions
+            let current_version = &profile.version.parse::<u32>().unwrap();
+            let new_version = &update.new_version.parse::<u32>().unwrap();
+
+            let result = new_version - current_version;
+            println!(
+              "Current version: {current_version}, New version: {new_version}, Result: {result}"
+            );
+            if result > 50 {
+              notifications.push(update);
+            } else {
+              println!(
+                "Skipping chromium update notification: only {result} new versions (need 50+)"
+              );
+            }
+          } else {
+            notifications.push(update);
+          }
         }
       }
     }
@@ -105,6 +126,93 @@ impl AutoUpdater {
     Ok(notifications)
   }
 
+  pub async fn check_for_updates_with_progress(&self, app_handle: &tauri::AppHandle) {
+    println!("Starting auto-update check with progress...");
+
+    // Check for browser updates and trigger auto-downloads
+    match self.check_for_updates().await {
+      Ok(update_notifications) => {
+        if !update_notifications.is_empty() {
+          println!(
+            "Found {} browser updates to auto-download",
+            update_notifications.len()
+          );
+
+          // Trigger automatic downloads for each update
+          for notification in update_notifications {
+            println!(
+              "Auto-downloading {} version {}",
+              notification.browser, notification.new_version
+            );
+
+            // Clone app_handle for the async task
+            let app_handle_clone = app_handle.clone();
+            let browser = notification.browser.clone();
+            let new_version = notification.new_version.clone();
+            let notification_id = notification.id.clone();
+            let affected_profiles = notification.affected_profiles.clone();
+
+            // Spawn async task to handle the download and auto-update
+            tokio::spawn(async move {
+              // First, check if browser already exists
+              match crate::browser_runner::is_browser_downloaded(
+                browser.clone(),
+                new_version.clone(),
+              ) {
+                true => {
+                  println!("Browser {browser} {new_version} already downloaded, proceeding to auto-update profiles");
+
+                  // Browser already exists, go straight to profile update
+                  match crate::auto_updater::complete_browser_update_with_auto_update(
+                    browser.clone(),
+                    new_version.clone(),
+                  )
+                  .await
+                  {
+                    Ok(updated_profiles) => {
+                      println!(
+                        "Auto-update completed for {} profiles: {:?}",
+                        updated_profiles.len(),
+                        updated_profiles
+                      );
+                    }
+                    Err(e) => {
+                      eprintln!("Failed to complete auto-update for {browser}: {e}");
+                    }
+                  }
+                }
+                false => {
+                  println!("Downloading browser {browser} version {new_version}...");
+
+                  // Emit the auto-update event to trigger frontend handling
+                  let auto_update_event = serde_json::json!({
+                    "browser": browser,
+                    "new_version": new_version,
+                    "notification_id": notification_id,
+                    "affected_profiles": affected_profiles
+                  });
+
+                  if let Err(e) =
+                    app_handle_clone.emit("browser-auto-update-available", &auto_update_event)
+                  {
+                    eprintln!("Failed to emit auto-update event for {browser}: {e}");
+                  } else {
+                    println!("Emitted auto-update event for {browser}");
+                  }
+                }
+              }
+            });
+          }
+        } else {
+          println!("No browser updates needed");
+        }
+      }
+      Err(e) => {
+        eprintln!("Failed to check for browser updates: {e}");
+      }
+    }
+  }
+
   /// Check if a specific profile has an available update
   fn check_profile_update(
     &self,
@@ -112,16 +220,15 @@ impl AutoUpdater {
     available_versions: &[BrowserVersionInfo],
   ) -> Result<Option<UpdateNotification>, Box<dyn std::error::Error + Send + Sync>> {
     let current_version = &profile.version;
-    let is_current_stable = !self.is_alpha_version(current_version);
+    let is_current_nightly = is_browser_version_nightly(&profile.browser, current_version, None);
 
     // Find the best available update
     let best_update = available_versions
       .iter()
       .filter(|v| {
         // Only consider versions newer than current
-        self.is_version_newer(&v.version, current_version) &&
-                // Respect version type preference
-                is_current_stable != v.is_prerelease
+        self.is_version_newer(&v.version, current_version)
+          && is_browser_version_nightly(&profile.browser, &v.version, None) == is_current_nightly
       })
       .max_by(|a, b| self.compare_versions(&a.version, &b.version));
 
@@ -181,77 +288,6 @@ impl AutoUpdater {
     result
   }
 
-  /// Mark download as auto-update
-  pub fn mark_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let mut state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    state.auto_update_downloads.insert(download_key);
-    self.save_auto_update_state(&state)?;
-    Ok(())
-  }
-
-  /// Remove auto-update download tracking
-  pub fn remove_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let mut state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    state.auto_update_downloads.remove(&download_key);
-    self.save_auto_update_state(&state)?;
-    Ok(())
-  }
-
-  /// Check if download is marked as auto-update
-  pub fn is_auto_update_download(
-    &self,
-    browser: &str,
-    version: &str,
-  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
-    let state = self.load_auto_update_state()?;
-    let download_key = format!("{browser}-{version}");
-    Ok(state.auto_update_downloads.contains(&download_key))
-  }
-
-  /// Start browser update process
-  pub async fn start_browser_update(
-    &self,
-    browser: &str,
-    new_version: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    // Add browser to disabled list to prevent conflicts during update
-    let mut state = self.load_auto_update_state()?;
-    state.disabled_browsers.insert(browser.to_string());
-
-    // Mark this download as auto-update for toast suppression
-    let download_key = format!("{browser}-{new_version}");
-    state.auto_update_downloads.insert(download_key);
-
-    self.save_auto_update_state(&state)?;
-
-    // The actual download will be triggered by the frontend
-    // This function now just marks the browser as updating to prevent conflicts
-    Ok(())
-  }
-
-  /// Complete browser update process
-  pub async fn complete_browser_update(
-    &self,
-    browser: &str,
-  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    // Remove browser from disabled list
-    let mut state = self.load_auto_update_state()?;
-    state.disabled_browsers.remove(browser);
-    self.save_auto_update_state(&state)?;
-
-    Ok(())
-  }
-
   /// Automatically update all affected profile versions after browser download
   pub async fn auto_update_profile_versions(
     &self,
@@ -312,9 +348,51 @@ impl AutoUpdater {
     state.auto_update_downloads.remove(&download_key);
     self.save_auto_update_state(&state)?;
 
+    // Check if auto-delete of unused binaries is enabled and perform cleanup
+    let settings = self
+      .settings_manager
+      .load_settings()
+      .map_err(|e| format!("Failed to load settings: {e}"))?;
+    if settings.auto_delete_unused_binaries {
+      // Perform cleanup in the background - don't fail the update if cleanup fails
+      if let Err(e) = self.cleanup_unused_binaries_internal() {
+        eprintln!("Warning: Failed to cleanup unused binaries after auto-update: {e}");
+      }
+    }
+
     Ok(updated_profiles)
   }
 
+  /// Internal method to cleanup unused binaries (used by auto-cleanup)
+  fn cleanup_unused_binaries_internal(
+    &self,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
+    // Load current profiles
+    let profiles = self
+      .browser_runner
+      .list_profiles()
+      .map_err(|e| format!("Failed to load profiles: {e}"))?;
+
+    // Load registry
+    let mut registry = crate::downloaded_browsers::DownloadedBrowsersRegistry::load()
+      .map_err(|e| format!("Failed to load browser registry: {e}"))?;
+
+    // Get active browser versions
+    let active_versions = registry.get_active_browser_versions(&profiles);
+
+    // Cleanup unused binaries
+    let cleaned_up = registry
+      .cleanup_unused_binaries(&active_versions)
+      .map_err(|e| format!("Failed to cleanup unused binaries: {e}"))?;
+
+    // Save updated registry
+    registry
+      .save()
+      .map_err(|e| format!("Failed to save registry: {e}"))?;
+
+    Ok(cleaned_up)
+  }
+
   /// Check if browser is disabled due to ongoing update
   pub fn is_browser_disabled(
     &self,
@@ -335,17 +413,6 @@ impl AutoUpdater {
     Ok(())
   }
 
-  // Helper methods
-
-  fn is_alpha_version(&self, version: &str) -> bool {
-    version.contains("alpha")
-      || version.contains("beta")
-      || version.contains("rc")
-      || version.contains("a")
-      || version.contains("b")
-      || version.contains("dev")
-  }
-
   fn is_version_newer(&self, version1: &str, version2: &str) -> bool {
     self.compare_versions(version1, version2) == std::cmp::Ordering::Greater
   }
@@ -414,24 +481,6 @@ pub async fn check_for_browser_updates() -> Result<Vec<UpdateNotification>, Stri
   Ok(grouped)
 }
 
-#[tauri::command]
-pub async fn start_browser_update(browser: String, new_version: String) -> Result<(), String> {
-  let updater = AutoUpdater::new();
-  updater
-    .start_browser_update(&browser, &new_version)
-    .await
-    .map_err(|e| format!("Failed to start browser update: {e}"))
-}
-
-#[tauri::command]
-pub async fn complete_browser_update(browser: String) -> Result<(), String> {
-  let updater = AutoUpdater::new();
-  updater
-    .complete_browser_update(&browser)
-    .await
-    .map_err(|e| format!("Failed to complete browser update: {e}"))
-}
-
 #[tauri::command]
 pub async fn is_browser_disabled_for_update(browser: String) -> Result<bool, String> {
   let updater = AutoUpdater::new();
@@ -461,27 +510,9 @@ pub async fn complete_browser_update_with_auto_update(
 }
 
 #[tauri::command]
-pub async fn mark_auto_update_download(browser: String, version: String) -> Result<(), String> {
+pub async fn check_for_updates_with_progress(app_handle: tauri::AppHandle) {
   let updater = AutoUpdater::new();
-  updater
-    .mark_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to mark auto-update download: {e}"))
-}
-
-#[tauri::command]
-pub async fn remove_auto_update_download(browser: String, version: String) -> Result<(), String> {
-  let updater = AutoUpdater::new();
-  updater
-    .remove_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to remove auto-update download: {e}"))
-}
-
-#[tauri::command]
-pub async fn is_auto_update_download(browser: String, version: String) -> Result<bool, String> {
-  let updater = AutoUpdater::new();
-  updater
-    .is_auto_update_download(&browser, &version)
-    .map_err(|e| format!("Failed to check auto-update download: {e}"))
+  updater.check_for_updates_with_progress(&app_handle).await;
 }
 
 #[cfg(test)]
@@ -497,6 +528,7 @@ mod tests {
       process_id: None,
       proxy: None,
       last_launch: None,
+      release_type: "stable".to_string(),
     }
   }
 
@@ -508,21 +540,6 @@ mod tests {
     }
   }
 
-  #[test]
-  fn test_is_alpha_version() {
-    let updater = AutoUpdater::new();
-
-    assert!(updater.is_alpha_version("1.0.0-alpha"));
-    assert!(updater.is_alpha_version("1.0.0-beta"));
-    assert!(updater.is_alpha_version("1.0.0-rc"));
-    assert!(updater.is_alpha_version("1.0.0a1"));
-    assert!(updater.is_alpha_version("1.0.0b1"));
-    assert!(updater.is_alpha_version("1.0.0-dev"));
-
-    assert!(!updater.is_alpha_version("1.0.0"));
-    assert!(!updater.is_alpha_version("1.2.3"));
-  }
-
   #[test]
   fn test_compare_versions() {
     let updater = AutoUpdater::new();

src-tauri/src/browser.rs

@@ -1,6 +1,4 @@
-use base64::{engine::general_purpose, Engine as _};
 use serde::{Deserialize, Serialize};
-use std::fs;
 use std::path::{Path, PathBuf};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -9,6 +7,8 @@ pub struct ProxySettings {
   pub proxy_type: String, // "http", "https", "socks4", or "socks5"
   pub host: String,
   pub port: u16,
+  pub username: Option<String>,
+  pub password: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -50,33 +50,25 @@ impl BrowserType {
 }
 
 pub trait Browser: Send + Sync {
-  fn browser_type(&self) -> BrowserType;
   fn get_executable_path(&self, install_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>>;
   fn create_launch_args(
     &self,
     profile_path: &str,
-    _proxy_settings: Option<&ProxySettings>,
+    proxy_settings: Option<&ProxySettings>,
     url: Option<String>,
   ) -> Result<Vec<String>, Box<dyn std::error::Error>>;
   fn is_version_downloaded(&self, version: &str, binaries_dir: &Path) -> bool;
+  fn prepare_executable(&self, executable_path: &Path) -> Result<(), Box<dyn std::error::Error>>;
 }
 
-pub struct FirefoxBrowser {
-  browser_type: BrowserType,
-}
+// Platform-specific modules
+#[cfg(target_os = "macos")]
+mod macos {
+  use super::*;
 
-impl FirefoxBrowser {
-  pub fn new(browser_type: BrowserType) -> Self {
-    Self { browser_type }
-  }
-}
-
-impl Browser for FirefoxBrowser {
-  fn browser_type(&self) -> BrowserType {
-    self.browser_type.clone()
-  }
-
-  fn get_executable_path(&self, install_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
+  pub fn get_firefox_executable_path(
+    install_dir: &Path,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
     // Find the .app directory
     let app_path = std::fs::read_dir(install_dir)?
       .filter_map(Result::ok)
@@ -106,6 +98,427 @@ impl Browser for FirefoxBrowser {
     Ok(executable_path)
   }
 
+  pub fn get_chromium_executable_path(
+    install_dir: &Path,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    // Find the .app directory
+    let app_path = std::fs::read_dir(install_dir)?
+      .filter_map(Result::ok)
+      .find(|entry| entry.path().extension().is_some_and(|ext| ext == "app"))
+      .ok_or("Browser app not found")?;
+
+    // Construct the browser executable path
+    let mut executable_dir = app_path.path();
+    executable_dir.push("Contents");
+    executable_dir.push("MacOS");
+
+    // Find the first executable in the MacOS directory
+    let executable_path = std::fs::read_dir(&executable_dir)?
+      .filter_map(Result::ok)
+      .find(|entry| {
+        let binding = entry.file_name();
+        let name = binding.to_string_lossy();
+        name.contains("Chromium") || name.contains("Brave") || name.contains("Google Chrome")
+      })
+      .map(|entry| entry.path())
+      .ok_or("No executable found in MacOS directory")?;
+
+    Ok(executable_path)
+  }
+
+  pub fn is_firefox_version_downloaded(install_dir: &Path) -> bool {
+    // On macOS, check for .app files
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        if entry.path().extension().is_some_and(|ext| ext == "app") {
+          return true;
+        }
+      }
+    }
+    false
+  }
+
+  pub fn is_chromium_version_downloaded(install_dir: &Path) -> bool {
+    // On macOS, check for .app files
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        if entry.path().extension().is_some_and(|ext| ext == "app") {
+          return true;
+        }
+      }
+    }
+    false
+  }
+
+  pub fn prepare_executable(_executable_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    // On macOS, no special preparation needed
+    Ok(())
+  }
+}
+
+#[cfg(target_os = "linux")]
+mod linux {
+  use super::*;
+  use std::os::unix::fs::PermissionsExt;
+
+  pub fn get_firefox_executable_path(
+    install_dir: &Path,
+    browser_type: &BrowserType,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    // Expected structure: install_dir/<browser>/<binary>
+    let browser_subdir = install_dir.join(browser_type.as_str());
+
+    // Try firefox first (preferred), then firefox-bin
+    let possible_executables = match browser_type {
+      BrowserType::Firefox | BrowserType::FirefoxDeveloper => {
+        vec![
+          browser_subdir.join("firefox"),
+          browser_subdir.join("firefox-bin"),
+        ]
+      }
+      BrowserType::MullvadBrowser => {
+        vec![
+          browser_subdir.join("firefox"),
+          browser_subdir.join("mullvad-browser"),
+          browser_subdir.join("firefox-bin"),
+        ]
+      }
+      BrowserType::Zen => {
+        vec![browser_subdir.join("zen"), browser_subdir.join("zen-bin")]
+      }
+      BrowserType::TorBrowser => {
+        vec![
+          browser_subdir.join("firefox"),
+          browser_subdir.join("tor-browser"),
+          browser_subdir.join("firefox-bin"),
+        ]
+      }
+      _ => vec![],
+    };
+
+    for executable_path in &possible_executables {
+      if executable_path.exists() && executable_path.is_file() {
+        return Ok(executable_path.clone());
+      }
+    }
+
+    Err(
+      format!(
+        "Firefox executable not found in {}/{}",
+        install_dir.display(),
+        browser_type.as_str()
+      )
+      .into(),
+    )
+  }
+
+  pub fn get_chromium_executable_path(
+    install_dir: &Path,
+    browser_type: &BrowserType,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let possible_executables = match browser_type {
+      BrowserType::Chromium => vec![install_dir.join("chromium"), install_dir.join("chrome")],
+      BrowserType::Brave => vec![
+        install_dir.join("brave"),
+        install_dir.join("brave-browser"),
+        install_dir.join("brave-browser-nightly"),
+        install_dir.join("brave-browser-beta"),
+      ],
+      _ => vec![],
+    };
+
+    for executable_path in &possible_executables {
+      if executable_path.exists() && executable_path.is_file() {
+        return Ok(executable_path.clone());
+      }
+    }
+
+    Err(
+      format!(
+        "Chromium executable not found in {}/{}",
+        install_dir.display(),
+        browser_type.as_str()
+      )
+      .into(),
+    )
+  }
+
+  pub fn is_firefox_version_downloaded(install_dir: &Path, browser_type: &BrowserType) -> bool {
+    // Expected structure: install_dir/<browser>/<binary>
+    let browser_subdir = install_dir.join(browser_type.as_str());
+
+    if !browser_subdir.exists() || !browser_subdir.is_dir() {
+      return false;
+    }
+
+    let possible_executables = match browser_type {
+      BrowserType::Firefox | BrowserType::FirefoxDeveloper => {
+        vec![
+          browser_subdir.join("firefox-bin"),
+          browser_subdir.join("firefox"),
+        ]
+      }
+      BrowserType::MullvadBrowser => {
+        vec![
+          browser_subdir.join("mullvad-browser"),
+          browser_subdir.join("firefox-bin"),
+          browser_subdir.join("firefox"),
+        ]
+      }
+      BrowserType::Zen => {
+        vec![browser_subdir.join("zen"), browser_subdir.join("zen-bin")]
+      }
+      BrowserType::TorBrowser => {
+        vec![
+          browser_subdir.join("tor-browser"),
+          browser_subdir.join("firefox-bin"),
+          browser_subdir.join("firefox"),
+        ]
+      }
+      _ => vec![],
+    };
+
+    for exe_path in &possible_executables {
+      if exe_path.exists() && exe_path.is_file() {
+        return true;
+      }
+    }
+
+    false
+  }
+
+  pub fn is_chromium_version_downloaded(install_dir: &Path, browser_type: &BrowserType) -> bool {
+    let possible_executables = match browser_type {
+      BrowserType::Chromium => vec![install_dir.join("chromium"), install_dir.join("chrome")],
+      BrowserType::Brave => vec![
+        install_dir.join("brave"),
+        install_dir.join("brave-browser"),
+        install_dir.join("brave-browser-nightly"),
+        install_dir.join("brave-browser-beta"),
+      ],
+      _ => vec![],
+    };
+
+    for exe_path in &possible_executables {
+      if exe_path.exists() && exe_path.is_file() {
+        return true;
+      }
+    }
+
+    false
+  }
+
+  pub fn prepare_executable(executable_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    // On Linux, ensure the executable has proper permissions
+    println!("Setting execute permissions for: {:?}", executable_path);
+
+    let metadata = std::fs::metadata(executable_path)?;
+    let mut permissions = metadata.permissions();
+
+    // Add execute permissions for owner, group, and others
+    let mode = permissions.mode();
+    permissions.set_mode(mode | 0o755);
+
+    std::fs::set_permissions(executable_path, permissions)?;
+
+    println!(
+      "Execute permissions set successfully for: {:?}",
+      executable_path
+    );
+    Ok(())
+  }
+}
+
+#[cfg(target_os = "windows")]
+mod windows {
+  use super::*;
+
+  pub fn get_firefox_executable_path(
+    install_dir: &Path,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    // On Windows, look for firefox.exe
+    let possible_paths = [
+      install_dir.join("firefox.exe"),
+      install_dir.join("firefox").join("firefox.exe"),
+      install_dir.join("bin").join("firefox.exe"),
+    ];
+
+    for path in &possible_paths {
+      if path.exists() && path.is_file() {
+        return Ok(path.clone());
+      }
+    }
+
+    // Look for any .exe file that might be the browser
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().is_some_and(|ext| ext == "exe") {
+          let name = path.file_stem().unwrap_or_default().to_string_lossy();
+          if name.starts_with("firefox")
+            || name.starts_with("mullvad")
+            || name.starts_with("zen")
+            || name.starts_with("tor")
+            || name.contains("browser")
+          {
+            return Ok(path);
+          }
+        }
+      }
+    }
+
+    Err("Firefox executable not found in Windows installation directory".into())
+  }
+
+  pub fn get_chromium_executable_path(
+    install_dir: &Path,
+    browser_type: &BrowserType,
+  ) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    // On Windows, look for .exe files
+    let possible_paths = match browser_type {
+      BrowserType::Chromium => vec![
+        install_dir.join("chromium.exe"),
+        install_dir.join("chrome.exe"),
+        install_dir.join("chromium-browser.exe"),
+        install_dir.join("bin").join("chromium.exe"),
+      ],
+      BrowserType::Brave => vec![
+        install_dir.join("brave.exe"),
+        install_dir.join("brave-browser.exe"),
+        install_dir.join("bin").join("brave.exe"),
+      ],
+      _ => vec![],
+    };
+
+    for path in &possible_paths {
+      if path.exists() && path.is_file() {
+        return Ok(path.clone());
+      }
+    }
+
+    // Look for any .exe file that might be the browser
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().is_some_and(|ext| ext == "exe") {
+          let name = path.file_stem().unwrap_or_default().to_string_lossy();
+          if name.contains("chromium") || name.contains("brave") || name.contains("chrome") {
+            return Ok(path);
+          }
+        }
+      }
+    }
+
+    Err("Chromium/Brave executable not found in Windows installation directory".into())
+  }
+
+  pub fn is_firefox_version_downloaded(install_dir: &Path) -> bool {
+    // On Windows, check for .exe files
+    let possible_executables = [
+      install_dir.join("firefox.exe"),
+      install_dir.join("firefox").join("firefox.exe"),
+      install_dir.join("bin").join("firefox.exe"),
+    ];
+
+    for exe_path in &possible_executables {
+      if exe_path.exists() && exe_path.is_file() {
+        return true;
+      }
+    }
+
+    // Check for any .exe file that looks like a browser
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+
+        if path.extension().is_some_and(|ext| ext == "exe") {
+          let name = path.file_stem().unwrap_or_default().to_string_lossy();
+          if name.starts_with("firefox")
+            || name.starts_with("mullvad")
+            || name.starts_with("zen")
+            || name.starts_with("tor")
+            || name.contains("browser")
+          {
+            return true;
+          }
+        }
+      }
+    }
+
+    false
+  }
+
+  pub fn is_chromium_version_downloaded(install_dir: &Path, browser_type: &BrowserType) -> bool {
+    // On Windows, check for .exe files
+    let possible_executables = match browser_type {
+      BrowserType::Chromium => vec![
+        install_dir.join("chromium.exe"),
+        install_dir.join("chrome.exe"),
+        install_dir.join("chromium-browser.exe"),
+        install_dir.join("bin").join("chromium.exe"),
+      ],
+      BrowserType::Brave => vec![
+        install_dir.join("brave.exe"),
+        install_dir.join("brave-browser.exe"),
+        install_dir.join("bin").join("brave.exe"),
+      ],
+      _ => vec![],
+    };
+
+    for exe_path in &possible_executables {
+      if exe_path.exists() && exe_path.is_file() {
+        return true;
+      }
+    }
+
+    // Check for any .exe file that looks like the browser
+    if let Ok(entries) = std::fs::read_dir(install_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+
+        if path.extension().is_some_and(|ext| ext == "exe") {
+          let name = path.file_stem().unwrap_or_default().to_string_lossy();
+          if name.contains("chromium") || name.contains("brave") || name.contains("chrome") {
+            return true;
+          }
+        }
+      }
+    }
+
+    false
+  }
+
+  pub fn prepare_executable(_executable_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    // On Windows, no special preparation needed
+    Ok(())
+  }
+}
+
+pub struct FirefoxBrowser {
+  browser_type: BrowserType,
+}
+
+impl FirefoxBrowser {
+  pub fn new(browser_type: BrowserType) -> Self {
+    Self { browser_type }
+  }
+}
+
+impl Browser for FirefoxBrowser {
+  fn get_executable_path(&self, install_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    #[cfg(target_os = "macos")]
+    return macos::get_firefox_executable_path(install_dir);
+
+    #[cfg(target_os = "linux")]
+    return linux::get_firefox_executable_path(install_dir, &self.browser_type);
+
+    #[cfg(target_os = "windows")]
+    return windows::get_firefox_executable_path(install_dir);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    Err("Unsupported platform".into())
+  }
+
   fn create_launch_args(
     &self,
     profile_path: &str,
@@ -135,34 +548,52 @@ impl Browser for FirefoxBrowser {
   }
 
   fn is_version_downloaded(&self, version: &str, binaries_dir: &Path) -> bool {
-    let browser_dir = binaries_dir
-      .join(self.browser_type().as_str())
-      .join(version);
+    // Expected structure: binaries/<browser>/<version>
+    let browser_dir = binaries_dir.join(self.browser_type.as_str()).join(version);
 
     println!("Firefox browser checking version {version} in directory: {browser_dir:?}");
 
-    // Only check if directory exists and contains a .app file
-    if browser_dir.exists() {
-      println!("Directory exists, checking for .app files...");
-      if let Ok(entries) = std::fs::read_dir(&browser_dir) {
-        for entry in entries.flatten() {
-          println!("  Found entry: {:?}", entry.path());
-          if entry.path().extension().is_some_and(|ext| ext == "app") {
-            println!("  Found .app file: {:?}", entry.path());
-            return true;
-          }
-        }
-      }
-      println!("No .app files found in directory");
-    } else {
+    if !browser_dir.exists() {
       println!("Directory does not exist: {browser_dir:?}");
+      return false;
     }
-    false
+
+    println!("Directory exists, checking for browser files...");
+
+    #[cfg(target_os = "macos")]
+    return macos::is_firefox_version_downloaded(&browser_dir);
+
+    #[cfg(target_os = "linux")]
+    return linux::is_firefox_version_downloaded(&browser_dir, &self.browser_type);
+
+    #[cfg(target_os = "windows")]
+    return windows::is_firefox_version_downloaded(&browser_dir);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    {
+      println!("Unsupported platform for browser verification");
+      false
+    }
+  }
+
+  fn prepare_executable(&self, executable_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    #[cfg(target_os = "macos")]
+    return macos::prepare_executable(executable_path);
+
+    #[cfg(target_os = "linux")]
+    return linux::prepare_executable(executable_path);
+
+    #[cfg(target_os = "windows")]
+    return windows::prepare_executable(executable_path);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    Err("Unsupported platform".into())
   }
 }
 
 // Chromium-based browsers (Chromium, Brave)
 pub struct ChromiumBrowser {
+  #[allow(dead_code)]
   browser_type: BrowserType,
 }
 
@@ -173,34 +604,18 @@ impl ChromiumBrowser {
 }
 
 impl Browser for ChromiumBrowser {
-  fn browser_type(&self) -> BrowserType {
-    self.browser_type.clone()
-  }
-
   fn get_executable_path(&self, install_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    // Find the .app directory
-    let app_path = std::fs::read_dir(install_dir)?
-      .filter_map(Result::ok)
-      .find(|entry| entry.path().extension().is_some_and(|ext| ext == "app"))
-      .ok_or("Browser app not found")?;
+    #[cfg(target_os = "macos")]
+    return macos::get_chromium_executable_path(install_dir);
 
-    // Construct the browser executable path
-    let mut executable_dir = app_path.path();
-    executable_dir.push("Contents");
-    executable_dir.push("MacOS");
+    #[cfg(target_os = "linux")]
+    return linux::get_chromium_executable_path(install_dir, &self.browser_type);
 
-    // Find the first executable in the MacOS directory
-    let executable_path = std::fs::read_dir(&executable_dir)?
-      .filter_map(Result::ok)
-      .find(|entry| {
-        let binding = entry.file_name();
-        let name = binding.to_string_lossy();
-        name.contains("Chromium") || name.contains("Brave") || name.contains("Google Chrome")
-      })
-      .map(|entry| entry.path())
-      .ok_or("No executable found in MacOS directory")?;
+    #[cfg(target_os = "windows")]
+    return windows::get_chromium_executable_path(install_dir, &self.browser_type);
 
-    Ok(executable_path)
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    Err("Unsupported platform".into())
   }
 
   fn create_launch_args(
@@ -216,19 +631,16 @@ impl Browser for ChromiumBrowser {
       "--disable-component-update".to_string(),
       "--disable-background-timer-throttling".to_string(),
       "--crash-server-url=".to_string(),
+      "--disable-updater".to_string(),
     ];
 
     // Add proxy configuration if provided
     if let Some(proxy) = proxy_settings {
       if proxy.enabled {
-        let pac_path = Path::new(profile_path).join("proxy.pac");
-        if pac_path.exists() {
-          let pac_content = fs::read(&pac_path)?;
-          let pac_base64 = general_purpose::STANDARD.encode(&pac_content);
-          args.push(format!(
-            "--proxy-pac-url=data:application/x-javascript-config;base64,{pac_base64}"
-          ));
-        }
+        args.push(format!(
+          "--proxy-server=http://{}:{}",
+          proxy.host, proxy.port
+        ));
       }
     }
 
@@ -240,35 +652,46 @@ impl Browser for ChromiumBrowser {
   }
 
   fn is_version_downloaded(&self, version: &str, binaries_dir: &Path) -> bool {
-    let browser_dir = binaries_dir
-      .join(self.browser_type().as_str())
-      .join(version);
+    // Expected structure: binaries/<browser>/<version>
+    let browser_dir = binaries_dir.join(self.browser_type.as_str()).join(version);
 
     println!("Chromium browser checking version {version} in directory: {browser_dir:?}");
 
-    // Check if directory exists and contains at least one .app file
-    if browser_dir.exists() {
-      println!("Directory exists, checking for .app files...");
-      if let Ok(entries) = std::fs::read_dir(&browser_dir) {
-        for entry in entries.flatten() {
-          println!("  Found entry: {:?}", entry.path());
-          if entry.path().extension().is_some_and(|ext| ext == "app") {
-            println!("  Found .app file: {:?}", entry.path());
-            // Try to get the executable path as a final verification
-            if self.get_executable_path(&browser_dir).is_ok() {
-              println!("  Executable path verification successful");
-              return true;
-            } else {
-              println!("  Executable path verification failed");
-            }
-          }
-        }
-      }
-      println!("No valid .app files found in directory");
-    } else {
+    if !browser_dir.exists() {
       println!("Directory does not exist: {browser_dir:?}");
+      return false;
     }
-    false
+
+    println!("Directory exists, checking for browser files...");
+
+    #[cfg(target_os = "macos")]
+    return macos::is_chromium_version_downloaded(&browser_dir);
+
+    #[cfg(target_os = "linux")]
+    return linux::is_chromium_version_downloaded(&browser_dir, &self.browser_type);
+
+    #[cfg(target_os = "windows")]
+    return windows::is_chromium_version_downloaded(&browser_dir, &self.browser_type);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    {
+      println!("Unsupported platform for browser verification");
+      false
+    }
+  }
+
+  fn prepare_executable(&self, executable_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    #[cfg(target_os = "macos")]
+    return macos::prepare_executable(executable_path);
+
+    #[cfg(target_os = "linux")]
+    return linux::prepare_executable(executable_path);
+
+    #[cfg(target_os = "windows")]
+    return windows::prepare_executable(executable_path);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    Err("Unsupported platform".into())
   }
 }
 
@@ -294,7 +717,7 @@ pub struct GithubRelease {
   #[serde(default)]
   pub published_at: String,
   #[serde(default)]
-  pub is_alpha: bool,
+  pub is_nightly: bool,
   #[serde(default)]
   pub prerelease: bool,
 }
@@ -303,6 +726,8 @@ pub struct GithubRelease {
 pub struct GithubAsset {
   pub name: String,
   pub browser_download_url: String,
+  #[serde(default)]
+  pub size: u64,
 }
 
 #[cfg(test)]
@@ -352,56 +777,6 @@ mod tests {
     assert!(BrowserType::from_str("Firefox").is_err()); // Case sensitive
   }
 
-  #[test]
-  fn test_firefox_browser_creation() {
-    let browser = FirefoxBrowser::new(BrowserType::Firefox);
-    assert_eq!(browser.browser_type(), BrowserType::Firefox);
-
-    let browser = FirefoxBrowser::new(BrowserType::MullvadBrowser);
-    assert_eq!(browser.browser_type(), BrowserType::MullvadBrowser);
-
-    let browser = FirefoxBrowser::new(BrowserType::TorBrowser);
-    assert_eq!(browser.browser_type(), BrowserType::TorBrowser);
-
-    let browser = FirefoxBrowser::new(BrowserType::Zen);
-    assert_eq!(browser.browser_type(), BrowserType::Zen);
-  }
-
-  #[test]
-  fn test_chromium_browser_creation() {
-    let browser = ChromiumBrowser::new(BrowserType::Chromium);
-    assert_eq!(browser.browser_type(), BrowserType::Chromium);
-
-    let browser = ChromiumBrowser::new(BrowserType::Brave);
-    assert_eq!(browser.browser_type(), BrowserType::Brave);
-  }
-
-  #[test]
-  fn test_browser_factory() {
-    // Test Firefox-based browsers
-    let browser = create_browser(BrowserType::Firefox);
-    assert_eq!(browser.browser_type(), BrowserType::Firefox);
-
-    let browser = create_browser(BrowserType::MullvadBrowser);
-    assert_eq!(browser.browser_type(), BrowserType::MullvadBrowser);
-
-    let browser = create_browser(BrowserType::Zen);
-    assert_eq!(browser.browser_type(), BrowserType::Zen);
-
-    let browser = create_browser(BrowserType::TorBrowser);
-    assert_eq!(browser.browser_type(), BrowserType::TorBrowser);
-
-    let browser = create_browser(BrowserType::FirefoxDeveloper);
-    assert_eq!(browser.browser_type(), BrowserType::FirefoxDeveloper);
-
-    // Test Chromium-based browsers
-    let browser = create_browser(BrowserType::Chromium);
-    assert_eq!(browser.browser_type(), BrowserType::Chromium);
-
-    let browser = create_browser(BrowserType::Brave);
-    assert_eq!(browser.browser_type(), BrowserType::Brave);
-  }
-
   #[test]
   fn test_firefox_launch_args() {
     // Test regular Firefox (should not use -no-remote)
@@ -482,6 +857,8 @@ mod tests {
       proxy_type: "http".to_string(),
       host: "127.0.0.1".to_string(),
       port: 8080,
+      username: None,
+      password: None,
     };
 
     assert!(proxy.enabled);
@@ -495,6 +872,8 @@ mod tests {
       proxy_type: "socks5".to_string(),
       host: "proxy.example.com".to_string(),
       port: 1080,
+      username: None,
+      password: None,
     };
 
     assert_eq!(socks_proxy.proxy_type, "socks5");
@@ -507,7 +886,7 @@ mod tests {
     let temp_dir = TempDir::new().unwrap();
     let binaries_dir = temp_dir.path();
 
-    // Create a mock Firefox browser installation
+    // Create a mock Firefox browser installation with new path structure: binaries/<browser>/<version>/
     let browser_dir = binaries_dir.join("firefox").join("139.0");
     fs::create_dir_all(&browser_dir).unwrap();
 
@@ -519,7 +898,7 @@ mod tests {
     assert!(browser.is_version_downloaded("139.0", binaries_dir));
     assert!(!browser.is_version_downloaded("140.0", binaries_dir));
 
-    // Test with Chromium browser
+    // Test with Chromium browser with new path structure
     let chromium_dir = binaries_dir.join("chromium").join("1465660");
     fs::create_dir_all(&chromium_dir).unwrap();
     let chromium_app_dir = chromium_dir.join("Chromium.app");
@@ -542,7 +921,7 @@ mod tests {
     let temp_dir = TempDir::new().unwrap();
     let binaries_dir = temp_dir.path();
 
-    // Create browser directory but no .app directory
+    // Create browser directory but no .app directory with new path structure
     let browser_dir = binaries_dir.join("firefox").join("139.0");
     fs::create_dir_all(&browser_dir).unwrap();
 
@@ -571,6 +950,8 @@ mod tests {
       proxy_type: "http".to_string(),
       host: "127.0.0.1".to_string(),
       port: 8080,
+      username: None,
+      password: None,
     };
 
     // Test that it can be serialized (implements Serialize)

src-tauri/src/default_browser.rs

@@ -65,25 +65,420 @@ mod macos {
 
 #[cfg(target_os = "windows")]
 mod windows {
+  use std::path::Path;
+  use winreg::enums::*;
+  use winreg::RegKey;
+
+  const APP_NAME: &str = "DonutBrowser";
+  const PROG_ID: &str = "DonutBrowser.HTML";
+
   pub fn is_default_browser() -> Result<bool, String> {
-    // Windows implementation would go here
-    Err("Windows support not implemented yet".to_string())
+    let schemes = ["http", "https"];
+
+    for scheme in schemes {
+      // Check if our browser is set as the default handler for this scheme
+      if !is_default_for_scheme(scheme)? {
+        return Ok(false);
+      }
+    }
+
+    Ok(true)
   }
 
   pub fn set_as_default_browser() -> Result<(), String> {
-    Err("Windows support not implemented yet".to_string())
+    // Get the current executable path
+    let exe_path = std::env::current_exe()
+      .map_err(|e| format!("Failed to get current executable path: {}", e))?;
+
+    let exe_path_str = exe_path
+      .to_str()
+      .ok_or("Failed to convert executable path to string")?;
+
+    // Verify the executable exists
+    if !Path::new(exe_path_str).exists() {
+      return Err(format!("Executable not found at: {}", exe_path_str));
+    }
+
+    // Register the application
+    register_application(exe_path_str)?;
+
+    // Set as default for HTTP and HTTPS
+    set_default_for_scheme("http")?;
+    set_default_for_scheme("https")?;
+
+    // Register file associations for HTML files
+    register_html_file_association(exe_path_str)?;
+
+    // Notify the system of changes
+    notify_system_of_changes();
+
+    Ok(())
+  }
+
+  fn is_default_for_scheme(scheme: &str) -> Result<bool, String> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // Check Software\Microsoft\Windows\Shell\Associations\UrlAssociations\{scheme}\UserChoice
+    let path = format!(
+      "Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\{}\\UserChoice",
+      scheme
+    );
+
+    match hkcu.open_subkey(&path) {
+      Ok(key) => match key.get_value::<String, _>("ProgId") {
+        Ok(prog_id) => Ok(prog_id == PROG_ID),
+        Err(_) => Ok(false),
+      },
+      Err(_) => Ok(false),
+    }
+  }
+
+  fn register_application(exe_path: &str) -> Result<(), String> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // Register in Software\RegisteredApplications
+    let (registered_apps, _) = hkcu
+      .create_subkey("Software\\RegisteredApplications")
+      .map_err(|e| format!("Failed to create RegisteredApplications key: {}", e))?;
+
+    registered_apps
+      .set_value(APP_NAME, &format!("Software\\{}", APP_NAME))
+      .map_err(|e| format!("Failed to set registered application: {}", e))?;
+
+    // Create application key
+    let (app_key, _) = hkcu
+      .create_subkey(&format!("Software\\{}", APP_NAME))
+      .map_err(|e| format!("Failed to create application key: {}", e))?;
+
+    // Set application properties
+    app_key
+      .set_value("ApplicationName", &APP_NAME)
+      .map_err(|e| format!("Failed to set ApplicationName: {}", e))?;
+
+    app_key
+      .set_value(
+        "ApplicationDescription",
+        &"Donut Browser - Simple Yet Powerful Browser Orchestrator",
+      )
+      .map_err(|e| format!("Failed to set ApplicationDescription: {}", e))?;
+
+    app_key
+      .set_value("ApplicationIcon", &format!("{},0", exe_path))
+      .map_err(|e| format!("Failed to set ApplicationIcon: {}", e))?;
+
+    // Create Capabilities key
+    let (capabilities, _) = app_key
+      .create_subkey("Capabilities")
+      .map_err(|e| format!("Failed to create Capabilities key: {}", e))?;
+
+    capabilities
+      .set_value(
+        "ApplicationDescription",
+        &"Donut Browser - Simple Yet Powerful Browser Orchestrator",
+      )
+      .map_err(|e| format!("Failed to set Capabilities description: {}", e))?;
+
+    // Set URL associations
+    let (url_assoc, _) = capabilities
+      .create_subkey("URLAssociations")
+      .map_err(|e| format!("Failed to create URLAssociations key: {}", e))?;
+
+    url_assoc
+      .set_value("http", &PROG_ID)
+      .map_err(|e| format!("Failed to set http association: {}", e))?;
+
+    url_assoc
+      .set_value("https", &PROG_ID)
+      .map_err(|e| format!("Failed to set https association: {}", e))?;
+
+    // Set file associations
+    let (file_assoc, _) = capabilities
+      .create_subkey("FileAssociations")
+      .map_err(|e| format!("Failed to create FileAssociations key: {}", e))?;
+
+    file_assoc
+      .set_value(".html", &PROG_ID)
+      .map_err(|e| format!("Failed to set .html association: {}", e))?;
+
+    file_assoc
+      .set_value(".htm", &PROG_ID)
+      .map_err(|e| format!("Failed to set .htm association: {}", e))?;
+
+    // Register the ProgID
+    register_prog_id(exe_path)?;
+
+    Ok(())
+  }
+
+  fn register_prog_id(exe_path: &str) -> Result<(), String> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // Create ProgID key
+    let (prog_id_key, _) = hkcu
+      .create_subkey(&format!("Software\\Classes\\{}", PROG_ID))
+      .map_err(|e| format!("Failed to create ProgID key: {}", e))?;
+
+    prog_id_key
+      .set_value("", &"Donut Browser Document")
+      .map_err(|e| format!("Failed to set ProgID default value: {}", e))?;
+
+    prog_id_key
+      .set_value("FriendlyTypeName", &"Donut Browser Document")
+      .map_err(|e| format!("Failed to set FriendlyTypeName: {}", e))?;
+
+    // Create DefaultIcon key
+    let (icon_key, _) = prog_id_key
+      .create_subkey("DefaultIcon")
+      .map_err(|e| format!("Failed to create DefaultIcon key: {}", e))?;
+
+    icon_key
+      .set_value("", &format!("{},0", exe_path))
+      .map_err(|e| format!("Failed to set default icon: {}", e))?;
+
+    // Create shell\open\command key
+    let (command_key, _) = prog_id_key
+      .create_subkey("shell\\open\\command")
+      .map_err(|e| format!("Failed to create command key: {}", e))?;
+
+    command_key
+      .set_value("", &format!("\"{}\" \"%1\"", exe_path))
+      .map_err(|e| format!("Failed to set command: {}", e))?;
+
+    Ok(())
+  }
+
+  fn set_default_for_scheme(scheme: &str) -> Result<(), String> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // Set in Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\.html\UserChoice
+    // Note: On Windows 10+, this might require elevated permissions or user interaction
+    // through the Settings app due to security restrictions
+
+    // Try to set the association in the user's choice
+    let user_choice_path = format!(
+      "Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\{}\\UserChoice",
+      scheme
+    );
+
+    // Note: Setting UserChoice directly may not work on Windows 10+ due to hash verification
+    // The user may need to manually set the default browser through Windows Settings
+    match hkcu.create_subkey(&user_choice_path) {
+      Ok((user_choice, _)) => {
+        // Attempt to set the ProgId
+        if let Err(_) = user_choice.set_value("ProgId", &PROG_ID) {
+          // If we can't set UserChoice, that's expected on newer Windows versions
+          // The registration is still valuable for the "Open with" menu
+        }
+      }
+      Err(_) => {
+        // Expected on newer Windows versions - user must set manually
+      }
+    }
+
+    Ok(())
+  }
+
+  fn register_html_file_association(_exe_path: &str) -> Result<(), String> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // Register .html and .htm file associations
+    for ext in &[".html", ".htm"] {
+      let ext_path = format!("Software\\Classes\\{}", ext);
+
+      match hkcu.create_subkey(&ext_path) {
+        Ok((ext_key, _)) => {
+          // Set the default value to our ProgID
+          let _ = ext_key.set_value("", &PROG_ID);
+        }
+        Err(_) => {
+          // Continue if we can't set the file association
+        }
+      }
+    }
+
+    Ok(())
+  }
+
+  fn notify_system_of_changes() {
+    // Use Windows API to notify the system of association changes
+    // This helps refresh the system's understanding of the changes
+    unsafe {
+      use std::ffi::c_void;
+
+      // Declare the Windows API functions
+      type UINT = u32;
+      type DWORD = u32;
+      type LPARAM = isize;
+      type WPARAM = usize;
+
+      const HWND_BROADCAST: *mut c_void = 0xffff as *mut c_void;
+      const WM_SETTINGCHANGE: UINT = 0x001A;
+      const SMTO_ABORTIFHUNG: UINT = 0x0002;
+
+      // Link to user32.dll functions
+      extern "system" {
+        fn SendMessageTimeoutA(
+          hWnd: *mut c_void,
+          Msg: UINT,
+          wParam: WPARAM,
+          lParam: LPARAM,
+          fuFlags: UINT,
+          uTimeout: UINT,
+          lpdwResult: *mut DWORD,
+        ) -> isize;
+      }
+
+      let mut result: DWORD = 0;
+
+      // Notify about file associations change
+      SendMessageTimeoutA(
+        HWND_BROADCAST,
+        WM_SETTINGCHANGE,
+        0,
+        "Software\\Classes\0".as_ptr() as LPARAM,
+        SMTO_ABORTIFHUNG,
+        1000,
+        &mut result,
+      );
+    }
   }
 }
 
 #[cfg(target_os = "linux")]
 mod linux {
+  use std::process::Command;
+
+  const APP_DESKTOP_NAME: &str = "donutbrowser.desktop";
+
   pub fn is_default_browser() -> Result<bool, String> {
-    // Linux implementation would go here
-    Err("Linux support not implemented yet".to_string())
+    // Check if xdg-mime is available
+    if !is_xdg_mime_available() {
+      return Err("xdg-mime utility not found. Please install xdg-utils package.".to_string());
+    }
+
+    let schemes = ["http", "https"];
+
+    for scheme in schemes {
+      let mime_type = format!("x-scheme-handler/{}", scheme);
+
+      // Query the current default handler for this scheme
+      let output = Command::new("xdg-mime")
+        .args(["query", "default", &mime_type])
+        .output()
+        .map_err(|e| format!("Failed to query default handler for {}: {}", scheme, e))?;
+
+      if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("xdg-mime query failed for {}: {}", scheme, stderr));
+      }
+
+      let current_handler = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+      // Check if our app is the default handler
+      if current_handler != APP_DESKTOP_NAME {
+        return Ok(false);
+      }
+    }
+
+    Ok(true)
   }
 
   pub fn set_as_default_browser() -> Result<(), String> {
-    Err("Linux support not implemented yet".to_string())
+    // Check if xdg-mime is available
+    if !is_xdg_mime_available() {
+      return Err("xdg-mime utility not found. Please install xdg-utils package.".to_string());
+    }
+
+    // Check if the desktop file exists in common locations
+    if !check_desktop_file_exists() {
+      return Err(format!(
+        "Desktop file '{}' not found in standard locations. Please ensure the application is properly installed. You can manually set Donut Browser as the default browser in your system settings.",
+        APP_DESKTOP_NAME
+      ));
+    }
+
+    let schemes = ["http", "https"];
+    let mut all_succeeded = true;
+    let mut error_messages = Vec::new();
+
+    for scheme in schemes {
+      let mime_type = format!("x-scheme-handler/{}", scheme);
+
+      // Set our app as the default handler for this scheme
+      let output = Command::new("xdg-mime")
+        .args(["default", APP_DESKTOP_NAME, &mime_type])
+        .output()
+        .map_err(|e| format!("Failed to set default handler for {}: {}", scheme, e))?;
+
+      if !output.status.success() {
+        all_succeeded = false;
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        error_messages.push(format!("Failed to set default for {}: {}", scheme, stderr));
+      }
+    }
+
+    if !all_succeeded {
+      return Err(format!(
+        "Some xdg-mime commands failed:\n{}\n\nYou may need to:\n1. Run with appropriate permissions\n2. Manually set the default browser in your desktop environment settings\n3. Restart your desktop session",
+        error_messages.join("\n")
+      ));
+    }
+
+    // Give the system a moment to process the changes
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    // Verify the changes took effect
+    match is_default_browser() {
+      Ok(true) => Ok(()),
+      Ok(false) => {
+        // This is the common case where commands succeed but verification fails
+        Err(format!(
+          "The xdg-mime commands completed successfully, but Donut Browser is not yet set as the default. This is common on some Linux distributions. Please try one of these options:\n\n1. Restart your desktop session and try again\n2. Log out and log back in\n3. Manually set Donut Browser as the default in your system settings:\n   - GNOME: Settings > Default Applications > Web\n   - KDE: System Settings > Applications > Default Applications > Web Browser\n   - XFCE: Settings > Preferred Applications > Web Browser\n   - Or run: xdg-settings set default-web-browser {}\n\nThe changes may take effect automatically after a desktop restart.",
+          APP_DESKTOP_NAME
+        ))
+      }
+      Err(e) => Err(format!(
+        "Set as default completed, but verification failed: {}. The changes may still be in effect after restarting your desktop session.",
+        e
+      ))
+    }
+  }
+
+  fn is_xdg_mime_available() -> bool {
+    Command::new("which")
+      .arg("xdg-mime")
+      .output()
+      .map(|output| output.status.success())
+      .unwrap_or(false)
+  }
+
+  fn check_desktop_file_exists() -> bool {
+    let desktop_locations = [
+      "~/.local/share/applications/",
+      "/usr/share/applications/",
+      "/usr/local/share/applications/",
+      "/var/lib/flatpak/exports/share/applications/",
+      "~/.local/share/flatpak/exports/share/applications/",
+    ];
+
+    for location in &desktop_locations {
+      let path = if location.starts_with('~') {
+        if let Ok(home) = std::env::var("HOME") {
+          location.replace('~', &home)
+        } else {
+          continue;
+        }
+      } else {
+        location.to_string()
+      };
+
+      let full_path = format!("{}{}", path, APP_DESKTOP_NAME);
+      if std::path::Path::new(&full_path).exists() {
+        return true;
+      }
+    }
+
+    false
   }
 }
 
@@ -140,7 +535,7 @@ pub async fn open_url_with_profile(
 
   // Use launch_or_open_url which handles both launching new instances and opening in existing ones
   runner
-    .launch_or_open_url(app_handle, &profile, Some(url.clone()))
+    .launch_or_open_url(app_handle, &profile, Some(url.clone()), None)
     .await
     .map_err(|e| {
       println!("Failed to open URL with profile '{profile_name}': {e}");
@@ -153,8 +548,8 @@ pub async fn open_url_with_profile(
 
 #[tauri::command]
 pub async fn smart_open_url(
-  _app_handle: tauri::AppHandle,
-  _url: String,
+  app_handle: tauri::AppHandle,
+  url: String,
   _is_startup: Option<bool>,
 ) -> Result<String, String> {
   use crate::browser_runner::BrowserRunner;
@@ -171,10 +566,75 @@ pub async fn smart_open_url(
   }
 
   println!(
-    "URL opening - Total profiles: {}, showing profile selector",
+    "URL opening - Total profiles: {}, checking for running profiles",
     profiles.len()
   );
 
-  // Always show the profile selector so the user can choose
+  // Check for running profiles and find the first one that can handle URLs
+  for profile in &profiles {
+    // Check if this profile is running
+    let is_running = runner
+      .check_browser_status(app_handle.clone(), profile)
+      .await
+      .unwrap_or(false);
+
+    if is_running {
+      println!(
+        "Found running profile '{}', attempting to open URL",
+        profile.name
+      );
+
+      // For TOR browser: Check if any other TOR browser is running
+      if profile.browser == "tor-browser" {
+        let mut other_tor_running = false;
+        for p in &profiles {
+          if p.browser == "tor-browser"
+            && p.name != profile.name
+            && runner
+              .check_browser_status(app_handle.clone(), p)
+              .await
+              .unwrap_or(false)
+          {
+            other_tor_running = true;
+            break;
+          }
+        }
+
+        if other_tor_running {
+          continue; // Skip this one, can't have multiple TOR instances
+        }
+      }
+
+      // For Mullvad browser: skip if running (can't open URLs in running Mullvad)
+      if profile.browser == "mullvad-browser" {
+        continue;
+      }
+
+      // Try to open the URL with this running profile
+      match runner
+        .launch_or_open_url(app_handle.clone(), profile, Some(url.clone()), None)
+        .await
+      {
+        Ok(_) => {
+          println!(
+            "Successfully opened URL '{}' with running profile '{}'",
+            url, profile.name
+          );
+          return Ok(format!("opened_with_profile:{}", profile.name));
+        }
+        Err(e) => {
+          println!(
+            "Failed to open URL with running profile '{}': {}",
+            profile.name, e
+          );
+          // Continue to try other profiles or show selector
+        }
+      }
+    }
+  }
+
+  println!("No suitable running profiles found, showing profile selector");
+
+  // No suitable running profile found, show the profile selector
   Err("show_selector".to_string())
 }

src-tauri/src/download.rs

@@ -34,6 +34,14 @@ impl Downloader {
     }
   }
 
+  #[cfg(test)]
+  pub fn new_with_api_client(api_client: ApiClient) -> Self {
+    Self {
+      client: Client::new(),
+      api_client,
+    }
+  }
+
   /// Resolve the actual download URL for browsers that need dynamic asset resolution
   pub async fn resolve_download_url(
     &self,
@@ -43,8 +51,11 @@ impl Downloader {
   ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
     match browser_type {
       BrowserType::Brave => {
-        // For Brave, we need to find the actual macOS asset
-        let releases = self.api_client.fetch_brave_releases().await?;
+        // For Brave, we need to find the actual platform-specific asset
+        let releases = self
+          .api_client
+          .fetch_brave_releases_with_caching(true)
+          .await?;
 
         // Find the release with the matching version
         let release = releases
@@ -54,56 +65,65 @@ impl Downloader {
           })
           .ok_or(format!("Brave version {version} not found"))?;
 
-        // Find the universal macOS DMG asset
-        let asset = release
-          .assets
-          .iter()
-          .find(|asset| asset.name.contains(".dmg") && asset.name.contains("universal"))
+        // Get platform and architecture info
+        let (os, arch) = Self::get_platform_info();
+
+        // Find the appropriate asset based on platform and architecture
+        let asset_url = self
+          .find_brave_asset(&release.assets, &os, &arch)
           .ok_or(format!(
-            "No universal macOS DMG asset found for Brave version {version}"
+            "No compatible asset found for Brave version {version} on {os}/{arch}"
           ))?;
 
-        Ok(asset.browser_download_url.clone())
+        Ok(asset_url)
       }
       BrowserType::Zen => {
-        // For Zen, verify the asset exists
-        let releases = self.api_client.fetch_zen_releases().await?;
+        // For Zen, verify the asset exists and handle different naming patterns
+        let releases = self
+          .api_client
+          .fetch_zen_releases_with_caching(true)
+          .await?;
 
         let release = releases
           .iter()
           .find(|r| r.tag_name == version)
           .ok_or(format!("Zen version {version} not found"))?;
 
-        // Find the macOS universal DMG asset
-        let asset = release
-          .assets
-          .iter()
-          .find(|asset| asset.name == "zen.macos-universal.dmg")
+        // Get platform and architecture info
+        let (os, arch) = Self::get_platform_info();
+
+        // Find the appropriate asset
+        let asset_url = self
+          .find_zen_asset(&release.assets, &os, &arch)
           .ok_or(format!(
-            "No macOS universal asset found for Zen version {version}"
+            "No compatible asset found for Zen version {version} on {os}/{arch}"
           ))?;
 
-        Ok(asset.browser_download_url.clone())
+        Ok(asset_url)
       }
       BrowserType::MullvadBrowser => {
         // For Mullvad, verify the asset exists
-        let releases = self.api_client.fetch_mullvad_releases().await?;
+        let releases = self
+          .api_client
+          .fetch_mullvad_releases_with_caching(true)
+          .await?;
 
         let release = releases
           .iter()
           .find(|r| r.tag_name == version)
           .ok_or(format!("Mullvad version {version} not found"))?;
 
-        // Find the macOS DMG asset
-        let asset = release
-          .assets
-          .iter()
-          .find(|asset| asset.name.contains(".dmg") && asset.name.contains("mac"))
+        // Get platform and architecture info
+        let (os, arch) = Self::get_platform_info();
+
+        // Find the appropriate asset
+        let asset_url = self
+          .find_mullvad_asset(&release.assets, &os, &arch)
           .ok_or(format!(
-            "No macOS asset found for Mullvad version {version}"
+            "No compatible asset found for Mullvad version {version} on {os}/{arch}"
           ))?;
 
-        Ok(asset.browser_download_url.clone())
+        Ok(asset_url)
       }
       _ => {
         // For other browsers, use the provided URL
@@ -112,9 +132,176 @@ impl Downloader {
     }
   }
 
-  pub async fn download_browser(
+  /// Get platform and architecture information
+  fn get_platform_info() -> (String, String) {
+    let os = if cfg!(target_os = "windows") {
+      "windows"
+    } else if cfg!(target_os = "linux") {
+      "linux"
+    } else if cfg!(target_os = "macos") {
+      "macos"
+    } else {
+      "unknown"
+    };
+
+    let arch = if cfg!(target_arch = "x86_64") {
+      "x64"
+    } else if cfg!(target_arch = "aarch64") {
+      "arm64"
+    } else {
+      "unknown"
+    };
+
+    (os.to_string(), arch.to_string())
+  }
+
+  /// Find the appropriate Brave asset for the current platform and architecture
+  fn find_brave_asset(
     &self,
-    app_handle: &tauri::AppHandle,
+    assets: &[crate::browser::GithubAsset],
+    os: &str,
+    arch: &str,
+  ) -> Option<String> {
+    // Brave asset naming patterns:
+    // Windows: BraveBrowserStandaloneNightlySetup.exe, BraveBrowserStandaloneSilentNightlySetup.exe
+    // macOS: Brave-Browser-Nightly-universal.dmg, Brave-Browser-Nightly-universal.pkg
+    // Linux: brave-browser-1.79.119-linux-arm64.zip, brave-browser-1.79.119-linux-amd64.zip
+
+    let asset = match os {
+      "windows" => {
+        // For Windows, look for standalone setup EXE (not the auto-updater one)
+        assets
+          .iter()
+          .find(|asset| {
+            let name = asset.name.to_lowercase();
+            name.contains("standalone") && name.ends_with(".exe") && !name.contains("silent")
+          })
+          .or_else(|| {
+            // Fallback to any EXE if standalone not found
+            assets.iter().find(|asset| asset.name.ends_with(".exe"))
+          })
+      }
+      "macos" => {
+        // For macOS, prefer universal DMG
+        assets
+          .iter()
+          .find(|asset| {
+            let name = asset.name.to_lowercase();
+            name.contains("universal") && name.ends_with(".dmg")
+          })
+          .or_else(|| {
+            // Fallback to any DMG
+            assets.iter().find(|asset| asset.name.ends_with(".dmg"))
+          })
+      }
+      "linux" => {
+        // For Linux, be strict about architecture matching - same logic as has_compatible_brave_asset
+        let arch_pattern = if arch == "arm64" { "arm64" } else { "amd64" };
+
+        assets.iter().find(|asset| {
+          let name = asset.name.to_lowercase();
+          name.contains("linux") && name.contains(arch_pattern) && name.ends_with(".zip")
+        })
+      }
+      _ => None,
+    };
+
+    asset.map(|a| a.browser_download_url.clone())
+  }
+
+  /// Find the appropriate Zen asset for the current platform and architecture
+  fn find_zen_asset(
+    &self,
+    assets: &[crate::browser::GithubAsset],
+    os: &str,
+    arch: &str,
+  ) -> Option<String> {
+    // Zen asset naming patterns:
+    // Windows: zen.installer.exe, zen.installer-arm64.exe
+    // macOS: zen.macos-universal.dmg
+    // Linux: zen.linux-x86_64.tar.xz, zen.linux-aarch64.tar.xz, zen-x86_64.AppImage, zen-aarch64.AppImage
+
+    let asset = match (os, arch) {
+      ("windows", "x64") => assets
+        .iter()
+        .find(|asset| asset.name == "zen.installer.exe"),
+      ("windows", "arm64") => assets
+        .iter()
+        .find(|asset| asset.name == "zen.installer-arm64.exe"),
+      ("macos", _) => assets
+        .iter()
+        .find(|asset| asset.name == "zen.macos-universal.dmg"),
+      ("linux", "x64") => {
+        // Prefer tar.xz, fallback to AppImage
+        assets
+          .iter()
+          .find(|asset| asset.name == "zen.linux-x86_64.tar.xz")
+          .or_else(|| {
+            assets
+              .iter()
+              .find(|asset| asset.name == "zen-x86_64.AppImage")
+          })
+      }
+      ("linux", "arm64") => {
+        // Prefer tar.xz, fallback to AppImage
+        assets
+          .iter()
+          .find(|asset| asset.name == "zen.linux-aarch64.tar.xz")
+          .or_else(|| {
+            assets
+              .iter()
+              .find(|asset| asset.name == "zen-aarch64.AppImage")
+          })
+      }
+      _ => None,
+    };
+
+    asset.map(|a| a.browser_download_url.clone())
+  }
+
+  /// Find the appropriate Mullvad asset for the current platform and architecture
+  fn find_mullvad_asset(
+    &self,
+    assets: &[crate::browser::GithubAsset],
+    os: &str,
+    arch: &str,
+  ) -> Option<String> {
+    // Mullvad asset naming patterns:
+    // Windows: mullvad-browser-windows-x86_64-VERSION.exe
+    // macOS: mullvad-browser-macos-VERSION.dmg
+    // Linux: mullvad-browser-x86_64-VERSION.tar.xz
+
+    let asset = match (os, arch) {
+      ("windows", "x64") => assets.iter().find(|asset| {
+        asset.name.contains("windows")
+          && asset.name.contains("x86_64")
+          && asset.name.ends_with(".exe")
+      }),
+      ("windows", "arm64") => {
+        // Mullvad doesn't support ARM64 on Windows
+        None
+      }
+      ("macos", _) => assets
+        .iter()
+        .find(|asset| asset.name.contains("macos") && asset.name.ends_with(".dmg")),
+      ("linux", "x64") => assets.iter().find(|asset| {
+        asset.name.contains("x86_64")
+          && asset.name.ends_with(".tar.xz")
+          && !asset.name.contains("windows")
+      }),
+      ("linux", "arm64") => {
+        // Mullvad doesn't support ARM64 on Linux
+        None
+      }
+      _ => None,
+    };
+
+    asset.map(|a| a.browser_download_url.clone())
+  }
+
+  pub async fn download_browser<R: tauri::Runtime>(
+    &self,
+    app_handle: &tauri::AppHandle<R>,
     browser_type: BrowserType,
     version: &str,
     download_info: &DownloadInfo,
@@ -127,6 +314,10 @@ impl Downloader {
       .resolve_download_url(browser_type.clone(), version, download_info)
       .await?;
 
+    // Check if this is a twilight release for special handling
+    let is_twilight =
+      browser_type == BrowserType::Zen && version.to_lowercase().contains("twilight");
+
     // Emit initial progress
     let progress = DownloadProgress {
       browser: browser_type.as_str().to_string(),
@@ -136,7 +327,11 @@ impl Downloader {
       percentage: 0.0,
       speed_bytes_per_sec: 0.0,
       eta_seconds: None,
-      stage: "downloading".to_string(),
+      stage: if is_twilight {
+        "downloading (twilight rolling release)".to_string()
+      } else {
+        "downloading".to_string()
+      },
     };
 
     let _ = app_handle.emit("download-progress", &progress);
@@ -145,10 +340,15 @@ impl Downloader {
     let response = self
       .client
       .get(&download_url)
-      .header("User-Agent", "donutbrowser")
+      .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36")
       .send()
       .await?;
 
+    // Check if the response is successful
+    if !response.status().is_success() {
+      return Err(format!("Download failed with status: {}", response.status()).into());
+    }
+
     let total_size = response.content_length();
     let mut downloaded = 0u64;
     let start_time = std::time::Instant::now();
@@ -183,6 +383,12 @@ impl Downloader {
           None
         };
 
+        let stage_description = if is_twilight {
+          "downloading (twilight rolling release)".to_string()
+        } else {
+          "downloading".to_string()
+        };
+
         let progress = DownloadProgress {
           browser: browser_type.as_str().to_string(),
           version: version.to_string(),
@@ -191,7 +397,7 @@ impl Downloader {
           percentage,
           speed_bytes_per_sec: speed,
           eta_seconds: eta,
-          stage: "downloading".to_string(),
+          stage: stage_description,
         };
 
         let _ = app_handle.emit("download-progress", &progress);
@@ -206,12 +412,62 @@ impl Downloader {
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::api_client::ApiClient;
+  use crate::browser::BrowserType;
+  use crate::browser_version_service::DownloadInfo;
+
+  use tempfile::TempDir;
+  use wiremock::matchers::{method, path, query_param};
+  use wiremock::{Mock, MockServer, ResponseTemplate};
+
+  async fn setup_mock_server() -> MockServer {
+    MockServer::start().await
+  }
+
+  fn create_test_api_client(server: &MockServer) -> ApiClient {
+    let base_url = server.uri();
+    ApiClient::new_with_base_urls(
+      base_url.clone(), // firefox_api_base
+      base_url.clone(), // firefox_dev_api_base
+      base_url.clone(), // github_api_base
+      base_url.clone(), // chromium_api_base
+      base_url.clone(), // tor_archive_base
+    )
+  }
 
   #[tokio::test]
   async fn test_resolve_brave_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "v1.81.9",
+        "name": "Brave Release 1.81.9",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "brave-v1.81.9-universal.dmg",
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/brave/brave-browser/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
 
-    // Test with a known Brave version
     let download_info = DownloadInfo {
       url: "placeholder".to_string(),
       filename: "brave-test.dmg".to_string(),
@@ -222,23 +478,43 @@ mod tests {
       .resolve_download_url(BrowserType::Brave, "v1.81.9", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert!(url.contains("github.com/brave/brave-browser"));
-        assert!(url.contains(".dmg"));
-        assert!(url.contains("universal"));
-        println!("Brave download URL resolved: {url}");
-      }
-      Err(e) => {
-        println!("Brave URL resolution failed (expected if version doesn't exist): {e}");
-        // This might fail if the version doesn't exist, which is okay for testing
-      }
-    }
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, "https://example.com/brave-1.81.9-universal.dmg");
   }
 
   #[tokio::test]
   async fn test_resolve_zen_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "1.11b",
+        "name": "Zen Browser 1.11b",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "zen.macos-universal.dmg",
+            "browser_download_url": "https://example.com/zen-1.11b-universal.dmg",
+            "size": 120000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/zen-browser/desktop/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
 
     let download_info = DownloadInfo {
       url: "placeholder".to_string(),
@@ -250,21 +526,43 @@ mod tests {
       .resolve_download_url(BrowserType::Zen, "1.11b", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert!(url.contains("github.com/zen-browser/desktop"));
-        assert!(url.contains("zen.macos-universal.dmg"));
-        println!("Zen download URL resolved: {url}");
-      }
-      Err(e) => {
-        println!("Zen URL resolution failed (expected if version doesn't exist): {e}");
-      }
-    }
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, "https://example.com/zen-1.11b-universal.dmg");
   }
 
   #[tokio::test]
   async fn test_resolve_mullvad_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "14.5a6",
+        "name": "Mullvad Browser 14.5a6",
+        "prerelease": true,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "mullvad-browser-macos-14.5a6.dmg",
+            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg",
+            "size": 100000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/mullvad/mullvad-browser/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
 
     let download_info = DownloadInfo {
       url: "placeholder".to_string(),
@@ -276,21 +574,16 @@ mod tests {
       .resolve_download_url(BrowserType::MullvadBrowser, "14.5a6", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert!(url.contains("github.com/mullvad/mullvad-browser"));
-        assert!(url.contains(".dmg"));
-        println!("Mullvad download URL resolved: {url}");
-      }
-      Err(e) => {
-        println!("Mullvad URL resolution failed (expected if version doesn't exist): {e}");
-      }
-    }
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, "https://example.com/mullvad-14.5a6.dmg");
   }
 
   #[tokio::test]
   async fn test_resolve_firefox_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
 
     let download_info = DownloadInfo {
       url: "https://download.mozilla.org/?product=firefox-139.0&os=osx&lang=en-US".to_string(),
@@ -302,20 +595,16 @@ mod tests {
       .resolve_download_url(BrowserType::Firefox, "139.0", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert_eq!(url, download_info.url);
-        println!("Firefox download URL (passthrough): {url}");
-      }
-      Err(e) => {
-        panic!("Firefox URL resolution should not fail: {e}");
-      }
-    }
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, download_info.url);
   }
 
   #[tokio::test]
   async fn test_resolve_chromium_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
 
     let download_info = DownloadInfo {
       url: "https://commondatastorage.googleapis.com/chromium-browser-snapshots/Mac/1465660/chrome-mac.zip".to_string(),
@@ -327,20 +616,16 @@ mod tests {
       .resolve_download_url(BrowserType::Chromium, "1465660", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert_eq!(url, download_info.url);
-        println!("Chromium download URL (passthrough): {url}");
-      }
-      Err(e) => {
-        panic!("Chromium URL resolution should not fail: {e}");
-      }
-    }
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, download_info.url);
   }
 
   #[tokio::test]
   async fn test_resolve_tor_download_url() {
-    let downloader = Downloader::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
 
     let download_info = DownloadInfo {
       url: "https://archive.torproject.org/tor-package-archive/torbrowser/14.0.4/tor-browser-macos-14.0.4.dmg".to_string(),
@@ -352,14 +637,349 @@ mod tests {
       .resolve_download_url(BrowserType::TorBrowser, "14.0.4", &download_info)
       .await;
 
-    match result {
-      Ok(url) => {
-        assert_eq!(url, download_info.url);
-        println!("TOR download URL (passthrough): {url}");
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, download_info.url);
+  }
+
+  #[tokio::test]
+  async fn test_resolve_brave_version_not_found() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "v1.81.8",
+        "name": "Brave Release 1.81.8",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "brave-v1.81.8-universal.dmg",
+            "browser_download_url": "https://example.com/brave-1.81.8-universal.dmg",
+            "size": 200000000
+          }
+        ]
       }
-      Err(e) => {
-        panic!("TOR URL resolution should not fail: {e}");
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/brave/brave-browser/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: "placeholder".to_string(),
+      filename: "brave-test.dmg".to_string(),
+      is_archive: true,
+    };
+
+    let result = downloader
+      .resolve_download_url(BrowserType::Brave, "v1.81.9", &download_info)
+      .await;
+
+    assert!(result.is_err());
+    assert!(result
+      .unwrap_err()
+      .to_string()
+      .contains("Brave version v1.81.9 not found"));
+  }
+
+  #[tokio::test]
+  async fn test_resolve_zen_asset_not_found() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "1.11b",
+        "name": "Zen Browser 1.11b",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "zen.linux-universal.tar.bz2",
+            "browser_download_url": "https://example.com/zen-1.11b-linux.tar.bz2",
+            "size": 150000000
+          }
+        ]
       }
-    }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/zen-browser/desktop/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: "placeholder".to_string(),
+      filename: "zen-test.dmg".to_string(),
+      is_archive: true,
+    };
+
+    let result = downloader
+      .resolve_download_url(BrowserType::Zen, "1.11b", &download_info)
+      .await;
+
+    assert!(result.is_err());
+    assert!(result
+      .unwrap_err()
+      .to_string()
+      .contains("No compatible asset found"));
+  }
+
+  #[tokio::test]
+  async fn test_download_browser_with_progress() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    // Create a temporary directory for the test
+    let temp_dir = TempDir::new().unwrap();
+    let dest_path = temp_dir.path();
+
+    // Create test file content (simulating a small download)
+    let test_content = b"This is a test file content for download simulation";
+
+    // Mock the download endpoint
+    Mock::given(method("GET"))
+      .and(path("/test-download"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_bytes(test_content)
+          .insert_header("content-length", test_content.len().to_string())
+          .insert_header("content-type", "application/octet-stream"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: format!("{}/test-download", server.uri()),
+      filename: "test-file.dmg".to_string(),
+      is_archive: true,
+    };
+
+    // Create a mock app handle for testing
+    let app = tauri::test::mock_app();
+    let app_handle = app.handle().clone();
+
+    let result = downloader
+      .download_browser(
+        &app_handle,
+        BrowserType::Firefox,
+        "139.0",
+        &download_info,
+        dest_path,
+      )
+      .await;
+
+    assert!(result.is_ok());
+    let downloaded_file = result.unwrap();
+    assert!(downloaded_file.exists());
+
+    // Verify file content
+    let downloaded_content = std::fs::read(&downloaded_file).unwrap();
+    assert_eq!(downloaded_content, test_content);
+  }
+
+  #[tokio::test]
+  async fn test_download_browser_network_error() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let temp_dir = TempDir::new().unwrap();
+    let dest_path = temp_dir.path();
+
+    // Mock a 404 response
+    Mock::given(method("GET"))
+      .and(path("/missing-file"))
+      .respond_with(ResponseTemplate::new(404))
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: format!("{}/missing-file", server.uri()),
+      filename: "missing-file.dmg".to_string(),
+      is_archive: true,
+    };
+
+    let app = tauri::test::mock_app();
+    let app_handle = app.handle().clone();
+
+    let result = downloader
+      .download_browser(
+        &app_handle,
+        BrowserType::Firefox,
+        "139.0",
+        &download_info,
+        dest_path,
+      )
+      .await;
+
+    assert!(result.is_err());
+  }
+
+  #[tokio::test]
+  async fn test_resolve_mullvad_asset_not_found() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "14.5a6",
+        "name": "Mullvad Browser 14.5a6",
+        "prerelease": true,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "mullvad-browser-linux-14.5a6.tar.xz",
+            "browser_download_url": "https://example.com/mullvad-14.5a6.tar.xz",
+            "size": 80000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/mullvad/mullvad-browser/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: "placeholder".to_string(),
+      filename: "mullvad-test.dmg".to_string(),
+      is_archive: true,
+    };
+
+    let result = downloader
+      .resolve_download_url(BrowserType::MullvadBrowser, "14.5a6", &download_info)
+      .await;
+
+    assert!(result.is_err());
+    assert!(result
+      .unwrap_err()
+      .to_string()
+      .contains("No compatible asset found"));
+  }
+
+  #[tokio::test]
+  async fn test_brave_version_with_v_prefix() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let mock_response = r#"[
+      {
+        "tag_name": "v1.81.9",
+        "name": "Brave Release 1.81.9",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "brave-v1.81.9-universal.dmg",
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/brave/brave-browser/releases"))
+      .and(query_param("per_page", "100"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: "placeholder".to_string(),
+      filename: "brave-test.dmg".to_string(),
+      is_archive: true,
+    };
+
+    // Test with version without v prefix
+    let result = downloader
+      .resolve_download_url(BrowserType::Brave, "1.81.9", &download_info)
+      .await;
+
+    assert!(result.is_ok());
+    let url = result.unwrap();
+    assert_eq!(url, "https://example.com/brave-1.81.9-universal.dmg");
+  }
+
+  #[tokio::test]
+  async fn test_download_browser_chunked_response() {
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let downloader = Downloader::new_with_api_client(api_client);
+
+    let temp_dir = TempDir::new().unwrap();
+    let dest_path = temp_dir.path();
+
+    // Create larger test content to simulate chunked transfer
+    let test_content = vec![42u8; 1024]; // 1KB of data
+
+    Mock::given(method("GET"))
+      .and(path("/chunked-download"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_bytes(test_content.clone())
+          .insert_header("content-length", test_content.len().to_string())
+          .insert_header("content-type", "application/octet-stream"),
+      )
+      .mount(&server)
+      .await;
+
+    let download_info = DownloadInfo {
+      url: format!("{}/chunked-download", server.uri()),
+      filename: "chunked-file.dmg".to_string(),
+      is_archive: true,
+    };
+
+    let app = tauri::test::mock_app();
+    let app_handle = app.handle().clone();
+
+    let result = downloader
+      .download_browser(
+        &app_handle,
+        BrowserType::Chromium,
+        "1465660",
+        &download_info,
+        dest_path,
+      )
+      .await;
+
+    assert!(result.is_ok());
+    let downloaded_file = result.unwrap();
+    assert!(downloaded_file.exists());
+
+    let downloaded_content = std::fs::read(&downloaded_file).unwrap();
+    assert_eq!(downloaded_content.len(), test_content.len());
   }
 }

src-tauri/src/downloaded_browsers.rs

@@ -12,6 +12,9 @@ pub struct DownloadedBrowserInfo {
   pub file_path: PathBuf,
   pub verified: bool,
   pub actual_version: Option<String>, // For browsers like Chromium where we track the actual version
+  pub file_size: Option<u64>, // For tracking file size changes (useful for rolling releases)
+  #[serde(default)] // Add default value (false) for backwards compatibility
+  pub is_rolling_release: bool, // True for Zen's twilight releases and other rolling releases
 }
 
 #[derive(Debug, Serialize, Deserialize, Default)]
@@ -24,7 +27,7 @@ impl DownloadedBrowsersRegistry {
     Self::default()
   }
 
-  pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
+  pub fn load() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
     let registry_path = Self::get_registry_path()?;
 
     if !registry_path.exists() {
@@ -36,7 +39,7 @@ impl DownloadedBrowsersRegistry {
     Ok(registry)
   }
 
-  pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
+  pub fn save(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let registry_path = Self::get_registry_path()?;
 
     // Ensure parent directory exists
@@ -49,7 +52,7 @@ impl DownloadedBrowsersRegistry {
     Ok(())
   }
 
-  fn get_registry_path() -> Result<PathBuf, Box<dyn std::error::Error>> {
+  fn get_registry_path() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
     let base_dirs = BaseDirs::new().ok_or("Failed to get base directories")?;
     let mut path = base_dirs.data_local_dir().to_path_buf();
     path.push(if cfg!(debug_assertions) {
@@ -98,6 +101,7 @@ impl DownloadedBrowsersRegistry {
   }
 
   pub fn mark_download_started(&mut self, browser: &str, version: &str, file_path: PathBuf) {
+    let is_rolling = Self::is_rolling_release(browser, version);
     let info = DownloadedBrowserInfo {
       browser: browser.to_string(),
       version: version.to_string(),
@@ -108,6 +112,8 @@ impl DownloadedBrowsersRegistry {
       file_path,
       verified: false,
       actual_version: None,
+      file_size: None,
+      is_rolling_release: is_rolling,
     };
     self.add_browser(info);
   }
@@ -131,11 +137,16 @@ impl DownloadedBrowsersRegistry {
     }
   }
 
+  fn is_rolling_release(browser: &str, version: &str) -> bool {
+    // Check if this is a rolling release like twilight
+    browser == "zen" && version.to_lowercase() == "twilight"
+  }
+
   pub fn cleanup_failed_download(
     &mut self,
     browser: &str,
     version: &str,
-  ) -> Result<(), Box<dyn std::error::Error>> {
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     if let Some(info) = self.remove_browser(browser, version) {
       // Clean up any files that might have been left behind
       if info.file_path.exists() {
@@ -164,6 +175,48 @@ impl DownloadedBrowsersRegistry {
     }
     Ok(())
   }
+
+  /// Find and remove unused browser binaries that are not referenced by any active profiles
+  pub fn cleanup_unused_binaries(
+    &mut self,
+    active_profiles: &[(String, String)], // (browser, version) pairs
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
+    let active_set: std::collections::HashSet<(String, String)> =
+      active_profiles.iter().cloned().collect();
+    let mut cleaned_up = Vec::new();
+
+    // Collect all downloaded browsers that are not in active profiles
+    let mut to_remove = Vec::new();
+    for (browser, versions) in &self.browsers {
+      for (version, info) in versions {
+        if info.verified && !active_set.contains(&(browser.clone(), version.clone())) {
+          to_remove.push((browser.clone(), version.clone()));
+        }
+      }
+    }
+
+    // Remove unused binaries
+    for (browser, version) in to_remove {
+      if let Err(e) = self.cleanup_failed_download(&browser, &version) {
+        eprintln!("Failed to cleanup unused binary {browser}:{version}: {e}");
+      } else {
+        cleaned_up.push(format!("{browser} {version}"));
+      }
+    }
+
+    Ok(cleaned_up)
+  }
+
+  /// Get all browsers and versions referenced by active profiles
+  pub fn get_active_browser_versions(
+    &self,
+    profiles: &[crate::browser_runner::BrowserProfile],
+  ) -> Vec<(String, String)> {
+    profiles
+      .iter()
+      .map(|profile| (profile.browser.clone(), profile.version.clone()))
+      .collect()
+  }
 }
 
 #[cfg(test)]
@@ -186,6 +239,8 @@ mod tests {
       file_path: PathBuf::from("/test/path"),
       verified: true,
       actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
     };
 
     registry.add_browser(info.clone());
@@ -206,6 +261,8 @@ mod tests {
       file_path: PathBuf::from("/test/path1"),
       verified: true,
       actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
     };
 
     let info2 = DownloadedBrowserInfo {
@@ -215,6 +272,8 @@ mod tests {
       file_path: PathBuf::from("/test/path2"),
       verified: false, // Not verified, should not be included
       actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
     };
 
     let info3 = DownloadedBrowserInfo {
@@ -224,6 +283,8 @@ mod tests {
       file_path: PathBuf::from("/test/path3"),
       verified: true,
       actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
     };
 
     registry.add_browser(info1);
@@ -266,6 +327,8 @@ mod tests {
       file_path: PathBuf::from("/test/path"),
       verified: true,
       actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
     };
 
     registry.add_browser(info);
@@ -275,4 +338,17 @@ mod tests {
     assert!(removed.is_some());
     assert!(!registry.is_browser_downloaded("firefox", "139.0"));
   }
+
+  #[test]
+  fn test_twilight_rolling_release() {
+    let mut registry = DownloadedBrowsersRegistry::new();
+
+    // Mark twilight download started
+    registry.mark_download_started("zen", "twilight", PathBuf::from("/test/zen-twilight"));
+
+    // Check that it's marked as rolling release
+    let zen_versions = &registry.browsers["zen"];
+    let twilight_info = &zen_versions["twilight"];
+    assert!(twilight_info.is_rolling_release);
+  }
 }

src-tauri/src/lib.rs

@@ -1,13 +1,14 @@
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
+use std::env;
 use std::sync::Mutex;
-use std::time::{SystemTime, UNIX_EPOCH};
-use tauri::{Emitter, Manager};
+use tauri::{Emitter, Manager, Runtime, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 use tauri_plugin_deep_link::DeepLinkExt;
 
 // Store pending URLs that need to be handled when the window is ready
 static PENDING_URLS: Mutex<Vec<String>> = Mutex::new(Vec::new());
 
 mod api_client;
+mod app_auto_updater;
 mod auto_updater;
 mod browser;
 mod browser_runner;
@@ -16,25 +17,26 @@ mod default_browser;
 mod download;
 mod downloaded_browsers;
 mod extraction;
+mod profile_importer;
 mod proxy_manager;
 mod settings_manager;
+mod theme_detector;
 mod version_updater;
 
 extern crate lazy_static;
 
 use browser_runner::{
-  check_browser_exists, check_browser_status, create_browser_profile, create_browser_profile_new,
-  delete_profile, download_browser, fetch_browser_versions, fetch_browser_versions_cached_first,
-  fetch_browser_versions_detailed, fetch_browser_versions_with_count,
-  fetch_browser_versions_with_count_cached_first, get_cached_browser_versions_detailed,
-  get_downloaded_browser_versions, get_saved_mullvad_releases, get_supported_browsers,
-  is_browser_downloaded, kill_browser_profile, launch_browser_profile, list_browser_profiles,
-  rename_profile, should_update_browser_cache, update_profile_proxy, update_profile_version,
+  check_browser_exists, check_browser_status, create_browser_profile_new, delete_profile,
+  download_browser, fetch_browser_versions_cached_first, fetch_browser_versions_with_count,
+  fetch_browser_versions_with_count_cached_first, get_browser_release_types,
+  get_downloaded_browser_versions, get_supported_browsers, is_browser_supported_on_platform,
+  kill_browser_profile, launch_browser_profile, list_browser_profiles, rename_profile,
+  update_profile_proxy, update_profile_version,
 };
 
 use settings_manager::{
-  disable_default_browser_prompt, get_app_settings, get_table_sorting_settings, save_app_settings,
-  save_table_sorting_settings, should_show_settings_on_startup,
+  clear_all_version_cache_and_refetch, get_app_settings, get_table_sorting_settings,
+  save_app_settings, save_table_sorting_settings, should_show_settings_on_startup,
 };
 
 use default_browser::{
@@ -42,21 +44,65 @@ use default_browser::{
 };
 
 use version_updater::{
-  check_version_update_needed, force_version_update_check, get_version_update_status,
-  get_version_updater, trigger_manual_version_update,
+  get_version_update_status, get_version_updater, trigger_manual_version_update,
 };
 
 use auto_updater::{
-  check_for_browser_updates, complete_browser_update, complete_browser_update_with_auto_update,
-  dismiss_update_notification, is_auto_update_download, is_browser_disabled_for_update,
-  mark_auto_update_download, remove_auto_update_download, start_browser_update,
+  check_for_browser_updates, complete_browser_update_with_auto_update, dismiss_update_notification,
+  is_browser_disabled_for_update,
 };
 
-#[tauri::command]
-fn greet() -> String {
-  let now = SystemTime::now();
-  let epoch_ms = now.duration_since(UNIX_EPOCH).unwrap().as_millis();
-  format!("Hello world from Rust! Current epoch: {epoch_ms}")
+use app_auto_updater::{
+  check_for_app_updates, check_for_app_updates_manual, download_and_install_app_update,
+};
+
+use profile_importer::{detect_existing_profiles, import_browser_profile};
+
+use theme_detector::get_system_theme;
+
+// Trait to extend WebviewWindow with transparent titlebar functionality
+pub trait WindowExt {
+  #[cfg(target_os = "macos")]
+  fn set_transparent_titlebar(&self, transparent: bool) -> Result<(), String>;
+}
+
+impl<R: Runtime> WindowExt for WebviewWindow<R> {
+  #[cfg(target_os = "macos")]
+  fn set_transparent_titlebar(&self, transparent: bool) -> Result<(), String> {
+    use objc2::rc::Retained;
+    use objc2_app_kit::{NSWindow, NSWindowStyleMask, NSWindowTitleVisibility};
+
+    unsafe {
+      let ns_window: Retained<NSWindow> =
+        Retained::retain(self.ns_window().unwrap().cast()).unwrap();
+
+      if transparent {
+        // Hide the title text
+        ns_window.setTitleVisibility(NSWindowTitleVisibility(2)); // NSWindowTitleHidden
+
+        // Make titlebar transparent
+        ns_window.setTitlebarAppearsTransparent(true);
+
+        // Set full size content view
+        let current_mask = ns_window.styleMask();
+        let new_mask = NSWindowStyleMask(current_mask.0 | (1 << 15)); // NSFullSizeContentViewWindowMask
+        ns_window.setStyleMask(new_mask);
+      } else {
+        // Show the title text
+        ns_window.setTitleVisibility(NSWindowTitleVisibility(0)); // NSWindowTitleVisible
+
+        // Make titlebar opaque
+        ns_window.setTitlebarAppearsTransparent(false);
+
+        // Remove full size content view
+        let current_mask = ns_window.styleMask();
+        let new_mask = NSWindowStyleMask(current_mask.0 & !(1 << 15));
+        ns_window.setStyleMask(new_mask);
+      }
+    }
+
+    Ok(())
+  }
 }
 
 #[tauri::command]
@@ -65,20 +111,16 @@ async fn handle_url_open(app: tauri::AppHandle, url: String) -> Result<(), Strin
 
   // Check if the main window exists and is ready
   if let Some(window) = app.get_webview_window("main") {
-    if window.is_visible().unwrap_or(false) {
-      // Window is visible, emit event directly
-      println!("Main window is visible, emitting show-profile-selector event");
-      app
-        .emit("show-profile-selector", url.clone())
-        .map_err(|e| format!("Failed to emit URL open event: {e}"))?;
-      let _ = window.show();
-      let _ = window.set_focus();
-    } else {
-      // Window not visible yet - add to pending URLs
-      println!("Main window not visible, adding URL to pending list");
-      let mut pending = PENDING_URLS.lock().unwrap();
-      pending.push(url);
-    }
+    println!("Main window exists");
+
+    // Try to show and focus the window first
+    let _ = window.show();
+    let _ = window.set_focus();
+    let _ = window.unminimize();
+
+    app
+      .emit("show-profile-selector", url.clone())
+      .map_err(|e| format!("Failed to emit URL open event: {e}"))?;
   } else {
     // Window doesn't exist yet - add to pending URLs
     println!("Main window doesn't exist, adding URL to pending list");
@@ -91,6 +133,8 @@ async fn handle_url_open(app: tauri::AppHandle, url: String) -> Result<(), Strin
 
 #[tauri::command]
 async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bool, String> {
+  println!("check_and_handle_startup_url called");
+
   let pending_urls = {
     let mut pending = PENDING_URLS.lock().unwrap();
     let urls = pending.clone();
@@ -98,12 +142,24 @@ async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bo
     urls
   };
 
+  println!("Found {} pending URLs", pending_urls.len());
+
   if !pending_urls.is_empty() {
     println!(
       "Handling {} pending URLs from frontend request",
       pending_urls.len()
     );
 
+    // Ensure the main window is visible and focused
+    if let Some(window) = app_handle.get_webview_window("main") {
+      let _ = window.show();
+      let _ = window.set_focus();
+      let _ = window.unminimize();
+
+      // Give the window a moment to become visible
+      tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+    }
+
     for url in pending_urls {
       println!("Emitting show-profile-selector event for URL: {url}");
       if let Err(e) = app_handle.emit("show-profile-selector", url.clone()) {
@@ -120,28 +176,75 @@ async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bo
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+  let args: Vec<String> = env::args().collect();
+  let startup_url = args.iter().find(|arg| arg.starts_with("http")).cloned();
+
+  if let Some(url) = startup_url.clone() {
+    println!("Found startup URL in command line: {url}");
+    let mut pending = PENDING_URLS.lock().unwrap();
+    pending.push(url.clone());
+  }
+
   tauri::Builder::default()
+    .plugin(tauri_plugin_single_instance::init(|_, args, _cwd| {
+      println!("Single instance triggered with args: {args:?}");
+    }))
+    .plugin(tauri_plugin_deep_link::init())
     .plugin(tauri_plugin_fs::init())
     .plugin(tauri_plugin_opener::init())
     .plugin(tauri_plugin_shell::init())
-    .plugin(tauri_plugin_deep_link::init())
+    .plugin(tauri_plugin_dialog::init())
+    .plugin(tauri_plugin_macos_permissions::init())
     .setup(|app| {
+      // Create the main window programmatically
+      #[allow(unused_variables)]
+      let win_builder = WebviewWindowBuilder::new(app, "main", WebviewUrl::default())
+        .title("Donut Browser")
+        .inner_size(900.0, 600.0)
+        .resizable(false)
+        .fullscreen(false)
+        .center()
+        .focused(true)
+        .visible(true);
+
+      #[allow(unused_variables)]
+      let window = win_builder.build().unwrap();
+
+      // Set transparent titlebar for macOS
+      #[cfg(target_os = "macos")]
+      {
+        if let Err(e) = window.set_transparent_titlebar(true) {
+          eprintln!("Failed to set transparent titlebar: {e}");
+        }
+      }
+
       // Set up deep link handler
       let handle = app.handle().clone();
 
       #[cfg(any(windows, target_os = "linux"))]
       {
         // For Windows and Linux, register all deep links at runtime for development
-        app.deep_link().register_all()?;
+        if let Err(e) = app.deep_link().register_all() {
+          eprintln!("Failed to register deep links: {e}");
+        }
+      }
+
+      #[cfg(target_os = "macos")]
+      {
+        // On macOS, try to register deep links for development builds
+        if let Err(e) = app.deep_link().register_all() {
+          eprintln!(
+            "Note: Deep link registration failed on macOS (this is normal for production): {e}"
+          );
+        }
       }
 
-      // Handle deep links - this works for both scenarios:
-      // 1. App is running and URL is opened
-      // 2. App is not running and URL causes app to launch
       app.deep_link().on_open_url({
         let handle = handle.clone();
         move |event| {
           let urls = event.urls();
+          println!("Deep link event received with {} URLs", urls.len());
+
           for url in urls {
             let url_string = url.to_string();
             println!("Deep link received: {url_string}");
@@ -159,76 +262,280 @@ pub fn run() {
         }
       });
 
+      if let Some(startup_url) = startup_url {
+        let handle_clone = handle.clone();
+        tauri::async_runtime::spawn(async move {
+          println!("Processing startup URL from command line: {startup_url}");
+          if let Err(e) = handle_url_open(handle_clone, startup_url.clone()).await {
+            eprintln!("Failed to handle startup URL: {e}");
+          }
+        });
+      }
+
       // Initialize and start background version updater
       let app_handle = app.handle().clone();
       tauri::async_runtime::spawn(async move {
         let version_updater = get_version_updater();
-        let mut updater_guard = version_updater.lock().await;
 
         // Set the app handle
-        updater_guard.set_app_handle(app_handle).await;
+        {
+          let mut updater_guard = version_updater.lock().await;
+          updater_guard.set_app_handle(app_handle);
+        }
 
-        // Start the background updates
-        updater_guard.start_background_updates().await;
+        // Run startup check without holding the lock
+        {
+          let updater_guard = version_updater.lock().await;
+          if let Err(e) = updater_guard.start_background_updates().await {
+            eprintln!("Failed to start background updates: {e}");
+          }
+        }
+      });
+
+      // Start the background update task separately
+      tauri::async_runtime::spawn(async move {
+        version_updater::VersionUpdater::run_background_task().await;
+      });
+
+      let app_handle_auto_updater = app.handle().clone();
+
+      // Start the auto-update check task separately
+      tauri::async_runtime::spawn(async move {
+        auto_updater::check_for_updates_with_progress(app_handle_auto_updater).await;
+      });
+
+      let app_handle_update = app.handle().clone();
+      tauri::async_runtime::spawn(async move {
+        println!("Starting app update check at startup...");
+        let updater = app_auto_updater::AppAutoUpdater::new();
+        match updater.check_for_updates().await {
+          Ok(Some(update_info)) => {
+            println!(
+              "App update available: {} -> {}",
+              update_info.current_version, update_info.new_version
+            );
+            // Emit update available event to the frontend
+            if let Err(e) = app_handle_update.emit("app-update-available", &update_info) {
+              eprintln!("Failed to emit app update event: {e}");
+            } else {
+              println!("App update event emitted successfully");
+            }
+          }
+          Ok(None) => {
+            println!("No app updates available");
+          }
+          Err(e) => {
+            eprintln!("Failed to check for app updates: {e}");
+          }
+        }
       });
 
       Ok(())
     })
     .invoke_handler(tauri::generate_handler![
-      greet,
       get_supported_browsers,
+      is_browser_supported_on_platform,
       download_browser,
       delete_profile,
-      is_browser_downloaded,
       check_browser_exists,
       create_browser_profile_new,
-      create_browser_profile, // Keep for backward compatibility
       list_browser_profiles,
       launch_browser_profile,
-      fetch_browser_versions,
-      fetch_browser_versions_detailed,
       fetch_browser_versions_with_count,
       fetch_browser_versions_cached_first,
       fetch_browser_versions_with_count_cached_first,
-      get_cached_browser_versions_detailed,
-      should_update_browser_cache,
       get_downloaded_browser_versions,
-      get_saved_mullvad_releases,
+      get_browser_release_types,
       update_profile_proxy,
       update_profile_version,
       check_browser_status,
       kill_browser_profile,
       rename_profile,
-      // Settings commands
       get_app_settings,
       save_app_settings,
       should_show_settings_on_startup,
-      disable_default_browser_prompt,
       get_table_sorting_settings,
       save_table_sorting_settings,
-      // Default browser commands
+      clear_all_version_cache_and_refetch,
       is_default_browser,
       open_url_with_profile,
       set_as_default_browser,
       smart_open_url,
-      handle_url_open,
       check_and_handle_startup_url,
-      // Version update commands
       trigger_manual_version_update,
       get_version_update_status,
-      check_version_update_needed,
-      force_version_update_check,
-      // Auto-update commands
       check_for_browser_updates,
-      start_browser_update,
-      complete_browser_update,
       is_browser_disabled_for_update,
       dismiss_update_notification,
       complete_browser_update_with_auto_update,
-      mark_auto_update_download,
-      remove_auto_update_download,
-      is_auto_update_download,
+      check_for_app_updates,
+      check_for_app_updates_manual,
+      download_and_install_app_update,
+      get_system_theme,
+      detect_existing_profiles,
+      import_browser_profile,
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");
 }
+
+#[cfg(test)]
+mod tests {
+  use std::fs;
+
+  #[test]
+  fn test_no_unused_tauri_commands() {
+    check_unused_commands(false); // Run in strict mode for CI
+  }
+
+  #[test]
+  fn test_unused_tauri_commands_detailed() {
+    check_unused_commands(true); // Run in verbose mode for development
+  }
+
+  fn check_unused_commands(verbose: bool) {
+    // Extract command names from the generate_handler! macro in this file
+    let lib_rs_content = fs::read_to_string("src/lib.rs").expect("Failed to read lib.rs");
+    let commands = extract_tauri_commands(&lib_rs_content);
+
+    // Get all frontend files
+    let frontend_files = get_frontend_files("../src");
+
+    // Check which commands are actually used
+    let mut unused_commands = Vec::new();
+    let mut used_commands = Vec::new();
+
+    for command in &commands {
+      let mut is_used = false;
+
+      for file_content in &frontend_files {
+        // More comprehensive search for command usage
+        if is_command_used(file_content, command) {
+          is_used = true;
+          break;
+        }
+      }
+
+      if is_used {
+        used_commands.push(command.clone());
+        if verbose {
+          println!("✅ {command}");
+        }
+      } else {
+        unused_commands.push(command.clone());
+        if verbose {
+          println!("❌ {command} (UNUSED)");
+        }
+      }
+    }
+
+    if verbose {
+      println!("\n📊 Summary:");
+      println!("  ✅ Used commands: {}", used_commands.len());
+      println!("  ❌ Unused commands: {}", unused_commands.len());
+    }
+
+    if !unused_commands.is_empty() {
+      let message = format!(
+        "Found {} unused Tauri commands: {}\n\nThese commands are exported in generate_handler! but not used in the frontend.\nConsider removing them or add them to the allowlist if they're used elsewhere.\n\nRun `pnpm check-unused-commands` for detailed analysis.",
+        unused_commands.len(),
+        unused_commands.join(", ")
+      );
+
+      if verbose {
+        println!("\n🚨 {message}");
+      } else {
+        panic!("{}", message);
+      }
+    } else if verbose {
+      println!("\n🎉 All exported commands are being used!");
+    } else {
+      println!(
+        "✅ All {} exported Tauri commands are being used in the frontend",
+        commands.len()
+      );
+    }
+  }
+
+  fn is_command_used(content: &str, command: &str) -> bool {
+    // Check various patterns for invoke usage
+    let patterns = vec![
+      format!("invoke<{}>(\"{}\"", "", command), // invoke<Type>("command"
+      format!("invoke(\"{}\"", command),         // invoke("command"
+      format!("invoke<{}>(\"{}\",", "", command), // invoke<Type>("command",
+      format!("invoke(\"{}\",", command),        // invoke("command",
+      format!("\"{}\"", command),                // Just the command name in quotes
+    ];
+
+    for pattern in patterns {
+      if content.contains(&pattern) {
+        return true;
+      }
+    }
+
+    // Also check for the command name appearing after "invoke" within a reasonable distance
+    if let Some(invoke_pos) = content.find("invoke") {
+      let after_invoke = &content[invoke_pos..];
+      if let Some(cmd_pos) = after_invoke.find(&format!("\"{command}\"")) {
+        // If the command appears within 100 characters of "invoke", consider it used
+        if cmd_pos < 100 {
+          return true;
+        }
+      }
+    }
+
+    false
+  }
+
+  fn extract_tauri_commands(content: &str) -> Vec<String> {
+    let mut commands = Vec::new();
+
+    // Find the generate_handler! macro
+    if let Some(start) = content.find("tauri::generate_handler![") {
+      if let Some(end) = content[start..].find("])") {
+        let handler_content = &content[start + 25..start + end]; // Skip "tauri::generate_handler!["
+
+        // Extract command names
+        for line in handler_content.lines() {
+          let line = line.trim();
+          if !line.is_empty() && !line.starts_with("//") {
+            // Remove trailing comma and whitespace
+            let command = line.trim_end_matches(',').trim();
+            if !command.is_empty() {
+              commands.push(command.to_string());
+            }
+          }
+        }
+      }
+    }
+
+    commands
+  }
+
+  fn get_frontend_files(src_dir: &str) -> Vec<String> {
+    let mut files_content = Vec::new();
+
+    if let Ok(entries) = fs::read_dir(src_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+
+        if path.is_dir() {
+          // Recursively read subdirectories
+          let subdir_files = get_frontend_files(&path.to_string_lossy());
+          files_content.extend(subdir_files);
+        } else if let Some(extension) = path.extension() {
+          if matches!(
+            extension.to_str(),
+            Some("ts") | Some("tsx") | Some("js") | Some("jsx")
+          ) {
+            if let Ok(content) = fs::read_to_string(&path) {
+              files_content.push(content);
+            }
+          }
+        }
+      }
+    }
+
+    files_content
+  }
+}

src-tauri/src/profile_importer.rs

@@ -0,0 +1,775 @@
+use directories::BaseDirs;
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::fs::{self, create_dir_all};
+use std::path::{Path, PathBuf};
+
+use crate::browser::BrowserType;
+use crate::browser_runner::BrowserRunner;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct DetectedProfile {
+  pub browser: String,
+  pub name: String,
+  pub path: String,
+  pub description: String,
+}
+
+pub struct ProfileImporter {
+  base_dirs: BaseDirs,
+  browser_runner: BrowserRunner,
+}
+
+impl ProfileImporter {
+  pub fn new() -> Self {
+    Self {
+      base_dirs: BaseDirs::new().expect("Failed to get base directories"),
+      browser_runner: BrowserRunner::new(),
+    }
+  }
+
+  /// Detect existing browser profiles on the system
+  pub fn detect_existing_profiles(
+    &self,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut detected_profiles = Vec::new();
+
+    // Detect Firefox profiles
+    detected_profiles.extend(self.detect_firefox_profiles()?);
+
+    // Detect Chrome profiles
+    detected_profiles.extend(self.detect_chrome_profiles()?);
+
+    // Detect Brave profiles
+    detected_profiles.extend(self.detect_brave_profiles()?);
+
+    // Detect Firefox Developer Edition profiles
+    detected_profiles.extend(self.detect_firefox_developer_profiles()?);
+
+    // Detect Chromium profiles
+    detected_profiles.extend(self.detect_chromium_profiles()?);
+
+    // Detect Mullvad Browser profiles
+    detected_profiles.extend(self.detect_mullvad_browser_profiles()?);
+
+    // Detect Zen Browser profiles
+    detected_profiles.extend(self.detect_zen_browser_profiles()?);
+
+    // Detect TOR Browser profiles
+    detected_profiles.extend(self.detect_tor_browser_profiles()?);
+
+    // Remove duplicates based on path
+    let mut seen_paths = HashSet::new();
+    let unique_profiles: Vec<DetectedProfile> = detected_profiles
+      .into_iter()
+      .filter(|profile| seen_paths.insert(profile.path.clone()))
+      .collect();
+
+    Ok(unique_profiles)
+  }
+
+  /// Detect Firefox profiles
+  fn detect_firefox_profiles(&self) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let firefox_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/Firefox/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&firefox_dir, "firefox")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      // Primary location in AppData\Roaming
+      let app_data = self.base_dirs.data_dir();
+      let firefox_dir = app_data.join("Mozilla/Firefox/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&firefox_dir, "firefox")?);
+
+      // Also check AppData\Local for portable installations
+      let local_app_data = self.base_dirs.data_local_dir();
+      let firefox_local_dir = local_app_data.join("Mozilla/Firefox/Profiles");
+      if firefox_local_dir.exists() {
+        profiles.extend(self.scan_firefox_profiles_dir(&firefox_local_dir, "firefox")?);
+      }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let firefox_dir = self.base_dirs.home_dir().join(".mozilla/firefox");
+      profiles.extend(self.scan_firefox_profiles_dir(&firefox_dir, "firefox")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Firefox Developer Edition profiles
+  fn detect_firefox_developer_profiles(
+    &self,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      // Firefox Developer Edition on macOS uses separate profile directories
+      let firefox_dev_alt_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/Firefox Developer Edition/Profiles");
+
+      // Only scan the dedicated dev edition directory if it exists, otherwise skip to avoid duplicates
+      if firefox_dev_alt_dir.exists() {
+        profiles.extend(self.scan_firefox_profiles_dir(&firefox_dev_alt_dir, "firefox-developer")?);
+      }
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      let app_data = self.base_dirs.data_dir();
+      // Firefox Developer Edition on Windows typically uses separate directories
+      let firefox_dev_dir = app_data.join("Mozilla/Firefox Developer Edition/Profiles");
+      if firefox_dev_dir.exists() {
+        profiles.extend(self.scan_firefox_profiles_dir(&firefox_dev_dir, "firefox-developer")?);
+      }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      // Firefox Developer Edition on Linux uses separate directories
+      let firefox_dev_dir = self
+        .base_dirs
+        .home_dir()
+        .join(".mozilla/firefox-dev-edition");
+      if firefox_dev_dir.exists() {
+        profiles.extend(self.scan_firefox_profiles_dir(&firefox_dev_dir, "firefox-developer")?);
+      }
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Chrome profiles
+  fn detect_chrome_profiles(&self) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let chrome_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/Google/Chrome");
+      profiles.extend(self.scan_chrome_profiles_dir(&chrome_dir, "chromium")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      let local_app_data = self.base_dirs.data_local_dir();
+      let chrome_dir = local_app_data.join("Google/Chrome/User Data");
+      profiles.extend(self.scan_chrome_profiles_dir(&chrome_dir, "chromium")?);
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let chrome_dir = self.base_dirs.home_dir().join(".config/google-chrome");
+      profiles.extend(self.scan_chrome_profiles_dir(&chrome_dir, "chromium")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Chromium profiles
+  fn detect_chromium_profiles(&self) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let chromium_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/Chromium");
+      profiles.extend(self.scan_chrome_profiles_dir(&chromium_dir, "chromium")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      let local_app_data = self.base_dirs.data_local_dir();
+      let chromium_dir = local_app_data.join("Chromium/User Data");
+      profiles.extend(self.scan_chrome_profiles_dir(&chromium_dir, "chromium")?);
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let chromium_dir = self.base_dirs.home_dir().join(".config/chromium");
+      profiles.extend(self.scan_chrome_profiles_dir(&chromium_dir, "chromium")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Brave profiles
+  fn detect_brave_profiles(&self) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let brave_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/BraveSoftware/Brave-Browser");
+      profiles.extend(self.scan_chrome_profiles_dir(&brave_dir, "brave")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      let local_app_data = self.base_dirs.data_local_dir();
+      let brave_dir = local_app_data.join("BraveSoftware/Brave-Browser/User Data");
+      profiles.extend(self.scan_chrome_profiles_dir(&brave_dir, "brave")?);
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let brave_dir = self
+        .base_dirs
+        .home_dir()
+        .join(".config/BraveSoftware/Brave-Browser");
+      profiles.extend(self.scan_chrome_profiles_dir(&brave_dir, "brave")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Mullvad Browser profiles
+  fn detect_mullvad_browser_profiles(
+    &self,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let mullvad_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/MullvadBrowser/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&mullvad_dir, "mullvad-browser")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      // Primary location in AppData\Roaming
+      let app_data = self.base_dirs.data_dir();
+      let mullvad_dir = app_data.join("MullvadBrowser/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&mullvad_dir, "mullvad-browser")?);
+
+      // Also check common installation locations
+      let local_app_data = self.base_dirs.data_local_dir();
+      let mullvad_local_dir = local_app_data.join("MullvadBrowser/Profiles");
+      if mullvad_local_dir.exists() {
+        profiles.extend(self.scan_firefox_profiles_dir(&mullvad_local_dir, "mullvad-browser")?);
+      }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let mullvad_dir = self.base_dirs.home_dir().join(".mullvad-browser");
+      profiles.extend(self.scan_firefox_profiles_dir(&mullvad_dir, "mullvad-browser")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect Zen Browser profiles
+  fn detect_zen_browser_profiles(
+    &self,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      let zen_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/Zen/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&zen_dir, "zen")?);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      let app_data = self.base_dirs.data_dir();
+      let zen_dir = app_data.join("Zen/Profiles");
+      profiles.extend(self.scan_firefox_profiles_dir(&zen_dir, "zen")?);
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      let zen_dir = self.base_dirs.home_dir().join(".zen");
+      profiles.extend(self.scan_firefox_profiles_dir(&zen_dir, "zen")?);
+    }
+
+    Ok(profiles)
+  }
+
+  /// Detect TOR Browser profiles
+  fn detect_tor_browser_profiles(
+    &self,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+      // TOR Browser on macOS is typically in Applications
+      let tor_dir = self
+        .base_dirs
+        .home_dir()
+        .join("Library/Application Support/TorBrowser-Data/Browser/profile.default");
+
+      if tor_dir.exists() {
+        profiles.push(DetectedProfile {
+          browser: "tor-browser".to_string(),
+          name: "TOR Browser - Default Profile".to_string(),
+          path: tor_dir.to_string_lossy().to_string(),
+          description: "Default TOR Browser profile".to_string(),
+        });
+      }
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+      // Check common TOR Browser installation locations on Windows
+      let possible_paths = [
+        // Default installation in user directory
+        (
+          "Desktop",
+          "Desktop/Tor Browser/Browser/TorBrowser/Data/Browser/profile.default",
+        ),
+        // AppData locations
+        (
+          "AppData/Roaming",
+          "TorBrowser/Browser/TorBrowser/Data/Browser/profile.default",
+        ),
+        (
+          "AppData/Local",
+          "TorBrowser/Browser/TorBrowser/Data/Browser/profile.default",
+        ),
+      ];
+
+      let home_dir = self.base_dirs.home_dir();
+
+      for (location_name, relative_path) in &possible_paths {
+        let tor_dir = home_dir.join(relative_path);
+        if tor_dir.exists() {
+          profiles.push(DetectedProfile {
+            browser: "tor-browser".to_string(),
+            name: format!("TOR Browser - {} Profile", location_name),
+            path: tor_dir.to_string_lossy().to_string(),
+            description: format!("TOR Browser profile from {}", location_name),
+          });
+        }
+      }
+
+      // Also check AppData directories if available
+      let app_data = self.base_dirs.data_dir();
+      let tor_app_data =
+        app_data.join("TorBrowser/Browser/TorBrowser/Data/Browser/profile.default");
+      if tor_app_data.exists() {
+        profiles.push(DetectedProfile {
+          browser: "tor-browser".to_string(),
+          name: "TOR Browser - AppData Profile".to_string(),
+          path: tor_app_data.to_string_lossy().to_string(),
+          description: "TOR Browser profile from AppData".to_string(),
+        });
+      }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+      // Common TOR Browser locations on Linux
+      let possible_paths = [
+        ".local/share/torbrowser/tbb/x86_64/tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default",
+        "tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default",
+        ".tor-browser/Browser/TorBrowser/Data/Browser/profile.default",
+        "Downloads/tor-browser_en-US/Browser/TorBrowser/Data/Browser/profile.default",
+      ];
+
+      let home_dir = self.base_dirs.home_dir();
+
+      for relative_path in &possible_paths {
+        let tor_dir = home_dir.join(relative_path);
+        if tor_dir.exists() {
+          profiles.push(DetectedProfile {
+            browser: "tor-browser".to_string(),
+            name: "TOR Browser - Default Profile".to_string(),
+            path: tor_dir.to_string_lossy().to_string(),
+            description: "TOR Browser profile".to_string(),
+          });
+          break; // Only add the first one found to avoid duplicates
+        }
+      }
+    }
+
+    Ok(profiles)
+  }
+
+  /// Scan Firefox-style profiles directory
+  fn scan_firefox_profiles_dir(
+    &self,
+    profiles_dir: &Path,
+    browser_type: &str,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    if !profiles_dir.exists() {
+      return Ok(profiles);
+    }
+
+    // Read profiles.ini file if it exists
+    let profiles_ini = profiles_dir
+      .parent()
+      .unwrap_or(profiles_dir)
+      .join("profiles.ini");
+    if profiles_ini.exists() {
+      if let Ok(content) = fs::read_to_string(&profiles_ini) {
+        profiles.extend(self.parse_firefox_profiles_ini(&content, profiles_dir, browser_type)?);
+      }
+    }
+
+    // Also scan directory for any profile folders not in profiles.ini
+    if let Ok(entries) = fs::read_dir(profiles_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+          let prefs_file = path.join("prefs.js");
+          if prefs_file.exists() {
+            let profile_name = path
+              .file_name()
+              .and_then(|n| n.to_str())
+              .unwrap_or("Unknown Profile");
+
+            // Check if this profile was already found in profiles.ini
+            let already_added = profiles.iter().any(|p| p.path == path.to_string_lossy());
+            if !already_added {
+              profiles.push(DetectedProfile {
+                browser: browser_type.to_string(),
+                name: format!(
+                  "{} Profile - {}",
+                  self.get_browser_display_name(browser_type),
+                  profile_name
+                ),
+                path: path.to_string_lossy().to_string(),
+                description: format!("Profile folder: {profile_name}"),
+              });
+            }
+          }
+        }
+      }
+    }
+
+    Ok(profiles)
+  }
+
+  /// Parse Firefox profiles.ini file
+  fn parse_firefox_profiles_ini(
+    &self,
+    content: &str,
+    profiles_dir: &Path,
+    browser_type: &str,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+    let mut current_section = String::new();
+    let mut profile_name = String::new();
+    let mut profile_path = String::new();
+    let mut is_relative = true;
+
+    for line in content.lines() {
+      let line = line.trim();
+
+      if line.starts_with('[') && line.ends_with(']') {
+        // Save previous profile if complete
+        if !current_section.is_empty()
+          && current_section.starts_with("Profile")
+          && !profile_path.is_empty()
+        {
+          let full_path = if is_relative {
+            profiles_dir.join(&profile_path)
+          } else {
+            PathBuf::from(&profile_path)
+          };
+
+          if full_path.exists() {
+            let display_name = if profile_name.is_empty() {
+              format!("{} Profile", self.get_browser_display_name(browser_type))
+            } else {
+              format!(
+                "{} - {}",
+                self.get_browser_display_name(browser_type),
+                profile_name
+              )
+            };
+
+            profiles.push(DetectedProfile {
+              browser: browser_type.to_string(),
+              name: display_name,
+              path: full_path.to_string_lossy().to_string(),
+              description: format!("Profile: {profile_name}"),
+            });
+          }
+        }
+
+        // Start new section
+        current_section = line[1..line.len() - 1].to_string();
+        profile_name.clear();
+        profile_path.clear();
+        is_relative = true;
+      } else if line.contains('=') {
+        let parts: Vec<&str> = line.splitn(2, '=').collect();
+        if parts.len() == 2 {
+          let key = parts[0].trim();
+          let value = parts[1].trim();
+
+          match key {
+            "Name" => profile_name = value.to_string(),
+            "Path" => profile_path = value.to_string(),
+            "IsRelative" => is_relative = value == "1",
+            _ => {}
+          }
+        }
+      }
+    }
+
+    // Handle last profile
+    if !current_section.is_empty()
+      && current_section.starts_with("Profile")
+      && !profile_path.is_empty()
+    {
+      let full_path = if is_relative {
+        profiles_dir.join(&profile_path)
+      } else {
+        PathBuf::from(&profile_path)
+      };
+
+      if full_path.exists() {
+        let display_name = if profile_name.is_empty() {
+          format!("{} Profile", self.get_browser_display_name(browser_type))
+        } else {
+          format!(
+            "{} - {}",
+            self.get_browser_display_name(browser_type),
+            profile_name
+          )
+        };
+
+        profiles.push(DetectedProfile {
+          browser: browser_type.to_string(),
+          name: display_name,
+          path: full_path.to_string_lossy().to_string(),
+          description: format!("Profile: {profile_name}"),
+        });
+      }
+    }
+
+    Ok(profiles)
+  }
+
+  /// Scan Chrome-style profiles directory
+  fn scan_chrome_profiles_dir(
+    &self,
+    browser_dir: &Path,
+    browser_type: &str,
+  ) -> Result<Vec<DetectedProfile>, Box<dyn std::error::Error>> {
+    let mut profiles = Vec::new();
+
+    if !browser_dir.exists() {
+      return Ok(profiles);
+    }
+
+    // Check for Default profile
+    let default_profile = browser_dir.join("Default");
+    if default_profile.exists() && default_profile.join("Preferences").exists() {
+      profiles.push(DetectedProfile {
+        browser: browser_type.to_string(),
+        name: format!(
+          "{} - Default Profile",
+          self.get_browser_display_name(browser_type)
+        ),
+        path: default_profile.to_string_lossy().to_string(),
+        description: "Default profile".to_string(),
+      });
+    }
+
+    // Check for Profile X directories
+    if let Ok(entries) = fs::read_dir(browser_dir) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+          let dir_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+
+          if dir_name.starts_with("Profile ") && path.join("Preferences").exists() {
+            let profile_number = &dir_name[8..]; // Remove "Profile " prefix
+            profiles.push(DetectedProfile {
+              browser: browser_type.to_string(),
+              name: format!(
+                "{} - Profile {}",
+                self.get_browser_display_name(browser_type),
+                profile_number
+              ),
+              path: path.to_string_lossy().to_string(),
+              description: format!("Profile {profile_number}"),
+            });
+          }
+        }
+      }
+    }
+
+    Ok(profiles)
+  }
+
+  /// Get browser display name
+  fn get_browser_display_name(&self, browser_type: &str) -> &str {
+    match browser_type {
+      "firefox" => "Firefox",
+      "firefox-developer" => "Firefox Developer",
+      "chromium" => "Chrome/Chromium",
+      "brave" => "Brave",
+      "mullvad-browser" => "Mullvad Browser",
+      "zen" => "Zen Browser",
+      "tor-browser" => "Tor Browser",
+      _ => "Unknown Browser",
+    }
+  }
+
+  /// Import a profile from an existing browser profile
+  pub fn import_profile(
+    &self,
+    source_path: &str,
+    browser_type: &str,
+    new_profile_name: &str,
+  ) -> Result<(), Box<dyn std::error::Error>> {
+    // Validate that source path exists
+    let source_path = Path::new(source_path);
+    if !source_path.exists() {
+      return Err("Source profile path does not exist".into());
+    }
+
+    // Validate browser type
+    let _browser_type = BrowserType::from_str(browser_type)
+      .map_err(|_| format!("Invalid browser type: {browser_type}"))?;
+
+    // Check if a profile with this name already exists
+    let existing_profiles = self.browser_runner.list_profiles()?;
+    if existing_profiles
+      .iter()
+      .any(|p| p.name.to_lowercase() == new_profile_name.to_lowercase())
+    {
+      return Err(format!("Profile with name '{new_profile_name}' already exists").into());
+    }
+
+    // Create the new profile directory
+    let snake_case_name = new_profile_name.to_lowercase().replace(' ', "_");
+    let profiles_dir = self.browser_runner.get_profiles_dir();
+    let new_profile_path = profiles_dir.join(&snake_case_name);
+
+    create_dir_all(&new_profile_path)?;
+
+    // Copy all files from source to destination
+    Self::copy_directory_recursive(source_path, &new_profile_path)?;
+
+    // Create the profile metadata without overwriting the imported data
+    // We need to find a suitable version for this browser type
+    let available_versions = self.get_default_version_for_browser(browser_type)?;
+
+    let profile = crate::browser_runner::BrowserProfile {
+      name: new_profile_name.to_string(),
+      browser: browser_type.to_string(),
+      version: available_versions,
+      profile_path: new_profile_path.to_string_lossy().to_string(),
+      proxy: None,
+      process_id: None,
+      last_launch: None,
+      release_type: "stable".to_string(),
+    };
+
+    // Save the profile metadata
+    self.browser_runner.save_profile(&profile)?;
+
+    println!(
+      "Successfully imported profile '{}' from '{}'",
+      new_profile_name,
+      source_path.display()
+    );
+
+    Ok(())
+  }
+
+  /// Get a default version for a browser type
+  fn get_default_version_for_browser(
+    &self,
+    browser_type: &str,
+  ) -> Result<String, Box<dyn std::error::Error>> {
+    // Try to get a downloaded version first, fallback to a reasonable default
+    let registry =
+      crate::downloaded_browsers::DownloadedBrowsersRegistry::load().unwrap_or_default();
+    let downloaded_versions = registry.get_downloaded_versions(browser_type);
+
+    if let Some(version) = downloaded_versions.first() {
+      return Ok(version.clone());
+    }
+
+    // If no downloaded versions, return a sensible default
+    match browser_type {
+      "firefox" => Ok("latest".to_string()),
+      "firefox-developer" => Ok("latest".to_string()),
+      "chromium" => Ok("latest".to_string()),
+      "brave" => Ok("latest".to_string()),
+      "zen" => Ok("latest".to_string()),
+      "mullvad-browser" => Ok("13.5.16".to_string()), // Mullvad Browser common version
+      "tor-browser" => Ok("latest".to_string()),
+      _ => Ok("latest".to_string()),
+    }
+  }
+
+  /// Recursively copy directory contents
+  fn copy_directory_recursive(
+    source: &Path,
+    destination: &Path,
+  ) -> Result<(), Box<dyn std::error::Error>> {
+    if !destination.exists() {
+      create_dir_all(destination)?;
+    }
+
+    for entry in fs::read_dir(source)? {
+      let entry = entry?;
+      let source_path = entry.path();
+      let dest_path = destination.join(entry.file_name());
+
+      if source_path.is_dir() {
+        Self::copy_directory_recursive(&source_path, &dest_path)?;
+      } else {
+        fs::copy(&source_path, &dest_path)?;
+      }
+    }
+
+    Ok(())
+  }
+}
+
+// Tauri commands
+#[tauri::command]
+pub async fn detect_existing_profiles() -> Result<Vec<DetectedProfile>, String> {
+  let importer = ProfileImporter::new();
+  importer
+    .detect_existing_profiles()
+    .map_err(|e| format!("Failed to detect existing profiles: {e}"))
+}
+
+#[tauri::command]
+pub async fn import_browser_profile(
+  source_path: String,
+  browser_type: String,
+  new_profile_name: String,
+) -> Result<(), String> {
+  let importer = ProfileImporter::new();
+  importer
+    .import_profile(&source_path, &browser_type, &new_profile_name)
+    .map_err(|e| format!("Failed to import profile: {e}"))
+}

src-tauri/src/proxy_manager.rs

@@ -11,7 +11,9 @@ use crate::browser::ProxySettings;
 pub struct ProxyInfo {
   pub id: String,
   pub local_url: String,
-  pub upstream_url: String,
+  pub upstream_host: String,
+  pub upstream_port: u16,
+  pub upstream_type: String,
   pub local_port: u16,
 }
 
@@ -19,7 +21,7 @@ pub struct ProxyInfo {
 pub struct ProxyManager {
   active_proxies: Mutex<HashMap<u32, ProxyInfo>>, // Maps browser process ID to proxy info
   // Store proxy info by profile name for persistence across browser restarts
-  profile_proxies: Mutex<HashMap<String, (String, u16)>>, // Maps profile name to (upstream_url, port)
+  profile_proxies: Mutex<HashMap<String, ProxySettings>>, // Maps profile name to proxy settings
 }
 
 impl ProxyManager {
@@ -30,11 +32,11 @@ impl ProxyManager {
     }
   }
 
-  // Start a proxy for a given upstream URL and associate it with a browser process ID
+  // Start a proxy for given proxy settings and associate it with a browser process ID
   pub async fn start_proxy(
     &self,
     app_handle: tauri::AppHandle,
-    upstream_url: &str,
+    proxy_settings: &ProxySettings,
     browser_pid: u32,
     profile_name: Option<&str>,
   ) -> Result<ProxySettings, String> {
@@ -44,9 +46,11 @@ impl ProxyManager {
       if let Some(proxy) = proxies.get(&browser_pid) {
         return Ok(ProxySettings {
           enabled: true,
-          proxy_type: "http".to_string(),
-          host: "localhost".to_string(),
+          proxy_type: proxy.upstream_type.clone(),
+          host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
           port: proxy.local_port,
+          username: None,
+          password: None,
         });
       }
     }
@@ -54,31 +58,62 @@ impl ProxyManager {
     // Check if we have a preferred port for this profile
     let preferred_port = if let Some(name) = profile_name {
       let profile_proxies = self.profile_proxies.lock().unwrap();
-      profile_proxies.get(name).map(|(_, port)| *port)
+      profile_proxies.get(name).and_then(|settings| {
+        // Find existing proxy with same settings to reuse port
+        let active_proxies = self.active_proxies.lock().unwrap();
+        active_proxies
+          .values()
+          .find(|p| {
+            p.upstream_host == settings.host
+              && p.upstream_port == settings.port
+              && p.upstream_type == settings.proxy_type
+          })
+          .map(|p| p.local_port)
+      })
     } else {
       None
     };
 
-    // Start a new proxy using the nodecar binary
+    // Start a new proxy using the nodecar binary with the correct CLI interface
     let mut nodecar = app_handle
       .shell()
       .sidecar("nodecar")
-      .unwrap()
+      .map_err(|e| format!("Failed to create sidecar: {e}"))?
       .arg("proxy")
       .arg("start")
-      .arg("-u")
-      .arg(upstream_url);
+      .arg("--host")
+      .arg(&proxy_settings.host)
+      .arg("--proxy-port")
+      .arg(proxy_settings.port.to_string())
+      .arg("--type")
+      .arg(&proxy_settings.proxy_type);
+
+    // Add credentials if provided
+    if let Some(username) = &proxy_settings.username {
+      nodecar = nodecar.arg("--username").arg(username);
+    }
+    if let Some(password) = &proxy_settings.password {
+      nodecar = nodecar.arg("--password").arg(password);
+    }
 
     // If we have a preferred port, use it
     if let Some(port) = preferred_port {
-      nodecar = nodecar.arg("-p").arg(port.to_string());
+      nodecar = nodecar.arg("--port").arg(port.to_string());
     }
 
-    let output = nodecar.output().await.unwrap();
+    // Execute the command and wait for it to complete
+    // The nodecar binary should start the worker and then exit
+    let output = nodecar
+      .output()
+      .await
+      .map_err(|e| format!("Failed to execute nodecar: {e}"))?;
 
     if !output.status.success() {
       let stderr = String::from_utf8_lossy(&output.stderr);
-      return Err(format!("Proxy start failed: {stderr}"));
+      let stdout = String::from_utf8_lossy(&output.stdout);
+      return Err(format!(
+        "Proxy start failed - stdout: {stdout}, stderr: {stderr}"
+      ));
     }
 
     let json_string =
@@ -95,15 +130,13 @@ impl ProxyManager {
       .as_str()
       .ok_or("Missing local URL")?
       .to_string();
-    let upstream_url_str = json["upstreamUrl"]
-      .as_str()
-      .ok_or("Missing upstream URL")?
-      .to_string();
 
     let proxy_info = ProxyInfo {
       id: id.to_string(),
       local_url,
-      upstream_url: upstream_url_str.clone(),
+      upstream_host: proxy_settings.host.clone(),
+      upstream_port: proxy_settings.port,
+      upstream_type: proxy_settings.proxy_type.clone(),
       local_port,
     };
 
@@ -116,15 +149,17 @@ impl ProxyManager {
     // Store the profile proxy info for persistence
     if let Some(name) = profile_name {
       let mut profile_proxies = self.profile_proxies.lock().unwrap();
-      profile_proxies.insert(name.to_string(), (upstream_url_str, local_port));
+      profile_proxies.insert(name.to_string(), proxy_settings.clone());
     }
 
     // Return proxy settings for the browser
     Ok(ProxySettings {
       enabled: true,
       proxy_type: "http".to_string(),
-      host: "localhost".to_string(),
+      host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
       port: proxy_info.local_port,
+      username: None,
+      password: None,
     })
   }
 
@@ -169,19 +204,556 @@ impl ProxyManager {
     proxies.get(&browser_pid).map(|proxy| ProxySettings {
       enabled: true,
       proxy_type: "http".to_string(),
-      host: "localhost".to_string(),
+      host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
       port: proxy.local_port,
+      username: None,
+      password: None,
     })
   }
 
   // Get stored proxy info for a profile
-  pub fn get_profile_proxy_info(&self, profile_name: &str) -> Option<(String, u16)> {
+  pub fn get_profile_proxy_info(&self, profile_name: &str) -> Option<ProxySettings> {
     let profile_proxies = self.profile_proxies.lock().unwrap();
     profile_proxies.get(profile_name).cloned()
   }
+
+  // Update the PID mapping for an existing proxy
+  pub fn update_proxy_pid(&self, old_pid: u32, new_pid: u32) -> Result<(), String> {
+    let mut proxies = self.active_proxies.lock().unwrap();
+    if let Some(proxy_info) = proxies.remove(&old_pid) {
+      proxies.insert(new_pid, proxy_info);
+      Ok(())
+    } else {
+      Err(format!("No proxy found for PID {old_pid}"))
+    }
+  }
 }
 
 // Create a singleton instance of the proxy manager
 lazy_static::lazy_static! {
     pub static ref PROXY_MANAGER: ProxyManager = ProxyManager::new();
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use std::env;
+  use std::path::PathBuf;
+  use std::process::Command;
+  use std::time::Duration;
+  use tokio::time::sleep;
+
+  // Mock HTTP server for testing
+
+  use http_body_util::Full;
+  use hyper::body::Bytes;
+  use hyper::server::conn::http1;
+  use hyper::service::service_fn;
+  use hyper::Response;
+  use hyper_util::rt::TokioIo;
+  use tokio::net::TcpListener;
+
+  // Helper function to build nodecar binary for testing
+  async fn ensure_nodecar_binary() -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let cargo_manifest_dir = env::var("CARGO_MANIFEST_DIR")?;
+    let project_root = PathBuf::from(cargo_manifest_dir)
+      .parent()
+      .unwrap()
+      .to_path_buf();
+    let nodecar_dir = project_root.join("nodecar");
+    let nodecar_dist = nodecar_dir.join("dist");
+    let nodecar_binary = nodecar_dist.join("nodecar");
+
+    // Check if binary already exists
+    if nodecar_binary.exists() {
+      return Ok(nodecar_binary);
+    }
+
+    // Build the nodecar binary
+    println!("Building nodecar binary for tests...");
+
+    // Install dependencies
+    let install_status = Command::new("pnpm")
+      .args(["install", "--frozen-lockfile"])
+      .current_dir(&nodecar_dir)
+      .status()?;
+
+    if !install_status.success() {
+      return Err("Failed to install nodecar dependencies".into());
+    }
+
+    // Determine the target architecture
+    let target = if cfg!(target_arch = "aarch64") && cfg!(target_os = "macos") {
+      "build:mac-aarch64"
+    } else if cfg!(target_arch = "x86_64") && cfg!(target_os = "macos") {
+      "build:mac-x86_64"
+    } else if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
+      "build:linux-x64"
+    } else if cfg!(target_arch = "aarch64") && cfg!(target_os = "linux") {
+      "build:linux-arm64"
+    } else if cfg!(target_arch = "x86_64") && cfg!(target_os = "windows") {
+      "build:win-x64"
+    } else if cfg!(target_arch = "aarch64") && cfg!(target_os = "windows") {
+      "build:win-arm64"
+    } else {
+      return Err("Unsupported target architecture for nodecar build".into());
+    };
+
+    // Build the binary
+    let build_status = Command::new("pnpm")
+      .args(["run", target])
+      .current_dir(&nodecar_dir)
+      .status()?;
+
+    if !build_status.success() {
+      return Err("Failed to build nodecar binary".into());
+    }
+
+    if !nodecar_binary.exists() {
+      return Err("Nodecar binary was not created successfully".into());
+    }
+
+    Ok(nodecar_binary)
+  }
+
+  #[tokio::test]
+  async fn test_proxy_manager_profile_persistence() {
+    let proxy_manager = ProxyManager::new();
+
+    let proxy_settings = ProxySettings {
+      enabled: true,
+      proxy_type: "socks5".to_string(),
+      host: "127.0.0.1".to_string(),
+      port: 1080,
+      username: None,
+      password: None,
+    };
+
+    // Test profile proxy info storage
+    {
+      let mut profile_proxies = proxy_manager.profile_proxies.lock().unwrap();
+      profile_proxies.insert("test_profile".to_string(), proxy_settings.clone());
+    }
+
+    // Test retrieval
+    let retrieved = proxy_manager.get_profile_proxy_info("test_profile");
+    assert!(retrieved.is_some());
+    let retrieved = retrieved.unwrap();
+    assert_eq!(retrieved.proxy_type, "socks5");
+    assert_eq!(retrieved.host, "127.0.0.1");
+    assert_eq!(retrieved.port, 1080);
+
+    // Test non-existent profile
+    let non_existent = proxy_manager.get_profile_proxy_info("non_existent");
+    assert!(non_existent.is_none());
+  }
+
+  #[tokio::test]
+  async fn test_proxy_manager_active_proxy_tracking() {
+    let proxy_manager = ProxyManager::new();
+
+    let proxy_info = ProxyInfo {
+      id: "test_proxy_123".to_string(),
+      local_url: "http://localhost:8080".to_string(),
+      upstream_host: "proxy.example.com".to_string(),
+      upstream_port: 3128,
+      upstream_type: "http".to_string(),
+      local_port: 8080,
+    };
+
+    let browser_pid = 54321u32;
+
+    // Add active proxy
+    {
+      let mut active_proxies = proxy_manager.active_proxies.lock().unwrap();
+      active_proxies.insert(browser_pid, proxy_info.clone());
+    }
+
+    // Test retrieval of proxy settings
+    let proxy_settings = proxy_manager.get_proxy_settings(browser_pid);
+    assert!(proxy_settings.is_some());
+    let settings = proxy_settings.unwrap();
+    assert!(settings.enabled);
+    assert_eq!(settings.host, "127.0.0.1");
+    assert_eq!(settings.port, 8080);
+
+    // Test non-existent browser PID
+    let non_existent = proxy_manager.get_proxy_settings(99999);
+    assert!(non_existent.is_none());
+  }
+
+  #[test]
+  fn test_proxy_settings_validation() {
+    // Test valid proxy settings
+    let valid_settings = ProxySettings {
+      enabled: true,
+      proxy_type: "http".to_string(),
+      host: "127.0.0.1".to_string(),
+      port: 8080,
+      username: Some("user".to_string()),
+      password: Some("pass".to_string()),
+    };
+
+    assert!(valid_settings.enabled);
+    assert_eq!(valid_settings.proxy_type, "http");
+    assert!(!valid_settings.host.is_empty());
+    assert!(valid_settings.port > 0);
+
+    // Test disabled proxy settings
+    let disabled_settings = ProxySettings {
+      enabled: false,
+      proxy_type: "http".to_string(),
+      host: "".to_string(),
+      port: 0,
+      username: None,
+      password: None,
+    };
+
+    assert!(!disabled_settings.enabled);
+  }
+
+  #[tokio::test]
+  async fn test_proxy_manager_concurrent_access() {
+    use std::sync::Arc;
+
+    let proxy_manager = Arc::new(ProxyManager::new());
+    let mut handles = vec![];
+
+    // Spawn multiple tasks that access the proxy manager concurrently
+    for i in 0..10 {
+      let pm = proxy_manager.clone();
+      let handle = tokio::spawn(async move {
+        let browser_pid = (1000 + i) as u32;
+        let proxy_info = ProxyInfo {
+          id: format!("proxy_{i}"),
+          local_url: format!("http://127.0.0.1:{}", 8000 + i),
+          upstream_host: "127.0.0.1".to_string(),
+          upstream_port: 3128,
+          upstream_type: "http".to_string(),
+          local_port: (8000 + i) as u16,
+        };
+
+        // Add proxy
+        {
+          let mut active_proxies = pm.active_proxies.lock().unwrap();
+          active_proxies.insert(browser_pid, proxy_info);
+        }
+
+        // Read proxy
+        let settings = pm.get_proxy_settings(browser_pid);
+        assert!(settings.is_some());
+
+        browser_pid
+      });
+      handles.push(handle);
+    }
+
+    // Wait for all tasks to complete
+    let results: Vec<u32> = futures_util::future::join_all(handles)
+      .await
+      .into_iter()
+      .map(|r| r.unwrap())
+      .collect();
+
+    // Verify all browser PIDs were processed
+    assert_eq!(results.len(), 10);
+    for (i, &browser_pid) in results.iter().enumerate() {
+      assert_eq!(browser_pid, (1000 + i) as u32);
+    }
+  }
+
+  // Integration test that actually builds and uses nodecar binary
+  #[tokio::test]
+  async fn test_proxy_integration_with_real_nodecar() -> Result<(), Box<dyn std::error::Error>> {
+    // This test requires nodecar to be built and available
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Start a mock upstream HTTP server
+    let upstream_listener = TcpListener::bind("127.0.0.1:0").await?;
+    let upstream_addr = upstream_listener.local_addr()?;
+
+    // Spawn upstream server
+    let server_handle = tokio::spawn(async move {
+      while let Ok((stream, _)) = upstream_listener.accept().await {
+        let io = TokioIo::new(stream);
+        tokio::task::spawn(async move {
+          let _ = http1::Builder::new()
+            .serve_connection(
+              io,
+              service_fn(|_req| async {
+                Ok::<_, hyper::Error>(Response::new(Full::new(Bytes::from("Upstream OK"))))
+              }),
+            )
+            .await;
+        });
+      }
+    });
+
+    // Wait for server to start
+    sleep(Duration::from_millis(100)).await;
+
+    // Test nodecar proxy start command directly (using the binary itself, not node)
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg(upstream_addr.ip().to_string())
+      .arg("--proxy-port")
+      .arg(upstream_addr.port().to_string())
+      .arg("--type")
+      .arg("http");
+
+    // Set a timeout for the command
+    let output = tokio::time::timeout(Duration::from_secs(10), async { cmd.output() }).await??;
+
+    if output.status.success() {
+      let stdout = String::from_utf8(output.stdout)?;
+      let config: serde_json::Value = serde_json::from_str(&stdout)?;
+
+      // Verify proxy configuration
+      assert!(config["id"].is_string());
+      assert!(config["localPort"].is_number());
+      assert!(config["localUrl"].is_string());
+
+      let proxy_id = config["id"].as_str().unwrap();
+      let local_port = config["localPort"].as_u64().unwrap();
+
+      // Wait for proxy worker to start
+      println!("Waiting for proxy worker to start...");
+      tokio::time::sleep(Duration::from_secs(3)).await;
+
+      // Test that the local port is listening
+      let mut port_test = Command::new("nc");
+      port_test
+        .arg("-z")
+        .arg("127.0.0.1")
+        .arg(local_port.to_string());
+
+      let port_output = port_test.output()?;
+      if port_output.status.success() {
+        println!("Proxy is listening on port {local_port}");
+      } else {
+        println!("Warning: Proxy port {local_port} is not listening");
+      }
+
+      // Test stopping the proxy
+      let mut stop_cmd = Command::new(&nodecar_path);
+      stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+
+      let stop_output =
+        tokio::time::timeout(Duration::from_secs(5), async { stop_cmd.output() }).await??;
+
+      assert!(stop_output.status.success());
+
+      println!("Integration test passed: nodecar proxy start/stop works correctly");
+    } else {
+      let stderr = String::from_utf8(output.stderr)?;
+      eprintln!("Nodecar failed: {stderr}");
+      return Err(format!("Nodecar command failed: {stderr}").into());
+    }
+
+    // Clean up server
+    server_handle.abort();
+
+    Ok(())
+  }
+
+  // Test that validates the command line arguments are constructed correctly
+  #[test]
+  fn test_proxy_command_construction() {
+    let proxy_settings = ProxySettings {
+      enabled: true,
+      proxy_type: "http".to_string(),
+      host: "proxy.example.com".to_string(),
+      port: 8080,
+      username: Some("user".to_string()),
+      password: Some("pass".to_string()),
+    };
+
+    // Test command arguments match expected format
+    let _expected_args = [
+      "proxy",
+      "start",
+      "--host",
+      "proxy.example.com",
+      "--proxy-port",
+      "8080",
+      "--type",
+      "http",
+      "--username",
+      "user",
+      "--password",
+      "pass",
+    ];
+
+    // This test verifies the argument structure without actually running the command
+    assert_eq!(proxy_settings.host, "proxy.example.com");
+    assert_eq!(proxy_settings.port, 8080);
+    assert_eq!(proxy_settings.proxy_type, "http");
+    assert_eq!(proxy_settings.username.as_ref().unwrap(), "user");
+    assert_eq!(proxy_settings.password.as_ref().unwrap(), "pass");
+  }
+
+  // Test the CLI detachment specifically - ensure the CLI exits properly
+  #[tokio::test]
+  async fn test_cli_exits_after_proxy_start() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test that the CLI exits quickly with a mock upstream
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("httpbin.org")
+      .arg("--proxy-port")
+      .arg("80")
+      .arg("--type")
+      .arg("http");
+
+    let start_time = std::time::Instant::now();
+    let output = tokio::time::timeout(Duration::from_secs(3), async { cmd.output() }).await;
+
+    match output {
+      Ok(Ok(cmd_output)) => {
+        let execution_time = start_time.elapsed();
+        println!("CLI completed in {execution_time:?}");
+
+        // Should complete very quickly if properly detached
+        assert!(
+          execution_time < Duration::from_secs(3),
+          "CLI took too long ({execution_time:?}), should exit immediately after starting worker"
+        );
+
+        if cmd_output.status.success() {
+          let stdout = String::from_utf8(cmd_output.stdout)?;
+          let config: serde_json::Value = serde_json::from_str(&stdout)?;
+
+          // Clean up - try to stop the proxy
+          if let Some(proxy_id) = config["id"].as_str() {
+            let mut stop_cmd = Command::new(&nodecar_path);
+            stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+            let _ = stop_cmd.output();
+          }
+        }
+
+        println!("CLI detachment test passed - CLI exited in {execution_time:?}");
+      }
+      Ok(Err(e)) => {
+        return Err(format!("Command execution failed: {e}").into());
+      }
+      Err(_) => {
+        return Err("CLI command timed out - this indicates improper detachment".into());
+      }
+    }
+
+    Ok(())
+  }
+
+  // Test that validates proper CLI detachment behavior
+  #[tokio::test]
+  async fn test_cli_detachment_behavior() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test that the CLI command exits quickly even with a real upstream
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("httpbin.org") // Use a known good endpoint
+      .arg("--proxy-port")
+      .arg("80")
+      .arg("--type")
+      .arg("http");
+
+    let start_time = std::time::Instant::now();
+    let output = tokio::time::timeout(Duration::from_secs(5), async { cmd.output() }).await??;
+    let execution_time = start_time.elapsed();
+
+    // Command should complete very quickly if properly detached
+    assert!(
+      execution_time < Duration::from_secs(5),
+      "CLI command took {execution_time:?}, should complete in under 5 seconds for proper detachment"
+    );
+
+    println!("CLI detachment test: command completed in {execution_time:?}");
+
+    if output.status.success() {
+      let stdout = String::from_utf8(output.stdout)?;
+      let config: serde_json::Value = serde_json::from_str(&stdout)?;
+      let proxy_id = config["id"].as_str().unwrap();
+
+      // Clean up
+      let mut stop_cmd = Command::new(&nodecar_path);
+      stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+      let _ = stop_cmd.output();
+
+      println!("CLI detachment test passed");
+    } else {
+      // Even if the upstream fails, the CLI should still exit quickly
+      println!("CLI command failed but exited quickly as expected");
+    }
+
+    Ok(())
+  }
+
+  // Test that validates URL encoding for special characters in credentials
+  #[tokio::test]
+  async fn test_proxy_credentials_encoding() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test with credentials that include special characters
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("test.example.com")
+      .arg("--proxy-port")
+      .arg("8080")
+      .arg("--type")
+      .arg("http")
+      .arg("--username")
+      .arg("user@domain.com") // Contains @ symbol
+      .arg("--password")
+      .arg("pass word!"); // Contains space and special character
+
+    let output = tokio::time::timeout(Duration::from_secs(5), async { cmd.output() }).await??;
+
+    if output.status.success() {
+      let stdout = String::from_utf8(output.stdout)?;
+      let config: serde_json::Value = serde_json::from_str(&stdout)?;
+
+      let upstream_url = config["upstreamUrl"].as_str().unwrap();
+
+      println!("Generated upstream URL: {upstream_url}");
+
+      // Verify that special characters are properly encoded
+      assert!(upstream_url.contains("user%40domain.com"));
+      // The password may be encoded as "pass%20word!" or "pass%20word%21" depending on implementation
+      assert!(upstream_url.contains("pass%20word"));
+
+      println!("URL encoding test passed - special characters handled correctly");
+
+      // Clean up
+      let proxy_id = config["id"].as_str().unwrap();
+      let mut stop_cmd = Command::new(&nodecar_path);
+      stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+      let _ = stop_cmd.output();
+    } else {
+      // This test might fail if the upstream doesn't exist, but we mainly care about URL construction
+      let stdout = String::from_utf8(output.stdout)?;
+      let stderr = String::from_utf8(output.stderr)?;
+      println!("Command failed (expected for non-existent upstream):");
+      println!("Stdout: {stdout}");
+      println!("Stderr: {stderr}");
+
+      // The important thing is that the command completed quickly
+      println!("URL encoding test completed - credentials should be properly encoded");
+    }
+
+    Ok(())
+  }
+}

src-tauri/src/settings_manager.rs

@@ -3,6 +3,9 @@ use serde::{Deserialize, Serialize};
 use std::fs::{self, create_dir_all};
 use std::path::PathBuf;
 
+use crate::api_client::ApiClient;
+use crate::version_updater;
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct TableSortingSettings {
   pub column: String,    // Column to sort by: "name", "browser", "status"
@@ -22,33 +25,25 @@ impl Default for TableSortingSettings {
 pub struct AppSettings {
   #[serde(default)]
   pub set_as_default_browser: bool,
-  #[serde(default = "default_show_settings_on_startup")]
+  #[serde(default)]
   pub show_settings_on_startup: bool,
   #[serde(default = "default_theme")]
   pub theme: String, // "light", "dark", or "system"
-  #[serde(default = "default_auto_updates_enabled")]
-  pub auto_updates_enabled: bool,
-}
-
-fn default_show_settings_on_startup() -> bool {
-  true
+  #[serde(default)]
+  pub auto_delete_unused_binaries: bool,
 }
 
 fn default_theme() -> String {
   "system".to_string()
 }
 
-fn default_auto_updates_enabled() -> bool {
-  true
-}
-
 impl Default for AppSettings {
   fn default() -> Self {
     Self {
       set_as_default_browser: false,
-      show_settings_on_startup: default_show_settings_on_startup(),
-      theme: default_theme(),
-      auto_updates_enabled: default_auto_updates_enabled(),
+      show_settings_on_startup: true,
+      theme: "system".to_string(),
+      auto_delete_unused_binaries: true,
     }
   }
 }
@@ -163,13 +158,6 @@ impl SettingsManager {
     // 3. User hasn't explicitly disabled the default browser setting
     Ok(settings.show_settings_on_startup && !settings.set_as_default_browser)
   }
-
-  pub fn disable_default_browser_prompt(&self) -> Result<(), Box<dyn std::error::Error>> {
-    let mut settings = self.load_settings()?;
-    settings.show_settings_on_startup = false;
-    self.save_settings(&settings)?;
-    Ok(())
-  }
 }
 
 #[tauri::command]
@@ -196,14 +184,6 @@ pub async fn should_show_settings_on_startup() -> Result<bool, String> {
     .map_err(|e| format!("Failed to check prompt setting: {e}"))
 }
 
-#[tauri::command]
-pub async fn disable_default_browser_prompt() -> Result<(), String> {
-  let manager = SettingsManager::new();
-  manager
-    .disable_default_browser_prompt()
-    .map_err(|e| format!("Failed to disable prompt: {e}"))
-}
-
 #[tauri::command]
 pub async fn get_table_sorting_settings() -> Result<TableSortingSettings, String> {
   let manager = SettingsManager::new();
@@ -219,3 +199,25 @@ pub async fn save_table_sorting_settings(sorting: TableSortingSettings) -> Resul
     .save_table_sorting(&sorting)
     .map_err(|e| format!("Failed to save table sorting settings: {e}"))
 }
+
+#[tauri::command]
+pub async fn clear_all_version_cache_and_refetch(
+  app_handle: tauri::AppHandle,
+) -> Result<(), String> {
+  let api_client = ApiClient::new();
+
+  // Clear all cache first
+  api_client
+    .clear_all_cache()
+    .map_err(|e| format!("Failed to clear version cache: {e}"))?;
+
+  let updater = version_updater::get_version_updater();
+  let updater_guard = updater.lock().await;
+
+  updater_guard
+    .trigger_manual_update(&app_handle)
+    .await
+    .map_err(|e| format!("Failed to trigger version update: {e}"))?;
+
+  Ok(())
+}

src-tauri/src/theme_detector.rs

@@ -0,0 +1,539 @@
+use serde::{Deserialize, Serialize};
+use std::process::Command;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SystemTheme {
+  pub theme: String, // "light", "dark", or "unknown"
+}
+
+pub struct ThemeDetector;
+
+impl ThemeDetector {
+  pub fn new() -> Self {
+    Self
+  }
+
+  /// Detect the system theme preference
+  pub fn detect_system_theme(&self) -> SystemTheme {
+    #[cfg(target_os = "linux")]
+    return linux::detect_system_theme();
+
+    #[cfg(target_os = "macos")]
+    return macos::detect_system_theme();
+
+    #[cfg(target_os = "windows")]
+    return windows::detect_system_theme();
+
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    return SystemTheme {
+      theme: "unknown".to_string(),
+    };
+  }
+}
+
+#[cfg(target_os = "linux")]
+mod linux {
+  use super::*;
+
+  pub fn detect_system_theme() -> SystemTheme {
+    // Try multiple methods in order of preference
+
+    // 1. Try GNOME/GTK settings via gsettings
+    if let Ok(theme) = detect_gnome_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 2. Try KDE Plasma settings via kreadconfig5/kreadconfig6
+    if let Ok(theme) = detect_kde_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 3. Try XFCE settings via xfconf-query
+    if let Ok(theme) = detect_xfce_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 4. Try looking at current GTK theme name
+    if let Ok(theme) = detect_gtk_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 5. Try dconf directly (fallback for GNOME-based systems)
+    if let Ok(theme) = detect_dconf_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 6. Try environment variables
+    if let Ok(theme) = detect_env_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 7. Try freedesktop portal
+    if let Ok(theme) = detect_portal_theme() {
+      return SystemTheme { theme };
+    }
+
+    // 8. Try looking at system color scheme files
+    if let Ok(theme) = detect_system_files_theme() {
+      return SystemTheme { theme };
+    }
+
+    // Fallback to unknown
+    SystemTheme {
+      theme: "unknown".to_string(),
+    }
+  }
+
+  fn detect_gnome_theme() -> Result<String, Box<dyn std::error::Error>> {
+    // Check if gsettings is available
+    if !is_command_available("gsettings") {
+      return Err("gsettings not available".into());
+    }
+
+    // Try GNOME color scheme first (modern way)
+    if let Ok(output) = Command::new("gsettings")
+      .args(["get", "org.gnome.desktop.interface", "color-scheme"])
+      .output()
+    {
+      if output.status.success() {
+        let scheme = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        match scheme.as_str() {
+          "'prefer-dark'" => return Ok("dark".to_string()),
+          "'prefer-light'" => return Ok("light".to_string()),
+          _ => {}
+        }
+      }
+    }
+
+    // Fallback to GTK theme name detection
+    if let Ok(output) = Command::new("gsettings")
+      .args(["get", "org.gnome.desktop.interface", "gtk-theme"])
+      .output()
+    {
+      if output.status.success() {
+        let theme_name = String::from_utf8_lossy(&output.stdout)
+          .trim()
+          .trim_matches('\'')
+          .to_lowercase();
+
+        if theme_name.contains("dark") || theme_name.contains("night") {
+          return Ok("dark".to_string());
+        } else if theme_name.contains("light") || theme_name.contains("adwaita") {
+          return Ok("light".to_string());
+        }
+      }
+    }
+
+    Err("Could not detect GNOME theme".into())
+  }
+
+  fn detect_kde_theme() -> Result<String, Box<dyn std::error::Error>> {
+    // Try KDE Plasma 6 first
+    if is_command_available("kreadconfig6") {
+      if let Ok(output) = Command::new("kreadconfig6")
+        .args([
+          "--file",
+          "kdeglobals",
+          "--group",
+          "KDE",
+          "--key",
+          "LookAndFeelPackage",
+        ])
+        .output()
+      {
+        if output.status.success() {
+          let theme = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_lowercase();
+          if theme.contains("dark") || theme.contains("breezedark") {
+            return Ok("dark".to_string());
+          } else if theme.contains("light") || theme.contains("breeze") {
+            return Ok("light".to_string());
+          }
+        }
+      }
+
+      // Try color scheme as well
+      if let Ok(output) = Command::new("kreadconfig6")
+        .args([
+          "--file",
+          "kdeglobals",
+          "--group",
+          "General",
+          "--key",
+          "ColorScheme",
+        ])
+        .output()
+      {
+        if output.status.success() {
+          let scheme = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_lowercase();
+          if scheme.contains("dark") || scheme.contains("breezedark") {
+            return Ok("dark".to_string());
+          } else if scheme.contains("light") || scheme.contains("breeze") {
+            return Ok("light".to_string());
+          }
+        }
+      }
+    }
+
+    // Try KDE Plasma 5 as fallback
+    if is_command_available("kreadconfig5") {
+      if let Ok(output) = Command::new("kreadconfig5")
+        .args([
+          "--file",
+          "kdeglobals",
+          "--group",
+          "KDE",
+          "--key",
+          "LookAndFeelPackage",
+        ])
+        .output()
+      {
+        if output.status.success() {
+          let theme = String::from_utf8_lossy(&output.stdout)
+            .trim()
+            .to_lowercase();
+          if theme.contains("dark") || theme.contains("breezedark") {
+            return Ok("dark".to_string());
+          } else if theme.contains("light") || theme.contains("breeze") {
+            return Ok("light".to_string());
+          }
+        }
+      }
+    }
+
+    Err("Could not detect KDE theme".into())
+  }
+
+  fn detect_xfce_theme() -> Result<String, Box<dyn std::error::Error>> {
+    if !is_command_available("xfconf-query") {
+      return Err("xfconf-query not available".into());
+    }
+
+    // Check XFCE theme
+    if let Ok(output) = Command::new("xfconf-query")
+      .args(["-c", "xsettings", "-p", "/Net/ThemeName"])
+      .output()
+    {
+      if output.status.success() {
+        let theme = String::from_utf8_lossy(&output.stdout)
+          .trim()
+          .to_lowercase();
+        if theme.contains("dark") || theme.contains("night") {
+          return Ok("dark".to_string());
+        } else if theme.contains("light") {
+          return Ok("light".to_string());
+        }
+      }
+    }
+
+    // Check XFCE window manager theme as backup
+    if let Ok(output) = Command::new("xfconf-query")
+      .args(["-c", "xfwm4", "-p", "/general/theme"])
+      .output()
+    {
+      if output.status.success() {
+        let theme = String::from_utf8_lossy(&output.stdout)
+          .trim()
+          .to_lowercase();
+        if theme.contains("dark") || theme.contains("night") {
+          return Ok("dark".to_string());
+        } else if theme.contains("light") {
+          return Ok("light".to_string());
+        }
+      }
+    }
+
+    Err("Could not detect XFCE theme".into())
+  }
+
+  fn detect_gtk_theme() -> Result<String, Box<dyn std::error::Error>> {
+    // Try to read GTK3 settings file
+    if let Ok(home) = std::env::var("HOME") {
+      let gtk3_settings = std::path::Path::new(&home).join(".config/gtk-3.0/settings.ini");
+      if gtk3_settings.exists() {
+        if let Ok(content) = std::fs::read_to_string(gtk3_settings) {
+          for line in content.lines() {
+            if line.starts_with("gtk-theme-name=") {
+              let theme_name = line.split('=').nth(1).unwrap_or("").trim().to_lowercase();
+              if theme_name.contains("dark") || theme_name.contains("night") {
+                return Ok("dark".to_string());
+              } else if theme_name.contains("light") || theme_name.contains("adwaita") {
+                return Ok("light".to_string());
+              }
+            }
+          }
+        }
+      }
+
+      // Try GTK4 settings
+      let gtk4_settings = std::path::Path::new(&home).join(".config/gtk-4.0/settings.ini");
+      if gtk4_settings.exists() {
+        if let Ok(content) = std::fs::read_to_string(gtk4_settings) {
+          for line in content.lines() {
+            if line.starts_with("gtk-theme-name=") {
+              let theme_name = line.split('=').nth(1).unwrap_or("").trim().to_lowercase();
+              if theme_name.contains("dark") || theme_name.contains("night") {
+                return Ok("dark".to_string());
+              } else if theme_name.contains("light") || theme_name.contains("adwaita") {
+                return Ok("light".to_string());
+              }
+            }
+          }
+        }
+      }
+    }
+
+    Err("Could not detect GTK theme".into())
+  }
+
+  fn detect_dconf_theme() -> Result<String, Box<dyn std::error::Error>> {
+    if !is_command_available("dconf") {
+      return Err("dconf not available".into());
+    }
+
+    // Try reading color scheme directly from dconf
+    if let Ok(output) = Command::new("dconf")
+      .args(["read", "/org/gnome/desktop/interface/color-scheme"])
+      .output()
+    {
+      if output.status.success() {
+        let scheme = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        match scheme.as_str() {
+          "'prefer-dark'" => return Ok("dark".to_string()),
+          "'prefer-light'" => return Ok("light".to_string()),
+          _ => {}
+        }
+      }
+    }
+
+    // Try reading GTK theme from dconf
+    if let Ok(output) = Command::new("dconf")
+      .args(["read", "/org/gnome/desktop/interface/gtk-theme"])
+      .output()
+    {
+      if output.status.success() {
+        let theme_name = String::from_utf8_lossy(&output.stdout)
+          .trim()
+          .trim_matches('\'')
+          .to_lowercase();
+
+        if theme_name.contains("dark") || theme_name.contains("night") {
+          return Ok("dark".to_string());
+        } else if theme_name.contains("light") || theme_name.contains("adwaita") {
+          return Ok("light".to_string());
+        }
+      }
+    }
+
+    Err("Could not detect dconf theme".into())
+  }
+
+  fn detect_env_theme() -> Result<String, Box<dyn std::error::Error>> {
+    // Check common environment variables
+    if let Ok(theme) = std::env::var("GTK_THEME") {
+      let theme_lower = theme.to_lowercase();
+      if theme_lower.contains("dark") || theme_lower.contains("night") {
+        return Ok("dark".to_string());
+      } else if theme_lower.contains("light") {
+        return Ok("light".to_string());
+      }
+    }
+
+    if let Ok(theme) = std::env::var("QT_STYLE_OVERRIDE") {
+      let theme_lower = theme.to_lowercase();
+      if theme_lower.contains("dark") || theme_lower.contains("night") {
+        return Ok("dark".to_string());
+      } else if theme_lower.contains("light") {
+        return Ok("light".to_string());
+      }
+    }
+
+    Err("Could not detect theme from environment".into())
+  }
+
+  fn detect_portal_theme() -> Result<String, Box<dyn std::error::Error>> {
+    if !is_command_available("busctl") {
+      return Err("busctl not available".into());
+    }
+
+    // Try to query the color scheme via org.freedesktop.portal.Settings
+    if let Ok(output) = Command::new("busctl")
+      .args([
+        "--user",
+        "call",
+        "org.freedesktop.portal.Desktop",
+        "/org/freedesktop/portal/desktop",
+        "org.freedesktop.portal.Settings",
+        "Read",
+        "ss",
+        "org.freedesktop.appearance",
+        "color-scheme",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let response = String::from_utf8_lossy(&output.stdout);
+        // Parse DBus response - look for preference values
+        if response.contains(" 1 ") {
+          return Ok("dark".to_string());
+        } else if response.contains(" 2 ") {
+          return Ok("light".to_string());
+        }
+      }
+    }
+
+    Err("Could not detect portal theme".into())
+  }
+
+  fn detect_system_files_theme() -> Result<String, Box<dyn std::error::Error>> {
+    // Check if we're in a dark terminal (heuristic)
+    if let Ok(term) = std::env::var("TERM") {
+      let term_lower = term.to_lowercase();
+      if term_lower.contains("dark") || term_lower.contains("night") {
+        return Ok("dark".to_string());
+      }
+    }
+
+    // Check if we can determine from desktop session
+    if let Ok(desktop) = std::env::var("XDG_CURRENT_DESKTOP") {
+      let desktop_lower = desktop.to_lowercase();
+      // Some desktops default to dark
+      if desktop_lower.contains("i3") || desktop_lower.contains("sway") {
+        // Window managers often use dark themes by default
+        return Ok("dark".to_string());
+      }
+    }
+
+    Err("Could not detect theme from system files".into())
+  }
+
+  fn is_command_available(command: &str) -> bool {
+    Command::new("which")
+      .arg(command)
+      .output()
+      .map(|output| output.status.success())
+      .unwrap_or(false)
+  }
+}
+
+#[cfg(target_os = "macos")]
+mod macos {
+  use super::*;
+
+  pub fn detect_system_theme() -> SystemTheme {
+    // macOS theme detection using osascript
+    if let Ok(output) = Command::new("osascript")
+      .args([
+        "-e",
+        "tell application \"System Events\" to tell appearance preferences to get dark mode",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let result = String::from_utf8_lossy(&output.stdout).to_string();
+        let result = result.trim();
+        match result {
+          "true" => {
+            return SystemTheme {
+              theme: "dark".to_string(),
+            }
+          }
+          "false" => {
+            return SystemTheme {
+              theme: "light".to_string(),
+            }
+          }
+          _ => {}
+        }
+      }
+    }
+
+    // Fallback method using defaults
+    if let Ok(output) = Command::new("defaults")
+      .args(["read", "-g", "AppleInterfaceStyle"])
+      .output()
+    {
+      if output.status.success() {
+        let style = String::from_utf8_lossy(&output.stdout).to_string();
+        let style = style.trim();
+        if style.to_lowercase() == "dark" {
+          return SystemTheme {
+            theme: "dark".to_string(),
+          };
+        }
+      }
+    }
+
+    // Default to light if we can't determine
+    SystemTheme {
+      theme: "light".to_string(),
+    }
+  }
+}
+
+#[cfg(target_os = "windows")]
+mod windows {
+  use super::*;
+
+  pub fn detect_system_theme() -> SystemTheme {
+    // Windows theme detection via registry
+    // This is a simplified implementation - you might want to use winreg crate for better registry access
+    if let Ok(output) = Command::new("reg")
+      .args([
+        "query",
+        "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+        "/v",
+        "AppsUseLightTheme",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let result = String::from_utf8_lossy(&output.stdout);
+        if result.contains("0x0") {
+          return SystemTheme {
+            theme: "dark".to_string(),
+          };
+        } else if result.contains("0x1") {
+          return SystemTheme {
+            theme: "light".to_string(),
+          };
+        }
+      }
+    }
+
+    // Default to light if we can't determine
+    SystemTheme {
+      theme: "light".to_string(),
+    }
+  }
+}
+
+// Command to expose this functionality to the frontend
+#[tauri::command]
+pub fn get_system_theme() -> SystemTheme {
+  let detector = ThemeDetector::new();
+  detector.detect_system_theme()
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_theme_detector_creation() {
+    let detector = ThemeDetector::new();
+    let theme = detector.detect_system_theme();
+
+    // Should return a valid theme string
+    assert!(matches!(theme.theme.as_str(), "light" | "dark" | "unknown"));
+  }
+
+  #[test]
+  fn test_get_system_theme_command() {
+    let theme = get_system_theme();
+    assert!(matches!(theme.theme.as_str(), "light" | "dark" | "unknown"));
+  }
+}

src-tauri/src/version_updater.rs

@@ -1,4 +1,3 @@
-use crate::browser_version_service::BrowserVersionService;
 use directories::BaseDirs;
 use serde::{Deserialize, Serialize};
 use std::fs;
@@ -8,7 +7,10 @@ use std::sync::OnceLock;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tauri::Emitter;
 use tokio::sync::Mutex;
-use tokio::time::{interval, Interval};
+use tokio::time::interval;
+
+use crate::auto_updater::AutoUpdater;
+use crate::browser_version_service::BrowserVersionService;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct VersionUpdateProgress {
@@ -46,22 +48,23 @@ impl Default for BackgroundUpdateState {
 
 pub struct VersionUpdater {
   version_service: BrowserVersionService,
-  app_handle: Arc<Mutex<Option<tauri::AppHandle>>>,
-  update_interval: Interval,
+  auto_updater: AutoUpdater,
+  app_handle: Option<tauri::AppHandle>,
 }
 
 impl VersionUpdater {
   pub fn new() -> Self {
-    let mut update_interval = interval(Duration::from_secs(5 * 60)); // Check every 5 minutes
-    update_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
-
     Self {
       version_service: BrowserVersionService::new(),
-      app_handle: Arc::new(Mutex::new(None)),
-      update_interval,
+      auto_updater: AutoUpdater::new(),
+      app_handle: None,
     }
   }
 
+  pub fn set_app_handle(&mut self, app_handle: tauri::AppHandle) {
+    self.app_handle = Some(app_handle);
+  }
+
   fn get_cache_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
     let base_dirs = BaseDirs::new().ok_or("Failed to get base directories")?;
     let app_name = if cfg!(debug_assertions) {
@@ -143,11 +146,6 @@ impl VersionUpdater {
     should_update
   }
 
-  pub async fn set_app_handle(&self, app_handle: tauri::AppHandle) {
-    let mut handle = self.app_handle.lock().await;
-    *handle = Some(app_handle);
-  }
-
   pub async fn check_and_run_startup_update(
     &self,
   ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@@ -157,15 +155,10 @@ impl VersionUpdater {
       return Ok(());
     }
 
-    let app_handle = {
-      let handle_guard = self.app_handle.lock().await;
-      handle_guard.clone()
-    };
-
-    if let Some(handle) = app_handle {
+    if let Some(ref app_handle) = self.app_handle {
       println!("Running startup version update...");
 
-      match self.update_all_browser_versions(&handle).await {
+      match self.update_all_browser_versions(app_handle).await {
         Ok(_) => {
           // Update the persistent state after successful update
           let state = BackgroundUpdateState {
@@ -191,7 +184,9 @@ impl VersionUpdater {
     Ok(())
   }
 
-  pub async fn start_background_updates(&mut self) {
+  pub async fn start_background_updates(
+    &self,
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     println!(
       "Starting background version update service (checking every 5 minutes for 3-hour intervals)"
     );
@@ -201,41 +196,54 @@ impl VersionUpdater {
       eprintln!("Startup version update failed: {e}");
     }
 
+    Ok(())
+  }
+
+  pub async fn run_background_task() {
+    let mut update_interval = interval(Duration::from_secs(5 * 60)); // Check every 5 minutes
+    update_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+
     loop {
-      self.update_interval.tick().await;
+      update_interval.tick().await;
 
       // Check if we should run an update based on persistent state
       if !Self::should_run_background_update() {
         continue;
       }
 
-      // Check if we have an app handle
-      let app_handle = {
-        let handle_guard = self.app_handle.lock().await;
-        handle_guard.clone()
-      };
+      println!("Starting background version update...");
 
-      if let Some(handle) = app_handle {
-        println!("Starting background version update...");
+      // Get the updater instance for this update cycle
+      let updater = get_version_updater();
+      let result = {
+        let updater_guard = updater.lock().await;
+        if let Some(ref app_handle) = updater_guard.app_handle {
+          updater_guard.update_all_browser_versions(app_handle).await
+        } else {
+          Err("App handle not available for background update".into())
+        }
+      }; // Release the lock here
 
-        match self.update_all_browser_versions(&handle).await {
-          Ok(_) => {
-            // Update the persistent state after successful update
-            let state = BackgroundUpdateState {
-              last_update_time: Self::get_current_timestamp(),
-              update_interval_hours: 3,
-            };
+      match result {
+        Ok(_) => {
+          // Update the persistent state after successful update
+          let state = BackgroundUpdateState {
+            last_update_time: Self::get_current_timestamp(),
+            update_interval_hours: 3,
+          };
 
-            if let Err(e) = Self::save_background_update_state(&state) {
-              eprintln!("Failed to save background update state: {e}");
-            } else {
-              println!("Background version update completed successfully");
-            }
+          if let Err(e) = Self::save_background_update_state(&state) {
+            eprintln!("Failed to save background update state: {e}");
+          } else {
+            println!("Background version update completed successfully");
           }
-          Err(e) => {
-            eprintln!("Background version update failed: {e}");
+        }
+        Err(e) => {
+          eprintln!("Background version update failed: {e}");
 
-            // Emit error event
+          // Try to emit error event if we have an app handle
+          let updater_guard = updater.lock().await;
+          if let Some(ref app_handle) = updater_guard.app_handle {
             let progress = VersionUpdateProgress {
               current_browser: "".to_string(),
               total_browsers: 0,
@@ -244,11 +252,9 @@ impl VersionUpdater {
               browser_new_versions: 0,
               status: "error".to_string(),
             };
-            let _ = handle.emit("version-update-progress", &progress);
+            let _ = app_handle.emit("version-update-progress", &progress);
           }
         }
-      } else {
-        println!("App handle not available, skipping background update");
       }
     }
   }
@@ -257,107 +263,108 @@ impl VersionUpdater {
     &self,
     app_handle: &tauri::AppHandle,
   ) -> Result<Vec<BackgroundUpdateResult>, Box<dyn std::error::Error + Send + Sync>> {
-    println!("Starting background version update for all browsers");
-
-    let browsers = [
-      "firefox",
-      "firefox-developer",
-      "mullvad-browser",
-      "zen",
-      "brave",
-      "chromium",
-      "tor-browser",
-    ];
-
-    let total_browsers = browsers.len();
+    let supported_browsers = self.version_service.get_supported_browsers();
+    let total_browsers = supported_browsers.len();
     let mut results = Vec::new();
     let mut total_new_versions = 0;
 
-    // Emit start event
-    let progress = VersionUpdateProgress {
-      current_browser: "".to_string(),
+    // Emit initial progress
+    let initial_progress = VersionUpdateProgress {
+      current_browser: String::new(),
       total_browsers,
       completed_browsers: 0,
       new_versions_found: 0,
       browser_new_versions: 0,
       status: "updating".to_string(),
     };
-    let _ = app_handle.emit("version-update-progress", &progress);
 
-    for (index, browser) in browsers.iter().enumerate() {
-      // Check if individual browser cache is expired before updating
-      if !self.version_service.should_update_cache(browser) {
-        println!("Skipping {browser} - cache is still fresh");
+    if let Err(e) = app_handle.emit("version-update-progress", &initial_progress) {
+      eprintln!("Failed to emit initial progress: {e}");
+    }
 
-        let browser_result = BackgroundUpdateResult {
-          browser: browser.to_string(),
-          new_versions_count: 0,
-          total_versions_count: 0,
-          updated_successfully: true,
-          error: None,
-        };
-        results.push(browser_result);
-        continue;
-      }
+    for (index, browser) in supported_browsers.iter().enumerate() {
+      println!("Updating browser versions for: {browser}");
 
-      println!("Updating versions for browser: {browser}");
-
-      // Emit progress for current browser
+      // Emit progress update for current browser
       let progress = VersionUpdateProgress {
-        current_browser: browser.to_string(),
+        current_browser: browser.clone(),
         total_browsers,
         completed_browsers: index,
         new_versions_found: total_new_versions,
         browser_new_versions: 0,
         status: "updating".to_string(),
       };
-      let _ = app_handle.emit("version-update-progress", &progress);
 
-      let result = self.update_browser_versions(browser).await;
+      if let Err(e) = app_handle.emit("version-update-progress", &progress) {
+        eprintln!("Failed to emit progress for {browser}: {e}");
+      }
 
-      match result {
-        Ok(new_count) => {
-          total_new_versions += new_count;
-          let browser_result = BackgroundUpdateResult {
-            browser: browser.to_string(),
-            new_versions_count: new_count,
-            total_versions_count: 0, // We'll update this if needed
+      match self.update_browser_versions(browser).await {
+        Ok(new_versions_count) => {
+          results.push(BackgroundUpdateResult {
+            browser: browser.clone(),
+            new_versions_count,
+            total_versions_count: 0, // We don't track total for background updates
             updated_successfully: true,
             error: None,
-          };
-          results.push(browser_result);
+          });
 
-          println!("Found {new_count} new versions for {browser}");
+          total_new_versions += new_versions_count;
+
+          // Emit progress update with new versions found
+          let progress = VersionUpdateProgress {
+            current_browser: browser.clone(),
+            total_browsers,
+            completed_browsers: index,
+            new_versions_found: total_new_versions,
+            browser_new_versions: new_versions_count,
+            status: "updating".to_string(),
+          };
+
+          if let Err(e) = app_handle.emit("version-update-progress", &progress) {
+            eprintln!("Failed to emit progress with versions for {browser}: {e}");
+          }
         }
         Err(e) => {
-          eprintln!("Failed to update versions for {browser}: {e}");
-          let browser_result = BackgroundUpdateResult {
-            browser: browser.to_string(),
+          results.push(BackgroundUpdateResult {
+            browser: browser.clone(),
             new_versions_count: 0,
             total_versions_count: 0,
             updated_successfully: false,
             error: Some(e.to_string()),
-          };
-          results.push(browser_result);
+          });
         }
       }
-
-      // Small delay between browsers to avoid overwhelming APIs
-      tokio::time::sleep(Duration::from_millis(500)).await;
     }
 
-    // Emit completion event
-    let progress = VersionUpdateProgress {
-      current_browser: "".to_string(),
+    // Emit completion
+    let final_progress = VersionUpdateProgress {
+      current_browser: String::new(),
       total_browsers,
       completed_browsers: total_browsers,
       new_versions_found: total_new_versions,
       browser_new_versions: 0,
       status: "completed".to_string(),
     };
-    let _ = app_handle.emit("version-update-progress", &progress);
 
-    println!("Background version update completed. Found {total_new_versions} new versions total");
+    if let Err(e) = app_handle.emit("version-update-progress", &final_progress) {
+      eprintln!("Failed to emit completion progress: {e}");
+    }
+
+    // After all version updates are complete, trigger auto-update check
+    if total_new_versions > 0 {
+      println!(
+        "Found {total_new_versions} new versions across all browsers. Checking for auto-updates..."
+      );
+
+      // Trigger auto-update check which will automatically download browsers
+      self
+        .auto_updater
+        .check_for_updates_with_progress(app_handle)
+        .await;
+    } else {
+      println!("No new versions found, skipping auto-update check");
+    }
 
     Ok(results)
   }
@@ -448,22 +455,6 @@ pub async fn get_version_update_status() -> Result<(Option<u64>, u64), String> {
   Ok((last_update, time_until_next))
 }
 
-#[tauri::command]
-pub async fn check_version_update_needed() -> Result<bool, String> {
-  Ok(VersionUpdater::should_run_background_update())
-}
-
-#[tauri::command]
-pub async fn force_version_update_check(_app_handle: tauri::AppHandle) -> Result<bool, String> {
-  let updater = get_version_updater();
-  let updater_guard = updater.lock().await;
-
-  match updater_guard.check_and_run_startup_update().await {
-    Ok(_) => Ok(true),
-    Err(e) => Err(format!("Failed to run version update check: {e}")),
-  }
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Donut Browser",
-  "version": "0.1.0",
+  "version": "0.5.3",
   "identifier": "com.donutbrowser",
   "build": {
     "beforeDevCommand": "pnpm dev",
@@ -10,15 +10,7 @@
     "frontendDist": "../dist"
   },
   "app": {
-    "windows": [
-      {
-        "title": "Donut Browser",
-        "width": 900,
-        "height": 600,
-        "resizable": false,
-        "fullscreen": false
-      }
-    ],
+    "windows": [],
     "security": {
       "csp": null
     }
@@ -26,6 +18,7 @@
   "bundle": {
     "active": true,
     "targets": "all",
+    "category": "Productivity",
     "externalBin": ["binaries/nodecar"],
     "icon": [
       "icons/32x32.png",
@@ -45,12 +38,32 @@
       "files": {
         "Info.plist": "Info.plist"
       }
+    },
+    "linux": {
+      "deb": {
+        "depends": ["xdg-utils"],
+        "files": {
+          "/usr/share/applications/donutbrowser.desktop": "donutbrowser.desktop"
+        }
+      },
+      "rpm": {
+        "depends": ["xdg-utils"],
+        "files": {
+          "/usr/share/applications/donutbrowser.desktop": "donutbrowser.desktop"
+        }
+      },
+      "appimage": {
+        "files": {
+          "usr/share/applications/donutbrowser.desktop": "donutbrowser.desktop"
+        }
+      }
     }
   },
   "plugins": {
     "deep-link": {
-      "schemes": ["http", "https"],
-      "domains": []
+      "desktop": {
+        "schemes": ["http", "https"]
+      }
     }
   }
 }

src/app/layout.tsx

@@ -4,6 +4,7 @@ import "@/styles/globals.css";
 import { CustomThemeProvider } from "@/components/theme-provider";
 import { Toaster } from "@/components/ui/sonner";
 import { TooltipProvider } from "@/components/ui/tooltip";
+import { WindowDragArea } from "@/components/window-drag-area";
 
 const geistSans = Geist({
   variable: "--font-geist-sans",
@@ -26,6 +27,7 @@ export default function RootLayout({
         className={`${geistSans.variable} ${geistMono.variable} antialiased`}
       >
         <CustomThemeProvider>
+          <WindowDragArea />
           <TooltipProvider>{children}</TooltipProvider>
           <Toaster />
         </CustomThemeProvider>

src/app/page.tsx

@@ -2,24 +2,38 @@
 
 import { ChangeVersionDialog } from "@/components/change-version-dialog";
 import { CreateProfileDialog } from "@/components/create-profile-dialog";
+import { ImportProfileDialog } from "@/components/import-profile-dialog";
+import { PermissionDialog } from "@/components/permission-dialog";
 import { ProfilesDataTable } from "@/components/profile-data-table";
 import { ProfileSelectorDialog } from "@/components/profile-selector-dialog";
 import { ProxySettingsDialog } from "@/components/proxy-settings-dialog";
 import { SettingsDialog } from "@/components/settings-dialog";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
 import {
   Tooltip,
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
+import { useAppUpdateNotifications } from "@/hooks/use-app-update-notifications";
+import { usePermissions } from "@/hooks/use-permissions";
+import type { PermissionType } from "@/hooks/use-permissions";
 import { useUpdateNotifications } from "@/hooks/use-update-notifications";
+import { useVersionUpdater } from "@/hooks/use-version-updater";
 import { showErrorToast } from "@/lib/toast-utils";
 import type { BrowserProfile, ProxySettings } from "@/types";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
+import { getCurrent } from "@tauri-apps/plugin-deep-link";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { GoGear, GoPlus } from "react-icons/go";
+import { FaDownload } from "react-icons/fa";
+import { GoGear, GoKebabHorizontal, GoPlus } from "react-icons/go";
 
 type BrowserTypeString =
   | "mullvad-browser"
@@ -42,25 +56,41 @@ export default function Home() {
   const [createProfileDialogOpen, setCreateProfileDialogOpen] = useState(false);
   const [changeVersionDialogOpen, setChangeVersionDialogOpen] = useState(false);
   const [settingsDialogOpen, setSettingsDialogOpen] = useState(false);
+  const [importProfileDialogOpen, setImportProfileDialogOpen] = useState(false);
   const [pendingUrls, setPendingUrls] = useState<PendingUrl[]>([]);
   const [currentProfileForProxy, setCurrentProfileForProxy] =
     useState<BrowserProfile | null>(null);
   const [currentProfileForVersionChange, setCurrentProfileForVersionChange] =
     useState<BrowserProfile | null>(null);
-  const [isClient, setIsClient] = useState(false);
+  const [hasCheckedStartupPrompt, setHasCheckedStartupPrompt] = useState(false);
+  const [permissionDialogOpen, setPermissionDialogOpen] = useState(false);
+  const [currentPermissionType, setCurrentPermissionType] =
+    useState<PermissionType>("microphone");
+  const { isMicrophoneAccessGranted, isCameraAccessGranted, isInitialized } =
+    usePermissions();
 
-  // Auto-update functionality - only initialize on client
-  const updateNotifications = useUpdateNotifications();
-  const { checkForUpdates, isUpdating } = updateNotifications;
-
-  // Ensure we're on the client side to prevent hydration mismatches
-  useEffect(() => {
-    setIsClient(true);
+  // Simple profiles loader without updates check (for use as callback)
+  const loadProfiles = useCallback(async () => {
+    try {
+      const profileList = await invoke<BrowserProfile[]>(
+        "list_browser_profiles",
+      );
+      setProfiles(profileList);
+    } catch (err: unknown) {
+      console.error("Failed to load profiles:", err);
+      setError(`Failed to load profiles: ${JSON.stringify(err)}`);
+    }
   }, []);
 
-  const loadProfiles = useCallback(async () => {
-    if (!isClient) return; // Only run on client side
+  // Version updater for handling version fetching progress events and auto-updates
+  useVersionUpdater();
 
+  // Auto-update functionality - use the existing hook for compatibility
+  const updateNotifications = useUpdateNotifications(loadProfiles);
+  const { checkForUpdates, isUpdating } = updateNotifications;
+
+  // Profiles loader with update check (for initial load and manual refresh)
+  const loadProfilesWithUpdateCheck = useCallback(async () => {
     try {
       const profileList = await invoke<BrowserProfile[]>(
         "list_browser_profiles",
@@ -73,12 +103,24 @@ export default function Home() {
       console.error("Failed to load profiles:", err);
       setError(`Failed to load profiles: ${JSON.stringify(err)}`);
     }
-  }, [checkForUpdates, isClient]);
+  }, [checkForUpdates]);
+
+  useAppUpdateNotifications();
+
+  // For some reason, app.deep_link().get_current() is not working properly
+  const checkCurrentUrl = useCallback(async () => {
+    try {
+      const currentUrl = await getCurrent();
+      if (currentUrl && currentUrl.length > 0) {
+        void handleUrlOpen(currentUrl[0]);
+      }
+    } catch (error) {
+      console.error("Failed to check current URL:", error);
+    }
+  }, []);
 
   useEffect(() => {
-    if (!isClient) return; // Only run on client side
-
-    void loadProfiles();
+    void loadProfilesWithUpdateCheck();
 
     // Check for startup default browser prompt
     void checkStartupPrompt();
@@ -88,6 +130,7 @@ export default function Home() {
 
     // Check for startup URLs (when app was launched as default browser)
     void checkStartupUrls();
+    void checkCurrentUrl();
 
     // Set up periodic update checks (every 30 minutes)
     const updateInterval = setInterval(
@@ -100,10 +143,18 @@ export default function Home() {
     return () => {
       clearInterval(updateInterval);
     };
-  }, [loadProfiles, checkForUpdates, isClient]);
+  }, [loadProfilesWithUpdateCheck, checkForUpdates, checkCurrentUrl]);
+
+  // Check permissions when they are initialized
+  useEffect(() => {
+    if (isInitialized) {
+      void checkAllPermissions();
+    }
+  }, [isInitialized]);
 
   const checkStartupPrompt = async () => {
-    if (!isClient) return; // Only run on client side
+    // Only check once during app startup to prevent reopening after dismissing notifications
+    if (hasCheckedStartupPrompt) return;
 
     try {
       const shouldShow = await invoke<boolean>(
@@ -112,14 +163,50 @@ export default function Home() {
       if (shouldShow) {
         setSettingsDialogOpen(true);
       }
+      setHasCheckedStartupPrompt(true);
     } catch (error) {
       console.error("Failed to check startup prompt:", error);
+      setHasCheckedStartupPrompt(true);
+    }
+  };
+
+  const checkAllPermissions = async () => {
+    try {
+      // Wait for permissions to be initialized before checking
+      if (!isInitialized) {
+        return;
+      }
+
+      // Check if any permissions are not granted - prioritize missing permissions
+      if (!isMicrophoneAccessGranted) {
+        setCurrentPermissionType("microphone");
+        setPermissionDialogOpen(true);
+      } else if (!isCameraAccessGranted) {
+        setCurrentPermissionType("camera");
+        setPermissionDialogOpen(true);
+      }
+    } catch (error) {
+      console.error("Failed to check permissions:", error);
+    }
+  };
+
+  const checkNextPermission = () => {
+    try {
+      if (!isMicrophoneAccessGranted) {
+        setCurrentPermissionType("microphone");
+        setPermissionDialogOpen(true);
+      } else if (!isCameraAccessGranted) {
+        setCurrentPermissionType("camera");
+        setPermissionDialogOpen(true);
+      } else {
+        setPermissionDialogOpen(false);
+      }
+    } catch (error) {
+      console.error("Failed to check next permission:", error);
     }
   };
 
   const checkStartupUrls = async () => {
-    if (!isClient) return; // Only run on client side
-
     try {
       const hasStartupUrl = await invoke<boolean>(
         "check_and_handle_startup_url",
@@ -133,8 +220,6 @@ export default function Home() {
   };
 
   const listenForUrlEvents = async () => {
-    if (!isClient) return; // Only run on client side
-
     try {
       // Listen for URL open events from the deep link handler (when app is already running)
       await listen<string>("url-open-request", (event) => {
@@ -145,10 +230,7 @@ export default function Home() {
       // Listen for show profile selector events
       await listen<string>("show-profile-selector", (event) => {
         console.log("Received show profile selector request:", event.payload);
-        setPendingUrls((prev) => [
-          ...prev,
-          { id: Date.now().toString(), url: event.payload },
-        ]);
+        setPendingUrls([{ id: Date.now().toString(), url: event.payload }]);
       });
 
       // Listen for show create profile dialog events
@@ -168,15 +250,13 @@ export default function Home() {
   };
 
   const handleUrlOpen = async (url: string) => {
-    if (!isClient) return; // Only run on client side
-
     try {
       // Use smart profile selection
       const result = await invoke<string>("smart_open_url", {
         url,
       });
       console.log("Smart URL opening succeeded:", result);
-      // URL was handled successfully
+      // URL was handled successfully, no need to show selector
     } catch (error: unknown) {
       console.log(
         "Smart URL opening failed or requires profile selection:",
@@ -184,7 +264,8 @@ export default function Home() {
       );
 
       // Show profile selector for manual selection
-      setPendingUrls((prev) => [...prev, { id: Date.now().toString(), url }]);
+      // Replace any existing pending URL with the new one
+      setPendingUrls([{ id: Date.now().toString(), url }]);
     }
   };
 
@@ -224,6 +305,7 @@ export default function Home() {
       name: string;
       browserStr: BrowserTypeString;
       version: string;
+      releaseType: string;
       proxy?: ProxySettings;
     }) => {
       setError(null);
@@ -235,6 +317,7 @@ export default function Home() {
             name: profileData.name,
             browserStr: profileData.browserStr,
             version: profileData.version,
+            releaseType: profileData.releaseType,
           },
         );
 
@@ -249,7 +332,9 @@ export default function Home() {
         await loadProfiles();
       } catch (error) {
         setError(
-          `Failed to create profile: ${error instanceof Error ? error.message : String(error)}`,
+          `Failed to create profile: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
         );
         throw error;
       }
@@ -263,40 +348,33 @@ export default function Home() {
 
   const runningProfilesRef = useRef<Set<string>>(new Set());
 
-  const checkBrowserStatus = useCallback(
-    async (profile: BrowserProfile) => {
-      if (!isClient) return; // Only run on client side
+  const checkBrowserStatus = useCallback(async (profile: BrowserProfile) => {
+    try {
+      const isRunning = await invoke<boolean>("check_browser_status", {
+        profile,
+      });
 
-      try {
-        const isRunning = await invoke<boolean>("check_browser_status", {
-          profile,
+      const currentRunning = runningProfilesRef.current.has(profile.name);
+
+      if (isRunning !== currentRunning) {
+        setRunningProfiles((prev) => {
+          const next = new Set(prev);
+          if (isRunning) {
+            next.add(profile.name);
+          } else {
+            next.delete(profile.name);
+          }
+          runningProfilesRef.current = next;
+          return next;
         });
-
-        const currentRunning = runningProfilesRef.current.has(profile.name);
-
-        if (isRunning !== currentRunning) {
-          setRunningProfiles((prev) => {
-            const next = new Set(prev);
-            if (isRunning) {
-              next.add(profile.name);
-            } else {
-              next.delete(profile.name);
-            }
-            runningProfilesRef.current = next;
-            return next;
-          });
-        }
-      } catch (err) {
-        console.error("Failed to check browser status:", err);
       }
-    },
-    [isClient],
-  );
+    } catch (err) {
+      console.error("Failed to check browser status:", err);
+    }
+  }, []);
 
   const launchProfile = useCallback(
     async (profile: BrowserProfile) => {
-      if (!isClient) return; // Only run on client side
-
       setError(null);
 
       // Check if browser is disabled due to ongoing update
@@ -330,11 +408,11 @@ export default function Home() {
         setError(`Failed to launch browser: ${JSON.stringify(err)}`);
       }
     },
-    [loadProfiles, checkBrowserStatus, isUpdating, isClient],
+    [loadProfiles, checkBrowserStatus, isUpdating],
   );
 
   useEffect(() => {
-    if (profiles.length === 0 || !isClient) return;
+    if (profiles.length === 0) return;
 
     const interval = setInterval(() => {
       for (const profile of profiles) {
@@ -345,7 +423,7 @@ export default function Home() {
     return () => {
       clearInterval(interval);
     };
-  }, [profiles, checkBrowserStatus, isClient]);
+  }, [profiles, checkBrowserStatus]);
 
   useEffect(() => {
     runningProfilesRef.current = runningProfiles;
@@ -401,76 +479,43 @@ export default function Home() {
     [loadProfiles],
   );
 
-  // Don't render anything until we're on the client side to prevent hydration issues
-  if (!isClient) {
-    return (
-      <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 gap-8 sm:p-12 font-[family-name:var(--font-geist-sans)]">
-        <main className="flex flex-col gap-8 row-start-2 items-center w-full max-w-3xl">
-          <Card className="w-full">
-            <CardHeader>
-              <div className="flex items-center justify-between">
-                <CardTitle>Profiles</CardTitle>
-                <div className="flex items-center gap-2">
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <Button
-                        size="sm"
-                        variant="outline"
-                        disabled
-                        className="flex items-center gap-2"
-                      >
-                        <GoGear className="h-4 w-4" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>Settings</TooltipContent>
-                  </Tooltip>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <Button
-                        size="sm"
-                        disabled
-                        className="flex items-center gap-2"
-                      >
-                        <GoPlus className="h-4 w-4" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>Create a new profile</TooltipContent>
-                  </Tooltip>
-                </div>
-              </div>
-            </CardHeader>
-            <CardContent className="p-8 text-center">
-              <div className="animate-pulse">Loading...</div>
-            </CardContent>
-          </Card>
-        </main>
-      </div>
-    );
-  }
-
   return (
-    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 gap-8 sm:p-12 font-[family-name:var(--font-geist-sans)]">
-      <main className="flex flex-col gap-8 row-start-2 items-center w-full max-w-3xl">
+    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen gap-8 font-[family-name:var(--font-geist-sans)]  bg-white dark:bg-black">
+      <main className="flex flex-col row-start-2 gap-8 items-center w-full max-w-3xl">
         <Card className="w-full">
           <CardHeader>
-            <div className="flex items-center justify-between">
+            <div className="flex justify-between items-center">
               <CardTitle>Profiles</CardTitle>
-              <div className="flex items-center gap-2">
-                <Tooltip>
-                  <TooltipTrigger asChild>
+              <div className="flex gap-2 items-center">
+                <DropdownMenu>
+                  <DropdownMenuTrigger asChild>
                     <Button
                       size="sm"
                       variant="outline"
+                      className="flex gap-2 items-center"
+                    >
+                      <GoKebabHorizontal className="w-4 h-4" />
+                    </Button>
+                  </DropdownMenuTrigger>
+                  <DropdownMenuContent align="end">
+                    <DropdownMenuItem
                       onClick={() => {
                         setSettingsDialogOpen(true);
                       }}
-                      className="flex items-center gap-2"
                     >
-                      <GoGear className="h-4 w-4" />
-                    </Button>
-                  </TooltipTrigger>
-                  <TooltipContent>Settings</TooltipContent>
-                </Tooltip>
+                      <GoGear className="mr-2 w-4 h-4" />
+                      Settings
+                    </DropdownMenuItem>
+                    <DropdownMenuItem
+                      onClick={() => {
+                        setImportProfileDialogOpen(true);
+                      }}
+                    >
+                      <FaDownload className="mr-2 w-4 h-4" />
+                      Import Profile
+                    </DropdownMenuItem>
+                  </DropdownMenuContent>
+                </DropdownMenu>
                 <Tooltip>
                   <TooltipTrigger asChild>
                     <Button
@@ -478,9 +523,9 @@ export default function Home() {
                       onClick={() => {
                         setCreateProfileDialogOpen(true);
                       }}
-                      className="flex items-center gap-2"
+                      className="flex gap-2 items-center"
                     >
-                      <GoPlus className="h-4 w-4" />
+                      <GoPlus className="w-4 h-4" />
                     </Button>
                   </TooltipTrigger>
                   <TooltipContent>Create a new profile</TooltipContent>
@@ -488,7 +533,7 @@ export default function Home() {
               </div>
             </div>
           </CardHeader>
-          <CardContent className="space-y-6">
+          <CardContent>
             <ProfilesDataTable
               data={profiles}
               onLaunchProfile={launchProfile}
@@ -538,6 +583,14 @@ export default function Home() {
         onVersionChanged={() => void loadProfiles()}
       />
 
+      <ImportProfileDialog
+        isOpen={importProfileDialogOpen}
+        onClose={() => {
+          setImportProfileDialogOpen(false);
+        }}
+        onImportComplete={() => void loadProfiles()}
+      />
+
       {pendingUrls.map((pendingUrl) => (
         <ProfileSelectorDialog
           key={pendingUrl.id}
@@ -551,6 +604,15 @@ export default function Home() {
           runningProfiles={runningProfiles}
         />
       ))}
+
+      <PermissionDialog
+        isOpen={permissionDialogOpen}
+        onClose={() => {
+          setPermissionDialogOpen(false);
+        }}
+        permissionType={currentPermissionType}
+        onPermissionGranted={checkNextPermission}
+      />
     </div>
   );
 }

src/components/app-update-toast.tsx

@@ -0,0 +1,123 @@
+"use client";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import React from "react";
+import { FaDownload, FaTimes } from "react-icons/fa";
+import { LuRefreshCw } from "react-icons/lu";
+
+interface AppUpdateInfo {
+  current_version: string;
+  new_version: string;
+  release_notes: string;
+  download_url: string;
+  is_nightly: boolean;
+  published_at: string;
+}
+
+interface AppUpdateToastProps {
+  updateInfo: AppUpdateInfo;
+  onUpdate: (updateInfo: AppUpdateInfo) => Promise<void>;
+  onDismiss: () => void;
+  isUpdating?: boolean;
+  updateProgress?: string;
+}
+
+export function AppUpdateToast({
+  updateInfo,
+  onUpdate,
+  onDismiss,
+  isUpdating = false,
+  updateProgress,
+}: AppUpdateToastProps) {
+  const handleUpdateClick = async () => {
+    await onUpdate(updateInfo);
+  };
+
+  return (
+    <div className="flex items-start w-full bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-4 shadow-lg max-w-md">
+      <div className="mr-3 mt-0.5">
+        {isUpdating ? (
+          <LuRefreshCw className="h-5 w-5 text-blue-500 animate-spin flex-shrink-0" />
+        ) : (
+          <FaDownload className="h-5 w-5 text-blue-500 flex-shrink-0" />
+        )}
+      </div>
+
+      <div className="flex-1 min-w-0">
+        <div className="flex items-start justify-between gap-2">
+          <div className="flex flex-col gap-1">
+            <div className="flex items-center gap-2">
+              <span className="font-semibold text-foreground text-sm">
+                Donut Browser Update Available
+              </span>
+              <Badge
+                variant={updateInfo.is_nightly ? "secondary" : "default"}
+                className="text-xs"
+              >
+                {updateInfo.is_nightly ? "Nightly" : "Stable"}
+              </Badge>
+            </div>
+            <div className="text-xs text-muted-foreground">
+              Update from {updateInfo.current_version} to{" "}
+              <span className="font-medium">{updateInfo.new_version}</span>
+            </div>
+          </div>
+
+          {!isUpdating && (
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={onDismiss}
+              className="h-6 w-6 p-0 shrink-0"
+            >
+              <FaTimes className="h-3 w-3" />
+            </Button>
+          )}
+        </div>
+
+        {isUpdating && updateProgress && (
+          <div className="mt-2">
+            <p className="text-xs text-muted-foreground">{updateProgress}</p>
+          </div>
+        )}
+
+        {!isUpdating && (
+          <div className="flex items-center gap-2 mt-3">
+            <Button
+              onClick={() => void handleUpdateClick()}
+              size="sm"
+              className="flex items-center gap-2 text-xs"
+            >
+              <FaDownload className="h-3 w-3" />
+              Update Now
+            </Button>
+            <Button
+              variant="outline"
+              onClick={onDismiss}
+              size="sm"
+              className="text-xs"
+            >
+              Later
+            </Button>
+          </div>
+        )}
+
+        {updateInfo.release_notes && !isUpdating && (
+          <div className="mt-2">
+            <details className="text-xs">
+              <summary className="cursor-pointer text-muted-foreground hover:text-foreground">
+                Release Notes
+              </summary>
+              <div className="mt-1 text-muted-foreground whitespace-pre-wrap max-h-32 overflow-y-auto">
+                {updateInfo.release_notes.length > 200
+                  ? `${updateInfo.release_notes.substring(0, 200)}...`
+                  : updateInfo.release_notes}
+              </div>
+            </details>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

src/components/change-version-dialog.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { LoadingButton } from "@/components/loading-button";
+import { ReleaseTypeSelector } from "@/components/release-type-selector";
 import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
@@ -12,9 +13,9 @@ import {
   DialogTitle,
 } from "@/components/ui/dialog";
 import { Label } from "@/components/ui/label";
-import { VersionSelector } from "@/components/version-selector";
 import { useBrowserDownload } from "@/hooks/use-browser-download";
-import type { BrowserProfile } from "@/types";
+import { getBrowserDisplayName } from "@/lib/browser-utils";
+import type { BrowserProfile, BrowserReleaseTypes } from "@/types";
 import { invoke } from "@tauri-apps/api/core";
 import { useEffect, useState } from "react";
 import { LuTriangleAlert } from "react-icons/lu";
@@ -32,16 +33,18 @@ export function ChangeVersionDialog({
   profile,
   onVersionChanged,
 }: ChangeVersionDialogProps) {
-  const [selectedVersion, setSelectedVersion] = useState<string | null>(null);
+  const [selectedReleaseType, setSelectedReleaseType] = useState<
+    "stable" | "nightly" | null
+  >(null);
+  const [releaseTypes, setReleaseTypes] = useState<BrowserReleaseTypes>({});
+  const [isLoadingReleaseTypes, setIsLoadingReleaseTypes] = useState(false);
   const [isUpdating, setIsUpdating] = useState(false);
   const [showDowngradeWarning, setShowDowngradeWarning] = useState(false);
   const [acknowledgeDowngrade, setAcknowledgeDowngrade] = useState(false);
 
   const {
-    availableVersions,
     downloadedVersions,
     isDownloading,
-    loadVersions,
     loadDownloadedVersions,
     downloadBrowser,
     isVersionDownloaded,
@@ -49,49 +52,73 @@ export function ChangeVersionDialog({
 
   useEffect(() => {
     if (isOpen && profile) {
-      setSelectedVersion(profile.version);
+      // Set current release type based on profile
+      setSelectedReleaseType(profile.release_type as "stable" | "nightly");
       setAcknowledgeDowngrade(false);
-      void loadVersions(profile.browser);
+      void loadReleaseTypes(profile.browser);
       void loadDownloadedVersions(profile.browser);
     }
-  }, [isOpen, profile, loadVersions, loadDownloadedVersions]);
+  }, [isOpen, profile, loadDownloadedVersions]);
+
+  const loadReleaseTypes = async (browser: string) => {
+    setIsLoadingReleaseTypes(true);
+    try {
+      const releaseTypes = await invoke<BrowserReleaseTypes>(
+        "get_browser_release_types",
+        { browserStr: browser },
+      );
+      setReleaseTypes(releaseTypes);
+    } catch (error) {
+      console.error("Failed to load release types:", error);
+    } finally {
+      setIsLoadingReleaseTypes(false);
+    }
+  };
 
   useEffect(() => {
-    if (profile && selectedVersion) {
-      // Check if this is a downgrade
-      const currentVersionIndex = availableVersions.findIndex(
-        (v) => v.tag_name === profile.version,
-      );
-      const selectedVersionIndex = availableVersions.findIndex(
-        (v) => v.tag_name === selectedVersion,
-      );
-
-      // If selected version has a higher index, it's older (downgrade)
+    if (
+      profile &&
+      selectedReleaseType &&
+      selectedReleaseType !== profile.release_type
+    ) {
+      // For simplicity, we'll show downgrade warning when switching from stable to nightly
+      // since nightly versions might be considered "downgrades" in terms of stability
       const isDowngrade =
-        currentVersionIndex !== -1 &&
-        selectedVersionIndex !== -1 &&
-        selectedVersionIndex > currentVersionIndex;
+        profile.release_type === "stable" && selectedReleaseType === "nightly";
       setShowDowngradeWarning(isDowngrade);
 
       if (!isDowngrade) {
         setAcknowledgeDowngrade(false);
       }
     }
-  }, [selectedVersion, profile, availableVersions]);
+  }, [selectedReleaseType, profile]);
 
   const handleDownload = async () => {
-    if (!profile || !selectedVersion) return;
-    await downloadBrowser(profile.browser, selectedVersion);
+    if (!profile || !selectedReleaseType) return;
+
+    const version =
+      selectedReleaseType === "stable"
+        ? releaseTypes.stable
+        : releaseTypes.nightly;
+    if (!version) return;
+
+    await downloadBrowser(profile.browser, version);
   };
 
   const handleVersionChange = async () => {
-    if (!profile || !selectedVersion) return;
+    if (!profile || !selectedReleaseType) return;
+
+    const version =
+      selectedReleaseType === "stable"
+        ? releaseTypes.stable
+        : releaseTypes.nightly;
+    if (!version) return;
 
     setIsUpdating(true);
     try {
       await invoke("update_profile_version", {
         profileName: profile.name,
-        version: selectedVersion,
+        version,
       });
       onVersionChanged();
       onClose();
@@ -102,10 +129,15 @@ export function ChangeVersionDialog({
     }
   };
 
+  const selectedVersion =
+    selectedReleaseType === "stable"
+      ? releaseTypes.stable
+      : releaseTypes.nightly;
+
   const canUpdate =
     profile &&
-    selectedVersion &&
-    selectedVersion !== profile.version &&
+    selectedReleaseType &&
+    selectedReleaseType !== profile.release_type &&
     selectedVersion &&
     isVersionDownloaded(selectedVersion) &&
     (!showDowngradeWarning || acknowledgeDowngrade);
@@ -116,50 +148,129 @@ export function ChangeVersionDialog({
     <Dialog open={isOpen} onOpenChange={onClose}>
       <DialogContent className="max-w-md">
         <DialogHeader>
-          <DialogTitle>Change Browser Version</DialogTitle>
+          <DialogTitle>Change Release Type</DialogTitle>
         </DialogHeader>
 
         <div className="grid gap-4 py-4">
           <div className="space-y-2">
             <Label className="text-sm font-medium">Profile:</Label>
-            <div className="p-2 bg-muted rounded text-sm">{profile.name}</div>
+            <div className="p-2 text-sm rounded bg-muted">{profile.name}</div>
           </div>
 
           <div className="space-y-2">
-            <Label className="text-sm font-medium">Current Version:</Label>
-            <div className="p-2 bg-muted rounded text-sm">
-              {profile.version}
+            <Label className="text-sm font-medium">Current Release:</Label>
+            <div className="p-2 text-sm capitalize rounded bg-muted">
+              {profile.release_type} ({profile.version})
             </div>
           </div>
 
-          {/* Version Selection */}
-          <div className="grid gap-2">
-            <Label>New Version</Label>
-            <VersionSelector
-              selectedVersion={selectedVersion}
-              onVersionSelect={setSelectedVersion}
-              availableVersions={availableVersions}
-              downloadedVersions={downloadedVersions}
-              isDownloading={isDownloading}
-              onDownload={() => {
-                void handleDownload();
-              }}
-              placeholder="Select version..."
-            />
-          </div>
+          {!releaseTypes.stable && !releaseTypes.nightly ? (
+            <Alert>
+              <AlertDescription>
+                No releases are available for{" "}
+                {getBrowserDisplayName(profile.browser)}.
+              </AlertDescription>
+            </Alert>
+          ) : !releaseTypes.stable || !releaseTypes.nightly ? (
+            <div className="space-y-4">
+              <Alert>
+                <AlertDescription>
+                  Only {profile.release_type} releases are available for{" "}
+                  {getBrowserDisplayName(profile.browser)}.
+                </AlertDescription>
+              </Alert>
+              <div className="grid gap-2">
+                <Label>New Release Type</Label>
+                {isLoadingReleaseTypes ? (
+                  <div className="text-sm text-muted-foreground">
+                    Loading release types...
+                  </div>
+                ) : (
+                  <div className="space-y-4">
+                    {selectedReleaseType &&
+                      selectedReleaseType !== profile.release_type &&
+                      selectedVersion &&
+                      !isVersionDownloaded(selectedVersion) && (
+                        <Alert>
+                          <AlertDescription>
+                            You must download{" "}
+                            {getBrowserDisplayName(profile.browser)}{" "}
+                            {selectedVersion} before switching to this release
+                            type. Use the download button above to get the
+                            latest version.
+                          </AlertDescription>
+                        </Alert>
+                      )}
+
+                    <ReleaseTypeSelector
+                      selectedReleaseType={selectedReleaseType}
+                      onReleaseTypeSelect={setSelectedReleaseType}
+                      availableReleaseTypes={releaseTypes}
+                      browser={profile.browser}
+                      isDownloading={isDownloading}
+                      onDownload={() => {
+                        void handleDownload();
+                      }}
+                      placeholder="Select release type..."
+                      downloadedVersions={downloadedVersions}
+                    />
+                  </div>
+                )}
+              </div>
+            </div>
+          ) : (
+            <div className="grid gap-2">
+              <Label>New Release Type</Label>
+              {isLoadingReleaseTypes ? (
+                <div className="text-sm text-muted-foreground">
+                  Loading release types...
+                </div>
+              ) : (
+                <div className="space-y-4">
+                  {selectedReleaseType &&
+                    selectedReleaseType !== profile.release_type &&
+                    selectedVersion &&
+                    !isVersionDownloaded(selectedVersion) && (
+                      <Alert>
+                        <AlertDescription>
+                          You must download{" "}
+                          {getBrowserDisplayName(profile.browser)}{" "}
+                          {selectedVersion} before switching to this release
+                          type. Use the download button above to get the latest
+                          version.
+                        </AlertDescription>
+                      </Alert>
+                    )}
+
+                  <ReleaseTypeSelector
+                    selectedReleaseType={selectedReleaseType}
+                    onReleaseTypeSelect={setSelectedReleaseType}
+                    availableReleaseTypes={releaseTypes}
+                    browser={profile.browser}
+                    isDownloading={isDownloading}
+                    onDownload={() => {
+                      void handleDownload();
+                    }}
+                    placeholder="Select release type..."
+                    downloadedVersions={downloadedVersions}
+                  />
+                </div>
+              )}
+            </div>
+          )}
 
           {/* Downgrade Warning */}
           {showDowngradeWarning && (
             <Alert className="border-orange-700">
-              <LuTriangleAlert className="h-4 w-4 text-orange-700" />
+              <LuTriangleAlert className="w-4 h-4 text-orange-700" />
               <AlertTitle className="text-orange-700">
-                Downgrade Warning
+                Stability Warning
               </AlertTitle>
               <AlertDescription className="text-orange-700">
-                You are about to downgrade from version {profile.version} to{" "}
-                {selectedVersion}. This may lead to compatibility issues, data
-                loss, or unexpected behavior.
-                <div className="flex items-center space-x-2 mt-3">
+                You are about to switch from stable to nightly releases. Nightly
+                versions may be less stable and could contain bugs or incomplete
+                features.
+                <div className="flex items-center mt-3 space-x-2">
                   <Checkbox
                     id="acknowledge-downgrade"
                     checked={acknowledgeDowngrade}
@@ -187,7 +298,7 @@ export function ChangeVersionDialog({
             }}
             disabled={!canUpdate}
           >
-            {isUpdating ? "Updating..." : "Update Version"}
+            {isUpdating ? "Updating..." : "Update Release Type"}
           </LoadingButton>
         </DialogFooter>
       </DialogContent>

src/components/create-profile-dialog.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { LoadingButton } from "@/components/loading-button";
+import { ReleaseTypeSelector } from "@/components/release-type-selector";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
 import {
@@ -24,12 +25,18 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { VersionSelector } from "@/components/version-selector";
 import { useBrowserDownload } from "@/hooks/use-browser-download";
-import type { BrowserProfile, ProxySettings } from "@/types";
+import { useBrowserSupport } from "@/hooks/use-browser-support";
+import { getBrowserDisplayName } from "@/lib/browser-utils";
+import type {
+  BrowserProfile,
+  BrowserReleaseTypes,
+  ProxySettings,
+} from "@/types";
 import { invoke } from "@tauri-apps/api/core";
 import { useEffect, useState } from "react";
 import { toast } from "sonner";
+import { Alert, AlertDescription } from "./ui/alert";
 
 type BrowserTypeString =
   | "mullvad-browser"
@@ -47,6 +54,7 @@ interface CreateProfileDialogProps {
     name: string;
     browserStr: BrowserTypeString;
     version: string;
+    releaseType: string;
     proxy?: ProxySettings;
   }) => Promise<void>;
 }
@@ -59,79 +67,80 @@ export function CreateProfileDialog({
   const [profileName, setProfileName] = useState("");
   const [selectedBrowser, setSelectedBrowser] =
     useState<BrowserTypeString | null>("mullvad-browser");
-  const [selectedVersion, setSelectedVersion] = useState<string | null>(null);
-  const [supportedBrowsers, setSupportedBrowsers] = useState<
-    BrowserTypeString[]
-  >([]);
+  const [selectedReleaseType, setSelectedReleaseType] = useState<
+    "stable" | "nightly" | null
+  >(null);
+  const [releaseTypes, setReleaseTypes] = useState<BrowserReleaseTypes>({
+    stable: undefined,
+    nightly: undefined,
+  });
   const [isCreating, setIsCreating] = useState(false);
   const [existingProfiles, setExistingProfiles] = useState<BrowserProfile[]>(
     [],
   );
+  const [isLoadingReleaseTypes, setIsLoadingReleaseTypes] = useState(false);
 
   // Proxy settings
   const [proxyEnabled, setProxyEnabled] = useState(false);
   const [proxyType, setProxyType] = useState("http");
   const [proxyHost, setProxyHost] = useState("");
   const [proxyPort, setProxyPort] = useState(8080);
+  const [proxyUsername, setProxyUsername] = useState("");
+  const [proxyPassword, setProxyPassword] = useState("");
 
   const {
-    availableVersions,
-    downloadedVersions,
-    isDownloading,
-    loadVersions,
-    loadDownloadedVersions,
     downloadBrowser,
+    isDownloading,
+    downloadedVersions,
+    loadDownloadedVersions,
     isVersionDownloaded,
   } = useBrowserDownload();
 
+  const {
+    supportedBrowsers,
+    isLoading: isLoadingSupport,
+    isBrowserSupported,
+  } = useBrowserSupport();
+
   useEffect(() => {
     if (isOpen) {
-      void loadSupportedBrowsers();
       void loadExistingProfiles();
     }
   }, [isOpen]);
 
+  useEffect(() => {
+    if (supportedBrowsers.length > 0) {
+      // Set default browser to first supported browser
+      if (supportedBrowsers.includes("mullvad-browser")) {
+        setSelectedBrowser("mullvad-browser");
+      } else if (supportedBrowsers.length > 0) {
+        setSelectedBrowser(supportedBrowsers[0] as BrowserTypeString);
+      }
+    }
+  }, [supportedBrowsers]);
+
   useEffect(() => {
     if (isOpen && selectedBrowser) {
-      // Reset selected version when browser changes
-      setSelectedVersion(null);
-      void loadVersions(selectedBrowser);
+      // Reset selected release type when browser changes
+      setSelectedReleaseType(null);
+      void loadReleaseTypes(selectedBrowser);
       void loadDownloadedVersions(selectedBrowser);
     }
-  }, [isOpen, selectedBrowser, loadVersions, loadDownloadedVersions]);
+  }, [isOpen, selectedBrowser, loadDownloadedVersions]);
 
-  // Set default version when versions are loaded and no version is selected
+  // Set default release type when release types are loaded
   useEffect(() => {
-    if (availableVersions.length > 0 && selectedBrowser) {
-      // Always reset version when browser changes or versions are loaded
-      // Find the latest stable version (not alpha/beta)
-      const stableVersions = availableVersions.filter((v) => !v.is_alpha);
-
-      if (stableVersions.length > 0) {
-        // Select the first stable version (they're already sorted newest first)
-        setSelectedVersion(stableVersions[0].tag_name);
-      } else if (availableVersions.length > 0) {
-        // If no stable version found, select the first available version
-        setSelectedVersion(availableVersions[0].tag_name);
+    if (!selectedReleaseType && Object.keys(releaseTypes).length > 0) {
+      // First try to set stable if it exists
+      if (releaseTypes.stable) {
+        setSelectedReleaseType("stable");
+      }
+      // If stable doesn't exist but nightly does, set nightly as default
+      else if (releaseTypes.nightly && selectedBrowser !== "chromium") {
+        setSelectedReleaseType("nightly");
       }
     }
-  }, [availableVersions, selectedBrowser]);
-
-  const loadSupportedBrowsers = async () => {
-    try {
-      const browsers = await invoke<BrowserTypeString[]>(
-        "get_supported_browsers",
-      );
-      setSupportedBrowsers(browsers);
-      if (browsers.includes("mullvad-browser")) {
-        setSelectedBrowser("mullvad-browser");
-      } else if (browsers.length > 0) {
-        setSelectedBrowser(browsers[0]);
-      }
-    } catch (error) {
-      console.error("Failed to load supported browsers:", error);
-    }
-  };
+  }, [releaseTypes, selectedReleaseType, selectedBrowser]);
 
   const loadExistingProfiles = async () => {
     try {
@@ -142,9 +151,34 @@ export function CreateProfileDialog({
     }
   };
 
+  const loadReleaseTypes = async (browser: string) => {
+    try {
+      setIsLoadingReleaseTypes(true);
+      const types = await invoke<BrowserReleaseTypes>(
+        "get_browser_release_types",
+        {
+          browserStr: browser,
+        },
+      );
+      setReleaseTypes(types);
+    } catch (error) {
+      console.error("Failed to load release types:", error);
+      toast.error("Failed to load available versions");
+    } finally {
+      setIsLoadingReleaseTypes(false);
+    }
+  };
+
   const handleDownload = async () => {
-    if (!selectedBrowser || !selectedVersion) return;
-    await downloadBrowser(selectedBrowser, selectedVersion);
+    if (!selectedBrowser || !selectedReleaseType) return;
+
+    const version =
+      selectedReleaseType === "stable"
+        ? releaseTypes.stable
+        : releaseTypes.nightly;
+    if (!version) return;
+
+    await downloadBrowser(selectedBrowser, version);
   };
 
   const validateProfileName = (name: string): string | null => {
@@ -177,7 +211,7 @@ export function CreateProfileDialog({
   }, [selectedBrowser, proxyEnabled]);
 
   const handleCreate = async () => {
-    if (!profileName.trim() || !selectedBrowser || !selectedVersion) return;
+    if (!profileName.trim() || !selectedBrowser || !selectedReleaseType) return;
 
     // Validate profile name
     const nameError = validateProfileName(profileName);
@@ -186,6 +220,15 @@ export function CreateProfileDialog({
       return;
     }
 
+    const version =
+      selectedReleaseType === "stable"
+        ? releaseTypes.stable
+        : releaseTypes.nightly;
+    if (!version) {
+      toast.error("Selected release type is not available");
+      return;
+    }
+
     setIsCreating(true);
     try {
       const proxy =
@@ -195,22 +238,27 @@ export function CreateProfileDialog({
               proxy_type: proxyType,
               host: proxyHost,
               port: proxyPort,
+              username: proxyUsername || undefined,
+              password: proxyPassword || undefined,
             }
           : undefined;
 
       await onCreateProfile({
         name: profileName.trim(),
         browserStr: selectedBrowser,
-        version: selectedVersion,
+        version,
+        releaseType: selectedReleaseType,
         proxy,
       });
 
       // Reset form
       setProfileName("");
-      setSelectedVersion(null);
+      setSelectedReleaseType(null);
       setProxyEnabled(false);
       setProxyHost("");
       setProxyPort(8080);
+      setProxyUsername("");
+      setProxyPassword("");
       onClose();
     } catch (error) {
       console.error("Failed to create profile:", error);
@@ -222,9 +270,16 @@ export function CreateProfileDialog({
   const nameError = profileName.trim()
     ? validateProfileName(profileName)
     : null;
+
+  const selectedVersion =
+    selectedReleaseType === "stable"
+      ? releaseTypes.stable
+      : releaseTypes.nightly;
+
   const canCreate =
     profileName.trim() &&
     selectedBrowser &&
+    selectedReleaseType &&
     selectedVersion &&
     isVersionDownloaded(selectedVersion) &&
     (!proxyEnabled || isProxyDisabled || (proxyHost && proxyPort)) &&
@@ -232,12 +287,12 @@ export function CreateProfileDialog({
 
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
-      <DialogContent className="max-w-md">
-        <DialogHeader>
+      <DialogContent className="max-w-md max-h-[80vh] my-8 flex flex-col">
+        <DialogHeader className="flex-shrink-0">
           <DialogTitle>Create New Profile</DialogTitle>
         </DialogHeader>
 
-        <div className="grid gap-4 py-4">
+        <div className="grid overflow-y-scroll flex-1 gap-6 py-4 min-h-0">
           {/* Profile Name */}
           <div className="grid gap-2">
             <Label htmlFor="profile-name">Profile Name</Label>
@@ -261,40 +316,104 @@ export function CreateProfileDialog({
               onValueChange={(value) => {
                 setSelectedBrowser(value as BrowserTypeString);
               }}
+              disabled={isLoadingSupport}
             >
               <SelectTrigger>
-                <SelectValue placeholder="Select browser" />
+                <SelectValue
+                  placeholder={
+                    isLoadingSupport ? "Loading browsers..." : "Select browser"
+                  }
+                />
               </SelectTrigger>
               <SelectContent>
-                {supportedBrowsers.map((browser) => (
-                  <SelectItem key={browser} value={browser}>
-                    {browser
-                      .split("-")
-                      .map(
-                        (word) => word.charAt(0).toUpperCase() + word.slice(1),
-                      )
-                      .join(" ")}
-                  </SelectItem>
-                ))}
+                {(
+                  [
+                    "mullvad-browser",
+                    "firefox",
+                    "firefox-developer",
+                    "chromium",
+                    "brave",
+                    "zen",
+                    "tor-browser",
+                  ] as BrowserTypeString[]
+                ).map((browser) => {
+                  const isSupported = isBrowserSupported(browser);
+                  const displayName = getBrowserDisplayName(browser);
+
+                  if (!isSupported) {
+                    return (
+                      <Tooltip key={browser}>
+                        <TooltipTrigger asChild>
+                          <SelectItem
+                            value={browser}
+                            disabled={true}
+                            className="opacity-50"
+                          >
+                            {displayName} (Not supported)
+                          </SelectItem>
+                        </TooltipTrigger>
+                        <TooltipContent>
+                          <p>
+                            {displayName} is not supported on your current
+                            platform or architecture.
+                          </p>
+                        </TooltipContent>
+                      </Tooltip>
+                    );
+                  }
+
+                  return (
+                    <SelectItem key={browser} value={browser}>
+                      {displayName}
+                    </SelectItem>
+                  );
+                })}
               </SelectContent>
             </Select>
           </div>
 
-          {/* Version Selection */}
-          <div className="grid gap-2">
-            <Label>Version</Label>
-            <VersionSelector
-              selectedVersion={selectedVersion}
-              onVersionSelect={setSelectedVersion}
-              availableVersions={availableVersions}
-              downloadedVersions={downloadedVersions}
-              isDownloading={isDownloading}
-              onDownload={() => {
-                void handleDownload();
-              }}
-              placeholder="Select version..."
-            />
-          </div>
+          {selectedBrowser ? (
+            <div className="grid gap-2">
+              <Label>Release Type</Label>
+              {isLoadingReleaseTypes ? (
+                <div className="text-sm text-muted-foreground">
+                  Loading release types...
+                </div>
+              ) : Object.keys(releaseTypes).length === 0 ? (
+                <Alert>
+                  <AlertDescription>
+                    No releases are available for{" "}
+                    {getBrowserDisplayName(selectedBrowser)}.
+                  </AlertDescription>
+                </Alert>
+              ) : (
+                <div className="space-y-4">
+                  {(!releaseTypes.stable || !releaseTypes.nightly) && (
+                    <Alert>
+                      <AlertDescription>
+                        Only {(releaseTypes.stable && "Stable") ?? "Nightly"}{" "}
+                        releases are available for{" "}
+                        {getBrowserDisplayName(selectedBrowser)}.
+                      </AlertDescription>
+                    </Alert>
+                  )}
+
+                  <ReleaseTypeSelector
+                    selectedReleaseType={selectedReleaseType}
+                    onReleaseTypeSelect={setSelectedReleaseType}
+                    availableReleaseTypes={releaseTypes}
+                    browser={selectedBrowser}
+                    isDownloading={isDownloading}
+                    onDownload={() => {
+                      void handleDownload();
+                    }}
+                    placeholder="Select release type..."
+                    downloadedVersions={downloadedVersions}
+                  />
+                </div>
+              )}
+            </div>
+          ) : null}
 
           {/* Proxy Settings */}
           <div className="grid gap-4 pt-4 border-t">
@@ -378,6 +497,31 @@ export function CreateProfileDialog({
                     max="65535"
                   />
                 </div>
+
+                <div className="grid gap-2">
+                  <Label htmlFor="proxy-username">Username (optional)</Label>
+                  <Input
+                    id="proxy-username"
+                    value={proxyUsername}
+                    onChange={(e) => {
+                      setProxyUsername(e.target.value);
+                    }}
+                    placeholder="Proxy username"
+                  />
+                </div>
+
+                <div className="grid gap-2">
+                  <Label htmlFor="proxy-password">Password (optional)</Label>
+                  <Input
+                    id="proxy-password"
+                    type="password"
+                    value={proxyPassword}
+                    onChange={(e) => {
+                      setProxyPassword(e.target.value);
+                    }}
+                    placeholder="Proxy password"
+                  />
+                </div>
               </>
             )}
           </div>

src/components/custom-toast.tsx

@@ -10,6 +10,7 @@
  * - Progress bars for downloads/updates
  * - Success/error states
  * - Customizable icons and content
+ * - Auto-update notifications
  *
  * Usage Examples:
  *
@@ -23,6 +24,11 @@
  * });
  * ```
  *
+ * Auto-update toast:
+ * ```
+ * showAutoUpdateToast("Firefox", "125.0.1");
+ * ```
+ *
  * Download progress toast:
  * ```
  * showToast({
@@ -47,6 +53,7 @@ import {
   LuCheckCheck,
   LuDownload,
   LuRefreshCw,
+  LuRocket,
   LuTriangleAlert,
 } from "react-icons/lu";
 
@@ -71,7 +78,12 @@ interface ErrorToastProps extends BaseToastProps {
 
 interface DownloadToastProps extends BaseToastProps {
   type: "download";
-  stage?: "downloading" | "extracting" | "verifying" | "completed";
+  stage?:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)";
   progress?: {
     percentage: number;
     speed?: string;
@@ -85,6 +97,7 @@ interface VersionUpdateToastProps extends BaseToastProps {
     current: number;
     total: number;
     found: number;
+    current_browser?: string;
   };
 }
 
@@ -93,38 +106,53 @@ interface FetchingToastProps extends BaseToastProps {
   browserName?: string;
 }
 
+interface TwilightUpdateToastProps extends BaseToastProps {
+  type: "twilight-update";
+  browserName?: string;
+  hasUpdate?: boolean;
+}
+
 type ToastProps =
   | LoadingToastProps
   | SuccessToastProps
   | ErrorToastProps
   | DownloadToastProps
   | VersionUpdateToastProps
-  | FetchingToastProps;
+  | FetchingToastProps
+  | TwilightUpdateToastProps;
 
 function getToastIcon(type: ToastProps["type"], stage?: string) {
   switch (type) {
     case "success":
-      return <LuCheckCheck className="h-4 w-4 text-green-500 flex-shrink-0" />;
+      return <LuCheckCheck className="flex-shrink-0 w-4 h-4 text-green-500" />;
     case "error":
-      return <LuTriangleAlert className="h-4 w-4 text-red-500 flex-shrink-0" />;
+      return <LuTriangleAlert className="flex-shrink-0 w-4 h-4 text-red-500" />;
     case "download":
       if (stage === "completed") {
         return (
-          <LuCheckCheck className="h-4 w-4 text-green-500 flex-shrink-0" />
+          <LuCheckCheck className="flex-shrink-0 w-4 h-4 text-green-500" />
         );
       }
-      return <LuDownload className="h-4 w-4 text-blue-500 flex-shrink-0" />;
+      return <LuDownload className="flex-shrink-0 w-4 h-4 text-blue-500" />;
     case "version-update":
       return (
-        <LuRefreshCw className="h-4 w-4 text-blue-500 animate-spin flex-shrink-0" />
+        <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-blue-500 animate-spin" />
       );
     case "fetching":
       return (
-        <LuRefreshCw className="h-4 w-4 text-blue-500 animate-spin flex-shrink-0" />
+        <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-blue-500 animate-spin" />
+      );
+    case "twilight-update":
+      return (
+        <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-purple-500 animate-spin" />
+      );
+    case "loading":
+      return (
+        <div className="flex-shrink-0 w-4 h-4 rounded-full border-2 border-blue-500 animate-spin border-t-transparent" />
       );
     default:
       return (
-        <div className="animate-spin rounded-full h-4 w-4 border-2 border-blue-500 border-t-transparent flex-shrink-0" />
+        <div className="flex-shrink-0 w-4 h-4 rounded-full border-2 border-blue-500 animate-spin border-t-transparent" />
       );
   }
 }
@@ -134,11 +162,33 @@ export function UnifiedToast(props: ToastProps) {
   const stage = "stage" in props ? props.stage : undefined;
   const progress = "progress" in props ? props.progress : undefined;
 
+  // Check if this is an auto-update toast
+  const isAutoUpdate = title.includes("update started");
+
   return (
-    <div className="flex items-start w-full bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-3 shadow-lg">
-      <div className="mr-3 mt-0.5">{getToastIcon(type, stage)}</div>
+    <div
+      className={`flex items-start p-3 w-96 rounded-lg border shadow-lg ${
+        isAutoUpdate
+          ? "bg-emerald-50 border-emerald-200 dark:bg-emerald-950 dark:border-emerald-800"
+          : "bg-white border-gray-200 dark:bg-gray-800 dark:border-gray-700"
+      }`}
+      data-toast-type={isAutoUpdate ? "auto-update" : "default"}
+    >
+      <div className="mr-3 mt-0.5">
+        {isAutoUpdate ? (
+          <LuRocket className="flex-shrink-0 w-4 h-4 text-emerald-500" />
+        ) : (
+          getToastIcon(type, stage)
+        )}
+      </div>
       <div className="flex-1 min-w-0">
-        <p className="text-sm font-medium text-gray-900 dark:text-white leading-tight">
+        <p
+          className={`text-sm font-medium leading-tight ${
+            isAutoUpdate
+              ? "text-emerald-900 dark:text-emerald-100"
+              : "text-gray-900 dark:text-white"
+          }`}
+        >
           {title}
         </p>
 
@@ -149,7 +199,7 @@ export function UnifiedToast(props: ToastProps) {
           stage === "downloading" && (
             <div className="mt-2 space-y-1">
               <div className="flex justify-between items-center">
-                <p className="text-xs text-gray-600 dark:text-gray-300 min-w-0 flex-1">
+                <p className="flex-1 min-w-0 text-xs text-gray-600 dark:text-gray-300">
                   {progress.percentage.toFixed(1)}%
                   {progress.speed && ` • ${progress.speed} MB/s`}
                   {progress.eta && ` • ${progress.eta} remaining`}
@@ -165,30 +215,56 @@ export function UnifiedToast(props: ToastProps) {
           )}
 
         {/* Version update progress */}
-        {type === "version-update" && progress && "found" in progress && (
-          <div className="mt-2 space-y-1">
-            <p className="text-xs text-gray-600 dark:text-gray-300">
-              {progress.found} new versions found so far
-            </p>
-            <div className="flex items-center space-x-2">
-              <div className="flex-1 bg-gray-200 dark:bg-gray-700 rounded-full h-1.5 min-w-0">
-                <div
-                  className="bg-blue-500 h-1.5 rounded-full transition-all duration-300"
-                  style={{
-                    width: `${(progress.current / progress.total) * 100}%`,
-                  }}
-                />
+        {type === "version-update" &&
+          progress &&
+          "current_browser" in progress && (
+            <div className="mt-2 space-y-1">
+              <p className="text-xs text-gray-600 dark:text-gray-300">
+                {progress.current_browser && (
+                  <>Looking for updates for {progress.current_browser}</>
+                )}
+              </p>
+              <div className="flex items-center space-x-2">
+                <div className="flex-1 bg-gray-200 dark:bg-gray-700 rounded-full h-1.5 min-w-0">
+                  <div
+                    className="bg-blue-500 h-1.5 rounded-full transition-all duration-300"
+                    style={{
+                      width: `${(progress.current / progress.total) * 100}%`,
+                    }}
+                  />
+                </div>
+                <span className="w-8 text-xs text-right text-gray-500 whitespace-nowrap dark:text-gray-400 shrink-0">
+                  {progress.current}/{progress.total}
+                </span>
               </div>
-              <span className="text-xs text-gray-500 dark:text-gray-400 whitespace-nowrap shrink-0 w-8 text-right">
-                {progress.current}/{progress.total}
-              </span>
             </div>
+          )}
+
+        {/* Twilight update progress */}
+        {type === "twilight-update" && (
+          <div className="mt-2">
+            <p className="text-xs text-gray-600 dark:text-gray-300">
+              {"hasUpdate" in props && props.hasUpdate
+                ? "New twilight build available for download"
+                : "Checking for twilight updates..."}
+            </p>
+            {props.browserName && (
+              <p className="mt-1 text-xs text-purple-600 dark:text-purple-400">
+                {props.browserName} • Rolling Release
+              </p>
+            )}
           </div>
         )}
 
         {/* Description */}
         {description && (
-          <p className="mt-1 text-xs text-gray-600 dark:text-gray-300 leading-tight">
+          <p
+            className={`mt-1 text-xs leading-tight ${
+              isAutoUpdate
+                ? "text-emerald-700 dark:text-emerald-300"
+                : "text-gray-600 dark:text-gray-300"
+            }`}
+          >
             {description}
           </p>
         )}
@@ -203,7 +279,12 @@ export function UnifiedToast(props: ToastProps) {
             )}
             {stage === "verifying" && (
               <p className="mt-1 text-xs text-gray-600 dark:text-gray-300">
-                Verifying installation...
+                Verifying browser files...
+              </p>
+            )}
+            {stage === "downloading (twilight rolling release)" && (
+              <p className="mt-1 text-xs text-purple-600 dark:text-purple-400">
+                Downloading rolling release build...
               </p>
             )}
           </>

src/components/icons/zen-browser.tsx

@@ -0,0 +1,24 @@
+export const ZenBrowser = (props: React.SVGProps<SVGSVGElement>) => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    width={24}
+    height={24}
+    role="graphics-symbol img"
+    fill="currentColor"
+    viewBox="0 0 24 24"
+    {...props}
+  >
+    <path
+      d="M12 8.15c-2.12 0-3.85 1.72-3.85 3.85s1.72 3.85 3.85 3.85 3.85-1.72 3.85-3.85S14.13 8.15 12 8.15m0 6.92c-1.7 0-3.08-1.38-3.08-3.08S10.3 8.91 12 8.91s3.08 1.38 3.08 3.08-1.38 3.08-3.08 3.08"
+      className="b"
+    />
+    <path
+      d="M12 5.33c-3.68 0-6.67 2.98-6.67 6.67s2.98 6.67 6.67 6.67 6.67-2.98 6.67-6.67S15.69 5.33 12 5.33m0 12.05c-2.97 0-5.38-2.41-5.38-5.38S9.03 6.62 12 6.62s5.38 2.41 5.38 5.38-2.41 5.38-5.38 5.38"
+      className="b"
+    />
+    <path
+      d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2m0 18.2c-4.53 0-8.21-3.67-8.21-8.2S7.47 3.79 12 3.79s8.21 3.67 8.21 8.21-3.67 8.2-8.21 8.2"
+      className="b"
+    />
+  </svg>
+);

src/components/import-profile-dialog.tsx

@@ -0,0 +1,482 @@
+"use client";
+
+import { LoadingButton } from "@/components/loading-button";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useBrowserSupport } from "@/hooks/use-browser-support";
+import { getBrowserDisplayName, getBrowserIcon } from "@/lib/browser-utils";
+import type { DetectedProfile } from "@/types";
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
+import { useEffect, useState } from "react";
+import { FaFolder } from "react-icons/fa";
+import { toast } from "sonner";
+
+interface ImportProfileDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onImportComplete?: () => void;
+}
+
+export function ImportProfileDialog({
+  isOpen,
+  onClose,
+  onImportComplete,
+}: ImportProfileDialogProps) {
+  const [detectedProfiles, setDetectedProfiles] = useState<DetectedProfile[]>(
+    [],
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const [isImporting, setIsImporting] = useState(false);
+  const [importMode, setImportMode] = useState<"auto-detect" | "manual">(
+    "auto-detect",
+  );
+
+  // Auto-detect state
+  const [selectedDetectedProfile, setSelectedDetectedProfile] = useState<
+    string | null
+  >(null);
+  const [autoDetectProfileName, setAutoDetectProfileName] = useState("");
+
+  // Manual import state
+  const [manualBrowserType, setManualBrowserType] = useState<string | null>(
+    null,
+  );
+  const [manualProfilePath, setManualProfilePath] = useState("");
+  const [manualProfileName, setManualProfileName] = useState("");
+
+  const { supportedBrowsers, isLoading: isLoadingSupport } =
+    useBrowserSupport();
+
+  useEffect(() => {
+    if (isOpen) {
+      void loadDetectedProfiles();
+    }
+  }, [isOpen]);
+
+  const loadDetectedProfiles = async () => {
+    setIsLoading(true);
+    try {
+      const profiles = await invoke<DetectedProfile[]>(
+        "detect_existing_profiles",
+      );
+      setDetectedProfiles(profiles);
+
+      // Auto-switch to manual mode if no profiles detected
+      if (profiles.length === 0) {
+        setImportMode("manual");
+      } else {
+        // Auto-select first profile if available
+        setSelectedDetectedProfile(profiles[0].path);
+
+        // Generate default name from the detected profile
+        const profile = profiles[0];
+        const browserName = getBrowserDisplayName(profile.browser);
+        const defaultName = `Imported ${browserName} Profile`;
+        setAutoDetectProfileName(defaultName);
+      }
+    } catch (error) {
+      console.error("Failed to detect existing profiles:", error);
+      toast.error("Failed to detect existing browser profiles");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleBrowseFolder = async () => {
+    try {
+      const selected = await open({
+        directory: true,
+        multiple: false,
+        title: "Select Browser Profile Folder",
+      });
+
+      if (selected && typeof selected === "string") {
+        setManualProfilePath(selected);
+      }
+    } catch (error) {
+      console.error("Failed to open folder dialog:", error);
+      toast.error("Failed to open folder dialog");
+    }
+  };
+
+  const handleAutoDetectImport = async () => {
+    if (!selectedDetectedProfile || !autoDetectProfileName.trim()) {
+      toast.error("Please select a profile and provide a name");
+      return;
+    }
+
+    const profile = detectedProfiles.find(
+      (p) => p.path === selectedDetectedProfile,
+    );
+    if (!profile) {
+      toast.error("Selected profile not found");
+      return;
+    }
+
+    setIsImporting(true);
+    try {
+      await invoke("import_browser_profile", {
+        sourcePath: profile.path,
+        browserType: profile.browser,
+        newProfileName: autoDetectProfileName.trim(),
+      });
+
+      toast.success(
+        `Successfully imported profile "${autoDetectProfileName.trim()}"`,
+      );
+      if (onImportComplete) {
+        onImportComplete();
+      }
+      onClose();
+    } catch (error) {
+      console.error("Failed to import profile:", error);
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      toast.error(`Failed to import profile: ${errorMessage}`);
+    } finally {
+      setIsImporting(false);
+    }
+  };
+
+  const handleManualImport = async () => {
+    if (
+      !manualBrowserType ||
+      !manualProfilePath.trim() ||
+      !manualProfileName.trim()
+    ) {
+      toast.error("Please fill in all fields");
+      return;
+    }
+
+    setIsImporting(true);
+    try {
+      await invoke("import_browser_profile", {
+        sourcePath: manualProfilePath.trim(),
+        browserType: manualBrowserType,
+        newProfileName: manualProfileName.trim(),
+      });
+
+      toast.success(
+        `Successfully imported profile "${manualProfileName.trim()}"`,
+      );
+      if (onImportComplete) {
+        onImportComplete();
+      }
+      onClose();
+    } catch (error) {
+      console.error("Failed to import profile:", error);
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      toast.error(`Failed to import profile: ${errorMessage}`);
+    } finally {
+      setIsImporting(false);
+    }
+  };
+
+  const handleClose = () => {
+    setSelectedDetectedProfile(null);
+    setAutoDetectProfileName("");
+    setManualBrowserType(null);
+    setManualProfilePath("");
+    setManualProfileName("");
+    // Only reset to auto-detect if there are profiles available
+    if (detectedProfiles.length > 0) {
+      setImportMode("auto-detect");
+    } else {
+      setImportMode("manual");
+    }
+    onClose();
+  };
+
+  // Update auto-detect profile name when selection changes
+  useEffect(() => {
+    if (selectedDetectedProfile) {
+      const profile = detectedProfiles.find(
+        (p) => p.path === selectedDetectedProfile,
+      );
+      if (profile) {
+        const browserName = getBrowserDisplayName(profile.browser);
+        const defaultName = `Imported ${browserName} Profile`;
+        setAutoDetectProfileName(defaultName);
+      }
+    }
+  }, [selectedDetectedProfile, detectedProfiles]);
+
+  const selectedProfile = detectedProfiles.find(
+    (p) => p.path === selectedDetectedProfile,
+  );
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className="max-w-2xl max-h-[80vh] my-8 flex flex-col">
+        <DialogHeader className="flex-shrink-0">
+          <DialogTitle>Import Browser Profile</DialogTitle>
+        </DialogHeader>
+
+        <div className="overflow-y-auto flex-1 space-y-6 min-h-0">
+          {/* Mode Selection */}
+          <div className="flex gap-2">
+            <Button
+              variant={importMode === "auto-detect" ? "default" : "outline"}
+              onClick={() => {
+                setImportMode("auto-detect");
+              }}
+              className="flex-1"
+              disabled={isLoading}
+            >
+              Auto-Detect
+            </Button>
+            <Button
+              variant={importMode === "manual" ? "default" : "outline"}
+              onClick={() => {
+                setImportMode("manual");
+              }}
+              className="flex-1"
+              disabled={isLoading}
+            >
+              Manual Import
+            </Button>
+          </div>
+
+          {/* Auto-Detect Mode */}
+          {importMode === "auto-detect" && (
+            <div className="space-y-4">
+              <h3 className="text-lg font-medium">Detected Browser Profiles</h3>
+
+              {isLoading ? (
+                <div className="py-8 text-center">
+                  <p className="text-muted-foreground">
+                    Scanning for browser profiles...
+                  </p>
+                </div>
+              ) : detectedProfiles.length === 0 ? (
+                <div className="py-8 text-center">
+                  <p className="text-muted-foreground">
+                    No browser profiles found on your system.
+                  </p>
+                  <p className="mt-2 text-sm text-muted-foreground">
+                    Try the manual import option if you have profiles in custom
+                    locations.
+                  </p>
+                </div>
+              ) : (
+                <div className="space-y-4">
+                  <div>
+                    <Label htmlFor="detected-profile-select" className="mb-2">
+                      Select Profile:
+                    </Label>
+                    <Select
+                      value={selectedDetectedProfile ?? undefined}
+                      onValueChange={(value) => {
+                        setSelectedDetectedProfile(value);
+                      }}
+                    >
+                      <SelectTrigger id="detected-profile-select">
+                        <SelectValue placeholder="Choose a detected profile" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {detectedProfiles.map((profile) => {
+                          const IconComponent = getBrowserIcon(profile.browser);
+                          return (
+                            <SelectItem key={profile.path} value={profile.path}>
+                              <div className="flex gap-2 items-center">
+                                {IconComponent && (
+                                  <IconComponent className="w-4 h-4" />
+                                )}
+                                <div className="flex flex-col">
+                                  <span className="font-medium">
+                                    {profile.name}
+                                  </span>
+                                  <span className="text-xs text-muted-foreground">
+                                    {profile.description}
+                                  </span>
+                                </div>
+                              </div>
+                            </SelectItem>
+                          );
+                        })}
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  {selectedProfile && (
+                    <div className="p-3 rounded-lg bg-muted">
+                      <p className="text-sm">
+                        <span className="font-medium">Path:</span>{" "}
+                        {selectedProfile.path}
+                      </p>
+                      <p className="text-sm">
+                        <span className="font-medium">Browser:</span>{" "}
+                        {getBrowserDisplayName(selectedProfile.browser)}
+                      </p>
+                    </div>
+                  )}
+
+                  <div>
+                    <Label htmlFor="auto-profile-name" className="mb-2">
+                      New Profile Name:
+                    </Label>
+                    <Input
+                      id="auto-profile-name"
+                      value={autoDetectProfileName}
+                      onChange={(e) => {
+                        setAutoDetectProfileName(e.target.value);
+                      }}
+                      placeholder="Enter a name for the imported profile"
+                    />
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+
+          {/* Manual Import Mode */}
+          {importMode === "manual" && (
+            <div className="space-y-4">
+              <h3 className="text-lg font-medium">Manual Profile Import</h3>
+
+              <div className="space-y-4">
+                <div>
+                  <Label htmlFor="manual-browser-select" className="mb-2">
+                    Browser Type:
+                  </Label>
+                  <Select
+                    value={manualBrowserType ?? undefined}
+                    onValueChange={(value) => {
+                      setManualBrowserType(value);
+                    }}
+                    disabled={isLoadingSupport}
+                  >
+                    <SelectTrigger id="manual-browser-select">
+                      <SelectValue
+                        placeholder={
+                          isLoadingSupport
+                            ? "Loading browsers..."
+                            : "Select browser type"
+                        }
+                      />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {supportedBrowsers.map((browser) => {
+                        const IconComponent = getBrowserIcon(browser);
+                        return (
+                          <SelectItem key={browser} value={browser}>
+                            <div className="flex gap-2 items-center">
+                              {IconComponent && (
+                                <IconComponent className="w-4 h-4" />
+                              )}
+                              <span>{getBrowserDisplayName(browser)}</span>
+                            </div>
+                          </SelectItem>
+                        );
+                      })}
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div>
+                  <Label htmlFor="manual-profile-path" className="mb-2">
+                    Profile Folder Path:
+                  </Label>
+                  <div className="flex gap-2">
+                    <Input
+                      id="manual-profile-path"
+                      value={manualProfilePath}
+                      onChange={(e) => {
+                        setManualProfilePath(e.target.value);
+                      }}
+                      placeholder="Enter the full path to the profile folder"
+                    />
+                    <Button
+                      variant="outline"
+                      size="icon"
+                      onClick={() => void handleBrowseFolder()}
+                      title="Browse for folder"
+                    >
+                      <FaFolder className="w-4 h-4" />
+                    </Button>
+                  </div>
+                  <p className="mt-2 text-xs text-muted-foreground">
+                    Example paths:
+                    <br />
+                    macOS: ~/Library/Application
+                    Support/Firefox/Profiles/xxx.default
+                    <br />
+                    Windows: %APPDATA%\Mozilla\Firefox\Profiles\xxx.default
+                    <br />
+                    Linux: ~/.mozilla/firefox/xxx.default
+                  </p>
+                </div>
+
+                <div>
+                  <Label htmlFor="manual-profile-name" className="mb-2">
+                    New Profile Name:
+                  </Label>
+                  <Input
+                    id="manual-profile-name"
+                    value={manualProfileName}
+                    onChange={(e) => {
+                      setManualProfileName(e.target.value);
+                    }}
+                    placeholder="Enter a name for the imported profile"
+                  />
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+
+        <DialogFooter className="flex-shrink-0">
+          <Button variant="outline" onClick={handleClose}>
+            Cancel
+          </Button>
+          {importMode === "auto-detect" ? (
+            <LoadingButton
+              isLoading={isImporting}
+              onClick={() => {
+                void handleAutoDetectImport();
+              }}
+              disabled={
+                !selectedDetectedProfile ||
+                !autoDetectProfileName.trim() ||
+                isLoading
+              }
+            >
+              Import Profile
+            </LoadingButton>
+          ) : (
+            <LoadingButton
+              isLoading={isImporting}
+              onClick={() => {
+                void handleManualImport();
+              }}
+              disabled={
+                !manualBrowserType ||
+                !manualProfilePath.trim() ||
+                !manualProfileName.trim()
+              }
+            >
+              Import Profile
+            </LoadingButton>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

src/components/permission-dialog.tsx

@@ -0,0 +1,170 @@
+"use client";
+
+import { LoadingButton } from "@/components/loading-button";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { usePermissions } from "@/hooks/use-permissions";
+import type { PermissionType } from "@/hooks/use-permissions";
+import { showErrorToast, showSuccessToast } from "@/lib/toast-utils";
+import { useEffect, useState } from "react";
+import { BsCamera, BsMic } from "react-icons/bs";
+
+interface PermissionDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  permissionType: PermissionType;
+  onPermissionGranted?: () => void;
+}
+
+export function PermissionDialog({
+  isOpen,
+  onClose,
+  permissionType,
+  onPermissionGranted,
+}: PermissionDialogProps) {
+  const [isRequesting, setIsRequesting] = useState(false);
+  const [isMacOS, setIsMacOS] = useState(false);
+  const {
+    requestPermission,
+    isMicrophoneAccessGranted,
+    isCameraAccessGranted,
+  } = usePermissions();
+
+  // Check if we're on macOS and close dialog if not
+  useEffect(() => {
+    const userAgent = navigator.userAgent;
+    const isMac = userAgent.includes("Mac");
+    setIsMacOS(isMac);
+
+    // If not macOS, close the dialog as permissions aren't needed
+    if (!isMac) {
+      onClose();
+    }
+  }, [onClose]);
+
+  // Get current permission status
+  const isCurrentPermissionGranted =
+    permissionType === "microphone"
+      ? isMicrophoneAccessGranted
+      : isCameraAccessGranted;
+
+  // Auto-close dialog when permission is granted
+  useEffect(() => {
+    if (isCurrentPermissionGranted && isOpen) {
+      onPermissionGranted?.();
+    }
+  }, [isCurrentPermissionGranted, isOpen, onPermissionGranted]);
+
+  const getPermissionIcon = (type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return <BsMic className="w-8 h-8" />;
+      case "camera":
+        return <BsCamera className="w-8 h-8" />;
+    }
+  };
+
+  const getPermissionTitle = (type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return "Microphone Access Required";
+      case "camera":
+        return "Camera Access Required";
+    }
+  };
+
+  const getPermissionDescription = (type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return "Donut Browser needs access to your microphone to enable microphone functionality in web browsers. Each website that wants to use your microphone will still ask for your permission individually.";
+      case "camera":
+        return "Donut Browser needs access to your camera to enable camera functionality in web browsers. Each website that wants to use your camera will still ask for your permission individually.";
+    }
+  };
+
+  const handleRequestPermission = async () => {
+    setIsRequesting(true);
+    try {
+      await requestPermission(permissionType);
+      showSuccessToast(
+        `${getPermissionTitle(permissionType).replace(
+          " Required",
+          "",
+        )} permission requested`,
+      );
+    } catch (error) {
+      console.error("Failed to request permission:", error);
+      showErrorToast("Failed to request permission");
+    } finally {
+      setIsRequesting(false);
+    }
+  };
+
+  // Don't render if not macOS
+  if (!isMacOS) {
+    return null;
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className="max-w-md">
+        <DialogHeader className="text-center">
+          <div className="flex justify-center items-center mx-auto mb-4 w-16 h-16 bg-blue-100 rounded-full dark:bg-blue-900">
+            {getPermissionIcon(permissionType)}
+          </div>
+          <DialogTitle className="text-xl">
+            {getPermissionTitle(permissionType)}
+          </DialogTitle>
+          <DialogDescription className="text-base">
+            {getPermissionDescription(permissionType)}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          {isCurrentPermissionGranted && (
+            <div className="p-3 bg-green-50 rounded-lg dark:bg-green-900/20">
+              <p className="text-sm text-green-800 dark:text-green-200">
+                ✅ Permission granted! Browsers launched from Donut Browser can
+                now access your {permissionType}.
+              </p>
+            </div>
+          )}
+
+          {!isCurrentPermissionGranted && (
+            <div className="p-3 bg-amber-50 rounded-lg dark:bg-amber-900/20">
+              <p className="text-sm text-amber-800 dark:text-amber-200">
+                ⚠️ Permission not granted. Click the button below to request
+                access to your {permissionType}.
+              </p>
+            </div>
+          )}
+        </div>
+
+        <DialogFooter className="gap-2">
+          <Button variant="outline" onClick={onClose}>
+            {isCurrentPermissionGranted ? "Done" : "Cancel"}
+          </Button>
+
+          {!isCurrentPermissionGranted && (
+            <LoadingButton
+              isLoading={isRequesting}
+              onClick={() => {
+                handleRequestPermission().catch(console.error);
+              }}
+              className="min-w-24"
+            >
+              Grant Access
+            </LoadingButton>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

src/components/profile-data-table.tsx

@@ -1,6 +1,5 @@
 "use client";
 
-import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import {
   Dialog,
@@ -78,6 +77,11 @@ export function ProfilesDataTable({
     React.useState<BrowserProfile | null>(null);
   const [newProfileName, setNewProfileName] = React.useState("");
   const [renameError, setRenameError] = React.useState<string | null>(null);
+  const [profileToDelete, setProfileToDelete] =
+    React.useState<BrowserProfile | null>(null);
+  const [deleteConfirmationName, setDeleteConfirmationName] =
+    React.useState("");
+  const [deleteError, setDeleteError] = React.useState<string | null>(null);
   const [isClient, setIsClient] = React.useState(false);
 
   // Ensure we're on the client side to prevent hydration mismatches
@@ -117,6 +121,26 @@ export function ProfilesDataTable({
     }
   };
 
+  const handleDelete = async () => {
+    if (!profileToDelete || !deleteConfirmationName.trim()) return;
+
+    if (deleteConfirmationName.trim() !== profileToDelete.name) {
+      setDeleteError(
+        "Profile name doesn't match. Please type the exact name to confirm deletion.",
+      );
+      return;
+    }
+
+    try {
+      await onDeleteProfile(profileToDelete);
+      setProfileToDelete(null);
+      setDeleteConfirmationName("");
+      setDeleteError(null);
+    } catch (err) {
+      setDeleteError(err as string);
+    }
+  };
+
   const columns: ColumnDef<BrowserProfile>[] = React.useMemo(
     () => [
       {
@@ -139,7 +163,7 @@ export function ProfilesDataTable({
           const isDisabled = shouldDisableTorStart || isBrowserUpdating;
 
           return (
-            <div className="flex items-center gap-2">
+            <div className="flex gap-2 items-center">
               <Tooltip>
                 <TooltipTrigger asChild>
                   <Button
@@ -181,21 +205,34 @@ export function ProfilesDataTable({
               onClick={() => {
                 column.toggleSorting(column.getIsSorted() === "asc");
               }}
-              className="h-auto p-0 font-semibold hover:bg-transparent"
+              className="p-0 h-auto font-semibold hover:bg-transparent"
             >
               Profile
-              {isSorted === "asc" && <LuChevronUp className="ml-2 h-4 w-4" />}
+              {isSorted === "asc" && <LuChevronUp className="ml-2 w-4 h-4" />}
               {isSorted === "desc" && (
-                <LuChevronDown className="ml-2 h-4 w-4" />
+                <LuChevronDown className="ml-2 w-4 h-4" />
               )}
               {!isSorted && (
-                <LuChevronDown className="ml-2 h-4 w-4 opacity-50" />
+                <LuChevronDown className="ml-2 w-4 h-4 opacity-50" />
               )}
             </Button>
           );
         },
         enableSorting: true,
         sortingFn: "alphanumeric",
+        cell: ({ row }) => {
+          const profile = row.original;
+          return profile.name.length > 15 ? (
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <span className="truncate">{profile.name.slice(0, 15)}...</span>
+              </TooltipTrigger>
+              <TooltipContent>{profile.name}</TooltipContent>
+            </Tooltip>
+          ) : (
+            profile.name
+          );
+        },
       },
       {
         accessorKey: "browser",
@@ -207,15 +244,15 @@ export function ProfilesDataTable({
               onClick={() => {
                 column.toggleSorting(column.getIsSorted() === "asc");
               }}
-              className="h-auto p-0 font-semibold hover:bg-transparent"
+              className="p-0 h-auto font-semibold hover:bg-transparent"
             >
               Browser
-              {isSorted === "asc" && <LuChevronUp className="ml-2 h-4 w-4" />}
+              {isSorted === "asc" && <LuChevronUp className="ml-2 w-4 h-4" />}
               {isSorted === "desc" && (
-                <LuChevronDown className="ml-2 h-4 w-4" />
+                <LuChevronDown className="ml-2 w-4 h-4" />
               )}
               {!isSorted && (
-                <LuChevronDown className="ml-2 h-4 w-4 opacity-50" />
+                <LuChevronDown className="ml-2 w-4 h-4 opacity-50" />
               )}
             </Button>
           );
@@ -223,10 +260,21 @@ export function ProfilesDataTable({
         cell: ({ row }) => {
           const browser: string = row.getValue("browser");
           const IconComponent = getBrowserIcon(browser);
-          return (
-            <div className="flex items-center gap-2">
-              {IconComponent && <IconComponent className="h-4 w-4" />}
-              <span>{getBrowserDisplayName(browser)}</span>
+          const browserDisplayName = getBrowserDisplayName(browser);
+          return browserDisplayName.length > 15 ? (
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <div className="flex gap-2 items-center">
+                  {IconComponent && <IconComponent className="w-4 h-4" />}
+                  <span>{browserDisplayName.slice(0, 15)}...</span>
+                </div>
+              </TooltipTrigger>
+              <TooltipContent>{browserDisplayName}</TooltipContent>
+            </Tooltip>
+          ) : (
+            <div className="flex gap-2 items-center">
+              {IconComponent && <IconComponent className="w-4 h-4" />}
+              <span>{browserDisplayName}</span>
             </div>
           );
         },
@@ -238,67 +286,33 @@ export function ProfilesDataTable({
         },
       },
       {
-        accessorKey: "version",
-        header: "Version",
-      },
-      {
-        id: "status",
-        header: ({ column }) => {
-          const isSorted = column.getIsSorted();
-          return (
-            <Button
-              variant="ghost"
-              onClick={() => {
-                column.toggleSorting(column.getIsSorted() === "asc");
-              }}
-              className="h-auto p-0 font-semibold hover:bg-transparent"
-            >
-              Status
-              {isSorted === "asc" && <LuChevronUp className="ml-2 h-4 w-4" />}
-              {isSorted === "desc" && (
-                <LuChevronDown className="ml-2 h-4 w-4" />
-              )}
-              {!isSorted && (
-                <LuChevronDown className="ml-2 h-4 w-4 opacity-50" />
-              )}
-            </Button>
-          );
-        },
+        accessorKey: "release_type",
+        header: "Release",
         cell: ({ row }) => {
-          const profile = row.original;
-          const isRunning = isClient && runningProfiles.has(profile.name);
+          const releaseType: string = row.getValue("release_type");
+          const isNightly = releaseType === "nightly";
           return (
-            <div className="flex flex-col gap-1">
-              <Badge
-                variant={isRunning ? "default" : "secondary"}
-                className="text-xs w-fit"
+            <div className="flex items-center">
+              <span
+                className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${
+                  isNightly
+                    ? "text-yellow-800 bg-yellow-100 dark:bg-yellow-900 dark:text-yellow-200"
+                    : "text-green-800 bg-green-100 dark:bg-green-900 dark:text-green-200"
+                }`}
               >
-                {isClient ? (isRunning ? "Running" : "Stopped") : "Loading..."}
-              </Badge>
-              {isClient && isRunning && profile.process_id && (
-                <span className="text-xs text-muted-foreground">
-                  PID: {profile.process_id}
-                </span>
-              )}
+                {isNightly ? "Nightly" : "Stable"}
+              </span>
             </div>
           );
         },
         enableSorting: true,
-        sortingFn: (rowA, rowB) => {
-          // If not on client, sort by name only to ensure consistency
-          if (!isClient) {
-            return rowA.original.name.localeCompare(rowB.original.name);
-          }
-
-          const isRunningA = runningProfiles.has(rowA.original.name);
-          const isRunningB = runningProfiles.has(rowB.original.name);
-
-          // Running profiles come first, then stopped ones
-          // Secondary sort by profile name
-          if (isRunningA === isRunningB) {
-            return rowA.original.name.localeCompare(rowB.original.name);
-          }
-          return isRunningA ? -1 : 1;
+        sortingFn: (rowA, rowB, columnId) => {
+          const releaseA: string = rowA.getValue(columnId);
+          const releaseB: string = rowB.getValue(columnId);
+          // Sort with "stable" before "nightly"
+          if (releaseA === "stable" && releaseB === "nightly") return -1;
+          if (releaseA === "nightly" && releaseB === "stable") return 1;
+          return 0;
         },
       },
       {
@@ -307,24 +321,30 @@ export function ProfilesDataTable({
         cell: ({ row }) => {
           const profile = row.original;
           const hasProxy = profile.proxy?.enabled;
+          const regularText = hasProxy ? profile.proxy?.proxy_type : "Disabled";
+          const regularTooltipText = hasProxy
+            ? `${profile.proxy?.proxy_type.toUpperCase()} proxy enabled (${
+                profile.proxy?.host
+              }:${profile.proxy?.port})`
+            : "No proxy configured";
           return (
             <Tooltip>
               <TooltipTrigger>
-                <div className="flex items-center gap-2">
+                <div className="flex gap-2 items-center">
                   {hasProxy && (
-                    <CiCircleCheck className="h-4 w-4 text-green-500" />
+                    <CiCircleCheck className="w-4 h-4 text-green-500" />
                   )}
                   <span className="text-sm text-muted-foreground">
-                    {hasProxy ? profile.proxy?.proxy_type : "Disabled"}
+                    {profile.browser === "tor-browser"
+                      ? "Not supported"
+                      : regularText}
                   </span>
                 </div>
               </TooltipTrigger>
               <TooltipContent>
-                {hasProxy
-                  ? `${profile.proxy?.proxy_type.toUpperCase()} proxy enabled (${
-                      profile.proxy?.host
-                    }:${profile.proxy?.port})`
-                  : "No proxy configured"}
+                {profile.browser === "tor-browser"
+                  ? "Proxies are not supported for TOR browser"
+                  : regularTooltipText}
               </TooltipContent>
             </Tooltip>
           );
@@ -338,16 +358,16 @@ export function ProfilesDataTable({
           const isRunning = isClient && runningProfiles.has(profile.name);
           const isBrowserUpdating = isClient && isUpdating(profile.browser);
           return (
-            <div className="flex items-center justify-end">
+            <div className="flex justify-end items-center">
               <DropdownMenu>
                 <DropdownMenuTrigger asChild>
                   <Button
                     variant="ghost"
-                    className="h-8 w-8 p-0"
+                    className="p-0 w-8 h-8"
                     disabled={!isClient}
                   >
                     <span className="sr-only">Open menu</span>
-                    <IoEllipsisHorizontal className="h-4 w-4" />
+                    <IoEllipsisHorizontal className="w-4 h-4" />
                   </Button>
                 </DropdownMenuTrigger>
                 <DropdownMenuContent align="end">
@@ -359,16 +379,18 @@ export function ProfilesDataTable({
                     }}
                     disabled={!isClient || isBrowserUpdating}
                   >
-                    Configure proxy
-                  </DropdownMenuItem>
-                  <DropdownMenuItem
-                    onClick={() => {
-                      onChangeVersion(profile);
-                    }}
-                    disabled={!isClient || isRunning || isBrowserUpdating}
-                  >
-                    Change version
+                    Configure Proxy
                   </DropdownMenuItem>
+                  {!["chromium", "zen"].includes(profile.browser) && (
+                    <DropdownMenuItem
+                      onClick={() => {
+                        onChangeVersion(profile);
+                      }}
+                      disabled={!isClient || isRunning || isBrowserUpdating}
+                    >
+                      Switch Release
+                    </DropdownMenuItem>
+                  )}
                   <DropdownMenuItem
                     onClick={() => {
                       setProfileToRename(profile);
@@ -376,14 +398,17 @@ export function ProfilesDataTable({
                     }}
                     disabled={!isClient || isRunning || isBrowserUpdating}
                   >
-                    Rename profile
+                    Rename
                   </DropdownMenuItem>
                   <DropdownMenuItem
-                    onClick={() => void onDeleteProfile(profile)}
+                    onClick={() => {
+                      setProfileToDelete(profile);
+                      setDeleteConfirmationName("");
+                    }}
                     className="text-red-600"
                     disabled={!isClient || isRunning || isBrowserUpdating}
                   >
-                    Delete profile
+                    Delete
                   </DropdownMenuItem>
                 </DropdownMenuContent>
               </DropdownMenu>
@@ -400,7 +425,6 @@ export function ProfilesDataTable({
       onLaunchProfile,
       onKillProfile,
       onProxySettings,
-      onDeleteProfile,
       onChangeVersion,
     ],
   );
@@ -484,7 +508,7 @@ export function ProfilesDataTable({
             <DialogTitle>Rename Profile</DialogTitle>
           </DialogHeader>
           <div className="grid gap-4 py-4">
-            <div className="grid grid-cols-4 items-center gap-4">
+            <div className="grid grid-cols-4 gap-4 items-center">
               <Label htmlFor="name" className="text-right">
                 Name
               </Label>
@@ -514,6 +538,74 @@ export function ProfilesDataTable({
           </DialogFooter>
         </DialogContent>
       </Dialog>
+
+      <Dialog
+        open={profileToDelete !== null}
+        onOpenChange={(open) => {
+          if (!open) {
+            setProfileToDelete(null);
+            setDeleteConfirmationName("");
+            setDeleteError(null);
+          }
+        }}
+      >
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>Delete Profile</DialogTitle>
+            <DialogDescription>
+              This action cannot be undone. This will permanently delete the
+              profile &quot;{profileToDelete?.name}&quot; and all its associated
+              data.
+            </DialogDescription>
+          </DialogHeader>
+          <div className="grid gap-4 py-4">
+            <div className="grid gap-2">
+              <Label htmlFor="delete-confirmation">
+                Please type <strong>{profileToDelete?.name}</strong> to confirm:
+              </Label>
+              <Input
+                id="delete-confirmation"
+                value={deleteConfirmationName}
+                onChange={(e) => {
+                  setDeleteConfirmationName(e.target.value);
+                  setDeleteError(null);
+                }}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") {
+                    void handleDelete();
+                  }
+                }}
+                placeholder="Type the profile name here"
+              />
+            </div>
+            {deleteError && (
+              <p className="text-sm text-red-600">{deleteError}</p>
+            )}
+          </div>
+          <DialogFooter>
+            <Button
+              variant="outline"
+              onClick={() => {
+                setProfileToDelete(null);
+                setDeleteConfirmationName("");
+                setDeleteError(null);
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="destructive"
+              onClick={() => void handleDelete()}
+              disabled={
+                !deleteConfirmationName.trim() ||
+                deleteConfirmationName !== profileToDelete?.name
+              }
+            >
+              Delete Profile
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
     </>
   );
 }

src/components/profile-selector-dialog.tsx

@@ -69,16 +69,29 @@ export function ProfileSelectorDialog({
 
       // Auto-select first available profile for link opening
       if (profileList.length > 0) {
-        // Find the first profile that can be used for opening links
-        const availableProfile = profileList.find((profile) => {
-          return canUseProfileForLinks(profile, profileList, runningProfiles);
+        // First, try to find a running profile that can be used for opening links
+        const runningAvailableProfile = profileList.find((profile) => {
+          const isRunning = runningProfiles.has(profile.name);
+          return (
+            isRunning &&
+            canUseProfileForLinks(profile, profileList, runningProfiles)
+          );
         });
 
-        if (availableProfile) {
-          setSelectedProfile(availableProfile.name);
+        if (runningAvailableProfile) {
+          setSelectedProfile(runningAvailableProfile.name);
         } else {
-          // If no suitable profile found, still select the first one to show UI
-          setSelectedProfile(profileList[0].name);
+          // If no running profile is suitable, find the first profile that can be used for opening links
+          const availableProfile = profileList.find((profile) => {
+            return canUseProfileForLinks(profile, profileList, runningProfiles);
+          });
+
+          if (availableProfile) {
+            setSelectedProfile(availableProfile.name);
+          } else {
+            // If no suitable profile found, still select the first one to show UI
+            setSelectedProfile(profileList[0].name);
+          }
         }
       }
     } catch (error) {
@@ -125,10 +138,6 @@ export function ProfileSelectorDialog({
     const isRunning = runningProfiles.has(profile.name);
 
     if (profile.browser === "tor-browser") {
-      const runningTorProfiles = profiles.filter(
-        (p) => p.browser === "tor-browser" && runningProfiles.has(p.name),
-      );
-
       // If another TOR profile is running, this one is not available
       return "Only 1 instance can run at a time";
     }
@@ -182,9 +191,6 @@ export function ProfileSelectorDialog({
   };
 
   const selectedProfileData = profiles.find((p) => p.name === selectedProfile);
-  const isSelectedProfileRunning = selectedProfile
-    ? runningProfiles.has(selectedProfile)
-    : false;
 
   // Check if the selected profile can be used for opening links
   const canOpenWithSelectedProfile = () => {
@@ -212,19 +218,19 @@ export function ProfileSelectorDialog({
         <div className="grid gap-4 py-4">
           {url && (
             <div className="space-y-2">
-              <div className="flex items-center justify-between">
+              <div className="flex justify-between items-center">
                 <Label className="text-sm font-medium">Opening URL:</Label>
                 <Button
                   variant="outline"
                   size="sm"
                   onClick={() => void handleCopyUrl()}
-                  className="flex items-center gap-2"
+                  className="flex gap-2 items-center"
                 >
-                  <LuCopy className="h-3 w-3" />
+                  <LuCopy className="w-3 h-3" />
                   Copy
                 </Button>
               </div>
-              <div className="p-2 bg-muted rounded text-sm break-all">
+              <div className="p-2 text-sm break-all rounded bg-muted">
                 {url}
               </div>
             </div>
@@ -277,14 +283,14 @@ export function ProfileSelectorDialog({
                                   !canUseForLinks ? "opacity-50" : ""
                                 }`}
                               >
-                                <div className="flex items-center gap-3 p-3 rounded-lg hover:bg-accent cursor-pointer">
-                                  <div className="flex items-center gap-2">
+                                <div className="flex gap-3 items-center px-2 py-1 rounded-lg cursor-pointer hover:bg-accent">
+                                  <div className="flex gap-2 items-center">
                                     {(() => {
                                       const IconComponent = getBrowserIcon(
                                         profile.browser,
                                       );
                                       return IconComponent ? (
-                                        <IconComponent className="h-4 w-4" />
+                                        <IconComponent className="w-4 h-4" />
                                       ) : null;
                                     })()}
                                   </div>

src/components/proxy-settings-dialog.tsx

@@ -30,6 +30,8 @@ interface ProxySettings {
   proxy_type: string;
   host: string;
   port: number;
+  username?: string;
+  password?: string;
 }
 
 interface ProxySettingsDialogProps {
@@ -52,6 +54,8 @@ export function ProxySettingsDialog({
     proxy_type: initialSettings?.proxy_type ?? "http",
     host: initialSettings?.host ?? "",
     port: initialSettings?.port ?? 8080,
+    username: initialSettings?.username ?? "",
+    password: initialSettings?.password ?? "",
   });
 
   const [initialSettingsState, setInitialSettingsState] =
@@ -60,6 +64,8 @@ export function ProxySettingsDialog({
       proxy_type: "http",
       host: "",
       port: 8080,
+      username: "",
+      password: "",
     });
 
   useEffect(() => {
@@ -69,6 +75,8 @@ export function ProxySettingsDialog({
         proxy_type: initialSettings.proxy_type,
         host: initialSettings.host,
         port: initialSettings.port,
+        username: initialSettings.username ?? "",
+        password: initialSettings.password ?? "",
       };
       setSettings(newSettings);
       setInitialSettingsState(newSettings);
@@ -78,6 +86,8 @@ export function ProxySettingsDialog({
         proxy_type: "http",
         host: "",
         port: 80,
+        username: "",
+        password: "",
       };
       setSettings(defaultSettings);
       setInitialSettingsState(defaultSettings);
@@ -94,7 +104,9 @@ export function ProxySettingsDialog({
       settings.enabled !== initialSettingsState.enabled ||
       settings.proxy_type !== initialSettingsState.proxy_type ||
       settings.host !== initialSettingsState.host ||
-      settings.port !== initialSettingsState.port
+      settings.port !== initialSettingsState.port ||
+      settings.username !== initialSettingsState.username ||
+      settings.password !== initialSettingsState.password
     );
   };
 
@@ -214,6 +226,31 @@ export function ProxySettingsDialog({
                   max="65535"
                 />
               </div>
+
+              <div className="grid gap-2">
+                <Label htmlFor="username">Username (optional)</Label>
+                <Input
+                  id="username"
+                  value={settings.username}
+                  onChange={(e) => {
+                    setSettings({ ...settings, username: e.target.value });
+                  }}
+                  placeholder="Proxy username"
+                />
+              </div>
+
+              <div className="grid gap-2">
+                <Label htmlFor="password">Password (optional)</Label>
+                <Input
+                  id="password"
+                  type="password"
+                  value={settings.password}
+                  onChange={(e) => {
+                    setSettings({ ...settings, password: e.target.value });
+                  }}
+                  placeholder="Proxy password"
+                />
+              </div>
             </>
           )}
         </div>

src/components/release-type-selector.tsx

@@ -0,0 +1,164 @@
+"use client";
+
+import { LoadingButton } from "@/components/loading-button";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandItem,
+  CommandList,
+} from "@/components/ui/command";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover";
+import { cn } from "@/lib/utils";
+import type { BrowserReleaseTypes } from "@/types";
+import { useState } from "react";
+import { LuDownload } from "react-icons/lu";
+import { LuCheck, LuChevronsUpDown } from "react-icons/lu";
+
+interface ReleaseTypeSelectorProps {
+  selectedReleaseType: "stable" | "nightly" | null;
+  onReleaseTypeSelect: (releaseType: "stable" | "nightly" | null) => void;
+  availableReleaseTypes: BrowserReleaseTypes;
+  browser: string;
+  isDownloading: boolean;
+  onDownload: () => void;
+  placeholder?: string;
+  showDownloadButton?: boolean;
+  downloadedVersions?: string[];
+}
+
+export function ReleaseTypeSelector({
+  selectedReleaseType,
+  onReleaseTypeSelect,
+  availableReleaseTypes,
+  browser,
+  isDownloading,
+  onDownload,
+  placeholder = "Select release type...",
+  showDownloadButton = true,
+  downloadedVersions = [],
+}: ReleaseTypeSelectorProps) {
+  const [popoverOpen, setPopoverOpen] = useState(false);
+
+  const releaseOptions = [
+    ...(availableReleaseTypes.stable
+      ? [{ type: "stable" as const, version: availableReleaseTypes.stable }]
+      : []),
+    ...(availableReleaseTypes.nightly && browser !== "chromium"
+      ? [{ type: "nightly" as const, version: availableReleaseTypes.nightly }]
+      : []),
+  ];
+
+  const selectedDisplayText = selectedReleaseType
+    ? selectedReleaseType === "stable"
+      ? "Stable"
+      : "Nightly"
+    : placeholder;
+
+  const selectedVersion =
+    selectedReleaseType === "stable"
+      ? availableReleaseTypes.stable
+      : selectedReleaseType === "nightly"
+        ? availableReleaseTypes.nightly
+        : null;
+
+  const isVersionDownloaded =
+    selectedVersion && downloadedVersions.includes(selectedVersion);
+
+  return (
+    <div className="space-y-4">
+      <Popover open={popoverOpen} onOpenChange={setPopoverOpen} modal={true}>
+        <PopoverTrigger asChild>
+          <Button
+            variant="outline"
+            role="combobox"
+            aria-expanded={popoverOpen}
+            className="justify-between w-full"
+          >
+            {selectedDisplayText}
+            <LuChevronsUpDown className="ml-2 w-4 h-4 opacity-50 shrink-0" />
+          </Button>
+        </PopoverTrigger>
+        <PopoverContent className="w-[300px] p-0">
+          <Command>
+            <CommandEmpty>No release types available.</CommandEmpty>
+            <CommandList>
+              <CommandGroup>
+                {releaseOptions.map((option) => {
+                  const isDownloaded = downloadedVersions.includes(
+                    option.version,
+                  );
+                  return (
+                    <CommandItem
+                      key={option.type}
+                      value={option.type}
+                      onSelect={(currentValue) => {
+                        const selectedType = currentValue as
+                          | "stable"
+                          | "nightly";
+                        onReleaseTypeSelect(
+                          selectedType === selectedReleaseType
+                            ? null
+                            : selectedType,
+                        );
+                        setPopoverOpen(false);
+                      }}
+                    >
+                      <LuCheck
+                        className={cn(
+                          "mr-2 h-4 w-4",
+                          selectedReleaseType === option.type
+                            ? "opacity-100"
+                            : "opacity-0",
+                        )}
+                      />
+                      <div className="flex gap-2 items-center">
+                        <span className="capitalize">{option.type}</span>
+                        {option.type === "nightly" && (
+                          <Badge variant="secondary" className="text-xs">
+                            Nightly
+                          </Badge>
+                        )}
+                        <Badge variant="outline" className="text-xs">
+                          {option.version}
+                        </Badge>
+                        {isDownloaded && (
+                          <Badge variant="default" className="text-xs">
+                            Downloaded
+                          </Badge>
+                        )}
+                      </div>
+                    </CommandItem>
+                  );
+                })}
+              </CommandGroup>
+            </CommandList>
+          </Command>
+        </PopoverContent>
+      </Popover>
+
+      {showDownloadButton &&
+        selectedReleaseType &&
+        selectedVersion &&
+        !isVersionDownloaded && (
+          <LoadingButton
+            isLoading={isDownloading}
+            onClick={() => {
+              onDownload();
+            }}
+            variant="outline"
+            className="w-full"
+          >
+            <LuDownload className="mr-2 w-4 h-4" />
+            {isDownloading ? "Downloading..." : "Download Browser"}
+          </LoadingButton>
+        )}
+    </div>
+  );
+}

src/components/settings-dialog.tsx

@@ -19,15 +19,25 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { usePermissions } from "@/hooks/use-permissions";
+import type { PermissionType } from "@/hooks/use-permissions";
+import { showErrorToast, showSuccessToast } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
 import { useTheme } from "next-themes";
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
+import { BsCamera, BsMic } from "react-icons/bs";
 
 interface AppSettings {
   set_as_default_browser: boolean;
   show_settings_on_startup: boolean;
   theme: string;
-  auto_updates_enabled: boolean;
+  auto_delete_unused_binaries: boolean;
+}
+
+interface PermissionInfo {
+  permission_type: PermissionType;
+  isGranted: boolean;
+  description: string;
 }
 
 interface SettingsDialogProps {
@@ -40,30 +50,59 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_updates_enabled: true,
+    auto_delete_unused_binaries: true,
   });
   const [originalSettings, setOriginalSettings] = useState<AppSettings>({
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_updates_enabled: true,
+    auto_delete_unused_binaries: true,
   });
   const [isDefaultBrowser, setIsDefaultBrowser] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
   const [isSaving, setIsSaving] = useState(false);
   const [isSettingDefault, setIsSettingDefault] = useState(false);
+  const [isClearingCache, setIsClearingCache] = useState(false);
+  const [permissions, setPermissions] = useState<PermissionInfo[]>([]);
+  const [isLoadingPermissions, setIsLoadingPermissions] = useState(false);
+  const [requestingPermission, setRequestingPermission] =
+    useState<PermissionType | null>(null);
+  const [isMacOS, setIsMacOS] = useState(false);
 
   const { setTheme } = useTheme();
+  const {
+    requestPermission,
+    isMicrophoneAccessGranted,
+    isCameraAccessGranted,
+  } = usePermissions();
+
+  const getPermissionDescription = useCallback((type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return "Access to microphone for browser applications";
+      case "camera":
+        return "Access to camera for browser applications";
+    }
+  }, []);
 
   useEffect(() => {
     if (isOpen) {
-      void loadSettings();
-      void checkDefaultBrowserStatus();
+      loadSettings().catch(console.error);
+      checkDefaultBrowserStatus().catch(console.error);
+
+      // Check if we're on macOS
+      const userAgent = navigator.userAgent;
+      const isMac = userAgent.includes("Mac");
+      setIsMacOS(isMac);
+
+      if (isMac) {
+        loadPermissions().catch(console.error);
+      }
 
       // Set up interval to check default browser status
       const intervalId = setInterval(() => {
-        void checkDefaultBrowserStatus();
-      }, 500); // Check every 2 seconds
+        checkDefaultBrowserStatus().catch(console.error);
+      }, 500); // Check every 500ms
 
       // Cleanup interval on component unmount or dialog close
       return () => {
@@ -72,6 +111,32 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     }
   }, [isOpen]);
 
+  // Update permissions when the permission states change
+  useEffect(() => {
+    if (isMacOS) {
+      const permissionList: PermissionInfo[] = [
+        {
+          permission_type: "microphone",
+          isGranted: isMicrophoneAccessGranted,
+          description: getPermissionDescription("microphone"),
+        },
+        {
+          permission_type: "camera",
+          isGranted: isCameraAccessGranted,
+          description: getPermissionDescription("camera"),
+        },
+      ];
+      setPermissions(permissionList);
+    } else {
+      setPermissions([]);
+    }
+  }, [
+    isMacOS,
+    isMicrophoneAccessGranted,
+    isCameraAccessGranted,
+    getPermissionDescription,
+  ]);
+
   const loadSettings = async () => {
     setIsLoading(true);
     try {
@@ -85,6 +150,36 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     }
   };
 
+  const loadPermissions = async () => {
+    setIsLoadingPermissions(true);
+    try {
+      if (!isMacOS) {
+        // On non-macOS platforms, don't show permissions
+        setPermissions([]);
+        return;
+      }
+
+      const permissionList: PermissionInfo[] = [
+        {
+          permission_type: "microphone",
+          isGranted: isMicrophoneAccessGranted,
+          description: getPermissionDescription("microphone"),
+        },
+        {
+          permission_type: "camera",
+          isGranted: isCameraAccessGranted,
+          description: getPermissionDescription("camera"),
+        },
+      ];
+
+      setPermissions(permissionList);
+    } catch (error) {
+      console.error("Failed to load permissions:", error);
+    } finally {
+      setIsLoadingPermissions(false);
+    }
+  };
+
   const checkDefaultBrowserStatus = async () => {
     try {
       const isDefault = await invoke<boolean>("is_default_browser");
@@ -106,11 +201,74 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     }
   };
 
+  const handleClearCache = async () => {
+    setIsClearingCache(true);
+    try {
+      await invoke("clear_all_version_cache_and_refetch");
+      showSuccessToast("Cache cleared successfully", {
+        description:
+          "All browser version cache has been cleared and browsers are being refreshed.",
+        duration: 4000,
+      });
+    } catch (error) {
+      console.error("Failed to clear cache:", error);
+      showErrorToast("Failed to clear cache", {
+        description:
+          error instanceof Error ? error.message : "Unknown error occurred",
+        duration: 4000,
+      });
+    } finally {
+      setIsClearingCache(false);
+    }
+  };
+
+  const handleRequestPermission = async (permissionType: PermissionType) => {
+    setRequestingPermission(permissionType);
+    try {
+      await requestPermission(permissionType);
+      showSuccessToast(
+        `${getPermissionDisplayName(permissionType)} access requested`,
+      );
+    } catch (error) {
+      console.error("Failed to request permission:", error);
+    } finally {
+      setRequestingPermission(null);
+    }
+  };
+
+  const getPermissionIcon = (type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return <BsMic className="w-4 h-4" />;
+      case "camera":
+        return <BsCamera className="w-4 h-4" />;
+    }
+  };
+
+  const getPermissionDisplayName = (type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return "Microphone";
+      case "camera":
+        return "Camera";
+    }
+  };
+
+  const getStatusBadge = (isGranted: boolean) => {
+    if (isGranted) {
+      return (
+        <Badge variant="default" className="text-green-800 bg-green-100">
+          Granted
+        </Badge>
+      );
+    }
+    return <Badge variant="secondary">Not Granted</Badge>;
+  };
+
   const handleSave = async () => {
     setIsSaving(true);
     try {
       await invoke("save_app_settings", { settings });
-      // Apply theme change immediately
       setTheme(settings.theme);
       setOriginalSettings(settings);
       onClose();
@@ -130,7 +288,8 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     settings.show_settings_on_startup !==
       originalSettings.show_settings_on_startup ||
     settings.theme !== originalSettings.theme ||
-    settings.auto_updates_enabled !== originalSettings.auto_updates_enabled;
+    settings.auto_delete_unused_binaries !==
+      originalSettings.auto_delete_unused_binaries;
 
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
@@ -139,7 +298,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
           <DialogTitle>Settings</DialogTitle>
         </DialogHeader>
 
-        <div className="grid gap-6 py-4 overflow-y-auto flex-1 min-h-0">
+        <div className="grid overflow-y-auto flex-1 gap-6 py-4 min-h-0">
           {/* Appearance Section */}
           <div className="space-y-4">
             <Label className="text-base font-medium">Appearance</Label>
@@ -172,7 +331,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
 
           {/* Default Browser Section */}
           <div className="space-y-4">
-            <div className="flex items-center justify-between">
+            <div className="flex justify-between items-center">
               <Label className="text-base font-medium">Default Browser</Label>
               <Badge variant={isDefaultBrowser ? "default" : "secondary"}>
                 {isDefaultBrowser ? "Active" : "Inactive"}
@@ -182,7 +341,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
             <LoadingButton
               isLoading={isSettingDefault}
               onClick={() => {
-                void handleSetDefaultBrowser();
+                handleSetDefaultBrowser().catch(console.error);
               }}
               disabled={isDefaultBrowser}
               variant={isDefaultBrowser ? "outline" : "default"}
@@ -205,20 +364,24 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
 
             <div className="flex items-center space-x-2">
               <Checkbox
-                id="auto-updates"
-                checked={settings.auto_updates_enabled}
+                id="auto-delete-binaries"
+                checked={settings.auto_delete_unused_binaries}
                 onCheckedChange={(checked) => {
-                  updateSetting("auto_updates_enabled", checked as boolean);
+                  updateSetting(
+                    "auto_delete_unused_binaries",
+                    checked as boolean,
+                  );
                 }}
               />
-              <Label htmlFor="auto-updates" className="text-sm">
-                Enable automatic browser updates
+              <Label htmlFor="auto-delete-binaries" className="text-sm">
+                Automatically delete unused browser binaries
               </Label>
             </div>
 
             <p className="text-xs text-muted-foreground">
               When enabled, Donut Browser will check for browser updates and
-              notify you when updates are available for your profiles.
+              notify you when updates are available for your profiles. Unused
+              binaries will be automatically deleted to save disk space.
             </p>
           </div>
 
@@ -244,6 +407,91 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
               starts.
             </p>
           </div>
+
+          {/* Permissions Section - Only show on macOS */}
+          {isMacOS && (
+            <div className="space-y-4">
+              <Label className="text-base font-medium">
+                System Permissions
+              </Label>
+
+              {isLoadingPermissions ? (
+                <div className="text-sm text-muted-foreground">
+                  Loading permissions...
+                </div>
+              ) : (
+                <div className="space-y-3">
+                  {permissions.map((permission) => (
+                    <div
+                      key={permission.permission_type}
+                      className="flex justify-between items-center p-3 rounded-lg border"
+                    >
+                      <div className="flex items-center space-x-3">
+                        {getPermissionIcon(permission.permission_type)}
+                        <div>
+                          <div className="text-sm font-medium">
+                            {getPermissionDisplayName(
+                              permission.permission_type,
+                            )}
+                          </div>
+                          <div className="text-xs text-muted-foreground">
+                            {permission.description}
+                          </div>
+                        </div>
+                      </div>
+                      <div className="flex items-center space-x-2">
+                        {getStatusBadge(permission.isGranted)}
+                        {!permission.isGranted && (
+                          <LoadingButton
+                            size="sm"
+                            isLoading={
+                              requestingPermission ===
+                              permission.permission_type
+                            }
+                            onClick={() => {
+                              handleRequestPermission(
+                                permission.permission_type,
+                              ).catch(console.error);
+                            }}
+                          >
+                            Grant
+                          </LoadingButton>
+                        )}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              )}
+
+              <p className="text-xs text-muted-foreground">
+                These permissions allow browsers launched from Donut Browser to
+                access system resources. Each website will still ask for your
+                permission individually.
+              </p>
+            </div>
+          )}
+
+          {/* Advanced Section */}
+          <div className="space-y-4">
+            <Label className="text-base font-medium">Advanced</Label>
+
+            <LoadingButton
+              isLoading={isClearingCache}
+              onClick={() => {
+                handleClearCache().catch(console.error);
+              }}
+              variant="outline"
+              className="w-full"
+            >
+              Clear All Version Cache
+            </LoadingButton>
+
+            <p className="text-xs text-muted-foreground">
+              Clear all cached browser version data and refresh all browser
+              versions from their sources. This will force a fresh download of
+              version information for all browsers.
+            </p>
+          </div>
         </div>
 
         <DialogFooter className="flex-shrink-0">
@@ -253,7 +501,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
           <LoadingButton
             isLoading={isSaving}
             onClick={() => {
-              void handleSave();
+              handleSave().catch(console.error);
             }}
             disabled={isLoading || !hasChanges}
           >

src/components/theme-provider.tsx

@@ -9,6 +9,10 @@ interface AppSettings {
   theme: string;
 }
 
+interface SystemTheme {
+  theme: string;
+}
+
 interface CustomThemeProviderProps {
   children: React.ReactNode;
 }
@@ -24,9 +28,33 @@ function getSystemTheme(): string {
   return "light";
 }
 
+// Function to get native system theme (fallback to CSS media query)
+async function getNativeSystemTheme(): Promise<string> {
+  try {
+    const systemTheme = await invoke<SystemTheme>("get_system_theme");
+    if (systemTheme.theme === "dark" || systemTheme.theme === "light") {
+      return systemTheme.theme;
+    }
+    // Fallback to CSS media query if native detection returns "unknown"
+    return getSystemTheme();
+  } catch (error) {
+    console.warn(
+      "Failed to get native system theme, falling back to CSS media query:",
+      error,
+    );
+    // Fallback to CSS media query
+    return getSystemTheme();
+  }
+}
+
 export function CustomThemeProvider({ children }: CustomThemeProviderProps) {
   const [isLoading, setIsLoading] = useState(true);
   const [defaultTheme, setDefaultTheme] = useState<string>("system");
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);
 
   useEffect(() => {
     const loadTheme = async () => {
@@ -36,7 +64,7 @@ export function CustomThemeProvider({ children }: CustomThemeProviderProps) {
       } catch (error) {
         console.error("Failed to load theme settings:", error);
         // For first-time users, detect system preference and apply it
-        const systemTheme = getSystemTheme();
+        const systemTheme = await getNativeSystemTheme();
         console.log(
           "First-time user detected, applying system theme:",
           systemTheme,
@@ -64,19 +92,70 @@ export function CustomThemeProvider({ children }: CustomThemeProviderProps) {
     void loadTheme();
   }, []);
 
+  // Monitor system theme changes when using "system" theme
+  useEffect(() => {
+    if (!mounted || defaultTheme !== "system") {
+      return;
+    }
+
+    const checkSystemTheme = async () => {
+      try {
+        const currentSystemTheme = await getNativeSystemTheme();
+        // Force re-evaluation by toggling the theme
+        const html = document.documentElement;
+
+        // Apply the system theme class
+        if (currentSystemTheme === "dark") {
+          if (!html.classList.contains("dark")) {
+            html.classList.add("dark");
+            html.classList.remove("light");
+          }
+        } else {
+          if (
+            !html.classList.contains("light") ||
+            html.classList.contains("dark")
+          ) {
+            html.classList.add("light");
+            html.classList.remove("dark");
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to check system theme:", error);
+      }
+    };
+
+    // Check system theme every 2 seconds when using system theme
+    const intervalId = setInterval(() => void checkSystemTheme(), 2000);
+
+    // Initial check
+    void checkSystemTheme();
+
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [mounted, defaultTheme]);
+
   if (isLoading) {
-    // Detect system theme to show appropriate loading screen
-    const systemTheme = getSystemTheme();
-    const loadingBgColor = systemTheme === "dark" ? "bg-gray-900" : "bg-white";
-    const spinnerColor =
-      systemTheme === "dark" ? "border-white" : "border-gray-900";
+    // Use a consistent loading screen that doesn't depend on system theme during SSR
+    // This prevents hydration mismatch by ensuring server and client render the same initially
+    let loadingBgColor = "bg-white";
+    let spinnerColor = "border-gray-900";
+
+    // Only apply system theme detection after component is mounted (client-side only)
+    if (mounted) {
+      // Use CSS media query for loading screen since async call would complicate this
+      const systemTheme = getSystemTheme();
+      loadingBgColor = systemTheme === "dark" ? "bg-gray-900" : "bg-white";
+      spinnerColor =
+        systemTheme === "dark" ? "border-white" : "border-gray-900";
+    }
 
     return (
       <div
-        className={`fixed inset-0 ${loadingBgColor} flex items-center justify-center`}
+        className={`flex fixed inset-0 justify-center items-center ${loadingBgColor}`}
       >
         <div
-          className={`animate-spin rounded-full h-8 w-8 border-2 ${spinnerColor} border-t-transparent`}
+          className={`w-8 h-8 rounded-full border-2 animate-spin ${spinnerColor} border-t-transparent`}
         />
       </div>
     );

src/components/ui/sonner.tsx

@@ -15,8 +15,15 @@ const Toaster = ({ ...props }: ToasterProps) => {
           "--normal-bg": "var(--popover)",
           "--normal-text": "var(--popover-foreground)",
           "--normal-border": "var(--border)",
+          zIndex: 99999,
         } as React.CSSProperties
       }
+      toastOptions={{
+        style: {
+          zIndex: 99999,
+          pointerEvents: "auto",
+        },
+      }}
       {...props}
     />
   );

src/components/update-notification.tsx

@@ -1,108 +0,0 @@
-"use client";
-
-/* eslint-disable @typescript-eslint/no-misused-promises */
-
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { getBrowserDisplayName } from "@/lib/browser-utils";
-import React from "react";
-import { FaDownload, FaTimes } from "react-icons/fa";
-import { LuDownload } from "react-icons/lu";
-
-interface UpdateNotification {
-  id: string;
-  browser: string;
-  current_version: string;
-  new_version: string;
-  affected_profiles: string[];
-  is_stable_update: boolean;
-  timestamp: number;
-}
-
-interface UpdateNotificationProps {
-  notification: UpdateNotification;
-  onUpdate: (browser: string, newVersion: string) => Promise<void>;
-  onDismiss: (notificationId: string) => Promise<void>;
-  isUpdating?: boolean;
-}
-
-export function UpdateNotificationComponent({
-  notification,
-  onUpdate,
-  onDismiss,
-  isUpdating = false,
-}: UpdateNotificationProps) {
-  const browserDisplayName = getBrowserDisplayName(notification.browser);
-
-  const profileText =
-    notification.affected_profiles.length === 1
-      ? `profile "${notification.affected_profiles[0]}"`
-      : `${notification.affected_profiles.length} profiles`;
-
-  const handleUpdateClick = async () => {
-    // Dismiss the notification immediately to close the modal
-    await onDismiss(notification.id);
-    // Then start the update process
-    await onUpdate(notification.browser, notification.new_version);
-  };
-
-  return (
-    <div className="flex flex-col gap-3 p-4 max-w-md bg-background border border-border rounded-lg shadow-lg">
-      <div className="flex items-start justify-between gap-2">
-        <div className="flex flex-col gap-1">
-          <div className="flex items-center gap-2">
-            <span className="font-semibold text-foreground">
-              {browserDisplayName} Update Available
-            </span>
-            <Badge
-              variant={notification.is_stable_update ? "default" : "secondary"}
-            >
-              {notification.is_stable_update ? "Stable" : "Beta"}
-            </Badge>
-          </div>
-          <div className="text-sm text-muted-foreground">
-            Update {profileText} from {notification.current_version} to{" "}
-            <span className="font-medium">{notification.new_version}</span>
-          </div>
-        </div>
-        <Button
-          variant="ghost"
-          size="sm"
-          onClick={async () => {
-            await onDismiss(notification.id);
-          }}
-          className="h-6 w-6 p-0 shrink-0"
-        >
-          <FaTimes className="h-3 w-3" />
-        </Button>
-      </div>
-
-      <div className="flex items-center gap-2">
-        <Button
-          onClick={handleUpdateClick}
-          disabled={isUpdating}
-          size="sm"
-          className="flex items-center gap-2"
-        >
-          <FaDownload className="h-3 w-3" />
-          Update
-        </Button>
-        <Button
-          variant="outline"
-          onClick={async () => {
-            await onDismiss(notification.id);
-          }}
-          size="sm"
-        >
-          Later
-        </Button>
-      </div>
-
-      {notification.affected_profiles.length > 1 && (
-        <div className="text-xs text-muted-foreground">
-          Affected profiles: {notification.affected_profiles.join(", ")}
-        </div>
-      )}
-    </div>
-  );
-}

src/components/version-selector.tsx

@@ -1,156 +0,0 @@
-"use client";
-
-import { LoadingButton } from "@/components/loading-button";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import {
-  Command,
-  CommandEmpty,
-  CommandGroup,
-  CommandInput,
-  CommandItem,
-  CommandList,
-} from "@/components/ui/command";
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-} from "@/components/ui/popover";
-import { cn } from "@/lib/utils";
-import { useState } from "react";
-import { LuDownload } from "react-icons/lu";
-import { LuCheck, LuChevronsUpDown } from "react-icons/lu";
-import { ScrollArea } from "./ui/scroll-area";
-
-interface GithubRelease {
-  tag_name: string;
-  assets: Array<{
-    name: string;
-    browser_download_url: string;
-    hash?: string;
-  }>;
-  published_at: string;
-  is_alpha: boolean;
-}
-
-interface VersionSelectorProps {
-  selectedVersion: string | null;
-  onVersionSelect: (version: string | null) => void;
-  availableVersions: GithubRelease[];
-  downloadedVersions: string[];
-  isDownloading: boolean;
-  onDownload: () => void;
-  placeholder?: string;
-  showDownloadButton?: boolean;
-}
-
-export function VersionSelector({
-  selectedVersion,
-  onVersionSelect,
-  availableVersions,
-  downloadedVersions,
-  isDownloading,
-  onDownload,
-  placeholder = "Select version...",
-  showDownloadButton = true,
-}: VersionSelectorProps) {
-  const [versionPopoverOpen, setVersionPopoverOpen] = useState(false);
-
-  const isVersionDownloaded = selectedVersion
-    ? downloadedVersions.includes(selectedVersion)
-    : false;
-
-  return (
-    <div className="space-y-4">
-      <Popover
-        open={versionPopoverOpen}
-        onOpenChange={setVersionPopoverOpen}
-        modal={true}
-      >
-        <PopoverTrigger asChild>
-          <Button
-            variant="outline"
-            role="combobox"
-            aria-expanded={versionPopoverOpen}
-            className="justify-between w-full"
-          >
-            {selectedVersion ?? placeholder}
-            <LuChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
-          </Button>
-        </PopoverTrigger>
-        <PopoverContent className="w-[300px] p-0">
-          <Command>
-            <CommandInput placeholder="Search versions..." />
-            <CommandEmpty>No versions found.</CommandEmpty>
-            <CommandList>
-              <ScrollArea
-                className={
-                  "[&>[data-radix-scroll-area-viewport]]:max-h-[200px]"
-                }
-              >
-                <CommandGroup>
-                  {availableVersions.map((version) => {
-                    const isDownloaded = downloadedVersions.includes(
-                      version.tag_name,
-                    );
-                    return (
-                      <CommandItem
-                        key={version.tag_name}
-                        value={version.tag_name}
-                        onSelect={(currentValue) => {
-                          onVersionSelect(
-                            currentValue === selectedVersion
-                              ? null
-                              : currentValue,
-                          );
-                          setVersionPopoverOpen(false);
-                        }}
-                      >
-                        <LuCheck
-                          className={cn(
-                            "mr-2 h-4 w-4",
-                            selectedVersion === version.tag_name
-                              ? "opacity-100"
-                              : "opacity-0",
-                          )}
-                        />
-                        <div className="flex items-center gap-2">
-                          <span>{version.tag_name}</span>
-                          {version.is_alpha && (
-                            <Badge variant="secondary" className="text-xs">
-                              Alpha
-                            </Badge>
-                          )}
-                          {isDownloaded && (
-                            <Badge variant="default" className="text-xs">
-                              Downloaded
-                            </Badge>
-                          )}
-                        </div>
-                      </CommandItem>
-                    );
-                  })}
-                </CommandGroup>
-              </ScrollArea>
-            </CommandList>
-          </Command>
-        </PopoverContent>
-      </Popover>
-
-      {/* Download Button */}
-      {showDownloadButton && selectedVersion && !isVersionDownloaded && (
-        <LoadingButton
-          isLoading={isDownloading}
-          onClick={() => {
-            onDownload();
-          }}
-          variant="outline"
-          className="w-full"
-        >
-          <LuDownload className="mr-2 h-4 w-4" />
-          {isDownloading ? "Downloading..." : "Download Browser"}
-        </LoadingButton>
-      )}
-    </div>
-  );
-}

src/components/version-update-settings.tsx

@@ -1,129 +0,0 @@
-"use client";
-
-import { LoadingButton } from "@/components/loading-button";
-import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
-import { useVersionUpdater } from "@/hooks/use-version-updater";
-import {
-  LuCheckCheck,
-  LuCircleAlert,
-  LuClock,
-  LuRefreshCw,
-} from "react-icons/lu";
-
-export function VersionUpdateSettings() {
-  const {
-    isUpdating,
-    lastUpdateTime,
-    timeUntilNextUpdate,
-    updateProgress,
-    triggerManualUpdate,
-    formatTimeUntilUpdate,
-    formatLastUpdateTime,
-  } = useVersionUpdater();
-
-  return (
-    <Card>
-      <CardHeader>
-        <CardTitle className="flex items-center gap-2">
-          <LuRefreshCw className="h-5 w-5" />
-          Background Version Updates
-        </CardTitle>
-        <CardDescription>
-          Browser versions are automatically checked every 3 hours in the
-          background. New versions are cached and ready when you need them.
-        </CardDescription>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* Current Status */}
-        <div className="grid gap-4 md:grid-cols-2">
-          <div className="space-y-2">
-            <div className="flex items-center gap-2 text-sm font-medium">
-              <LuClock className="h-4 w-4" />
-              Last Update
-            </div>
-            <div className="text-sm text-muted-foreground">
-              {formatLastUpdateTime(lastUpdateTime)}
-            </div>
-          </div>
-
-          <div className="space-y-2">
-            <div className="flex items-center gap-2 text-sm font-medium">
-              <LuCheckCheck className="h-4 w-4" />
-              Next Update
-            </div>
-            <div className="text-sm text-muted-foreground">
-              {timeUntilNextUpdate <= 0
-                ? "Now"
-                : `In ${formatTimeUntilUpdate(timeUntilNextUpdate)}`}
-            </div>
-          </div>
-        </div>
-
-        {/* Progress indicator */}
-        {isUpdating && updateProgress && (
-          <Alert>
-            <LuRefreshCw className="h-4 w-4 animate-spin" />
-            <AlertTitle>Updating Browser Versions</AlertTitle>
-            <AlertDescription>
-              {updateProgress.current_browser ? (
-                <>
-                  Checking {updateProgress.current_browser} (
-                  {updateProgress.completed_browsers}/
-                  {updateProgress.total_browsers})
-                  <br />
-                  {updateProgress.new_versions_found} new versions found so far
-                </>
-              ) : (
-                "Starting version update..."
-              )}
-            </AlertDescription>
-          </Alert>
-        )}
-
-        {/* Manual update button */}
-        <div className="flex items-center justify-between pt-2 border-t">
-          <div className="space-y-1">
-            <div className="text-sm font-medium">Manual Update</div>
-            <div className="text-xs text-muted-foreground">
-              Check for new browser versions now
-            </div>
-          </div>
-          <LoadingButton
-            isLoading={isUpdating}
-            onClick={() => {
-              void triggerManualUpdate();
-            }}
-            variant="outline"
-            size="sm"
-            disabled={isUpdating}
-          >
-            <LuRefreshCw className="h-4 w-4 mr-2" />
-            {isUpdating ? "Updating..." : "Check Now"}
-          </LoadingButton>
-        </div>
-
-        {/* Information about background updates */}
-        <Alert>
-          <LuCircleAlert className="h-4 w-4" />
-          <AlertTitle>How it works</AlertTitle>
-          <AlertDescription className="text-xs">
-            • Version information is checked automatically every 3 hours
-            <br />• New versions are added to the cache without removing old
-            ones
-            <br />• When creating profiles or changing versions, you&apos;ll see
-            how many new versions were found
-            <br />• This keeps the app responsive while ensuring you have the
-            latest information
-          </AlertDescription>
-        </Alert>
-      </CardContent>
-    </Card>
-  );
-}

src/components/window-drag-area.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { useEffect, useState } from "react";
+
+export function WindowDragArea() {
+  const [isMacOS, setIsMacOS] = useState(false);
+
+  useEffect(() => {
+    // Check if we're on macOS using user agent detection
+    const checkPlatform = () => {
+      const userAgent = navigator.userAgent.toLowerCase();
+      setIsMacOS(userAgent.includes("mac"));
+    };
+
+    checkPlatform();
+  }, []);
+
+  const handleMouseDown = (e: React.MouseEvent) => {
+    // Only handle left mouse button
+    if (e.button !== 0) return;
+
+    // Start dragging asynchronously
+    const startDrag = async () => {
+      try {
+        const window = getCurrentWindow();
+        await window.startDragging();
+      } catch (error) {
+        console.error("Failed to start window dragging:", error);
+      }
+    };
+
+    void startDrag();
+  };
+
+  // Only render on macOS
+  if (!isMacOS) {
+    return null;
+  }
+
+  return (
+    <div
+      className="fixed top-0 right-0 left-0 h-10 z-9999"
+      style={{
+        // Ensure it's above all other content
+        zIndex: 9999,
+        // Make it transparent but still capture mouse events
+        backgroundColor: "transparent",
+        // Prevent text selection during drag
+        userSelect: "none",
+        WebkitUserSelect: "none",
+      }}
+      onMouseDown={handleMouseDown}
+      // Prevent context menu
+      onContextMenu={(e) => {
+        e.preventDefault();
+      }}
+    />
+  );
+}

src/hooks/use-app-update-notifications.tsx

@@ -0,0 +1,168 @@
+"use client";
+
+import { AppUpdateToast } from "@/components/app-update-toast";
+import { showToast } from "@/lib/toast-utils";
+import type { AppUpdateInfo } from "@/types";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import React, { useCallback, useEffect, useState } from "react";
+import { toast } from "sonner";
+
+export function useAppUpdateNotifications() {
+  const [updateInfo, setUpdateInfo] = useState<AppUpdateInfo | null>(null);
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [updateProgress, setUpdateProgress] = useState<string>("");
+  const [isClient, setIsClient] = useState(false);
+  const [dismissedVersion, setDismissedVersion] = useState<string | null>(null);
+
+  // Ensure we're on the client side to prevent hydration mismatches
+  useEffect(() => {
+    setIsClient(true);
+  }, []);
+
+  const checkForAppUpdates = useCallback(async () => {
+    if (!isClient) return;
+
+    try {
+      const update = await invoke<AppUpdateInfo | null>(
+        "check_for_app_updates",
+      );
+
+      // Don't show update if this version was already dismissed
+      if (update && update.new_version !== dismissedVersion) {
+        setUpdateInfo(update);
+      } else if (update) {
+        console.log("Update available but dismissed:", update.new_version);
+      }
+    } catch (error) {
+      console.error("Failed to check for app updates:", error);
+    }
+  }, [isClient, dismissedVersion]);
+
+  const checkForAppUpdatesManual = useCallback(async () => {
+    if (!isClient) return;
+
+    try {
+      console.log("Triggering manual app update check...");
+      const update = await invoke<AppUpdateInfo | null>(
+        "check_for_app_updates_manual",
+      );
+      console.log("Manual check result:", update);
+
+      // Always show manual check results, even if previously dismissed
+      setUpdateInfo(update);
+    } catch (error) {
+      console.error("Failed to manually check for app updates:", error);
+    }
+  }, [isClient]);
+
+  const handleAppUpdate = useCallback(async (appUpdateInfo: AppUpdateInfo) => {
+    try {
+      setIsUpdating(true);
+      setUpdateProgress("Starting update...");
+
+      await invoke("download_and_install_app_update", {
+        updateInfo: appUpdateInfo,
+      });
+    } catch (error) {
+      console.error("Failed to update app:", error);
+      showToast({
+        type: "error",
+        title: "Failed to update Donut Browser",
+        description: String(error),
+        duration: 6000,
+      });
+      setIsUpdating(false);
+      setUpdateProgress("");
+    }
+  }, []);
+
+  const dismissAppUpdate = useCallback(() => {
+    if (!isClient) return;
+
+    // Remember the dismissed version so we don't show it again
+    if (updateInfo) {
+      setDismissedVersion(updateInfo.new_version);
+      console.log("Dismissed app update version:", updateInfo.new_version);
+    }
+
+    setUpdateInfo(null);
+    toast.dismiss("app-update");
+  }, [isClient, updateInfo]);
+
+  // Listen for app update availability
+  useEffect(() => {
+    if (!isClient) return;
+
+    const unlistenUpdate = listen<AppUpdateInfo>(
+      "app-update-available",
+      (event) => {
+        console.log("App update available:", event.payload);
+        setUpdateInfo(event.payload);
+      },
+    );
+
+    const unlistenProgress = listen<string>("app-update-progress", (event) => {
+      console.log("App update progress:", event.payload);
+      setUpdateProgress(event.payload);
+    });
+
+    return () => {
+      void unlistenUpdate.then((unlisten) => {
+        unlisten();
+      });
+      void unlistenProgress.then((unlisten) => {
+        unlisten();
+      });
+    };
+  }, [isClient]);
+
+  // Show toast when update is available
+  useEffect(() => {
+    if (!isClient || !updateInfo) return;
+
+    toast.custom(
+      () => (
+        <AppUpdateToast
+          updateInfo={updateInfo}
+          onUpdate={handleAppUpdate}
+          onDismiss={dismissAppUpdate}
+          isUpdating={isUpdating}
+          updateProgress={updateProgress}
+        />
+      ),
+      {
+        id: "app-update",
+        duration: Number.POSITIVE_INFINITY, // Persistent until user action
+        position: "top-left",
+        style: {
+          zIndex: 99999, // Ensure app updates appear above dialogs
+          pointerEvents: "auto", // Ensure app updates remain interactive
+        },
+      },
+    );
+  }, [
+    updateInfo,
+    handleAppUpdate,
+    dismissAppUpdate,
+    isUpdating,
+    updateProgress,
+    isClient,
+  ]);
+
+  // Check for app updates on startup
+  useEffect(() => {
+    if (!isClient) return;
+
+    // Check for updates immediately on startup
+    void checkForAppUpdates();
+  }, [isClient, checkForAppUpdates]);
+
+  return {
+    updateInfo,
+    isUpdating,
+    checkForAppUpdates,
+    checkForAppUpdatesManual,
+    dismissAppUpdate,
+  };
+}

src/hooks/use-browser-download.ts

@@ -3,23 +3,21 @@ import {
   dismissToast,
   showDownloadToast,
   showErrorToast,
-  showFetchingToast,
   showSuccessToast,
 } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
 
 interface GithubRelease {
   tag_name: string;
-  assets: Array<{
+  assets: {
     name: string;
     browser_download_url: string;
     hash?: string;
-  }>;
+  }[];
   published_at: string;
-  is_alpha: boolean;
+  is_nightly: boolean;
 }
 
 interface BrowserVersionInfo {
@@ -45,31 +43,6 @@ interface BrowserVersionsResult {
   total_versions_count: number;
 }
 
-interface VersionUpdateProgress {
-  current_browser: string;
-  total_browsers: number;
-  completed_browsers: number;
-  new_versions_found: number;
-  browser_new_versions: number;
-  status: string;
-}
-
-const isAlphaVersion = (version: string): boolean => {
-  // Check for common alpha/beta/dev indicators
-  const lowerVersion = version.toLowerCase();
-  return (
-    lowerVersion.includes("a") ||
-    lowerVersion.includes("b") ||
-    lowerVersion.includes("alpha") ||
-    lowerVersion.includes("beta") ||
-    lowerVersion.includes("dev") ||
-    lowerVersion.includes("rc") ||
-    lowerVersion.includes("pre") ||
-    // Check for patterns like "139.0b1" or "140.0a1"
-    /\d+\.\d+[ab]\d+/.test(lowerVersion)
-  );
-};
-
 export function useBrowserDownload() {
   const [availableVersions, setAvailableVersions] = useState<GithubRelease[]>(
     [],
@@ -78,7 +51,6 @@ export function useBrowserDownload() {
   const [isDownloading, setIsDownloading] = useState(false);
   const [downloadProgress, setDownloadProgress] =
     useState<DownloadProgress | null>(null);
-  const [isUpdatingVersions, setIsUpdatingVersions] = useState(false);
 
   // Listen for download progress events
   useEffect(() => {
@@ -88,53 +60,29 @@ export function useBrowserDownload() {
 
       const browserName = getBrowserDisplayName(progress.browser);
 
-      // Check if this is an auto-update download to suppress completion toast
-      const checkAutoUpdate = async () => {
-        let isAutoUpdate = false;
-        try {
-          isAutoUpdate = await invoke<boolean>("is_auto_update_download", {
-            browser: progress.browser,
-            version: progress.version,
-          });
-        } catch (error) {
-          console.error("Failed to check auto-update status:", error);
-        }
+      // Show toast with progress
+      if (progress.stage === "downloading") {
+        const speedMBps = (
+          progress.speed_bytes_per_sec /
+          (1024 * 1024)
+        ).toFixed(1);
+        const etaText = progress.eta_seconds
+          ? formatTime(progress.eta_seconds)
+          : "calculating...";
 
-        // Show toast with progress
-        if (progress.stage === "downloading") {
-          const speedMBps = (
-            progress.speed_bytes_per_sec /
-            (1024 * 1024)
-          ).toFixed(1);
-          const etaText = progress.eta_seconds
-            ? formatTime(progress.eta_seconds)
-            : "calculating...";
-
-          showDownloadToast(browserName, progress.version, "downloading", {
-            percentage: progress.percentage,
-            speed: speedMBps,
-            eta: etaText,
-          });
-        } else if (progress.stage === "extracting") {
-          showDownloadToast(browserName, progress.version, "extracting");
-        } else if (progress.stage === "verifying") {
-          showDownloadToast(browserName, progress.version, "verifying");
-        } else if (progress.stage === "completed") {
-          // Suppress completion toast for auto-updates
-          showDownloadToast(
-            browserName,
-            progress.version,
-            "completed",
-            undefined,
-            {
-              suppressCompletionToast: isAutoUpdate,
-            },
-          );
-          setDownloadProgress(null);
-        }
-      };
-
-      void checkAutoUpdate();
+        showDownloadToast(browserName, progress.version, "downloading", {
+          percentage: progress.percentage,
+          speed: speedMBps,
+          eta: etaText,
+        });
+      } else if (progress.stage === "extracting") {
+        showDownloadToast(browserName, progress.version, "extracting");
+      } else if (progress.stage === "verifying") {
+        showDownloadToast(browserName, progress.version, "verifying");
+      } else if (progress.stage === "completed") {
+        showDownloadToast(browserName, progress.version, "completed");
+        setDownloadProgress(null);
+      }
     });
 
     return () => {
@@ -144,51 +92,6 @@ export function useBrowserDownload() {
     };
   }, []);
 
-  // Listen for version update progress events
-  useEffect(() => {
-    const unlisten = listen<VersionUpdateProgress>(
-      "version-update-progress",
-      (event) => {
-        const progress = event.payload;
-
-        if (progress.status === "updating") {
-          setIsUpdatingVersions(true);
-          if (progress.current_browser) {
-            const browserName = getBrowserDisplayName(progress.current_browser);
-            showFetchingToast(browserName, {
-              id: `version-update-${progress.current_browser}`,
-              description: "Fetching latest release information...",
-            });
-          }
-        } else if (progress.status === "completed") {
-          setIsUpdatingVersions(false);
-          if (progress.new_versions_found > 0) {
-            showSuccessToast(
-              `Found ${progress.new_versions_found} new browser versions!`,
-              {
-                duration: 3000,
-              },
-            );
-          }
-          // Dismiss any update toasts
-          toast.dismiss();
-        } else if (progress.status === "error") {
-          setIsUpdatingVersions(false);
-          showErrorToast("Failed to check for new versions", {
-            duration: 4000,
-          });
-          toast.dismiss();
-        }
-      },
-    );
-
-    return () => {
-      void unlisten.then((fn) => {
-        fn();
-      });
-    };
-  }, []);
-
   const formatTime = (seconds: number): string => {
     if (seconds < 60) {
       return `${Math.round(seconds)}s`;
@@ -214,10 +117,8 @@ export function useBrowserDownload() {
   const loadVersions = useCallback(async (browserStr: string) => {
     const browserName = getBrowserDisplayName(browserStr);
 
-    // Show fetching toast
-    const toastId = showFetchingToast(browserName, {
-      id: `fetch-${browserStr}`,
-    });
+    // Use a simple loading state instead of toast for version fetching
+    console.log(`Fetching ${browserName} versions...`);
 
     try {
       const versionInfos = await invoke<BrowserVersionInfo[]>(
@@ -231,16 +132,14 @@ export function useBrowserDownload() {
           tag_name: versionInfo.version,
           assets: [],
           published_at: versionInfo.date,
-          is_alpha: versionInfo.is_prerelease,
+          is_nightly: versionInfo.is_prerelease,
         }),
       );
 
       setAvailableVersions(githubReleases);
-      dismissToast(toastId);
       return githubReleases;
     } catch (error) {
       console.error("Failed to load versions:", error);
-      dismissToast(toastId);
       showErrorToast(`Failed to fetch ${browserName} versions`, {
         description:
           error instanceof Error ? error.message : "Unknown error occurred",
@@ -272,7 +171,7 @@ export function useBrowserDownload() {
           tag_name: versionInfo.version,
           assets: [],
           published_at: versionInfo.date,
-          is_alpha: versionInfo.is_prerelease,
+          is_nightly: versionInfo.is_prerelease,
         }),
       );
 
@@ -325,6 +224,22 @@ export function useBrowserDownload() {
       setIsDownloading(true);
 
       try {
+        // Check browser compatibility before attempting download
+        const isSupported = await invoke<boolean>(
+          "is_browser_supported_on_platform",
+          { browserStr },
+        );
+        if (!isSupported) {
+          const supportedBrowsers = await invoke<string[]>(
+            "get_supported_browsers",
+          );
+          throw new Error(
+            `${browserName} is not supported on your platform. Supported browsers: ${supportedBrowsers
+              .map(getBrowserDisplayName)
+              .join(", ")}`,
+          );
+        }
+
         await invoke("download_browser", { browserStr, version });
         await loadDownloadedVersions(browserStr);
       } catch (error) {
@@ -358,7 +273,6 @@ export function useBrowserDownload() {
     downloadedVersions,
     isDownloading,
     downloadProgress,
-    isUpdatingVersions,
     loadVersions,
     loadVersionsWithNewCount,
     loadDownloadedVersions,

src/hooks/use-browser-support.ts

@@ -0,0 +1,53 @@
+import { invoke } from "@tauri-apps/api/core";
+import { useEffect, useState } from "react";
+
+export function useBrowserSupport() {
+  const [supportedBrowsers, setSupportedBrowsers] = useState<string[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const loadSupportedBrowsers = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const browsers = await invoke<string[]>("get_supported_browsers");
+        setSupportedBrowsers(browsers);
+      } catch (err) {
+        console.error("Failed to load supported browsers:", err);
+        setError(
+          err instanceof Error
+            ? err.message
+            : "Failed to load supported browsers",
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void loadSupportedBrowsers();
+  }, []);
+
+  const isBrowserSupported = (browser: string): boolean => {
+    return supportedBrowsers.includes(browser);
+  };
+
+  const checkBrowserSupport = async (browser: string): Promise<boolean> => {
+    try {
+      return await invoke<boolean>("is_browser_supported_on_platform", {
+        browserStr: browser,
+      });
+    } catch (err) {
+      console.error(`Failed to check support for browser ${browser}:`, err);
+      return false;
+    }
+  };
+
+  return {
+    supportedBrowsers,
+    isLoading,
+    error,
+    isBrowserSupported,
+    checkBrowserSupport,
+  };
+}

src/hooks/use-permissions.ts

@@ -0,0 +1,174 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// Platform-specific imports
+let macOSPermissions:
+  | typeof import("tauri-plugin-macos-permissions-api")
+  | null = null;
+
+// Dynamically import macOS permissions only when needed
+const loadMacOSPermissions = async () => {
+  if (macOSPermissions) return macOSPermissions;
+
+  try {
+    macOSPermissions = await import("tauri-plugin-macos-permissions-api");
+    return macOSPermissions;
+  } catch (error) {
+    console.warn("Failed to load macOS permissions API:", error);
+    return null;
+  }
+};
+
+export type PermissionType = "microphone" | "camera";
+
+interface UsePermissionsReturn {
+  requestPermission: (type: PermissionType) => Promise<void>;
+  isMicrophoneAccessGranted: boolean;
+  isCameraAccessGranted: boolean;
+  isInitialized: boolean;
+}
+
+export function usePermissions(): UsePermissionsReturn {
+  const [isMicrophoneAccessGranted, setIsMicrophoneAccessGranted] =
+    useState(false);
+  const [isCameraAccessGranted, setIsCameraAccessGranted] = useState(false);
+  const [currentPlatform, setCurrentPlatform] = useState<string | null>(null);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const intervalRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Check permissions status
+  const checkPermissions = useCallback(async () => {
+    if (!currentPlatform) return;
+
+    if (currentPlatform !== "macos") {
+      // Windows/Linux - assume permissions are granted
+      setIsMicrophoneAccessGranted(true);
+      setIsCameraAccessGranted(true);
+      setIsInitialized(true);
+      return;
+    }
+
+    // macOS - use the permissions API
+    try {
+      const permissions = await loadMacOSPermissions();
+      if (permissions) {
+        const [micGranted, camGranted] = await Promise.all([
+          permissions.checkMicrophonePermission(),
+          permissions.checkCameraPermission(),
+        ]);
+
+        setIsMicrophoneAccessGranted(micGranted);
+        setIsCameraAccessGranted(camGranted);
+        setIsInitialized(true);
+      }
+    } catch (error) {
+      console.error("Failed to check permissions on macOS:", error);
+      setIsInitialized(true);
+    }
+  }, [currentPlatform]);
+
+  // Request permission
+  const requestPermission = useCallback(
+    async (type: PermissionType): Promise<void> => {
+      if (!currentPlatform || currentPlatform !== "macos") return;
+
+      // macOS - use the permissions API
+      try {
+        const permissions = await loadMacOSPermissions();
+        if (!permissions) return;
+
+        if (type === "microphone") {
+          await permissions.requestMicrophonePermission();
+
+          // Poll for permission status change
+          const pollMicPermission = async () => {
+            const granted = await permissions.checkMicrophonePermission();
+            setIsMicrophoneAccessGranted(granted);
+
+            if (!granted) {
+              setTimeout(() => {
+                void pollMicPermission();
+              }, 1000);
+            }
+          };
+
+          await pollMicPermission();
+        }
+
+        if (type === "camera") {
+          await permissions.requestCameraPermission();
+
+          // Poll for permission status change
+          const pollCamPermission = async () => {
+            const granted = await permissions.checkCameraPermission();
+            setIsCameraAccessGranted(granted);
+
+            if (!granted) {
+              setTimeout(() => {
+                void pollCamPermission();
+              }, 1000);
+            }
+          };
+
+          await pollCamPermission();
+        }
+      } catch (error) {
+        console.error(`Failed to request ${type} permission on macOS:`, error);
+      }
+    },
+    [currentPlatform],
+  );
+
+  // Initialize platform detection and start interval checking
+  useEffect(() => {
+    const initializePlatform = async () => {
+      try {
+        // Detect platform - on macOS we need permissions, on others we don't
+        const userAgent = navigator.userAgent;
+        let platformName = "unknown";
+
+        if (userAgent.includes("Mac")) {
+          platformName = "macos";
+        } else if (userAgent.includes("Win")) {
+          platformName = "windows";
+        } else if (userAgent.includes("Linux")) {
+          platformName = "linux";
+        }
+
+        setCurrentPlatform(platformName);
+      } catch (error) {
+        console.error("Failed to detect platform:", error);
+        // Fallback - assume non-macOS
+        setCurrentPlatform("unknown");
+      }
+    };
+
+    initializePlatform().catch(console.error);
+  }, []);
+
+  // Set up interval checking when platform is determined
+  useEffect(() => {
+    if (!currentPlatform) return;
+
+    // Initial check
+    void checkPermissions();
+
+    // Set up 500ms interval for checking permissions
+    intervalRef.current = setInterval(() => {
+      void checkPermissions();
+    }, 500);
+
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [currentPlatform, checkPermissions]);
+
+  return {
+    requestPermission,
+    isMicrophoneAccessGranted,
+    isCameraAccessGranted,
+    isInitialized,
+  };
+}

src/hooks/use-update-notifications.tsx

@@ -1,9 +1,7 @@
-import { UpdateNotificationComponent } from "@/components/update-notification";
 import { getBrowserDisplayName } from "@/lib/browser-utils";
-import { showToast } from "@/lib/toast-utils";
+import { dismissToast, showToast } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
-import React, { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
+import { useCallback, useRef, useState } from "react";
 
 interface UpdateNotification {
   id: string;
@@ -13,52 +11,103 @@ interface UpdateNotification {
   affected_profiles: string[];
   is_stable_update: boolean;
   timestamp: number;
+  is_rolling_release: boolean;
 }
 
-export function useUpdateNotifications() {
+export function useUpdateNotifications(
+  onProfilesUpdated?: () => Promise<void>,
+) {
   const [notifications, setNotifications] = useState<UpdateNotification[]>([]);
   const [updatingBrowsers, setUpdatingBrowsers] = useState<Set<string>>(
     new Set(),
   );
-  const [isClient, setIsClient] = useState(false);
+  const [processedNotifications, setProcessedNotifications] = useState<
+    Set<string>
+  >(new Set());
 
-  // Ensure we're on the client side to prevent hydration mismatches
-  useEffect(() => {
-    setIsClient(true);
-  }, []);
+  const isUpdating = useCallback(
+    (browser: string) => updatingBrowsers.has(browser),
+    [updatingBrowsers],
+  );
+
+  // Add refs to track ongoing operations to prevent duplicates
+  const isCheckingForUpdates = useRef(false);
+  const activeDownloads = useRef<Set<string>>(new Set()); // Track "browser-version" keys
 
   const checkForUpdates = useCallback(async () => {
-    if (!isClient) return; // Only run on client side
+    // Prevent multiple simultaneous calls
+    if (isCheckingForUpdates.current) {
+      console.log("Already checking for updates, skipping duplicate call");
+      return;
+    }
+
+    isCheckingForUpdates.current = true;
 
     try {
       const updates = await invoke<UpdateNotification[]>(
         "check_for_browser_updates",
       );
-      setNotifications(updates);
 
-      // Show toasts for new notifications - we'll define handleUpdate and handleDismiss separately
-      // to avoid circular dependencies
+      // Filter out already processed notifications
+      const newUpdates = updates.filter((notification) => {
+        return !processedNotifications.has(notification.id);
+      });
+
+      setNotifications(newUpdates);
+
+      // Automatically start downloads for new update notifications
+      for (const notification of newUpdates) {
+        if (!processedNotifications.has(notification.id)) {
+          setProcessedNotifications((prev) =>
+            new Set(prev).add(notification.id),
+          );
+          // Start automatic update without user interaction
+          void handleAutoUpdate(
+            notification.browser,
+            notification.new_version,
+            notification.id,
+          );
+        }
+      }
     } catch (error) {
       console.error("Failed to check for updates:", error);
+    } finally {
+      isCheckingForUpdates.current = false;
     }
-  }, [isClient]);
+  }, [processedNotifications]);
+
+  const handleAutoUpdate = useCallback(
+    async (browser: string, newVersion: string, notificationId: string) => {
+      const downloadKey = `${browser}-${newVersion}`;
+
+      // Check if this download is already in progress
+      if (activeDownloads.current.has(downloadKey)) {
+        console.log(
+          `Download already in progress for ${downloadKey}, skipping duplicate`,
+        );
+        return;
+      }
+
+      // Mark download as active and disable browser
+      activeDownloads.current.add(downloadKey);
+      setUpdatingBrowsers((prev) => new Set(prev).add(browser));
 
-  const handleUpdate = useCallback(
-    async (browser: string, newVersion: string) => {
       try {
-        setUpdatingBrowsers((prev) => new Set(prev).add(browser));
         const browserDisplayName = getBrowserDisplayName(browser);
 
-        // Dismiss all notifications for this browser first
-        const browserNotifications = notifications.filter(
-          (n) => n.browser === browser,
-        );
-        for (const notification of browserNotifications) {
-          toast.dismiss(notification.id);
-          await invoke("dismiss_update_notification", {
-            notificationId: notification.id,
-          });
-        }
+        // Dismiss the notification in the backend
+        await invoke("dismiss_update_notification", {
+          notificationId,
+        });
+
+        // Show update started notification
+        showToast({
+          id: `auto-update-started-${browser}-${newVersion}`,
+          type: "loading",
+          title: `${browserDisplayName} update started`,
+          description: `Version ${newVersion} download will begin shortly. Browser launch is disabled until update completes.`,
+          duration: 4000,
+        });
 
         try {
           // Check if browser already exists before downloading
@@ -72,14 +121,25 @@ export function useUpdateNotifications() {
             console.log(
               `${browserDisplayName} ${newVersion} already exists, skipping download`,
             );
+
+            showToast({
+              id: `auto-update-skip-download-${browser}-${newVersion}`,
+              type: "success",
+              title: `${browserDisplayName} ${newVersion} already available`,
+              description: "Updating profile configurations...",
+              duration: 3000,
+            });
           } else {
-            // Mark download as auto-update in the backend for toast suppression
-            await invoke("mark_auto_update_download", {
-              browser,
-              version: newVersion,
+            // Show download starting notification
+            showToast({
+              id: `auto-update-download-starting-${browser}-${newVersion}`,
+              type: "loading",
+              title: `Starting ${browserDisplayName} ${newVersion} download`,
+              description: "Download progress will be shown below...",
+              duration: 4000,
             });
 
-            // Download the browser (progress will be handled by use-browser-download hook)
+            // Download the browser - this will trigger download progress events automatically
             await invoke("download_browser", {
               browserStr: browser,
               version: newVersion,
@@ -103,54 +163,45 @@ export function useUpdateNotifications() {
                 : `${updatedProfiles.length} profiles have been updated`;
 
             showToast({
+              id: `auto-update-success-${browser}-${newVersion}`,
               type: "success",
               title: `${browserDisplayName} update completed`,
-              description: `${profileText} to version ${newVersion}. Running profiles were not updated and can be updated manually.`,
-              duration: 5000,
+              description: `${profileText} to version ${newVersion}. You can now launch your browsers with the latest version.`,
+              duration: 6000,
             });
           } else {
             showToast({
+              id: `auto-update-success-${browser}-${newVersion}`,
               type: "success",
-              title: `${browserDisplayName} update ready`,
-              description:
-                "All affected profiles are currently running. Stop them and manually update their versions to use the new version.",
-              duration: 5000,
+              title: `${browserDisplayName} update completed`,
+              description: `Version ${newVersion} is now available. Running profiles will use the new version when restarted.`,
+              duration: 6000,
             });
           }
+
+          if (onProfilesUpdated) {
+            await onProfilesUpdated();
+          }
         } catch (downloadError) {
           console.error("Failed to download browser:", downloadError);
 
-          // Clean up auto-update tracking on error
-          try {
-            await invoke("remove_auto_update_download", {
-              browser,
-              version: newVersion,
-            });
-          } catch (e) {
-            console.error("Failed to clean up auto-update tracking:", e);
-          }
+          dismissToast(`download-${browser}-${newVersion}`);
 
           showToast({
+            id: `auto-update-error-${browser}-${newVersion}`,
             type: "error",
             title: `Failed to download ${browserDisplayName} ${newVersion}`,
             description: String(downloadError),
-            duration: 6000,
+            duration: 8000,
           });
           throw downloadError;
         }
-
-        // Refresh notifications to clear any remaining ones
-        await checkForUpdates();
       } catch (error) {
-        console.error("Failed to start update:", error);
-        const browserDisplayName = getBrowserDisplayName(browser);
-        showToast({
-          type: "error",
-          title: `Failed to update ${browserDisplayName}`,
-          description: String(error),
-          duration: 6000,
-        });
+        console.error("Failed to start auto-update:", error);
+        throw error;
       } finally {
+        // Clean up
+        activeDownloads.current.delete(downloadKey);
         setUpdatingBrowsers((prev) => {
           const next = new Set(prev);
           next.delete(browser);
@@ -158,54 +209,12 @@ export function useUpdateNotifications() {
         });
       }
     },
-    [notifications, checkForUpdates],
+    [onProfilesUpdated],
   );
 
-  const handleDismiss = useCallback(
-    async (notificationId: string) => {
-      if (!isClient) return; // Only run on client side
-
-      try {
-        toast.dismiss(notificationId);
-        await invoke("dismiss_update_notification", { notificationId });
-        await checkForUpdates();
-      } catch (error) {
-        console.error("Failed to dismiss notification:", error);
-      }
-    },
-    [checkForUpdates, isClient],
-  );
-
-  // Separate effect to show toasts when notifications change
-  useEffect(() => {
-    if (!isClient) return;
-
-    for (const notification of notifications) {
-      const isUpdating = updatingBrowsers.has(notification.browser);
-
-      toast.custom(
-        () => (
-          <UpdateNotificationComponent
-            notification={notification}
-            onUpdate={handleUpdate}
-            onDismiss={handleDismiss}
-            isUpdating={isUpdating}
-          />
-        ),
-        {
-          id: notification.id,
-          duration: Number.POSITIVE_INFINITY, // Persistent until user action
-          position: "top-right",
-          // Remove transparent styling to fix background issue
-          style: undefined,
-        },
-      );
-    }
-  }, [notifications, updatingBrowsers, handleUpdate, handleDismiss, isClient]);
-
   return {
     notifications,
+    isUpdating,
     checkForUpdates,
-    isUpdating: (browser: string) => updatingBrowsers.has(browser),
   };
 }

src/hooks/use-version-updater.ts

@@ -1,13 +1,14 @@
 import { getBrowserDisplayName } from "@/lib/browser-utils";
 import {
   dismissToast,
-  showLoadingToast,
-  showVersionUpdateToast,
+  showAutoUpdateToast,
+  showErrorToast,
+  showSuccessToast,
+  showUnifiedVersionUpdateToast,
 } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
 
 interface VersionUpdateProgress {
   current_browser: string;
@@ -32,6 +33,13 @@ interface BrowserVersionsResult {
   total_versions_count: number;
 }
 
+interface AutoUpdateEvent {
+  browser: string;
+  new_version: string;
+  notification_id: string;
+  affected_profiles: string[];
+}
+
 export function useVersionUpdater() {
   const [isUpdating, setIsUpdating] = useState(false);
   const [lastUpdateTime, setLastUpdateTime] = useState<number | null>(null);
@@ -39,6 +47,18 @@ export function useVersionUpdater() {
   const [updateProgress, setUpdateProgress] =
     useState<VersionUpdateProgress | null>(null);
 
+  const loadUpdateStatus = useCallback(async () => {
+    try {
+      const [lastUpdate, timeUntilNext] = await invoke<[number | null, number]>(
+        "get_version_update_status",
+      );
+      setLastUpdateTime(lastUpdate);
+      setTimeUntilNextUpdate(timeUntilNext);
+    } catch (error) {
+      console.error("Failed to load version update status:", error);
+    }
+  }, []);
+
   // Listen for version update progress events
   useEffect(() => {
     const unlisten = listen<VersionUpdateProgress>(
@@ -50,42 +70,35 @@ export function useVersionUpdater() {
         if (progress.status === "updating") {
           setIsUpdating(true);
 
-          if (progress.current_browser) {
-            const browserName = getBrowserDisplayName(progress.current_browser);
-            showVersionUpdateToast(
-              `Downloading release information for ${browserName}`,
-              {
-                id: "version-update-progress",
-                progress: {
-                  current: progress.completed_browsers + 1,
-                  total: progress.total_browsers,
-                  found: progress.new_versions_found,
-                },
-              },
-            );
-          } else {
-            showLoadingToast("Starting version update check...", {
-              id: "version-update-progress",
-              description: "Initializing browser version check...",
-            });
-          }
+          // Show unified progress toast
+          const currentBrowserName = progress.current_browser
+            ? getBrowserDisplayName(progress.current_browser)
+            : undefined;
+
+          showUnifiedVersionUpdateToast("Checking for browser updates...", {
+            description: currentBrowserName
+              ? `Fetching ${currentBrowserName} release information...`
+              : "Initializing version check...",
+            progress: {
+              current: progress.completed_browsers,
+              total: progress.total_browsers,
+              found: progress.new_versions_found,
+              current_browser: currentBrowserName,
+            },
+          });
         } else if (progress.status === "completed") {
           setIsUpdating(false);
           setUpdateProgress(null);
+          dismissToast("unified-version-update");
 
           if (progress.new_versions_found > 0) {
-            toast.success(
-              `Found ${progress.new_versions_found} new browser versions!`,
-              {
-                id: "version-update-progress",
-                duration: 4000,
-                description:
-                  "Version information has been updated in the background",
-              },
-            );
+            showSuccessToast("Browser versions updated successfully", {
+              duration: 5000,
+              description:
+                "Auto-downloads will start shortly for available updates.",
+            });
           } else {
-            toast.success("No new browser versions found", {
-              id: "version-update-progress",
+            showSuccessToast("No new browser versions found", {
               duration: 3000,
               description: "All browser versions are up to date",
             });
@@ -96,16 +109,115 @@ export function useVersionUpdater() {
         } else if (progress.status === "error") {
           setIsUpdating(false);
           setUpdateProgress(null);
+          dismissToast("unified-version-update");
 
-          toast.error("Failed to update browser versions", {
-            id: "version-update-progress",
-            duration: 4000,
+          showErrorToast("Failed to update browser versions", {
+            duration: 6000,
             description: "Check your internet connection and try again",
           });
         }
       },
     );
 
+    return () => {
+      void unlisten.then((fn) => {
+        fn();
+      });
+    };
+  }, [loadUpdateStatus]);
+
+  // Listen for browser auto-update events
+  useEffect(() => {
+    const unlisten = listen<AutoUpdateEvent>(
+      "browser-auto-update-available",
+      (event) => {
+        const handleAutoUpdate = async () => {
+          const { browser, new_version, notification_id } = event.payload;
+          console.log("Browser auto-update event received:", event.payload);
+
+          const browserDisplayName = getBrowserDisplayName(browser);
+
+          try {
+            // Show auto-update start notification
+            showAutoUpdateToast(browserDisplayName, new_version, {
+              description: `Downloading ${browserDisplayName} ${new_version} automatically. Progress will be shown below.`,
+            });
+
+            // Dismiss the update notification in the backend
+            await invoke("dismiss_update_notification", {
+              notificationId: notification_id,
+            });
+
+            // Check if browser already exists before downloading
+            const isDownloaded = await invoke<boolean>("check_browser_exists", {
+              browserStr: browser,
+              version: new_version,
+            });
+
+            if (isDownloaded) {
+              // Browser already exists, skip download and go straight to profile update
+              console.log(
+                `${browserDisplayName} ${new_version} already exists, skipping download`,
+              );
+
+              showSuccessToast(
+                `${browserDisplayName} ${new_version} already available`,
+                {
+                  description: "Updating profile configurations...",
+                  duration: 3000,
+                },
+              );
+            } else {
+              // Download the browser - this will trigger download progress events automatically
+              await invoke("download_browser", {
+                browserStr: browser,
+                version: new_version,
+              });
+            }
+
+            // Complete the update with auto-update of profile versions
+            const updatedProfiles = await invoke<string[]>(
+              "complete_browser_update_with_auto_update",
+              {
+                browser,
+                newVersion: new_version,
+              },
+            );
+
+            // Show success message based on whether profiles were updated
+            if (updatedProfiles.length > 0) {
+              const profileText =
+                updatedProfiles.length === 1
+                  ? `Profile "${updatedProfiles[0]}" has been updated`
+                  : `${updatedProfiles.length} profiles have been updated`;
+
+              showSuccessToast(`${browserDisplayName} update completed`, {
+                description: `${profileText} to version ${new_version}. You can now launch your browsers with the latest version.`,
+                duration: 6000,
+              });
+            } else {
+              showSuccessToast(`${browserDisplayName} update completed`, {
+                description: `Version ${new_version} is now available. Running profiles will use the new version when restarted.`,
+                duration: 6000,
+              });
+            }
+          } catch (error) {
+            console.error("Failed to handle browser auto-update:", error);
+            showErrorToast(`Failed to auto-update ${browserDisplayName}`, {
+              description:
+                error instanceof Error
+                  ? error.message
+                  : "Unknown error occurred",
+              duration: 8000,
+            });
+          }
+        };
+
+        // Call the async handler
+        void handleAutoUpdate();
+      },
+    );
+
     return () => {
       void unlisten.then((fn) => {
         fn();
@@ -125,19 +237,7 @@ export function useVersionUpdater() {
     return () => {
       clearInterval(interval);
     };
-  }, []);
-
-  const loadUpdateStatus = useCallback(async () => {
-    try {
-      const [lastUpdate, timeUntilNext] = await invoke<[number | null, number]>(
-        "get_version_update_status",
-      );
-      setLastUpdateTime(lastUpdate);
-      setTimeUntilNextUpdate(timeUntilNext);
-    } catch (error) {
-      console.error("Failed to load version update status:", error);
-    }
-  }, []);
+  }, [loadUpdateStatus]);
 
   const triggerManualUpdate = useCallback(async () => {
     try {
@@ -158,17 +258,17 @@ export function useVersionUpdater() {
       ).length;
 
       if (failedUpdates > 0) {
-        toast.warning("Update completed with some errors", {
+        showErrorToast("Update completed with some errors", {
           description: `${totalNewVersions} new versions found, ${failedUpdates} browsers failed to update`,
           duration: 5000,
         });
       } else if (totalNewVersions > 0) {
-        toast.success(`Found ${totalNewVersions} new browser versions!`, {
-          description: `Updated ${successfulUpdates} browsers successfully`,
+        showSuccessToast("Browser versions updated successfully", {
+          description: `Found ${totalNewVersions} new versions across ${successfulUpdates} browsers. Auto-downloads will start shortly.`,
           duration: 4000,
         });
       } else {
-        toast.success("No new browser versions found", {
+        showSuccessToast("No new browser versions found", {
           description: "All browser versions are up to date",
           duration: 3000,
         });
@@ -178,7 +278,7 @@ export function useVersionUpdater() {
       return results;
     } catch (error) {
       console.error("Failed to trigger manual update:", error);
-      toast.error("Failed to update browser versions", {
+      showErrorToast("Failed to update browser versions", {
         description:
           error instanceof Error ? error.message : "Unknown error occurred",
         duration: 4000,
@@ -200,7 +300,7 @@ export function useVersionUpdater() {
         // Show notification about new versions if any were found
         if (result.new_versions_count && result.new_versions_count > 0) {
           const browserName = getBrowserDisplayName(browserStr);
-          toast.success(
+          showSuccessToast(
             `Found ${result.new_versions_count} new ${browserName} versions!`,
             {
               duration: 3000,
@@ -219,18 +319,15 @@ export function useVersionUpdater() {
   );
 
   const formatTimeUntilUpdate = useCallback((seconds: number): string => {
-    if (seconds <= 0) return "Update overdue";
-
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-
-    if (hours > 0) {
-      return `${hours}h ${minutes}m`;
+    if (seconds < 60) {
+      return `${seconds} seconds`;
     }
-    if (minutes > 0) {
-      return `${minutes}m`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) {
+      return `${minutes} minute${minutes === 1 ? "" : "s"}`;
     }
-    return "< 1m";
+    const hours = Math.floor(minutes / 60);
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
   }, []);
 
   const formatLastUpdateTime = useCallback(

src/lib/browser-utils.ts

@@ -3,6 +3,7 @@
  * Centralized helpers for browser name mapping, icons, etc.
  */
 
+import { ZenBrowser } from "@/components/icons/zen-browser";
 import { FaChrome, FaFirefox } from "react-icons/fa";
 import { SiBrave, SiMullvad, SiTorbrowser } from "react-icons/si";
 
@@ -38,21 +39,10 @@ export function getBrowserIcon(browserType: string) {
     case "firefox-developer":
       return FaFirefox;
     case "zen":
-      return FaFirefox;
+      return ZenBrowser;
     case "tor-browser":
       return SiTorbrowser;
     default:
       return null;
   }
 }
-
-/**
- * Format browser name by capitalizing words and joining with spaces
- * (fallback method for simple transformations)
- */
-export function formatBrowserName(browserType: string): string {
-  return browserType
-    .split("-")
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
-}

src/lib/toast-utils.ts

@@ -2,29 +2,33 @@ import { UnifiedToast } from "@/components/custom-toast";
 import React from "react";
 import { toast as sonnerToast } from "sonner";
 
-// Define toast types locally
-export interface BaseToastProps {
+interface BaseToastProps {
   id?: string;
   title: string;
   description?: string;
   duration?: number;
 }
 
-export interface LoadingToastProps extends BaseToastProps {
+interface LoadingToastProps extends BaseToastProps {
   type: "loading";
 }
 
-export interface SuccessToastProps extends BaseToastProps {
+interface SuccessToastProps extends BaseToastProps {
   type: "success";
 }
 
-export interface ErrorToastProps extends BaseToastProps {
+interface ErrorToastProps extends BaseToastProps {
   type: "error";
 }
 
-export interface DownloadToastProps extends BaseToastProps {
+interface DownloadToastProps extends BaseToastProps {
   type: "download";
-  stage?: "downloading" | "extracting" | "verifying" | "completed";
+  stage?:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)";
   progress?: {
     percentage: number;
     speed?: string;
@@ -32,41 +36,33 @@ export interface DownloadToastProps extends BaseToastProps {
   };
 }
 
-export interface VersionUpdateToastProps extends BaseToastProps {
+interface VersionUpdateToastProps extends BaseToastProps {
   type: "version-update";
   progress?: {
     current: number;
     total: number;
     found: number;
+    current_browser?: string;
   };
 }
 
-export interface FetchingToastProps extends BaseToastProps {
-  type: "fetching";
-  browserName?: string;
-}
-
-export type ToastProps =
-  | LoadingToastProps
+type ToastProps =
   | SuccessToastProps
   | ErrorToastProps
   | DownloadToastProps
-  | VersionUpdateToastProps
-  | FetchingToastProps;
+  | LoadingToastProps
+  | VersionUpdateToastProps;
 
-// Unified toast function
 export function showToast(props: ToastProps & { id?: string }) {
   const toastId = props.id ?? `toast-${props.type}-${Date.now()}`;
 
-  // Improved duration logic - make toasts disappear more quickly
   let duration: number;
   if (props.duration !== undefined) {
     duration = props.duration;
   } else {
     switch (props.type) {
       case "loading":
-      case "fetching":
-        duration = 10000; // 10 seconds instead of infinite
+        duration = 10000;
         break;
       case "download":
         // Only keep infinite for active downloading, others get shorter durations
@@ -78,15 +74,15 @@ export function showToast(props: ToastProps & { id?: string }) {
           duration = 20000;
         }
         break;
-      case "version-update":
-        duration = 15000;
-        break;
       case "success":
         duration = 3000;
         break;
       case "error":
         duration = 10000;
         break;
+      case "version-update":
+        duration = 15000;
+        break;
       default:
         duration = 5000;
     }
@@ -101,6 +97,8 @@ export function showToast(props: ToastProps & { id?: string }) {
         border: "none",
         boxShadow: "none",
         padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
       },
     });
   } else if (props.type === "error") {
@@ -112,10 +110,12 @@ export function showToast(props: ToastProps & { id?: string }) {
         border: "none",
         boxShadow: "none",
         padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
       },
     });
   } else {
-    sonnerToast.custom((id) => React.createElement(UnifiedToast, props), {
+    sonnerToast.custom(() => React.createElement(UnifiedToast, props), {
       id: toastId,
       duration,
       style: {
@@ -123,6 +123,8 @@ export function showToast(props: ToastProps & { id?: string }) {
         border: "none",
         boxShadow: "none",
         padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
       },
     });
   }
@@ -130,26 +132,15 @@ export function showToast(props: ToastProps & { id?: string }) {
   return toastId;
 }
 
-// Convenience functions for common use cases
-export function showLoadingToast(
-  title: string,
-  options?: {
-    id?: string;
-    description?: string;
-    duration?: number;
-  },
-) {
-  return showToast({
-    type: "loading",
-    title,
-    ...options,
-  });
-}
-
 export function showDownloadToast(
   browserName: string,
   version: string,
-  stage: "downloading" | "extracting" | "verifying" | "completed",
+  stage:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)",
   progress?: { percentage: number; speed?: string; eta?: string },
   options?: { suppressCompletionToast?: boolean },
 ) {
@@ -160,7 +151,9 @@ export function showDownloadToast(
         ? `Downloading ${browserName} ${version}`
         : stage === "extracting"
           ? `Extracting ${browserName} ${version}`
-          : `Verifying ${browserName} ${version}`;
+          : stage === "downloading (twilight rolling release)"
+            ? `Downloading ${browserName} ${version}`
+            : `Verifying ${browserName} ${version}`;
 
   // Don't show completion toast if suppressed (for auto-update scenarios)
   if (stage === "completed" && options?.suppressCompletionToast) {
@@ -177,44 +170,6 @@ export function showDownloadToast(
   });
 }
 
-export function showVersionUpdateToast(
-  title: string,
-  options?: {
-    id?: string;
-    description?: string;
-    progress?: {
-      current: number;
-      total: number;
-      found: number;
-    };
-    duration?: number;
-  },
-) {
-  return showToast({
-    type: "version-update",
-    title,
-    ...options,
-  });
-}
-
-export function showFetchingToast(
-  browserName: string,
-  options?: {
-    id?: string;
-    description?: string;
-    duration?: number;
-  },
-) {
-  return showToast({
-    type: "fetching",
-    title: `Checking for new ${browserName} versions...`,
-    description:
-      options?.description ?? "Fetching latest release information...",
-    browserName,
-    ...options,
-  });
-}
-
 export function showSuccessToast(
   title: string,
   options?: {
@@ -245,12 +200,49 @@ export function showErrorToast(
   });
 }
 
-// Generic helper for dismissing toasts
+export function showAutoUpdateToast(
+  browserName: string,
+  version: string,
+  options?: {
+    id?: string;
+    description?: string;
+    duration?: number;
+  },
+) {
+  return showToast({
+    type: "loading",
+    title: `${browserName} update started`,
+    description:
+      options?.description ??
+      `Automatically downloading ${browserName} ${version}. Progress will be shown in download notifications.`,
+    id: options?.id ?? `auto-update-${browserName.toLowerCase()}-${version}`,
+    duration: options?.duration ?? 4000,
+  });
+}
+
 export function dismissToast(id: string) {
   sonnerToast.dismiss(id);
 }
 
-// Dismiss all toasts
-export function dismissAllToasts() {
-  sonnerToast.dismiss();
+export function showUnifiedVersionUpdateToast(
+  title: string,
+  options?: {
+    id?: string;
+    description?: string;
+    progress?: {
+      current: number;
+      total: number;
+      found: number;
+      current_browser?: string;
+    };
+    duration?: number;
+  },
+) {
+  return showToast({
+    type: "version-update",
+    title,
+    id: "unified-version-update",
+    duration: Number.POSITIVE_INFINITY, // Keep showing until completed
+    ...options,
+  });
 }

src/styles/globals.css

@@ -123,3 +123,23 @@
     @apply bg-background text-foreground;
   }
 }
+
+/* Ensure Sonner toasts appear above all dialogs and remain interactive */
+.toaster,
+[data-sonner-toaster] {
+  z-index: 99999 !important;
+  pointer-events: auto !important;
+}
+
+[data-sonner-toast] {
+  z-index: 99999 !important;
+  pointer-events: auto !important;
+}
+
+/* Ensure toast buttons and interactive elements work */
+[data-sonner-toast] button,
+[data-sonner-toast] [role="button"],
+[data-sonner-toast] input,
+[data-sonner-toast] select {
+  pointer-events: auto !important;
+}

src/types.ts

@@ -3,6 +3,8 @@ export interface ProxySettings {
   proxy_type: string; // "http", "https", "socks4", or "socks5"
   host: string;
   port: number;
+  username?: string;
+  password?: string;
 }
 
 export interface TableSortingSettings {
@@ -18,4 +20,26 @@ export interface BrowserProfile {
   proxy?: ProxySettings;
   process_id?: number;
   last_launch?: number;
+  release_type: string; // "stable" or "nightly"
+}
+
+export interface DetectedProfile {
+  browser: string;
+  name: string;
+  path: string;
+  description: string;
+}
+
+export interface BrowserReleaseTypes {
+  stable?: string;
+  nightly?: string;
+}
+
+export interface AppUpdateInfo {
+  current_version: string;
+  new_version: string;
+  release_notes: string;
+  download_url: string;
+  is_nightly: boolean;
+  published_at: string;
 }

tailwind.config.js

@@ -0,0 +1,13 @@
+export default {
+  darkMode: "class",
+  theme: {
+    extend: {
+      colors: {
+        black: "#000000",
+      },
+      backgroundColor: {
+        dark: "#000000",
+      },
+    },
+  },
+};