Merge pull request #10 from zhom/dependabot/cargo/src-tauri/rust-dependencies-04ecd6b2d6

deps(rust)(deps): bump the rust-dependencies group in /src-tauri with 3 updates
deps(rust)(deps): bump the rust-dependencies group
2026-06-11 17:27:54 +02:00 · 2025-06-03 15:09:36 +04:00 · 2025-06-03 11:07:37 +00:00 · 2025-06-03 14:58:38 +04:00 · 2025-06-03 10:48:03 +00:00 · 2025-06-03 14:46:58 +04:00
41 changed files with 2870 additions and 1910 deletions
@@ -1,28 +1,70 @@
 version: 2
 updates:
-  # Enable version updates for Node.js dependencies
+  # Frontend dependencies (root package.json)
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
+      day: "monday"
+      time: "09:00"
    allow:
      - dependency-type: "all"
    groups:
-      all:
+      frontend-dependencies:
        patterns:
          - "*"
    ignore:
      - dependency-name: "eslint"
        versions: ">= 9"
+    commit-message:
+      prefix: "deps"
+      include: "scope"

-  # Enable version updates for rust
+  # Nodecar dependencies
+  - package-ecosystem: "npm"
+    directory: "/nodecar"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "09:00"
+    allow:
+      - dependency-type: "all"
+    groups:
+      nodecar-dependencies:
+        patterns:
+          - "*"
+    commit-message:
+      prefix: "deps(nodecar)"
+      include: "scope"
+
+  # Rust dependencies
  - package-ecosystem: "cargo"
    directory: "/src-tauri"
    schedule:
      interval: "weekly"
+      day: "monday"
+      time: "09:00"
    allow:
      - dependency-type: "all"
    groups:
-      all:
+      rust-dependencies:
        patterns:
          - "*"
+    commit-message:
+      prefix: "deps(rust)"
+      include: "scope"
+
+  # GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "09:00"
+    groups:
+      github-actions:
+        patterns:
+          - "*"
+    commit-message:
+      prefix: "ci"
+      include: "scope"
@@ -1,34 +0,0 @@
-# Automatically squashes and merges Dependabot dependency upgrades if tests pass
-
-name: Dependabot Auto-merge
-
-on: pull_request_target
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  dependabot:
-    runs-on: ubuntu-latest
-
-    if: ${{ github.actor == 'dependabot[bot]' }}
-    steps:
-      - name: Fetch Dependabot metadata
-        id: dependabot-metadata
-        uses: dependabot/fetch-metadata@v2
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
-
-      - name: Approve Dependabot PR
-        run: gh pr review --approve "$PR_URL"
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Auto-merge (squash) Dependabot PR
-        if: ${{ steps.dependabot-metadata.outputs.update-type != 'version-update:semver-major' }}
-        run: gh pr merge --auto --squash "$PR_URL"
-        env:
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -13,6 +13,8 @@ on:
    paths-ignore:
      - "src-tauri/**"
      - "README.md"
+      - ".github/workflows/lint-rs.yml"
+      - ".github/workflows/osv.yml"

 jobs:
  build:
@@ -49,4 +51,4 @@ jobs:
          pnpm install --frozen-lockfile

      - name: Run lint step
-        run: pnpm lint
+        run: pnpm run lint:js
@@ -12,11 +12,18 @@ on:
  pull_request:
    paths-ignore:
      - "src/**"
+      - "nodecar/**"
      - "package.json"
      - "package-lock.json"
      - "yarn.lock"
      - "pnpm-lock.yaml"
      - "README.md"
+      - ".github/workflows/lint-js.yml"
+      - ".github/workflows/osv.yml"
+      - "next.config.js"
+      - "tailwind.config.js"
+      - "tsconfig.json"
+      - "biome.json"

 jobs:
  build:
