chore: reset lock file

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

.github/dependabot.yml

@@ -1,4 +1,5 @@
 version: 2
+
 updates:
   # Frontend dependencies (root package.json)
   - package-ecosystem: "npm"
@@ -13,9 +14,6 @@ updates:
       frontend-dependencies:
         patterns:
           - "*"
-    ignore:
-      - dependency-name: "eslint"
-        versions: ">= 9"
     commit-message:
       prefix: "deps"
       include: "scope"

.github/workflows/codeql.yml

@@ -27,35 +27,69 @@ jobs:
             build-mode: none
           - language: javascript-typescript
             build-mode: none
+          # - language: rust
+          #   build-mode: none
     steps:
       - name: Checkout repository
-        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: Setup Rust
+        uses: dtolnay/rust-toolchain@b3b07ba8b418998c39fb20f53e8b695cdcc8de1b #master
+        with:
+          toolchain: stable
+          targets: x86_64-unknown-linux-gnu
+
+      - name: Install system dependencies (Rust only)
+        if: matrix.language == 'rust'
+        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@98c8021b550208e191a6a3145459bfc9fb29c4c0 #v2.8.0
+        with:
+          workdir: ./src-tauri
+
       - name: Install dependencies from lockfile
         run: pnpm install --frozen-lockfile
+        
+      - name: Install rust dependencies
+        if: matrix.language == 'rust'
+        working-directory: ./src-tauri
+        run: |
+          cargo build
+        
+      - name: Build nodecar sidecar
+        if: matrix.language == 'rust'
+        shell: bash
+        working-directory: ./nodecar
+        run: |
+          pnpm run build:linux-x64
+
+      - name: Copy nodecar binary to Tauri binaries
+        if: matrix.language == 'rust'
+        shell: bash
+        run: |
+          mkdir -p src-tauri/binaries
+          cp nodecar/dist/nodecar src-tauri/binaries/nodecar-x86_64-unknown-linux-gnu
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        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@v3
+        uses: github/codeql-action/analyze@b1e4dc3db58c9601794e22a9f6d28d45461b9dbf #v3.29.0
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/contributors.yml

@@ -0,0 +1,21 @@
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  contrib-readme-job:
+    runs-on: ubuntu-latest
+    name: Automatically update the contributors list in the README
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Contribute List
+        uses: akhilmhdh/contributors-readme-action@1ff4c56187458b34cd602aee93e897344ce34bfc #v2.3.10
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/dependabot-automerge.yml

@@ -0,0 +1,84 @@
+name: Dependabot Automerge
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  pull-requests: write
+  contents: write
+  checks: read
+
+jobs:
+  security-scan:
+    name: Security Vulnerability Scan
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
+    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: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@08eff52bf64351f401fb50d4972fa95b9f2c2d1b #v2.4.0
+        secrets: inherit
+        with:
+          compat-lookup: true
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Auto-merge minor and patch updates
+        uses: ridedott/merge-me-action@338053c6f9b9311a6be80208f6f0723981e40627 #v2.10.122
+        secrets: inherit
+        with:
+          GITHUB_TOKEN: ${{ secrets.SECRET_DEPENDABOT_GITHUB_TOKEN }}
+          MERGE_METHOD: SQUASH
+          PRESET: DEPENDABOT_MINOR
+          MAXIMUM_RETRIES: 5
+    timeout-minutes: 10

.github/workflows/greetings.yml

@@ -0,0 +1,16 @@
+name: Greetings
+
+on: [pull_request_target, issues]
+
+jobs:
+  greeting:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/first-interaction@34f15e814fe48ac9312ccf29db4e74fa767cbab7 #v1.3.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          issue-message: "Thank you for your first issue ❤️ If it's a feature request, please make sure it's clear what you want, why you want it, and how important it is to you. If you posted a bug report, please make sure it includes as much detail as possible."
+          pr-message: "Welcome to the community and thank you for your first contribution ❤️ A human will review your PR shortly. Make sure that the pipelines are green, so that the PR is considered ready for a review and could be merged."

.github/workflows/issue-validation.yml

@@ -0,0 +1,173 @@
+name: Issue Validation
+
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  issues: write
+  models: read
+
+jobs:
+  validate-issue:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
+
+      - name: Get issue templates
+        id: get-templates
+        run: |
+          # Read the issue templates
+          if [ -f ".github/ISSUE_TEMPLATE/01-bug-report.md" ]; then
+            echo "bug-template-exists=true" >> $GITHUB_OUTPUT
+          fi
+
+          if [ -f ".github/ISSUE_TEMPLATE/02-feature-request.md" ]; then
+            echo "feature-template-exists=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create issue analysis prompt
+        id: create-prompt
+        env:
+          ISSUE_TITLE: ${{ github.event.issue.title }}
+          ISSUE_BODY: ${{ github.event.issue.body }}
+          ISSUE_LABELS: ${{ join(github.event.issue.labels.*.name, ', ') }}
+        run: |
+          cat > issue_analysis.txt << EOF
+          ## Issue Content to Analyze:
+
+          **Title:** $ISSUE_TITLE
+
+          **Body:**
+          $ISSUE_BODY
+
+          **Labels:** $ISSUE_LABELS
+          EOF
+
+      - name: Validate issue with AI
+        id: validate
+        uses: actions/ai-inference@d645f067d89ee1d5d736a5990e327e504d1c5a4a # v1.1.0
+        with:
+          prompt-file: issue_analysis.txt
+          system-prompt: |
+            You are an issue validation assistant for Donut Browser, an browser orchestrator. 
+
+            Analyze the provided issue content and determine if it contains sufficient information based on these requirements:
+
+            **For Bug Reports, the issue should include:**
+            1. Clear description of the problem
+            2. Steps to reproduce the issue (numbered list preferred)
+            3. Expected vs actual behavior
+            4. Environment information (OS, browser version, etc.)
+            5. Error messages, stack traces, or screenshots if applicable
+
+            **For Feature Requests, the issue should include:**
+            1. Clear description of the requested feature
+            2. Use case or problem it solves
+            3. Proposed solution or how it should work
+            4. Priority level or importance
+
+            **General Requirements for all issues:**
+            1. Descriptive title
+            2. Sufficient detail to understand and act upon
+            3. Professional tone and clear communication
+
+            Respond in JSON format with the following structure:
+            ```json
+            {
+              "is_valid": true|false,
+              "issue_type": "bug_report"|"feature_request"|"other",
+              "missing_info": [
+                "List of missing required information"
+              ],
+              "suggestions": [
+                "Specific suggestions for improvement"
+              ],
+              "overall_assessment": "Brief assessment of the issue quality"
+            }
+            ```
+
+            Be constructive and helpful in your feedback. If the issue is incomplete, provide specific guidance on what's needed.
+          model: gpt-4o
+
+      - name: Parse validation result and take action
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Get the AI response
+          VALIDATION_RESULT='${{ steps.validate.outputs.response }}'
+
+          # Extract JSON from the response (handle potential markdown formatting)
+          JSON_RESULT=$(echo "$VALIDATION_RESULT" | sed -n '/```json/,/```/p' | sed '1d;$d' || echo "$VALIDATION_RESULT")
+
+          # Parse JSON fields
+          IS_VALID=$(echo "$JSON_RESULT" | jq -r '.is_valid // false')
+          ISSUE_TYPE=$(echo "$JSON_RESULT" | jq -r '.issue_type // "other"')
+          MISSING_INFO=$(echo "$JSON_RESULT" | jq -r '.missing_info[]? // empty' | sed 's/^/- /')
+          SUGGESTIONS=$(echo "$JSON_RESULT" | jq -r '.suggestions[]? // empty' | sed 's/^/- /')
+          ASSESSMENT=$(echo "$JSON_RESULT" | jq -r '.overall_assessment // "No assessment provided"')
+
+          echo "Issue validation result: $IS_VALID"
+          echo "Issue type: $ISSUE_TYPE"
+
+          if [ "$IS_VALID" = "false" ]; then
+            # Create a comment asking for more information
+            cat > comment.md << EOF
+          ## 🤖 Issue Validation
+
+          Thank you for submitting this issue! However, it appears that some required information might be missing to help us better understand and address your concern.
+
+          **Issue Type Detected:** \`$ISSUE_TYPE\`
+
+          **Assessment:** $ASSESSMENT
+
+          ### 📋 Missing Information:
+          $MISSING_INFO
+
+          ### 💡 Suggestions for Improvement:
+          $SUGGESTIONS
+
+          ### 📝 How to Provide Additional Information:
+
+          Please edit your original issue description to include the missing information. Here are our issue templates for reference:
+
+          - **Bug Report Template:** [View Template](.github/ISSUE_TEMPLATE/01-bug-report.md)
+          - **Feature Request Template:** [View Template](.github/ISSUE_TEMPLATE/02-feature-request.md)
+
+          ### 🔧 Quick Tips:
+          - For **bug reports**: Include step-by-step reproduction instructions, your environment details, and any error messages
+          - For **feature requests**: Describe the use case, expected behavior, and why this feature would be valuable
+          - Add **screenshots** or **logs** when applicable
+
+          Once you've updated the issue with the missing information, feel free to remove this comment or reply to let us know you've made the updates.
+
+          ---
+          *This validation was performed automatically to ensure we have all the information needed to help you effectively.*
+          EOF
+
+            # Post the comment
+            gh issue comment ${{ github.event.issue.number }} --body-file comment.md
+            
+            # Add a label to indicate validation needed
+            gh issue edit ${{ github.event.issue.number }} --add-label "needs-info"
+            
+            echo "✅ Validation comment posted and 'needs-info' label added"
+          else
+            echo "✅ Issue contains sufficient information"
+            
+            # Add appropriate labels based on issue type
+            case "$ISSUE_TYPE" in
+              "bug_report")
+                gh issue edit ${{ github.event.issue.number }} --add-label "bug"
+                ;;
+              "feature_request")
+                gh issue edit ${{ github.event.issue.number }} --add-label "enhancement"
+                ;;
+            esac
+          fi
+
+      - name: Cleanup
+        run: |
+          rm -f issue_analysis.txt comment.md

.github/workflows/lint-js.yml

@@ -16,6 +16,9 @@ on:
       - ".github/workflows/lint-rs.yml"
       - ".github/workflows/osv.yml"
 
+permissions:
+  contents: read
+
 jobs:
   build:
     strategy:
@@ -31,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
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 #v4.4.0
         with:
           node-version-file: .node-version
           cache: "pnpm"
@@ -45,10 +48,5 @@ jobs:
       - name: Install dependencies from lockfile
         run: pnpm install --frozen-lockfile
 
-      - name: Install nodecar dependencies
-        working-directory: ./nodecar
-        run: |
-          pnpm install --frozen-lockfile
-
       - name: Run lint step
         run: pnpm run lint:js

.github/workflows/lint-rs.yml

@@ -24,6 +24,9 @@ on:
       - "tsconfig.json"
       - "biome.json"
 
+permissions:
+  contents: read
+
 jobs:
   build:
     strategy:
@@ -39,20 +42,21 @@ 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
@@ -67,11 +71,6 @@ jobs:
       - name: Install frontend dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Install nodecar dependencies
-        working-directory: ./nodecar
-        run: |
-          pnpm install --frozen-lockfile
-
       - name: Build nodecar binary
         shell: bash
         working-directory: ./nodecar

.github/workflows/osv.yml

@@ -50,7 +50,7 @@ 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
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
     with:
       scan-args: |-
         -r
@@ -63,7 +63,7 @@ jobs:
   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
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
     with:
       scan-args: |-
         -r

.github/workflows/pr-checks.yml

@@ -16,16 +16,20 @@ jobs:
     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
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
     with:
       scan-args: |-
         -r

.github/workflows/release-notes-generator.yml

@@ -0,0 +1,118 @@
+name: Generate Release Notes
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+  models: read
+
+jobs:
+  generate-release-notes:
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v') && !github.event.release.prerelease
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
+        with:
+          fetch-depth: 0 # Fetch full history to compare with previous release
+
+      - name: Get previous release tag
+        id: get-previous-tag
+        run: |
+          # Get the previous release tag (excluding the current one)
+          CURRENT_TAG="${{ github.ref_name }}"
+          PREVIOUS_TAG=$(git tag --sort=-version:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | grep -v "$CURRENT_TAG" | head -n 1)
+
+          if [ -z "$PREVIOUS_TAG" ]; then
+            echo "No previous release found, using initial commit"
+            PREVIOUS_TAG=$(git rev-list --max-parents=0 HEAD)
+          fi
+
+          echo "current-tag=$CURRENT_TAG" >> $GITHUB_OUTPUT
+          echo "previous-tag=$PREVIOUS_TAG" >> $GITHUB_OUTPUT
+          echo "Previous release: $PREVIOUS_TAG"
+          echo "Current release: $CURRENT_TAG"
+
+      - name: Get commit messages between releases
+        id: get-commits
+        run: |
+          # Get commit messages between previous and current release
+          PREVIOUS_TAG="${{ steps.get-previous-tag.outputs.previous-tag }}"
+          CURRENT_TAG="${{ steps.get-previous-tag.outputs.current-tag }}"
+
+          # Get commit log with detailed format
+          COMMIT_LOG=$(git log --pretty=format:"- %s (%h by %an)" $PREVIOUS_TAG..$CURRENT_TAG --no-merges)
+
+          # Get changed files summary
+          CHANGED_FILES=$(git diff --name-status $PREVIOUS_TAG..$CURRENT_TAG | head -20)
+
+          # Save to files for AI processing
+          echo "$COMMIT_LOG" > commits.txt
+          echo "$CHANGED_FILES" > changes.txt
+
+          echo "commits-file=commits.txt" >> $GITHUB_OUTPUT
+          echo "changes-file=changes.txt" >> $GITHUB_OUTPUT
+
+      - name: Generate release notes with AI
+        id: generate-notes
+        uses: actions/ai-inference@d645f067d89ee1d5d736a5990e327e504d1c5a4a # v1.1.0
+        with:
+          prompt-file: commits.txt
+          system-prompt: |
+            You are an expert technical writer tasked with generating comprehensive release notes for Donut Browser, a powerful browser orchestrator.
+
+            Analyze the provided commit messages and generate well-structured release notes following this format:
+
+            ## What's New in ${{ steps.get-previous-tag.outputs.current-tag }}
+
+            [Brief 1-2 sentence overview of the release]
+
+            ### ✨ New Features
+            [List new features with brief descriptions]
+
+            ### 🐛 Bug Fixes  
+            [List bug fixes]
+
+            ### 🔧 Improvements
+            [List improvements and enhancements]
+
+            ### 📚 Documentation
+            [List documentation updates if any]
+
+            ### 🔄 Dependencies
+            [List dependency updates if any]
+
+            ### 🛠️ Developer Experience
+            [List development-related changes if any]
+
+            Guidelines:
+            - Use clear, user-friendly language
+            - Group related commits logically
+            - Omit minor commits like formatting, typos unless significant
+            - Focus on user-facing changes
+            - Use emojis sparingly and consistently
+            - Keep descriptions concise but informative
+            - If commits are unclear, infer the purpose from the context
+
+            The application is a desktop app built with Tauri + Next.js that helps users manage multiple browser profiles with proxy support.
+          model: gpt-4o
+
+      - name: Update release with generated notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Get the generated release notes
+          RELEASE_NOTES="${{ steps.generate-notes.outputs.response }}"
+
+          # Update the release with the generated notes
+          gh api --method PATCH /repos/${{ github.repository }}/releases/${{ github.event.release.id }} \
+            --field body="$RELEASE_NOTES"
+
+          echo "✅ Release notes updated successfully!"
+
+      - name: Cleanup
+        run: |
+          rm -f commits.txt changes.txt

.github/workflows/release.yml

@@ -13,7 +13,7 @@ env:
 jobs:
   security-scan:
     name: Security Vulnerability Scan
-    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
     with:
       scan-args: |-
         -r
@@ -31,11 +31,15 @@ jobs:
     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
@@ -51,6 +55,8 @@ jobs:
     name: Spell Check
     uses: ./.github/workflows/spellcheck.yml
     secrets: inherit
+    permissions:
+      contents: read
 
   release:
     needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
@@ -99,19 +105,20 @@ 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)
@@ -121,18 +128,13 @@ jobs:
           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@98c8021b550208e191a6a3145459bfc9fb29c4c0 #v2.8.0
         with:
           workdir: ./src-tauri
 
       - name: Install frontend dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Install nodecar dependencies
-        working-directory: ./nodecar
-        run: |
-          pnpm install --frozen-lockfile
-
       - name: Build nodecar sidecar
         shell: bash
         working-directory: ./nodecar
@@ -153,7 +155,7 @@ jobs:
         run: pnpm build
 
       - name: Build Tauri app
-        uses: tauri-apps/tauri-action@v0
+        uses: tauri-apps/tauri-action@564aea5a8075c7a54c167bb0cf5b3255314a7f9d #v0.5.22
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           GITHUB_REF_NAME: ${{ github.ref_name }}
@@ -166,7 +168,7 @@ jobs:
           args: ${{ matrix.args }}
 
       - name: Commit CHANGELOG.md
-        uses: stefanzweifel/git-auto-commit-action@v6
+        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]"

.github/workflows/rolling-release.yml

@@ -12,7 +12,7 @@ env:
 jobs:
   security-scan:
     name: Security Vulnerability Scan
-    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@40a8940a65eab1544a6af759e43d936201a131a2" # v2.0.3
     with:
       scan-args: |-
         -r
@@ -30,11 +30,15 @@ jobs:
     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
@@ -50,6 +54,8 @@ jobs:
     name: Spell Check
     uses: ./.github/workflows/spellcheck.yml
     secrets: inherit
+    permissions:
+      contents: read
 
   rolling-release:
     needs: [security-scan, lint-js, lint-rust, codeql, spellcheck]
@@ -98,19 +104,20 @@ 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)
@@ -120,18 +127,13 @@ jobs:
           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@98c8021b550208e191a6a3145459bfc9fb29c4c0 #v2.8.0
         with:
           workdir: ./src-tauri
 
       - name: Install frontend dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Install nodecar dependencies
-        working-directory: ./nodecar
-        run: |
-          pnpm install --frozen-lockfile
-
       - name: Build nodecar sidecar
         shell: bash
         working-directory: ./nodecar
@@ -161,7 +163,7 @@ jobs:
           echo "Generated timestamp: ${TIMESTAMP}-${COMMIT_HASH}"
 
       - name: Build Tauri app
-        uses: tauri-apps/tauri-action@v0
+        uses: tauri-apps/tauri-action@564aea5a8075c7a54c167bb0cf5b3255314a7f9d #v0.5.22
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           BUILD_TAG: "nightly-${{ steps.timestamp.outputs.timestamp }}"

.github/workflows/spellcheck.yml

@@ -21,6 +21,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Actions Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 #v4.2.2
       - name: Spell Check Repo
-        uses: crate-ci/typos@v1.33.1
+        uses: crate-ci/typos@392b78fe18a52790c53f42456e46124f77346842 #v1.34.0

.github/workflows/stale.yml

@@ -0,0 +1,21 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+    - cron: "35 23 * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: "This issue has been inactive for 60 days. Please respond to keep it open."
+          stale-pr-message: "This pull request has been inactive for 60 days. Please respond to keep it open."
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"

.gitignore

@@ -46,7 +46,4 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 
-# eslint
-.eslintcache
-
 !**/.gitkeep

.vscode/settings.json

@@ -1,12 +1,14 @@
 {
   "cSpell.words": [
     "ahooks",
+    "akhilmhdh",
     "appimage",
     "appindicator",
     "applescript",
     "autoconfig",
     "autologin",
     "biomejs",
+    "camoufox",
     "cdylib",
     "CFURL",
     "checkin",
@@ -14,6 +16,8 @@
     "clippy",
     "cmdk",
     "codegen",
+    "CTYPE",
+    "datareporting",
     "devedition",
     "doesn",
     "donutbrowser",
@@ -21,15 +25,22 @@
     "dtolnay",
     "dyld",
     "elif",
+    "errorlevel",
+    "esac",
     "esbuild",
-    "eslintcache",
     "frontmost",
+    "geoip",
+    "gettimezone",
     "gifs",
     "gsettings",
+    "healthreport",
+    "hkcu",
     "icns",
     "idletime",
+    "Inno",
     "KHTML",
     "launchservices",
+    "letterboxing",
     "libatk",
     "libayatana",
     "libcairo",
@@ -38,18 +49,27 @@
     "libpango",
     "librsvg",
     "libwebkit",
+    "libxdo",
+    "localtime",
+    "mmdb",
     "mountpoint",
+    "msiexec",
     "msvc",
     "msys",
     "Mullvad",
     "mullvadbrowser",
     "nodecar",
+    "nodemon",
+    "norestart",
+    "NSIS",
     "ntlm",
     "objc",
     "orhun",
     "osascript",
+    "peerconnection",
     "pixbuf",
     "plasmohq",
+    "prefs",
     "propertylist",
     "reqwest",
     "ridedott",
@@ -60,26 +80,39 @@
     "shadcn",
     "signon",
     "sonner",
+    "splitn",
     "sspi",
     "staticlib",
     "stefanzweifel",
     "subdirs",
+    "subkey",
+    "SUPPRESSMSGBOXES",
     "swatinem",
     "sysinfo",
     "systempreferences",
+    "systemsetup",
     "taskkill",
+    "tasklist",
     "tauri",
+    "TERX",
+    "timedatectl",
     "titlebar",
     "Torbrowser",
+    "trackingprotection",
     "turbopack",
+    "udeps",
     "unlisten",
     "unminimize",
     "unrs",
     "urlencoding",
     "vercel",
+    "VERYSILENT",
+    "webgl",
+    "webrtc",
     "winreg",
     "wiremock",
     "xattr",
-    "zhom"
+    "zhom",
+    "zoneinfo"
   ]
 }

CONTRIBUTING.md

@@ -149,43 +149,6 @@ Refs #00000
 
 - Ensure that "Allow edits from maintainers" option is checked
 
-## Types of Contributions
-
-### Bug Reports
-
-When filing bug reports, please include:
-
-- Clear description of the issue
-- Steps to reproduce
-- Expected vs actual behavior
-- Environment details (OS, version, etc.)
-- Screenshots or error logs if applicable
-
-### Feature Requests
-
-When suggesting new features:
-
-- Explain the use case and why it's valuable
-- Describe the desired behavior
-- Consider alternatives you've thought of
-- Check if it aligns with our roadmap
-
-### Code Contributions
-
-- Bug fixes
-- New features
-- Performance improvements
-- Documentation updates
-- Test coverage improvements
-
-### Documentation
-
-- README improvements
-- Code comments
-- API documentation
-- Tutorial content
-- Translation work
-
 ## Architecture Overview
 
 Donut Browser is built with:

README.md

@@ -83,6 +83,24 @@ Have questions or want to contribute? We'd love to hear from you!
  </picture>
 </a>
 
+## Contributors
+
+<!-- readme: collaborators,contributors -start -->
+<table>
+	<tbody>
+		<tr>
+            <td align="center">
+                <a href="https://github.com/zhom">
+                    <img src="https://avatars.githubusercontent.com/u/2717306?v=4" width="100;" alt="zhom"/>
+                    <br />
+                    <sub><b>zhom</b></sub>
+                </a>
+            </td>
+		</tr>
+	<tbody>
+</table>
+<!-- readme: collaborators,contributors -end -->
+
 ## 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.

biome.json

@@ -1,22 +1,18 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.0.6/schema.json",
   "vcs": {
     "enabled": false,
     "clientKind": "git",
     "useIgnoreFile": false
   },
   "files": {
-    "ignoreUnknown": false,
-    "ignore": []
+    "ignoreUnknown": false
   },
   "formatter": {
     "enabled": true,
     "indentStyle": "space",
     "indentWidth": 2
   },
-  "organizeImports": {
-    "enabled": true
-  },
   "linter": {
     "enabled": true,
     "rules": {
@@ -25,17 +21,7 @@
         "useHookAtTopLevel": "error"
       },
       "nursery": {
-        "useGoogleFontDisplay": "error",
-        "noDocumentImportInPage": "error",
-        "noHeadElement": "error",
-        "noHeadImportInDocument": "error",
-        "noImgElement": "off",
-        "useComponentExportOnlyModules": {
-          "level": "error",
-          "options": {
-            "allowExportNames": ["metadata", "badgeVariants", "buttonVariants"]
-          }
-        }
+        "useUniqueElementIds": "off"
       },
       "a11y": {
         "useSemanticElements": "off"

eslint.config.mjs

@@ -1,92 +0,0 @@
-import { FlatCompat } from "@eslint/eslintrc";
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
-
-const compat = new FlatCompat({
-  baseDirectory: import.meta.dirname,
-});
-
-const eslintConfig = tseslint.config(
-  eslint.configs.recommended,
-  tseslint.configs.strictTypeChecked,
-  tseslint.configs.stylisticTypeChecked,
-  ...compat.extends("next/core-web-vitals"),
-  {
-    // Disabled rules taken from https://biomejs.dev/linter/rules-sources for ones that
-    // are already handled by Prettier and TypeScript or are not needed
-    rules: {
-      // eslint-plugin-jsx-a11y rules - some disabled for performance/specific project needs
-      "jsx-a11y/alt-text": "off",
-      "jsx-a11y/anchor-has-content": "off",
-      "jsx-a11y/anchor-is-valid": "off",
-      "jsx-a11y/aria-activedescendant-has-tabindex": "off",
-      "jsx-a11y/aria-props": "off",
-      "jsx-a11y/aria-proptypes": "off",
-      "jsx-a11y/aria-role": "off",
-      "jsx-a11y/aria-unsupported-elements": "off",
-      "jsx-a11y/autocomplete-valid": "off",
-      "jsx-a11y/click-events-have-key-events": "off",
-      "jsx-a11y/heading-has-content": "off",
-      "jsx-a11y/html-has-lang": "off",
-      "jsx-a11y/iframe-has-title": "off",
-      "jsx-a11y/img-redundant-alt": "off",
-      "jsx-a11y/interactive-supports-focus": "off",
-      "jsx-a11y/label-has-associated-control": "off",
-      "jsx-a11y/lang": "off",
-      "jsx-a11y/media-has-caption": "off",
-      "jsx-a11y/mouse-events-have-key-events": "off",
-      "jsx-a11y/no-access-key": "off",
-      "jsx-a11y/no-aria-hidden-on-focusable": "off",
-      "jsx-a11y/no-autofocus": "off",
-      "jsx-a11y/no-distracting-elements": "off",
-      "jsx-a11y/no-interactive-element-to-noninteractive-role": "off",
-      "jsx-a11y/no-noninteractive-element-to-interactive-role": "off",
-      "jsx-a11y/no-noninteractive-tabindex": "off",
-      "jsx-a11y/no-redundant-roles": "off",
-      "jsx-a11y/no-static-element-interactions": "off",
-      "jsx-a11y/prefer-tag-over-role": "off",
-      "jsx-a11y/role-has-required-aria-props": "off",
-      "jsx-a11y/role-supports-aria-props": "off",
-      "jsx-a11y/scope": "off",
-      "jsx-a11y/tabindex-no-positive": "off",
-      // eslint-plugin-react rules - some disabled for performance/specific project needs
-      "react/button-has-type": "off",
-      "react/jsx-boolean-value": "off",
-      "react/jsx-curly-brace-presence": "off",
-      "react/jsx-fragments": "off",
-      "react/jsx-key": "off",
-      "react/jsx-no-comment-textnodes": "off",
-      "react/jsx-no-duplicate-props": "off",
-      "react/jsx-no-target-blank": "off",
-      "react/jsx-no-useless-fragment": "off",
-      "react/no-array-index-key": "off",
-      "react/no-children-prop": "off",
-      "react/no-danger": "off",
-      "react/no-danger-with-children": "off",
-      "react/void-dom-elements-no-children": "off",
-      // eslint-plugin-react-hooks rules - disabled for specific project needs
-      "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/no-explicit-any": "off",
-      "@typescript-eslint/require-await": "off",
-      // Custom rules
-      "@typescript-eslint/restrict-template-expressions": [
-        "error",
-        {
-          allowNumber: true,
-          allowBoolean: true,
-          allowNever: true,
-        },
-      ],
-    },
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-  }
-);
-
-export default eslintConfig;

nodecar/eslint.config.mjs

@@ -1,90 +0,0 @@
-import { FlatCompat } from "@eslint/eslintrc";
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
-
-const compat = new FlatCompat({
-  baseDirectory: import.meta.dirname,
-});
-
-const eslintConfig = tseslint.config(
-  eslint.configs.recommended,
-  ...compat.extends("next/core-web-vitals"),
-  {
-    // Disabled rules taken from https://biomejs.dev/linter/rules-sources for ones that
-    // are already handled by Prettier and TypeScript or are not needed
-    rules: {
-      // eslint-plugin-jsx-a11y rules - some disabled for performance/specific project needs
-      "jsx-a11y/alt-text": "off",
-      "jsx-a11y/anchor-has-content": "off",
-      "jsx-a11y/anchor-is-valid": "off",
-      "jsx-a11y/aria-activedescendant-has-tabindex": "off",
-      "jsx-a11y/aria-props": "off",
-      "jsx-a11y/aria-proptypes": "off",
-      "jsx-a11y/aria-role": "off",
-      "jsx-a11y/aria-unsupported-elements": "off",
-      "jsx-a11y/autocomplete-valid": "off",
-      "jsx-a11y/click-events-have-key-events": "off",
-      "jsx-a11y/heading-has-content": "off",
-      "jsx-a11y/html-has-lang": "off",
-      "jsx-a11y/iframe-has-title": "off",
-      "jsx-a11y/img-redundant-alt": "off",
-      "jsx-a11y/interactive-supports-focus": "off",
-      "jsx-a11y/label-has-associated-control": "off",
-      "jsx-a11y/lang": "off",
-      "jsx-a11y/media-has-caption": "off",
-      "jsx-a11y/mouse-events-have-key-events": "off",
-      "jsx-a11y/no-access-key": "off",
-      "jsx-a11y/no-aria-hidden-on-focusable": "off",
-      "jsx-a11y/no-autofocus": "off",
-      "jsx-a11y/no-distracting-elements": "off",
-      "jsx-a11y/no-interactive-element-to-noninteractive-role": "off",
-      "jsx-a11y/no-noninteractive-element-to-interactive-role": "off",
-      "jsx-a11y/no-noninteractive-tabindex": "off",
-      "jsx-a11y/no-redundant-roles": "off",
-      "jsx-a11y/no-static-element-interactions": "off",
-      "jsx-a11y/prefer-tag-over-role": "off",
-      "jsx-a11y/role-has-required-aria-props": "off",
-      "jsx-a11y/role-supports-aria-props": "off",
-      "jsx-a11y/scope": "off",
-      "jsx-a11y/tabindex-no-positive": "off",
-      // eslint-plugin-react rules - some disabled for performance/specific project needs
-      "react/button-has-type": "off",
-      "react/jsx-boolean-value": "off",
-      "react/jsx-curly-brace-presence": "off",
-      "react/jsx-fragments": "off",
-      "react/jsx-key": "off",
-      "react/jsx-no-comment-textnodes": "off",
-      "react/jsx-no-duplicate-props": "off",
-      "react/jsx-no-target-blank": "off",
-      "react/jsx-no-useless-fragment": "off",
-      "react/no-array-index-key": "off",
-      "react/no-children-prop": "off",
-      "react/no-danger": "off",
-      "react/no-danger-with-children": "off",
-      "react/void-dom-elements-no-children": "off",
-      // eslint-plugin-react-hooks rules - disabled for specific project needs
-      "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/no-explicit-any": "off",
-      "@typescript-eslint/require-await": "off",
-      // Custom rules
-      "@typescript-eslint/restrict-template-expressions": [
-        "error",
-        {
-          allowNumber: true,
-          allowBoolean: true,
-          allowNever: true,
-        },
-      ],
-    },
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-  }
-);
-
-export default eslintConfig;

nodecar/package.json

@@ -21,15 +21,19 @@
   "author": "",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@types/node": "^24.0.1",
+    "@types/node": "^24.0.10",
     "@yao-pkg/pkg": "^6.5.1",
+    "camoufox-js": "^0.6.0",
     "commander": "^14.0.0",
-    "dotenv": "^16.5.0",
+    "dotenv": "^17.0.1",
     "get-port": "^7.1.0",
     "nodemon": "^3.1.10",
     "proxy-chain": "^2.5.9",
+    "tmp": "^0.2.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.34.0"
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@types/tmp": "^0.2.6"
   }
 }

nodecar/src/camoufox-launcher.ts

@@ -0,0 +1,503 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+export interface CamoufoxConfig {
+  id: string;
+  pid?: number;
+  executablePath: string;
+  profilePath: string;
+  url?: string;
+  options: CamoufoxLaunchOptions;
+}
+
+export interface CamoufoxLaunchOptions {
+  // Operating system to use for fingerprint generation
+  os?: "windows" | "macos" | "linux" | string[];
+
+  // Blocking options
+  block_images?: boolean;
+  block_webrtc?: boolean;
+  block_webgl?: boolean;
+
+  // Security options
+  disable_coop?: boolean;
+
+  // Geolocation options
+  geoip?: string | boolean;
+
+  // UI behavior
+  humanize?: boolean | number;
+
+  // Localization
+  locale?: string | string[];
+
+  // Extensions and fonts
+  addons?: string[];
+  fonts?: string[];
+  custom_fonts_only?: boolean;
+  exclude_addons?: string[];
+
+  // Screen and window
+  screen?: {
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+  };
+  window?: [number, number];
+
+  // Fingerprint
+  fingerprint?: any;
+
+  // Version and mode
+  ff_version?: number;
+  headless?: boolean;
+  main_world_eval?: boolean;
+
+  // Custom executable path
+  executable_path?: string;
+
+  // Firefox preferences
+  firefox_user_prefs?: Record<string, any>;
+
+  // Proxy settings
+  proxy?:
+    | string
+    | {
+        server: string;
+        username?: string;
+        password?: string;
+        bypass?: string;
+      };
+
+  // Cache and performance
+  enable_cache?: boolean;
+
+  // Additional options
+  args?: string[];
+  env?: Record<string, string | number | boolean>;
+  debug?: boolean;
+  virtual_display?: string;
+  webgl_config?: [string, string];
+
+  // Custom options
+  timezone?: string;
+  country?: string;
+  geolocation?: {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+  };
+}
+
+// Store for active Camoufox processes
+const activeCamoufoxProcesses = new Map<string, CamoufoxConfig>();
+
+/**
+ * Generate a unique ID for the Camoufox instance
+ */
+function generateCamoufoxId(): string {
+  return `camoufox_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * Save Camoufox configuration to storage
+ */
+function saveCamoufoxConfig(config: CamoufoxConfig): void {
+  try {
+    const configDir = path.join(os.tmpdir(), "nodecar_camoufox");
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const configFile = path.join(configDir, `${config.id}.json`);
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+    activeCamoufoxProcesses.set(config.id, config);
+  } catch (error) {
+    console.error(`Failed to save Camoufox config: ${error}`);
+  }
+}
+
+/**
+ * Load Camoufox configuration from storage
+ */
+function loadCamoufoxConfig(id: string): CamoufoxConfig | null {
+  try {
+    const configFile = path.join(os.tmpdir(), "nodecar_camoufox", `${id}.json`);
+    if (fs.existsSync(configFile)) {
+      const config = JSON.parse(fs.readFileSync(configFile, "utf8"));
+      activeCamoufoxProcesses.set(id, config);
+      return config;
+    }
+  } catch (error) {
+    console.error(`Failed to load Camoufox config: ${error}`);
+  }
+  return null;
+}
+
+/**
+ * Delete Camoufox configuration from storage
+ */
+function deleteCamoufoxConfig(id: string): boolean {
+  try {
+    const configFile = path.join(os.tmpdir(), "nodecar_camoufox", `${id}.json`);
+    if (fs.existsSync(configFile)) {
+      fs.unlinkSync(configFile);
+    }
+    activeCamoufoxProcesses.delete(id);
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete Camoufox config: ${error}`);
+    return false;
+  }
+}
+
+/**
+ * Load all Camoufox configurations on startup
+ */
+function loadAllCamoufoxConfigs(): void {
+  try {
+    const configDir = path.join(os.tmpdir(), "nodecar_camoufox");
+    if (fs.existsSync(configDir)) {
+      const files = fs.readdirSync(configDir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          const id = path.basename(file, ".json");
+          loadCamoufoxConfig(id);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Failed to load Camoufox configs: ${error}`);
+  }
+}
+
+/**
+ * Check if a process is still running
+ */
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Convert Camoufox options to command line arguments
+ */
+function buildCamoufoxArgs(
+  options: CamoufoxLaunchOptions,
+  profilePath: string,
+  url?: string,
+): string[] {
+  const args: string[] = [];
+
+  // Always use profile
+  args.push("-profile", profilePath);
+
+  // Cache enabled by default as requested
+  if (options.enable_cache !== false) {
+    // Cache is enabled by default in Camoufox, no special args needed
+  }
+
+  // Headless mode
+  if (options.headless) {
+    args.push("-headless");
+  }
+
+  // No remote for security (anti-detect)
+  args.push("-no-remote");
+
+  // Custom Firefox user preferences will be written to user.js in profile
+
+  // Additional custom args
+  if (options.args) {
+    args.push(...options.args);
+  }
+
+  // URL to open
+  if (url) {
+    args.push(url);
+  }
+
+  return args;
+}
+
+/**
+ * Create user.js file with Camoufox preferences
+ */
+function createUserJs(
+  profilePath: string,
+  options: CamoufoxLaunchOptions,
+): void {
+  const preferences: string[] = [];
+
+  // Anti-detect preferences
+  preferences.push('user_pref("privacy.resistFingerprinting", true);');
+  preferences.push(
+    'user_pref("privacy.resistFingerprinting.letterboxing", true);',
+  );
+  preferences.push('user_pref("privacy.trackingprotection.enabled", true);');
+
+  // Disable telemetry and data collection
+  preferences.push(
+    'user_pref("datareporting.healthreport.uploadEnabled", false);',
+  );
+  preferences.push(
+    'user_pref("datareporting.policy.dataSubmissionEnabled", false);',
+  );
+  preferences.push('user_pref("toolkit.telemetry.enabled", false);');
+  preferences.push('user_pref("toolkit.telemetry.unified", false);');
+
+  // Block options
+  if (options.block_images) {
+    preferences.push('user_pref("permissions.default.image", 2);');
+  }
+
+  if (options.block_webrtc) {
+    preferences.push('user_pref("media.peerconnection.enabled", false);');
+    preferences.push('user_pref("media.navigator.enabled", false);');
+  }
+
+  if (options.block_webgl) {
+    preferences.push('user_pref("webgl.disabled", true);');
+    preferences.push('user_pref("webgl.disable-extensions", true);');
+  }
+
+  // COOP settings
+  if (options.disable_coop) {
+    preferences.push(
+      'user_pref("browser.tabs.remote.useCrossOriginOpenerPolicy", false);',
+    );
+  }
+
+  // Locale settings
+  if (options.locale) {
+    const localeStr = Array.isArray(options.locale)
+      ? options.locale[0]
+      : options.locale;
+    preferences.push(`user_pref("intl.locale.requested", "${localeStr}");`);
+    preferences.push(`user_pref("general.useragent.locale", "${localeStr}");`);
+  }
+
+  // Timezone
+  if (options.timezone) {
+    preferences.push(
+      `user_pref("privacy.resistFingerprinting.timezone", "${options.timezone}");`,
+    );
+  }
+
+  // Custom Firefox preferences
+  if (options.firefox_user_prefs) {
+    for (const [key, value] of Object.entries(options.firefox_user_prefs)) {
+      if (typeof value === "string") {
+        preferences.push(`user_pref("${key}", "${value}");`);
+      } else if (typeof value === "boolean") {
+        preferences.push(`user_pref("${key}", ${value});`);
+      } else if (typeof value === "number") {
+        preferences.push(`user_pref("${key}", ${value});`);
+      }
+    }
+  }
+
+  // Proxy settings
+  if (options.proxy) {
+    if (typeof options.proxy === "string") {
+      // Parse proxy URL
+      try {
+        const proxyUrl = new URL(options.proxy);
+        const port =
+          parseInt(proxyUrl.port) ||
+          (proxyUrl.protocol === "https:" ? 443 : 80);
+
+        if (proxyUrl.protocol.startsWith("socks")) {
+          preferences.push('user_pref("network.proxy.type", 1);');
+          preferences.push(
+            `user_pref("network.proxy.socks", "${proxyUrl.hostname}");`,
+          );
+          preferences.push(`user_pref("network.proxy.socks_port", ${port});`);
+          if (proxyUrl.protocol === "socks5:") {
+            preferences.push('user_pref("network.proxy.socks_version", 5);');
+          } else {
+            preferences.push('user_pref("network.proxy.socks_version", 4);');
+          }
+        } else {
+          preferences.push('user_pref("network.proxy.type", 1);');
+          preferences.push(
+            `user_pref("network.proxy.http", "${proxyUrl.hostname}");`,
+          );
+          preferences.push(`user_pref("network.proxy.http_port", ${port});`);
+          preferences.push(
+            `user_pref("network.proxy.ssl", "${proxyUrl.hostname}");`,
+          );
+          preferences.push(`user_pref("network.proxy.ssl_port", ${port});`);
+        }
+
+        if (proxyUrl.username && proxyUrl.password) {
+          // Note: Basic auth for proxies is handled differently in modern Firefox
+          preferences.push(
+            'user_pref("network.proxy.allow_hijacking_localhost", true);',
+          );
+        }
+      } catch (error) {
+        console.error(`Invalid proxy URL: ${options.proxy}`);
+      }
+    }
+  }
+
+  // Geolocation
+  if (options.geolocation) {
+    preferences.push('user_pref("geo.enabled", true);');
+    preferences.push(
+      `user_pref("geo.wifi.uri", "data:application/json,{\\"location\\": {\\"lat\\": ${options.geolocation.latitude}, \\"lng\\": ${options.geolocation.longitude}}, \\"accuracy\\": ${options.geolocation.accuracy || 100}}");`,
+    );
+  } else {
+    preferences.push('user_pref("geo.enabled", false);');
+  }
+
+  // Write user.js file
+  const userJsPath = path.join(profilePath, "user.js");
+  fs.writeFileSync(userJsPath, preferences.join("\n"));
+}
+
+/**
+ * Launch Camoufox browser with specified options
+ */
+export async function launchCamoufox(
+  executablePath: string,
+  profilePath: string,
+  options: CamoufoxLaunchOptions = {},
+  url?: string,
+): Promise<CamoufoxConfig> {
+  const id = generateCamoufoxId();
+
+  // Ensure profile directory exists
+  if (!fs.existsSync(profilePath)) {
+    fs.mkdirSync(profilePath, { recursive: true });
+  }
+
+  // Create user.js with preferences
+  createUserJs(profilePath, options);
+
+  // Build command line arguments
+  const args = buildCamoufoxArgs(options, profilePath, url);
+
+  // Prepare environment variables
+  const env = {
+    ...process.env,
+    ...options.env,
+  };
+
+  // Handle virtual display
+  if (options.virtual_display) {
+    env.DISPLAY = options.virtual_display;
+  }
+
+  // Launch the process
+  const child = spawn(executablePath, args, {
+    env: env as NodeJS.ProcessEnv,
+    detached: true,
+    stdio: options.debug ? "inherit" : "ignore",
+  });
+
+  if (!child.pid) {
+    throw new Error("Failed to launch Camoufox process");
+  }
+
+  const config: CamoufoxConfig = {
+    id,
+    pid: child.pid,
+    executablePath,
+    profilePath,
+    url,
+    options,
+  };
+
+  // Save configuration
+  saveCamoufoxConfig(config);
+
+  // Handle process exit
+  child.on("exit", (code, signal) => {
+    console.log(
+      `Camoufox process ${child.pid} exited with code ${code}, signal ${signal}`,
+    );
+    deleteCamoufoxConfig(id);
+  });
+
+  child.on("error", (error) => {
+    console.error(`Camoufox process error: ${error}`);
+    deleteCamoufoxConfig(id);
+  });
+
+  // Detach the child process so it can continue running independently
+  child.unref();
+
+  return config;
+}
+
+/**
+ * Stop a Camoufox process by ID
+ */
+export async function stopCamoufox(id: string): Promise<boolean> {
+  const config = activeCamoufoxProcesses.get(id) || loadCamoufoxConfig(id);
+
+  if (!config || !config.pid) {
+    return false;
+  }
+
+  try {
+    if (isProcessRunning(config.pid)) {
+      process.kill(config.pid, "SIGTERM");
+
+      // Wait a moment for graceful shutdown
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+
+      // Force kill if still running
+      if (isProcessRunning(config.pid)) {
+        process.kill(config.pid, "SIGKILL");
+      }
+    }
+
+    deleteCamoufoxConfig(id);
+    return true;
+  } catch (error) {
+    console.error(`Failed to stop Camoufox process: ${error}`);
+    return false;
+  }
+}
+
+/**
+ * List all Camoufox processes
+ */
+export function listCamoufoxProcesses(): any[] {
+  loadAllCamoufoxConfigs();
+
+  // Filter out dead processes
+  const activeConfigs: any[] = [];
+
+  for (const [id, config] of activeCamoufoxProcesses) {
+    if (config.pid && isProcessRunning(config.pid)) {
+      // Return in snake_case format for Rust compatibility
+      activeConfigs.push({
+        id: config.id,
+        pid: config.pid,
+        executable_path: config.executablePath,
+        profile_path: config.profilePath,
+        url: config.url,
+        options: config.options,
+      });
+    } else {
+      // Clean up dead processes
+      deleteCamoufoxConfig(id);
+    }
+  }
+
+  return activeConfigs;
+}
+
+// Load existing configurations on module initialization
+loadAllCamoufoxConfigs();

nodecar/src/index.ts

@@ -1,4 +1,9 @@
 import { program } from "commander";
+import {
+  launchCamoufox,
+  listCamoufoxProcesses,
+  stopCamoufox,
+} from "./camoufox-launcher";
 import {
   startProxyProcess,
   stopAllProxyProcesses,
@@ -149,4 +154,277 @@ program
     }
   });
 
+// Command for Camoufox browser orchestrator
+program
+  .command("camoufox")
+  .argument("<action>", "launch, stop, list, or open-url for Camoufox browser")
+  .requiredOption("--executable-path <path>", "path to Camoufox executable")
+  .requiredOption("--profile-path <path>", "path to browser profile directory")
+  .option("--url <url>", "URL to open")
+  .option("--id <id>", "Camoufox instance ID (for stop/open-url actions)")
+
+  // Operating system fingerprinting
+  .option(
+    "--os <os>",
+    "OS to emulate (windows, macos, linux, or comma-separated list)",
+  )
+
+  // Blocking options
+  .option("--block-images", "block all images")
+  .option("--block-webrtc", "block WebRTC entirely")
+  .option("--block-webgl", "block WebGL")
+
+  // Security options
+  .option("--disable-coop", "disable Cross-Origin-Opener-Policy")
+
+  // Geolocation and IP
+  .option(
+    "--geoip <ip>",
+    "IP address for geolocation spoofing (or 'auto' for automatic)",
+  )
+  .option("--country <country>", "country code for geolocation")
+  .option("--timezone <timezone>", "timezone to spoof")
+  .option("--latitude <lat>", "latitude for geolocation", parseFloat)
+  .option("--longitude <lng>", "longitude for geolocation", parseFloat)
+
+  // UI and behavior
+  .option(
+    "--humanize [duration]",
+    "humanize cursor movement (optional max duration in seconds)",
+    (val) => (val ? parseFloat(val) : true),
+  )
+  .option("--headless", "run in headless mode")
+
+  // Localization
+  .option("--locale <locale>", "locale(s) to use (comma-separated)")
+
+  // Extensions and fonts
+  .option("--addons <addons>", "Firefox addons to load (comma-separated paths)")
+  .option("--fonts <fonts>", "additional fonts to load (comma-separated)")
+  .option("--custom-fonts-only", "use only custom fonts, exclude OS fonts")
+  .option(
+    "--exclude-addons <addons>",
+    "default addons to exclude (comma-separated)",
+  )
+
+  // Screen and window
+  .option("--screen-min-width <width>", "minimum screen width", parseInt)
+  .option("--screen-max-width <width>", "maximum screen width", parseInt)
+  .option("--screen-min-height <height>", "minimum screen height", parseInt)
+  .option("--screen-max-height <height>", "maximum screen height", parseInt)
+  .option("--window-width <width>", "fixed window width", parseInt)
+  .option("--window-height <height>", "fixed window height", parseInt)
+
+  // Advanced options
+  .option("--ff-version <version>", "Firefox version to emulate", parseInt)
+  .option("--main-world-eval", "enable main world script evaluation")
+  .option("--webgl-vendor <vendor>", "WebGL vendor string")
+  .option("--webgl-renderer <renderer>", "WebGL renderer string")
+
+  // Proxy
+  .option(
+    "--proxy <proxy>",
+    "proxy URL (protocol://[username:password@]host:port)",
+  )
+
+  // Cache and performance
+  .option("--disable-cache", "disable browser cache (cache enabled by default)")
+
+  // Environment and debugging
+  .option("--virtual-display <display>", "virtual display number (e.g., :99)")
+  .option("--debug", "enable debug output")
+  .option("--args <args>", "additional browser arguments (comma-separated)")
+  .option("--env <env>", "environment variables (JSON string)")
+
+  // Firefox preferences
+  .option("--firefox-prefs <prefs>", "Firefox user preferences (JSON string)")
+
+  .description("launch and manage Camoufox browser orchestrator instances")
+  .action(async (action: string, options: any) => {
+    try {
+      if (action === "launch") {
+        // Validate required options
+        if (!options.executablePath || !options.profilePath) {
+          console.error(
+            "Error: --executable-path and --profile-path are required for launch",
+          );
+          process.exit(1);
+          return;
+        }
+
+        // Build Camoufox options
+        const camoufoxOptions: any = {
+          enable_cache: !options.disableCache, // Cache enabled by default as requested
+        };
+
+        // OS fingerprinting
+        if (options.os) {
+          camoufoxOptions.os = options.os.includes(",")
+            ? options.os.split(",")
+            : options.os;
+        }
+
+        // Blocking options
+        if (options.blockImages) camoufoxOptions.block_images = true;
+        if (options.blockWebrtc) camoufoxOptions.block_webrtc = true;
+        if (options.blockWebgl) camoufoxOptions.block_webgl = true;
+
+        // Security options
+        if (options.disableCoop) camoufoxOptions.disable_coop = true;
+
+        // Geolocation
+        if (options.geoip) {
+          camoufoxOptions.geoip =
+            options.geoip === "auto" ? true : options.geoip;
+        }
+        if (options.latitude && options.longitude) {
+          camoufoxOptions.geolocation = {
+            latitude: options.latitude,
+            longitude: options.longitude,
+            accuracy: 100,
+          };
+        }
+        if (options.country) camoufoxOptions.country = options.country;
+        if (options.timezone) camoufoxOptions.timezone = options.timezone;
+
+        // UI and behavior
+        if (options.humanize) camoufoxOptions.humanize = options.humanize;
+        if (options.headless) camoufoxOptions.headless = true;
+
+        // Localization
+        if (options.locale) {
+          camoufoxOptions.locale = options.locale.includes(",")
+            ? options.locale.split(",")
+            : options.locale;
+        }
+
+        // Extensions and fonts
+        if (options.addons) camoufoxOptions.addons = options.addons.split(",");
+        if (options.fonts) camoufoxOptions.fonts = options.fonts.split(",");
+        if (options.customFontsOnly) camoufoxOptions.custom_fonts_only = true;
+        if (options.excludeAddons)
+          camoufoxOptions.exclude_addons = options.excludeAddons.split(",");
+
+        // Screen and window
+        const screen: any = {};
+        if (options.screenMinWidth) screen.minWidth = options.screenMinWidth;
+        if (options.screenMaxWidth) screen.maxWidth = options.screenMaxWidth;
+        if (options.screenMinHeight) screen.minHeight = options.screenMinHeight;
+        if (options.screenMaxHeight) screen.maxHeight = options.screenMaxHeight;
+        if (Object.keys(screen).length > 0) camoufoxOptions.screen = screen;
+
+        if (options.windowWidth && options.windowHeight) {
+          camoufoxOptions.window = [options.windowWidth, options.windowHeight];
+        }
+
+        // Advanced options
+        if (options.ffVersion) camoufoxOptions.ff_version = options.ffVersion;
+        if (options.mainWorldEval) camoufoxOptions.main_world_eval = true;
+        if (options.webglVendor && options.webglRenderer) {
+          camoufoxOptions.webgl_config = [
+            options.webglVendor,
+            options.webglRenderer,
+          ];
+        }
+
+        // Proxy
+        if (options.proxy) camoufoxOptions.proxy = options.proxy;
+
+        // Environment and debugging
+        if (options.virtualDisplay)
+          camoufoxOptions.virtual_display = options.virtualDisplay;
+        if (options.debug) camoufoxOptions.debug = true;
+        if (options.args) camoufoxOptions.args = options.args.split(",");
+        if (options.env) {
+          try {
+            camoufoxOptions.env = JSON.parse(options.env);
+          } catch (e) {
+            console.error("Invalid JSON for --env option");
+            process.exit(1);
+            return;
+          }
+        }
+
+        // Firefox preferences
+        if (options.firefoxPrefs) {
+          try {
+            camoufoxOptions.firefox_user_prefs = JSON.parse(
+              options.firefoxPrefs,
+            );
+          } catch (e) {
+            console.error("Invalid JSON for --firefox-prefs option");
+            process.exit(1);
+            return;
+          }
+        }
+
+        // Launch Camoufox
+        const config = await launchCamoufox(
+          options.executablePath,
+          options.profilePath,
+          camoufoxOptions,
+          options.url,
+        );
+
+        // Output the configuration as JSON for the Rust side to parse
+        console.log(
+          JSON.stringify({
+            id: config.id,
+            pid: config.pid,
+            executable_path: config.executablePath,
+            profile_path: config.profilePath,
+            url: config.url,
+          }),
+        );
+
+        process.exit(0);
+      } else if (action === "stop") {
+        if (!options.id) {
+          console.error("Error: --id is required for stop action");
+          process.exit(1);
+          return;
+        }
+
+        const success = await stopCamoufox(options.id);
+        console.log(JSON.stringify({ success }));
+        process.exit(0);
+      } else if (action === "list") {
+        const processes = listCamoufoxProcesses();
+        // Convert camelCase to snake_case for Rust compatibility
+        const rustCompatibleProcesses = processes.map((process) => ({
+          id: process.id,
+          pid: process.pid,
+          executable_path: process.executablePath,
+          profile_path: process.profilePath,
+          url: process.url,
+        }));
+        console.log(JSON.stringify(rustCompatibleProcesses));
+        process.exit(0);
+      } else if (action === "open-url") {
+        if (!options.id || !options.url) {
+          console.error(
+            "Error: --id and --url are required for open-url action",
+          );
+          process.exit(1);
+          return;
+        }
+
+        // This would require implementing URL opening in existing instance
+        // For now, we'll return an error as this feature would need additional implementation
+        console.error("open-url action is not yet implemented");
+        process.exit(1);
+      } else {
+        console.error(
+          "Invalid action. Use 'launch', 'stop', 'list', or 'open-url'",
+        );
+        process.exit(1);
+      }
+    } catch (error: unknown) {
+      console.error(
+        `Camoufox command failed: ${error instanceof Error ? error.message : JSON.stringify(error)}`,
+      );
+      process.exit(1);
+    }
+  });
+
 program.parse();

nodecar/src/proxy-storage.ts

@@ -1,8 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
+import tmp from "tmp";
 
-// Define the proxy configuration type
 export interface ProxyConfig {
   id: string;
   upstreamUrl: string;
@@ -12,10 +11,8 @@ export interface ProxyConfig {
   pid?: number;
 }
 
-// Path to store proxy configurations
-const STORAGE_DIR = path.join(os.tmpdir(), "donutbrowser", "proxies");
+const STORAGE_DIR = path.join(tmp.tmpdir, "donutbrowser", "proxies");
 
-// Ensure storage directory exists
 if (!fs.existsSync(STORAGE_DIR)) {
   fs.mkdirSync(STORAGE_DIR, { recursive: true });
 }
@@ -88,7 +85,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 +108,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 +136,7 @@ export function isProcessRunning(pid: number): boolean {
     // but checks if it exists
     process.kill(pid, 0);
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package.json

@@ -2,7 +2,7 @@
   "name": "donutbrowser",
   "private": true,
   "license": "AGPL-3.0",
-  "version": "0.5.2",
+  "version": "0.7.2",
   "type": "module",
   "scripts": {
     "dev": "next dev --turbopack",
@@ -11,13 +11,13 @@
     "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:js": "biome check src/ && tsc --noEmit",
     "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 && 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:js": "biome check src/ --fix",
+    "format:js": "biome check src/ --write --unsafe",
     "format": "pnpm format:js && pnpm format:rust",
     "cargo": "cd src-tauri && cargo",
     "unused-exports:js": "ts-unused-exports tsconfig.json",
@@ -33,55 +33,46 @@
     "@radix-ui/react-scroll-area": "^1.2.9",
     "@radix-ui/react-select": "^2.2.5",
     "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-tabs": "^1.1.12",
     "@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",
+    "@tauri-apps/api": "^2.6.0",
+    "@tauri-apps/plugin-deep-link": "^2.4.0",
+    "@tauri-apps/plugin-dialog": "^2.3.0",
+    "@tauri-apps/plugin-fs": "~2.4.0",
+    "@tauri-apps/plugin-opener": "^2.4.0",
+    "ahooks": "^3.9.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "next": "^15.3.3",
+    "next": "^15.3.5",
     "next-themes": "^0.4.6",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-icons": "^5.5.0",
-    "sonner": "^2.0.5",
+    "sonner": "^2.0.6",
     "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.29.0",
-    "@next/eslint-plugin-next": "^15.3.3",
-    "@tailwindcss/postcss": "^4.1.10",
-    "@tauri-apps/cli": "^2.5.0",
-    "@types/node": "^24.0.1",
+    "@biomejs/biome": "2.0.6",
+    "@tailwindcss/postcss": "^4.1.11",
+    "@tauri-apps/cli": "^2.6.2",
+    "@types/node": "^24.0.13",
     "@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",
+    "@vitejs/plugin-react": "^4.6.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.1.1",
-    "tailwindcss": "^4.1.10",
+    "lint-staged": "^16.1.2",
+    "tailwindcss": "^4.1.11",
     "ts-unused-exports": "^11.0.1",
-    "tw-animate-css": "^1.3.4",
-    "typescript": "~5.8.3",
-    "typescript-eslint": "^8.34.0"
+    "tw-animate-css": "^1.3.5",
+    "typescript": "~5.8.3"
   },
   "packageManager": "pnpm@10.11.1",
   "lint-staged": {
     "**/*.{js,jsx,ts,tsx,json,css,md}": [
-      "biome check --fix",
-      "eslint --cache --fix"
+      "biome check --fix"
     ],
     "src-tauri/**/*.rs": [
       "cd src-tauri && cargo fmt --all",

pnpm-workspace.yaml

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

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "donutbrowser"
-version = "0.5.2"
+version = "0.7.2"
 description = "Simple Yet Powerful Browser Orchestrator"
 authors = ["zhom@github"]
 edition = "2021"
@@ -34,14 +34,16 @@ tokio = { version = "1", features = ["full"] }
 sysinfo = "0.35"
 lazy_static = "1.4"
 base64 = "0.22"
-zip = "4"
 async-trait = "0.1"
 futures-util = "0.3"
-urlencoding = "2.1"
+uuid = { version = "1.0", features = ["v4", "serde"] }
 
 [target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
 tauri-plugin-single-instance = { version = "2", features = ["deep-link"] }
 
+[target.'cfg(windows)'.dependencies]
+zip = "4"
+
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation="0.10"
 objc2 = "0.6.1"
@@ -63,7 +65,6 @@ windows = { version = "0.61", features = [
 
 [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"] }

src-tauri/src/api_client.rs

@@ -9,21 +9,21 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use crate::browser::GithubRelease;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-struct VersionComponent {
-  major: u32,
-  minor: u32,
-  patch: u32,
-  pre_release: Option<PreRelease>,
+pub struct VersionComponent {
+  pub major: u32,
+  pub minor: u32,
+  pub patch: u32,
+  pub pre_release: Option<PreRelease>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-struct PreRelease {
-  kind: PreReleaseKind,
-  number: Option<u32>,
+pub struct PreRelease {
+  pub kind: PreReleaseKind,
+  pub number: Option<u32>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
-enum PreReleaseKind {
+pub enum PreReleaseKind {
   Alpha,
   Beta,
   RC,
@@ -32,7 +32,7 @@ enum PreReleaseKind {
 }
 
 impl VersionComponent {
-  fn parse(version: &str) -> Self {
+  pub fn parse(version: &str) -> Self {
     let version = version.trim();
 
     // Handle special case for Zen Browser twilight releases
@@ -259,6 +259,10 @@ pub fn is_browser_version_nightly(
       // Chromium builds are generally stable snapshots
       false
     }
+    "camoufox" => {
+      // For Camoufox, beta versions are actually the stable releases
+      false
+    }
     _ => {
       // Default fallback
       is_nightly_version(version)
@@ -637,15 +641,39 @@ impl ApiClient {
       "{}/repos/mullvad/mullvad-browser/releases?per_page=100",
       self.github_api_base
     );
-    let releases = self
+
+    let response = self
       .client
       .get(url)
       .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?
-      .json::<Vec<GithubRelease>>()
       .await?;
 
+    if !response.status().is_success() {
+      return Err(format!("GitHub API returned status: {}", response.status()).into());
+    }
+
+    // Get the response text first for better error reporting
+    let response_text = response.text().await?;
+
+    // Try to parse the JSON with better error handling
+    let releases: Vec<GithubRelease> = match serde_json::from_str(&response_text) {
+      Ok(releases) => releases,
+      Err(e) => {
+        eprintln!("Failed to parse GitHub API response for Mullvad releases:");
+        eprintln!("Error: {e}");
+        eprintln!(
+          "Response text (first 500 chars): {}",
+          if response_text.len() > 500 {
+            &response_text[..500]
+          } else {
+            &response_text
+          }
+        );
+        return Err(format!("Failed to parse GitHub API response: {e}").into());
+      }
+    };
+
     let mut releases: Vec<GithubRelease> = releases
       .into_iter()
       .map(|mut release| {
@@ -683,15 +711,39 @@ impl ApiClient {
       "{}/repos/zen-browser/desktop/releases?per_page=100",
       self.github_api_base
     );
-    let mut releases = self
+
+    let response = self
       .client
       .get(url)
       .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?
-      .json::<Vec<GithubRelease>>()
       .await?;
 
+    if !response.status().is_success() {
+      return Err(format!("GitHub API returned status: {}", response.status()).into());
+    }
+
+    // Get the response text first for better error reporting
+    let response_text = response.text().await?;
+
+    // Try to parse the JSON with better error handling
+    let mut releases: Vec<GithubRelease> = match serde_json::from_str(&response_text) {
+      Ok(releases) => releases,
+      Err(e) => {
+        eprintln!("Failed to parse GitHub API response for Zen releases:");
+        eprintln!("Error: {e}");
+        eprintln!(
+          "Response text (first 500 chars): {}",
+          if response_text.len() > 500 {
+            &response_text[..500]
+          } else {
+            &response_text
+          }
+        );
+        return Err(format!("Failed to parse GitHub API response: {e}").into());
+      }
+    };
+
     // Check for twilight updates and mark alpha releases
     for release in &mut releases {
       // Use browser-specific alpha detection for Zen Browser - only "twilight" is nightly
@@ -740,15 +792,39 @@ impl ApiClient {
       "{}/repos/brave/brave-browser/releases?per_page=100",
       self.github_api_base
     );
-    let releases = self
+
+    let response = self
       .client
       .get(url)
       .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?
-      .json::<Vec<GithubRelease>>()
       .await?;
 
+    if !response.status().is_success() {
+      return Err(format!("GitHub API returned status: {}", response.status()).into());
+    }
+
+    // Get the response text first for better error reporting
+    let response_text = response.text().await?;
+
+    // Try to parse the JSON with better error handling
+    let releases: Vec<GithubRelease> = match serde_json::from_str(&response_text) {
+      Ok(releases) => releases,
+      Err(e) => {
+        eprintln!("Failed to parse GitHub API response for Brave releases:");
+        eprintln!("Error: {e}");
+        eprintln!(
+          "Response text (first 500 chars): {}",
+          if response_text.len() > 500 {
+            &response_text[..500]
+          } else {
+            &response_text
+          }
+        );
+        return Err(format!("Failed to parse GitHub API response: {e}").into());
+      }
+    };
+
     // Get platform info to filter appropriate releases
     let (os, arch) = Self::get_platform_info();
 
@@ -784,6 +860,31 @@ impl ApiClient {
   }
 
   /// Check if a Brave release has compatible assets for the given platform and architecture
+  fn has_compatible_camoufox_asset(
+    &self,
+    assets: &[crate::browser::GithubAsset],
+    os: &str,
+    arch: &str,
+  ) -> bool {
+    let (os_name, arch_name) = match (os, arch) {
+      ("windows", "x64") => ("win", "x86_64"),
+      ("windows", "arm64") => ("win", "arm64"),
+      ("linux", "x64") => ("lin", "x86_64"),
+      ("linux", "arm64") => ("lin", "arm64"),
+      ("macos", "x64") => ("mac", "x86_64"),
+      ("macos", "arm64") => ("mac", "arm64"),
+      _ => return false,
+    };
+
+    // Look for assets matching the pattern: camoufox-{version}-{release}-{os}.{arch}.zip
+    assets.iter().any(|asset| {
+      let name = asset.name.to_lowercase();
+      name.starts_with("camoufox-")
+        && name.contains(&format!("-{os_name}.{arch_name}.zip"))
+        && name.ends_with(".zip")
+    })
+  }
+
   fn has_compatible_brave_asset(
     assets: &[crate::browser::GithubAsset],
     os: &str,
@@ -924,6 +1025,128 @@ impl ApiClient {
     )
   }
 
+  pub async fn fetch_camoufox_releases_with_caching(
+    &self,
+    no_caching: bool,
+  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
+    // Check cache first (unless bypassing)
+    if !no_caching {
+      if let Some(cached_releases) = self.load_cached_github_releases("camoufox") {
+        println!(
+          "Using cached Camoufox releases, count: {}",
+          cached_releases.len()
+        );
+        return Ok(cached_releases);
+      }
+    }
+
+    println!("Fetching Camoufox releases from GitHub API...");
+    let url = format!(
+      "{}/repos/daijro/camoufox/releases?per_page=100",
+      self.github_api_base
+    );
+
+    let response = self
+      .client
+      .get(url)
+      .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?;
+
+    if !response.status().is_success() {
+      return Err(format!("GitHub API returned status: {}", response.status()).into());
+    }
+
+    // Get the response text first for better error reporting
+    let response_text = response.text().await?;
+
+    // Try to parse the JSON with better error handling
+    let releases: Vec<GithubRelease> = match serde_json::from_str(&response_text) {
+      Ok(releases) => releases,
+      Err(e) => {
+        eprintln!("Failed to parse GitHub API response for Camoufox releases:");
+        eprintln!("Error: {e}");
+        eprintln!(
+          "Response text (first 500 chars): {}",
+          if response_text.len() > 500 {
+            &response_text[..500]
+          } else {
+            &response_text
+          }
+        );
+        return Err(format!("Failed to parse GitHub API response: {e}").into());
+      }
+    };
+
+    println!(
+      "Fetched {} total Camoufox releases from GitHub",
+      releases.len()
+    );
+
+    // Get platform info to filter appropriate releases
+    let (os, arch) = Self::get_platform_info();
+    println!("Filtering for platform: {os}/{arch}");
+
+    // Filter releases that have assets compatible with the current platform
+    let mut compatible_releases: Vec<GithubRelease> = releases
+      .into_iter()
+      .enumerate()
+      .filter_map(|(i, release)| {
+        let has_compatible = self.has_compatible_camoufox_asset(&release.assets, &os, &arch);
+        if !has_compatible {
+          println!(
+            "Release {} ({}) has no compatible assets for {}/{}",
+            i, release.tag_name, os, arch
+          );
+          println!(
+            "  Available assets: {:?}",
+            release.assets.iter().map(|a| &a.name).collect::<Vec<_>>()
+          );
+        }
+        if has_compatible {
+          Some(release)
+        } else {
+          None
+        }
+      })
+      .collect();
+
+    println!(
+      "After platform filtering: {} compatible releases",
+      compatible_releases.len()
+    );
+
+    // Sort by version (latest first) with debugging
+    println!(
+      "Before sorting: {:?}",
+      compatible_releases
+        .iter()
+        .map(|r| &r.tag_name)
+        .take(10)
+        .collect::<Vec<_>>()
+    );
+    sort_github_releases(&mut compatible_releases);
+    println!(
+      "After sorting: {:?}",
+      compatible_releases
+        .iter()
+        .map(|r| &r.tag_name)
+        .take(10)
+        .collect::<Vec<_>>()
+    );
+
+    // Cache the results (unless bypassing cache)
+    if !no_caching {
+      if let Err(e) = self.save_cached_github_releases("camoufox", &compatible_releases) {
+        eprintln!("Failed to cache Camoufox releases: {e}");
+      } else {
+        println!("Cached {} Camoufox releases", compatible_releases.len());
+      }
+    }
+
+    Ok(compatible_releases)
+  }
+
   pub async fn fetch_tor_releases_with_caching(
     &self,
     no_caching: bool,
@@ -1726,4 +1949,115 @@ mod tests {
     let result = client.fetch_zen_releases_with_caching(true).await;
     assert!(result.is_err());
   }
+
+  #[test]
+  fn test_camoufox_beta_version_parsing() {
+    // Test specific Camoufox beta versions that are causing issues
+    let v22 = VersionComponent::parse("135.0.5beta22");
+    let v24 = VersionComponent::parse("135.0.5beta24");
+
+    println!("v22: {v22:?}");
+    println!("v24: {v24:?}");
+
+    // v24 should be greater than v22
+    assert!(
+      v24 > v22,
+      "135.0.5beta24 should be greater than 135.0.5beta22"
+    );
+
+    // Test other beta version combinations
+    let v1 = VersionComponent::parse("135.0.5beta1");
+    let v2 = VersionComponent::parse("135.0.5beta2");
+    assert!(v2 > v1, "135.0.5beta2 should be greater than 135.0.5beta1");
+
+    // Test sorting of multiple versions
+    let mut versions = vec![
+      "135.0.5beta22".to_string(),
+      "135.0.5beta24".to_string(),
+      "135.0.5beta23".to_string(),
+      "135.0.5beta21".to_string(),
+    ];
+
+    sort_versions(&mut versions);
+
+    println!("Sorted versions: {versions:?}");
+
+    // Should be sorted from newest to oldest
+    assert_eq!(versions[0], "135.0.5beta24");
+    assert_eq!(versions[1], "135.0.5beta23");
+    assert_eq!(versions[2], "135.0.5beta22");
+    assert_eq!(versions[3], "135.0.5beta21");
+  }
+
+  #[test]
+  fn test_camoufox_user_reported_versions() {
+    // Test the exact versions reported by the user: 135.0.1beta24 vs 135.0beta22
+    let v22 = VersionComponent::parse("135.0beta22");
+    let v24 = VersionComponent::parse("135.0.1beta24");
+
+    println!("User reported v22: {v22:?}");
+    println!("User reported v24: {v24:?}");
+
+    // 135.0.1beta24 should be greater than 135.0beta22 (newer patch version)
+    assert!(
+      v24 > v22,
+      "135.0.1beta24 should be greater than 135.0beta22, but got: v24={v24:?} vs v22={v22:?}"
+    );
+
+    // Test sorting of the exact user-reported versions
+    let mut versions = vec!["135.0beta22".to_string(), "135.0.1beta24".to_string()];
+
+    sort_versions(&mut versions);
+
+    println!("User reported sorted versions: {versions:?}");
+
+    // Should be sorted from newest to oldest
+    assert_eq!(
+      versions[0], "135.0.1beta24",
+      "135.0.1beta24 should be first (newest)"
+    );
+    assert_eq!(
+      versions[1], "135.0beta22",
+      "135.0beta22 should be second (older)"
+    );
+  }
+
+  #[test]
+  fn test_camoufox_version_classification() {
+    // Test that Camoufox beta versions are now correctly classified as stable (not nightly)
+    assert!(
+      !is_browser_version_nightly("camoufox", "135.0beta22", None),
+      "135.0beta22 should be classified as stable for Camoufox"
+    );
+    assert!(
+      !is_browser_version_nightly("camoufox", "135.0.1beta24", None),
+      "135.0.1beta24 should be classified as stable for Camoufox"
+    );
+
+    // Test with release names too - beta releases should be stable
+    assert!(
+      !is_browser_version_nightly("camoufox", "135.0beta22", Some("Release Beta 22")),
+      "Release with 'Beta' in name should be classified as stable for Camoufox"
+    );
+
+    // Test that stable versions are not classified as nightly
+    assert!(
+      !is_browser_version_nightly("camoufox", "135.0", None),
+      "135.0 should be classified as stable"
+    );
+    assert!(
+      !is_browser_version_nightly("camoufox", "135.0.1", None),
+      "135.0.1 should be classified as stable"
+    );
+
+    // Test alpha and RC versions are still considered nightly
+    assert!(
+      !is_browser_version_nightly("camoufox", "136.0alpha1", None),
+      "136.0alpha1 should not be classified as nightly/prerelease"
+    );
+    assert!(
+      !is_browser_version_nightly("camoufox", "136.0rc1", None),
+      "136.0rc1 should not be classified as nightly/prerelease"
+    );
+  }
 }

src-tauri/src/app_auto_updater.rs

@@ -35,6 +35,15 @@ pub struct AppUpdateInfo {
   pub published_at: String,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct AppUpdateProgress {
+  pub stage: String, // "downloading", "extracting", "installing", "completed"
+  pub percentage: Option<f64>,
+  pub speed: Option<String>, // MB/s
+  pub eta: Option<String>,   // estimated time remaining
+  pub message: String,
+}
+
 pub struct AppAutoUpdater {
   client: Client,
 }
@@ -98,9 +107,7 @@ impl AppAutoUpdater {
       // For stable builds, look for stable releases (semver format)
       let stable_releases: Vec<&AppRelease> = releases
         .iter()
-        .filter(|release| {
-          release.tag_name.starts_with('v') && !release.tag_name.starts_with("nightly-")
-        })
+        .filter(|release| release.tag_name.starts_with('v'))
         .collect();
       println!("Found {} stable releases", stable_releases.len());
       stable_releases
@@ -311,21 +318,48 @@ impl AppAutoUpdater {
       .to_string();
 
     // Emit download start event
-    let _ = app_handle.emit("app-update-progress", "Downloading update...");
+    let _ = app_handle.emit(
+      "app-update-progress",
+      AppUpdateProgress {
+        stage: "downloading".to_string(),
+        percentage: Some(0.0),
+        speed: None,
+        eta: None,
+        message: "Starting download...".to_string(),
+      },
+    );
 
-    // Download the update
+    // Download the update with progress tracking
     let download_path = self
-      .download_update(&update_info.download_url, &temp_dir, &filename)
+      .download_update_with_progress(&update_info.download_url, &temp_dir, &filename, app_handle)
       .await?;
 
     // Emit extraction start event
-    let _ = app_handle.emit("app-update-progress", "Preparing update...");
+    let _ = app_handle.emit(
+      "app-update-progress",
+      AppUpdateProgress {
+        stage: "extracting".to_string(),
+        percentage: None,
+        speed: None,
+        eta: None,
+        message: "Preparing update...".to_string(),
+      },
+    );
 
     // Extract the update
     let extracted_app_path = self.extract_update(&download_path, &temp_dir).await?;
 
     // Emit installation start event
-    let _ = app_handle.emit("app-update-progress", "Installing update...");
+    let _ = app_handle.emit(
+      "app-update-progress",
+      AppUpdateProgress {
+        stage: "installing".to_string(),
+        percentage: None,
+        speed: None,
+        eta: None,
+        message: "Installing update...".to_string(),
+      },
+    );
 
     // Install the update (overwrite current app)
     self.install_update(&extracted_app_path).await?;
@@ -334,7 +368,16 @@ impl AppAutoUpdater {
     let _ = fs::remove_dir_all(&temp_dir);
 
     // Emit completion event
-    let _ = app_handle.emit("app-update-progress", "Update completed. Restarting...");
+    let _ = app_handle.emit(
+      "app-update-progress",
+      AppUpdateProgress {
+        stage: "completed".to_string(),
+        percentage: Some(100.0),
+        speed: None,
+        eta: None,
+        message: "Update completed. Restarting...".to_string(),
+      },
+    );
 
     // Restart the application
     self.restart_application().await?;
@@ -342,12 +385,13 @@ impl AppAutoUpdater {
     Ok(())
   }
 
-  /// Download the update file
-  async fn download_update(
+  /// Download the update file with progress tracking
+  async fn download_update_with_progress(
     &self,
     download_url: &str,
     dest_dir: &Path,
     filename: &str,
+    app_handle: &tauri::AppHandle,
   ) -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
     let file_path = dest_dir.join(filename);
 
@@ -362,15 +406,75 @@ impl AppAutoUpdater {
       return Err(format!("Download failed with status: {}", response.status()).into());
     }
 
+    let total_size = response.content_length().unwrap_or(0);
     let mut file = fs::File::create(&file_path)?;
     let mut stream = response.bytes_stream();
+    let mut downloaded = 0u64;
+    let start_time = std::time::Instant::now();
+    let mut last_update = std::time::Instant::now();
 
     use futures_util::StreamExt;
     while let Some(chunk) = stream.next().await {
       let chunk = chunk?;
       file.write_all(&chunk)?;
+      downloaded += chunk.len() as u64;
+
+      // Update progress every 100ms to avoid overwhelming the UI
+      if last_update.elapsed().as_millis() > 100 {
+        let elapsed = start_time.elapsed().as_secs_f64();
+        let percentage = if total_size > 0 {
+          (downloaded as f64 / total_size as f64) * 100.0
+        } else {
+          0.0
+        };
+
+        let speed = if elapsed > 0.0 {
+          downloaded as f64 / elapsed / 1024.0 / 1024.0 // MB/s
+        } else {
+          0.0
+        };
+
+        let eta = if total_size > 0 && speed > 0.0 {
+          let remaining_bytes = total_size - downloaded;
+          let remaining_seconds = (remaining_bytes as f64 / 1024.0 / 1024.0) / speed;
+          if remaining_seconds < 60.0 {
+            format!("{}s", remaining_seconds as u32)
+          } else {
+            let minutes = remaining_seconds as u32 / 60;
+            let seconds = remaining_seconds as u32 % 60;
+            format!("{minutes}m {seconds}s")
+          }
+        } else {
+          "Unknown".to_string()
+        };
+
+        let _ = app_handle.emit(
+          "app-update-progress",
+          AppUpdateProgress {
+            stage: "downloading".to_string(),
+            percentage: Some(percentage),
+            speed: Some(format!("{speed:.1}")),
+            eta: Some(eta),
+            message: "Downloading update...".to_string(),
+          },
+        );
+
+        last_update = std::time::Instant::now();
+      }
     }
 
+    // Emit final download completion
+    let _ = app_handle.emit(
+      "app-update-progress",
+      AppUpdateProgress {
+        stage: "downloading".to_string(),
+        percentage: Some(100.0),
+        speed: None,
+        eta: None,
+        message: "Download completed".to_string(),
+      },
+    );
+
     Ok(file_path)
   }
 

src-tauri/src/auto_updater.rs

@@ -101,7 +101,7 @@ impl AutoUpdater {
         if let Some(update) = self.check_profile_update(&profile, &versions)? {
           // Apply chromium threshold logic
           if browser == "chromium" {
-            // For chromium, only show notifications if there are 50+ new versions
+            // For chromium, only show notifications if there are 200+ new versions
             let current_version = &profile.version.parse::<u32>().unwrap();
             let new_version = &update.new_version.parse::<u32>().unwrap();
 
@@ -109,7 +109,7 @@ impl AutoUpdater {
             println!(
               "Current version: {current_version}, New version: {new_version}, Result: {result}"
             );
-            if result > 50 {
+            if result > 200 {
               notifications.push(update);
             } else {
               println!(
@@ -348,16 +348,9 @@ 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}");
-      }
+    // Always perform cleanup after auto-update - 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)
@@ -414,22 +407,17 @@ impl AutoUpdater {
   }
 
   fn is_version_newer(&self, version1: &str, version2: &str) -> bool {
-    self.compare_versions(version1, version2) == std::cmp::Ordering::Greater
+    // Use the proper VersionComponent comparison from api_client.rs
+    let version_a = crate::api_client::VersionComponent::parse(version1);
+    let version_b = crate::api_client::VersionComponent::parse(version2);
+    version_a > version_b
   }
 
   fn compare_versions(&self, version1: &str, version2: &str) -> std::cmp::Ordering {
-    // Basic semantic version comparison
-    let v1_parts = self.parse_version(version1);
-    let v2_parts = self.parse_version(version2);
-
-    v1_parts.cmp(&v2_parts)
-  }
-
-  fn parse_version(&self, version: &str) -> Vec<u32> {
-    version
-      .split(&['.', 'a', 'b', '-', '_'][..])
-      .filter_map(|part| part.parse::<u32>().ok())
-      .collect()
+    // Use the proper VersionComponent comparison from api_client.rs
+    let version_a = crate::api_client::VersionComponent::parse(version1);
+    let version_b = crate::api_client::VersionComponent::parse(version2);
+    version_a.cmp(&version_b)
   }
 
   fn get_auto_update_state_file(&self) -> PathBuf {
@@ -521,14 +509,15 @@ mod tests {
 
   fn create_test_profile(name: &str, browser: &str, version: &str) -> BrowserProfile {
     BrowserProfile {
+      id: uuid::Uuid::new_v4(),
       name: name.to_string(),
       browser: browser.to_string(),
       version: version.to_string(),
-      profile_path: format!("/tmp/{name}"),
       process_id: None,
-      proxy: None,
+      proxy_id: None,
       last_launch: None,
       release_type: "stable".to_string(),
+      camoufox_config: None,
     }
   }
 
@@ -576,6 +565,68 @@ mod tests {
     assert!(!updater.is_version_newer("1.0.0", "1.0.0"));
   }
 
+  #[test]
+  fn test_camoufox_beta_version_comparison() {
+    let updater = AutoUpdater::new();
+
+    // Test the exact user-reported scenario: 135.0.1beta24 vs 135.0beta22
+    assert!(
+      updater.is_version_newer("135.0.1beta24", "135.0beta22"),
+      "135.0.1beta24 should be newer than 135.0beta22"
+    );
+
+    assert_eq!(
+      updater.compare_versions("135.0.1beta24", "135.0beta22"),
+      std::cmp::Ordering::Greater,
+      "135.0.1beta24 should compare as greater than 135.0beta22"
+    );
+
+    // Test other camoufox beta version combinations
+    assert!(
+      updater.is_version_newer("135.0.5beta24", "135.0.5beta22"),
+      "135.0.5beta24 should be newer than 135.0.5beta22"
+    );
+
+    assert!(
+      updater.is_version_newer("135.0.1beta1", "135.0beta1"),
+      "135.0.1beta1 should be newer than 135.0beta1 due to patch version"
+    );
+
+    // Test that older versions are not considered newer
+    assert!(
+      !updater.is_version_newer("135.0beta22", "135.0.1beta24"),
+      "135.0beta22 should NOT be newer than 135.0.1beta24"
+    );
+  }
+
+  #[test]
+  fn test_beta_version_ordering_comprehensive() {
+    let updater = AutoUpdater::new();
+
+    // Test various beta version patterns that could appear in camoufox
+    let test_cases = vec![
+      ("135.0.1beta24", "135.0beta22", true),   // User reported case
+      ("135.0.5beta24", "135.0.5beta22", true), // Same patch, different beta
+      ("135.1beta1", "135.0beta99", true),      // Higher minor beats beta number
+      ("136.0beta1", "135.9.9beta99", true),    // Higher major beats everything
+      ("135.0.1beta1", "135.0beta1", true),     // Patch version matters
+      ("135.0beta22", "135.0.1beta24", false),  // Reverse of user case
+    ];
+
+    for (newer, older, should_be_newer) in test_cases {
+      let result = updater.is_version_newer(newer, older);
+      assert_eq!(
+        result,
+        should_be_newer,
+        "Expected {} {} {} but got {}",
+        newer,
+        if should_be_newer { ">" } else { "<=" },
+        older,
+        if result { "true" } else { "false" }
+      );
+    }
+  }
+
   #[test]
   fn test_check_profile_update_stable_to_stable() {
     let updater = AutoUpdater::new();
@@ -860,15 +911,4 @@ mod tests {
     let loaded_state: AutoUpdateState = serde_json::from_str(&content).unwrap();
     assert_eq!(loaded_state.pending_updates.len(), 0);
   }
-
-  #[test]
-  fn test_parse_version() {
-    let updater = AutoUpdater::new();
-
-    assert_eq!(updater.parse_version("1.2.3"), vec![1, 2, 3]);
-    assert_eq!(updater.parse_version("1.2.3-alpha"), vec![1, 2, 3]);
-    assert_eq!(updater.parse_version("1.2.3a1"), vec![1, 2, 3, 1]);
-    assert_eq!(updater.parse_version("1.2.3b2"), vec![1, 2, 3, 2]);
-    assert_eq!(updater.parse_version("10.0.0"), vec![10, 0, 0]);
-  }
 }

src-tauri/src/browser.rs

@@ -1,9 +1,8 @@
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProxySettings {
-  pub enabled: bool,
   pub proxy_type: String, // "http", "https", "socks4", or "socks5"
   pub host: String,
   pub port: u16,
@@ -20,6 +19,7 @@ pub enum BrowserType {
   Brave,
   Zen,
   TorBrowser,
+  Camoufox,
 }
 
 impl BrowserType {
@@ -32,6 +32,7 @@ impl BrowserType {
       BrowserType::Brave => "brave",
       BrowserType::Zen => "zen",
       BrowserType::TorBrowser => "tor-browser",
+      BrowserType::Camoufox => "camoufox",
     }
   }
 
@@ -44,6 +45,7 @@ impl BrowserType {
       "brave" => Ok(BrowserType::Brave),
       "zen" => Ok(BrowserType::Zen),
       "tor-browser" => Ok(BrowserType::TorBrowser),
+      "camoufox" => Ok(BrowserType::Camoufox),
       _ => Err(format!("Unknown browser type: {s}")),
     }
   }
@@ -90,6 +92,7 @@ mod macos {
           || name.starts_with("mullvad")
           || name.starts_with("zen")
           || name.starts_with("tor")
+          || name.starts_with("camoufox")
           || name.contains("Browser")
       })
       .map(|entry| entry.path())
@@ -193,6 +196,12 @@ mod linux {
           browser_subdir.join("firefox-bin"),
         ]
       }
+      BrowserType::Camoufox => {
+        vec![
+          browser_subdir.join("camoufox"),
+          browser_subdir.join("camoufox-bin"),
+        ]
+      }
       _ => vec![],
     };
 
@@ -275,6 +284,12 @@ mod linux {
           browser_subdir.join("firefox"),
         ]
       }
+      BrowserType::Camoufox => {
+        vec![
+          browser_subdir.join("camoufox-bin"),
+          browser_subdir.join("camoufox"),
+        ]
+      }
       _ => vec![],
     };
 
@@ -359,6 +374,7 @@ mod windows {
             || name.starts_with("mullvad")
             || name.starts_with("zen")
             || name.starts_with("tor")
+            || name.starts_with("camoufox")
             || name.contains("browser")
           {
             return Ok(path);
@@ -437,6 +453,7 @@ mod windows {
             || name.starts_with("mullvad")
             || name.starts_with("zen")
             || name.starts_with("tor")
+            || name.starts_with("camoufox")
             || name.contains("browser")
           {
             return true;
@@ -533,7 +550,10 @@ impl Browser for FirefoxBrowser {
       BrowserType::MullvadBrowser | BrowserType::TorBrowser => {
         args.push("-no-remote".to_string());
       }
-      BrowserType::Firefox | BrowserType::FirefoxDeveloper | BrowserType::Zen => {
+      BrowserType::Firefox
+      | BrowserType::FirefoxDeveloper
+      | BrowserType::Zen
+      | BrowserType::Camoufox => {
         // Don't use -no-remote so we can communicate with existing instances
       }
       _ => {}
@@ -636,12 +656,11 @@ impl Browser for ChromiumBrowser {
 
     // Add proxy configuration if provided
     if let Some(proxy) = proxy_settings {
-      if proxy.enabled {
-        args.push(format!(
-          "--proxy-server=http://{}:{}",
-          proxy.host, proxy.port
-        ));
-      }
+      // Apply proxy settings
+      args.push(format!(
+        "--proxy-server=http://{}:{}",
+        proxy.host, proxy.port
+      ));
     }
 
     if let Some(url) = url {
@@ -695,6 +714,81 @@ impl Browser for ChromiumBrowser {
   }
 }
 
+pub struct CamoufoxBrowser;
+
+impl CamoufoxBrowser {
+  pub fn new() -> Self {
+    Self
+  }
+}
+
+impl Browser for CamoufoxBrowser {
+  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, &BrowserType::Camoufox);
+
+    #[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,
+    _proxy_settings: Option<&ProxySettings>,
+    url: Option<String>,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+    // For Camoufox, we handle launching through the camoufox launcher
+    // This method won't be used directly, but we provide basic Firefox args as fallback
+    let mut args = vec![
+      "-profile".to_string(),
+      profile_path.to_string(),
+      "-no-remote".to_string(),
+    ];
+
+    if let Some(url) = url {
+      args.push(url);
+    }
+
+    Ok(args)
+  }
+
+  fn is_version_downloaded(&self, version: &str, binaries_dir: &Path) -> bool {
+    let install_dir = binaries_dir.join("camoufox").join(version);
+
+    #[cfg(target_os = "macos")]
+    return macos::is_firefox_version_downloaded(&install_dir);
+
+    #[cfg(target_os = "linux")]
+    return linux::is_firefox_version_downloaded(&install_dir, &BrowserType::Camoufox);
+
+    #[cfg(target_os = "windows")]
+    return windows::is_firefox_version_downloaded(&install_dir);
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    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())
+  }
+}
+
 // Factory function to create browser instances
 pub fn create_browser(browser_type: BrowserType) -> Box<dyn Browser> {
   match browser_type {
@@ -704,6 +798,7 @@ pub fn create_browser(browser_type: BrowserType) -> Box<dyn Browser> {
     | BrowserType::Zen
     | BrowserType::TorBrowser => Box::new(FirefoxBrowser::new(browser_type)),
     BrowserType::Chromium | BrowserType::Brave => Box::new(ChromiumBrowser::new(browser_type)),
+    BrowserType::Camoufox => Box::new(CamoufoxBrowser::new()),
   }
 }
 
@@ -720,6 +815,24 @@ pub struct GithubRelease {
   pub is_nightly: bool,
   #[serde(default)]
   pub prerelease: bool,
+  #[serde(default)]
+  pub draft: bool,
+  #[serde(default)]
+  pub body: Option<String>,
+  #[serde(default)]
+  pub html_url: Option<String>,
+  #[serde(default)]
+  pub id: Option<u64>,
+  #[serde(default)]
+  pub node_id: Option<String>,
+  #[serde(default)]
+  pub target_commitish: Option<String>,
+  #[serde(default)]
+  pub created_at: Option<String>,
+  #[serde(default)]
+  pub tarball_url: Option<String>,
+  #[serde(default)]
+  pub zipball_url: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -728,6 +841,22 @@ pub struct GithubAsset {
   pub browser_download_url: String,
   #[serde(default)]
   pub size: u64,
+  #[serde(default)]
+  pub download_count: Option<u64>,
+  #[serde(default)]
+  pub id: Option<u64>,
+  #[serde(default)]
+  pub node_id: Option<String>,
+  #[serde(default)]
+  pub label: Option<String>,
+  #[serde(default)]
+  pub content_type: Option<String>,
+  #[serde(default)]
+  pub state: Option<String>,
+  #[serde(default)]
+  pub created_at: Option<String>,
+  #[serde(default)]
+  pub updated_at: Option<String>,
 }
 
 #[cfg(test)]
@@ -746,6 +875,7 @@ mod tests {
     assert_eq!(BrowserType::Brave.as_str(), "brave");
     assert_eq!(BrowserType::Zen.as_str(), "zen");
     assert_eq!(BrowserType::TorBrowser.as_str(), "tor-browser");
+    assert_eq!(BrowserType::Camoufox.as_str(), "camoufox");
 
     // Test from_str
     assert_eq!(
@@ -770,6 +900,10 @@ mod tests {
       BrowserType::from_str("tor-browser").unwrap(),
       BrowserType::TorBrowser
     );
+    assert_eq!(
+      BrowserType::from_str("camoufox").unwrap(),
+      BrowserType::Camoufox
+    );
 
     // Test invalid browser type
     assert!(BrowserType::from_str("invalid").is_err());
@@ -853,7 +987,6 @@ mod tests {
   #[test]
   fn test_proxy_settings_creation() {
     let proxy = ProxySettings {
-      enabled: true,
       proxy_type: "http".to_string(),
       host: "127.0.0.1".to_string(),
       port: 8080,
@@ -861,14 +994,12 @@ mod tests {
       password: None,
     };
 
-    assert!(proxy.enabled);
     assert_eq!(proxy.proxy_type, "http");
     assert_eq!(proxy.host, "127.0.0.1");
     assert_eq!(proxy.port, 8080);
 
     // Test different proxy types
     let socks_proxy = ProxySettings {
-      enabled: true,
       proxy_type: "socks5".to_string(),
       host: "proxy.example.com".to_string(),
       port: 1080,
@@ -946,7 +1077,6 @@ mod tests {
   #[test]
   fn test_proxy_settings_serialization() {
     let proxy = ProxySettings {
-      enabled: true,
       proxy_type: "http".to_string(),
       host: "127.0.0.1".to_string(),
       port: 8080,
@@ -962,7 +1092,6 @@ mod tests {
 
     // Test that it can be deserialized (implements Deserialize)
     let deserialized: ProxySettings = serde_json::from_str(&json).unwrap();
-    assert_eq!(deserialized.enabled, proxy.enabled);
     assert_eq!(deserialized.proxy_type, proxy.proxy_type);
     assert_eq!(deserialized.host, proxy.host);
     assert_eq!(deserialized.port, proxy.port);

src-tauri/src/browser_version_service.rs

@@ -87,6 +87,10 @@ impl BrowserVersionService {
           Ok(true)
         }
       }
+      "camoufox" => {
+        // Camoufox supports all platforms and architectures according to the JS code
+        Ok(true)
+      }
       _ => Err(format!("Unknown browser: {browser}").into()),
     }
   }
@@ -101,6 +105,7 @@ impl BrowserVersionService {
       "brave",
       "chromium",
       "tor-browser",
+      "camoufox",
     ];
 
     all_browsers
@@ -237,6 +242,7 @@ impl BrowserVersionService {
       "brave" => self.fetch_brave_versions(true).await?,
       "chromium" => self.fetch_chromium_versions(true).await?,
       "tor-browser" => self.fetch_tor_versions(true).await?,
+      "camoufox" => self.fetch_camoufox_versions(true).await?,
       _ => return Err(format!("Unsupported browser: {browser}").into()),
     };
 
@@ -454,6 +460,27 @@ impl BrowserVersionService {
           })
           .collect()
       }
+      "camoufox" => {
+        let releases = self.fetch_camoufox_releases_detailed(true).await?;
+        merged_versions
+          .into_iter()
+          .map(|version| {
+            if let Some(release) = releases.iter().find(|r| r.tag_name == version) {
+              BrowserVersionInfo {
+                version: release.tag_name.clone(),
+                is_prerelease: release.is_nightly,
+                date: release.published_at.clone(),
+              }
+            } else {
+              BrowserVersionInfo {
+                version: version.clone(),
+                is_prerelease: false, // Camoufox usually stable releases
+                date: "".to_string(),
+              }
+            }
+          })
+          .collect()
+      }
       _ => {
         return Err(format!("Unsupported browser: {browser}").into());
       }
@@ -727,6 +754,32 @@ impl BrowserVersionService {
           is_archive,
         })
       }
+      "camoufox" => {
+        // Camoufox downloads from GitHub releases with pattern: camoufox-{version}-{release}-{os}.{arch}.zip
+        let (os_name, arch_name) = match (&os[..], &arch[..]) {
+          ("windows", "x64") => ("win", "x86_64"),
+          ("windows", "arm64") => ("win", "arm64"),
+          ("linux", "x64") => ("lin", "x86_64"),
+          ("linux", "arm64") => ("lin", "arm64"),
+          ("macos", "x64") => ("mac", "x86_64"),
+          ("macos", "arm64") => ("mac", "arm64"),
+          _ => {
+            return Err(
+              format!("Unsupported platform/architecture for Camoufox: {os}/{arch}").into(),
+            )
+          }
+        };
+
+        // Note: We provide a placeholder URL here since Camoufox requires dynamic resolution
+        // The actual URL will be resolved in download.rs resolve_download_url
+        Ok(DownloadInfo {
+          url: format!(
+            "https://github.com/daijro/camoufox/releases/download/{version}/camoufox-{{version}}-{{release}}-{os_name}.{arch_name}.zip"
+          ),
+          filename: format!("camoufox-{version}-{os_name}.{arch_name}.zip"),
+          is_archive: true,
+        })
+      }
       _ => Err(format!("Unsupported browser: {browser}").into()),
     }
   }
@@ -889,6 +942,24 @@ impl BrowserVersionService {
       .fetch_tor_releases_with_caching(no_caching)
       .await
   }
+
+  async fn fetch_camoufox_versions(
+    &self,
+    no_caching: bool,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
+    let releases = self.fetch_camoufox_releases_detailed(no_caching).await?;
+    Ok(releases.into_iter().map(|r| r.tag_name).collect())
+  }
+
+  async fn fetch_camoufox_releases_detailed(
+    &self,
+    no_caching: bool,
+  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
+    self
+      .api_client
+      .fetch_camoufox_releases_with_caching(no_caching)
+      .await
+  }
 }
 
 #[cfg(test)]

src-tauri/src/camoufox.rs

@@ -0,0 +1,607 @@
+use crate::browser_runner::BrowserProfile;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use tauri::AppHandle;
+use tauri_plugin_shell::ShellExt;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CamoufoxConfig {
+  pub os: Option<Vec<String>>,
+  pub block_images: Option<bool>,
+  pub block_webrtc: Option<bool>,
+  pub block_webgl: Option<bool>,
+  pub disable_coop: Option<bool>,
+  pub geoip: Option<serde_json::Value>, // Can be String or bool
+  pub country: Option<String>,
+  pub timezone: Option<String>,
+  pub latitude: Option<f64>,
+  pub longitude: Option<f64>,
+  pub humanize: Option<bool>,
+  pub humanize_duration: Option<f64>,
+  pub headless: Option<bool>,
+  pub locale: Option<Vec<String>>,
+  pub addons: Option<Vec<String>>,
+  pub fonts: Option<Vec<String>>,
+  pub custom_fonts_only: Option<bool>,
+  pub exclude_addons: Option<Vec<String>>,
+  pub screen_min_width: Option<u32>,
+  pub screen_max_width: Option<u32>,
+  pub screen_min_height: Option<u32>,
+  pub screen_max_height: Option<u32>,
+  pub window_width: Option<u32>,
+  pub window_height: Option<u32>,
+  pub ff_version: Option<u32>,
+  pub main_world_eval: Option<bool>,
+  pub webgl_vendor: Option<String>,
+  pub webgl_renderer: Option<String>,
+  pub proxy: Option<String>,
+  pub enable_cache: Option<bool>,
+  pub virtual_display: Option<String>,
+  pub debug: Option<bool>,
+  pub additional_args: Option<Vec<String>>,
+  pub env_vars: Option<HashMap<String, String>>,
+  pub firefox_prefs: Option<HashMap<String, serde_json::Value>>,
+}
+
+impl Default for CamoufoxConfig {
+  fn default() -> Self {
+    Self {
+      os: None,
+      block_images: None,
+      block_webrtc: None,
+      block_webgl: None,
+      disable_coop: None,
+      geoip: None,
+      country: None,
+      timezone: None,
+      latitude: None,
+      longitude: None,
+      humanize: None,
+      humanize_duration: None,
+      headless: None,
+      locale: None,
+      addons: None,
+      fonts: None,
+      custom_fonts_only: None,
+      exclude_addons: None,
+      screen_min_width: None,
+      screen_max_width: None,
+      screen_min_height: None,
+      screen_max_height: None,
+      window_width: None,
+      window_height: None,
+      ff_version: None,
+      main_world_eval: None,
+      webgl_vendor: None,
+      webgl_renderer: None,
+      proxy: None,
+      enable_cache: Some(true), // Cache enabled by default
+      virtual_display: None,
+      debug: None,
+      additional_args: None,
+      env_vars: None,
+      firefox_prefs: None,
+    }
+  }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(non_snake_case)]
+pub struct CamoufoxLaunchResult {
+  pub id: String,
+  pub pid: Option<u32>,
+  #[serde(alias = "executable_path")]
+  pub executablePath: String,
+  #[serde(alias = "profile_path")]
+  pub profilePath: String,
+  pub url: Option<String>,
+}
+
+pub struct CamoufoxLauncher {
+  app_handle: AppHandle,
+}
+
+impl CamoufoxLauncher {
+  pub fn new(app_handle: AppHandle) -> Self {
+    Self { app_handle }
+  }
+
+  /// Launch Camoufox browser with the specified configuration
+  pub async fn launch_camoufox(
+    &self,
+    executable_path: &str,
+    profile_path: &str,
+    config: &CamoufoxConfig,
+    url: Option<&str>,
+  ) -> Result<CamoufoxLaunchResult, Box<dyn std::error::Error + Send + Sync>> {
+    println!("Launching Camoufox with executable: {executable_path}");
+    println!("Profile path: {profile_path}");
+    println!("URL: {url:?}");
+
+    // Use Tauri's sidecar to call nodecar
+    let mut sidecar = self
+      .app_handle
+      .shell()
+      .sidecar("nodecar")
+      .map_err(|e| format!("Failed to create nodecar sidecar: {e}"))?
+      .arg("camoufox")
+      .arg("launch")
+      .arg("--executable-path")
+      .arg(executable_path)
+      .arg("--profile-path")
+      .arg(profile_path);
+
+    // Add URL if provided
+    if let Some(url) = url {
+      sidecar = sidecar.arg("--url").arg(url);
+    }
+
+    // Add configuration options
+    if let Some(os_list) = &config.os {
+      sidecar = sidecar.arg("--os").arg(os_list.join(","));
+    }
+
+    if config.block_images.unwrap_or(false) {
+      sidecar = sidecar.arg("--block-images");
+    }
+
+    if config.block_webrtc.unwrap_or(false) {
+      sidecar = sidecar.arg("--block-webrtc");
+    }
+
+    if config.block_webgl.unwrap_or(false) {
+      sidecar = sidecar.arg("--block-webgl");
+    }
+
+    if config.disable_coop.unwrap_or(false) {
+      sidecar = sidecar.arg("--disable-coop");
+    }
+
+    if let Some(geoip) = &config.geoip {
+      match geoip {
+        serde_json::Value::String(s) => {
+          sidecar = sidecar.arg("--geoip").arg(s);
+        }
+        serde_json::Value::Bool(b) => {
+          sidecar = sidecar
+            .arg("--geoip")
+            .arg(if *b { "auto" } else { "false" });
+        }
+        _ => {
+          sidecar = sidecar.arg("--geoip").arg(geoip.to_string());
+        }
+      }
+    }
+
+    if let Some(country) = &config.country {
+      sidecar = sidecar.arg("--country").arg(country);
+    }
+
+    if let Some(timezone) = &config.timezone {
+      sidecar = sidecar.arg("--timezone").arg(timezone);
+    }
+
+    if let Some(latitude) = config.latitude {
+      if let Some(longitude) = config.longitude {
+        sidecar = sidecar.arg("--latitude").arg(latitude.to_string());
+        sidecar = sidecar.arg("--longitude").arg(longitude.to_string());
+      }
+    }
+
+    if let Some(humanize) = config.humanize {
+      if humanize {
+        if let Some(duration) = config.humanize_duration {
+          sidecar = sidecar.arg("--humanize").arg(duration.to_string());
+        } else {
+          sidecar = sidecar.arg("--humanize");
+        }
+      }
+    }
+
+    if config.headless.unwrap_or(false) {
+      sidecar = sidecar.arg("--headless");
+    }
+
+    if let Some(locale_list) = &config.locale {
+      sidecar = sidecar.arg("--locale").arg(locale_list.join(","));
+    }
+
+    if let Some(addons_list) = &config.addons {
+      sidecar = sidecar.arg("--addons").arg(addons_list.join(","));
+    }
+
+    if let Some(fonts_list) = &config.fonts {
+      sidecar = sidecar.arg("--fonts").arg(fonts_list.join(","));
+    }
+
+    if config.custom_fonts_only.unwrap_or(false) {
+      sidecar = sidecar.arg("--custom-fonts-only");
+    }
+
+    if let Some(exclude_addons_list) = &config.exclude_addons {
+      sidecar = sidecar
+        .arg("--exclude-addons")
+        .arg(exclude_addons_list.join(","));
+    }
+
+    // Screen size configuration
+    if let Some(width) = config.screen_min_width {
+      sidecar = sidecar.arg("--screen-min-width").arg(width.to_string());
+    }
+
+    if let Some(width) = config.screen_max_width {
+      sidecar = sidecar.arg("--screen-max-width").arg(width.to_string());
+    }
+
+    if let Some(height) = config.screen_min_height {
+      sidecar = sidecar.arg("--screen-min-height").arg(height.to_string());
+    }
+
+    if let Some(height) = config.screen_max_height {
+      sidecar = sidecar.arg("--screen-max-height").arg(height.to_string());
+    }
+
+    if let Some(width) = config.window_width {
+      sidecar = sidecar.arg("--window-width").arg(width.to_string());
+    }
+
+    if let Some(height) = config.window_height {
+      sidecar = sidecar.arg("--window-height").arg(height.to_string());
+    }
+
+    // Advanced options
+    if let Some(ff_version) = config.ff_version {
+      sidecar = sidecar.arg("--ff-version").arg(ff_version.to_string());
+    }
+
+    if config.main_world_eval.unwrap_or(false) {
+      sidecar = sidecar.arg("--main-world-eval");
+    }
+
+    if let Some(vendor) = &config.webgl_vendor {
+      if let Some(renderer) = &config.webgl_renderer {
+        sidecar = sidecar.arg("--webgl-vendor").arg(vendor);
+        sidecar = sidecar.arg("--webgl-renderer").arg(renderer);
+      }
+    }
+
+    if let Some(proxy) = &config.proxy {
+      sidecar = sidecar.arg("--proxy").arg(proxy);
+    }
+
+    // Cache is enabled by default, only add flag if disabled
+    if !config.enable_cache.unwrap_or(true) {
+      sidecar = sidecar.arg("--disable-cache");
+    }
+
+    if let Some(virtual_display) = &config.virtual_display {
+      sidecar = sidecar.arg("--virtual-display").arg(virtual_display);
+    }
+
+    if config.debug.unwrap_or(false) {
+      sidecar = sidecar.arg("--debug");
+    }
+
+    if let Some(args) = &config.additional_args {
+      sidecar = sidecar.arg("--args").arg(args.join(","));
+    }
+
+    if let Some(env_vars) = &config.env_vars {
+      let env_json = serde_json::to_string(env_vars)
+        .map_err(|e| format!("Failed to serialize environment variables: {e}"))?;
+      sidecar = sidecar.arg("--env").arg(env_json);
+    }
+
+    if let Some(firefox_prefs) = &config.firefox_prefs {
+      let prefs_json = serde_json::to_string(firefox_prefs)
+        .map_err(|e| format!("Failed to serialize Firefox preferences: {e}"))?;
+      sidecar = sidecar.arg("--firefox-prefs").arg(prefs_json);
+    }
+
+    // Execute the command
+    println!("Executing nodecar command...");
+    let output = sidecar
+      .output()
+      .await
+      .map_err(|e| format!("Failed to execute nodecar command: {e}"))?;
+
+    // Check the command status first
+    if !output.status.success() {
+      let error_msg = String::from_utf8_lossy(&output.stderr);
+      let stdout_msg = String::from_utf8_lossy(&output.stdout);
+      return Err(
+        format!(
+          "Failed to launch Camoufox: Command failed with status {:?}\nstderr: {}\nstdout: {}",
+          output.status, error_msg, stdout_msg
+        )
+        .into(),
+      );
+    }
+
+    // Parse the JSON response
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    println!("Nodecar stdout: {stdout}");
+
+    // Try to parse the JSON response
+    let result: CamoufoxLaunchResult = serde_json::from_str(&stdout)
+      .map_err(|e| format!("Failed to parse nodecar response as JSON: {e}\nResponse: {stdout}"))?;
+
+    println!("Successfully launched Camoufox with ID: {}", result.id);
+
+    Ok(result)
+  }
+
+  /// Stop a Camoufox process by ID
+  pub async fn stop_camoufox(
+    &self,
+    id: &str,
+  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+    println!("Stopping Camoufox process with ID: {id}");
+
+    // First, we need to find the process to get its executable and profile paths
+    let processes = self.list_camoufox_processes().await?;
+    let target_process = processes.iter().find(|p| p.id == id);
+
+    if let Some(process) = target_process {
+      println!(
+        "Found process to stop: executable={}, profile={}",
+        process.executablePath, process.profilePath
+      );
+
+      let sidecar = self
+        .app_handle
+        .shell()
+        .sidecar("nodecar")
+        .map_err(|e| format!("Failed to create nodecar sidecar: {e}"))?
+        .arg("camoufox")
+        .arg("stop")
+        .arg("--executable-path")
+        .arg(&process.executablePath)
+        .arg("--profile-path")
+        .arg(&process.profilePath)
+        .arg("--id")
+        .arg(id);
+
+      let output = sidecar
+        .output()
+        .await
+        .map_err(|e| format!("Failed to execute nodecar stop command: {e}"))?;
+
+      if !output.status.success() {
+        let error_msg = String::from_utf8_lossy(&output.stderr);
+        let stdout_msg = String::from_utf8_lossy(&output.stdout);
+        println!("Failed to stop Camoufox process - stderr: {error_msg}, stdout: {stdout_msg}");
+        return Err(format!("Failed to stop Camoufox process: {error_msg}").into());
+      }
+
+      let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+      println!("Stop command result: {stdout}");
+
+      // Parse the JSON response which contains a "success" field
+      let response: serde_json::Value = serde_json::from_str(&stdout)
+        .map_err(|e| format!("Failed to parse stop response as JSON: {e}\nResponse: {stdout}"))?;
+
+      let success = response
+        .get("success")
+        .and_then(|v| v.as_bool())
+        .ok_or_else(|| {
+          format!("Invalid response format - missing or invalid 'success' field: {stdout}")
+        })?;
+
+      if success {
+        println!("Successfully stopped Camoufox process: {id}");
+      } else {
+        println!("Failed to stop Camoufox process: {id} (process may not exist)");
+      }
+
+      Ok(success)
+    } else {
+      println!("Camoufox process with ID {id} not found in running processes");
+      // If we can't find the process, it might already be stopped
+      Ok(false)
+    }
+  }
+
+  /// List all Camoufox processes
+  pub async fn list_camoufox_processes(
+    &self,
+  ) -> Result<Vec<CamoufoxLaunchResult>, Box<dyn std::error::Error + Send + Sync>> {
+    println!("Listing Camoufox processes...");
+
+    // For the list command, we need to provide dummy executable-path and profile-path
+    // even though they're not used by the list action
+    let sidecar = self
+      .app_handle
+      .shell()
+      .sidecar("nodecar")
+      .map_err(|e| format!("Failed to create nodecar sidecar: {e}"))?
+      .arg("camoufox")
+      .arg("list")
+      .arg("--executable-path")
+      .arg("/dummy/path") // Dummy path since list doesn't use it
+      .arg("--profile-path")
+      .arg("/dummy/profile"); // Dummy path since list doesn't use it
+
+    let output = sidecar
+      .output()
+      .await
+      .map_err(|e| format!("Failed to execute nodecar list command: {e}"))?;
+
+    if !output.status.success() {
+      let error_msg = String::from_utf8_lossy(&output.stderr);
+      return Err(format!("Failed to list Camoufox processes: {error_msg}").into());
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    println!("List command result: {stdout}");
+
+    // Parse the response as an array of process info
+    let processes: Vec<serde_json::Value> =
+      serde_json::from_str(&stdout).map_err(|e| format!("Failed to parse list response: {e}"))?;
+
+    // Convert to CamoufoxLaunchResult format
+    let mut results = Vec::new();
+    for process in processes {
+      // Handle both camelCase and snake_case formats from nodecar
+      let id = process.get("id").and_then(|v| v.as_str());
+
+      // Try both formats for executable path
+      let executable_path = process
+        .get("executable_path")
+        .and_then(|v| v.as_str())
+        .or_else(|| process.get("executablePath").and_then(|v| v.as_str()));
+
+      // Try both formats for profile path
+      let profile_path = process
+        .get("profile_path")
+        .and_then(|v| v.as_str())
+        .or_else(|| process.get("profilePath").and_then(|v| v.as_str()));
+
+      if let (Some(id), Some(executable_path), Some(profile_path)) =
+        (id, executable_path, profile_path)
+      {
+        let pid = process
+          .get("pid")
+          .and_then(|v| v.as_u64())
+          .map(|v| v as u32);
+
+        let url = process
+          .get("url")
+          .and_then(|v| v.as_str())
+          .map(|s| s.to_string());
+
+        results.push(CamoufoxLaunchResult {
+          id: id.to_string(),
+          pid,
+          executablePath: executable_path.to_string(),
+          profilePath: profile_path.to_string(),
+          url,
+        });
+      } else {
+        println!("Skipping malformed process entry: {process:?}");
+      }
+    }
+
+    println!("Parsed {} valid Camoufox processes", results.len());
+    Ok(results)
+  }
+
+  /// Find Camoufox process by profile path (for integration with browser_runner)
+  pub async fn find_camoufox_by_profile(
+    &self,
+    profile_path: &str,
+  ) -> Result<Option<CamoufoxLaunchResult>, Box<dyn std::error::Error + Send + Sync>> {
+    println!("Looking for Camoufox process with profile path: {profile_path}");
+
+    let processes = self.list_camoufox_processes().await?;
+    println!("Found {} running Camoufox processes", processes.len());
+
+    for process in &processes {
+      println!(
+        "Checking process with profile path: {}",
+        process.profilePath
+      );
+    }
+
+    // Convert both paths to canonical form for comparison
+    let target_path = std::path::Path::new(profile_path)
+      .canonicalize()
+      .unwrap_or_else(|_| std::path::Path::new(profile_path).to_path_buf());
+
+    for process in &processes {
+      println!(
+        "Comparing target path: {} with process path: {}",
+        target_path.display(),
+        process.profilePath
+      );
+
+      // Try multiple comparison methods
+      let process_path = std::path::Path::new(&process.profilePath)
+        .canonicalize()
+        .unwrap_or_else(|_| std::path::Path::new(&process.profilePath).to_path_buf());
+
+      // Method 1: Canonical path comparison
+      if process_path == target_path {
+        println!("Found match using canonical path comparison");
+        return Ok(Some(process.clone()));
+      }
+
+      // Method 2: Direct string comparison
+      if process.profilePath == profile_path {
+        println!("Found match using direct string comparison");
+        return Ok(Some(process.clone()));
+      }
+
+      // Method 3: Compare as strings after canonicalization
+      if process_path.to_string_lossy() == target_path.to_string_lossy() {
+        println!("Found match using canonical string comparison");
+        return Ok(Some(process.clone()));
+      }
+
+      // Method 4: Compare file names if full paths don't match
+      if let (Some(process_file), Some(target_file)) =
+        (process_path.file_name(), target_path.file_name())
+      {
+        if process_file == target_file {
+          // If the parent directories also match, it's likely the same profile
+          if let (Some(process_parent), Some(target_parent)) =
+            (process_path.parent(), target_path.parent())
+          {
+            if process_parent == target_parent {
+              println!("Found match using parent directory and file name comparison");
+              return Ok(Some(process.clone()));
+            }
+          }
+        }
+      }
+
+      // Method 5: Check if either path contains the other (for symlinks or different representations)
+      let process_path_str = process_path.to_string_lossy();
+      let target_path_str = target_path.to_string_lossy();
+
+      if process_path_str.contains(target_path_str.as_ref())
+        || target_path_str.contains(process_path_str.as_ref())
+      {
+        println!("Found match using path containment check");
+        return Ok(Some(process.clone()));
+      }
+    }
+
+    println!("No matching Camoufox process found for profile path: {profile_path}");
+    Ok(None)
+  }
+}
+
+pub async fn launch_camoufox_profile(
+  app_handle: AppHandle,
+  profile: BrowserProfile,
+  config: CamoufoxConfig,
+  url: Option<String>,
+) -> Result<CamoufoxLaunchResult, String> {
+  let launcher = CamoufoxLauncher::new(app_handle);
+
+  // Get the executable path for Camoufox
+  let browser_runner = crate::browser_runner::BrowserRunner::new();
+  let binaries_dir = browser_runner.get_binaries_dir();
+  let browser_dir = binaries_dir.join("camoufox").join(&profile.version);
+
+  // Get executable path
+  let browser = crate::browser::create_browser(crate::browser::BrowserType::Camoufox);
+  let executable_path = browser
+    .get_executable_path(&browser_dir)
+    .map_err(|e| format!("Failed to get Camoufox executable path: {e}"))?;
+
+  // Get profile path
+  let profiles_dir = browser_runner.get_profiles_dir();
+  let profile_path = profile.get_profile_data_path(&profiles_dir);
+
+  launcher
+    .launch_camoufox(
+      &executable_path.to_string_lossy(),
+      &profile_path.to_string_lossy(),
+      &config,
+      url.as_deref(),
+    )
+    .await
+    .map_err(|e| format!("Failed to launch Camoufox: {e}"))
+}

src-tauri/src/default_browser.rs

@@ -605,9 +605,25 @@ pub async fn smart_open_url(
         }
       }
 
-      // For Mullvad browser: skip if running (can't open URLs in running Mullvad)
+      // For Mullvad browser: Check if any other Mullvad browser is running
       if profile.browser == "mullvad-browser" {
-        continue;
+        let mut other_mullvad_running = false;
+        for p in &profiles {
+          if p.browser == "mullvad-browser"
+            && p.name != profile.name
+            && runner
+              .check_browser_status(app_handle.clone(), p)
+              .await
+              .unwrap_or(false)
+          {
+            other_mullvad_running = true;
+            break;
+          }
+        }
+
+        if other_mullvad_running {
+          continue; // Skip this one, can't have multiple Mullvad instances
+        }
       }
 
       // Try to open the URL with this running profile

src-tauri/src/download.rs

@@ -79,15 +79,29 @@ impl Downloader {
       }
       BrowserType::Zen => {
         // For Zen, verify the asset exists and handle different naming patterns
-        let releases = self
-          .api_client
-          .fetch_zen_releases_with_caching(true)
-          .await?;
+        let releases = match self.api_client.fetch_zen_releases_with_caching(true).await {
+          Ok(releases) => releases,
+          Err(e) => {
+            eprintln!("Failed to fetch Zen releases: {e}");
+            return Err(format!("Failed to fetch Zen releases from GitHub API: {e}. This might be due to GitHub API rate limiting or network issues. Please try again later.").into());
+          }
+        };
 
         let release = releases
           .iter()
           .find(|r| r.tag_name == version)
-          .ok_or(format!("Zen version {version} not found"))?;
+          .ok_or_else(|| {
+            format!(
+              "Zen version {} not found. Available versions: {}",
+              version,
+              releases
+                .iter()
+                .take(5)
+                .map(|r| r.tag_name.as_str())
+                .collect::<Vec<_>>()
+                .join(", ")
+            )
+          })?;
 
         // Get platform and architecture info
         let (os, arch) = Self::get_platform_info();
@@ -95,9 +109,17 @@ impl Downloader {
         // Find the appropriate asset
         let asset_url = self
           .find_zen_asset(&release.assets, &os, &arch)
-          .ok_or(format!(
-            "No compatible asset found for Zen version {version} on {os}/{arch}"
-          ))?;
+          .ok_or_else(|| {
+            let available_assets: Vec<&str> =
+              release.assets.iter().map(|a| a.name.as_str()).collect();
+            format!(
+              "No compatible asset found for Zen version {} on {}/{}. Available assets: {}",
+              version,
+              os,
+              arch,
+              available_assets.join(", ")
+            )
+          })?;
 
         Ok(asset_url)
       }
@@ -125,6 +147,30 @@ impl Downloader {
 
         Ok(asset_url)
       }
+      BrowserType::Camoufox => {
+        // For Camoufox, verify the asset exists and find the correct download URL
+        let releases = self
+          .api_client
+          .fetch_camoufox_releases_with_caching(true)
+          .await?;
+
+        let release = releases
+          .iter()
+          .find(|r| r.tag_name == version)
+          .ok_or(format!("Camoufox version {version} not found"))?;
+
+        // Get platform and architecture info
+        let (os, arch) = Self::get_platform_info();
+
+        // Find the appropriate asset
+        let asset_url = self
+          .find_camoufox_asset(&release.assets, &os, &arch)
+          .ok_or(format!(
+            "No compatible asset found for Camoufox version {version} on {os}/{arch}"
+          ))?;
+
+        Ok(asset_url)
+      }
       _ => {
         // For other browsers, use the provided URL
         Ok(download_info.url.clone())
@@ -299,6 +345,35 @@ impl Downloader {
     asset.map(|a| a.browser_download_url.clone())
   }
 
+  /// Find the appropriate Camoufox asset for the current platform and architecture
+  fn find_camoufox_asset(
+    &self,
+    assets: &[crate::browser::GithubAsset],
+    os: &str,
+    arch: &str,
+  ) -> Option<String> {
+    // Camoufox asset naming pattern: camoufox-{version}-{release}-{os}.{arch}.zip
+    let (os_name, arch_name) = match (os, arch) {
+      ("windows", "x64") => ("win", "x86_64"),
+      ("windows", "arm64") => ("win", "arm64"),
+      ("linux", "x64") => ("lin", "x86_64"),
+      ("linux", "arm64") => ("lin", "arm64"),
+      ("macos", "x64") => ("mac", "x86_64"),
+      ("macos", "arm64") => ("mac", "arm64"),
+      _ => return None,
+    };
+
+    // Look for assets matching the pattern
+    let asset = assets.iter().find(|asset| {
+      let name = asset.name.to_lowercase();
+      name.starts_with("camoufox-")
+        && name.contains(&format!("-{os_name}.{arch_name}.zip"))
+        && name.ends_with(".zip")
+    });
+
+    asset.map(|a| a.browser_download_url.clone())
+  }
+
   pub async fn download_browser<R: tauri::Runtime>(
     &self,
     app_handle: &tauri::AppHandle<R>,

src-tauri/src/downloaded_browsers.rs

@@ -189,8 +189,22 @@ impl DownloadedBrowsersRegistry {
     let mut to_remove = Vec::new();
     for (browser, versions) in &self.browsers {
       for (version, info) in versions {
+        // Only remove verified downloads that are not used by any active profile
         if info.verified && !active_set.contains(&(browser.clone(), version.clone())) {
-          to_remove.push((browser.clone(), version.clone()));
+          // Double-check that this browser+version is truly not in use
+          // by looking for exact matches in the active profiles
+          let is_in_use = active_profiles
+            .iter()
+            .any(|(active_browser, active_version)| {
+              active_browser == browser && active_version == version
+            });
+
+          if !is_in_use {
+            to_remove.push((browser.clone(), version.clone()));
+            println!("Marking for removal: {browser} {version} (not used by any profile)");
+          } else {
+            println!("Keeping: {browser} {version} (in use by profile)");
+          }
         }
       }
     }
@@ -201,9 +215,16 @@ impl DownloadedBrowsersRegistry {
         eprintln!("Failed to cleanup unused binary {browser}:{version}: {e}");
       } else {
         cleaned_up.push(format!("{browser} {version}"));
+        println!("Successfully removed unused binary: {browser} {version}");
       }
     }
 
+    if cleaned_up.is_empty() {
+      println!("No unused binaries found to clean up");
+    } else {
+      println!("Cleaned up {} unused binaries", cleaned_up.len());
+    }
+
     Ok(cleaned_up)
   }
 
@@ -217,6 +238,45 @@ impl DownloadedBrowsersRegistry {
       .map(|profile| (profile.browser.clone(), profile.version.clone()))
       .collect()
   }
+
+  /// Verify that all registered browsers actually exist on disk and clean up stale entries
+  pub fn verify_and_cleanup_stale_entries(
+    &mut self,
+    browser_runner: &crate::browser_runner::BrowserRunner,
+  ) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
+    use crate::browser::{create_browser, BrowserType};
+    let mut cleaned_up = Vec::new();
+    let binaries_dir = browser_runner.get_binaries_dir();
+
+    let browsers_to_check: Vec<(String, String)> = self
+      .browsers
+      .iter()
+      .flat_map(|(browser, versions)| {
+        versions
+          .keys()
+          .map(|version| (browser.clone(), version.clone()))
+      })
+      .collect();
+
+    for (browser_str, version) in browsers_to_check {
+      if let Ok(browser_type) = BrowserType::from_str(&browser_str) {
+        let browser = create_browser(browser_type);
+        if !browser.is_version_downloaded(&version, &binaries_dir) {
+          // Files don't exist, remove from registry
+          if let Some(_removed) = self.remove_browser(&browser_str, &version) {
+            cleaned_up.push(format!("{browser_str} {version}"));
+            println!("Removed stale registry entry for {browser_str} {version}");
+          }
+        }
+      }
+    }
+
+    if !cleaned_up.is_empty() {
+      self.save()?;
+    }
+
+    Ok(cleaned_up)
+  }
 }
 
 #[cfg(test)]

src-tauri/src/geoip_downloader.rs

@@ -0,0 +1,171 @@
+use crate::browser::GithubRelease;
+use directories::BaseDirs;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use tauri::Emitter;
+use tokio::fs;
+use tokio::io::AsyncWriteExt;
+
+const MMDB_REPO: &str = "P3TERX/GeoLite.mmdb";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GeoIPDownloadProgress {
+  pub stage: String, // "downloading", "extracting", "completed"
+  pub percentage: f64,
+  pub message: String,
+}
+
+pub struct GeoIPDownloader {
+  client: Client,
+}
+
+impl GeoIPDownloader {
+  pub fn new() -> Self {
+    Self {
+      client: Client::new(),
+    }
+  }
+
+  fn get_cache_dir() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
+    let base_dirs = BaseDirs::new().ok_or("Failed to determine base directories")?;
+
+    #[cfg(target_os = "windows")]
+    let cache_dir = base_dirs
+      .data_local_dir()
+      .join("camoufox")
+      .join("camoufox")
+      .join("Cache");
+
+    #[cfg(target_os = "macos")]
+    let cache_dir = base_dirs.cache_dir().join("camoufox");
+
+    #[cfg(target_os = "linux")]
+    let cache_dir = base_dirs.cache_dir().join("camoufox");
+
+    #[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
+    let cache_dir = base_dirs.cache_dir().join("camoufox");
+
+    Ok(cache_dir)
+  }
+
+  fn get_mmdb_file_path() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
+    Ok(Self::get_cache_dir()?.join("GeoLite2-City.mmdb"))
+  }
+
+  pub fn is_geoip_database_available() -> bool {
+    if let Ok(mmdb_path) = Self::get_mmdb_file_path() {
+      mmdb_path.exists()
+    } else {
+      false
+    }
+  }
+
+  fn find_city_mmdb_asset(&self, release: &GithubRelease) -> Option<String> {
+    for asset in &release.assets {
+      if asset.name.ends_with("-City.mmdb") {
+        return Some(asset.browser_download_url.clone());
+      }
+    }
+    None
+  }
+
+  pub async fn download_geoip_database(
+    &self,
+    app_handle: &tauri::AppHandle,
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    // Emit initial progress
+    let _ = app_handle.emit(
+      "geoip-download-progress",
+      GeoIPDownloadProgress {
+        stage: "downloading".to_string(),
+        percentage: 0.0,
+        message: "Starting GeoIP database download".to_string(),
+      },
+    );
+
+    // Fetch latest release from GitHub
+    let releases = self.fetch_geoip_releases().await?;
+    let latest_release = releases.first().ok_or("No GeoIP database releases found")?;
+
+    let download_url = self
+      .find_city_mmdb_asset(latest_release)
+      .ok_or("No compatible GeoIP database asset found")?;
+
+    // Create cache directory
+    let cache_dir = Self::get_cache_dir()?;
+    fs::create_dir_all(&cache_dir).await?;
+
+    let mmdb_path = Self::get_mmdb_file_path()?;
+
+    // Download the file
+    let response = self.client.get(&download_url).send().await?;
+
+    if !response.status().is_success() {
+      return Err(
+        format!(
+          "Failed to download GeoIP database: HTTP {}",
+          response.status()
+        )
+        .into(),
+      );
+    }
+
+    let total_size = response.content_length().unwrap_or(0);
+    let mut downloaded = 0;
+    let mut file = fs::File::create(&mmdb_path).await?;
+    let mut stream = response.bytes_stream();
+
+    use futures_util::StreamExt;
+    while let Some(chunk) = stream.next().await {
+      let chunk = chunk?;
+      downloaded += chunk.len() as u64;
+      file.write_all(&chunk).await?;
+
+      if total_size > 0 {
+        let percentage = (downloaded as f64 / total_size as f64) * 100.0;
+        let _ = app_handle.emit(
+          "geoip-download-progress",
+          GeoIPDownloadProgress {
+            stage: "downloading".to_string(),
+            percentage,
+            message: format!("Downloaded {downloaded} / {total_size} bytes"),
+          },
+        );
+      }
+    }
+
+    file.flush().await?;
+
+    // Emit completion
+    let _ = app_handle.emit(
+      "geoip-download-progress",
+      GeoIPDownloadProgress {
+        stage: "completed".to_string(),
+        percentage: 100.0,
+        message: "GeoIP database download completed".to_string(),
+      },
+    );
+
+    Ok(())
+  }
+
+  async fn fetch_geoip_releases(
+    &self,
+  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
+    let url = format!("https://api.github.com/repos/{MMDB_REPO}/releases");
+    let response = self
+      .client
+      .get(&url)
+      .header("User-Agent", "Mozilla/5.0 (compatible; donutbrowser)")
+      .send()
+      .await?;
+
+    if !response.status().is_success() {
+      return Err(format!("Failed to fetch releases: HTTP {}", response.status()).into());
+    }
+
+    let releases: Vec<GithubRelease> = response.json().await?;
+    Ok(releases)
+  }
+}

src-tauri/src/lib.rs

@@ -13,25 +13,29 @@ mod auto_updater;
 mod browser;
 mod browser_runner;
 mod browser_version_service;
+mod camoufox;
 mod default_browser;
 mod download;
 mod downloaded_browsers;
 mod extraction;
+mod geoip_downloader;
+
 mod profile_importer;
 mod proxy_manager;
 mod settings_manager;
+mod system_utils;
 mod theme_detector;
 mod version_updater;
 
 extern crate lazy_static;
 
 use browser_runner::{
-  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,
+  check_browser_exists, check_browser_status, check_missing_binaries, create_browser_profile_new,
+  delete_profile, download_browser, ensure_all_binaries_exist, 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::{
@@ -60,6 +64,8 @@ use profile_importer::{detect_existing_profiles, import_browser_profile};
 
 use theme_detector::get_system_theme;
 
+use system_utils::{get_system_locale, get_system_timezone};
+
 // Trait to extend WebviewWindow with transparent titlebar functionality
 pub trait WindowExt {
   #[cfg(target_os = "macos")]
@@ -174,6 +180,50 @@ async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bo
   Ok(false)
 }
 
+#[tauri::command]
+async fn create_stored_proxy(
+  name: String,
+  proxy_settings: crate::browser::ProxySettings,
+) -> Result<crate::proxy_manager::StoredProxy, String> {
+  crate::proxy_manager::PROXY_MANAGER
+    .create_stored_proxy(name, proxy_settings)
+    .map_err(|e| format!("Failed to create stored proxy: {e}"))
+}
+
+#[tauri::command]
+async fn get_stored_proxies() -> Result<Vec<crate::proxy_manager::StoredProxy>, String> {
+  Ok(crate::proxy_manager::PROXY_MANAGER.get_stored_proxies())
+}
+
+#[tauri::command]
+async fn update_stored_proxy(
+  proxy_id: String,
+  name: Option<String>,
+  proxy_settings: Option<crate::browser::ProxySettings>,
+) -> Result<crate::proxy_manager::StoredProxy, String> {
+  crate::proxy_manager::PROXY_MANAGER
+    .update_stored_proxy(&proxy_id, name, proxy_settings)
+    .map_err(|e| format!("Failed to update stored proxy: {e}"))
+}
+
+#[tauri::command]
+async fn delete_stored_proxy(proxy_id: String) -> Result<(), String> {
+  crate::proxy_manager::PROXY_MANAGER
+    .delete_stored_proxy(&proxy_id)
+    .map_err(|e| format!("Failed to delete stored proxy: {e}"))
+}
+
+#[tauri::command]
+async fn update_camoufox_config(
+  profile_name: String,
+  config: crate::camoufox::CamoufoxConfig,
+) -> Result<(), String> {
+  let browser_runner = browser_runner::BrowserRunner::new();
+  browser_runner
+    .update_camoufox_config(&profile_name, config)
+    .map_err(|e| format!("Failed to update Camoufox config: {e}"))
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
   let args: Vec<String> = env::args().collect();
@@ -218,6 +268,26 @@ pub fn run() {
         }
       }
 
+      // Migrate profiles to UUID format if needed (async)
+      println!("Checking for profile migration...");
+      let browser_runner = browser_runner::BrowserRunner::new();
+      tauri::async_runtime::spawn(async move {
+        match browser_runner.migrate_profiles_to_uuid().await {
+          Ok(migrated) => {
+            if !migrated.is_empty() {
+              println!(
+                "Successfully migrated {} profiles: {:?}",
+                migrated.len(),
+                migrated
+              );
+            }
+          }
+          Err(e) => {
+            eprintln!("Warning: Failed to migrate profiles: {e}");
+          }
+        }
+      });
+
       // Set up deep link handler
       let handle = app.handle().clone();
 
@@ -374,6 +444,15 @@ pub fn run() {
       get_system_theme,
       detect_existing_profiles,
       import_browser_profile,
+      check_missing_binaries,
+      ensure_all_binaries_exist,
+      create_stored_proxy,
+      get_stored_proxies,
+      update_stored_proxy,
+      delete_stored_proxy,
+      update_camoufox_config,
+      get_system_locale,
+      get_system_timezone,
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");

src-tauri/src/profile_importer.rs

@@ -664,29 +664,32 @@ impl ProfileImporter {
       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(' ', "_");
+    // Generate UUID for new profile and create the directory structure
+    let profile_id = uuid::Uuid::new_v4();
     let profiles_dir = self.browser_runner.get_profiles_dir();
-    let new_profile_path = profiles_dir.join(&snake_case_name);
+    let new_profile_uuid_dir = profiles_dir.join(profile_id.to_string());
+    let new_profile_data_dir = new_profile_uuid_dir.join("profile");
 
-    create_dir_all(&new_profile_path)?;
+    create_dir_all(&new_profile_uuid_dir)?;
+    create_dir_all(&new_profile_data_dir)?;
 
-    // Copy all files from source to destination
-    Self::copy_directory_recursive(source_path, &new_profile_path)?;
+    // Copy all files from source to destination profile subdirectory
+    Self::copy_directory_recursive(source_path, &new_profile_data_dir)?;
 
     // 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 {
+      id: profile_id,
       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,
+      proxy_id: None,
       process_id: None,
       last_launch: None,
       release_type: "stable".to_string(),
+      camoufox_config: None,
     };
 
     // Save the profile metadata
@@ -706,7 +709,7 @@ impl ProfileImporter {
     &self,
     browser_type: &str,
   ) -> Result<String, Box<dyn std::error::Error>> {
-    // Try to get a downloaded version first, fallback to a reasonable default
+    // Check if any version of the browser is downloaded
     let registry =
       crate::downloaded_browsers::DownloadedBrowsersRegistry::load().unwrap_or_default();
     let downloaded_versions = registry.get_downloaded_versions(browser_type);
@@ -715,17 +718,12 @@ impl ProfileImporter {
       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()),
-    }
+    // If no downloaded versions found, return an error
+    Err(format!(
+      "No downloaded versions found for browser '{}'. Please download a version of {} first before importing profiles.",
+      browser_type,
+      self.get_browser_display_name(browser_type)
+    ).into())
   }
 
   /// Recursively copy directory contents

src-tauri/src/proxy_manager.rs

@@ -1,6 +1,9 @@
+use directories::BaseDirs;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
 use std::sync::Mutex;
 use tauri_plugin_shell::ShellExt;
 
@@ -17,19 +20,232 @@ pub struct ProxyInfo {
   pub local_port: u16,
 }
 
-// Global proxy manager to track active proxies
+// Stored proxy configuration with name and ID for reuse
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StoredProxy {
+  pub id: String,
+  pub name: String,
+  pub proxy_settings: ProxySettings,
+}
+
+impl StoredProxy {
+  pub fn new(name: String, proxy_settings: ProxySettings) -> Self {
+    Self {
+      id: uuid::Uuid::new_v4().to_string(),
+      name,
+      proxy_settings,
+    }
+  }
+
+  pub fn update_settings(&mut self, proxy_settings: ProxySettings) {
+    self.proxy_settings = proxy_settings;
+  }
+
+  pub fn update_name(&mut self, name: String) {
+    self.name = name;
+  }
+}
+
+// Global proxy manager to track active proxies and stored proxy configurations
 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, ProxySettings>>, // Maps profile name to proxy settings
+  stored_proxies: Mutex<HashMap<String, StoredProxy>>,    // Maps proxy ID to stored proxy
+  base_dirs: BaseDirs,
 }
 
 impl ProxyManager {
   pub fn new() -> Self {
-    Self {
+    let base_dirs = BaseDirs::new().expect("Failed to get base directories");
+    let manager = Self {
       active_proxies: Mutex::new(HashMap::new()),
       profile_proxies: Mutex::new(HashMap::new()),
+      stored_proxies: Mutex::new(HashMap::new()),
+      base_dirs,
+    };
+
+    // Load stored proxies on initialization
+    if let Err(e) = manager.load_stored_proxies() {
+      eprintln!("Warning: Failed to load stored proxies: {e}");
     }
+
+    manager
+  }
+
+  // Get the path to the proxies directory
+  fn get_proxies_dir(&self) -> PathBuf {
+    let mut path = self.base_dirs.data_local_dir().to_path_buf();
+    path.push(if cfg!(debug_assertions) {
+      "DonutBrowserDev"
+    } else {
+      "DonutBrowser"
+    });
+    path.push("proxies");
+    path
+  }
+
+  // Get the path to a specific proxy file
+  fn get_proxy_file_path(&self, proxy_id: &str) -> PathBuf {
+    self.get_proxies_dir().join(format!("{proxy_id}.json"))
+  }
+
+  // Load stored proxies from disk
+  fn load_stored_proxies(&self) -> Result<(), Box<dyn std::error::Error>> {
+    let proxies_dir = self.get_proxies_dir();
+
+    if !proxies_dir.exists() {
+      return Ok(()); // No proxies directory yet
+    }
+
+    let mut stored_proxies = self.stored_proxies.lock().unwrap();
+
+    // Read all JSON files from the proxies directory
+    for entry in fs::read_dir(&proxies_dir)? {
+      let entry = entry?;
+      let path = entry.path();
+
+      if path.extension().is_some_and(|ext| ext == "json") {
+        let content = fs::read_to_string(&path)?;
+        let proxy: StoredProxy = serde_json::from_str(&content)?;
+        stored_proxies.insert(proxy.id.clone(), proxy);
+      }
+    }
+
+    Ok(())
+  }
+
+  // Save a single proxy to disk
+  fn save_proxy(&self, proxy: &StoredProxy) -> Result<(), Box<dyn std::error::Error>> {
+    let proxies_dir = self.get_proxies_dir();
+
+    // Ensure directory exists
+    fs::create_dir_all(&proxies_dir)?;
+
+    let proxy_file = self.get_proxy_file_path(&proxy.id);
+    let content = serde_json::to_string_pretty(proxy)?;
+    fs::write(&proxy_file, content)?;
+
+    Ok(())
+  }
+
+  // Delete a proxy file from disk
+  fn delete_proxy_file(&self, proxy_id: &str) -> Result<(), Box<dyn std::error::Error>> {
+    let proxy_file = self.get_proxy_file_path(proxy_id);
+    if proxy_file.exists() {
+      fs::remove_file(proxy_file)?;
+    }
+    Ok(())
+  }
+
+  // Create a new stored proxy
+  pub fn create_stored_proxy(
+    &self,
+    name: String,
+    proxy_settings: ProxySettings,
+  ) -> Result<StoredProxy, String> {
+    // Check if name already exists
+    {
+      let stored_proxies = self.stored_proxies.lock().unwrap();
+      if stored_proxies.values().any(|p| p.name == name) {
+        return Err(format!("Proxy with name '{name}' already exists"));
+      }
+    }
+
+    let stored_proxy = StoredProxy::new(name, proxy_settings);
+
+    {
+      let mut stored_proxies = self.stored_proxies.lock().unwrap();
+      stored_proxies.insert(stored_proxy.id.clone(), stored_proxy.clone());
+    }
+
+    if let Err(e) = self.save_proxy(&stored_proxy) {
+      eprintln!("Warning: Failed to save proxy: {e}");
+    }
+
+    Ok(stored_proxy)
+  }
+
+  // Get all stored proxies
+  pub fn get_stored_proxies(&self) -> Vec<StoredProxy> {
+    let stored_proxies = self.stored_proxies.lock().unwrap();
+    stored_proxies.values().cloned().collect()
+  }
+
+  // Get a stored proxy by ID
+
+  // Update a stored proxy
+  pub fn update_stored_proxy(
+    &self,
+    proxy_id: &str,
+    name: Option<String>,
+    proxy_settings: Option<ProxySettings>,
+  ) -> Result<StoredProxy, String> {
+    // First, check for conflicts without holding a mutable reference
+    {
+      let stored_proxies = self.stored_proxies.lock().unwrap();
+
+      // Check if proxy exists
+      if !stored_proxies.contains_key(proxy_id) {
+        return Err(format!("Proxy with ID '{proxy_id}' not found"));
+      }
+
+      // Check if new name conflicts with existing proxies
+      if let Some(ref new_name) = name {
+        if stored_proxies
+          .values()
+          .any(|p| p.id != proxy_id && p.name == *new_name)
+        {
+          return Err(format!("Proxy with name '{new_name}' already exists"));
+        }
+      }
+    } // Release the lock here
+
+    // Now get mutable access for updates
+    let updated_proxy = {
+      let mut stored_proxies = self.stored_proxies.lock().unwrap();
+      let stored_proxy = stored_proxies.get_mut(proxy_id).unwrap(); // Safe because we checked above
+
+      if let Some(new_name) = name {
+        stored_proxy.update_name(new_name);
+      }
+
+      if let Some(new_settings) = proxy_settings {
+        stored_proxy.update_settings(new_settings);
+      }
+
+      stored_proxy.clone()
+    };
+
+    if let Err(e) = self.save_proxy(&updated_proxy) {
+      eprintln!("Warning: Failed to save proxy: {e}");
+    }
+
+    Ok(updated_proxy)
+  }
+
+  // Delete a stored proxy
+  pub fn delete_stored_proxy(&self, proxy_id: &str) -> Result<(), String> {
+    {
+      let mut stored_proxies = self.stored_proxies.lock().unwrap();
+      if stored_proxies.remove(proxy_id).is_none() {
+        return Err(format!("Proxy with ID '{proxy_id}' not found"));
+      }
+    }
+
+    if let Err(e) = self.delete_proxy_file(proxy_id) {
+      eprintln!("Warning: Failed to delete proxy file: {e}");
+    }
+
+    Ok(())
+  }
+
+  // Get proxy settings for a stored proxy ID
+  pub fn get_proxy_settings_by_id(&self, proxy_id: &str) -> Option<ProxySettings> {
+    let stored_proxies = self.stored_proxies.lock().unwrap();
+    stored_proxies
+      .get(proxy_id)
+      .map(|p| p.proxy_settings.clone())
   }
 
   // Start a proxy for given proxy settings and associate it with a browser process ID
@@ -45,8 +261,7 @@ impl ProxyManager {
       let proxies = self.active_proxies.lock().unwrap();
       if let Some(proxy) = proxies.get(&browser_pid) {
         return Ok(ProxySettings {
-          enabled: true,
-          proxy_type: proxy.upstream_type.clone(),
+          proxy_type: "http".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,
@@ -154,7 +369,6 @@ impl ProxyManager {
 
     // Return proxy settings for the browser
     Ok(ProxySettings {
-      enabled: true,
       proxy_type: "http".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,
@@ -199,10 +413,10 @@ impl ProxyManager {
   }
 
   // Get proxy settings for a browser process ID
+  #[allow(dead_code)]
   pub fn get_proxy_settings(&self, browser_pid: u32) -> Option<ProxySettings> {
     let proxies = self.active_proxies.lock().unwrap();
     proxies.get(&browser_pid).map(|proxy| ProxySettings {
-      enabled: true,
       proxy_type: "http".to_string(),
       host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
       port: proxy.local_port,
@@ -212,6 +426,7 @@ impl ProxyManager {
   }
 
   // Get stored proxy info for a profile
+  #[allow(dead_code)]
   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()
@@ -321,7 +536,6 @@ mod tests {
     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,
@@ -373,9 +587,8 @@ mod tests {
     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);
+    assert!(settings.host == "127.0.0.1");
+    assert!(settings.port == 8080);
 
     // Test non-existent browser PID
     let non_existent = proxy_manager.get_proxy_settings(99999);
@@ -386,7 +599,6 @@ mod tests {
   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,
@@ -394,14 +606,11 @@ mod tests {
       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,
+    // Test proxy settings with empty values
+    let empty_settings = ProxySettings {
       proxy_type: "http".to_string(),
       host: "".to_string(),
       port: 0,
@@ -409,7 +618,7 @@ mod tests {
       password: None,
     };
 
-    assert!(!disabled_settings.enabled);
+    assert!(empty_settings.host.is_empty());
   }
 
   #[tokio::test]
@@ -563,7 +772,6 @@ mod tests {
   #[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,

src-tauri/src/settings_manager.rs

@@ -29,8 +29,6 @@ pub struct AppSettings {
   pub show_settings_on_startup: bool,
   #[serde(default = "default_theme")]
   pub theme: String, // "light", "dark", or "system"
-  #[serde(default)]
-  pub auto_delete_unused_binaries: bool,
 }
 
 fn default_theme() -> String {
@@ -43,7 +41,6 @@ impl Default for AppSettings {
       set_as_default_browser: false,
       show_settings_on_startup: true,
       theme: "system".to_string(),
-      auto_delete_unused_binaries: true,
     }
   }
 }

src-tauri/src/system_utils.rs

@@ -0,0 +1,331 @@
+use serde::{Deserialize, Serialize};
+use std::process::Command;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SystemLocale {
+  pub locale: String,
+  pub language: String,
+  pub country: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SystemTimezone {
+  pub timezone: String,
+  pub offset: String,
+}
+
+pub struct SystemUtils;
+
+impl SystemUtils {
+  pub fn new() -> Self {
+    Self
+  }
+
+  /// Detect the system's locale settings
+  pub fn detect_system_locale(&self) -> SystemLocale {
+    #[cfg(target_os = "macos")]
+    return macos::detect_system_locale();
+
+    #[cfg(target_os = "linux")]
+    return linux::detect_system_locale();
+
+    #[cfg(target_os = "windows")]
+    return windows::detect_system_locale();
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    return SystemLocale {
+      locale: "en-US".to_string(),
+      language: "en".to_string(),
+      country: "US".to_string(),
+    };
+  }
+
+  /// Detect the system's timezone settings
+  pub fn detect_system_timezone(&self) -> SystemTimezone {
+    #[cfg(target_os = "macos")]
+    return macos::detect_system_timezone();
+
+    #[cfg(target_os = "linux")]
+    return linux::detect_system_timezone();
+
+    #[cfg(target_os = "windows")]
+    return windows::detect_system_timezone();
+
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+    return SystemTimezone {
+      timezone: "UTC".to_string(),
+      offset: "+00:00".to_string(),
+    };
+  }
+}
+
+#[cfg(target_os = "macos")]
+mod macos {
+  use super::*;
+
+  pub fn detect_system_locale() -> SystemLocale {
+    // Try to get the system locale from macOS
+    if let Ok(output) = Command::new("defaults")
+      .args(["read", "-g", "AppleLocale"])
+      .output()
+    {
+      if output.status.success() {
+        let locale_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        return parse_locale(&locale_str);
+      }
+    }
+
+    // Fallback to environment variables
+    detect_locale_from_env()
+  }
+
+  pub fn detect_system_timezone() -> SystemTimezone {
+    // Try to get timezone from macOS system
+    if let Ok(output) = Command::new("date").arg("+%Z").output() {
+      if output.status.success() {
+        let tz_abbr = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+        // Get the full timezone name
+        if let Ok(tz_output) = Command::new("systemsetup").args(["-gettimezone"]).output() {
+          if tz_output.status.success() {
+            let tz_full = String::from_utf8_lossy(&tz_output.stdout);
+            if let Some(tz_name) = tz_full.strip_prefix("Time Zone: ") {
+              let tz_clean = tz_name.trim().to_string();
+              if !tz_clean.is_empty() {
+                return SystemTimezone {
+                  timezone: tz_clean,
+                  offset: tz_abbr,
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Fallback to reading /etc/localtime link
+    detect_timezone_from_files()
+  }
+}
+
+#[cfg(target_os = "linux")]
+mod linux {
+  use super::*;
+
+  pub fn detect_system_locale() -> SystemLocale {
+    // Try to get locale from locale command
+    if let Ok(output) = Command::new("locale").output() {
+      if output.status.success() {
+        let output_str = String::from_utf8_lossy(&output.stdout);
+        for line in output_str.lines() {
+          if line.starts_with("LANG=") {
+            let locale_value = line.strip_prefix("LANG=").unwrap_or("");
+            let locale_clean = locale_value.trim_matches('"');
+            return parse_locale(locale_clean);
+          }
+        }
+      }
+    }
+
+    // Fallback to environment variables
+    detect_locale_from_env()
+  }
+
+  pub fn detect_system_timezone() -> SystemTimezone {
+    // Try to read /etc/timezone first (Debian/Ubuntu)
+    if let Ok(tz_content) = std::fs::read_to_string("/etc/timezone") {
+      let tz_name = tz_content.trim().to_string();
+      if !tz_name.is_empty() {
+        return SystemTimezone {
+          timezone: tz_name,
+          offset: get_timezone_offset(),
+        };
+      }
+    }
+
+    // Try timedatectl (systemd systems)
+    if let Ok(output) = Command::new("timedatectl")
+      .args(["show", "--property=Timezone", "--value"])
+      .output()
+    {
+      if output.status.success() {
+        let tz_name = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        if !tz_name.is_empty() {
+          return SystemTimezone {
+            timezone: tz_name,
+            offset: get_timezone_offset(),
+          };
+        }
+      }
+    }
+
+    // Fallback to reading /etc/localtime symlink
+    detect_timezone_from_files()
+  }
+
+  fn get_timezone_offset() -> String {
+    if let Ok(output) = Command::new("date").arg("+%z").output() {
+      if output.status.success() {
+        return String::from_utf8_lossy(&output.stdout).trim().to_string();
+      }
+    }
+    "+00:00".to_string()
+  }
+}
+
+#[cfg(target_os = "windows")]
+mod windows {
+  use super::*;
+
+  pub fn detect_system_locale() -> SystemLocale {
+    // Try to get locale from Windows registry/powershell
+    if let Ok(output) = Command::new("powershell")
+      .args([
+        "-Command",
+        "Get-Culture | Select-Object -ExpandProperty Name",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let locale_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        return parse_locale(&locale_str);
+      }
+    }
+
+    // Fallback to environment variables
+    detect_locale_from_env()
+  }
+
+  pub fn detect_system_timezone() -> SystemTimezone {
+    // Try to get timezone from Windows
+    if let Ok(output) = Command::new("powershell")
+      .args([
+        "-Command",
+        "Get-TimeZone | Select-Object -ExpandProperty Id",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let tz_id = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        if !tz_id.is_empty() {
+          return SystemTimezone {
+            timezone: tz_id,
+            offset: get_windows_timezone_offset(),
+          };
+        }
+      }
+    }
+
+    // Fallback
+    SystemTimezone {
+      timezone: "UTC".to_string(),
+      offset: "+00:00".to_string(),
+    }
+  }
+
+  fn get_windows_timezone_offset() -> String {
+    if let Ok(output) = Command::new("powershell")
+      .args([
+        "-Command",
+        "Get-TimeZone | Select-Object -ExpandProperty BaseUtcOffset",
+      ])
+      .output()
+    {
+      if output.status.success() {
+        let offset_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        // Convert Windows offset format to standard format
+        if let Some(colon_pos) = offset_str.find(':') {
+          let hours = &offset_str[..colon_pos];
+          let minutes = &offset_str[colon_pos + 1..];
+          if let (Ok(h), Ok(m)) = (hours.parse::<i32>(), minutes.parse::<i32>()) {
+            return format!("{:+03}:{:02}", h, m);
+          }
+        }
+      }
+    }
+    "+00:00".to_string()
+  }
+}
+
+// Helper functions used across platforms
+fn parse_locale(locale_str: &str) -> SystemLocale {
+  // Remove encoding suffix if present (e.g., "en_US.UTF-8" -> "en_US")
+  let locale_base = locale_str.split('.').next().unwrap_or(locale_str);
+
+  // Split language and country (e.g., "en_US" -> ["en", "US"])
+  let parts: Vec<&str> = locale_base.split(&['_', '-']).collect();
+
+  let language = parts.first().unwrap_or(&"en").to_string();
+  let country = parts.get(1).unwrap_or(&"US").to_string();
+
+  // Convert to standard format (e.g., "en-US")
+  let standard_locale = if parts.len() >= 2 {
+    format!("{}-{}", language, country.to_uppercase())
+  } else {
+    format!("{language}-US")
+  };
+
+  SystemLocale {
+    locale: standard_locale,
+    language,
+    country: country.to_uppercase(),
+  }
+}
+
+fn detect_locale_from_env() -> SystemLocale {
+  // Check environment variables in order of preference
+  let env_vars = ["LANG", "LC_ALL", "LC_CTYPE", "LANGUAGE"];
+
+  for var in &env_vars {
+    if let Ok(value) = std::env::var(var) {
+      if !value.is_empty() {
+        return parse_locale(&value);
+      }
+    }
+  }
+
+  // Default fallback
+  SystemLocale {
+    locale: "en-US".to_string(),
+    language: "en".to_string(),
+    country: "US".to_string(),
+  }
+}
+
+fn detect_timezone_from_files() -> SystemTimezone {
+  // Try to read timezone from /etc/localtime symlink
+  if let Ok(link_target) = std::fs::read_link("/etc/localtime") {
+    if let Some(tz_path) = link_target.to_str() {
+      // Extract timezone name from path like /usr/share/zoneinfo/America/New_York
+      if let Some(zoneinfo_pos) = tz_path.find("zoneinfo/") {
+        let tz_name = &tz_path[zoneinfo_pos + 9..];
+        if !tz_name.is_empty() {
+          return SystemTimezone {
+            timezone: tz_name.to_string(),
+            offset: "+00:00".to_string(), // Could be improved with actual offset calculation
+          };
+        }
+      }
+    }
+  }
+
+  // Default fallback
+  SystemTimezone {
+    timezone: "UTC".to_string(),
+    offset: "+00:00".to_string(),
+  }
+}
+
+/// Tauri command to get system locale
+#[tauri::command]
+pub async fn get_system_locale() -> Result<SystemLocale, String> {
+  let utils = SystemUtils::new();
+  Ok(utils.detect_system_locale())
+}
+
+/// Tauri command to get system timezone
+#[tauri::command]
+pub async fn get_system_timezone() -> Result<SystemTimezone, String> {
+  let utils = SystemUtils::new();
+  Ok(utils.detect_system_timezone())
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Donut Browser",
-  "version": "0.5.2",
+  "version": "0.7.2",
   "identifier": "com.donutbrowser",
   "build": {
     "beforeDevCommand": "pnpm dev",

src/app/layout.tsx

@@ -24,12 +24,12 @@ export default function RootLayout({
   return (
     <html lang="en" suppressHydrationWarning>
       <body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+        className={`${geistSans.variable} ${geistMono.variable} antialiased overflow-hidden`}
       >
         <CustomThemeProvider>
-          <WindowDragArea />
           <TooltipProvider>{children}</TooltipProvider>
           <Toaster />
+          <WindowDragArea />
         </CustomThemeProvider>
       </body>
     </html>

src/app/page.tsx

@@ -1,11 +1,20 @@
 "use client";
 
+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 { FaDownload } from "react-icons/fa";
+import { FiWifi } from "react-icons/fi";
+import { GoGear, GoKebabHorizontal, GoPlus } from "react-icons/go";
+import { CamoufoxConfigDialog } from "@/components/camoufox-config-dialog";
 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 { ProxyManagementDialog } from "@/components/proxy-management-dialog";
 import { ProxySettingsDialog } from "@/components/proxy-settings-dialog";
 import { SettingsDialog } from "@/components/settings-dialog";
 import { Button } from "@/components/ui/button";
@@ -22,18 +31,13 @@ import {
   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 { usePermissions } 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 { FaDownload } from "react-icons/fa";
-import { GoGear, GoKebabHorizontal, GoPlus } from "react-icons/go";
+import { sleep } from "@/lib/utils";
+import type { BrowserProfile, CamoufoxConfig } from "@/types";
 
 type BrowserTypeString =
   | "mullvad-browser"
@@ -42,7 +46,8 @@ type BrowserTypeString =
   | "chromium"
   | "brave"
   | "zen"
-  | "tor-browser";
+  | "tor-browser"
+  | "camoufox";
 
 interface PendingUrl {
   id: string;
@@ -57,29 +62,120 @@ export default function Home() {
   const [changeVersionDialogOpen, setChangeVersionDialogOpen] = useState(false);
   const [settingsDialogOpen, setSettingsDialogOpen] = useState(false);
   const [importProfileDialogOpen, setImportProfileDialogOpen] = useState(false);
+  const [proxyManagementDialogOpen, setProxyManagementDialogOpen] =
+    useState(false);
+  const [camoufoxConfigDialogOpen, setCamoufoxConfigDialogOpen] =
+    useState(false);
   const [pendingUrls, setPendingUrls] = useState<PendingUrl[]>([]);
   const [currentProfileForProxy, setCurrentProfileForProxy] =
     useState<BrowserProfile | null>(null);
   const [currentProfileForVersionChange, setCurrentProfileForVersionChange] =
     useState<BrowserProfile | null>(null);
+  const [currentProfileForCamoufoxConfig, setCurrentProfileForCamoufoxConfig] =
+    useState<BrowserProfile | null>(null);
   const [hasCheckedStartupPrompt, setHasCheckedStartupPrompt] = useState(false);
   const [permissionDialogOpen, setPermissionDialogOpen] = useState(false);
   const [currentPermissionType, setCurrentPermissionType] =
     useState<PermissionType>("microphone");
+  const [proxyDataReloadTrigger, setProxyDataReloadTrigger] = useState(0);
   const { isMicrophoneAccessGranted, isCameraAccessGranted, isInitialized } =
     usePermissions();
 
+  // Check for missing binaries and offer to download them
+  const checkMissingBinaries = useCallback(async () => {
+    try {
+      const missingBinaries = await invoke<[string, string, string][]>(
+        "check_missing_binaries",
+      );
+
+      if (missingBinaries.length > 0) {
+        console.log("Found missing binaries:", missingBinaries);
+
+        // Group missing binaries by browser type to avoid concurrent downloads
+        const browserMap = new Map<string, string[]>();
+        for (const [profileName, browser, version] of missingBinaries) {
+          if (!browserMap.has(browser)) {
+            browserMap.set(browser, []);
+          }
+          const versions = browserMap.get(browser);
+          if (versions) {
+            versions.push(`${version} (for ${profileName})`);
+          }
+        }
+
+        // Show a toast notification about missing binaries and auto-download them
+        const missingList = Array.from(browserMap.entries())
+          .map(([browser, versions]) => `${browser}: ${versions.join(", ")}`)
+          .join(", ");
+
+        console.log(`Downloading missing binaries: ${missingList}`);
+
+        try {
+          // Download missing binaries sequentially by browser type to prevent conflicts
+          const downloaded = await invoke<string[]>(
+            "ensure_all_binaries_exist",
+          );
+          if (downloaded.length > 0) {
+            console.log(
+              "Successfully downloaded missing binaries:",
+              downloaded,
+            );
+          }
+        } catch (downloadError) {
+          console.error("Failed to download missing binaries:", downloadError);
+          setError(
+            `Failed to download missing binaries: ${JSON.stringify(
+              downloadError,
+            )}`,
+          );
+        }
+      }
+    } catch (err: unknown) {
+      console.error("Failed to check missing binaries:", err);
+    }
+  }, []);
+
   // 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);
+      setProfiles(
+        profileList.filter((profile) => profile.browser !== "camoufox"),
+      );
+
+      // Check for missing binaries after loading profiles
+      await checkMissingBinaries();
     } catch (err: unknown) {
       console.error("Failed to load profiles:", err);
       setError(`Failed to load profiles: ${JSON.stringify(err)}`);
     }
+  }, [checkMissingBinaries]);
+
+  // Trigger proxy data reload in ProfilesDataTable
+  const triggerProxyDataReload = useCallback(() => {
+    setProxyDataReloadTrigger((prev) => prev + 1);
+  }, []);
+
+  const handleUrlOpen = useCallback(async (url: string) => {
+    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, no need to show selector
+    } catch (error: unknown) {
+      console.log(
+        "Smart URL opening failed or requires profile selection:",
+        error,
+      );
+
+      // Show profile selector for manual selection
+      // Replace any existing pending URL with the new one
+      setPendingUrls([{ id: Date.now().toString(), url }]);
+    }
   }, []);
 
   // Version updater for handling version fetching progress events and auto-updates
@@ -95,15 +191,31 @@ export default function Home() {
       const profileList = await invoke<BrowserProfile[]>(
         "list_browser_profiles",
       );
-      setProfiles(profileList);
+      setProfiles(
+        profileList.filter((profile) => profile.browser !== "camoufox"),
+      );
+
+      // TODO: remove after a few version bumps, needed to properly display migrated profiles
+      setTimeout(async () => {
+        for (let i = 0; i < 10; i++) {
+          const profiles = await invoke<BrowserProfile[]>(
+            "list_browser_profiles",
+          );
+          setProfiles(
+            profiles.filter((profile) => profile.browser !== "camoufox"),
+          );
+        }
+        await sleep(500);
+      }, 0);
 
       // Check for updates after loading profiles
       await checkForUpdates();
+      await checkMissingBinaries();
     } catch (err: unknown) {
       console.error("Failed to load profiles:", err);
       setError(`Failed to load profiles: ${JSON.stringify(err)}`);
     }
-  }, [checkForUpdates]);
+  }, [checkForUpdates, checkMissingBinaries]);
 
   useAppUpdateNotifications();
 
@@ -117,42 +229,9 @@ export default function Home() {
     } catch (error) {
       console.error("Failed to check current URL:", error);
     }
-  }, []);
+  }, [handleUrlOpen]);
 
-  useEffect(() => {
-    void loadProfilesWithUpdateCheck();
-
-    // Check for startup default browser prompt
-    void checkStartupPrompt();
-
-    // Listen for URL open events
-    void listenForUrlEvents();
-
-    // 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(
-      () => {
-        void checkForUpdates();
-      },
-      30 * 60 * 1000,
-    );
-
-    return () => {
-      clearInterval(updateInterval);
-    };
-  }, [loadProfilesWithUpdateCheck, checkForUpdates, checkCurrentUrl]);
-
-  // Check permissions when they are initialized
-  useEffect(() => {
-    if (isInitialized) {
-      void checkAllPermissions();
-    }
-  }, [isInitialized]);
-
-  const checkStartupPrompt = async () => {
+  const checkStartupPrompt = useCallback(async () => {
     // Only check once during app startup to prevent reopening after dismissing notifications
     if (hasCheckedStartupPrompt) return;
 
@@ -168,9 +247,9 @@ export default function Home() {
       console.error("Failed to check startup prompt:", error);
       setHasCheckedStartupPrompt(true);
     }
-  };
+  }, [hasCheckedStartupPrompt]);
 
-  const checkAllPermissions = async () => {
+  const checkAllPermissions = useCallback(async () => {
     try {
       // Wait for permissions to be initialized before checking
       if (!isInitialized) {
@@ -188,9 +267,9 @@ export default function Home() {
     } catch (error) {
       console.error("Failed to check permissions:", error);
     }
-  };
+  }, [isMicrophoneAccessGranted, isCameraAccessGranted, isInitialized]);
 
-  const checkNextPermission = () => {
+  const checkNextPermission = useCallback(() => {
     try {
       if (!isMicrophoneAccessGranted) {
         setCurrentPermissionType("microphone");
@@ -204,9 +283,9 @@ export default function Home() {
     } catch (error) {
       console.error("Failed to check next permission:", error);
     }
-  };
+  }, [isMicrophoneAccessGranted, isCameraAccessGranted]);
 
-  const checkStartupUrls = async () => {
+  const checkStartupUrls = useCallback(async () => {
     try {
       const hasStartupUrl = await invoke<boolean>(
         "check_and_handle_startup_url",
@@ -217,9 +296,9 @@ export default function Home() {
     } catch (error) {
       console.error("Failed to check startup URLs:", error);
     }
-  };
+  }, []);
 
-  const listenForUrlEvents = async () => {
+  const listenForUrlEvents = useCallback(async () => {
     try {
       // Listen for URL open events from the deep link handler (when app is already running)
       await listen<string>("url-open-request", (event) => {
@@ -247,27 +326,7 @@ export default function Home() {
     } catch (error) {
       console.error("Failed to setup URL listener:", error);
     }
-  };
-
-  const handleUrlOpen = async (url: string) => {
-    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, no need to show selector
-    } catch (error: unknown) {
-      console.log(
-        "Smart URL opening failed or requires profile selection:",
-        error,
-      );
-
-      // Show profile selector for manual selection
-      // Replace any existing pending URL with the new one
-      setPendingUrls([{ id: Date.now().toString(), url }]);
-    }
-  };
+  }, [handleUrlOpen]);
 
   const openProxyDialog = useCallback((profile: BrowserProfile | null) => {
     setCurrentProfileForProxy(profile);
@@ -279,8 +338,32 @@ export default function Home() {
     setChangeVersionDialogOpen(true);
   }, []);
 
+  const handleConfigureCamoufox = useCallback((profile: BrowserProfile) => {
+    setCurrentProfileForCamoufoxConfig(profile);
+    setCamoufoxConfigDialogOpen(true);
+  }, []);
+
+  const handleSaveCamoufoxConfig = useCallback(
+    async (profile: BrowserProfile, config: CamoufoxConfig) => {
+      setError(null);
+      try {
+        await invoke("update_camoufox_config", {
+          profileName: profile.name,
+          config,
+        });
+        await loadProfiles();
+        setCamoufoxConfigDialogOpen(false);
+      } catch (err: unknown) {
+        console.error("Failed to update camoufox config:", err);
+        setError(`Failed to update camoufox config: ${JSON.stringify(err)}`);
+        throw err;
+      }
+    },
+    [loadProfiles],
+  );
+
   const handleSaveProxy = useCallback(
-    async (proxySettings: ProxySettings) => {
+    async (proxyId: string | null) => {
       setProxyDialogOpen(false);
       setError(null);
 
@@ -288,16 +371,18 @@ export default function Home() {
         if (currentProfileForProxy) {
           await invoke("update_profile_proxy", {
             profileName: currentProfileForProxy.name,
-            proxy: proxySettings,
+            proxyId: proxyId,
           });
         }
         await loadProfiles();
+        // Trigger proxy data reload in the table
+        triggerProxyDataReload();
       } catch (err: unknown) {
         console.error("Failed to update proxy settings:", err);
         setError(`Failed to update proxy settings: ${JSON.stringify(err)}`);
       }
     },
-    [currentProfileForProxy, loadProfiles],
+    [currentProfileForProxy, loadProfiles, triggerProxyDataReload],
   );
 
   const handleCreateProfile = useCallback(
@@ -306,30 +391,27 @@ export default function Home() {
       browserStr: BrowserTypeString;
       version: string;
       releaseType: string;
-      proxy?: ProxySettings;
+      proxyId?: string;
+      camoufoxConfig?: CamoufoxConfig;
     }) => {
       setError(null);
 
       try {
-        const profile = await invoke<BrowserProfile>(
+        const _profile = await invoke<BrowserProfile>(
           "create_browser_profile_new",
           {
             name: profileData.name,
             browserStr: profileData.browserStr,
             version: profileData.version,
             releaseType: profileData.releaseType,
+            proxyId: profileData.proxyId,
+            camoufoxConfig: profileData.camoufoxConfig,
           },
         );
 
-        // Update proxy if provided
-        if (profileData.proxy) {
-          await invoke("update_profile_proxy", {
-            profileName: profile.name,
-            proxy: profileData.proxy,
-          });
-        }
-
         await loadProfiles();
+        // Trigger proxy data reload in the table
+        triggerProxyDataReload();
       } catch (error) {
         setError(
           `Failed to create profile: ${
@@ -339,7 +421,7 @@ export default function Home() {
         throw error;
       }
     },
-    [loadProfiles],
+    [loadProfiles, triggerProxyDataReload],
   );
 
   const [runningProfiles, setRunningProfiles] = useState<Set<string>>(
@@ -411,40 +493,39 @@ export default function Home() {
     [loadProfiles, checkBrowserStatus, isUpdating],
   );
 
-  useEffect(() => {
-    if (profiles.length === 0) return;
-
-    const interval = setInterval(() => {
-      for (const profile of profiles) {
-        void checkBrowserStatus(profile);
-      }
-    }, 500);
-
-    return () => {
-      clearInterval(interval);
-    };
-  }, [profiles, checkBrowserStatus]);
-
-  useEffect(() => {
-    runningProfilesRef.current = runningProfiles;
-  }, [runningProfiles]);
-
-  useEffect(() => {
-    if (error) {
-      showErrorToast(error);
-      setError(null);
-    }
-  }, [error]);
-
   const handleDeleteProfile = useCallback(
     async (profile: BrowserProfile) => {
       setError(null);
+      console.log("Attempting to delete profile:", profile.name);
+
       try {
+        // First check if the browser is running for this profile
+        const isRunning = await invoke<boolean>("check_browser_status", {
+          profile,
+        });
+
+        if (isRunning) {
+          setError(
+            "Cannot delete profile while browser is running. Please stop the browser first.",
+          );
+          return;
+        }
+
+        // Attempt to delete the profile
         await invoke("delete_profile", { profileName: profile.name });
+        console.log("Profile deletion command completed successfully");
+
+        // Give a small delay to ensure file system operations complete
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        // Reload profiles to ensure UI is updated
         await loadProfiles();
+
+        console.log("Profile deleted and profiles reloaded successfully");
       } catch (err: unknown) {
         console.error("Failed to delete profile:", err);
-        setError(`Failed to delete profile: ${JSON.stringify(err)}`);
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        setError(`Failed to delete profile: ${errorMessage}`);
       }
     },
     [loadProfiles],
@@ -479,6 +560,71 @@ export default function Home() {
     [loadProfiles],
   );
 
+  useEffect(() => {
+    void loadProfilesWithUpdateCheck();
+
+    // Check for startup default browser prompt
+    void checkStartupPrompt();
+
+    // Listen for URL open events
+    void listenForUrlEvents();
+
+    // 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(
+      () => {
+        void checkForUpdates();
+      },
+      30 * 60 * 1000,
+    );
+
+    return () => {
+      clearInterval(updateInterval);
+    };
+  }, [
+    loadProfilesWithUpdateCheck,
+    checkForUpdates,
+    checkCurrentUrl,
+    checkStartupPrompt,
+    listenForUrlEvents,
+    checkStartupUrls,
+  ]);
+
+  useEffect(() => {
+    if (profiles.length === 0) return;
+
+    const interval = setInterval(() => {
+      for (const profile of profiles) {
+        void checkBrowserStatus(profile);
+      }
+    }, 500);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, [profiles, checkBrowserStatus]);
+
+  useEffect(() => {
+    runningProfilesRef.current = runningProfiles;
+  }, [runningProfiles]);
+
+  useEffect(() => {
+    if (error) {
+      showErrorToast(error);
+      setError(null);
+    }
+  }, [error]);
+
+  // Check permissions when they are initialized
+  useEffect(() => {
+    if (isInitialized) {
+      void checkAllPermissions();
+    }
+  }, [isInitialized, checkAllPermissions]);
+
   return (
     <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">
@@ -506,6 +652,14 @@ export default function Home() {
                       <GoGear className="mr-2 w-4 h-4" />
                       Settings
                     </DropdownMenuItem>
+                    <DropdownMenuItem
+                      onClick={() => {
+                        setProxyManagementDialogOpen(true);
+                      }}
+                    >
+                      <FiWifi className="mr-2 w-4 h-4" />
+                      Proxies
+                    </DropdownMenuItem>
                     <DropdownMenuItem
                       onClick={() => {
                         setImportProfileDialogOpen(true);
@@ -542,8 +696,12 @@ export default function Home() {
               onDeleteProfile={handleDeleteProfile}
               onRenameProfile={handleRenameProfile}
               onChangeVersion={openChangeVersionDialog}
+              onConfigureCamoufox={handleConfigureCamoufox}
               runningProfiles={runningProfiles}
               isUpdating={isUpdating}
+              onReloadProxyData={
+                proxyDataReloadTrigger > 0 ? triggerProxyDataReload : undefined
+              }
             />
           </CardContent>
         </Card>
@@ -554,8 +712,8 @@ export default function Home() {
         onClose={() => {
           setProxyDialogOpen(false);
         }}
-        onSave={(proxy: ProxySettings) => void handleSaveProxy(proxy)}
-        initialSettings={currentProfileForProxy?.proxy}
+        onSave={handleSaveProxy}
+        initialProxyId={currentProfileForProxy?.proxy_id}
         browserType={currentProfileForProxy?.browser}
       />
 
@@ -591,6 +749,13 @@ export default function Home() {
         onImportComplete={() => void loadProfiles()}
       />
 
+      <ProxyManagementDialog
+        isOpen={proxyManagementDialogOpen}
+        onClose={() => {
+          setProxyManagementDialogOpen(false);
+        }}
+      />
+
       {pendingUrls.map((pendingUrl) => (
         <ProfileSelectorDialog
           key={pendingUrl.id}
@@ -613,6 +778,15 @@ export default function Home() {
         permissionType={currentPermissionType}
         onPermissionGranted={checkNextPermission}
       />
+
+      <CamoufoxConfigDialog
+        isOpen={camoufoxConfigDialogOpen}
+        onClose={() => {
+          setCamoufoxConfigDialogOpen(false);
+        }}
+        profile={currentProfileForCamoufoxConfig}
+        onSave={handleSaveCamoufoxConfig}
+      />
     </div>
   );
 }

src/components/app-update-toast.tsx

@@ -1,26 +1,57 @@
 "use client";
 
+import { FaDownload, FaTimes } from "react-icons/fa";
+import { LuCheckCheck, LuCog, LuRefreshCw } from "react-icons/lu";
 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;
-}
+import type { AppUpdateInfo, AppUpdateProgress } from "@/types";
 
 interface AppUpdateToastProps {
   updateInfo: AppUpdateInfo;
   onUpdate: (updateInfo: AppUpdateInfo) => Promise<void>;
   onDismiss: () => void;
   isUpdating?: boolean;
-  updateProgress?: string;
+  updateProgress?: AppUpdateProgress | null;
+}
+
+function getStageIcon(stage?: string, isUpdating?: boolean) {
+  if (!isUpdating) {
+    return <FaDownload className="flex-shrink-0 w-5 h-5 text-blue-500" />;
+  }
+
+  switch (stage) {
+    case "downloading":
+      return <FaDownload className="flex-shrink-0 w-5 h-5 text-blue-500" />;
+    case "extracting":
+      return (
+        <LuRefreshCw className="flex-shrink-0 w-5 h-5 text-blue-500 animate-spin" />
+      );
+    case "installing":
+      return (
+        <LuCog className="flex-shrink-0 w-5 h-5 text-blue-500 animate-spin" />
+      );
+    case "completed":
+      return <LuCheckCheck className="flex-shrink-0 w-5 h-5 text-green-500" />;
+    default:
+      return (
+        <LuRefreshCw className="flex-shrink-0 w-5 h-5 text-blue-500 animate-spin" />
+      );
+  }
+}
+
+function getStageDisplayName(stage?: string) {
+  switch (stage) {
+    case "downloading":
+      return "Downloading";
+    case "extracting":
+      return "Extracting";
+    case "installing":
+      return "Installing";
+    case "completed":
+      return "Completed";
+    default:
+      return "Updating";
+  }
 }
 
 export function AppUpdateToast({
@@ -34,22 +65,32 @@ export function AppUpdateToast({
     await onUpdate(updateInfo);
   };
 
+  const showDownloadProgress =
+    isUpdating &&
+    updateProgress?.stage === "downloading" &&
+    updateProgress.percentage !== undefined;
+
+  const showOtherStageProgress =
+    isUpdating &&
+    updateProgress &&
+    (updateProgress.stage === "extracting" ||
+      updateProgress.stage === "installing" ||
+      updateProgress.stage === "completed");
+
   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="flex items-start p-4 w-full max-w-md bg-white rounded-lg border border-gray-200 shadow-lg dark:bg-gray-800 dark:border-gray-700">
       <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" />
-        )}
+        {getStageIcon(updateProgress?.stage, isUpdating)}
       </div>
 
       <div className="flex-1 min-w-0">
-        <div className="flex items-start justify-between gap-2">
+        <div className="flex gap-2 justify-between items-start">
           <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
+            <div className="flex gap-2 items-center">
+              <span className="text-sm font-semibold text-foreground">
+                {isUpdating
+                  ? `${getStageDisplayName(updateProgress?.stage)} Donut Browser Update`
+                  : "Donut Browser Update Available"}
               </span>
               <Badge
                 variant={updateInfo.is_nightly ? "secondary" : "default"}
@@ -59,8 +100,14 @@ export function AppUpdateToast({
               </Badge>
             </div>
             <div className="text-xs text-muted-foreground">
-              Update from {updateInfo.current_version} to{" "}
-              <span className="font-medium">{updateInfo.new_version}</span>
+              {isUpdating ? (
+                updateProgress?.message || "Updating..."
+              ) : (
+                <>
+                  Update from {updateInfo.current_version} to{" "}
+                  <span className="font-medium">{updateInfo.new_version}</span>
+                </>
+              )}
             </div>
           </div>
 
@@ -69,27 +116,76 @@ export function AppUpdateToast({
               variant="ghost"
               size="sm"
               onClick={onDismiss}
-              className="h-6 w-6 p-0 shrink-0"
+              className="p-0 w-6 h-6 shrink-0"
             >
-              <FaTimes className="h-3 w-3" />
+              <FaTimes className="w-3 h-3" />
             </Button>
           )}
         </div>
 
-        {isUpdating && updateProgress && (
-          <div className="mt-2">
-            <p className="text-xs text-muted-foreground">{updateProgress}</p>
+        {/* Download progress */}
+        {showDownloadProgress && updateProgress && (
+          <div className="mt-2 space-y-1">
+            <div className="flex justify-between items-center">
+              <p className="flex-1 min-w-0 text-xs text-muted-foreground">
+                {updateProgress.percentage?.toFixed(1)}%
+                {updateProgress.speed && ` • ${updateProgress.speed} MB/s`}
+                {updateProgress.eta && ` • ${updateProgress.eta} remaining`}
+              </p>
+            </div>
+            <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+              <div
+                className="bg-blue-500 h-1.5 rounded-full transition-all duration-300"
+                style={{ width: `${updateProgress.percentage}%` }}
+              />
+            </div>
+          </div>
+        )}
+
+        {/* Other stage progress (with visual indicators) */}
+        {showOtherStageProgress && (
+          <div className="mt-2 space-y-2">
+            <p className="text-xs text-muted-foreground">
+              {updateProgress.message}
+            </p>
+
+            {/* Progress indicator for non-downloading stages */}
+            <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+              <div
+                className={`h-1.5 rounded-full transition-all duration-500 ${
+                  updateProgress.stage === "completed"
+                    ? "bg-green-500 w-full"
+                    : "bg-blue-500 w-full animate-pulse"
+                }`}
+              />
+            </div>
+
+            {updateProgress.stage === "extracting" && (
+              <p className="text-xs text-muted-foreground">
+                Preparing update files...
+              </p>
+            )}
+            {updateProgress.stage === "installing" && (
+              <p className="text-xs text-muted-foreground">
+                Installing new version...
+              </p>
+            )}
+            {updateProgress.stage === "completed" && (
+              <p className="text-xs text-green-600 dark:text-green-400">
+                Update completed! Restarting application...
+              </p>
+            )}
           </div>
         )}
 
         {!isUpdating && (
-          <div className="flex items-center gap-2 mt-3">
+          <div className="flex gap-2 items-center mt-3">
             <Button
               onClick={() => void handleUpdateClick()}
               size="sm"
-              className="flex items-center gap-2 text-xs"
+              className="flex gap-2 items-center text-xs"
             >
-              <FaDownload className="h-3 w-3" />
+              <FaDownload className="w-3 h-3" />
               Update Now
             </Button>
             <Button
@@ -102,21 +198,6 @@ export function AppUpdateToast({
             </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/camoufox-config-dialog.tsx

@@ -0,0 +1,502 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import type { BrowserProfile, CamoufoxConfig } from "@/types";
+
+interface CamoufoxConfigDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  profile: BrowserProfile | null;
+  onSave: (profile: BrowserProfile, config: CamoufoxConfig) => Promise<void>;
+}
+
+const osOptions = [
+  { value: "windows", label: "Windows" },
+  { value: "macos", label: "macOS" },
+  { value: "linux", label: "Linux" },
+];
+
+const timezoneOptions = [
+  { value: "America/New_York", label: "America/New_York" },
+  { value: "America/Los_Angeles", label: "America/Los_Angeles" },
+  { value: "Europe/London", label: "Europe/London" },
+  { value: "Europe/Paris", label: "Europe/Paris" },
+  { value: "Asia/Tokyo", label: "Asia/Tokyo" },
+  { value: "Asia/Shanghai", label: "Asia/Shanghai" },
+  { value: "Australia/Sydney", label: "Australia/Sydney" },
+];
+
+const localeOptions = [
+  { value: "en-US", label: "English (US)" },
+  { value: "en-GB", label: "English (UK)" },
+  { value: "fr-FR", label: "French" },
+  { value: "de-DE", label: "German" },
+  { value: "es-ES", label: "Spanish" },
+  { value: "it-IT", label: "Italian" },
+  { value: "ja-JP", label: "Japanese" },
+  { value: "zh-CN", label: "Chinese (Simplified)" },
+];
+
+const getCurrentOS = () => {
+  if (typeof window !== "undefined") {
+    const userAgent = window.navigator.userAgent;
+    if (userAgent.includes("Win")) return "windows";
+    if (userAgent.includes("Mac")) return "macos";
+    if (userAgent.includes("Linux")) return "linux";
+  }
+  return "unknown";
+};
+
+export function CamoufoxConfigDialog({
+  isOpen,
+  onClose,
+  profile,
+  onSave,
+}: CamoufoxConfigDialogProps) {
+  const [config, setConfig] = useState<CamoufoxConfig>({
+    enable_cache: true,
+    os: [getCurrentOS()],
+  });
+  const [isSaving, setIsSaving] = useState(false);
+
+  // Initialize config when profile changes
+  useEffect(() => {
+    if (profile && profile.browser === "camoufox") {
+      setConfig(
+        profile.camoufox_config || {
+          enable_cache: true,
+          os: [getCurrentOS()],
+        },
+      );
+    }
+  }, [profile]);
+
+  const updateConfig = (key: keyof CamoufoxConfig, value: unknown) => {
+    setConfig((prev) => ({ ...prev, [key]: value }));
+  };
+
+  const handleSave = async () => {
+    if (!profile) return;
+
+    setIsSaving(true);
+    try {
+      await onSave(profile, config);
+      onClose();
+    } catch (error) {
+      console.error("Failed to save camoufox config:", error);
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handleClose = () => {
+    // Reset config to original when closing without saving
+    if (profile && profile.browser === "camoufox") {
+      setConfig(
+        profile.camoufox_config || {
+          enable_cache: true,
+          os: [getCurrentOS()],
+        },
+      );
+    }
+    onClose();
+  };
+
+  if (!profile || profile.browser !== "camoufox") {
+    return null;
+  }
+
+  // Get the selected OS for warning
+  const selectedOS = config.os?.[0];
+  const currentOS = getCurrentOS();
+  const showOSWarning =
+    selectedOS && selectedOS !== currentOS && currentOS !== "unknown";
+
+  return (
+    <Dialog open={isOpen} onOpenChange={handleClose}>
+      <DialogContent className="max-w-3xl max-h-[90vh] flex flex-col">
+        <DialogHeader className="flex-shrink-0">
+          <DialogTitle>
+            Configure Camoufox Settings - {profile.name}
+          </DialogTitle>
+        </DialogHeader>
+
+        <ScrollArea className="flex-1 pr-6 h-[320px]">
+          <div className="py-4 space-y-6">
+            {/* Operating System */}
+            <div className="space-y-3">
+              <Label>Operating System Fingerprint</Label>
+              <Select
+                value={selectedOS || ""}
+                onValueChange={(value: string) => updateConfig("os", [value])}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Select OS" />
+                </SelectTrigger>
+                <SelectContent>
+                  {osOptions.map((os) => (
+                    <SelectItem key={os.value} value={os.value}>
+                      {os.label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              {showOSWarning && (
+                <div className="p-3 bg-amber-50 rounded-md border border-amber-200">
+                  <p className="text-sm text-amber-800">
+                    ⚠️ Warning: Spoofing OS features is detectable by advanced
+                    anti-bot systems. Some platform-specific APIs and behaviors
+                    cannot be fully replicated.
+                  </p>
+                </div>
+              )}
+            </div>
+
+            {/* Blocking Options */}
+            <div className="space-y-3">
+              <Label>Privacy & Blocking</Label>
+              <div className="space-y-2">
+                <div className="flex items-center space-x-2">
+                  <Checkbox
+                    id="block-images"
+                    checked={config.block_images || false}
+                    onCheckedChange={(checked) =>
+                      updateConfig("block_images", checked)
+                    }
+                  />
+                  <Label htmlFor="block-images">Block Images</Label>
+                </div>
+                <div className="flex items-center space-x-2">
+                  <Checkbox
+                    id="block-webrtc"
+                    checked={config.block_webrtc || false}
+                    onCheckedChange={(checked) =>
+                      updateConfig("block_webrtc", checked)
+                    }
+                  />
+                  <Label htmlFor="block-webrtc">Block WebRTC</Label>
+                </div>
+                <div className="flex items-center space-x-2">
+                  <Checkbox
+                    id="block-webgl"
+                    checked={config.block_webgl || false}
+                    onCheckedChange={(checked) =>
+                      updateConfig("block_webgl", checked)
+                    }
+                  />
+                  <Label htmlFor="block-webgl">Block WebGL</Label>
+                </div>
+              </div>
+            </div>
+
+            {/* Geolocation */}
+            <div className="space-y-3">
+              <Label>Geolocation</Label>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="country">Country</Label>
+                  <Input
+                    id="country"
+                    value={config.country || ""}
+                    onChange={(e) =>
+                      updateConfig("country", e.target.value || undefined)
+                    }
+                    placeholder="e.g., US, GB, DE"
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label>Timezone</Label>
+                  <Select
+                    value={config.timezone || "auto"}
+                    onValueChange={(value) =>
+                      updateConfig(
+                        "timezone",
+                        value === "auto" ? undefined : value,
+                      )
+                    }
+                  >
+                    <SelectTrigger>
+                      <SelectValue placeholder="Select timezone" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="auto">Auto</SelectItem>
+                      {timezoneOptions.map((tz) => (
+                        <SelectItem key={tz.value} value={tz.value}>
+                          {tz.label}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </div>
+              </div>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="latitude">Latitude</Label>
+                  <Input
+                    id="latitude"
+                    type="number"
+                    step="any"
+                    value={config.latitude || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "latitude",
+                        e.target.value ? parseFloat(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 40.7128"
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="longitude">Longitude</Label>
+                  <Input
+                    id="longitude"
+                    type="number"
+                    step="any"
+                    value={config.longitude || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "longitude",
+                        e.target.value ? parseFloat(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., -74.0060"
+                  />
+                </div>
+              </div>
+            </div>
+
+            {/* Localization */}
+            <div className="space-y-3">
+              <Label>Locale</Label>
+              <Select
+                value={config.locale?.[0] || ""}
+                onValueChange={(value) =>
+                  updateConfig("locale", value ? [value] : undefined)
+                }
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Select locale" />
+                </SelectTrigger>
+                <SelectContent>
+                  {localeOptions.map((locale) => (
+                    <SelectItem key={locale.value} value={locale.value}>
+                      {locale.label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+
+            {/* Screen Resolution */}
+            <div className="space-y-3">
+              <Label>Screen Resolution</Label>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="screen-min-width">Min Width</Label>
+                  <Input
+                    id="screen-min-width"
+                    type="number"
+                    value={config.screen_min_width || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "screen_min_width",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 1024"
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="screen-max-width">Max Width</Label>
+                  <Input
+                    id="screen-max-width"
+                    type="number"
+                    value={config.screen_max_width || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "screen_max_width",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 1920"
+                  />
+                </div>
+              </div>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="screen-min-height">Min Height</Label>
+                  <Input
+                    id="screen-min-height"
+                    type="number"
+                    value={config.screen_min_height || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "screen_min_height",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 768"
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="screen-max-height">Max Height</Label>
+                  <Input
+                    id="screen-max-height"
+                    type="number"
+                    value={config.screen_max_height || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "screen_max_height",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 1080"
+                  />
+                </div>
+              </div>
+            </div>
+
+            {/* Window Size */}
+            <div className="space-y-3">
+              <Label>Window Size</Label>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="window-width">Width</Label>
+                  <Input
+                    id="window-width"
+                    type="number"
+                    value={config.window_width || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "window_width",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 1366"
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="window-height">Height</Label>
+                  <Input
+                    id="window-height"
+                    type="number"
+                    value={config.window_height || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "window_height",
+                        e.target.value ? parseInt(e.target.value) : undefined,
+                      )
+                    }
+                    placeholder="e.g., 768"
+                  />
+                </div>
+              </div>
+            </div>
+
+            {/* Advanced Options */}
+            <div className="space-y-3">
+              <Label>Advanced Options</Label>
+              <div className="space-y-2">
+                <div className="flex items-center space-x-2">
+                  <Checkbox
+                    id="enable-cache"
+                    checked={config.enable_cache || false}
+                    onCheckedChange={(checked) =>
+                      updateConfig("enable_cache", checked)
+                    }
+                  />
+                  <Label htmlFor="enable-cache">Enable Browser Cache</Label>
+                </div>
+                <div className="flex items-center space-x-2">
+                  <Checkbox
+                    id="main-world-eval"
+                    checked={config.main_world_eval || false}
+                    onCheckedChange={(checked) =>
+                      updateConfig("main_world_eval", checked)
+                    }
+                  />
+                  <Label htmlFor="main-world-eval">
+                    Enable Main World Evaluation
+                  </Label>
+                </div>
+              </div>
+            </div>
+
+            {/* WebGL Settings */}
+            <div className="space-y-3">
+              <Label>WebGL Settings</Label>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="webgl-vendor">WebGL Vendor</Label>
+                  <Input
+                    id="webgl-vendor"
+                    value={config.webgl_vendor || ""}
+                    onChange={(e) =>
+                      updateConfig("webgl_vendor", e.target.value || undefined)
+                    }
+                    placeholder="e.g., Intel Inc."
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="webgl-renderer">WebGL Renderer</Label>
+                  <Input
+                    id="webgl-renderer"
+                    value={config.webgl_renderer || ""}
+                    onChange={(e) =>
+                      updateConfig(
+                        "webgl_renderer",
+                        e.target.value || undefined,
+                      )
+                    }
+                    placeholder="e.g., Intel Iris OpenGL Engine"
+                  />
+                </div>
+              </div>
+            </div>
+
+            {/* Debug Options */}
+            <div className="space-y-3">
+              <Label>Debug Options</Label>
+              <div className="flex items-center space-x-2">
+                <Checkbox
+                  id="debug"
+                  checked={config.debug || false}
+                  onCheckedChange={(checked) => updateConfig("debug", checked)}
+                />
+                <Label htmlFor="debug">Enable Debug Mode</Label>
+              </div>
+            </div>
+          </div>
+        </ScrollArea>
+
+        <DialogFooter className="flex-shrink-0 pt-4 border-t">
+          <Button variant="outline" onClick={handleClose}>
+            Cancel
+          </Button>
+          <Button onClick={handleSave} disabled={isSaving}>
+            {isSaving ? "Saving..." : "Save Configuration"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

src/components/change-version-dialog.tsx

@@ -1,5 +1,8 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
+import { LuTriangleAlert } from "react-icons/lu";
 import { LoadingButton } from "@/components/loading-button";
 import { ReleaseTypeSelector } from "@/components/release-type-selector";
 import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
@@ -16,9 +19,6 @@ import { Label } from "@/components/ui/label";
 import { useBrowserDownload } from "@/hooks/use-browser-download";
 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";
 
 interface ChangeVersionDialogProps {
   isOpen: boolean;
@@ -50,17 +50,7 @@ export function ChangeVersionDialog({
     isVersionDownloaded,
   } = useBrowserDownload();
 
-  useEffect(() => {
-    if (isOpen && profile) {
-      // Set current release type based on profile
-      setSelectedReleaseType(profile.release_type as "stable" | "nightly");
-      setAcknowledgeDowngrade(false);
-      void loadReleaseTypes(profile.browser);
-      void loadDownloadedVersions(profile.browser);
-    }
-  }, [isOpen, profile, loadDownloadedVersions]);
-
-  const loadReleaseTypes = async (browser: string) => {
+  const loadReleaseTypes = useCallback(async (browser: string) => {
     setIsLoadingReleaseTypes(true);
     try {
       const releaseTypes = await invoke<BrowserReleaseTypes>(
@@ -73,7 +63,7 @@ export function ChangeVersionDialog({
     } finally {
       setIsLoadingReleaseTypes(false);
     }
-  };
+  }, []);
 
   useEffect(() => {
     if (
@@ -93,7 +83,7 @@ export function ChangeVersionDialog({
     }
   }, [selectedReleaseType, profile]);
 
-  const handleDownload = async () => {
+  const handleDownload = useCallback(async () => {
     if (!profile || !selectedReleaseType) return;
 
     const version =
@@ -103,9 +93,9 @@ export function ChangeVersionDialog({
     if (!version) return;
 
     await downloadBrowser(profile.browser, version);
-  };
+  }, [profile, selectedReleaseType, downloadBrowser, releaseTypes]);
 
-  const handleVersionChange = async () => {
+  const handleVersionChange = useCallback(async () => {
     if (!profile || !selectedReleaseType) return;
 
     const version =
@@ -127,7 +117,7 @@ export function ChangeVersionDialog({
     } finally {
       setIsUpdating(false);
     }
-  };
+  }, [profile, selectedReleaseType, releaseTypes, onVersionChanged, onClose]);
 
   const selectedVersion =
     selectedReleaseType === "stable"
@@ -142,6 +132,16 @@ export function ChangeVersionDialog({
     isVersionDownloaded(selectedVersion) &&
     (!showDowngradeWarning || acknowledgeDowngrade);
 
+  useEffect(() => {
+    if (isOpen && profile) {
+      // Set current release type based on profile
+      setSelectedReleaseType(profile.release_type as "stable" | "nightly");
+      setAcknowledgeDowngrade(false);
+      void loadReleaseTypes(profile.browser);
+      void loadDownloadedVersions(profile.browser);
+    }
+  }, [isOpen, profile, loadDownloadedVersions, loadReleaseTypes]);
+
   if (!profile) return null;
 
   return (

src/components/create-profile-dialog.tsx

@@ -1,9 +1,11 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
 import { LoadingButton } from "@/components/loading-button";
-import { ReleaseTypeSelector } from "@/components/release-type-selector";
+import { SharedCamoufoxConfigForm } from "@/components/shared-camoufox-config-form";
 import { Button } from "@/components/ui/button";
-import { Checkbox } from "@/components/ui/checkbox";
+import { Combobox } from "@/components/ui/combobox";
 import {
   Dialog,
   DialogContent,
@@ -13,6 +15,7 @@ import {
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
+import { ScrollArea } from "@/components/ui/scroll-area";
 import {
   Select,
   SelectContent,
@@ -20,23 +23,10 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@/components/ui/tooltip";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { useBrowserDownload } from "@/hooks/use-browser-download";
-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";
+import { getBrowserIcon, getCurrentOS } from "@/lib/browser-utils";
+import type { BrowserReleaseTypes, CamoufoxConfig, StoredProxy } from "@/types";
 
 type BrowserTypeString =
   | "mullvad-browser"
@@ -45,7 +35,8 @@ type BrowserTypeString =
   | "chromium"
   | "brave"
   | "zen"
-  | "tor-browser";
+  | "tor-browser"
+  | "camoufox";
 
 interface CreateProfileDialogProps {
   isOpen: boolean;
@@ -55,211 +46,211 @@ interface CreateProfileDialogProps {
     browserStr: BrowserTypeString;
     version: string;
     releaseType: string;
-    proxy?: ProxySettings;
+    proxyId?: string;
+    camoufoxConfig?: CamoufoxConfig;
   }) => Promise<void>;
 }
 
+interface BrowserOption {
+  value: BrowserTypeString;
+  label: string;
+  description: string;
+}
+
+const browserOptions: BrowserOption[] = [
+  {
+    value: "firefox",
+    label: "Firefox",
+    description: "Mozilla's main web browser",
+  },
+  {
+    value: "firefox-developer",
+    label: "Firefox Developer Edition",
+    description: "Browser for developers with cutting-edge features",
+  },
+  {
+    value: "chromium",
+    label: "Chromium",
+    description: "Open-source version of Chrome",
+  },
+  {
+    value: "brave",
+    label: "Brave",
+    description: "Privacy-focused browser with ad blocking",
+  },
+  {
+    value: "zen",
+    label: "Zen Browser",
+    description: "Beautiful, customizable Firefox-based browser",
+  },
+  {
+    value: "mullvad-browser",
+    label: "Mullvad Browser",
+    description: "Privacy browser by Mullvad VPN",
+  },
+  {
+    value: "tor-browser",
+    label: "Tor Browser",
+    description: "Browse anonymously through the Tor network",
+  },
+];
+
+const IS_ANTI_DETECT_SUPPORTED = false;
+
 export function CreateProfileDialog({
   isOpen,
   onClose,
   onCreateProfile,
 }: CreateProfileDialogProps) {
   const [profileName, setProfileName] = useState("");
-  const [selectedBrowser, setSelectedBrowser] =
-    useState<BrowserTypeString | null>("mullvad-browser");
-  const [selectedReleaseType, setSelectedReleaseType] = useState<
-    "stable" | "nightly" | null
-  >(null);
-  const [releaseTypes, setReleaseTypes] = useState<BrowserReleaseTypes>({
-    stable: undefined,
-    nightly: undefined,
+  const [activeTab, setActiveTab] = useState("regular");
+
+  // Regular browser states
+  const [selectedBrowser, setSelectedBrowser] = useState<BrowserTypeString>();
+  const [selectedProxyId, setSelectedProxyId] = useState<string>();
+
+  // Camoufox anti-detect states
+  const [camoufoxConfig, setCamoufoxConfig] = useState<CamoufoxConfig>({
+    enable_cache: true, // Cache enabled by default
+    os: [getCurrentOS()], // Default to current OS
   });
+
+  // Common states
+  const [availableReleaseTypes, setAvailableReleaseTypes] =
+    useState<BrowserReleaseTypes>({});
+  const [camoufoxReleaseTypes, setCamoufoxReleaseTypes] =
+    useState<BrowserReleaseTypes>({});
+  const [supportedBrowsers, setSupportedBrowsers] = useState<string[]>([]);
+  const [storedProxies, setStoredProxies] = useState<StoredProxy[]>([]);
   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("");
 
+  // Use the browser download hook
   const {
+    isBrowserDownloading,
     downloadBrowser,
-    isDownloading,
-    downloadedVersions,
     loadDownloadedVersions,
     isVersionDownloaded,
   } = useBrowserDownload();
 
-  const {
-    supportedBrowsers,
-    isLoading: isLoadingSupport,
-    isBrowserSupported,
-  } = useBrowserSupport();
+  const loadSupportedBrowsers = useCallback(async () => {
+    try {
+      const browsers = await invoke<string[]>("get_supported_browsers");
+      setSupportedBrowsers(browsers);
+    } catch (error) {
+      console.error("Failed to load supported browsers:", error);
+    }
+  }, []);
 
+  const loadStoredProxies = useCallback(async () => {
+    try {
+      const proxies = await invoke<StoredProxy[]>("get_stored_proxies");
+      setStoredProxies(proxies);
+    } catch (error) {
+      console.error("Failed to load stored proxies:", error);
+    }
+  }, []);
+
+  const loadReleaseTypes = useCallback(
+    async (browser: string) => {
+      try {
+        const releaseTypes = await invoke<BrowserReleaseTypes>(
+          "get_browser_release_types",
+          { browserStr: browser },
+        );
+
+        if (browser === "camoufox") {
+          setCamoufoxReleaseTypes(releaseTypes);
+        } else {
+          setAvailableReleaseTypes(releaseTypes);
+        }
+
+        // Load downloaded versions for this browser
+        await loadDownloadedVersions(browser);
+      } catch (error) {
+        console.error(`Failed to load release types for ${browser}:`, error);
+      }
+    },
+    [loadDownloadedVersions],
+  );
+
+  // Load data when dialog opens
   useEffect(() => {
     if (isOpen) {
-      void loadExistingProfiles();
+      void loadSupportedBrowsers();
+      void loadStoredProxies();
+      // Load camoufox release types when dialog opens
+      void loadReleaseTypes("camoufox");
     }
-  }, [isOpen]);
+  }, [isOpen, loadSupportedBrowsers, loadStoredProxies, loadReleaseTypes]);
 
+  // Load release types when browser selection changes
   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 release type when browser changes
-      setSelectedReleaseType(null);
+    if (selectedBrowser) {
       void loadReleaseTypes(selectedBrowser);
-      void loadDownloadedVersions(selectedBrowser);
     }
-  }, [isOpen, selectedBrowser, loadDownloadedVersions]);
+  }, [selectedBrowser, loadReleaseTypes]);
 
-  // Set default release type when release types are loaded
-  useEffect(() => {
-    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");
-      }
+  const handleDownload = async (browserStr: string) => {
+    const releaseTypes =
+      browserStr === "camoufox" ? camoufoxReleaseTypes : availableReleaseTypes;
+    const latestStableVersion = releaseTypes.stable;
+
+    if (!latestStableVersion) {
+      console.error("No stable version available for download");
+      return;
     }
-  }, [releaseTypes, selectedReleaseType, selectedBrowser]);
 
-  const loadExistingProfiles = async () => {
     try {
-      const profiles = await invoke<BrowserProfile[]>("list_browser_profiles");
-      setExistingProfiles(profiles);
+      await downloadBrowser(browserStr, latestStableVersion);
     } catch (error) {
-      console.error("Failed to load existing profiles:", error);
+      console.error("Failed to download browser:", error);
     }
   };
 
-  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 || !selectedReleaseType) return;
-
-    const version =
-      selectedReleaseType === "stable"
-        ? releaseTypes.stable
-        : releaseTypes.nightly;
-    if (!version) return;
-
-    await downloadBrowser(selectedBrowser, version);
-  };
-
-  const validateProfileName = (name: string): string | null => {
-    const trimmedName = name.trim();
-
-    if (!trimmedName) {
-      return "Profile name cannot be empty";
-    }
-
-    // Check for duplicate names (case insensitive)
-    const isDuplicate = existingProfiles.some(
-      (profile) => profile.name.toLowerCase() === trimmedName.toLowerCase(),
-    );
-
-    if (isDuplicate) {
-      return "A profile with this name already exists";
-    }
-
-    return null;
-  };
-
-  // Helper to determine if proxy should be disabled for the selected browser
-  const isProxyDisabled = selectedBrowser === "tor-browser";
-
-  // Update proxy enabled state when browser changes to tor-browser
-  useEffect(() => {
-    if (selectedBrowser === "tor-browser" && proxyEnabled) {
-      setProxyEnabled(false);
-    }
-  }, [selectedBrowser, proxyEnabled]);
-
   const handleCreate = async () => {
-    if (!profileName.trim() || !selectedBrowser || !selectedReleaseType) return;
-
-    // Validate profile name
-    const nameError = validateProfileName(profileName);
-    if (nameError) {
-      toast.error(nameError);
-      return;
-    }
-
-    const version =
-      selectedReleaseType === "stable"
-        ? releaseTypes.stable
-        : releaseTypes.nightly;
-    if (!version) {
-      toast.error("Selected release type is not available");
-      return;
-    }
+    if (!profileName.trim()) return;
 
     setIsCreating(true);
     try {
-      const proxy =
-        proxyEnabled && !isProxyDisabled
-          ? {
-              enabled: true,
-              proxy_type: proxyType,
-              host: proxyHost,
-              port: proxyPort,
-              username: proxyUsername || undefined,
-              password: proxyPassword || undefined,
-            }
-          : undefined;
+      if (activeTab === "regular") {
+        if (!selectedBrowser) {
+          console.error("Missing required browser selection");
+          return;
+        }
 
-      await onCreateProfile({
-        name: profileName.trim(),
-        browserStr: selectedBrowser,
-        version,
-        releaseType: selectedReleaseType,
-        proxy,
-      });
+        // Use the latest stable version by default
+        const latestStableVersion = availableReleaseTypes.stable;
+        if (!latestStableVersion) {
+          console.error("No stable version available");
+          return;
+        }
 
-      // Reset form
-      setProfileName("");
-      setSelectedReleaseType(null);
-      setProxyEnabled(false);
-      setProxyHost("");
-      setProxyPort(8080);
-      setProxyUsername("");
-      setProxyPassword("");
-      onClose();
+        await onCreateProfile({
+          name: profileName.trim(),
+          browserStr: selectedBrowser,
+          version: latestStableVersion,
+          releaseType: "stable",
+          proxyId: selectedProxyId,
+        });
+      } else {
+        // Anti-detect tab - always use Camoufox with latest version
+        const latestCamoufoxVersion = camoufoxReleaseTypes.stable;
+        if (!latestCamoufoxVersion) {
+          console.error("No Camoufox version available");
+          return;
+        }
+
+        await onCreateProfile({
+          name: profileName.trim(),
+          browserStr: "camoufox" as BrowserTypeString,
+          version: latestCamoufoxVersion,
+          releaseType: "stable",
+          proxyId: selectedProxyId,
+          camoufoxConfig,
+        });
+      }
+
+      handleClose();
     } catch (error) {
       console.error("Failed to create profile:", error);
     } finally {
@@ -267,278 +258,227 @@ export function CreateProfileDialog({
     }
   };
 
-  const nameError = profileName.trim()
-    ? validateProfileName(profileName)
-    : null;
+  const handleClose = () => {
+    // Reset all states
+    setProfileName("");
+    setSelectedBrowser(undefined);
+    setSelectedProxyId(undefined);
+    setCamoufoxConfig({
+      enable_cache: true,
+      os: [getCurrentOS()], // Reset to current OS
+    });
+    setActiveTab("regular");
+    onClose();
+  };
 
-  const selectedVersion =
-    selectedReleaseType === "stable"
-      ? releaseTypes.stable
-      : releaseTypes.nightly;
+  const isCreateDisabled = () => {
+    if (!profileName.trim()) return true;
 
-  const canCreate =
-    profileName.trim() &&
-    selectedBrowser &&
-    selectedReleaseType &&
-    selectedVersion &&
-    isVersionDownloaded(selectedVersion) &&
-    (!proxyEnabled || isProxyDisabled || (proxyHost && proxyPort)) &&
-    !nameError;
+    if (activeTab === "regular") {
+      return !selectedBrowser || !availableReleaseTypes.stable;
+    } else {
+      // For anti-detect, we need camoufox to be available
+      return !camoufoxReleaseTypes.stable;
+    }
+  };
+
+  const updateCamoufoxConfig = (key: keyof CamoufoxConfig, value: unknown) => {
+    setCamoufoxConfig((prev) => ({ ...prev, [key]: value }));
+  };
+
+  // Check if browser version is downloaded and available
+  const isBrowserVersionAvailable = (browserStr: string) => {
+    const releaseTypes =
+      browserStr === "camoufox" ? camoufoxReleaseTypes : availableReleaseTypes;
+    const latestStableVersion = releaseTypes.stable;
+    return latestStableVersion && isVersionDownloaded(latestStableVersion);
+  };
+
+  // Get the selected OS for warning
+  const selectedOS = camoufoxConfig.os?.[0];
+  const currentOS = getCurrentOS();
+  const _showOSWarning =
+    selectedOS && selectedOS !== currentOS && currentOS !== "unknown";
 
   return (
-    <Dialog open={isOpen} onOpenChange={onClose}>
-      <DialogContent className="max-w-md max-h-[80vh] my-8 flex flex-col">
+    <Dialog open={isOpen} onOpenChange={handleClose}>
+      <DialogContent className="max-w-4xl max-h-[90vh] flex flex-col">
         <DialogHeader className="flex-shrink-0">
           <DialogTitle>Create New Profile</DialogTitle>
         </DialogHeader>
 
-        <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>
-            <Input
-              id="profile-name"
-              value={profileName}
-              onChange={(e) => {
-                setProfileName(e.target.value);
-              }}
-              placeholder="Enter profile name"
-              className={nameError ? "border-red-500" : ""}
-            />
-            {nameError && <p className="text-sm text-red-600">{nameError}</p>}
-          </div>
+        <Tabs
+          value={activeTab}
+          onValueChange={setActiveTab}
+          className="flex flex-col flex-1 w-full min-h-0"
+        >
+          <TabsList className="grid flex-shrink-0 grid-cols-2 w-full">
+            <TabsTrigger value="regular">Regular Browsers</TabsTrigger>
+            <TabsTrigger value="anti-detect">Anti-Detect</TabsTrigger>
+          </TabsList>
 
-          {/* Browser Selection */}
-          <div className="grid gap-2">
-            <Label>Browser</Label>
-            <Select
-              value={selectedBrowser ?? undefined}
-              onValueChange={(value) => {
-                setSelectedBrowser(value as BrowserTypeString);
-              }}
-              disabled={isLoadingSupport}
-            >
-              <SelectTrigger>
-                <SelectValue
-                  placeholder={
-                    isLoadingSupport ? "Loading browsers..." : "Select browser"
-                  }
+          <ScrollArea className="flex-1 pr-6 h-[320px]">
+            <div className="py-4 space-y-6">
+              {/* Profile Name - Common to both tabs */}
+              <div className="space-y-2">
+                <Label htmlFor="profile-name">Profile Name</Label>
+                <Input
+                  id="profile-name"
+                  value={profileName}
+                  onChange={(e) => setProfileName(e.target.value)}
+                  placeholder="Enter profile name"
                 />
-              </SelectTrigger>
-              <SelectContent>
-                {(
-                  [
-                    "mullvad-browser",
-                    "firefox",
-                    "firefox-developer",
-                    "chromium",
-                    "brave",
-                    "zen",
-                    "tor-browser",
-                  ] as BrowserTypeString[]
-                ).map((browser) => {
-                  const isSupported = isBrowserSupported(browser);
-                  const displayName = getBrowserDisplayName(browser);
+              </div>
 
-                  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>
-
-          {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>
-              ) : (
+              <TabsContent value="regular" className="mt-0 space-y-6">
                 <div className="space-y-4">
-                  {(!releaseTypes.stable || !releaseTypes.nightly) && (
-                    <Alert>
-                      <AlertDescription>
-                        Only {(releaseTypes.stable && "Stable") ?? "Nightly"}{" "}
-                        releases are available for{" "}
-                        {getBrowserDisplayName(selectedBrowser)}.
-                      </AlertDescription>
-                    </Alert>
-                  )}
+                  <div className="space-y-2">
+                    <Label>Browser</Label>
+                    <Combobox
+                      options={browserOptions
+                        .filter((browser) =>
+                          supportedBrowsers.includes(browser.value),
+                        )
+                        .map((browser) => {
+                          const IconComponent = getBrowserIcon(browser.value);
+                          return {
+                            value: browser.value,
+                            label: browser.label,
+                            icon: IconComponent,
+                          };
+                        })}
+                      value={selectedBrowser || ""}
+                      onValueChange={(value) =>
+                        setSelectedBrowser(value as BrowserTypeString)
+                      }
+                      placeholder="Select a browser..."
+                      searchPlaceholder="Search browsers..."
+                    />
+                  </div>
 
-                  <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">
-            <div className="flex items-center space-x-2">
-              {isProxyDisabled ? (
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <div className="flex items-center space-x-2 opacity-50">
-                      <Checkbox
-                        id="proxy-enabled"
-                        checked={false}
-                        disabled={true}
-                      />
-                      <Label htmlFor="proxy-enabled" className="text-gray-500">
-                        Enable Proxy
-                      </Label>
+                  {selectedBrowser && (
+                    <div className="space-y-3">
+                      {!isBrowserVersionAvailable(selectedBrowser) &&
+                        availableReleaseTypes.stable && (
+                          <div className="flex gap-3 items-center">
+                            <p className="text-sm text-muted-foreground">
+                              Latest stable version (
+                              {availableReleaseTypes.stable}) needs to be
+                              downloaded
+                            </p>
+                            <LoadingButton
+                              onClick={() => handleDownload(selectedBrowser)}
+                              isLoading={isBrowserDownloading(selectedBrowser)}
+                              size="sm"
+                              disabled={isBrowserDownloading(selectedBrowser)}
+                            >
+                              Download
+                            </LoadingButton>
+                          </div>
+                        )}
+                      {isBrowserVersionAvailable(selectedBrowser) && (
+                        <div className="text-sm text-green-600">
+                          ✓ Latest stable version (
+                          {availableReleaseTypes.stable}) is available
+                        </div>
+                      )}
                     </div>
-                  </TooltipTrigger>
-                  <TooltipContent>
-                    <p>
-                      Tor Browser has its own built-in proxy system and
-                      doesn&apos;t support additional proxy configuration
-                    </p>
-                  </TooltipContent>
-                </Tooltip>
-              ) : (
-                <>
-                  <Checkbox
-                    id="proxy-enabled"
-                    checked={proxyEnabled}
-                    onCheckedChange={(checked) => {
-                      setProxyEnabled(checked as boolean);
-                    }}
-                  />
-                  <Label htmlFor="proxy-enabled">Enable Proxy</Label>
-                </>
-              )}
-            </div>
+                  )}
+                </div>
+              </TabsContent>
 
-            {proxyEnabled && !isProxyDisabled && (
-              <>
-                <div className="grid gap-2">
-                  <Label>Proxy Type</Label>
-                  <Select value={proxyType} onValueChange={setProxyType}>
+              <TabsContent value="anti-detect" className="mt-0 space-y-6">
+                <div className="p-3 text-center bg-blue-50 rounded-md border border-blue-200 dark:bg-blue-950 dark:border-blue-800">
+                  <p className="text-sm text-blue-800 dark:text-blue-200">
+                    Anti-Detect support is coming soon!
+                  </p>
+                </div>
+              </TabsContent>
+              {IS_ANTI_DETECT_SUPPORTED && (
+                <TabsContent value="anti-detect" className="mt-0 space-y-6">
+                  {/* Anti-Detect Description */}
+                  <div className="p-3 text-center bg-blue-50 rounded-md border border-blue-200 dark:bg-blue-950 dark:border-blue-800">
+                    <p className="text-sm text-blue-800 dark:text-blue-200">
+                      Powered by Camoufox
+                    </p>
+                  </div>
+
+                  <div className="space-y-6">
+                    {/* Camoufox Download Status */}
+                    {!isBrowserVersionAvailable("camoufox") &&
+                      camoufoxReleaseTypes.stable && (
+                        <div className="flex gap-3 items-center p-3 bg-amber-50 rounded-md border border-amber-200">
+                          <p className="text-sm text-amber-800">
+                            Camoufox version ({camoufoxReleaseTypes.stable})
+                            needs to be downloaded
+                          </p>
+                          <LoadingButton
+                            onClick={() => handleDownload("camoufox")}
+                            isLoading={isBrowserDownloading("camoufox")}
+                            size="sm"
+                            disabled={isBrowserDownloading("camoufox")}
+                          >
+                            Download
+                          </LoadingButton>
+                        </div>
+                      )}
+                    {isBrowserVersionAvailable("camoufox") && (
+                      <div className="p-3 text-sm text-green-600 bg-green-50 rounded-md border border-green-200">
+                        ✓ Camoufox version ({camoufoxReleaseTypes.stable}) is
+                        available
+                      </div>
+                    )}
+
+                    <SharedCamoufoxConfigForm
+                      config={camoufoxConfig}
+                      onConfigChange={updateCamoufoxConfig}
+                    />
+                  </div>
+                </TabsContent>
+              )}
+
+              {/* Proxy Selection - Common to both tabs - Compact without card */}
+              {storedProxies.length > 0 && (
+                <div className="space-y-3">
+                  <Label>Proxy</Label>
+                  <Select
+                    value={selectedProxyId || "none"}
+                    onValueChange={(value) =>
+                      setSelectedProxyId(value === "none" ? undefined : value)
+                    }
+                  >
                     <SelectTrigger>
-                      <SelectValue />
+                      <SelectValue placeholder="No proxy" />
                     </SelectTrigger>
                     <SelectContent>
-                      {["http", "https", "socks4", "socks5"].map((type) => (
-                        <SelectItem key={type} value={type}>
-                          {type.toUpperCase()}
+                      <SelectItem value="none">No proxy</SelectItem>
+                      {storedProxies.map((proxy) => (
+                        <SelectItem key={proxy.id} value={proxy.id}>
+                          {proxy.name} ({proxy.proxy_settings.proxy_type}://
+                          {proxy.proxy_settings.host}:
+                          {proxy.proxy_settings.port})
                         </SelectItem>
                       ))}
                     </SelectContent>
                   </Select>
                 </div>
+              )}
+            </div>
+          </ScrollArea>
 
-                <div className="grid gap-2">
-                  <Label htmlFor="proxy-host">Host</Label>
-                  <Input
-                    id="proxy-host"
-                    value={proxyHost}
-                    onChange={(e) => {
-                      setProxyHost(e.target.value);
-                    }}
-                    placeholder="e.g. 127.0.0.1"
-                  />
-                </div>
-
-                <div className="grid gap-2">
-                  <Label htmlFor="proxy-port">Port</Label>
-                  <Input
-                    id="proxy-port"
-                    type="number"
-                    value={proxyPort}
-                    onChange={(e) => {
-                      setProxyPort(Number.parseInt(e.target.value, 10) || 0);
-                    }}
-                    placeholder="e.g. 8080"
-                    min="1"
-                    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>
-        </div>
-
-        <DialogFooter>
-          <Button variant="outline" onClick={onClose}>
-            Cancel
-          </Button>
-          <LoadingButton
-            isLoading={isCreating}
-            onClick={() => void handleCreate()}
-            disabled={!canCreate}
-          >
-            Create Profile
-          </LoadingButton>
-        </DialogFooter>
+          <DialogFooter className="flex-shrink-0 pt-4 border-t">
+            <Button variant="outline" onClick={handleClose}>
+              Cancel
+            </Button>
+            <LoadingButton
+              onClick={handleCreate}
+              isLoading={isCreating}
+              disabled={isCreateDisabled()}
+            >
+              Create Profile
+            </LoadingButton>
+          </DialogFooter>
+        </Tabs>
       </DialogContent>
     </Dialog>
   );

src/components/custom-toast.tsx

@@ -48,7 +48,6 @@
  * ```
  */
 
-import React from "react";
 import {
   LuCheckCheck,
   LuDownload,
@@ -112,6 +111,16 @@ interface TwilightUpdateToastProps extends BaseToastProps {
   hasUpdate?: boolean;
 }
 
+interface AppUpdateToastProps extends BaseToastProps {
+  type: "app-update";
+  stage?: "downloading" | "extracting" | "installing" | "completed";
+  progress?: {
+    percentage: number;
+    speed?: string;
+    eta?: string;
+  };
+}
+
 type ToastProps =
   | LoadingToastProps
   | SuccessToastProps
@@ -119,7 +128,8 @@ type ToastProps =
   | DownloadToastProps
   | VersionUpdateToastProps
   | FetchingToastProps
-  | TwilightUpdateToastProps;
+  | TwilightUpdateToastProps
+  | AppUpdateToastProps;
 
 function getToastIcon(type: ToastProps["type"], stage?: string) {
   switch (type) {
@@ -134,6 +144,21 @@ function getToastIcon(type: ToastProps["type"], stage?: string) {
         );
       }
       return <LuDownload className="flex-shrink-0 w-4 h-4 text-blue-500" />;
+    case "app-update":
+      if (stage === "completed") {
+        return (
+          <LuCheckCheck className="flex-shrink-0 w-4 h-4 text-green-500" />
+        );
+      } else if (stage === "downloading") {
+        return <LuDownload className="flex-shrink-0 w-4 h-4 text-blue-500" />;
+      } else if (stage === "installing") {
+        return (
+          <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-blue-500 animate-spin" />
+        );
+      }
+      return (
+        <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-blue-500 animate-spin" />
+      );
     case "version-update":
       return (
         <LuRefreshCw className="flex-shrink-0 w-4 h-4 text-blue-500 animate-spin" />
@@ -214,6 +239,47 @@ export function UnifiedToast(props: ToastProps) {
             </div>
           )}
 
+        {/* App update progress */}
+        {type === "app-update" && (
+          <div className="mt-2 space-y-1">
+            {/* Download progress with percentage */}
+            {progress &&
+              "percentage" in progress &&
+              stage === "downloading" && (
+                <>
+                  <div className="flex justify-between items-center">
+                    <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`}
+                    </p>
+                  </div>
+                  <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+                    <div
+                      className="bg-blue-500 h-1.5 rounded-full transition-all duration-300"
+                      style={{ width: `${progress.percentage}%` }}
+                    />
+                  </div>
+                </>
+              )}
+
+            {/* Progress indicator for other stages */}
+            {(stage === "extracting" ||
+              stage === "installing" ||
+              stage === "completed") && (
+              <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+                <div
+                  className={`h-1.5 rounded-full transition-all duration-500 ${
+                    stage === "completed"
+                      ? "bg-green-500 w-full"
+                      : "bg-blue-500 w-full animate-pulse"
+                  }`}
+                />
+              </div>
+            )}
+          </div>
+        )}
+
         {/* Version update progress */}
         {type === "version-update" &&
           progress &&
@@ -289,6 +355,27 @@ export function UnifiedToast(props: ToastProps) {
             )}
           </>
         )}
+
+        {/* Stage-specific descriptions for app updates */}
+        {type === "app-update" && !description && (
+          <>
+            {stage === "extracting" && (
+              <p className="mt-1 text-xs text-gray-600 dark:text-gray-300">
+                Preparing update files...
+              </p>
+            )}
+            {stage === "installing" && (
+              <p className="mt-1 text-xs text-gray-600 dark:text-gray-300">
+                Installing new version...
+              </p>
+            )}
+            {stage === "completed" && (
+              <p className="mt-1 text-xs text-green-600 dark:text-green-400">
+                Update completed! Restarting application...
+              </p>
+            )}
+          </>
+        )}
       </div>
     </div>
   );

src/components/import-profile-dialog.tsx

@@ -1,5 +1,10 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
+import { useCallback, useEffect, useState } from "react";
+import { FaFolder } from "react-icons/fa";
+import { toast } from "sonner";
 import { LoadingButton } from "@/components/loading-button";
 import { Button } from "@/components/ui/button";
 import {
@@ -21,11 +26,6 @@ import {
 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;
@@ -63,13 +63,7 @@ export function ImportProfileDialog({
   const { supportedBrowsers, isLoading: isLoadingSupport } =
     useBrowserSupport();
 
-  useEffect(() => {
-    if (isOpen) {
-      void loadDetectedProfiles();
-    }
-  }, [isOpen]);
-
-  const loadDetectedProfiles = async () => {
+  const loadDetectedProfiles = useCallback(async () => {
     setIsLoading(true);
     try {
       const profiles = await invoke<DetectedProfile[]>(
@@ -96,7 +90,7 @@ export function ImportProfileDialog({
     } finally {
       setIsLoading(false);
     }
-  };
+  }, []);
 
   const handleBrowseFolder = async () => {
     try {
@@ -115,7 +109,7 @@ export function ImportProfileDialog({
     }
   };
 
-  const handleAutoDetectImport = async () => {
+  const handleAutoDetectImport = useCallback(async () => {
     if (!selectedDetectedProfile || !autoDetectProfileName.trim()) {
       toast.error("Please select a profile and provide a name");
       return;
@@ -148,13 +142,31 @@ export function ImportProfileDialog({
       console.error("Failed to import profile:", error);
       const errorMessage =
         error instanceof Error ? error.message : String(error);
-      toast.error(`Failed to import profile: ${errorMessage}`);
+
+      // Check if error is about browser not being downloaded
+      if (errorMessage.includes("No downloaded versions found")) {
+        const browserDisplayName = getBrowserDisplayName(profile.browser);
+        toast.error(
+          `${browserDisplayName} is not installed. Please download ${browserDisplayName} first from the main window, then try importing again.`,
+          {
+            duration: 8000,
+          },
+        );
+      } else {
+        toast.error(`Failed to import profile: ${errorMessage}`);
+      }
     } finally {
       setIsImporting(false);
     }
-  };
+  }, [
+    selectedDetectedProfile,
+    autoDetectProfileName,
+    detectedProfiles,
+    onImportComplete,
+    onClose,
+  ]);
 
-  const handleManualImport = async () => {
+  const handleManualImport = useCallback(async () => {
     if (
       !manualBrowserType ||
       !manualProfilePath.trim() ||
@@ -183,11 +195,29 @@ export function ImportProfileDialog({
       console.error("Failed to import profile:", error);
       const errorMessage =
         error instanceof Error ? error.message : String(error);
-      toast.error(`Failed to import profile: ${errorMessage}`);
+
+      // Check if error is about browser not being downloaded
+      if (errorMessage.includes("No downloaded versions found")) {
+        const browserDisplayName = getBrowserDisplayName(manualBrowserType);
+        toast.error(
+          `${browserDisplayName} is not installed. Please download ${browserDisplayName} first from the main window, then try importing again.`,
+          {
+            duration: 8000,
+          },
+        );
+      } else {
+        toast.error(`Failed to import profile: ${errorMessage}`);
+      }
     } finally {
       setIsImporting(false);
     }
-  };
+  }, [
+    manualBrowserType,
+    manualProfilePath,
+    manualProfileName,
+    onImportComplete,
+    onClose,
+  ]);
 
   const handleClose = () => {
     setSelectedDetectedProfile(null);
@@ -222,6 +252,12 @@ export function ImportProfileDialog({
     (p) => p.path === selectedDetectedProfile,
   );
 
+  useEffect(() => {
+    if (isOpen) {
+      void loadDetectedProfiles();
+    }
+  }, [isOpen, loadDetectedProfiles]);
+
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
       <DialogContent className="max-w-2xl max-h-[80vh] my-8 flex flex-col">

src/components/loading-button.tsx

@@ -1,5 +1,6 @@
 import { LuLoaderCircle } from "react-icons/lu";
 import { type ButtonProps, Button as UIButton } from "./ui/button";
+
 type Props = ButtonProps & {
   isLoading: boolean;
   "aria-label"?: string;

src/components/permission-dialog.tsx

@@ -1,5 +1,7 @@
 "use client";
 
+import { useEffect, useState } from "react";
+import { BsCamera, BsMic } from "react-icons/bs";
 import { LoadingButton } from "@/components/loading-button";
 import { Button } from "@/components/ui/button";
 import {
@@ -10,11 +12,9 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
-import { usePermissions } from "@/hooks/use-permissions";
 import type { PermissionType } from "@/hooks/use-permissions";
+import { usePermissions } 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;

src/components/profile-data-table.tsx

@@ -1,5 +1,18 @@
 "use client";
 
+import {
+  type ColumnDef,
+  flexRender,
+  getCoreRowModel,
+  getSortedRowModel,
+  type SortingState,
+  useReactTable,
+} from "@tanstack/react-table";
+import { invoke } from "@tauri-apps/api/core";
+import * as React from "react";
+import { CiCircleCheck } from "react-icons/ci";
+import { IoEllipsisHorizontal } from "react-icons/io5";
+import { LuChevronDown, LuChevronUp } from "react-icons/lu";
 import { Button } from "@/components/ui/button";
 import {
   Dialog,
@@ -17,6 +30,7 @@ import {
   DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
+import { ScrollArea } from "@/components/ui/scroll-area";
 import {
   Table,
   TableBody,
@@ -31,20 +45,13 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 import { useTableSorting } from "@/hooks/use-table-sorting";
-import { getBrowserDisplayName, getBrowserIcon } from "@/lib/browser-utils";
-import type { BrowserProfile } from "@/types";
 import {
-  type ColumnDef,
-  type SortingState,
-  flexRender,
-  getCoreRowModel,
-  getSortedRowModel,
-  useReactTable,
-} from "@tanstack/react-table";
-import * as React from "react";
-import { CiCircleCheck } from "react-icons/ci";
-import { IoEllipsisHorizontal } from "react-icons/io5";
-import { LuChevronDown, LuChevronUp } from "react-icons/lu";
+  getBrowserDisplayName,
+  getBrowserIcon,
+  getCurrentOS,
+} from "@/lib/browser-utils";
+import { cn } from "@/lib/utils";
+import type { BrowserProfile, StoredProxy } from "@/types";
 import { Input } from "./ui/input";
 import { Label } from "./ui/label";
 
@@ -56,8 +63,10 @@ interface ProfilesDataTableProps {
   onDeleteProfile: (profile: BrowserProfile) => void | Promise<void>;
   onRenameProfile: (oldName: string, newName: string) => Promise<void>;
   onChangeVersion: (profile: BrowserProfile) => void;
+  onConfigureCamoufox?: (profile: BrowserProfile) => void;
   runningProfiles: Set<string>;
   isUpdating?: (browser: string) => boolean;
+  onReloadProxyData?: () => void | Promise<void>;
 }
 
 export function ProfilesDataTable({
@@ -68,8 +77,10 @@ export function ProfilesDataTable({
   onDeleteProfile,
   onRenameProfile,
   onChangeVersion,
+  onConfigureCamoufox,
   runningProfiles,
   isUpdating = () => false,
+  onReloadProxyData,
 }: ProfilesDataTableProps) {
   const { getTableSorting, updateSorting, isLoaded } = useTableSorting();
   const [sorting, setSorting] = React.useState<SortingState>([]);
@@ -83,12 +94,65 @@ export function ProfilesDataTable({
     React.useState("");
   const [deleteError, setDeleteError] = React.useState<string | null>(null);
   const [isClient, setIsClient] = React.useState(false);
+  const [storedProxies, setStoredProxies] = React.useState<StoredProxy[]>([]);
+
+  // Helper function to check if a profile has a proxy
+  const hasProxy = React.useCallback(
+    (profile: BrowserProfile): boolean => {
+      if (!profile.proxy_id) return false;
+      const proxy = storedProxies.find((p) => p.id === profile.proxy_id);
+      return proxy !== undefined;
+    },
+    [storedProxies],
+  );
+
+  // Helper function to get proxy info for a profile
+  const getProxyInfo = React.useCallback(
+    (profile: BrowserProfile): StoredProxy | null => {
+      if (!profile.proxy_id) return null;
+      return storedProxies.find((p) => p.id === profile.proxy_id) ?? null;
+    },
+    [storedProxies],
+  );
+
+  // Helper function to get proxy name for display
+  const getProxyDisplayName = React.useCallback(
+    (profile: BrowserProfile): string => {
+      if (!profile.proxy_id) return "Disabled";
+      const proxy = storedProxies.find((p) => p.id === profile.proxy_id);
+      return proxy?.name ?? "Unknown Proxy";
+    },
+    [storedProxies],
+  );
 
   // Ensure we're on the client side to prevent hydration mismatches
   React.useEffect(() => {
     setIsClient(true);
   }, []);
 
+  // Load stored proxies
+  const loadStoredProxies = React.useCallback(async () => {
+    try {
+      const proxiesList = await invoke<StoredProxy[]>("get_stored_proxies");
+      setStoredProxies(proxiesList);
+    } catch (error) {
+      console.error("Failed to load stored proxies:", error);
+    }
+  }, []);
+
+  React.useEffect(() => {
+    if (isClient) {
+      void loadStoredProxies();
+    }
+  }, [isClient, loadStoredProxies]);
+
+  // Reload proxy data when requested from parent
+  React.useEffect(() => {
+    if (onReloadProxyData) {
+      void loadStoredProxies();
+    }
+  }, [onReloadProxyData, loadStoredProxies]);
+
   // Update local sorting state when settings are loaded
   React.useEffect(() => {
     if (isLoaded && isClient) {
@@ -320,32 +384,41 @@ export function ProfilesDataTable({
         header: "Proxy",
         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";
+          const profileHasProxy = hasProxy(profile);
+          const proxyDisplayName = getProxyDisplayName(profile);
+          const proxyInfo = getProxyInfo(profile);
+
+          const tooltipText =
+            profile.browser === "tor-browser"
+              ? "Proxies are not supported for TOR browser"
+              : profileHasProxy && proxyInfo
+                ? `${proxyDisplayName}, ${proxyInfo.proxy_settings.proxy_type.toUpperCase()} (${
+                    proxyInfo.proxy_settings.host
+                  }:${proxyInfo.proxy_settings.port})`
+                : "No proxy configured";
+
           return (
             <Tooltip>
               <TooltipTrigger>
                 <div className="flex gap-2 items-center">
-                  {hasProxy && (
+                  {profileHasProxy && (
                     <CiCircleCheck className="w-4 h-4 text-green-500" />
                   )}
-                  <span className="text-sm text-muted-foreground">
-                    {profile.browser === "tor-browser"
-                      ? "Not supported"
-                      : regularText}
-                  </span>
+
+                  {proxyDisplayName.length > 10 ? (
+                    <span className="text-sm truncate text-muted-foreground">
+                      {proxyDisplayName.slice(0, 10)}...
+                    </span>
+                  ) : (
+                    <span className="text-sm text-muted-foreground">
+                      {profile.browser === "tor-browser"
+                        ? "Not supported"
+                        : proxyDisplayName}
+                    </span>
+                  )}
                 </div>
               </TooltipTrigger>
-              <TooltipContent>
-                {profile.browser === "tor-browser"
-                  ? "Proxies are not supported for TOR browser"
-                  : regularTooltipText}
-              </TooltipContent>
+              <TooltipContent>{tooltipText}</TooltipContent>
             </Tooltip>
           );
         },
@@ -381,7 +454,19 @@ export function ProfilesDataTable({
                   >
                     Configure Proxy
                   </DropdownMenuItem>
-                  {!["chromium", "zen"].includes(profile.browser) && (
+                  {profile.browser === "camoufox" && onConfigureCamoufox && (
+                    <DropdownMenuItem
+                      onClick={() => {
+                        onConfigureCamoufox(profile);
+                      }}
+                      disabled={!isClient || isBrowserUpdating}
+                    >
+                      Configure Camoufox
+                    </DropdownMenuItem>
+                  )}
+                  {!["chromium", "zen", "camoufox"].includes(
+                    profile.browser,
+                  ) && (
                     <DropdownMenuItem
                       onClick={() => {
                         onChangeVersion(profile);
@@ -426,6 +511,10 @@ export function ProfilesDataTable({
       onKillProfile,
       onProxySettings,
       onChangeVersion,
+      onConfigureCamoufox,
+      getProxyInfo,
+      hasProxy,
+      getProxyDisplayName,
     ],
   );
 
@@ -440,9 +529,16 @@ export function ProfilesDataTable({
     getCoreRowModel: getCoreRowModel(),
   });
 
+  const platform = getCurrentOS();
+
   return (
     <>
-      <div className="rounded-md border">
+      <ScrollArea
+        className={cn(
+          "rounded-md border",
+          platform === "macos" ? "h-[380px]" : "h-[320px]",
+        )}
+      >
         <Table>
           <TableHeader>
             {table.getHeaderGroups().map((headerGroup) => (
@@ -491,7 +587,7 @@ export function ProfilesDataTable({
             )}
           </TableBody>
         </Table>
-      </div>
+      </ScrollArea>
 
       <Dialog
         open={profileToRename !== null}

src/components/profile-selector-dialog.tsx

@@ -1,5 +1,9 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
+import { LuCopy } from "react-icons/lu";
+import { toast } from "sonner";
 import { LoadingButton } from "@/components/loading-button";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -24,11 +28,7 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 import { getBrowserDisplayName, getBrowserIcon } from "@/lib/browser-utils";
-import type { BrowserProfile } from "@/types";
-import { invoke } from "@tauri-apps/api/core";
-import { useEffect, useState } from "react";
-import { LuCopy } from "react-icons/lu";
-import { toast } from "sonner";
+import type { BrowserProfile, StoredProxy } from "@/types";
 
 interface ProfileSelectorDialogProps {
   isOpen: boolean;
@@ -47,25 +47,77 @@ export function ProfileSelectorDialog({
   const [selectedProfile, setSelectedProfile] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [isLaunching, setIsLaunching] = useState(false);
+  const [storedProxies, setStoredProxies] = useState<StoredProxy[]>([]);
 
-  useEffect(() => {
-    if (isOpen) {
-      void loadProfiles();
-    }
-  }, [isOpen]);
+  // Helper function to check if a profile has a proxy
+  const hasProxy = useCallback(
+    (profile: BrowserProfile): boolean => {
+      if (!profile.proxy_id) return false;
+      const proxy = storedProxies.find((p) => p.id === profile.proxy_id);
+      return proxy !== undefined;
+    },
+    [storedProxies],
+  );
 
-  const loadProfiles = async () => {
+  // Helper function to determine if a profile can be used for opening links
+  const canUseProfileForLinks = useCallback(
+    (
+      profile: BrowserProfile,
+      allProfiles: BrowserProfile[],
+      runningProfiles: Set<string>,
+    ): boolean => {
+      const isRunning = runningProfiles.has(profile.name);
+
+      // For TOR browser: Check if any TOR browser is running
+      if (profile.browser === "tor-browser") {
+        const runningTorProfiles = allProfiles.filter(
+          (p) => p.browser === "tor-browser" && runningProfiles.has(p.name),
+        );
+
+        // If no TOR browser is running, allow any TOR profile
+        if (runningTorProfiles.length === 0) {
+          return true;
+        }
+
+        // If TOR browser(s) are running, only allow the running one(s)
+        return isRunning;
+      }
+
+      // For Mullvad browser: Check if any Mullvad browser is running
+      if (profile.browser === "mullvad-browser") {
+        const runningMullvadProfiles = allProfiles.filter(
+          (p) => p.browser === "mullvad-browser" && runningProfiles.has(p.name),
+        );
+
+        // If no Mullvad browser is running, allow any Mullvad profile
+        if (runningMullvadProfiles.length === 0) {
+          return true;
+        }
+
+        // If Mullvad browser(s) are running, only allow the running one(s)
+        return isRunning;
+      }
+
+      return true;
+    },
+    [],
+  );
+
+  const loadProfiles = useCallback(async () => {
     setIsLoading(true);
     try {
-      const profileList = await invoke<BrowserProfile[]>(
-        "list_browser_profiles",
-      );
+      // Load both profiles and stored proxies
+      const [profileList, proxiesList] = await Promise.all([
+        invoke<BrowserProfile[]>("list_browser_profiles"),
+        invoke<StoredProxy[]>("get_stored_proxies"),
+      ]);
 
       // Sort profiles by name
       profileList.sort((a, b) => a.name.localeCompare(b.name));
 
-      // Don't filter any profiles, show all of them
+      // Set both profiles and proxies
       setProfiles(profileList);
+      setStoredProxies(proxiesList);
 
       // Auto-select first available profile for link opening
       if (profileList.length > 0) {
@@ -99,56 +151,20 @@ export function ProfileSelectorDialog({
     } finally {
       setIsLoading(false);
     }
-  };
-
-  // Helper function to determine if a profile can be used for opening links
-  const canUseProfileForLinks = (
-    profile: BrowserProfile,
-    allProfiles: BrowserProfile[],
-    runningProfiles: Set<string>,
-  ): boolean => {
-    const isRunning = runningProfiles.has(profile.name);
-
-    // For TOR browser: Check if any TOR browser is running
-    if (profile.browser === "tor-browser") {
-      const runningTorProfiles = allProfiles.filter(
-        (p) => p.browser === "tor-browser" && runningProfiles.has(p.name),
-      );
-
-      // If no TOR browser is running, allow any TOR profile
-      if (runningTorProfiles.length === 0) {
-        return true;
-      }
-
-      // If TOR browser(s) are running, only allow the running one(s)
-      return isRunning;
-    }
-
-    // For Mullvad browser: never allow if running
-    if (profile.browser === "mullvad-browser" && isRunning) {
-      return false;
-    }
-
-    // For other browsers: always allow
-    return true;
-  };
+  }, [runningProfiles, canUseProfileForLinks]);
 
   // Helper function to get tooltip content for profiles
   const getProfileTooltipContent = (profile: BrowserProfile): string => {
     const isRunning = runningProfiles.has(profile.name);
 
-    if (profile.browser === "tor-browser") {
-      // If another TOR profile is running, this one is not available
+    if (
+      profile.browser === "tor-browser" ||
+      profile.browser === "mullvad-browser"
+    ) {
+      // If another TOR/Mullvad profile is running, this one is not available
       return "Only 1 instance can run at a time";
     }
 
-    if (profile.browser === "mullvad-browser") {
-      if (isRunning) {
-        return "Only launching the browser is supported, opening them in a running browser is not yet available";
-      }
-      return "Only launching the browser is supported, opening them in a running browser is not yet available";
-    }
-
     if (isRunning) {
       return "URL will open in a new tab in the existing browser window";
     }
@@ -156,7 +172,7 @@ export function ProfileSelectorDialog({
     return "";
   };
 
-  const handleOpenUrl = async () => {
+  const handleOpenUrl = useCallback(async () => {
     if (!selectedProfile || !url) return;
 
     setIsLaunching(true);
@@ -171,14 +187,14 @@ export function ProfileSelectorDialog({
     } finally {
       setIsLaunching(false);
     }
-  };
+  }, [selectedProfile, url, onClose]);
 
-  const handleCancel = () => {
+  const handleCancel = useCallback(() => {
     setSelectedProfile(null);
     onClose();
-  };
+  }, [onClose]);
 
-  const handleCopyUrl = async () => {
+  const handleCopyUrl = useCallback(async () => {
     if (!url) return;
 
     try {
@@ -188,7 +204,7 @@ export function ProfileSelectorDialog({
       console.error("Failed to copy URL:", error);
       toast.error("Failed to copy URL to clipboard");
     }
-  };
+  }, [url]);
 
   const selectedProfileData = profiles.find((p) => p.name === selectedProfile);
 
@@ -208,6 +224,12 @@ export function ProfileSelectorDialog({
     return getProfileTooltipContent(selectedProfileData);
   };
 
+  useEffect(() => {
+    if (isOpen) {
+      void loadProfiles();
+    }
+  }, [isOpen, loadProfiles]);
+
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
       <DialogContent className="max-w-md">
@@ -253,86 +275,84 @@ export function ProfileSelectorDialog({
                 </div>
               </div>
             ) : (
-              <>
-                <Select
-                  value={selectedProfile ?? undefined}
-                  onValueChange={setSelectedProfile}
-                >
-                  <SelectTrigger>
-                    <SelectValue placeholder="Choose a profile" />
-                  </SelectTrigger>
-                  <SelectContent>
-                    {profiles.map((profile) => {
-                      const isRunning = runningProfiles.has(profile.name);
-                      const canUseForLinks = canUseProfileForLinks(
-                        profile,
-                        profiles,
-                        runningProfiles,
-                      );
-                      const tooltipContent = getProfileTooltipContent(profile);
+              <Select
+                value={selectedProfile ?? undefined}
+                onValueChange={setSelectedProfile}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Choose a profile" />
+                </SelectTrigger>
+                <SelectContent>
+                  {profiles.map((profile) => {
+                    const isRunning = runningProfiles.has(profile.name);
+                    const canUseForLinks = canUseProfileForLinks(
+                      profile,
+                      profiles,
+                      runningProfiles,
+                    );
+                    const tooltipContent = getProfileTooltipContent(profile);
 
-                      return (
-                        <Tooltip key={profile.name}>
-                          <TooltipTrigger asChild>
-                            <SelectItem
-                              value={profile.name}
-                              disabled={!canUseForLinks}
+                    return (
+                      <Tooltip key={profile.name}>
+                        <TooltipTrigger asChild>
+                          <SelectItem
+                            value={profile.name}
+                            disabled={!canUseForLinks}
+                          >
+                            <div
+                              className={`flex items-center gap-2 ${
+                                !canUseForLinks ? "opacity-50" : ""
+                              }`}
                             >
-                              <div
-                                className={`flex items-center gap-2 ${
-                                  !canUseForLinks ? "opacity-50" : ""
-                                }`}
-                              >
-                                <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="w-4 h-4" />
-                                      ) : null;
-                                    })()}
-                                  </div>
-                                  <div className="flex-1 text-right">
-                                    <div className="font-medium">
-                                      {profile.name}
-                                    </div>
+                              <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="w-4 h-4" />
+                                    ) : null;
+                                  })()}
+                                </div>
+                                <div className="flex-1 text-right">
+                                  <div className="font-medium">
+                                    {profile.name}
                                   </div>
                                 </div>
-                                <Badge variant="secondary" className="text-xs">
-                                  {getBrowserDisplayName(profile.browser)}
-                                </Badge>
-                                {profile.proxy?.enabled && (
-                                  <Badge variant="outline" className="text-xs">
-                                    Proxy
-                                  </Badge>
-                                )}
-                                {isRunning && (
-                                  <Badge variant="default" className="text-xs">
-                                    Running
-                                  </Badge>
-                                )}
-                                {!canUseForLinks && (
-                                  <Badge
-                                    variant="destructive"
-                                    className="text-xs"
-                                  >
-                                    Unavailable
-                                  </Badge>
-                                )}
                               </div>
-                            </SelectItem>
-                          </TooltipTrigger>
-                          {tooltipContent && (
-                            <TooltipContent>{tooltipContent}</TooltipContent>
-                          )}
-                        </Tooltip>
-                      );
-                    })}
-                  </SelectContent>
-                </Select>
-              </>
+                              <Badge variant="secondary" className="text-xs">
+                                {getBrowserDisplayName(profile.browser)}
+                              </Badge>
+                              {hasProxy(profile) && (
+                                <Badge variant="outline" className="text-xs">
+                                  Proxy
+                                </Badge>
+                              )}
+                              {isRunning && (
+                                <Badge variant="default" className="text-xs">
+                                  Running
+                                </Badge>
+                              )}
+                              {!canUseForLinks && (
+                                <Badge
+                                  variant="destructive"
+                                  className="text-xs"
+                                >
+                                  Unavailable
+                                </Badge>
+                              )}
+                            </div>
+                          </SelectItem>
+                        </TooltipTrigger>
+                        {tooltipContent && (
+                          <TooltipContent>{tooltipContent}</TooltipContent>
+                        )}
+                      </Tooltip>
+                    );
+                  })}
+                </SelectContent>
+              </Select>
             )}
           </div>
         </div>

src/components/proxy-form-dialog.tsx

@@ -0,0 +1,285 @@
+"use client";
+
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
+import { toast } from "sonner";
+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 type { StoredProxy } from "@/types";
+
+interface ProxyFormData {
+  name: string;
+  proxy_type: string;
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+}
+
+interface ProxyFormDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onSave: (proxy: StoredProxy) => void;
+  editingProxy?: StoredProxy | null;
+}
+
+export function ProxyFormDialog({
+  isOpen,
+  onClose,
+  onSave,
+  editingProxy,
+}: ProxyFormDialogProps) {
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [formData, setFormData] = useState<ProxyFormData>({
+    name: "",
+    proxy_type: "http",
+    host: "",
+    port: 8080,
+    username: "",
+    password: "",
+  });
+
+  const resetForm = useCallback(() => {
+    setFormData({
+      name: "",
+      proxy_type: "http",
+      host: "",
+      port: 8080,
+      username: "",
+      password: "",
+    });
+  }, []);
+
+  // Load editing proxy data when dialog opens
+  useEffect(() => {
+    if (isOpen) {
+      if (editingProxy) {
+        setFormData({
+          name: editingProxy.name,
+          proxy_type: editingProxy.proxy_settings.proxy_type,
+          host: editingProxy.proxy_settings.host,
+          port: editingProxy.proxy_settings.port,
+          username: editingProxy.proxy_settings.username || "",
+          password: editingProxy.proxy_settings.password || "",
+        });
+      } else {
+        resetForm();
+      }
+    }
+  }, [isOpen, editingProxy, resetForm]);
+
+  const handleSubmit = useCallback(async () => {
+    if (!formData.name.trim()) {
+      toast.error("Proxy name is required");
+      return;
+    }
+
+    if (!formData.host.trim() || !formData.port) {
+      toast.error("Host and port are required");
+      return;
+    }
+
+    setIsSubmitting(true);
+    try {
+      const proxySettings = {
+        proxy_type: formData.proxy_type,
+        host: formData.host.trim(),
+        port: formData.port,
+        username: formData.username.trim() || undefined,
+        password: formData.password.trim() || undefined,
+      };
+
+      let savedProxy: StoredProxy;
+
+      if (editingProxy) {
+        // Update existing proxy
+        savedProxy = await invoke<StoredProxy>("update_stored_proxy", {
+          proxyId: editingProxy.id,
+          name: formData.name.trim(),
+          proxySettings,
+        });
+        toast.success("Proxy updated successfully");
+      } else {
+        // Create new proxy
+        savedProxy = await invoke<StoredProxy>("create_stored_proxy", {
+          name: formData.name.trim(),
+          proxySettings,
+        });
+        toast.success("Proxy created successfully");
+      }
+
+      onSave(savedProxy);
+      onClose();
+    } catch (error) {
+      console.error("Failed to save proxy:", error);
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      toast.error(`Failed to save proxy: ${errorMessage}`);
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [formData, editingProxy, onSave, onClose]);
+
+  const handleClose = useCallback(() => {
+    if (!isSubmitting) {
+      onClose();
+    }
+  }, [isSubmitting, onClose]);
+
+  const isFormValid =
+    formData.name.trim() &&
+    formData.host.trim() &&
+    formData.port > 0 &&
+    formData.port <= 65535;
+
+  return (
+    <Dialog open={isOpen} onOpenChange={handleClose}>
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>
+            {editingProxy ? "Edit Proxy" : "Create New Proxy"}
+          </DialogTitle>
+        </DialogHeader>
+
+        <div className="grid gap-4 py-4">
+          <div className="grid gap-2">
+            <Label htmlFor="proxy-name">Proxy Name</Label>
+            <Input
+              id="proxy-name"
+              value={formData.name}
+              onChange={(e) =>
+                setFormData({ ...formData, name: e.target.value })
+              }
+              placeholder="e.g. Office Proxy, Home VPN, etc."
+              disabled={isSubmitting}
+            />
+          </div>
+
+          <div className="grid gap-2">
+            <Label>Proxy Type</Label>
+            <Select
+              value={formData.proxy_type}
+              onValueChange={(value) =>
+                setFormData({ ...formData, proxy_type: value })
+              }
+              disabled={isSubmitting}
+            >
+              <SelectTrigger>
+                <SelectValue placeholder="Select proxy type" />
+              </SelectTrigger>
+              <SelectContent>
+                {["http", "https", "socks4", "socks5"].map((type) => (
+                  <SelectItem key={type} value={type}>
+                    {type.toUpperCase()}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className="grid grid-cols-2 gap-4">
+            <div className="grid gap-2">
+              <Label htmlFor="proxy-host">Host</Label>
+              <Input
+                id="proxy-host"
+                value={formData.host}
+                onChange={(e) =>
+                  setFormData({ ...formData, host: e.target.value })
+                }
+                placeholder="e.g. 127.0.0.1"
+                disabled={isSubmitting}
+              />
+            </div>
+
+            <div className="grid gap-2">
+              <Label htmlFor="proxy-port">Port</Label>
+              <Input
+                id="proxy-port"
+                type="number"
+                value={formData.port}
+                onChange={(e) =>
+                  setFormData({
+                    ...formData,
+                    port: parseInt(e.target.value, 10) || 0,
+                  })
+                }
+                placeholder="e.g. 8080"
+                min="1"
+                max="65535"
+                disabled={isSubmitting}
+              />
+            </div>
+          </div>
+
+          <div className="grid grid-cols-2 gap-4">
+            <div className="grid gap-2">
+              <Label htmlFor="proxy-username">Username (optional)</Label>
+              <Input
+                id="proxy-username"
+                value={formData.username}
+                onChange={(e) =>
+                  setFormData({
+                    ...formData,
+                    username: e.target.value,
+                  })
+                }
+                placeholder="Proxy username"
+                disabled={isSubmitting}
+              />
+            </div>
+
+            <div className="grid gap-2">
+              <Label htmlFor="proxy-password">Password (optional)</Label>
+              <Input
+                id="proxy-password"
+                type="password"
+                value={formData.password}
+                onChange={(e) =>
+                  setFormData({
+                    ...formData,
+                    password: e.target.value,
+                  })
+                }
+                placeholder="Proxy password"
+                disabled={isSubmitting}
+              />
+            </div>
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button
+            variant="outline"
+            onClick={handleClose}
+            disabled={isSubmitting}
+          >
+            Cancel
+          </Button>
+          <LoadingButton
+            isLoading={isSubmitting}
+            onClick={handleSubmit}
+            disabled={!isFormValid}
+          >
+            {editingProxy ? "Update Proxy" : "Create Proxy"}
+          </LoadingButton>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

src/components/proxy-management-dialog.tsx

@@ -0,0 +1,240 @@
+"use client";
+
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
+import { FiEdit2, FiPlus, FiTrash2, FiWifi } from "react-icons/fi";
+import { toast } from "sonner";
+import { ProxyFormDialog } from "@/components/proxy-form-dialog";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
+import type { StoredProxy } from "@/types";
+
+interface ProxyManagementDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+export function ProxyManagementDialog({
+  isOpen,
+  onClose,
+}: ProxyManagementDialogProps) {
+  const [storedProxies, setStoredProxies] = useState<StoredProxy[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [showProxyForm, setShowProxyForm] = useState(false);
+  const [editingProxy, setEditingProxy] = useState<StoredProxy | null>(null);
+
+  const loadStoredProxies = useCallback(async () => {
+    try {
+      setLoading(true);
+      const proxies = await invoke<StoredProxy[]>("get_stored_proxies");
+      setStoredProxies(proxies);
+    } catch (error) {
+      console.error("Failed to load stored proxies:", error);
+      toast.error("Failed to load proxies");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (isOpen) {
+      loadStoredProxies();
+    }
+  }, [isOpen, loadStoredProxies]);
+
+  const handleDeleteProxy = useCallback(async (proxy: StoredProxy) => {
+    if (
+      !confirm(`Are you sure you want to delete the proxy "${proxy.name}"?`)
+    ) {
+      return;
+    }
+
+    try {
+      await invoke("delete_stored_proxy", { proxyId: proxy.id });
+      setStoredProxies((prev) => prev.filter((p) => p.id !== proxy.id));
+      toast.success("Proxy deleted successfully");
+    } catch (error) {
+      console.error("Failed to delete proxy:", error);
+      toast.error("Failed to delete proxy");
+    }
+  }, []);
+
+  const handleCreateProxy = useCallback(() => {
+    setEditingProxy(null);
+    setShowProxyForm(true);
+  }, []);
+
+  const handleEditProxy = useCallback((proxy: StoredProxy) => {
+    setEditingProxy(proxy);
+    setShowProxyForm(true);
+  }, []);
+
+  const handleProxySaved = useCallback((savedProxy: StoredProxy) => {
+    setStoredProxies((prev) => {
+      const existingIndex = prev.findIndex((p) => p.id === savedProxy.id);
+      if (existingIndex >= 0) {
+        // Update existing proxy
+        const updated = [...prev];
+        updated[existingIndex] = savedProxy;
+        return updated;
+      } else {
+        // Add new proxy
+        return [...prev, savedProxy];
+      }
+    });
+    setShowProxyForm(false);
+    setEditingProxy(null);
+  }, []);
+
+  const handleProxyFormClose = useCallback(() => {
+    setShowProxyForm(false);
+    setEditingProxy(null);
+  }, []);
+
+  const trimName = useCallback((name: string) => {
+    return name.length > 30 ? `${name.substring(0, 30)}...` : name;
+  }, []);
+
+  return (
+    <>
+      <Dialog open={isOpen} onOpenChange={onClose}>
+        <DialogContent className="max-w-2xl max-h-[80vh] flex flex-col">
+          <DialogHeader className="flex-shrink-0">
+            <div className="flex gap-2 items-center">
+              <FiWifi className="w-5 h-5" />
+              <DialogTitle>Proxy Management</DialogTitle>
+            </div>
+          </DialogHeader>
+
+          <div className="flex flex-col flex-1 gap-4 py-4 min-h-0">
+            {/* Header with Create Button */}
+            <div className="flex flex-shrink-0 justify-between items-center">
+              <div>
+                <h3 className="text-lg font-medium">Stored Proxies</h3>
+                <p className="text-sm text-muted-foreground">
+                  Manage your saved proxy configurations for reuse across
+                  profiles
+                </p>
+              </div>
+              <Button
+                onClick={handleCreateProxy}
+                className="flex gap-2 items-center"
+              >
+                <FiPlus className="w-4 h-4" />
+                Create Proxy
+              </Button>
+            </div>
+
+            {/* Proxy List - Scrollable */}
+            <div className="flex-1 min-h-0">
+              {loading ? (
+                <div className="flex justify-center items-center h-32">
+                  <p className="text-sm text-muted-foreground">
+                    Loading proxies...
+                  </p>
+                </div>
+              ) : storedProxies.length === 0 ? (
+                <div className="flex flex-col justify-center items-center h-32 text-center">
+                  <FiWifi className="mx-auto mb-4 w-12 h-12 text-muted-foreground" />
+                  <p className="mb-2 text-muted-foreground">
+                    No proxies configured
+                  </p>
+                  <p className="mb-4 text-sm text-muted-foreground">
+                    Create your first proxy configuration to get started
+                  </p>
+                  <Button variant="outline" onClick={handleCreateProxy}>
+                    <FiPlus className="mr-2 w-4 h-4" />
+                    Create First Proxy
+                  </Button>
+                </div>
+              ) : (
+                <div className="overflow-y-auto pr-2 space-y-2 h-full">
+                  {storedProxies.map((proxy) => (
+                    <div
+                      key={proxy.id}
+                      className="flex justify-between items-center p-1 rounded border bg-card"
+                    >
+                      <div className="flex-1 ml-2 min-w-0">
+                        {proxy.name.length > 30 ? (
+                          <Tooltip>
+                            <TooltipTrigger asChild>
+                              <span className="block font-medium truncate text-card-foreground">
+                                {trimName(proxy.name)}
+                              </span>
+                            </TooltipTrigger>
+                            <TooltipContent>
+                              <span className="text-sm font-medium text-card-foreground">
+                                {proxy.name}
+                              </span>
+                            </TooltipContent>
+                          </Tooltip>
+                        ) : (
+                          <span className="text-sm font-medium text-card-foreground">
+                            {proxy.name}
+                          </span>
+                        )}
+                      </div>
+                      <div className="flex flex-shrink-0 gap-1 items-center">
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              onClick={() => handleEditProxy(proxy)}
+                            >
+                              <FiEdit2 className="w-4 h-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            <p>Edit proxy</p>
+                          </TooltipContent>
+                        </Tooltip>
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              onClick={() => handleDeleteProxy(proxy)}
+                              className="text-destructive hover:text-destructive"
+                            >
+                              <FiTrash2 className="w-4 h-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            <p>Delete proxy</p>
+                          </TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              )}
+            </div>
+          </div>
+
+          <DialogFooter className="flex-shrink-0">
+            <Button onClick={onClose}>Close</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      <ProxyFormDialog
+        isOpen={showProxyForm}
+        onClose={handleProxyFormClose}
+        onSave={handleProxySaved}
+        editingProxy={editingProxy}
+      />
+    </>
+  );
+}

src/components/proxy-settings-dialog.tsx

@@ -1,7 +1,13 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { useCallback, useEffect, useState } from "react";
+import { FiPlus } from "react-icons/fi";
+import { toast } from "sonner";
+import { ProxyFormDialog } from "@/components/proxy-form-dialog";
+import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
-import { Checkbox } from "@/components/ui/checkbox";
+import { Card, CardContent } from "@/components/ui/card";
 import {
   Dialog,
   DialogContent,
@@ -9,36 +15,20 @@ import {
   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 {
   Tooltip,
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { useEffect, useState } from "react";
-
-interface ProxySettings {
-  enabled: boolean;
-  proxy_type: string;
-  host: string;
-  port: number;
-  username?: string;
-  password?: string;
-}
+import { cn } from "@/lib/utils";
+import type { StoredProxy } from "@/types";
 
 interface ProxySettingsDialogProps {
   isOpen: boolean;
   onClose: () => void;
-  onSave: (proxySettings: ProxySettings) => void;
-  initialSettings?: ProxySettings;
+  onSave: (proxyId: string | null) => void;
+  initialProxyId?: string | null;
   browserType?: string;
 }
 
@@ -46,232 +36,245 @@ export function ProxySettingsDialog({
   isOpen,
   onClose,
   onSave,
-  initialSettings,
+  initialProxyId,
   browserType,
 }: ProxySettingsDialogProps) {
-  const [settings, setSettings] = useState<ProxySettings>({
-    enabled: initialSettings?.enabled ?? false,
-    proxy_type: initialSettings?.proxy_type ?? "http",
-    host: initialSettings?.host ?? "",
-    port: initialSettings?.port ?? 8080,
-    username: initialSettings?.username ?? "",
-    password: initialSettings?.password ?? "",
-  });
-
-  const [initialSettingsState, setInitialSettingsState] =
-    useState<ProxySettings>({
-      enabled: false,
-      proxy_type: "http",
-      host: "",
-      port: 8080,
-      username: "",
-      password: "",
-    });
-
-  useEffect(() => {
-    if (isOpen && initialSettings) {
-      const newSettings = {
-        enabled: initialSettings.enabled,
-        proxy_type: initialSettings.proxy_type,
-        host: initialSettings.host,
-        port: initialSettings.port,
-        username: initialSettings.username ?? "",
-        password: initialSettings.password ?? "",
-      };
-      setSettings(newSettings);
-      setInitialSettingsState(newSettings);
-    } else if (isOpen) {
-      const defaultSettings = {
-        enabled: false,
-        proxy_type: "http",
-        host: "",
-        port: 80,
-        username: "",
-        password: "",
-      };
-      setSettings(defaultSettings);
-      setInitialSettingsState(defaultSettings);
-    }
-  }, [isOpen, initialSettings]);
-
-  const handleSubmit = () => {
-    onSave(settings);
-  };
-
-  // Check if settings have changed
-  const hasChanged = () => {
-    return (
-      settings.enabled !== initialSettingsState.enabled ||
-      settings.proxy_type !== initialSettingsState.proxy_type ||
-      settings.host !== initialSettingsState.host ||
-      settings.port !== initialSettingsState.port ||
-      settings.username !== initialSettingsState.username ||
-      settings.password !== initialSettingsState.password
-    );
-  };
+  const [storedProxies, setStoredProxies] = useState<StoredProxy[]>([]);
+  const [selectedProxyId, setSelectedProxyId] = useState<string | null>(
+    initialProxyId || null,
+  );
+  const [loading, setLoading] = useState(false);
+  const [showProxyForm, setShowProxyForm] = useState(false);
 
   // Helper to determine if proxy should be disabled for the selected browser
   const isProxyDisabled = browserType === "tor-browser";
 
-  // Update proxy enabled state when browser is tor-browser
-  useEffect(() => {
-    if (browserType === "tor-browser" && settings.enabled) {
-      setSettings((prev) => ({ ...prev, enabled: false }));
+  const loadStoredProxies = useCallback(async () => {
+    try {
+      setLoading(true);
+      const proxies = await invoke<StoredProxy[]>("get_stored_proxies");
+      setStoredProxies(proxies);
+    } catch (error) {
+      console.error("Failed to load stored proxies:", error);
+      toast.error("Failed to load proxies");
+    } finally {
+      setLoading(false);
     }
-  }, [browserType, settings.enabled]);
+  }, []);
+
+  useEffect(() => {
+    if (isOpen) {
+      loadStoredProxies();
+      if (isProxyDisabled) {
+        setSelectedProxyId(null);
+      }
+    }
+  }, [isOpen, isProxyDisabled, loadStoredProxies]);
+
+  const handleCreateProxy = useCallback(() => {
+    setShowProxyForm(true);
+  }, []);
+
+  const handleProxySaved = useCallback((savedProxy: StoredProxy) => {
+    setStoredProxies((prev) => {
+      const existingIndex = prev.findIndex((p) => p.id === savedProxy.id);
+      if (existingIndex >= 0) {
+        // Update existing proxy
+        const updated = [...prev];
+        updated[existingIndex] = savedProxy;
+        return updated;
+      } else {
+        // Add new proxy
+        return [...prev, savedProxy];
+      }
+    });
+    setSelectedProxyId(savedProxy.id);
+    setShowProxyForm(false);
+  }, []);
+
+  const handleProxyFormClose = useCallback(() => {
+    setShowProxyForm(false);
+  }, []);
+
+  const handleSave = () => {
+    onSave(selectedProxyId);
+  };
+
+  const hasChanged = () => {
+    return selectedProxyId !== initialProxyId;
+  };
 
   return (
-    <Dialog
-      open={isOpen}
-      onOpenChange={(open) => {
-        if (!open) {
-          onClose();
-        }
-      }}
-    >
-      <DialogContent>
-        <DialogHeader>
-          <DialogTitle>Proxy Settings</DialogTitle>
-        </DialogHeader>
+    <>
+      <Dialog
+        open={isOpen}
+        onOpenChange={(open) => {
+          if (!open) {
+            onClose();
+          }
+        }}
+      >
+        <DialogContent className="max-w-md max-h-[80vh] my-8 flex flex-col">
+          <DialogHeader className="flex-shrink-0">
+            <DialogTitle>Proxy Settings</DialogTitle>
+          </DialogHeader>
 
-        <div className="grid gap-4 py-4">
-          <div className="flex items-center space-x-2">
-            {isProxyDisabled ? (
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <div className="flex items-center space-x-2 opacity-50">
-                    <Checkbox
-                      id="proxy-enabled"
-                      checked={false}
-                      disabled={true}
-                    />
-                    <Label htmlFor="proxy-enabled" className="text-gray-500">
-                      Enable Proxy
-                    </Label>
-                  </div>
-                </TooltipTrigger>
-                <TooltipContent>
-                  <p>
-                    Tor Browser has its own built-in proxy system and
-                    doesn&apos;t support additional proxy configuration
-                  </p>
-                </TooltipContent>
-              </Tooltip>
-            ) : (
+          <div className="grid gap-6 py-4">
+            {isProxyDisabled && (
+              <div className="p-4 bg-yellow-50 rounded-md border border-yellow-200 dark:bg-yellow-900/20 dark:border-yellow-800">
+                <p className="text-sm text-yellow-800 dark:text-yellow-200">
+                  Tor Browser has its own built-in proxy system and doesn't
+                  support additional proxy configuration.
+                </p>
+              </div>
+            )}
+
+            {!isProxyDisabled && (
               <>
-                <Checkbox
-                  id="proxy-enabled"
-                  checked={settings.enabled}
-                  onCheckedChange={(checked) => {
-                    setSettings({ ...settings, enabled: checked as boolean });
-                  }}
-                />
-                <Label htmlFor="proxy-enabled">Enable Proxy</Label>
+                {/* Proxy Selection */}
+                <div className="space-y-3">
+                  <div className="flex justify-between items-center">
+                    <Label className="text-base font-medium">
+                      Select Proxy
+                    </Label>
+                    <Tooltip>
+                      <TooltipTrigger asChild>
+                        <Button
+                          variant="outline"
+                          size="sm"
+                          onClick={handleCreateProxy}
+                          className="flex gap-2 items-center"
+                        >
+                          <FiPlus className="w-4 h-4" />
+                          Create New
+                        </Button>
+                      </TooltipTrigger>
+                      <TooltipContent>
+                        <p>Create a new proxy configuration</p>
+                      </TooltipContent>
+                    </Tooltip>
+                  </div>
+
+                  <div className="overflow-y-auto p-2 space-y-2 h-full">
+                    <Button
+                      variant="ghost"
+                      onClick={() => setSelectedProxyId(null)}
+                      asChild
+                    >
+                      <Card
+                        className={cn(
+                          "w-full bg-card cursor-pointer transition-colors",
+                          selectedProxyId === null
+                            ? "ring-2 ring-blue-500"
+                            : "",
+                        )}
+                      >
+                        <CardContent className="p-4 w-full">
+                          <div className="flex items-center space-x-3">
+                            <input
+                              type="radio"
+                              id="no-proxy"
+                              name="proxy-selection"
+                              checked={selectedProxyId === null}
+                              onChange={() => setSelectedProxyId(null)}
+                            />
+                            <div className="flex gap-2 items-center">
+                              <Label
+                                htmlFor="no-proxy"
+                                className="font-medium cursor-pointer"
+                              >
+                                No Proxy
+                              </Label>
+                            </div>
+                          </div>
+                        </CardContent>
+                      </Card>
+                    </Button>
+
+                    {loading ? (
+                      <p className="text-sm text-muted-foreground">
+                        Loading proxies...
+                      </p>
+                    ) : (
+                      storedProxies.map((proxy) => (
+                        <Button
+                          key={proxy.id}
+                          variant="ghost"
+                          onClick={() => setSelectedProxyId(proxy.id)}
+                          asChild
+                        >
+                          <Card
+                            className={cn(
+                              "w-full bg-card cursor-pointer transition-colors",
+                              selectedProxyId === proxy.id
+                                ? "ring-2 ring-blue-500"
+                                : "",
+                            )}
+                          >
+                            <CardContent className="p-4 w-full">
+                              <div className="flex items-center space-x-3">
+                                <input
+                                  type="radio"
+                                  id={`proxy-${proxy.id}`}
+                                  name="proxy-selection"
+                                  checked={selectedProxyId === proxy.id}
+                                  onChange={() => setSelectedProxyId(proxy.id)}
+                                />
+                                <div className="flex gap-2 items-center">
+                                  <Label
+                                    htmlFor={`proxy-${proxy.id}`}
+                                    className="font-medium cursor-pointer"
+                                  >
+                                    {proxy.name}
+                                  </Label>
+                                  <Badge variant="outline">
+                                    {proxy.proxy_settings.proxy_type.toUpperCase()}
+                                  </Badge>
+                                </div>
+                              </div>
+                            </CardContent>
+                          </Card>
+                        </Button>
+                      ))
+                    )}
+
+                    {!loading && storedProxies.length === 0 && (
+                      <div className="py-4 text-center">
+                        <p className="mb-2 text-sm text-muted-foreground">
+                          No saved proxies available.
+                        </p>
+                        <Button
+                          variant="outline"
+                          size="sm"
+                          onClick={handleCreateProxy}
+                        >
+                          <FiPlus className="mr-2 w-4 h-4" />
+                          Create First Proxy
+                        </Button>
+                      </div>
+                    )}
+                  </div>
+                </div>
               </>
             )}
           </div>
 
-          {settings.enabled && !isProxyDisabled && (
-            <>
-              <div className="grid gap-2">
-                <Label>Proxy Type</Label>
-                <Select
-                  value={settings.proxy_type}
-                  onValueChange={(value) => {
-                    setSettings({
-                      ...settings,
-                      proxy_type: value,
-                    });
-                  }}
-                >
-                  <SelectTrigger>
-                    <SelectValue placeholder="Select proxy type" />
-                  </SelectTrigger>
-                  <SelectContent>
-                    {["http", "https", "socks4", "socks5"].map((type) => (
-                      <SelectItem key={type} value={type}>
-                        {type.toUpperCase()}
-                      </SelectItem>
-                    ))}
-                  </SelectContent>
-                </Select>
-              </div>
+          <DialogFooter>
+            <Button variant="outline" onClick={onClose}>
+              Cancel
+            </Button>
+            <Button onClick={handleSave} disabled={!hasChanged()}>
+              Save
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
 
-              <div className="grid gap-2">
-                <Label htmlFor="host">Host</Label>
-                <Input
-                  id="host"
-                  value={settings.host}
-                  onChange={(e) => {
-                    setSettings({ ...settings, host: e.target.value });
-                  }}
-                  placeholder="e.g. 127.0.0.1"
-                />
-              </div>
-
-              <div className="grid gap-2">
-                <Label htmlFor="port">Port</Label>
-                <Input
-                  id="port"
-                  type="number"
-                  value={settings.port}
-                  onChange={(e) => {
-                    setSettings({
-                      ...settings,
-                      port: Number.parseInt(e.target.value, 10) || 0,
-                    });
-                  }}
-                  placeholder="e.g. 8080"
-                  min="1"
-                  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>
-
-        <DialogFooter>
-          <Button variant="outline" onClick={onClose}>
-            Cancel
-          </Button>
-          <Button
-            onClick={handleSubmit}
-            disabled={
-              !hasChanged() ||
-              (!isProxyDisabled &&
-                settings.enabled &&
-                (!settings.host || !settings.port))
-            }
-          >
-            Save
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
+      <ProxyFormDialog
+        isOpen={showProxyForm}
+        onClose={handleProxyFormClose}
+        onSave={handleProxySaved}
+      />
+    </>
   );
 }

src/components/release-type-selector.tsx

@@ -1,5 +1,7 @@
 "use client";
 
+import { useState } from "react";
+import { LuCheck, LuChevronsUpDown, LuDownload } from "react-icons/lu";
 import { LoadingButton } from "@/components/loading-button";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -17,9 +19,6 @@ import {
 } 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;
@@ -55,6 +54,16 @@ export function ReleaseTypeSelector({
       : []),
   ];
 
+  // Only show dropdown if there are multiple release types available
+  const showDropdown = releaseOptions.length > 1;
+
+  // If only one release type is available, auto-select it
+  if (!showDropdown && releaseOptions.length === 1 && !selectedReleaseType) {
+    setTimeout(() => {
+      onReleaseTypeSelect(releaseOptions[0].type);
+    }, 0);
+  }
+
   const selectedDisplayText = selectedReleaseType
     ? selectedReleaseType === "stable"
       ? "Stable"
@@ -73,75 +82,99 @@ export function ReleaseTypeSelector({
 
   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
+      {showDropdown ? (
+        <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="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>
-                        )}
-                        <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>
+                          {isDownloaded && (
+                            <Badge variant="default" className="text-xs">
+                              Downloaded
+                            </Badge>
+                          )}
+                        </div>
+                      </CommandItem>
+                    );
+                  })}
+                </CommandGroup>
+              </CommandList>
+            </Command>
+          </PopoverContent>
+        </Popover>
+      ) : (
+        // Show a simple display when only one release type is available
+        releaseOptions.length === 1 && (
+          <div className="flex gap-2 justify-center items-center p-3 rounded-md border bg-muted/50">
+            <span className="text-sm font-medium capitalize">
+              {releaseOptions[0].type}
+            </span>
+            {releaseOptions[0].type === "nightly" && (
+              <Badge variant="secondary" className="text-xs">
+                Nightly
+              </Badge>
+            )}
+            <Badge variant="outline" className="text-xs">
+              {releaseOptions[0].version}
+            </Badge>
+            {downloadedVersions.includes(releaseOptions[0].version) && (
+              <Badge variant="default" className="text-xs">
+                Downloaded
+              </Badge>
+            )}
+          </div>
+        )
+      )}
 
       {showDownloadButton &&
         selectedReleaseType &&

src/components/settings-dialog.tsx

@@ -1,5 +1,9 @@
 "use client";
 
+import { invoke } from "@tauri-apps/api/core";
+import { useTheme } from "next-themes";
+import { useCallback, useEffect, useState } from "react";
+import { BsCamera, BsMic } from "react-icons/bs";
 import { LoadingButton } from "@/components/loading-button";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
@@ -19,19 +23,14 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
-import { usePermissions } from "@/hooks/use-permissions";
 import type { PermissionType } from "@/hooks/use-permissions";
+import { usePermissions } from "@/hooks/use-permissions";
 import { showErrorToast, showSuccessToast } from "@/lib/toast-utils";
-import { invoke } from "@tauri-apps/api/core";
-import { useTheme } from "next-themes";
-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_delete_unused_binaries: boolean;
 }
 
 interface PermissionInfo {
@@ -50,13 +49,11 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_delete_unused_binaries: true,
   });
   const [originalSettings, setOriginalSettings] = useState<AppSettings>({
     set_as_default_browser: false,
     show_settings_on_startup: true,
     theme: "system",
-    auto_delete_unused_binaries: true,
   });
   const [isDefaultBrowser, setIsDefaultBrowser] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
@@ -76,6 +73,35 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     isCameraAccessGranted,
   } = usePermissions();
 
+  const getPermissionIcon = useCallback((type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return <BsMic className="w-4 h-4" />;
+      case "camera":
+        return <BsCamera className="w-4 h-4" />;
+    }
+  }, []);
+
+  const getPermissionDisplayName = useCallback((type: PermissionType) => {
+    switch (type) {
+      case "microphone":
+        return "Microphone";
+      case "camera":
+        return "Camera";
+    }
+  }, []);
+
+  const getStatusBadge = useCallback((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 getPermissionDescription = useCallback((type: PermissionType) => {
     switch (type) {
       case "microphone":
@@ -84,60 +110,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
         return "Access to camera for browser applications";
     }
   }, []);
-
-  useEffect(() => {
-    if (isOpen) {
-      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(() => {
-        checkDefaultBrowserStatus().catch(console.error);
-      }, 500); // Check every 500ms
-
-      // Cleanup interval on component unmount or dialog close
-      return () => {
-        clearInterval(intervalId);
-      };
-    }
-  }, [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 () => {
+  const loadSettings = useCallback(async () => {
     setIsLoading(true);
     try {
       const appSettings = await invoke<AppSettings>("get_app_settings");
@@ -148,9 +121,9 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     } finally {
       setIsLoading(false);
     }
-  };
+  }, []);
 
-  const loadPermissions = async () => {
+  const loadPermissions = useCallback(async () => {
     setIsLoadingPermissions(true);
     try {
       if (!isMacOS) {
@@ -178,18 +151,23 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     } finally {
       setIsLoadingPermissions(false);
     }
-  };
+  }, [
+    getPermissionDescription,
+    isCameraAccessGranted,
+    isMacOS,
+    isMicrophoneAccessGranted,
+  ]);
 
-  const checkDefaultBrowserStatus = async () => {
+  const checkDefaultBrowserStatus = useCallback(async () => {
     try {
       const isDefault = await invoke<boolean>("is_default_browser");
       setIsDefaultBrowser(isDefault);
     } catch (error) {
       console.error("Failed to check default browser status:", error);
     }
-  };
+  }, []);
 
-  const handleSetDefaultBrowser = async () => {
+  const handleSetDefaultBrowser = useCallback(async () => {
     setIsSettingDefault(true);
     try {
       await invoke("set_as_default_browser");
@@ -199,9 +177,9 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     } finally {
       setIsSettingDefault(false);
     }
-  };
+  }, [checkDefaultBrowserStatus]);
 
-  const handleClearCache = async () => {
+  const handleClearCache = useCallback(async () => {
     setIsClearingCache(true);
     try {
       await invoke("clear_all_version_cache_and_refetch");
@@ -220,52 +198,25 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     } 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 () => {
+  const handleRequestPermission = useCallback(
+    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);
+      }
+    },
+    [getPermissionDisplayName, requestPermission],
+  );
+  const handleSave = useCallback(async () => {
     setIsSaving(true);
     try {
       await invoke("save_app_settings", { settings });
@@ -277,19 +228,72 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
     } finally {
       setIsSaving(false);
     }
-  };
+  }, [onClose, setTheme, settings]);
 
-  const updateSetting = (key: keyof AppSettings, value: boolean | string) => {
-    setSettings((prev) => ({ ...prev, [key]: value }));
-  };
+  const updateSetting = useCallback(
+    (key: keyof AppSettings, value: boolean | string) => {
+      setSettings((prev) => ({ ...prev, [key]: value }));
+    },
+    [],
+  );
+
+  useEffect(() => {
+    if (isOpen) {
+      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(() => {
+        checkDefaultBrowserStatus().catch(console.error);
+      }, 500); // Check every 500ms
+
+      // Cleanup interval on component unmount or dialog close
+      return () => {
+        clearInterval(intervalId);
+      };
+    }
+  }, [isOpen, loadPermissions, checkDefaultBrowserStatus, loadSettings]);
+
+  // 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,
+  ]);
 
   // Check if settings have changed (excluding default browser setting)
   const hasChanges =
     settings.show_settings_on_startup !==
       originalSettings.show_settings_on_startup ||
-    settings.theme !== originalSettings.theme ||
-    settings.auto_delete_unused_binaries !==
-      originalSettings.auto_delete_unused_binaries;
+    settings.theme !== originalSettings.theme;
 
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
@@ -358,33 +362,6 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
             </p>
           </div>
 
-          {/* Auto-Update Section */}
-          <div className="space-y-4">
-            <Label className="text-base font-medium">Auto-Updates</Label>
-
-            <div className="flex items-center space-x-2">
-              <Checkbox
-                id="auto-delete-binaries"
-                checked={settings.auto_delete_unused_binaries}
-                onCheckedChange={(checked) => {
-                  updateSetting(
-                    "auto_delete_unused_binaries",
-                    checked as boolean,
-                  );
-                }}
-              />
-              <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. Unused
-              binaries will be automatically deleted to save disk space.
-            </p>
-          </div>
-
           {/* Startup Behavior Section */}
           <div className="space-y-4">
             <Label className="text-base font-medium">Startup Behavior</Label>

src/components/shared-camoufox-config-form.tsx

@@ -0,0 +1,568 @@
+"use client";
+
+import { invoke } from "@tauri-apps/api/core";
+import { useEffect, useState } from "react";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import type { CamoufoxConfig } from "@/types";
+
+const osOptions = [
+  { value: "windows", label: "Windows" },
+  { value: "macos", label: "macOS" },
+  { value: "linux", label: "Linux" },
+];
+
+const timezoneOptions = [
+  { value: "America/New_York", label: "America/New_York" },
+  { value: "America/Los_Angeles", label: "America/Los_Angeles" },
+  { value: "America/Chicago", label: "America/Chicago" },
+  { value: "America/Denver", label: "America/Denver" },
+  { value: "America/Phoenix", label: "America/Phoenix" },
+  { value: "America/Toronto", label: "America/Toronto" },
+  { value: "America/Vancouver", label: "America/Vancouver" },
+  { value: "Europe/London", label: "Europe/London" },
+  { value: "Europe/Paris", label: "Europe/Paris" },
+  { value: "Europe/Berlin", label: "Europe/Berlin" },
+  { value: "Europe/Rome", label: "Europe/Rome" },
+  { value: "Europe/Madrid", label: "Europe/Madrid" },
+  { value: "Europe/Amsterdam", label: "Europe/Amsterdam" },
+  { value: "Europe/Zurich", label: "Europe/Zurich" },
+  { value: "Europe/Vienna", label: "Europe/Vienna" },
+  { value: "Europe/Warsaw", label: "Europe/Warsaw" },
+  { value: "Europe/Prague", label: "Europe/Prague" },
+  { value: "Europe/Stockholm", label: "Europe/Stockholm" },
+  { value: "Europe/Copenhagen", label: "Europe/Copenhagen" },
+  { value: "Europe/Helsinki", label: "Europe/Helsinki" },
+  { value: "Europe/Oslo", label: "Europe/Oslo" },
+  { value: "Europe/Brussels", label: "Europe/Brussels" },
+  { value: "Europe/Dublin", label: "Europe/Dublin" },
+  { value: "Europe/Lisbon", label: "Europe/Lisbon" },
+  { value: "Europe/Athens", label: "Europe/Athens" },
+  { value: "Europe/Budapest", label: "Europe/Budapest" },
+  { value: "Europe/Bucharest", label: "Europe/Bucharest" },
+  { value: "Europe/Sofia", label: "Europe/Sofia" },
+  { value: "Europe/Kiev", label: "Europe/Kiev" },
+  { value: "Europe/Moscow", label: "Europe/Moscow" },
+  { value: "Asia/Tokyo", label: "Asia/Tokyo" },
+  { value: "Asia/Seoul", label: "Asia/Seoul" },
+  { value: "Asia/Shanghai", label: "Asia/Shanghai" },
+  { value: "Asia/Hong_Kong", label: "Asia/Hong_Kong" },
+  { value: "Asia/Singapore", label: "Asia/Singapore" },
+  { value: "Asia/Bangkok", label: "Asia/Bangkok" },
+  { value: "Asia/Jakarta", label: "Asia/Jakarta" },
+  { value: "Asia/Manila", label: "Asia/Manila" },
+  { value: "Asia/Kolkata", label: "Asia/Kolkata" },
+  { value: "Asia/Dubai", label: "Asia/Dubai" },
+  { value: "Asia/Riyadh", label: "Asia/Riyadh" },
+  { value: "Asia/Tehran", label: "Asia/Tehran" },
+  { value: "Asia/Jerusalem", label: "Asia/Jerusalem" },
+  { value: "Asia/Istanbul", label: "Asia/Istanbul" },
+  { value: "Australia/Sydney", label: "Australia/Sydney" },
+  { value: "Australia/Melbourne", label: "Australia/Melbourne" },
+  { value: "Australia/Brisbane", label: "Australia/Brisbane" },
+  { value: "Australia/Perth", label: "Australia/Perth" },
+  { value: "Australia/Adelaide", label: "Australia/Adelaide" },
+  { value: "Pacific/Auckland", label: "Pacific/Auckland" },
+  { value: "Pacific/Honolulu", label: "Pacific/Honolulu" },
+  { value: "Africa/Cairo", label: "Africa/Cairo" },
+  { value: "Africa/Johannesburg", label: "Africa/Johannesburg" },
+  { value: "Africa/Lagos", label: "Africa/Lagos" },
+  { value: "Africa/Nairobi", label: "Africa/Nairobi" },
+  { value: "America/Sao_Paulo", label: "America/Sao_Paulo" },
+  { value: "America/Buenos_Aires", label: "America/Buenos_Aires" },
+  { value: "America/Lima", label: "America/Lima" },
+  { value: "America/Bogota", label: "America/Bogota" },
+  { value: "America/Santiago", label: "America/Santiago" },
+  { value: "America/Caracas", label: "America/Caracas" },
+  { value: "America/Mexico_City", label: "America/Mexico_City" },
+];
+
+const localeOptions = [
+  { value: "en-US", label: "English (US)" },
+  { value: "en-GB", label: "English (UK)" },
+  { value: "en-CA", label: "English (Canada)" },
+  { value: "en-AU", label: "English (Australia)" },
+  { value: "fr-FR", label: "French (France)" },
+  { value: "fr-CA", label: "French (Canada)" },
+  { value: "de-DE", label: "German (Germany)" },
+  { value: "de-AT", label: "German (Austria)" },
+  { value: "de-CH", label: "German (Switzerland)" },
+  { value: "es-ES", label: "Spanish (Spain)" },
+  { value: "es-MX", label: "Spanish (Mexico)" },
+  { value: "es-AR", label: "Spanish (Argentina)" },
+  { value: "it-IT", label: "Italian (Italy)" },
+  { value: "it-CH", label: "Italian (Switzerland)" },
+  { value: "pt-BR", label: "Portuguese (Brazil)" },
+  { value: "pt-PT", label: "Portuguese (Portugal)" },
+  { value: "ru-RU", label: "Russian (Russia)" },
+  { value: "zh-CN", label: "Chinese (Simplified)" },
+  { value: "zh-TW", label: "Chinese (Traditional)" },
+  { value: "ja-JP", label: "Japanese (Japan)" },
+  { value: "ko-KR", label: "Korean (Korea)" },
+  { value: "ar-SA", label: "Arabic (Saudi Arabia)" },
+  { value: "ar-EG", label: "Arabic (Egypt)" },
+  { value: "hi-IN", label: "Hindi (India)" },
+  { value: "tr-TR", label: "Turkish (Turkey)" },
+  { value: "pl-PL", label: "Polish (Poland)" },
+  { value: "nl-NL", label: "Dutch (Netherlands)" },
+  { value: "nl-BE", label: "Dutch (Belgium)" },
+  { value: "sv-SE", label: "Swedish (Sweden)" },
+  { value: "da-DK", label: "Danish (Denmark)" },
+  { value: "no-NO", label: "Norwegian (Norway)" },
+  { value: "fi-FI", label: "Finnish (Finland)" },
+  { value: "he-IL", label: "Hebrew (Israel)" },
+  { value: "th-TH", label: "Thai (Thailand)" },
+  { value: "vi-VN", label: "Vietnamese (Vietnam)" },
+  { value: "id-ID", label: "Indonesian (Indonesia)" },
+  { value: "ms-MY", label: "Malay (Malaysia)" },
+  { value: "uk-UA", label: "Ukrainian (Ukraine)" },
+  { value: "cs-CZ", label: "Czech (Czech Republic)" },
+  { value: "sk-SK", label: "Slovak (Slovakia)" },
+  { value: "hu-HU", label: "Hungarian (Hungary)" },
+  { value: "ro-RO", label: "Romanian (Romania)" },
+  { value: "bg-BG", label: "Bulgarian (Bulgaria)" },
+  { value: "hr-HR", label: "Croatian (Croatia)" },
+  { value: "sr-RS", label: "Serbian (Serbia)" },
+  { value: "sl-SI", label: "Slovenian (Slovenia)" },
+  { value: "lt-LT", label: "Lithuanian (Lithuania)" },
+  { value: "lv-LV", label: "Latvian (Latvia)" },
+  { value: "et-EE", label: "Estonian (Estonia)" },
+  { value: "el-GR", label: "Greek (Greece)" },
+  { value: "ca-ES", label: "Catalan (Spain)" },
+  { value: "eu-ES", label: "Basque (Spain)" },
+  { value: "gl-ES", label: "Galician (Spain)" },
+  { value: "is-IS", label: "Icelandic (Iceland)" },
+  { value: "mt-MT", label: "Maltese (Malta)" },
+];
+
+const getCurrentOS = () => {
+  if (typeof window !== "undefined") {
+    const userAgent = window.navigator.userAgent;
+    if (userAgent.includes("Win")) return "windows";
+    if (userAgent.includes("Mac")) return "macos";
+    if (userAgent.includes("Linux")) return "linux";
+  }
+  return "unknown";
+};
+
+interface SystemLocale {
+  locale: string;
+  language: string;
+  country: string;
+}
+
+interface SystemTimezone {
+  timezone: string;
+  offset: string;
+}
+
+interface SharedCamoufoxConfigFormProps {
+  config: CamoufoxConfig;
+  onConfigChange: (key: keyof CamoufoxConfig, value: unknown) => void;
+  className?: string;
+}
+
+export function SharedCamoufoxConfigForm({
+  config,
+  onConfigChange,
+  className = "",
+}: SharedCamoufoxConfigFormProps) {
+  const [systemLocale, setSystemLocale] = useState<SystemLocale | null>(null);
+  const [systemTimezone, setSystemTimezone] = useState<SystemTimezone | null>(
+    null,
+  );
+  const [isLoadingSystemDefaults, setIsLoadingSystemDefaults] = useState(true);
+
+  // Load system defaults on component mount
+  useEffect(() => {
+    const loadSystemDefaults = async () => {
+      try {
+        const [locale, timezone] = await Promise.all([
+          invoke<SystemLocale>("get_system_locale"),
+          invoke<SystemTimezone>("get_system_timezone"),
+        ]);
+        setSystemLocale(locale);
+        setSystemTimezone(timezone);
+      } catch (error) {
+        console.error("Failed to load system defaults:", error);
+        // Set fallback defaults
+        setSystemLocale({
+          locale: "en-US",
+          language: "en",
+          country: "US",
+        });
+        setSystemTimezone({
+          timezone: "America/New_York",
+          offset: "-05:00",
+        });
+      } finally {
+        setIsLoadingSystemDefaults(false);
+      }
+    };
+
+    loadSystemDefaults();
+  }, []);
+
+  // Get the selected OS for warning
+  const selectedOS = config.os?.[0];
+  const currentOS = getCurrentOS();
+  const showOSWarning =
+    selectedOS && selectedOS !== currentOS && currentOS !== "unknown";
+
+  return (
+    <div className={`space-y-6 ${className}`}>
+      {/* OS Selection */}
+      <div className="space-y-3">
+        <Label>Operating System</Label>
+        <Select
+          value={config.os?.[0] || getCurrentOS()}
+          onValueChange={(value) => onConfigChange("os", [value])}
+        >
+          <SelectTrigger>
+            <SelectValue placeholder="Select OS" />
+          </SelectTrigger>
+          <SelectContent>
+            {osOptions.map((os) => (
+              <SelectItem key={os.value} value={os.value}>
+                {os.label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        {showOSWarning && (
+          <p className="text-sm text-yellow-600 dark:text-yellow-400">
+            ⚠️ Selected OS ({selectedOS}) differs from your current OS (
+            {currentOS}). This may affect fingerprinting effectiveness.
+          </p>
+        )}
+      </div>
+
+      {/* Privacy & Blocking */}
+      <div className="space-y-3">
+        <Label>Privacy & Blocking</Label>
+        <div className="space-y-2">
+          <div className="flex items-center space-x-2">
+            <Checkbox
+              id="block-images"
+              checked={config.block_images || false}
+              onCheckedChange={(checked) =>
+                onConfigChange("block_images", checked)
+              }
+            />
+            <Label htmlFor="block-images">Block Images</Label>
+          </div>
+          <div className="flex items-center space-x-2">
+            <Checkbox
+              id="block-webrtc"
+              checked={config.block_webrtc || false}
+              onCheckedChange={(checked) =>
+                onConfigChange("block_webrtc", checked)
+              }
+            />
+            <Label htmlFor="block-webrtc">Block WebRTC</Label>
+          </div>
+          <div className="flex items-center space-x-2">
+            <Checkbox
+              id="block-webgl"
+              checked={config.block_webgl || false}
+              onCheckedChange={(checked) =>
+                onConfigChange("block_webgl", checked)
+              }
+            />
+            <Label htmlFor="block-webgl">Block WebGL</Label>
+          </div>
+        </div>
+      </div>
+
+      {/* Geolocation */}
+      <div className="space-y-3">
+        <Label>Geolocation</Label>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="country">Country</Label>
+            <Input
+              id="country"
+              value={config.country || ""}
+              onChange={(e) =>
+                onConfigChange("country", e.target.value || undefined)
+              }
+              placeholder={
+                systemLocale
+                  ? `e.g., ${systemLocale.country}`
+                  : "e.g., US, GB, DE"
+              }
+            />
+          </div>
+          <div className="space-y-2">
+            <Label>Timezone</Label>
+            <Select
+              value={config.timezone || "auto"}
+              onValueChange={(value) =>
+                onConfigChange("timezone", value === "auto" ? undefined : value)
+              }
+            >
+              <SelectTrigger>
+                <SelectValue
+                  placeholder={
+                    isLoadingSystemDefaults ? "Loading..." : "Select timezone"
+                  }
+                />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="auto">
+                  {isLoadingSystemDefaults
+                    ? "Auto (loading...)"
+                    : `Auto (${systemTimezone?.timezone || "UTC"})`}
+                </SelectItem>
+                {timezoneOptions.map((tz) => (
+                  <SelectItem key={tz.value} value={tz.value}>
+                    {tz.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="latitude">Latitude</Label>
+            <Input
+              id="latitude"
+              type="number"
+              step="any"
+              value={config.latitude || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "latitude",
+                  e.target.value ? parseFloat(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 40.7128"
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="longitude">Longitude</Label>
+            <Input
+              id="longitude"
+              type="number"
+              step="any"
+              value={config.longitude || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "longitude",
+                  e.target.value ? parseFloat(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., -74.0060"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Localization */}
+      <div className="space-y-3">
+        <Label>Locale</Label>
+        <Select
+          value={config.locale?.[0] || ""}
+          onValueChange={(value) =>
+            onConfigChange("locale", value ? [value] : undefined)
+          }
+        >
+          <SelectTrigger>
+            <SelectValue
+              placeholder={
+                isLoadingSystemDefaults
+                  ? "Loading..."
+                  : `Select locale (system: ${systemLocale?.locale || "unknown"})`
+              }
+            />
+          </SelectTrigger>
+          <SelectContent>
+            {!isLoadingSystemDefaults && systemLocale && (
+              <SelectItem value={systemLocale.locale}>
+                {systemLocale.locale} (System Default)
+              </SelectItem>
+            )}
+            {localeOptions.map((locale) => (
+              <SelectItem key={locale.value} value={locale.value}>
+                {locale.label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {/* Screen Resolution */}
+      <div className="space-y-3">
+        <Label>Screen Resolution</Label>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="screen-min-width">Min Width</Label>
+            <Input
+              id="screen-min-width"
+              type="number"
+              value={config.screen_min_width || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "screen_min_width",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 1024"
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="screen-max-width">Max Width</Label>
+            <Input
+              id="screen-max-width"
+              type="number"
+              value={config.screen_max_width || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "screen_max_width",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 1920"
+            />
+          </div>
+        </div>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="screen-min-height">Min Height</Label>
+            <Input
+              id="screen-min-height"
+              type="number"
+              value={config.screen_min_height || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "screen_min_height",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 768"
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="screen-max-height">Max Height</Label>
+            <Input
+              id="screen-max-height"
+              type="number"
+              value={config.screen_max_height || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "screen_max_height",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 1080"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Window Size */}
+      <div className="space-y-3">
+        <Label>Window Size</Label>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="window-width">Width</Label>
+            <Input
+              id="window-width"
+              type="number"
+              value={config.window_width || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "window_width",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 1366"
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="window-height">Height</Label>
+            <Input
+              id="window-height"
+              type="number"
+              value={config.window_height || ""}
+              onChange={(e) =>
+                onConfigChange(
+                  "window_height",
+                  e.target.value ? parseInt(e.target.value) : undefined,
+                )
+              }
+              placeholder="e.g., 768"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Advanced Options */}
+      <div className="space-y-3">
+        <Label>Advanced Options</Label>
+        <div className="space-y-2">
+          <div className="flex items-center space-x-2">
+            <Checkbox
+              id="enable-cache"
+              checked={config.enable_cache || false}
+              onCheckedChange={(checked) =>
+                onConfigChange("enable_cache", checked)
+              }
+            />
+            <Label htmlFor="enable-cache">Enable Browser Cache</Label>
+          </div>
+          <div className="flex items-center space-x-2">
+            <Checkbox
+              id="main-world-eval"
+              checked={config.main_world_eval || false}
+              onCheckedChange={(checked) =>
+                onConfigChange("main_world_eval", checked)
+              }
+            />
+            <Label htmlFor="main-world-eval">
+              Enable Main World Evaluation
+            </Label>
+          </div>
+        </div>
+      </div>
+
+      {/* WebGL Settings */}
+      <div className="space-y-3">
+        <Label>WebGL Settings</Label>
+        <div className="grid grid-cols-2 gap-4">
+          <div className="space-y-2">
+            <Label htmlFor="webgl-vendor">WebGL Vendor</Label>
+            <Input
+              id="webgl-vendor"
+              value={config.webgl_vendor || ""}
+              onChange={(e) =>
+                onConfigChange("webgl_vendor", e.target.value || undefined)
+              }
+              placeholder="e.g., Intel Inc."
+            />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor="webgl-renderer">WebGL Renderer</Label>
+            <Input
+              id="webgl-renderer"
+              value={config.webgl_renderer || ""}
+              onChange={(e) =>
+                onConfigChange("webgl_renderer", e.target.value || undefined)
+              }
+              placeholder="e.g., Intel HD Graphics"
+            />
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

src/components/ui/alert.tsx

@@ -1,4 +1,4 @@
-import { type VariantProps, cva } from "class-variance-authority";
+import { cva, type VariantProps } from "class-variance-authority";
 import type * as React from "react";
 
 import { cn } from "@/lib/utils";

src/components/ui/badge.tsx

@@ -1,5 +1,5 @@
 import { Slot } from "@radix-ui/react-slot";
-import { type VariantProps, cva } from "class-variance-authority";
+import { cva, type VariantProps } from "class-variance-authority";
 import type * as React from "react";
 
 import { cn } from "@/lib/utils";

src/components/ui/button.tsx

@@ -1,5 +1,5 @@
 import { Slot } from "@radix-ui/react-slot";
-import { type VariantProps, cva } from "class-variance-authority";
+import { cva, type VariantProps } from "class-variance-authority";
 import type * as React from "react";
 
 import { cn } from "@/lib/utils";

src/components/ui/combobox.tsx

@@ -19,6 +19,85 @@ import {
 } from "@/components/ui/popover";
 import { cn } from "@/lib/utils";
 
+interface ComboboxOption {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+interface ComboboxProps {
+  options: ComboboxOption[];
+  value: string;
+  onValueChange: (value: string) => void;
+  placeholder?: string;
+  searchPlaceholder?: string;
+  className?: string;
+}
+
+export function Combobox({
+  options,
+  value,
+  onValueChange,
+  placeholder = "Select option...",
+  searchPlaceholder = "Search...",
+  className,
+}: ComboboxProps) {
+  const [open, setOpen] = React.useState(false);
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger asChild>
+        <Button
+          variant="outline"
+          role="combobox"
+          aria-expanded={open}
+          className={cn("w-full justify-between", className)}
+        >
+          {value
+            ? options.find((option) => option.value === value)?.label
+            : placeholder}
+          <LuChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+        </Button>
+      </PopoverTrigger>
+      <PopoverContent className="w-full p-0">
+        <Command>
+          <CommandInput placeholder={searchPlaceholder} />
+          <CommandList>
+            <CommandEmpty>No option found.</CommandEmpty>
+            <CommandGroup>
+              {options.map((option) => (
+                <CommandItem
+                  key={option.value}
+                  value={option.value}
+                  onSelect={(currentValue) => {
+                    onValueChange(currentValue === value ? "" : currentValue);
+                    setOpen(false);
+                  }}
+                >
+                  <LuCheck
+                    className={cn(
+                      "mr-2 h-4 w-4",
+                      value === option.value ? "opacity-100" : "opacity-0",
+                    )}
+                  />
+                  <div className="flex flex-col">
+                    <span>{option.label}</span>
+                    {option.description && (
+                      <span className="text-sm text-muted-foreground">
+                        {option.description}
+                      </span>
+                    )}
+                  </div>
+                </CommandItem>
+              ))}
+            </CommandGroup>
+          </CommandList>
+        </Command>
+      </PopoverContent>
+    </Popover>
+  );
+}
+
 const frameworks = [
   {
     value: "next.js",

src/components/ui/dialog.tsx

@@ -5,6 +5,7 @@ import type * as React from "react";
 import { RxCross2 } from "react-icons/rx";
 
 import { cn } from "@/lib/utils";
+import { WindowDragArea } from "../window-drag-area";
 
 function Dialog({
   ...props
@@ -38,11 +39,13 @@ function DialogOverlay({
     <DialogPrimitive.Overlay
       data-slot="dialog-overlay"
       className={cn(
-        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-[9999] bg-black/50",
         className,
       )}
       {...props}
-    />
+    >
+      <WindowDragArea />
+    </DialogPrimitive.Overlay>
   );
 }
 
@@ -57,7 +60,7 @@ function DialogContent({
       <DialogPrimitive.Content
         data-slot="dialog-content"
         className={cn(
-          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
+          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-[10000] grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg",
           className,
         )}
         {...props}
@@ -102,7 +105,7 @@ function DialogTitle({
   return (
     <DialogPrimitive.Title
       data-slot="dialog-title"
-      className={cn("text-lg leading-none font-semibold", className)}
+      className={cn("text-lg font-semibold leading-none", className)}
       {...props}
     />
   );
@@ -115,7 +118,7 @@ function DialogDescription({
   return (
     <DialogPrimitive.Description
       data-slot="dialog-description"
-      className={cn("text-muted-foreground text-sm", className)}
+      className={cn("text-sm text-muted-foreground", className)}
       {...props}
     />
   );

src/components/ui/dropdown-menu.tsx

@@ -42,7 +42,7 @@ function DropdownMenuContent({
         data-slot="dropdown-menu-content"
         sideOffset={sideOffset}
         className={cn(
-          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border p-1 shadow-md",
+          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-[50000] max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border p-1 shadow-md",
           className,
         )}
         {...props}
@@ -230,7 +230,7 @@ function DropdownMenuSubContent({
     <DropdownMenuPrimitive.SubContent
       data-slot="dropdown-menu-sub-content"
       className={cn(
-        "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg",
+        "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-[50000] min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg",
         className,
       )}
       {...props}

src/components/ui/popover.tsx

@@ -30,7 +30,7 @@ function PopoverContent({
         align={align}
         sideOffset={sideOffset}
         className={cn(
-          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 origin-(--radix-popover-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden",
+          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-[50000] origin-(--radix-popover-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden",
           className,
         )}
         {...props}

src/components/ui/select.tsx

@@ -61,7 +61,7 @@ function SelectContent({
       <SelectPrimitive.Content
         data-slot="select-content"
         className={cn(
-          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
+          "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-[50000] max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
           position === "popper" &&
             "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
           className,

src/components/ui/table.tsx

@@ -8,11 +8,11 @@ function Table({ className, ...props }: React.ComponentProps<"table">) {
   return (
     <div
       data-slot="table-container"
-      className="relative w-full overflow-x-auto"
+      className="overflow-x-auto relative w-full"
     >
       <table
         data-slot="table"
-        className={cn("w-full caption-bottom text-sm", className)}
+        className={cn("w-full text-sm caption-bottom", className)}
         {...props}
       />
     </div>
@@ -98,7 +98,7 @@ function TableCaption({
   return (
     <caption
       data-slot="table-caption"
-      className={cn("text-muted-foreground mt-4 text-sm", className)}
+      className={cn("mt-4 text-sm text-muted-foreground", className)}
       {...props}
     />
   );

src/components/ui/tabs.tsx

@@ -0,0 +1,55 @@
+"use client";
+
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const Tabs = TabsPrimitive.Root;
+
+const TabsList = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.List
+    ref={ref}
+    className={cn(
+      "inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsList.displayName = TabsPrimitive.List.displayName;
+
+const TabsTrigger = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      "inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+
+const TabsContent = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Content
+    ref={ref}
+    className={cn(
+      "mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+
+export { Tabs, TabsList, TabsTrigger, TabsContent };

src/components/ui/tooltip.tsx

@@ -46,13 +46,13 @@ function TooltipContent({
         data-slot="tooltip-content"
         sideOffset={sideOffset}
         className={cn(
-          "bg-primary text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance",
+          "bg-primary text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-[50000] w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance",
           className,
         )}
         {...props}
       >
         {children}
-        <TooltipPrimitive.Arrow className="bg-primary fill-primary z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" />
+        <TooltipPrimitive.Arrow className="bg-primary fill-primary z-[50000] size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" />
       </TooltipPrimitive.Content>
     </TooltipPrimitive.Portal>
   );

src/components/window-drag-area.tsx

@@ -33,27 +33,19 @@ export function WindowDragArea() {
     void startDrag();
   };
 
-  // Only render on macOS
+  // Only render on macOS and when no dialogs are open
   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",
-      }}
+    <button
+      type="button"
+      className="fixed top-0 right-0 left-0 h-10 bg-transparent border-0 z-[9999] select-none"
       onMouseDown={handleMouseDown}
-      // Prevent context menu
       onContextMenu={(e) => {
         e.preventDefault();
+        e.stopPropagation();
       }}
     />
   );

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

@@ -1,17 +1,18 @@
 "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 { useCallback, useEffect, useState } from "react";
 import { toast } from "sonner";
+import { AppUpdateToast } from "@/components/app-update-toast";
+import { showToast } from "@/lib/toast-utils";
+import type { AppUpdateInfo, AppUpdateProgress } from "@/types";
 
 export function useAppUpdateNotifications() {
   const [updateInfo, setUpdateInfo] = useState<AppUpdateInfo | null>(null);
   const [isUpdating, setIsUpdating] = useState(false);
-  const [updateProgress, setUpdateProgress] = useState<string>("");
+  const [updateProgress, setUpdateProgress] =
+    useState<AppUpdateProgress | null>(null);
   const [isClient, setIsClient] = useState(false);
   const [dismissedVersion, setDismissedVersion] = useState<string | null>(null);
 
@@ -59,7 +60,13 @@ export function useAppUpdateNotifications() {
   const handleAppUpdate = useCallback(async (appUpdateInfo: AppUpdateInfo) => {
     try {
       setIsUpdating(true);
-      setUpdateProgress("Starting update...");
+      setUpdateProgress({
+        stage: "downloading",
+        percentage: 0,
+        speed: undefined,
+        eta: undefined,
+        message: "Starting update...",
+      });
 
       await invoke("download_and_install_app_update", {
         updateInfo: appUpdateInfo,
@@ -73,7 +80,7 @@ export function useAppUpdateNotifications() {
         duration: 6000,
       });
       setIsUpdating(false);
-      setUpdateProgress("");
+      setUpdateProgress(null);
     }
   }, []);
 
@@ -102,10 +109,21 @@ export function useAppUpdateNotifications() {
       },
     );
 
-    const unlistenProgress = listen<string>("app-update-progress", (event) => {
-      console.log("App update progress:", event.payload);
-      setUpdateProgress(event.payload);
-    });
+    const unlistenProgress = listen<AppUpdateProgress>(
+      "app-update-progress",
+      (event) => {
+        console.log("App update progress:", event.payload);
+        setUpdateProgress(event.payload);
+
+        // If update is completed, mark as no longer updating after a delay
+        if (event.payload.stage === "completed") {
+          setTimeout(() => {
+            setIsUpdating(false);
+            setUpdateProgress(null);
+          }, 5000); // Show completion message for 5 seconds instead of 2
+        }
+      },
+    );
 
     return () => {
       void unlistenUpdate.then((unlisten) => {
@@ -161,6 +179,7 @@ export function useAppUpdateNotifications() {
   return {
     updateInfo,
     isUpdating,
+    updateProgress,
     checkForAppUpdates,
     checkForAppUpdatesManual,
     dismissAppUpdate,

src/hooks/use-browser-download.ts

@@ -1,3 +1,6 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { useCallback, useEffect, useState } from "react";
 import { getBrowserDisplayName } from "@/lib/browser-utils";
 import {
   dismissToast,
@@ -5,9 +8,6 @@ import {
   showErrorToast,
   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";
 
 interface GithubRelease {
   tag_name: string;
@@ -48,51 +48,13 @@ export function useBrowserDownload() {
     [],
   );
   const [downloadedVersions, setDownloadedVersions] = useState<string[]>([]);
-  const [isDownloading, setIsDownloading] = useState(false);
+  const [downloadingBrowsers, setDownloadingBrowsers] = useState<Set<string>>(
+    new Set(),
+  );
   const [downloadProgress, setDownloadProgress] =
     useState<DownloadProgress | null>(null);
 
-  // Listen for download progress events
-  useEffect(() => {
-    const unlisten = listen<DownloadProgress>("download-progress", (event) => {
-      const progress = event.payload;
-      setDownloadProgress(progress);
-
-      const browserName = getBrowserDisplayName(progress.browser);
-
-      // 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") {
-        showDownloadToast(browserName, progress.version, "completed");
-        setDownloadProgress(null);
-      }
-    });
-
-    return () => {
-      void unlisten.then((fn) => {
-        fn();
-      });
-    };
-  }, []);
-
-  const formatTime = (seconds: number): string => {
+  const formatTime = useCallback((seconds: number): string => {
     if (seconds < 60) {
       return `${Math.round(seconds)}s`;
     }
@@ -104,15 +66,15 @@ export function useBrowserDownload() {
     const hours = Math.floor(seconds / 3600);
     const minutes = Math.floor((seconds % 3600) / 60);
     return `${hours}h ${minutes}m`;
-  };
+  }, []);
 
-  const formatBytes = (bytes: number): string => {
+  const formatBytes = useCallback((bytes: number): string => {
     if (bytes === 0) return "0 B";
     const k = 1024;
     const sizes = ["B", "KB", "MB", "GB"];
     const i = Math.floor(Math.log(bytes) / Math.log(k));
     return `${Number.parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
-  };
+  }, []);
 
   const loadVersions = useCallback(async (browserStr: string) => {
     const browserName = getBrowserDisplayName(browserStr);
@@ -221,7 +183,7 @@ export function useBrowserDownload() {
       suppressNotifications = false,
     ) => {
       const browserName = getBrowserDisplayName(browserStr);
-      setIsDownloading(true);
+      setDownloadingBrowsers((prev) => new Set(prev).add(browserStr));
 
       try {
         // Check browser compatibility before attempting download
@@ -255,7 +217,11 @@ export function useBrowserDownload() {
         }
         throw error;
       } finally {
-        setIsDownloading(false);
+        setDownloadingBrowsers((prev) => {
+          const next = new Set(prev);
+          next.delete(browserStr);
+          return next;
+        });
       }
     },
     [loadDownloadedVersions],
@@ -268,10 +234,80 @@ export function useBrowserDownload() {
     [downloadedVersions],
   );
 
+  // Check if a browser type is currently downloading
+  const isBrowserDownloading = useCallback(
+    (browserStr: string) => {
+      return downloadingBrowsers.has(browserStr);
+    },
+    [downloadingBrowsers],
+  );
+
+  // Legacy isDownloading for backwards compatibility
+  const isDownloading = downloadingBrowsers.size > 0;
+
+  // Listen for download progress events
+  useEffect(() => {
+    let unlistenFn: (() => void) | null = null;
+
+    const setupListener = async () => {
+      try {
+        unlistenFn = await listen<DownloadProgress>(
+          "download-progress",
+          (event) => {
+            const progress = event.payload;
+            setDownloadProgress(progress);
+
+            const browserName = getBrowserDisplayName(progress.browser);
+
+            // 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") {
+              showDownloadToast(browserName, progress.version, "completed");
+              setDownloadProgress(null);
+            }
+          },
+        );
+      } catch (error) {
+        console.error("Failed to setup download progress listener:", error);
+      }
+    };
+
+    setupListener();
+
+    return () => {
+      if (unlistenFn) {
+        try {
+          unlistenFn();
+        } catch (error) {
+          console.error("Failed to cleanup download progress listener:", error);
+        }
+      }
+    };
+  }, [formatTime]);
+
   return {
     availableVersions,
     downloadedVersions,
     isDownloading,
+    isBrowserDownloading,
+    downloadingBrowsers,
     downloadProgress,
     loadVersions,
     loadVersionsWithNewCount,

src/hooks/use-table-sorting.ts

@@ -1,7 +1,7 @@
-import type { TableSortingSettings } from "@/types";
 import type { SortingState } from "@tanstack/react-table";
 import { invoke } from "@tauri-apps/api/core";
 import { useCallback, useEffect, useState } from "react";
+import type { TableSortingSettings } from "@/types";
 
 export function useTableSorting() {
   const [sortingSettings, setSortingSettings] = useState<TableSortingSettings>({

src/hooks/use-update-notifications.tsx

@@ -1,7 +1,7 @@
-import { getBrowserDisplayName } from "@/lib/browser-utils";
-import { dismissToast, showToast } from "@/lib/toast-utils";
 import { invoke } from "@tauri-apps/api/core";
 import { useCallback, useRef, useState } from "react";
+import { getBrowserDisplayName } from "@/lib/browser-utils";
+import { dismissToast, showToast } from "@/lib/toast-utils";
 
 interface UpdateNotification {
   id: string;
@@ -32,64 +32,21 @@ export function useUpdateNotifications(
 
   // 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 () => {
-    // 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",
-      );
-
-      // 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;
-    }
-  }, [processedNotifications]);
+  // Track browser types being downloaded (not browser-version pairs)
+  const activeDownloads = useRef<Set<string>>(new Set()); // Track browser types
 
   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)) {
+      // Check if this browser type is already being downloaded
+      if (activeDownloads.current.has(browser)) {
         console.log(
-          `Download already in progress for ${downloadKey}, skipping duplicate`,
+          `Download already in progress for browser type ${browser}, skipping duplicate auto-update`,
         );
         return;
       }
 
-      // Mark download as active and disable browser
-      activeDownloads.current.add(downloadKey);
+      // Mark browser type as active and disable browser
+      activeDownloads.current.add(browser);
       setUpdatingBrowsers((prev) => new Set(prev).add(browser));
 
       try {
@@ -200,8 +157,8 @@ export function useUpdateNotifications(
         console.error("Failed to start auto-update:", error);
         throw error;
       } finally {
-        // Clean up
-        activeDownloads.current.delete(downloadKey);
+        // Clean up - remove browser type from active downloads
+        activeDownloads.current.delete(browser);
         setUpdatingBrowsers((prev) => {
           const next = new Set(prev);
           next.delete(browser);
@@ -212,6 +169,48 @@ export function useUpdateNotifications(
     [onProfilesUpdated],
   );
 
+  const checkForUpdates = useCallback(async () => {
+    // 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",
+      );
+
+      // 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;
+    }
+  }, [processedNotifications, handleAutoUpdate]);
+
   return {
     notifications,
     isUpdating,

src/hooks/use-version-updater.ts

@@ -1,3 +1,6 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { useCallback, useEffect, useState } from "react";
 import { getBrowserDisplayName } from "@/lib/browser-utils";
 import {
   dismissToast,
@@ -6,9 +9,6 @@ import {
   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";
 
 interface VersionUpdateProgress {
   current_browser: string;
@@ -61,167 +61,207 @@ export function useVersionUpdater() {
 
   // Listen for version update progress events
   useEffect(() => {
-    const unlisten = listen<VersionUpdateProgress>(
-      "version-update-progress",
-      (event) => {
-        const progress = event.payload;
-        setUpdateProgress(progress);
+    let unlistenFn: (() => void) | null = null;
 
-        if (progress.status === "updating") {
-          setIsUpdating(true);
+    const setupListener = async () => {
+      try {
+        unlistenFn = await listen<VersionUpdateProgress>(
+          "version-update-progress",
+          (event) => {
+            const progress = event.payload;
+            setUpdateProgress(progress);
 
-          // Show unified progress toast
-          const currentBrowserName = progress.current_browser
-            ? getBrowserDisplayName(progress.current_browser)
-            : undefined;
+            if (progress.status === "updating") {
+              setIsUpdating(true);
 
-          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");
+              // Show unified progress toast
+              const currentBrowserName = progress.current_browser
+                ? getBrowserDisplayName(progress.current_browser)
+                : undefined;
 
-          if (progress.new_versions_found > 0) {
-            showSuccessToast("Browser versions updated successfully", {
-              duration: 5000,
-              description:
-                "Auto-downloads will start shortly for available updates.",
-            });
-          } else {
-            showSuccessToast("No new browser versions found", {
-              duration: 3000,
-              description: "All browser versions are up to date",
-            });
-          }
+              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");
 
-          // Refresh status
-          void loadUpdateStatus();
-        } else if (progress.status === "error") {
-          setIsUpdating(false);
-          setUpdateProgress(null);
-          dismissToast("unified-version-update");
+              if (progress.new_versions_found > 0) {
+                showSuccessToast("Browser versions updated successfully", {
+                  duration: 5000,
+                  description:
+                    "Auto-downloads will start shortly for available updates.",
+                });
+              } else {
+                showSuccessToast("No new browser versions found", {
+                  duration: 3000,
+                  description: "All browser versions are up to date",
+                });
+              }
 
-          showErrorToast("Failed to update browser versions", {
-            duration: 6000,
-            description: "Check your internet connection and try again",
-          });
-        }
-      },
-    );
+              // Refresh status
+              void loadUpdateStatus();
+            } else if (progress.status === "error") {
+              setIsUpdating(false);
+              setUpdateProgress(null);
+              dismissToast("unified-version-update");
+
+              showErrorToast("Failed to update browser versions", {
+                duration: 6000,
+                description: "Check your internet connection and try again",
+              });
+            }
+          },
+        );
+      } catch (error) {
+        console.error(
+          "Failed to setup version update progress listener:",
+          error,
+        );
+      }
+    };
+
+    setupListener();
 
     return () => {
-      void unlisten.then((fn) => {
-        fn();
-      });
+      if (unlistenFn) {
+        try {
+          unlistenFn();
+        } catch (error) {
+          console.error(
+            "Failed to cleanup version update progress listener:",
+            error,
+          );
+        }
+      }
     };
   }, [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);
+    let unlistenFn: (() => void) | null = null;
 
-          const browserDisplayName = getBrowserDisplayName(browser);
+    const setupListener = async () => {
+      try {
+        unlistenFn = await 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);
 
-          try {
-            // Show auto-update start notification
-            showAutoUpdateToast(browserDisplayName, new_version, {
-              description: `Downloading ${browserDisplayName} ${new_version} automatically. Progress will be shown below.`,
-            });
+              const browserDisplayName = getBrowserDisplayName(browser);
 
-            // Dismiss the update notification in the backend
-            await invoke("dismiss_update_notification", {
-              notificationId: notification_id,
-            });
+              try {
+                // Show auto-update start notification
+                showAutoUpdateToast(browserDisplayName, new_version, {
+                  description: `Downloading ${browserDisplayName} ${new_version} automatically. Progress will be shown below.`,
+                });
 
-            // Check if browser already exists before downloading
-            const isDownloaded = await invoke<boolean>("check_browser_exists", {
-              browserStr: browser,
-              version: new_version,
-            });
+                // Dismiss the update notification in the backend
+                await invoke("dismiss_update_notification", {
+                  notificationId: notification_id,
+                });
 
-            if (isDownloaded) {
-              // Browser already exists, skip download and go straight to profile update
-              console.log(
-                `${browserDisplayName} ${new_version} already exists, skipping download`,
-              );
+                // Check if browser already exists before downloading
+                const isDownloaded = await invoke<boolean>(
+                  "check_browser_exists",
+                  {
+                    browserStr: browser,
+                    version: new_version,
+                  },
+                );
 
-              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,
-              });
-            }
+                if (isDownloaded) {
+                  // Browser already exists, skip download and go straight to profile update
+                  console.log(
+                    `${browserDisplayName} ${new_version} already exists, skipping download`,
+                  );
 
-            // Complete the update with auto-update of profile versions
-            const updatedProfiles = await invoke<string[]>(
-              "complete_browser_update_with_auto_update",
-              {
-                browser,
-                newVersion: new_version,
-              },
-            );
+                  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,
+                  });
+                }
 
-            // 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`;
+                // Complete the update with auto-update of profile versions
+                const updatedProfiles = await invoke<string[]>(
+                  "complete_browser_update_with_auto_update",
+                  {
+                    browser,
+                    newVersion: new_version,
+                  },
+                );
 
-              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,
-            });
-          }
-        };
+                // 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`;
 
-        // Call the async handler
-        void handleAutoUpdate();
-      },
-    );
+                  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();
+          },
+        );
+      } catch (error) {
+        console.error("Failed to setup browser auto-update listener:", error);
+      }
+    };
+
+    setupListener();
 
     return () => {
-      void unlisten.then((fn) => {
-        fn();
-      });
+      if (unlistenFn) {
+        try {
+          unlistenFn();
+        } catch (error) {
+          console.error(
+            "Failed to cleanup browser auto-update listener:",
+            error,
+          );
+        }
+      }
     };
   }, []);
 

src/lib/browser-utils.ts

@@ -3,9 +3,9 @@
  * Centralized helpers for browser name mapping, icons, etc.
  */
 
-import { ZenBrowser } from "@/components/icons/zen-browser";
-import { FaChrome, FaFirefox } from "react-icons/fa";
+import { FaChrome, FaFirefox, FaShieldAlt } from "react-icons/fa";
 import { SiBrave, SiMullvad, SiTorbrowser } from "react-icons/si";
+import { ZenBrowser } from "@/components/icons/zen-browser";
 
 /**
  * Map internal browser names to display names
@@ -19,6 +19,7 @@ export function getBrowserDisplayName(browserType: string): string {
     brave: "Brave",
     chromium: "Chromium",
     "tor-browser": "Tor Browser",
+    camoufox: "Anti-Detect",
   };
 
   return browserNames[browserType] || browserType;
@@ -42,7 +43,19 @@ export function getBrowserIcon(browserType: string) {
       return ZenBrowser;
     case "tor-browser":
       return SiTorbrowser;
+    case "camoufox":
+      return FaShieldAlt;
     default:
       return null;
   }
 }
+
+export const getCurrentOS = () => {
+  if (typeof window !== "undefined") {
+    const userAgent = window.navigator.userAgent;
+    if (userAgent.includes("Win")) return "windows";
+    if (userAgent.includes("Mac")) return "macos";
+    if (userAgent.includes("Linux")) return "linux";
+  }
+  return "unknown";
+};

src/lib/toast-utils.ts

@@ -1,6 +1,6 @@
-import { UnifiedToast } from "@/components/custom-toast";
 import React from "react";
 import { toast as sonnerToast } from "sonner";
+import { UnifiedToast } from "@/components/custom-toast";
 
 interface BaseToastProps {
   id?: string;
@@ -46,12 +46,23 @@ interface VersionUpdateToastProps extends BaseToastProps {
   };
 }
 
+interface AppUpdateToastProps extends BaseToastProps {
+  type: "app-update";
+  stage?: "downloading" | "extracting" | "installing" | "completed";
+  progress?: {
+    percentage: number;
+    speed?: string;
+    eta?: string;
+  };
+}
+
 type ToastProps =
   | SuccessToastProps
   | ErrorToastProps
   | DownloadToastProps
   | LoadingToastProps
-  | VersionUpdateToastProps;
+  | VersionUpdateToastProps
+  | AppUpdateToastProps;
 
 export function showToast(props: ToastProps & { id?: string }) {
   const toastId = props.id ?? `toast-${props.type}-${Date.now()}`;
@@ -246,3 +257,27 @@ export function showUnifiedVersionUpdateToast(
     ...options,
   });
 }
+
+export function showAppUpdateToast(
+  title: string,
+  stage: "downloading" | "extracting" | "installing" | "completed",
+  options?: {
+    id?: string;
+    description?: string;
+    progress?: {
+      percentage: number;
+      speed?: string;
+      eta?: string;
+    };
+    duration?: number;
+  },
+) {
+  return showToast({
+    type: "app-update",
+    title,
+    stage,
+    id: options?.id ?? "app-update-progress",
+    duration: stage === "downloading" ? Number.POSITIVE_INFINITY : 5000,
+    ...options,
+  });
+}

src/lib/utils.ts

@@ -4,3 +4,7 @@ import { twMerge } from "tailwind-merge";
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

src/types.ts

@@ -1,5 +1,4 @@
 export interface ProxySettings {
-  enabled: boolean;
   proxy_type: string; // "http", "https", "socks4", or "socks5"
   host: string;
   port: number;
@@ -13,14 +12,21 @@ export interface TableSortingSettings {
 }
 
 export interface BrowserProfile {
+  id: string; // UUID of the profile
   name: string;
   browser: string;
   version: string;
-  profile_path: string;
-  proxy?: ProxySettings;
+  proxy_id?: string; // Reference to stored proxy
   process_id?: number;
   last_launch?: number;
   release_type: string; // "stable" or "nightly"
+  camoufox_config?: CamoufoxConfig; // Camoufox configuration
+}
+
+export interface StoredProxy {
+  id: string;
+  name: string;
+  proxy_settings: ProxySettings;
 }
 
 export interface DetectedProfile {
@@ -43,3 +49,57 @@ export interface AppUpdateInfo {
   is_nightly: boolean;
   published_at: string;
 }
+
+export interface AppUpdateProgress {
+  stage: string; // "downloading", "extracting", "installing", "completed"
+  percentage?: number;
+  speed?: string; // MB/s
+  eta?: string; // estimated time remaining
+  message: string;
+}
+
+export interface CamoufoxConfig {
+  os?: string[];
+  block_images?: boolean;
+  block_webrtc?: boolean;
+  block_webgl?: boolean;
+  disable_coop?: boolean;
+  geoip?: string | boolean;
+  country?: string;
+  timezone?: string;
+  latitude?: number;
+  longitude?: number;
+  humanize?: boolean;
+  humanize_duration?: number;
+  headless?: boolean;
+  locale?: string[];
+  addons?: string[];
+  fonts?: string[];
+  custom_fonts_only?: boolean;
+  exclude_addons?: string[];
+  screen_min_width?: number;
+  screen_max_width?: number;
+  screen_min_height?: number;
+  screen_max_height?: number;
+  window_width?: number;
+  window_height?: number;
+  ff_version?: number;
+  main_world_eval?: boolean;
+  webgl_vendor?: string;
+  webgl_renderer?: string;
+  proxy?: string;
+  enable_cache?: boolean;
+  virtual_display?: string;
+  debug?: boolean;
+  additional_args?: string[];
+  env_vars?: Record<string, string>;
+  firefox_prefs?: Record<string, unknown>;
+}
+
+export interface CamoufoxLaunchResult {
+  id: string;
+  pid?: number;
+  executable_path: string;
+  profile_path: string;
+  url?: string;
+}