@@ -0,0 +1,79 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# A sample workflow which sets up periodic OSV-Scanner scanning for vulnerabilities,
+# in addition to a PR check which fails if new vulnerabilities are introduced.
+#
+# For more examples and options, including how to ignore specific vulnerabilities,
+# see https://google.github.io/osv-scanner/github-action/
+
+# Security vulnerability scanning for Donut Browser
+# Scans dependencies in package managers (npm/pnpm, Cargo) for known vulnerabilities
+# Runs on schedule and when dependencies change
+
+name: Security Vulnerability Scan
+
+on:
+  pull_request:
+    branches: ["main"]
+    paths:
+      - "package.json"
+      - "pnpm-lock.yaml"
+      - "package-lock.json"
+      - "src-tauri/Cargo.toml"
+      - "src-tauri/Cargo.lock"
+      - "nodecar/package.json"
+      - "nodecar/package-lock.json"
+      - ".github/workflows/osv.yml"
+  merge_group:
+    branches: ["main"]
+  schedule:
+    # Run weekly on Tuesdays at 2:20 PM UTC
+    - cron: "20 14 * * 2"
+  push:
+    branches: ["main"]
+    paths:
+      - "package.json"
+      - "pnpm-lock.yaml"
+      - "package-lock.json"
+      - "src-tauri/Cargo.toml"
+      - "src-tauri/Cargo.lock"
+      - "nodecar/package.json"
+      - "nodecar/package-lock.json"
+
+permissions:
+  # Require writing security events to upload SARIF file to security tab
+  security-events: write
+  # Read commit contents
+  contents: read
+
+jobs:
+  scan-scheduled:
+    name: Scheduled Security Scan
+    if: ${{ github.event_name == 'push' || github.event_name == 'schedule' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=package-lock.json
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/package-lock.json
+        ./
+
+  scan-pr:
+    name: PR Security Scan
+    if: ${{ github.event_name == 'pull_request' || github.event_name == 'merge_group' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=package-lock.json
+        --lockfile=pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        --lockfile=nodecar/package-lock.json
+        ./
@@ -0,0 +1,51 @@
+name: Pull Request Checks
+
+on:
+  pull_request:
+    branches: ["main"]
+  merge_group:
+    branches: ["main"]
+
+permissions:
+  # Required for OSV scanner to upload SARIF file to security tab
+  security-events: write
+  # Read commit contents
+  contents: read
+
+jobs:
+  lint-js:
+    name: Lint JavaScript/TypeScript
+    uses: ./.github/workflows/lint-js.yml
+    secrets: inherit
+
+  lint-rust:
+    name: Lint Rust
+    uses: ./.github/workflows/lint-rs.yml
+    secrets: inherit
+
+  security-scan:
+    name: Security Vulnerability Scan
+    if: ${{ github.event_name == 'pull_request' || github.event_name == 'merge_group' }}
+    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@e69cc6c86b31f1e7e23935bbe7031b50e51082de" # v2.0.2
+    with:
+      scan-args: |-
+        -r
+        --skip-git
+        --lockfile=pnpm-lock.yaml
+        --lockfile=nodecar/pnpm-lock.yaml
+        --lockfile=src-tauri/Cargo.lock
+        ./
+
+  pr-status:
+    name: PR Status Check
+    runs-on: ubuntu-latest
+    needs: [lint-js, lint-rust, security-scan]
+    if: always()
+    steps:
+      - name: Check all jobs succeeded
+        run: |
+          if [[ "${{ needs.lint-js.result }}" != "success" || "${{ needs.lint-rust.result }}" != "success" || "${{ needs.security-scan.result }}" != "success" ]]; then
+            echo "One or more checks failed"
+            exit 1
+          fi
+          echo "All checks passed!"
@@ -30,8 +30,8 @@ yarn-error.log*
 .pnpm-debug.log*

 # nodecar
-nodecar/dist
-nodecar/node_modules
+**/dist
+**/node_modules

 # local env files
 .env*.local
@@ -1,23 +1,45 @@
 {
  "cSpell.words": [
+    "applescript",
+    "autoconfig",
    "autologin",
+    "cdylib",
    "CFURL",
+    "checkin",
    "clippy",
+    "codegen",
    "donutbrowser",
+    "dtolnay",
+    "elif",
+    "gifs",
    "launchservices",
    "mountpoint",
+    "Mullvad",
    "nodecar",
    "ntlm",
+    "objc",
+    "osascript",
+    "plasmohq",
    "propertylist",
+    "reqwest",
    "rlib",
    "rustc",
    "serde",
    "shadcn",
    "signon",
+    "sonner",
    "sspi",
    "staticlib",
+    "swatinem",
    "sysinfo",
    "systempreferences",
-    "turbopack"
+    "tauri",
+    "titlebar",
+    "Torbrowser",
+    "turbopack",
+    "unlisten",
+    "wiremock",
+    "xattr",
+    "zhom"
  ]
 }
@@ -27,7 +27,7 @@

 ## Download

-> As of right now, the app is not signed by Apple. You need to have Gatekeeper disabled to run it.
+> As of right now, the app is not signed by Apple. You need to have Gatekeeper disabled to run it. The app automatically checks for updates on each launch.

 The app can be downloaded from the [releases page](https://github.com/zhom/donutbrowser/releases/latest).

@@ -54,6 +54,10 @@ Have questions or want to contribute? We'd love to hear from you!
 - **Issues**: [GitHub Issues](https://github.com/zhom/donutbrowser/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/zhom/donutbrowser/discussions)

+## Contact
+
+Have an urgent question or want to report a security vulnerability? Send an email to contact at donutbrowser dot com and we'll get back to you as fast as possible.
+
 ## License

 This project is licensed under the AGPL-3.0 License - see the [LICENSE](LICENSE) file for details.
@@ -4,7 +4,7 @@
  "rsc": true,
  "tsx": true,
  "tailwind": {
-    "config": "",
+    "config": "tailwind.config.js",
    "css": "src/styles/globals.css",
    "baseColor": "zinc",
    "cssVariables": true,
@@ -18,4 +18,4 @@
    "hooks": "@/hooks"
  },
  "iconLibrary": "lucide"
-}
+}
@@ -17,7 +17,7 @@
  },
  "keywords": [],
  "author": "",
-  "license": "ISC",
+  "license": "AGPL-3.0",
  "packageManager": "pnpm@10.6.1",
  "dependencies": {
    "@types/node": "^22.15.17",
@@ -1,21 +1,23 @@
 {
  "name": "donutbrowser",
  "private": true,
-  "version": "0.2.3",
+  "license": "AGPL-3.0",
+  "version": "0.2.5",
  "type": "module",
  "scripts": {
    "dev": "next dev --turbopack",
    "build": "next build",
    "start": "next start",
-    "lint": "biome check src/ && tsc --noEmit && next lint",
+    "lint": "pnpm lint:js && pnpm lint:rust",
+    "lint:js": "biome check src/ && tsc --noEmit && next lint",
    "lint:rust": "cd src-tauri && cargo clippy --all-targets --all-features -- -D warnings -D clippy::all && cargo fmt --all",
    "tauri": "tauri",
    "shadcn:add": "pnpm dlx shadcn@latest add",
    "prepare": "husky",
-    "format:js": "biome check src/ --fix",
    "format:rust": "cd src-tauri && cargo clippy --fix --allow-dirty --all-targets --all-features -- -D warnings -D clippy::all && cargo fmt --all",
-    "format:biome": "biome check src/ --fix",
-    "format": "pnpm format:js && pnpm format:rust"
+    "format:js": "biome check src/ --fix",
+    "format": "pnpm format:js && pnpm format:rust",
+    "cargo": "cd src-tauri && cargo"
  },
  "dependencies": {
    "@radix-ui/react-checkbox": "^1.3.2",
@@ -35,7 +37,7 @@
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "^1.1.1",
-    "next": "^15.3.2",
+    "next": "^15.3.3",
    "next-themes": "^0.4.6",
    "react": "^19.1.0",
    "react-dom": "^19.1.0",
@@ -60,7 +62,7 @@
    "eslint-config-next": "^15.3.2",
    "eslint-plugin-react-hooks": "^5.2.0",
    "husky": "^9.1.7",
-    "lint-staged": "^15.3.0",
+    "lint-staged": "^16.1.0",
    "tailwindcss": "^4.1.7",
    "tw-animate-css": "^1.3.0",
    "typescript": "~5.8.3",
@@ -1,6 +1,6 @@
 [package]
 name = "donutbrowser"
-version = "0.2.3"
+version = "0.2.5"
 description = "Browser Orchestrator"
 authors = ["zhom@github"]
 edition = "2021"
@@ -37,6 +37,8 @@ futures-util = "0.3"

 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation="0.10"
+objc2 = "0.6.1"
+objc2-app-kit = { version = "0.3.1", features = ["NSWindow"] }

 [dev-dependencies]
 tempfile = "3.13.0"
@@ -13,7 +13,7 @@
 	<key>CFBundleVersion</key>
 	<string>1</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.2.3</string>
+	<string>0.2.5</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleIconFile</key>
@@ -6,6 +6,11 @@
  "permissions": [
    "core:default",
    "core:event:default",
+    "core:window:default",
+    "core:window:allow-start-dragging",
+    "core:window:allow-close",
+    "core:window:allow-minimize",
+    "core:window:allow-toggle-maximize",
    "opener:default",
    "fs:default",
    "shell:allow-execute",
@@ -36,12 +36,16 @@ impl VersionComponent {
    let version = version.trim();

    // Handle special case for Zen Browser twilight releases
-    if version.to_lowercase().contains("twilight") {
+    if version.to_lowercase() == "twilight" {
+      // Pure twilight release without base version
      return VersionComponent {
-        major: u32::MAX,
-        minor: u32::MAX,
-        patch: u32::MAX,
-        pre_release: None,
+        major: 999, // High major version to indicate it's a rolling release
+        minor: 0,
+        patch: 0,
+        pre_release: Some(PreRelease {
+          kind: PreReleaseKind::Alpha,
+          number: Some(999), // High number to indicate it's a rolling release
+        }),
      };
    }

@@ -140,6 +144,38 @@ impl Ord for VersionComponent {
  fn cmp(&self, other: &Self) -> std::cmp::Ordering {
    use std::cmp::Ordering;

+    // Check for twilight versions
+    let self_is_twilight = self
+      .pre_release
+      .as_ref()
+      .map(|pr| pr.kind == PreReleaseKind::Alpha && pr.number == Some(999))
+      .unwrap_or(false);
+    let other_is_twilight = other
+      .pre_release
+      .as_ref()
+      .map(|pr| pr.kind == PreReleaseKind::Alpha && pr.number == Some(999))
+      .unwrap_or(false);
+
+    // If one is twilight and the other isn't, twilight always has priority
+    if self_is_twilight && !other_is_twilight {
+      return Ordering::Greater; // twilight > non-twilight
+    }
+    if !self_is_twilight && other_is_twilight {
+      return Ordering::Less; // non-twilight < twilight
+    }
+
+    // Both are twilight or both are not twilight - use normal comparison
+    match (self_is_twilight, other_is_twilight) {
+      (true, true) => {
+        // Both are twilight, compare by base version
+        return (self.major, self.minor, self.patch).cmp(&(other.major, other.minor, other.patch));
+      }
+      (false, false) => {
+        // Neither is twilight, continue with normal comparison
+      }
+      _ => unreachable!(), // Already handled above
+    }
+
    // Compare major.minor.patch first
    match (self.major, self.minor, self.patch).cmp(&(other.major, other.minor, other.patch)) {
      Ordering::Equal => {
@@ -193,6 +229,12 @@ pub fn is_alpha_version(version: &str) -> bool {
  version_comp.pre_release.is_some()
 }

+// Browser-specific alpha version detection for Zen Browser
+pub fn is_zen_alpha_version(version: &str) -> bool {
+  // For Zen Browser, only "twilight" is considered alpha/pre-release
+  version.to_lowercase() == "twilight"
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct FirefoxRelease {
  pub build_number: u32,
@@ -273,7 +315,7 @@ impl ApiClient {
    }
  }

-  fn get_cache_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
+  fn get_cache_dir() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
    let base_dirs = BaseDirs::new().ok_or("Failed to get base directories")?;
    let app_name = if cfg!(debug_assertions) {
      "DonutBrowserDev"
@@ -343,7 +385,7 @@ impl ApiClient {
    &self,
    browser: &str,
    versions: &[String],
-  ) -> Result<(), Box<dyn std::error::Error>> {
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let cache_dir = Self::get_cache_dir()?;
    let cache_file = cache_dir.join(format!("{browser}_versions.json"));

@@ -378,7 +420,7 @@ impl ApiClient {
    &self,
    browser: &str,
    releases: &[GithubRelease],
-  ) -> Result<(), Box<dyn std::error::Error>> {
+  ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let cache_dir = Self::get_cache_dir()?;
    let cache_file = cache_dir.join(format!("{browser}_github.json"));

@@ -569,13 +611,6 @@ impl ApiClient {
    Ok(releases)
  }

-  #[allow(dead_code)]
-  pub async fn fetch_mullvad_releases(
-    &self,
-  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
-    self.fetch_mullvad_releases_with_caching(false).await
-  }
-
  pub async fn fetch_mullvad_releases_with_caching(
    &self,
    no_caching: bool,
@@ -622,13 +657,6 @@ impl ApiClient {
    Ok(releases)
  }

-  #[allow(dead_code)]
-  pub async fn fetch_zen_releases(
-    &self,
-  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
-    self.fetch_zen_releases_with_caching(false).await
-  }
-
  pub async fn fetch_zen_releases_with_caching(
    &self,
    no_caching: bool,
@@ -654,7 +682,25 @@ impl ApiClient {
      .json::<Vec<GithubRelease>>()
      .await?;

-    // Sort releases using the new version sorting system (twilight releases will be at top)
+    // Check for twilight updates and mark alpha releases
+    for release in &mut releases {
+      // Use browser-specific alpha detection for Zen Browser
+      release.is_alpha = is_zen_alpha_version(&release.tag_name) || release.prerelease;
+
+      // Check for twilight update if this is a twilight release
+      if release.tag_name.to_lowercase() == "twilight" {
+        if let Ok(has_update) = self.check_twilight_update(release).await {
+          if has_update {
+            println!(
+              "Detected update for Zen twilight release: {}",
+              release.tag_name
+            );
+          }
+        }
+      }
+    }
+
+    // Sort releases using the new version sorting system
    sort_github_releases(&mut releases);

    // Cache the results (unless bypassing cache)
@@ -667,13 +713,6 @@ impl ApiClient {
    Ok(releases)
  }

-  #[allow(dead_code)]
-  pub async fn fetch_brave_releases(
-    &self,
-  ) -> Result<Vec<GithubRelease>, Box<dyn std::error::Error + Send + Sync>> {
-    self.fetch_brave_releases_with_caching(false).await
-  }
-
  pub async fn fetch_brave_releases_with_caching(
    &self,
    no_caching: bool,
@@ -935,6 +974,64 @@ impl ApiClient {
    // Check if there's a macOS DMG file in this version directory
    Ok(html.contains("tor-browser-macos-") && html.contains(".dmg"))
  }
+
+  /// Check if a Zen twilight release has been updated by comparing file size
+  pub async fn check_twilight_update(
+    &self,
+    release: &GithubRelease,
+  ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+    if release.tag_name.to_lowercase() != "twilight" {
+      return Ok(false); // Not a twilight release
+    }
+
+    // Find the macOS universal DMG asset
+    let asset = release
+      .assets
+      .iter()
+      .find(|asset| asset.name == "zen.macos-universal.dmg")
+      .ok_or("No macOS universal asset found for twilight release")?;
+
+    // Check if we have cached file size information
+    let cache_dir = Self::get_cache_dir()?;
+    let twilight_cache_file = cache_dir.join("zen_twilight_info.json");
+
+    #[derive(serde::Serialize, serde::Deserialize)]
+    struct TwilightInfo {
+      file_size: u64,
+      last_updated: u64,
+      download_url: String,
+    }
+
+    let current_info = TwilightInfo {
+      file_size: asset.size,
+      last_updated: Self::get_current_timestamp(),
+      download_url: asset.browser_download_url.clone(),
+    };
+
+    if !twilight_cache_file.exists() {
+      // No cache exists, save current info and return true (new)
+      let content = serde_json::to_string_pretty(&current_info)?;
+      fs::write(&twilight_cache_file, content)?;
+      return Ok(true);
+    }
+
+    let cached_content = fs::read_to_string(&twilight_cache_file)?;
+    let cached_info: TwilightInfo = serde_json::from_str(&cached_content)?;
+
+    // Check if file size has changed
+    if cached_info.file_size != current_info.file_size {
+      // File size changed, update cache and return true
+      let content = serde_json::to_string_pretty(&current_info)?;
+      fs::write(&twilight_cache_file, content)?;
+      println!(
+        "Zen twilight release updated: file size changed from {} to {}",
+        cached_info.file_size, current_info.file_size
+      );
+      return Ok(true);
+    }
+
+    Ok(false) // No update detected
+  }
 }

 #[cfg(test)]
@@ -989,10 +1086,14 @@ mod tests {
    assert_eq!(pre.number, Some(5));

    // Test twilight version (Zen Browser)
-    let v4 = VersionComponent::parse("1.0.0-twilight");
-    assert_eq!(v4.major, u32::MAX);
-    assert_eq!(v4.minor, u32::MAX);
-    assert_eq!(v4.patch, u32::MAX);
+    let v4 = VersionComponent::parse("twilight");
+    assert_eq!(v4.major, 999);
+    assert_eq!(v4.minor, 0);
+    assert_eq!(v4.patch, 0);
+    assert!(v4.pre_release.is_some());
+    let pre = v4.pre_release.unwrap();
+    assert_eq!(pre.kind, PreReleaseKind::Alpha);
+    assert_eq!(pre.number, Some(999));
  }

  #[test]
@@ -1022,10 +1123,15 @@ mod tests {
    let v10 = VersionComponent::parse("137.0b5");
    assert!(v10 > v9); // b5 > b4

-    // Test twilight version (should be highest)
-    let v11 = VersionComponent::parse("1.0.0-twilight");
-    let v12 = VersionComponent::parse("999.999.999");
-    assert!(v11 > v12);
+    // Test twilight version (should have highest priority)
+    let v11 = VersionComponent::parse("twilight");
+    let v12 = VersionComponent::parse("1.0.0");
+    assert!(v11 > v12); // twilight > stable due to high major version
+
+    // Test twilight vs other pre-releases
+    let v13 = VersionComponent::parse("twilight");
+    let v14 = VersionComponent::parse("1.0.0a1");
+    assert!(v13 > v14); // twilight > a1 due to high major version
  }

  #[test]
@@ -1037,14 +1143,14 @@ mod tests {
      "137.0b4".to_string(),
      "137.0b5".to_string(),
      "137.0".to_string(),
-      "1.0.0-twilight".to_string(),
+      "twilight".to_string(),
      "2.0.0a1".to_string(),
    ];

    sort_versions(&mut versions);

-    // Expected order: twilight, 137.0, 137.0b5, 137.0b4, 2.0.0a1, 1.12.6b, 1.10.0, 1.9.9b
-    assert_eq!(versions[0], "1.0.0-twilight");
+    // Expected order with twilight priority: twilight first due to high major version (999), then normal semantic versioning
+    assert_eq!(versions[0], "twilight");
    assert_eq!(versions[1], "137.0");
    assert_eq!(versions[2], "137.0b5");
    assert_eq!(versions[3], "137.0b4");
@@ -1054,6 +1160,31 @@ mod tests {
    assert_eq!(versions[7], "1.9.9b");
  }

+  #[test]
+  fn test_sort_versions_comprehensive() {
+    let mut versions = vec![
+      "1.0.0".to_string(),
+      "1.0.1".to_string(),
+      "1.1.0".to_string(),
+      "2.0.0a1".to_string(),
+      "2.0.0b1".to_string(),
+      "2.0.0rc1".to_string(),
+      "2.0.0".to_string(),
+      "10.0.0".to_string(),
+      "twilight".to_string(),
+    ];
+
+    sort_versions(&mut versions);
+
+    // Expected order with twilight priority: twilight first due to high major version (999), then normal semantic versioning
+    assert_eq!(versions[0], "twilight");
+    assert_eq!(versions[1], "10.0.0");
+    assert_eq!(versions[2], "2.0.0");
+    assert_eq!(versions[3], "2.0.0rc1");
+    assert_eq!(versions[4], "2.0.0b1");
+    assert_eq!(versions[5], "2.0.0a1");
+  }
+
  #[tokio::test]
  async fn test_firefox_api() {
    let server = setup_mock_server().await;
@@ -1167,7 +1298,8 @@ mod tests {
        "assets": [
          {
            "name": "mullvad-browser-macos-14.5a6.dmg",
-            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg"
+            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg",
+            "size": 100000000
          }
        ]
      }
@@ -1200,14 +1332,15 @@ mod tests {

    let mock_response = r#"[
      {
-        "tag_name": "1.0.0-twilight",
+        "tag_name": "twilight",
        "name": "Zen Browser Twilight",
        "prerelease": false,
        "published_at": "2024-01-15T10:00:00Z",
        "assets": [
          {
            "name": "zen.macos-universal.dmg",
-            "browser_download_url": "https://example.com/zen-twilight.dmg"
+            "browser_download_url": "https://example.com/zen-twilight.dmg",
+            "size": 120000000
          }
        ]
      }
@@ -1229,7 +1362,7 @@ mod tests {
    assert!(result.is_ok());
    let releases = result.unwrap();
    assert!(!releases.is_empty());
-    assert_eq!(releases[0].tag_name, "1.0.0-twilight");
+    assert_eq!(releases[0].tag_name, "twilight");
  }

  #[tokio::test]
@@ -1246,7 +1379,8 @@ mod tests {
        "assets": [
          {
            "name": "brave-v1.81.9-universal.dmg",
-            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg"
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
          }
        ]
      }
@@ -1472,28 +1606,15 @@ mod tests {
  }

  #[test]
-  fn test_sort_versions_comprehensive() {
-    let mut versions = vec![
-      "1.0.0".to_string(),
-      "1.0.1".to_string(),
-      "1.1.0".to_string(),
-      "2.0.0a1".to_string(),
-      "2.0.0b1".to_string(),
-      "2.0.0rc1".to_string(),
-      "2.0.0".to_string(),
-      "10.0.0".to_string(),
-      "1.0.0-twilight".to_string(),
-    ];
+  fn test_is_zen_alpha_version() {
+    // Only "twilight" should be considered alpha for Zen Browser
+    assert!(is_zen_alpha_version("twilight"));
+    assert!(is_zen_alpha_version("TWILIGHT")); // Case insensitive

-    sort_versions(&mut versions);
-
-    // Twilight should be first, then normal semantic versioning
-    assert_eq!(versions[0], "1.0.0-twilight");
-    assert_eq!(versions[1], "10.0.0");
-    assert_eq!(versions[2], "2.0.0");
-    assert_eq!(versions[3], "2.0.0rc1");
-    assert_eq!(versions[4], "2.0.0b1");
-    assert_eq!(versions[5], "2.0.0a1");
+    // Versions with "b" should NOT be considered alpha for Zen Browser
+    assert!(!is_zen_alpha_version("1.12.8b"));
+    assert!(!is_zen_alpha_version("1.0.0b1"));
+    assert!(!is_zen_alpha_version("2.0.0"));
  }

  #[tokio::test]
@@ -170,6 +170,10 @@ impl AppAutoUpdater {

  /// Determine if an update should be performed
  fn should_update(&self, current_version: &str, new_version: &str, is_nightly: bool) -> bool {
+    if current_version.starts_with("dev-") {
+      return false;
+    }
+
    println!(
      "Comparing versions: current={current_version}, new={new_version}, is_nightly={is_nightly}"
    );
@@ -608,8 +612,10 @@ mod tests {
    // Upgrade from stable to nightly
    assert!(updater.should_update("v1.0.0", "nightly-abc123", true));

-    // Upgrade from dev to nightly
-    assert!(updater.should_update("dev-0.1.0", "nightly-abc123", true));
+    // Don't upgrade dev, ever
+    assert!(!updater.should_update("dev-0.1.0", "nightly-xyz987", false));
+    assert!(!updater.should_update("dev-0.1.0", "nightly-xyz987", true));
+    assert!(!updater.should_update("dev-0.1.0", "v1.2.3", false));
  }

  #[test]
@@ -303,6 +303,8 @@ pub struct GithubRelease {
 pub struct GithubAsset {
  pub name: String,
  pub browser_download_url: String,
+  #[serde(default)]
+  pub size: u64,
 }

 #[cfg(test)]
@@ -35,6 +35,11 @@ impl BrowserVersionService {
    }
  }

+  #[cfg(test)]
+  pub fn new_with_api_client(api_client: ApiClient) -> Self {
+    Self { api_client }
+  }
+
  /// Get cached browser versions immediately (returns None if no cache exists)
  pub fn get_cached_browser_versions(&self, browser: &str) -> Option<Vec<String>> {
    self.api_client.load_cached_versions(browser)
@@ -541,6 +546,335 @@ impl BrowserVersionService {
 #[cfg(test)]
 mod tests {
  use super::*;
+  use wiremock::matchers::{header, method, path};
+  use wiremock::{Mock, MockServer, ResponseTemplate};
+
+  async fn setup_mock_server() -> MockServer {
+    MockServer::start().await
+  }
+
+  fn create_test_api_client(server: &MockServer) -> ApiClient {
+    let base_url = server.uri();
+    ApiClient::new_with_base_urls(
+      base_url.clone(), // firefox_api_base
+      base_url.clone(), // firefox_dev_api_base
+      base_url.clone(), // github_api_base
+      base_url.clone(), // chromium_api_base
+      base_url.clone(), // tor_archive_base
+      base_url.clone(), // mozilla_download_base
+    )
+  }
+
+  fn create_test_service(api_client: ApiClient) -> BrowserVersionService {
+    BrowserVersionService::new_with_api_client(api_client)
+  }
+
+  async fn setup_firefox_mocks(server: &MockServer) {
+    let mock_response = r#"{
+      "releases": {
+        "firefox-139.0": {
+          "build_number": 1,
+          "category": "major",
+          "date": "2024-01-15",
+          "description": "Firefox 139.0 Release",
+          "is_security_driven": false,
+          "product": "firefox",
+          "version": "139.0"
+        },
+        "firefox-138.0": {
+          "build_number": 1,
+          "category": "major",
+          "date": "2024-01-01",
+          "description": "Firefox 138.0 Release",
+          "is_security_driven": false,
+          "product": "firefox",
+          "version": "138.0"
+        },
+        "firefox-137.0": {
+          "build_number": 1,
+          "category": "major",
+          "date": "2023-12-15",
+          "description": "Firefox 137.0 Release",
+          "is_security_driven": false,
+          "product": "firefox",
+          "version": "137.0"
+        }
+      }
+    }"#;
+
+    Mock::given(method("GET"))
+      .and(path("/firefox.json"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_firefox_dev_mocks(server: &MockServer) {
+    let mock_response = r#"{
+      "releases": {
+        "devedition-140.0b1": {
+          "build_number": 1,
+          "category": "major",
+          "date": "2024-01-20",
+          "description": "Firefox Developer Edition 140.0b1",
+          "is_security_driven": false,
+          "product": "devedition",
+          "version": "140.0b1"
+        },
+        "devedition-139.0b5": {
+          "build_number": 1,
+          "category": "major",
+          "date": "2024-01-10",
+          "description": "Firefox Developer Edition 139.0b5",
+          "is_security_driven": false,
+          "product": "devedition",
+          "version": "139.0b5"
+        }
+      }
+    }"#;
+
+    Mock::given(method("GET"))
+      .and(path("/devedition.json"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_mullvad_mocks(server: &MockServer) {
+    let mock_response = r#"[
+      {
+        "tag_name": "14.5a6",
+        "name": "Mullvad Browser 14.5a6",
+        "prerelease": true,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "mullvad-browser-macos-14.5a6.dmg",
+            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg",
+            "size": 100000000
+          }
+        ]
+      },
+      {
+        "tag_name": "14.5a5",
+        "name": "Mullvad Browser 14.5a5",
+        "prerelease": true,
+        "published_at": "2024-01-10T10:00:00Z",
+        "assets": [
+          {
+            "name": "mullvad-browser-macos-14.5a5.dmg",
+            "browser_download_url": "https://example.com/mullvad-14.5a5.dmg",
+            "size": 99000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/mullvad/mullvad-browser/releases"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_zen_mocks(server: &MockServer) {
+    let mock_response = r#"[
+      {
+        "tag_name": "twilight",
+        "name": "Zen Browser Twilight",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "zen.macos-universal.dmg",
+            "browser_download_url": "https://example.com/zen-twilight.dmg",
+            "size": 120000000
+          }
+        ]
+      },
+      {
+        "tag_name": "1.11b",
+        "name": "Zen Browser 1.11b",
+        "prerelease": false,
+        "published_at": "2024-01-10T10:00:00Z",
+        "assets": [
+          {
+            "name": "zen.macos-universal.dmg",
+            "browser_download_url": "https://example.com/zen-1.11b.dmg",
+            "size": 115000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/zen-browser/desktop/releases"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_brave_mocks(server: &MockServer) {
+    let mock_response = r#"[
+      {
+        "tag_name": "v1.81.9",
+        "name": "Brave Release 1.81.9",
+        "prerelease": false,
+        "published_at": "2024-01-15T10:00:00Z",
+        "assets": [
+          {
+            "name": "brave-v1.81.9-universal.dmg",
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
+          }
+        ]
+      },
+      {
+        "tag_name": "v1.81.8",
+        "name": "Brave Release 1.81.8",
+        "prerelease": false,
+        "published_at": "2024-01-10T10:00:00Z",
+        "assets": [
+          {
+            "name": "brave-v1.81.8-universal.dmg",
+            "browser_download_url": "https://example.com/brave-1.81.8-universal.dmg",
+            "size": 199000000
+          }
+        ]
+      }
+    ]"#;
+
+    Mock::given(method("GET"))
+      .and(path("/repos/brave/brave-browser/releases"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_response)
+          .insert_header("content-type", "application/json"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_chromium_mocks(server: &MockServer) {
+    let arch = if cfg!(target_arch = "aarch64") {
+      "Mac_Arm"
+    } else {
+      "Mac"
+    };
+
+    Mock::given(method("GET"))
+      .and(path(format!("/{arch}/LAST_CHANGE")))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string("1465660")
+          .insert_header("content-type", "text/plain"),
+      )
+      .mount(server)
+      .await;
+  }
+
+  async fn setup_tor_mocks(server: &MockServer) {
+    let mock_html = r#"
+    <html>
+    <body>
+    <a href="../">../</a>
+    <a href="14.0.4/">14.0.4/</a>
+    <a href="14.0.3/">14.0.3/</a>
+    <a href="14.0.2/">14.0.2/</a>
+    </body>
+    </html>
+    "#;
+
+    let version_html_144 = r#"
+    <html>
+    <body>
+    <a href="tor-browser-macos-14.0.4.dmg">tor-browser-macos-14.0.4.dmg</a>
+    </body>
+    </html>
+    "#;
+
+    let version_html_143 = r#"
+    <html>
+    <body>
+    <a href="tor-browser-macos-14.0.3.dmg">tor-browser-macos-14.0.3.dmg</a>
+    </body>
+    </html>
+    "#;
+
+    let version_html_142 = r#"
+    <html>
+    <body>
+    <a href="tor-browser-macos-14.0.2.dmg">tor-browser-macos-14.0.2.dmg</a>
+    </body>
+    </html>
+    "#;
+
+    Mock::given(method("GET"))
+      .and(path("/"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(mock_html)
+          .insert_header("content-type", "text/html"),
+      )
+      .mount(server)
+      .await;
+
+    Mock::given(method("GET"))
+      .and(path("/14.0.4/"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(version_html_144)
+          .insert_header("content-type", "text/html"),
+      )
+      .mount(server)
+      .await;
+
+    Mock::given(method("GET"))
+      .and(path("/14.0.3/"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(version_html_143)
+          .insert_header("content-type", "text/html"),
+      )
+      .mount(server)
+      .await;
+
+    Mock::given(method("GET"))
+      .and(path("/14.0.2/"))
+      .and(header("user-agent", "donutbrowser"))
+      .respond_with(
+        ResponseTemplate::new(200)
+          .set_body_string(version_html_142)
+          .insert_header("content-type", "text/html"),
+      )
+      .mount(server)
+      .await;
+  }

  #[tokio::test]
  async fn test_browser_version_service_creation() {
@@ -550,7 +884,11 @@ mod tests {

  #[tokio::test]
  async fn test_fetch_firefox_versions() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    // Test with caching
    let result_cached = service.fetch_browser_versions("firefox", false).await;
@@ -561,15 +899,13 @@ mod tests {

    if let Ok(versions) = result_cached {
      assert!(!versions.is_empty(), "Should have Firefox versions");
+      assert_eq!(versions[0], "139.0", "Should have latest version first");
      println!(
        "Firefox cached test passed. Found {versions_count} versions",
        versions_count = versions.len()
      );
    }

-    // Small delay to avoid rate limiting
-    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
-
    // Test without caching
    let result_no_cache = service.fetch_browser_versions("firefox", true).await;
    assert!(
@@ -582,6 +918,7 @@ mod tests {
        !versions.is_empty(),
        "Should have Firefox versions without caching"
      );
+      assert_eq!(versions[0], "139.0", "Should have latest version first");
      println!(
        "Firefox no-cache test passed. Found {versions_count} versions",
        versions_count = versions.len()
@@ -591,7 +928,11 @@ mod tests {

  #[tokio::test]
  async fn test_fetch_browser_versions_with_count() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    let result = service
      .fetch_browser_versions_with_count("firefox", false)
@@ -605,6 +946,10 @@ mod tests {
        result.versions.len(),
        "Total count should match versions length"
      );
+      assert_eq!(
+        result.versions[0], "139.0",
+        "Should have latest version first"
+      );
      println!(
        "Firefox count test passed. Found {} versions, new: {}",
        result.total_versions_count,
@@ -615,7 +960,11 @@ mod tests {

  #[tokio::test]
  async fn test_fetch_detailed_versions() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    let result = service
      .fetch_browser_versions_detailed("firefox", false)
@@ -631,6 +980,12 @@ mod tests {
        !first_version.version.is_empty(),
        "Version should not be empty"
      );
+      assert_eq!(
+        first_version.version, "139.0",
+        "Should have latest version first"
+      );
+      assert_eq!(first_version.date, "2024-01-15", "Should have correct date");
+      assert!(!first_version.is_prerelease, "Should be stable release");
      println!(
        "Firefox detailed test passed. Found {versions_count} detailed versions",
        versions_count = versions.len()
@@ -640,7 +995,9 @@ mod tests {

  #[tokio::test]
  async fn test_unsupported_browser() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    let result = service.fetch_browser_versions("unsupported", false).await;
    assert!(
@@ -658,7 +1015,11 @@ mod tests {

  #[tokio::test]
  async fn test_incremental_update() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    // This test might fail if there are no cached versions yet, which is fine
    let result = service
@@ -678,7 +1039,20 @@ mod tests {

  #[tokio::test]
  async fn test_all_supported_browsers() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+
+    // Setup all browser mocks
+    setup_firefox_mocks(&server).await;
+    setup_firefox_dev_mocks(&server).await;
+    setup_mullvad_mocks(&server).await;
+    setup_zen_mocks(&server).await;
+    setup_brave_mocks(&server).await;
+    setup_chromium_mocks(&server).await;
+    setup_tor_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);
+
    let browsers = vec![
      "firefox",
      "firefox-developer",
@@ -690,30 +1064,30 @@ mod tests {
    ];

    for browser in browsers {
-      // Test that we can at least call the function without panicking
      let result = service.fetch_browser_versions(browser, false).await;

      match result {
        Ok(versions) => {
+          assert!(!versions.is_empty(), "Should have versions for {browser}");
          println!(
            "{browser} test passed. Found {versions_count} versions",
            versions_count = versions.len()
          );
        }
        Err(e) => {
-          // Some browsers might fail due to network issues, but shouldn't panic
-          println!("{browser} test failed (network issue): {e}");
+          panic!("{browser} test failed: {e}");
        }
      }
-
-      // Small delay between requests to avoid rate limiting
-      tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
    }
  }

  #[tokio::test]
  async fn test_no_caching_parameter() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    // Test with caching enabled (default)
    let result_cached = service.fetch_browser_versions("firefox", false).await;
@@ -722,9 +1096,6 @@ mod tests {
      "Should fetch Firefox versions with caching"
    );

-    // Small delay to avoid rate limiting
-    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
-
    // Test with caching disabled (no_caching = true)
    let result_no_cache = service.fetch_browser_versions("firefox", true).await;
    assert!(
@@ -742,6 +1113,10 @@ mod tests {
        !no_cache_versions.is_empty(),
        "No-cache versions should not be empty"
      );
+      assert_eq!(
+        cached_versions, no_cache_versions,
+        "Both should return same versions"
+      );
      println!(
        "No-caching test passed. Cached: {} versions, No-cache: {} versions",
        cached_versions.len(),
@@ -752,7 +1127,11 @@ mod tests {

  #[tokio::test]
  async fn test_detailed_versions_with_no_caching() {
-    let service = BrowserVersionService::new();
+    let server = setup_mock_server().await;
+    setup_firefox_mocks(&server).await;
+
+    let api_client = create_test_api_client(&server);
+    let service = create_test_service(api_client);

    // Test detailed versions with caching
    let result_cached = service
@@ -763,9 +1142,6 @@ mod tests {
      "Should fetch detailed Firefox versions with caching"
    );

-    // Small delay to avoid rate limiting
-    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
-
    // Test detailed versions without caching
    let result_no_cache = service
      .fetch_browser_versions_detailed("firefox", true)
@@ -799,6 +1175,17 @@ mod tests {
        "No-cache version should not be empty"
      );

+      assert_eq!(first_cached.version, "139.0", "Should have correct version");
+      assert_eq!(
+        first_no_cache.version, "139.0",
+        "Should have correct version"
+      );
+      assert_eq!(first_cached.date, "2024-01-15", "Should have correct date");
+      assert_eq!(
+        first_no_cache.date, "2024-01-15",
+        "Should have correct date"
+      );
+
      println!(
        "Detailed no-caching test passed. Cached: {} versions, No-cache: {} versions",
        cached_versions.len(),
@@ -153,8 +153,8 @@ pub async fn open_url_with_profile(

 #[tauri::command]
 pub async fn smart_open_url(
-  _app_handle: tauri::AppHandle,
-  _url: String,
+  app_handle: tauri::AppHandle,
+  url: String,
  _is_startup: Option<bool>,
 ) -> Result<String, String> {
  use crate::browser_runner::BrowserRunner;
@@ -171,10 +171,75 @@ pub async fn smart_open_url(
  }

  println!(
-    "URL opening - Total profiles: {}, showing profile selector",
+    "URL opening - Total profiles: {}, checking for running profiles",
    profiles.len()
  );

-  // Always show the profile selector so the user can choose
+  // Check for running profiles and find the first one that can handle URLs
+  for profile in &profiles {
+    // Check if this profile is running
+    let is_running = runner
+      .check_browser_status(app_handle.clone(), profile)
+      .await
+      .unwrap_or(false);
+
+    if is_running {
+      println!(
+        "Found running profile '{}', attempting to open URL",
+        profile.name
+      );
+
+      // For TOR browser: Check if any other TOR browser is running
+      if profile.browser == "tor-browser" {
+        let mut other_tor_running = false;
+        for p in &profiles {
+          if p.browser == "tor-browser"
+            && p.name != profile.name
+            && runner
+              .check_browser_status(app_handle.clone(), p)
+              .await
+              .unwrap_or(false)
+          {
+            other_tor_running = true;
+            break;
+          }
+        }
+
+        if other_tor_running {
+          continue; // Skip this one, can't have multiple TOR instances
+        }
+      }
+
+      // For Mullvad browser: skip if running (can't open URLs in running Mullvad)
+      if profile.browser == "mullvad-browser" {
+        continue;
+      }
+
+      // Try to open the URL with this running profile
+      match runner
+        .launch_or_open_url(app_handle.clone(), profile, Some(url.clone()))
+        .await
+      {
+        Ok(_) => {
+          println!(
+            "Successfully opened URL '{}' with running profile '{}'",
+            url, profile.name
+          );
+          return Ok(format!("opened_with_profile:{}", profile.name));
+        }
+        Err(e) => {
+          println!(
+            "Failed to open URL with running profile '{}': {}",
+            profile.name, e
+          );
+          // Continue to try other profiles or show selector
+        }
+      }
+    }
+  }
+
+  println!("No suitable running profiles found, showing profile selector");
+
+  // No suitable running profile found, show the profile selector
  Err("show_selector".to_string())
 }
@@ -144,6 +144,10 @@ impl Downloader {
      .resolve_download_url(browser_type.clone(), version, download_info)
      .await?;

+    // Check if this is a twilight release for special handling
+    let is_twilight =
+      browser_type == BrowserType::Zen && version.to_lowercase().contains("twilight");
+
    // Emit initial progress
    let progress = DownloadProgress {
      browser: browser_type.as_str().to_string(),
@@ -153,7 +157,11 @@ impl Downloader {
      percentage: 0.0,
      speed_bytes_per_sec: 0.0,
      eta_seconds: None,
-      stage: "downloading".to_string(),
+      stage: if is_twilight {
+        "downloading (twilight rolling release)".to_string()
+      } else {
+        "downloading".to_string()
+      },
    };

    let _ = app_handle.emit("download-progress", &progress);
@@ -205,6 +213,12 @@ impl Downloader {
          None
        };

+        let stage_description = if is_twilight {
+          "downloading (twilight rolling release)".to_string()
+        } else {
+          "downloading".to_string()
+        };
+
        let progress = DownloadProgress {
          browser: browser_type.as_str().to_string(),
          version: version.to_string(),
@@ -213,7 +227,7 @@ impl Downloader {
          percentage,
          speed_bytes_per_sec: speed,
          eta_seconds: eta,
-          stage: "downloading".to_string(),
+          stage: stage_description,
        };

        let _ = app_handle.emit("download-progress", &progress);
@@ -267,7 +281,8 @@ mod tests {
        "assets": [
          {
            "name": "brave-v1.81.9-universal.dmg",
-            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg"
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
          }
        ]
      }
@@ -314,7 +329,8 @@ mod tests {
        "assets": [
          {
            "name": "zen.macos-universal.dmg",
-            "browser_download_url": "https://example.com/zen-1.11b-universal.dmg"
+            "browser_download_url": "https://example.com/zen-1.11b-universal.dmg",
+            "size": 120000000
          }
        ]
      }
@@ -361,7 +377,8 @@ mod tests {
        "assets": [
          {
            "name": "mullvad-browser-macos-14.5a6.dmg",
-            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg"
+            "browser_download_url": "https://example.com/mullvad-14.5a6.dmg",
+            "size": 100000000
          }
        ]
      }
@@ -471,7 +488,8 @@ mod tests {
        "assets": [
          {
            "name": "brave-v1.81.8-universal.dmg",
-            "browser_download_url": "https://example.com/brave-1.81.8-universal.dmg"
+            "browser_download_url": "https://example.com/brave-1.81.8-universal.dmg",
+            "size": 200000000
          }
        ]
      }
@@ -520,7 +538,8 @@ mod tests {
        "assets": [
          {
            "name": "zen.linux-universal.tar.bz2",
-            "browser_download_url": "https://example.com/zen-1.11b-linux.tar.bz2"
+            "browser_download_url": "https://example.com/zen-1.11b-linux.tar.bz2",
+            "size": 150000000
          }
        ]
      }
@@ -663,7 +682,8 @@ mod tests {
        "assets": [
          {
            "name": "mullvad-browser-linux-14.5a6.tar.xz",
-            "browser_download_url": "https://example.com/mullvad-14.5a6.tar.xz"
+            "browser_download_url": "https://example.com/mullvad-14.5a6.tar.xz",
+            "size": 80000000
          }
        ]
      }
@@ -712,7 +732,8 @@ mod tests {
        "assets": [
          {
            "name": "brave-v1.81.9-universal.dmg",
-            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg"
+            "browser_download_url": "https://example.com/brave-1.81.9-universal.dmg",
+            "size": 200000000
          }
        ]
      }
@@ -12,6 +12,9 @@ pub struct DownloadedBrowserInfo {
  pub file_path: PathBuf,
  pub verified: bool,
  pub actual_version: Option<String>, // For browsers like Chromium where we track the actual version
+  pub file_size: Option<u64>, // For tracking file size changes (useful for rolling releases)
+  #[serde(default)] // Add default value (false) for backwards compatibility
+  pub is_rolling_release: bool, // True for Zen's twilight releases and other rolling releases
 }

 #[derive(Debug, Serialize, Deserialize, Default)]
@@ -98,6 +101,7 @@ impl DownloadedBrowsersRegistry {
  }

  pub fn mark_download_started(&mut self, browser: &str, version: &str, file_path: PathBuf) {
+    let is_rolling = Self::is_rolling_release(browser, version);
    let info = DownloadedBrowserInfo {
      browser: browser.to_string(),
      version: version.to_string(),
@@ -108,6 +112,8 @@ impl DownloadedBrowsersRegistry {
      file_path,
      verified: false,
      actual_version: None,
+      file_size: None,
+      is_rolling_release: is_rolling,
    };
    self.add_browser(info);
  }
@@ -131,6 +137,11 @@ impl DownloadedBrowsersRegistry {
    }
  }

+  fn is_rolling_release(browser: &str, version: &str) -> bool {
+    // Check if this is a rolling release like twilight
+    browser == "zen" && version.to_lowercase() == "twilight"
+  }
+
  pub fn cleanup_failed_download(
    &mut self,
    browser: &str,
@@ -186,6 +197,8 @@ mod tests {
      file_path: PathBuf::from("/test/path"),
      verified: true,
      actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
    };

    registry.add_browser(info.clone());
@@ -206,6 +219,8 @@ mod tests {
      file_path: PathBuf::from("/test/path1"),
      verified: true,
      actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
    };

    let info2 = DownloadedBrowserInfo {
@@ -215,6 +230,8 @@ mod tests {
      file_path: PathBuf::from("/test/path2"),
      verified: false, // Not verified, should not be included
      actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
    };

    let info3 = DownloadedBrowserInfo {
@@ -224,6 +241,8 @@ mod tests {
      file_path: PathBuf::from("/test/path3"),
      verified: true,
      actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
    };

    registry.add_browser(info1);
@@ -266,6 +285,8 @@ mod tests {
      file_path: PathBuf::from("/test/path"),
      verified: true,
      actual_version: None,
+      file_size: None,
+      is_rolling_release: false,
    };

    registry.add_browser(info);
@@ -275,4 +296,17 @@ mod tests {
    assert!(removed.is_some());
    assert!(!registry.is_browser_downloaded("firefox", "139.0"));
  }
+
+  #[test]
+  fn test_twilight_rolling_release() {
+    let mut registry = DownloadedBrowsersRegistry::new();
+
+    // Mark twilight download started
+    registry.mark_download_started("zen", "twilight", PathBuf::from("/test/zen-twilight"));
+
+    // Check that it's marked as rolling release
+    let zen_versions = &registry.browsers["zen"];
+    let twilight_info = &zen_versions["twilight"];
+    assert!(twilight_info.is_rolling_release);
+  }
 }
@@ -1,7 +1,7 @@
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
 use std::sync::Mutex;
 use std::time::{SystemTime, UNIX_EPOCH};
-use tauri::{Emitter, Manager};
+use tauri::{Emitter, Manager, Runtime, WebviewUrl, WebviewWindow, WebviewWindowBuilder};
 use tauri_plugin_deep_link::DeepLinkExt;

 // Store pending URLs that need to be handled when the window is ready
@@ -58,6 +58,51 @@ use app_auto_updater::{
  get_app_version_info,
 };

+// Trait to extend WebviewWindow with transparent titlebar functionality
+pub trait WindowExt {
+  #[cfg(target_os = "macos")]
+  fn set_transparent_titlebar(&self, transparent: bool) -> Result<(), String>;
+}
+
+impl<R: Runtime> WindowExt for WebviewWindow<R> {
+  #[cfg(target_os = "macos")]
+  fn set_transparent_titlebar(&self, transparent: bool) -> Result<(), String> {
+    use objc2::rc::Retained;
+    use objc2_app_kit::{NSWindow, NSWindowStyleMask, NSWindowTitleVisibility};
+
+    unsafe {
+      let ns_window: Retained<NSWindow> =
+        Retained::retain(self.ns_window().unwrap().cast()).unwrap();
+
+      if transparent {
+        // Hide the title text
+        ns_window.setTitleVisibility(NSWindowTitleVisibility(2)); // NSWindowTitleHidden
+
+        // Make titlebar transparent
+        ns_window.setTitlebarAppearsTransparent(true);
+
+        // Set full size content view
+        let current_mask = ns_window.styleMask();
+        let new_mask = NSWindowStyleMask(current_mask.0 | (1 << 15)); // NSFullSizeContentViewWindowMask
+        ns_window.setStyleMask(new_mask);
+      } else {
+        // Show the title text
+        ns_window.setTitleVisibility(NSWindowTitleVisibility(0)); // NSWindowTitleVisible
+
+        // Make titlebar opaque
+        ns_window.setTitlebarAppearsTransparent(false);
+
+        // Remove full size content view
+        let current_mask = ns_window.styleMask();
+        let new_mask = NSWindowStyleMask(current_mask.0 & !(1 << 15));
+        ns_window.setStyleMask(new_mask);
+      }
+    }
+
+    Ok(())
+  }
+}
+
 #[tauri::command]
 fn greet() -> String {
  let now = SystemTime::now();
@@ -124,6 +169,61 @@ async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bo
  Ok(false)
 }

+#[tauri::command]
+async fn set_window_background_color(
+  app_handle: tauri::AppHandle,
+  is_dark_mode: bool,
+) -> Result<(), String> {
+  #[cfg(target_os = "macos")]
+  {
+    if let Some(window) = app_handle.get_webview_window("main") {
+      use objc2::rc::Retained;
+      use objc2_app_kit::{NSColor, NSWindow};
+
+      let ns_window: Retained<NSWindow> =
+        unsafe { Retained::retain(window.ns_window().unwrap().cast()).unwrap() };
+
+      let bg_color = if is_dark_mode {
+        // Dark mode - pure black background
+        unsafe { NSColor::colorWithRed_green_blue_alpha(0.0, 0.0, 0.0, 1.0) }
+      } else {
+        // Light mode - pure white background
+        unsafe { NSColor::colorWithRed_green_blue_alpha(1.0, 1.0, 1.0, 1.0) }
+      };
+
+      // Ensure this runs on the main thread for immediate visual update
+      unsafe {
+        // Set the window background color
+        ns_window.setBackgroundColor(Some(&bg_color));
+
+        // Force immediate visual updates using multiple refresh methods
+        ns_window.invalidateShadow();
+        ns_window.display();
+
+        // Ensure the window content is redrawn
+        if let Some(content_view) = ns_window.contentView() {
+          content_view.setNeedsDisplay(true);
+          content_view.displayIfNeeded();
+        }
+
+        // Trigger a window update
+        ns_window.update();
+      }
+
+      // Also emit an event to the frontend to ensure synchronization
+      let _ = app_handle.emit("window-background-updated", is_dark_mode);
+    }
+  }
+
+  #[cfg(not(target_os = "macos"))]
+  {
+    // For non-macOS platforms, we can't change the native window background
+    let _ = (app_handle, is_dark_mode); // Suppress unused variable warnings
+  }
+
+  Ok(())
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
  tauri::Builder::default()
@@ -132,6 +232,23 @@ pub fn run() {
    .plugin(tauri_plugin_shell::init())
    .plugin(tauri_plugin_deep_link::init())
    .setup(|app| {
+      // Create the main window programmatically
+      let win_builder = WebviewWindowBuilder::new(app, "main", WebviewUrl::default())
+        .title("Donut Browser")
+        .inner_size(900.0, 600.0)
+        .resizable(false)
+        .fullscreen(false);
+
+      let window = win_builder.build().unwrap();
+
+      // Set transparent titlebar for macOS
+      #[cfg(target_os = "macos")]
+      {
+        if let Err(e) = window.set_transparent_titlebar(true) {
+          eprintln!("Failed to set transparent titlebar: {e}");
+        }
+      }
+
      // Set up deep link handler
      let handle = app.handle().clone();

@@ -264,6 +381,7 @@ pub fn run() {
      check_for_app_updates_manual,
      download_and_install_app_update,
      get_app_version_info,
+      set_window_background_color,
    ])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "Donut Browser",
-  "version": "0.2.3",
+  "version": "0.2.5",
  "identifier": "com.donutbrowser",
  "build": {
    "beforeDevCommand": "pnpm dev",
@@ -10,15 +10,7 @@
    "frontendDist": "../dist"
  },
  "app": {
-    "windows": [
-      {
-        "title": "Donut Browser",
-        "width": 900,
-        "height": 600,
-        "resizable": false,
-        "fullscreen": false
-      }
-    ],
+    "windows": [],
    "security": {
      "csp": null
    }
@@ -4,6 +4,7 @@ import "@/styles/globals.css";
 import { CustomThemeProvider } from "@/components/theme-provider";
 import { Toaster } from "@/components/ui/sonner";
 import { TooltipProvider } from "@/components/ui/tooltip";
+import { WindowDragArea } from "@/components/window-drag-area";

 const geistSans = Geist({
  variable: "--font-geist-sans",
@@ -26,6 +27,7 @@ export default function RootLayout({
        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
      >
        <CustomThemeProvider>
+          <WindowDragArea />
          <TooltipProvider>{children}</TooltipProvider>
          <Toaster />
        </CustomThemeProvider>
@@ -48,24 +48,27 @@ export default function Home() {
    useState<BrowserProfile | null>(null);
  const [currentProfileForVersionChange, setCurrentProfileForVersionChange] =
    useState<BrowserProfile | null>(null);
-  const [isClient, setIsClient] = useState(false);
+  const [hasCheckedStartupPrompt, setHasCheckedStartupPrompt] = useState(false);

-  // Auto-update functionality - only initialize on client
-  const updateNotifications = useUpdateNotifications();
-  const { checkForUpdates, isUpdating } = updateNotifications;
-
-  // App auto-update functionality
-  const appUpdateNotifications = useAppUpdateNotifications();
-  const { checkForAppUpdatesManual } = appUpdateNotifications;
-
-  // Ensure we're on the client side to prevent hydration mismatches
-  useEffect(() => {
-    setIsClient(true);
+  // Simple profiles loader without updates check (for use as callback)
+  const loadProfiles = useCallback(async () => {
+    try {
+      const profileList = await invoke<BrowserProfile[]>(
+        "list_browser_profiles",
+      );
+      setProfiles(profileList);
+    } catch (err: unknown) {
+      console.error("Failed to load profiles:", err);
+      setError(`Failed to load profiles: ${JSON.stringify(err)}`);
+    }
  }, []);

-  const loadProfiles = useCallback(async () => {
-    if (!isClient) return; // Only run on client side
+  // Auto-update functionality - pass loadProfiles to refresh profiles after updates
+  const updateNotifications = useUpdateNotifications(loadProfiles);
+  const { checkForUpdates, isUpdating } = updateNotifications;

+  // Profiles loader with update check (for initial load and manual refresh)
+  const loadProfilesWithUpdateCheck = useCallback(async () => {
    try {
      const profileList = await invoke<BrowserProfile[]>(
        "list_browser_profiles",
@@ -78,12 +81,12 @@ export default function Home() {
      console.error("Failed to load profiles:", err);
      setError(`Failed to load profiles: ${JSON.stringify(err)}`);
    }
-  }, [checkForUpdates, isClient]);
+  }, [checkForUpdates]);
+
+  useAppUpdateNotifications();

  useEffect(() => {
-    if (!isClient) return; // Only run on client side
-
-    void loadProfiles();
+    void loadProfilesWithUpdateCheck();

    // Check for startup default browser prompt
    void checkStartupPrompt();
@@ -105,10 +108,11 @@ export default function Home() {
    return () => {
      clearInterval(updateInterval);
    };
-  }, [loadProfiles, checkForUpdates, isClient]);
+  }, [loadProfilesWithUpdateCheck, checkForUpdates]);

  const checkStartupPrompt = async () => {
-    if (!isClient) return; // Only run on client side
+    // Only check once during app startup to prevent reopening after dismissing notifications
+    if (hasCheckedStartupPrompt) return;

    try {
      const shouldShow = await invoke<boolean>(
@@ -117,14 +121,14 @@ export default function Home() {
      if (shouldShow) {
        setSettingsDialogOpen(true);
      }
+      setHasCheckedStartupPrompt(true);
    } catch (error) {
      console.error("Failed to check startup prompt:", error);
+      setHasCheckedStartupPrompt(true);
    }
  };

  const checkStartupUrls = async () => {
-    if (!isClient) return; // Only run on client side
-
    try {
      const hasStartupUrl = await invoke<boolean>(
        "check_and_handle_startup_url",
@@ -138,8 +142,6 @@ export default function Home() {
  };

  const listenForUrlEvents = async () => {
-    if (!isClient) return; // Only run on client side
-
    try {
      // Listen for URL open events from the deep link handler (when app is already running)
      await listen<string>("url-open-request", (event) => {
@@ -150,10 +152,7 @@ export default function Home() {
      // Listen for show profile selector events
      await listen<string>("show-profile-selector", (event) => {
        console.log("Received show profile selector request:", event.payload);
-        setPendingUrls((prev) => [
-          ...prev,
-          { id: Date.now().toString(), url: event.payload },
-        ]);
+        setPendingUrls([{ id: Date.now().toString(), url: event.payload }]);
      });

      // Listen for show create profile dialog events
@@ -173,15 +172,13 @@ export default function Home() {
  };

  const handleUrlOpen = async (url: string) => {
-    if (!isClient) return; // Only run on client side
-
    try {
      // Use smart profile selection
      const result = await invoke<string>("smart_open_url", {
        url,
      });
      console.log("Smart URL opening succeeded:", result);
-      // URL was handled successfully
+      // URL was handled successfully, no need to show selector
    } catch (error: unknown) {
      console.log(
        "Smart URL opening failed or requires profile selection:",
@@ -189,7 +186,8 @@ export default function Home() {
      );

      // Show profile selector for manual selection
-      setPendingUrls((prev) => [...prev, { id: Date.now().toString(), url }]);
+      // Replace any existing pending URL with the new one
+      setPendingUrls([{ id: Date.now().toString(), url }]);
    }
  };

@@ -270,40 +268,33 @@ export default function Home() {

  const runningProfilesRef = useRef<Set<string>>(new Set());

-  const checkBrowserStatus = useCallback(
-    async (profile: BrowserProfile) => {
-      if (!isClient) return; // Only run on client side
+  const checkBrowserStatus = useCallback(async (profile: BrowserProfile) => {
+    try {
+      const isRunning = await invoke<boolean>("check_browser_status", {
+        profile,
+      });

-      try {
-        const isRunning = await invoke<boolean>("check_browser_status", {
-          profile,
+      const currentRunning = runningProfilesRef.current.has(profile.name);
+
+      if (isRunning !== currentRunning) {
+        setRunningProfiles((prev) => {
+          const next = new Set(prev);
+          if (isRunning) {
+            next.add(profile.name);
+          } else {
+            next.delete(profile.name);
+          }
+          runningProfilesRef.current = next;
+          return next;
        });
-
-        const currentRunning = runningProfilesRef.current.has(profile.name);
-
-        if (isRunning !== currentRunning) {
-          setRunningProfiles((prev) => {
-            const next = new Set(prev);
-            if (isRunning) {
-              next.add(profile.name);
-            } else {
-              next.delete(profile.name);
-            }
-            runningProfilesRef.current = next;
-            return next;
-          });
-        }
-      } catch (err) {
-        console.error("Failed to check browser status:", err);
      }
-    },
-    [isClient],
-  );
+    } catch (err) {
+      console.error("Failed to check browser status:", err);
+    }
+  }, []);

  const launchProfile = useCallback(
    async (profile: BrowserProfile) => {
-      if (!isClient) return; // Only run on client side
-
      setError(null);

      // Check if browser is disabled due to ongoing update
@@ -337,11 +328,11 @@ export default function Home() {
        setError(`Failed to launch browser: ${JSON.stringify(err)}`);
      }
    },
-    [loadProfiles, checkBrowserStatus, isUpdating, isClient],
+    [loadProfiles, checkBrowserStatus, isUpdating],
  );

  useEffect(() => {
-    if (profiles.length === 0 || !isClient) return;
+    if (profiles.length === 0) return;

    const interval = setInterval(() => {
      for (const profile of profiles) {
@@ -352,7 +343,7 @@ export default function Home() {
    return () => {
      clearInterval(interval);
    };
-  }, [profiles, checkBrowserStatus, isClient]);
+  }, [profiles, checkBrowserStatus]);

  useEffect(() => {
    runningProfilesRef.current = runningProfiles;
@@ -408,61 +399,14 @@ export default function Home() {
    [loadProfiles],
  );

-  // Don't render anything until we're on the client side to prevent hydration issues
-  if (!isClient) {
-    return (
-      <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 gap-8 sm:p-12 font-[family-name:var(--font-geist-sans)]">
-        <main className="flex flex-col gap-8 row-start-2 items-center w-full max-w-3xl">
-          <Card className="w-full">
-            <CardHeader>
-              <div className="flex items-center justify-between">
-                <CardTitle>Profiles</CardTitle>
-                <div className="flex items-center gap-2">
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <Button
-                        size="sm"
-                        variant="outline"
-                        disabled
-                        className="flex items-center gap-2"
-                      >
-                        <GoGear className="h-4 w-4" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>Settings</TooltipContent>
-                  </Tooltip>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <Button
-                        size="sm"
-                        disabled
-                        className="flex items-center gap-2"
-                      >
-                        <GoPlus className="h-4 w-4" />
-                      </Button>
-                    </TooltipTrigger>
-                    <TooltipContent>Create a new profile</TooltipContent>
-                  </Tooltip>
-                </div>
-              </div>
-            </CardHeader>
-            <CardContent className="p-8 text-center">
-              <div className="animate-pulse">Loading...</div>
-            </CardContent>
-          </Card>
-        </main>
-      </div>
-    );
-  }
-
  return (
-    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 gap-8 sm:p-12 font-[family-name:var(--font-geist-sans)]">
-      <main className="flex flex-col gap-8 row-start-2 items-center w-full max-w-3xl">
+    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 gap-8 sm:p-12 font-[family-name:var(--font-geist-sans)]  bg-white dark:bg-black">
+      <main className="flex flex-col row-start-2 gap-8 items-center w-full max-w-3xl">
        <Card className="w-full">
          <CardHeader>
-            <div className="flex items-center justify-between">
+            <div className="flex justify-between items-center">
              <CardTitle>Profiles</CardTitle>
-              <div className="flex items-center gap-2">
+              <div className="flex gap-2 items-center">
                <Tooltip>
                  <TooltipTrigger asChild>
                    <Button
@@ -471,9 +415,9 @@ export default function Home() {
                      onClick={() => {
                        setSettingsDialogOpen(true);
                      }}
-                      className="flex items-center gap-2"
+                      className="flex gap-2 items-center"
                    >
-                      <GoGear className="h-4 w-4" />
+                      <GoGear className="w-4 h-4" />
                    </Button>
                  </TooltipTrigger>
                  <TooltipContent>Settings</TooltipContent>
@@ -485,9 +429,9 @@ export default function Home() {
                      onClick={() => {
                        setCreateProfileDialogOpen(true);
                      }}
-                      className="flex items-center gap-2"
+                      className="flex gap-2 items-center"
                    >
-                      <GoPlus className="h-4 w-4" />
+                      <GoPlus className="w-4 h-4" />
                    </Button>
                  </TooltipTrigger>
                  <TooltipContent>Create a new profile</TooltipContent>
@@ -71,7 +71,12 @@ interface ErrorToastProps extends BaseToastProps {

 interface DownloadToastProps extends BaseToastProps {
  type: "download";
-  stage?: "downloading" | "extracting" | "verifying" | "completed";
+  stage?:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)";
  progress?: {
    percentage: number;
    speed?: string;
@@ -93,13 +98,20 @@ interface FetchingToastProps extends BaseToastProps {
  browserName?: string;
 }

+interface TwilightUpdateToastProps extends BaseToastProps {
+  type: "twilight-update";
+  browserName?: string;
+  hasUpdate?: boolean;
+}
+
 type ToastProps =
  | LoadingToastProps
  | SuccessToastProps
  | ErrorToastProps
  | DownloadToastProps
  | VersionUpdateToastProps
-  | FetchingToastProps;
+  | FetchingToastProps
+  | TwilightUpdateToastProps;

 function getToastIcon(type: ToastProps["type"], stage?: string) {
  switch (type) {
@@ -122,6 +134,10 @@ function getToastIcon(type: ToastProps["type"], stage?: string) {
      return (
        <LuRefreshCw className="h-4 w-4 text-blue-500 animate-spin flex-shrink-0" />
      );
+    case "twilight-update":
+      return (
+        <LuRefreshCw className="h-4 w-4 text-purple-500 animate-spin flex-shrink-0" />
+      );
    default:
      return (
        <div className="animate-spin rounded-full h-4 w-4 border-2 border-blue-500 border-t-transparent flex-shrink-0" />
@@ -186,6 +202,22 @@ export function UnifiedToast(props: ToastProps) {
          </div>
        )}

+        {/* Twilight update progress */}
+        {type === "twilight-update" && (
+          <div className="mt-2">
+            <p className="text-xs text-gray-600 dark:text-gray-300">
+              {"hasUpdate" in props && props.hasUpdate
+                ? "New twilight build available for download"
+                : "Checking for twilight updates..."}
+            </p>
+            {props.browserName && (
+              <p className="text-xs text-purple-600 dark:text-purple-400 mt-1">
+                {props.browserName} • Rolling Release
+              </p>
+            )}
+          </div>
+        )}
+
        {/* Description */}
        {description && (
          <p className="mt-1 text-xs text-gray-600 dark:text-gray-300 leading-tight">
@@ -206,6 +238,11 @@ export function UnifiedToast(props: ToastProps) {
                Verifying installation...
              </p>
            )}
+            {stage === "downloading (twilight rolling release)" && (
+              <p className="mt-1 text-xs text-purple-600 dark:text-purple-400">
+                Downloading rolling release build...
+              </p>
+            )}
          </>
        )}
      </div>
@@ -401,7 +401,7 @@ export function ProfilesDataTable({
                    }}
                    disabled={!isClient || isRunning || isBrowserUpdating}
                  >
-                    Rename profile
+                    Rename
                  </DropdownMenuItem>
                  <DropdownMenuItem
                    onClick={() => {
@@ -411,7 +411,7 @@ export function ProfilesDataTable({
                    className="text-red-600"
                    disabled={!isClient || isRunning || isBrowserUpdating}
                  >
-                    Delete profile
+                    Delete
                  </DropdownMenuItem>
                </DropdownMenuContent>
              </DropdownMenu>
@@ -69,16 +69,29 @@ export function ProfileSelectorDialog({

      // Auto-select first available profile for link opening
      if (profileList.length > 0) {
-        // Find the first profile that can be used for opening links
-        const availableProfile = profileList.find((profile) => {
-          return canUseProfileForLinks(profile, profileList, runningProfiles);
+        // First, try to find a running profile that can be used for opening links
+        const runningAvailableProfile = profileList.find((profile) => {
+          const isRunning = runningProfiles.has(profile.name);
+          return (
+            isRunning &&
+            canUseProfileForLinks(profile, profileList, runningProfiles)
+          );
        });

-        if (availableProfile) {
-          setSelectedProfile(availableProfile.name);
+        if (runningAvailableProfile) {
+          setSelectedProfile(runningAvailableProfile.name);
        } else {
-          // If no suitable profile found, still select the first one to show UI
-          setSelectedProfile(profileList[0].name);
+          // If no running profile is suitable, find the first profile that can be used for opening links
+          const availableProfile = profileList.find((profile) => {
+            return canUseProfileForLinks(profile, profileList, runningProfiles);
+          });
+
+          if (availableProfile) {
+            setSelectedProfile(availableProfile.name);
+          } else {
+            // If no suitable profile found, still select the first one to show UI
+            setSelectedProfile(profileList[0].name);
+          }
        }
      }
    } catch (error) {
@@ -277,7 +290,7 @@ export function ProfileSelectorDialog({
                                  !canUseForLinks ? "opacity-50" : ""
                                }`}
                              >
-                                <div className="flex items-center gap-3 p-3 rounded-lg hover:bg-accent cursor-pointer">
+                                <div className="flex items-center gap-3 py-1 px-2 rounded-lg hover:bg-accent cursor-pointer">
                                  <div className="flex items-center gap-2">
                                    {(() => {
                                      const IconComponent = getBrowserIcon(
@@ -139,7 +139,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {
          <DialogTitle>Settings</DialogTitle>
        </DialogHeader>

-        <div className="grid gap-6 py-4 overflow-y-auto flex-1 min-h-0">
+        <div className="grid overflow-y-auto flex-1 gap-6 py-4 min-h-0">
          {/* Appearance Section */}
          <div className="space-y-4">
            <Label className="text-base font-medium">Appearance</Label>
@@ -172,7 +172,7 @@ export function SettingsDialog({ isOpen, onClose }: SettingsDialogProps) {

          {/* Default Browser Section */}
          <div className="space-y-4">
-            <div className="flex items-center justify-between">
+            <div className="flex justify-between items-center">
              <Label className="text-base font-medium">Default Browser</Label>
              <Badge variant={isDefaultBrowser ? "default" : "secondary"}>
                {isDefaultBrowser ? "Active" : "Inactive"}
@@ -27,6 +27,11 @@ function getSystemTheme(): string {
 export function CustomThemeProvider({ children }: CustomThemeProviderProps) {
  const [isLoading, setIsLoading] = useState(true);
  const [defaultTheme, setDefaultTheme] = useState<string>("system");
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);

  useEffect(() => {
    const loadTheme = async () => {
@@ -65,11 +70,18 @@ export function CustomThemeProvider({ children }: CustomThemeProviderProps) {
  }, []);

  if (isLoading) {
-    // Detect system theme to show appropriate loading screen
-    const systemTheme = getSystemTheme();
-    const loadingBgColor = systemTheme === "dark" ? "bg-gray-900" : "bg-white";
-    const spinnerColor =
-      systemTheme === "dark" ? "border-white" : "border-gray-900";
+    // Use a consistent loading screen that doesn't depend on system theme during SSR
+    // This prevents hydration mismatch by ensuring server and client render the same initially
+    let loadingBgColor = "bg-white";
+    let spinnerColor = "border-gray-900";
+
+    // Only apply system theme detection after component is mounted (client-side only)
+    if (mounted) {
+      const systemTheme = getSystemTheme();
+      loadingBgColor = systemTheme === "dark" ? "bg-gray-900" : "bg-white";
+      spinnerColor =
+        systemTheme === "dark" ? "border-white" : "border-gray-900";
+    }

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

  return (
-    <div className="flex flex-col gap-3 p-4 max-w-md bg-background border border-border rounded-lg shadow-lg">
-      <div className="flex items-start justify-between gap-2">
+    <div className="flex flex-col gap-3 p-4 max-w-md rounded-lg border shadow-lg bg-background border-border">
+      <div className="flex gap-2 justify-between items-start">
        <div className="flex flex-col gap-1">
-          <div className="flex items-center gap-2">
+          <div className="flex gap-2 items-center">
            <span className="font-semibold text-foreground">
              {browserDisplayName} Update Available
            </span>
            <Badge
              variant={notification.is_stable_update ? "default" : "secondary"}
            >
-              {notification.is_stable_update ? "Stable" : "Beta"}
+              {notification.is_stable_update ? "Stable" : "Nightly"}
            </Badge>
          </div>
          <div className="text-sm text-muted-foreground">
@@ -71,20 +71,20 @@ export function UpdateNotificationComponent({
          onClick={async () => {
            await onDismiss(notification.id);
          }}
-          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>

-      <div className="flex items-center gap-2">
+      <div className="flex gap-2 items-center">
        <Button
          onClick={handleUpdateClick}
          disabled={isUpdating}
          size="sm"
-          className="flex items-center gap-2"
+          className="flex gap-2 items-center"
        >
-          <FaDownload className="h-3 w-3" />
+          <FaDownload className="w-3 h-3" />
          Update
        </Button>
        <Button
@@ -0,0 +1,60 @@
+"use client";
+
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { useEffect, useState } from "react";
+
+export function WindowDragArea() {
+  const [isMacOS, setIsMacOS] = useState(false);
+
+  useEffect(() => {
+    // Check if we're on macOS using user agent detection
+    const checkPlatform = () => {
+      const userAgent = navigator.userAgent.toLowerCase();
+      setIsMacOS(userAgent.includes("mac"));
+    };
+
+    checkPlatform();
+  }, []);
+
+  const handleMouseDown = (e: React.MouseEvent) => {
+    // Only handle left mouse button
+    if (e.button !== 0) return;
+
+    // Start dragging asynchronously
+    const startDrag = async () => {
+      try {
+        const window = getCurrentWindow();
+        await window.startDragging();
+      } catch (error) {
+        console.error("Failed to start window dragging:", error);
+      }
+    };
+
+    void startDrag();
+  };
+
+  // Only render on macOS
+  if (!isMacOS) {
+    return null;
+  }
+
+  return (
+    <div
+      className="fixed top-0 right-0 left-0 z-50 h-8 cursor-move"
+      style={{
+        // Ensure it's above all other content
+        zIndex: 9999,
+        // Make it transparent but still capture mouse events
+        backgroundColor: "transparent",
+        // Prevent text selection during drag
+        userSelect: "none",
+        WebkitUserSelect: "none",
+      }}
+      onMouseDown={handleMouseDown}
+      // Prevent context menu
+      onContextMenu={(e) => {
+        e.preventDefault();
+      }}
+    />
+  );
+}
@@ -134,7 +134,11 @@ export function useAppUpdateNotifications() {
      {
        id: "app-update",
        duration: Number.POSITIVE_INFINITY, // Persistent until user action
-        position: "top-right",
+        position: "top-left",
+        style: {
+          zIndex: 99999, // Ensure app updates appear above dialogs
+          pointerEvents: "auto", // Ensure app updates remain interactive
+        },
      },
    );
  }, [
@@ -13,35 +13,66 @@ interface UpdateNotification {
  affected_profiles: string[];
  is_stable_update: boolean;
  timestamp: number;
+  is_rolling_release: boolean;
 }

-export function useUpdateNotifications() {
+export function useUpdateNotifications(
+  onProfilesUpdated?: () => Promise<void>,
+) {
  const [notifications, setNotifications] = useState<UpdateNotification[]>([]);
  const [updatingBrowsers, setUpdatingBrowsers] = useState<Set<string>>(
    new Set(),
  );
-  const [isClient, setIsClient] = useState(false);
-
-  // Ensure we're on the client side to prevent hydration mismatches
-  useEffect(() => {
-    setIsClient(true);
-  }, []);
+  const [dismissedNotifications, setDismissedNotifications] = useState<
+    Set<string>
+  >(new Set());

  const checkForUpdates = useCallback(async () => {
-    if (!isClient) return; // Only run on client side
-
    try {
      const updates = await invoke<UpdateNotification[]>(
        "check_for_browser_updates",
      );
-      setNotifications(updates);
+
+      // Filter out dismissed notifications unless they're for a newer version
+      const filteredUpdates = updates.filter((notification) => {
+        // Check if this exact notification was dismissed
+        if (dismissedNotifications.has(notification.id)) {
+          return false;
+        }
+
+        // Check if we dismissed an older version for this browser
+        const dismissedForBrowser = Array.from(dismissedNotifications).find(
+          (dismissedId) => {
+            const parts = dismissedId.split("_");
+            if (parts.length >= 2) {
+              const browser = parts[0];
+              return browser === notification.browser;
+            }
+            return false;
+          },
+        );
+
+        if (dismissedForBrowser) {
+          // Extract the dismissed version to compare
+          const dismissedParts = dismissedForBrowser.split("_to_");
+          if (dismissedParts.length === 2) {
+            const dismissedToVersion = dismissedParts[1];
+            // Only show if this is a newer version than what was dismissed
+            return notification.new_version !== dismissedToVersion;
+          }
+        }
+
+        return true;
+      });
+
+      setNotifications(filteredUpdates);

      // Show toasts for new notifications - we'll define handleUpdate and handleDismiss separately
      // to avoid circular dependencies
    } catch (error) {
      console.error("Failed to check for updates:", error);
    }
-  }, [isClient]);
+  }, [dismissedNotifications]);

  const handleUpdate = useCallback(
    async (browser: string, newVersion: string) => {
@@ -117,6 +148,11 @@ export function useUpdateNotifications() {
              duration: 5000,
            });
          }
+
+          // Trigger profile refresh to update UI with new versions
+          if (onProfilesUpdated) {
+            void onProfilesUpdated();
+          }
        } catch (downloadError) {
          console.error("Failed to download browser:", downloadError);

@@ -158,28 +194,28 @@ export function useUpdateNotifications() {
        });
      }
    },
-    [notifications, checkForUpdates],
+    [notifications, checkForUpdates, onProfilesUpdated],
  );

  const handleDismiss = useCallback(
    async (notificationId: string) => {
-      if (!isClient) return; // Only run on client side
-
      try {
        toast.dismiss(notificationId);
        await invoke("dismiss_update_notification", { notificationId });
+
+        // Track this notification as dismissed to prevent showing it again
+        setDismissedNotifications((prev) => new Set(prev).add(notificationId));
+
        await checkForUpdates();
      } catch (error) {
        console.error("Failed to dismiss notification:", error);
      }
    },
-    [checkForUpdates, isClient],
+    [checkForUpdates],
  );

  // Separate effect to show toasts when notifications change
  useEffect(() => {
-    if (!isClient) return;
-
    for (const notification of notifications) {
      const isUpdating = updatingBrowsers.has(notification.browser);

@@ -196,12 +232,14 @@ export function useUpdateNotifications() {
          id: notification.id,
          duration: Number.POSITIVE_INFINITY, // Persistent until user action
          position: "top-right",
-          // Remove transparent styling to fix background issue
-          style: undefined,
+          style: {
+            zIndex: 99999, // Ensure notifications appear above dialogs
+            pointerEvents: "auto", // Ensure notifications remain interactive
+          },
        },
      );
    }
-  }, [notifications, updatingBrowsers, handleUpdate, handleDismiss, isClient]);
+  }, [notifications, updatingBrowsers, handleUpdate, handleDismiss]);

  return {
    notifications,
@@ -24,7 +24,12 @@ export interface ErrorToastProps extends BaseToastProps {

 export interface DownloadToastProps extends BaseToastProps {
  type: "download";
-  stage?: "downloading" | "extracting" | "verifying" | "completed";
+  stage?:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)";
  progress?: {
    percentage: number;
    speed?: string;
@@ -46,13 +51,20 @@ export interface FetchingToastProps extends BaseToastProps {
  browserName?: string;
 }

+export interface TwilightUpdateToastProps extends BaseToastProps {
+  type: "twilight-update";
+  browserName?: string;
+  hasUpdate?: boolean;
+}
+
 export type ToastProps =
  | LoadingToastProps
  | SuccessToastProps
  | ErrorToastProps
  | DownloadToastProps
  | VersionUpdateToastProps
-  | FetchingToastProps;
+  | FetchingToastProps
+  | TwilightUpdateToastProps;

 // Unified toast function
 export function showToast(props: ToastProps & { id?: string }) {
@@ -81,6 +93,9 @@ export function showToast(props: ToastProps & { id?: string }) {
      case "version-update":
        duration = 15000;
        break;
+      case "twilight-update":
+        duration = 10000;
+        break;
      case "success":
        duration = 3000;
        break;
@@ -101,6 +116,8 @@ export function showToast(props: ToastProps & { id?: string }) {
        border: "none",
        boxShadow: "none",
        padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
      },
    });
  } else if (props.type === "error") {
@@ -112,6 +129,8 @@ export function showToast(props: ToastProps & { id?: string }) {
        border: "none",
        boxShadow: "none",
        padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
      },
    });
  } else {
@@ -123,6 +142,8 @@ export function showToast(props: ToastProps & { id?: string }) {
        border: "none",
        boxShadow: "none",
        padding: 0,
+        zIndex: 99999,
+        pointerEvents: "auto",
      },
    });
  }
@@ -149,7 +170,12 @@ export function showLoadingToast(
 export function showDownloadToast(
  browserName: string,
  version: string,
-  stage: "downloading" | "extracting" | "verifying" | "completed",
+  stage:
+    | "downloading"
+    | "extracting"
+    | "verifying"
+    | "completed"
+    | "downloading (twilight rolling release)",
  progress?: { percentage: number; speed?: string; eta?: string },
  options?: { suppressCompletionToast?: boolean },
 ) {
@@ -160,7 +186,9 @@ export function showDownloadToast(
        ? `Downloading ${browserName} ${version}`
        : stage === "extracting"
          ? `Extracting ${browserName} ${version}`
-          : `Verifying ${browserName} ${version}`;
+          : stage === "downloading (twilight rolling release)"
+            ? `Downloading ${browserName} ${version}`
+            : `Verifying ${browserName} ${version}`;

  // Don't show completion toast if suppressed (for auto-update scenarios)
  if (stage === "completed" && options?.suppressCompletionToast) {
@@ -245,6 +273,25 @@ export function showErrorToast(
  });
 }

+export function showTwilightUpdateToast(
+  browserName: string,
+  options?: {
+    id?: string;
+    description?: string;
+    hasUpdate?: boolean;
+    duration?: number;
+  },
+) {
+  return showToast({
+    type: "twilight-update",
+    title: options?.hasUpdate
+      ? `${browserName} twilight update available`
+      : `Checking for ${browserName} twilight updates...`,
+    browserName,
+    ...options,
+  });
+}
+
 // Generic helper for dismissing toasts
 export function dismissToast(id: string) {
  sonnerToast.dismiss(id);
@@ -123,3 +123,23 @@
    @apply bg-background text-foreground;
  }
 }
+
+/* Ensure Sonner toasts appear above all dialogs and remain interactive */
+.toaster,
+[data-sonner-toaster] {
+  z-index: 99999 !important;
+  pointer-events: auto !important;
+}
+
+[data-sonner-toast] {
+  z-index: 99999 !important;
+  pointer-events: auto !important;
+}
+
+/* Ensure toast buttons and interactive elements work */
+[data-sonner-toast] button,
+[data-sonner-toast] [role="button"],
+[data-sonner-toast] input,
+[data-sonner-toast] select {
+  pointer-events: auto !important;
+}
@@ -0,0 +1,13 @@
+module.exports = {
+  darkMode: "class",
+  theme: {
+    extend: {
+      colors: {
+        black: "#000000",
+      },
+      backgroundColor: {
+        dark: "#000000",
+      },
+    },
+  },
+};