refactor: flush consistently

CONTRIBUTING.md

@@ -12,6 +12,16 @@ Do keep in mind before you start working on an issue / posting a PR:
 - Confirm if other contributors are working on the same issue
 - Check if the feature aligns with our roadmap and project goals
 
+## Contributor License Agreement
+
+By contributing to Donut Browser, you agree that your contributions will be licensed under the same terms as the project. You must agree to our [Contributor License Agreement](CONTRIBUTOR_LICENSE_AGREEMENT.md) before your contributions can be accepted. This agreement ensures that:
+
+- Your contributions can be used in the open source version of Donut Browser (licensed under AGPL-3.0)
+- Donut Browser can offer commercial licenses for the software, including your contributions
+- You retain all rights to use your contributions for any other purpose
+
+When you submit your first pull request, you acknowledge that you agree to the terms of the Contributor License Agreement.
+
 ## Tips & Things to Consider
 
 - PRs with tests are highly appreciated

CONTRIBUTOR_LICENSE_AGREEMENT.md

@@ -0,0 +1,15 @@
+# Donut Browser Software Grant and Contributor License Agreement ("Agreement")
+
+This agreement is based on the Apache Software Foundation Contributor License Agreement. (v r190612)
+
+Thank you for your interest in the Donut Browser project ("Donut Browser" or "the Project"). In order to clarify the intellectual property license granted with Contributions from any person or entity, Donut Browser must have a Contributor License Agreement (CLA) on file that has been agreed to by each Contributor, indicating agreement to the license terms below. This license is for your protection as a Contributor as well as the protection of Donut Browser and its users; it does not change your rights to use your own Contributions for any other purpose. This Agreement allows an individual to contribute to Donut Browser on that individual's own behalf, or an entity (the "Corporation") to submit Contributions to Donut Browser, to authorize Contributions submitted by its designated employees to Donut Browser, and to grant copyright and patent licenses thereto.
+
+You accept and agree to the following terms and conditions for Your present and future Contributions submitted to Donut Browser. Except for the license granted herein to Donut Browser and recipients of software distributed by Donut Browser, You reserve all right, title, and interest in and to Your Contributions.
+
+1. Definitions. "You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with Donut Browser. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "Contribution" shall mean any work, as well as any modifications or additions to an existing work, that is intentionally submitted by You to Donut Browser for inclusion in, or documentation of, any of the products owned or managed by Donut Browser (the "Work"). For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to Donut Browser or its representatives, including but not limited to communication on electronic mailing lists, source code control systems (such as GitHub), and issue tracking systems that are managed by, or on behalf of, Donut Browser for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution."
+2. Grant of Copyright License. Subject to the terms and conditions of this Agreement, You hereby grant to Donut Browser and to recipients of software distributed by Donut Browser a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works under any license terms, including but not limited to the GNU Affero General Public License version 3 (AGPL-3.0) and any commercial or proprietary license terms that Donut Browser may choose to offer. This grant includes the right for Donut Browser to offer the Work, including Your Contributions, under multiple licenses simultaneously (dual or multi-licensing), including both open source and commercial licenses.
+3. Grant of Patent License. Subject to the terms and conditions of this Agreement, You hereby grant to Donut Browser and to recipients of software distributed by Donut Browser a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) were submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed.
+4. You represent that You are legally entitled to grant the above license. If You are an individual, and if Your employer(s) has rights to intellectual property that you create that includes Your Contributions, you represent that You have received permission to make Contributions on behalf of that employer, or that Your employer has waived such rights for your Contributions to Donut Browser. If You are a Corporation, any individual who makes a contribution from an account associated with You will be considered authorized to Contribute on Your behalf.
+5. You represent that each of Your Contributions is Your original creation (see section 7 for submissions on behalf of others).
+6. You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
+7. Should You wish to submit work that is not Your original creation, You may submit it to Donut Browser separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]".

package.json

@@ -2,7 +2,7 @@
   "name": "donutbrowser",
   "private": true,
   "license": "AGPL-3.0",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "type": "module",
   "scripts": {
     "dev": "next dev --turbopack",

src-tauri/Cargo.lock

@@ -1293,7 +1293,7 @@ dependencies = [
 
 [[package]]
 name = "donutbrowser"
-version = "0.13.6"
+version = "0.13.7"
 dependencies = [
  "aes-gcm",
  "argon2",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "donutbrowser"
-version = "0.13.6"
+version = "0.13.7"
 description = "Simple Yet Powerful Anti-Detect Browser"
 authors = ["zhom@github"]
 edition = "2021"

src-tauri/src/lib.rs

@@ -594,7 +594,8 @@ pub fn run() {
       // Periodically broadcast browser running status to the frontend
       let app_handle_status = app.handle().clone();
       tauri::async_runtime::spawn(async move {
-        let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(500));
+        let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(5));
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
         let mut last_running_states: std::collections::HashMap<String, bool> =
           std::collections::HashMap::new();
 

src-tauri/src/profile/manager.rs

@@ -750,7 +750,7 @@ impl ProfileManager {
 
     // For non-camoufox browsers, use the existing PID-based logic
     let inner_profile = profile.clone();
-    let system = System::new_all();
+    let mut system = System::new();
     let mut is_running = false;
     let mut found_pid: Option<u32> = None;
 
@@ -792,6 +792,8 @@ impl ProfileManager {
 
     // If we didn't find the browser with the stored PID, search all processes
     if !is_running {
+      // Refresh all processes only when we need to search (expensive but necessary)
+      system.refresh_all();
       for (pid, process) in system.processes() {
         let cmd = process.cmd();
         if cmd.len() >= 2 {
@@ -874,7 +876,6 @@ impl ProfileManager {
         None => inner_profile.clone(),
       };
 
-      let previous_pid = latest_profile.process_id;
       let mut merged = latest_profile.clone();
 
       if let Some(pid) = found_pid {
@@ -890,13 +891,6 @@ impl ProfileManager {
         if let Err(e) = self.save_profile(&merged) {
           log::warn!("Warning: Failed to clear profile PID: {e}");
         }
-
-        // Stop any associated proxy immediately when the browser stops
-        if let Some(old_pid) = previous_pid {
-          let _ = crate::proxy_manager::PROXY_MANAGER
-            .stop_proxy(app_handle.clone(), old_pid)
-            .await;
-        }
       }
 
       // Emit profile update event to frontend
@@ -974,18 +968,12 @@ impl ProfileManager {
             None => profile.clone(),
           };
 
-          if let Some(old_pid) = latest.process_id {
+          if latest.process_id.is_some() {
             latest.process_id = None;
             if let Err(e) = self.save_profile(&latest) {
               log::warn!("Warning: Failed to clear Camoufox profile process info: {e}");
             }
 
-            // Stop any proxy tied to this old PID immediately
-            let _ = crate::proxy_manager::PROXY_MANAGER
-              .stop_proxy(app_handle.clone(), old_pid)
-              .await;
-
-            // Emit profile update event to frontend
             if let Err(e) = app_handle.emit("profile-updated", &latest) {
               log::warn!("Warning: Failed to emit profile update event: {e}");
             }
@@ -1010,7 +998,7 @@ impl ProfileManager {
             None => profile.clone(),
           };
 
-          if let Some(old_pid) = latest.process_id {
+          if latest.process_id.is_some() {
             latest.process_id = None;
             if let Err(e2) = self.save_profile(&latest) {
               log::warn!(
@@ -1018,11 +1006,6 @@ impl ProfileManager {
               );
             }
 
-            // Best-effort stop of proxy tied to old PID
-            let _ = crate::proxy_manager::PROXY_MANAGER
-              .stop_proxy(app_handle.clone(), old_pid)
-              .await;
-
             // Emit profile update event to frontend
             if let Err(e3) = app_handle.emit("profile-updated", &latest) {
               log::warn!("Warning: Failed to emit profile update event: {e3}");
@@ -1241,7 +1224,9 @@ mod tests {
     let temp_dir = TempDir::new().unwrap();
 
     // Mock the base directories by setting environment variables
-    std::env::set_var("HOME", temp_dir.path());
+    unsafe {
+      std::env::set_var("HOME", temp_dir.path());
+    }
 
     let profile_manager = ProfileManager::instance();
     (profile_manager, temp_dir)

src-tauri/src/proxy_manager.rs

@@ -595,11 +595,6 @@ impl ProxyManager {
     browser_pid: u32,
     profile_id: Option<&str>,
   ) -> Result<ProxySettings, String> {
-    // First, proactively cleanup any dead proxies so we don't accidentally reuse stale ones
-    let _ = self.cleanup_dead_proxies(app_handle.clone()).await;
-
-    // If we have a previous proxy tied to this profile, and the upstream settings are changing,
-    // stop it before starting a new one so the change takes effect immediately.
     if let Some(name) = profile_id {
       // Check if we have an active proxy recorded for this profile
       let maybe_existing_id = {
@@ -625,30 +620,29 @@ impl ProxyManager {
             && existing.upstream_host == desired_host
             && existing.upstream_port == desired_port;
 
-          if !is_same_upstream {
-            // Stop the previous proxy tied to this profile (best effort)
-            // We don't know the original PID mapping that created it; iterate to find its key
-            let pid_to_stop = {
-              let proxies = self.active_proxies.lock().unwrap();
-              proxies.iter().find_map(|(pid, info)| {
-                if info.id == existing_id {
-                  Some(*pid)
-                } else {
-                  None
-                }
-              })
-            };
-            if let Some(pid) = pid_to_stop {
-              let _ = self.stop_proxy(app_handle.clone(), pid).await;
+          if is_same_upstream {
+            // Settings match - can reuse existing proxy
+            // Just update the PID mapping if needed
+            let proxies = self.active_proxies.lock().unwrap();
+            if proxies.contains_key(&browser_pid) {
+              // Already mapped, reuse it
+              return Ok(ProxySettings {
+                proxy_type: "http".to_string(),
+                host: "127.0.0.1".to_string(),
+                port: existing.local_port,
+                username: None,
+                password: None,
+              });
             }
+            // Need to add this PID to the mapping - we'll do that after starting
           }
+          // Settings differ - we'll create a new proxy, but don't stop the old one
+          // It will be cleaned up by periodic cleanup if it becomes dead
         }
       }
     }
-    // Check if we already have a proxy for this browser PID. If it exists but the upstream
-    // settings don't match the newly requested ones, stop it and create a new proxy so that
-    // changes take effect immediately.
-    let mut needs_restart = false;
+    // Check if we already have a proxy for this browser PID
+    // If settings match, reuse it; otherwise create a new one (don't stop the old one)
     {
       let proxies = self.active_proxies.lock().unwrap();
       if let Some(existing) = proxies.get(&browser_pid) {
@@ -663,7 +657,7 @@ impl ProxyManager {
           && existing.upstream_port == desired_port;
 
         if is_same_upstream {
-          // Check if profile_id matches - if not, we need to restart to update tracking
+          // Check if profile_id matches
           let profile_id_matches = match (profile_id, &existing.profile_id) {
             (Some(ref new_id), Some(ref old_id)) => new_id == old_id,
             (None, None) => true,
@@ -671,7 +665,7 @@ impl ProxyManager {
           };
 
           if profile_id_matches {
-            // Reuse existing local proxy (profile_id matches)
+            // Reuse existing local proxy (settings and profile_id match)
             return Ok(ProxySettings {
               proxy_type: "http".to_string(),
               host: "127.0.0.1".to_string(),
@@ -679,28 +673,15 @@ impl ProxyManager {
               username: None,
               password: None,
             });
-          } else {
-            // Profile ID changed - need to restart proxy to update tracking
-            log::info!(
-              "Profile ID changed for proxy {}: {:?} -> {:?}, restarting proxy",
-              existing.id,
-              existing.profile_id,
-              profile_id
-            );
-            needs_restart = true;
           }
-        } else {
-          // Upstream changed; we must restart the local proxy so that traffic is routed correctly
-          needs_restart = true;
+          // Profile ID changed - we'll create a new proxy but don't stop the old one
+          // It will be cleaned up by periodic cleanup if it becomes dead
         }
+        // Upstream changed - we'll create a new proxy but don't stop the old one
+        // It will be cleaned up by periodic cleanup if it becomes dead
       }
     }
 
-    if needs_restart {
-      // Best-effort stop of the old proxy for this PID before starting a new one
-      let _ = self.stop_proxy(app_handle.clone(), browser_pid).await;
-    }
-
     // Start a new proxy using the donut-proxy binary with the correct CLI interface
     let mut proxy_cmd = app_handle
       .shell()
@@ -955,30 +936,108 @@ impl ProxyManager {
     }
   }
 
-  // Check if a process is still running
-  fn is_process_running(&self, pid: u32) -> bool {
-    use sysinfo::{Pid, System};
-    let system = System::new_all();
-    system.process(Pid::from(pid as usize)).is_some()
-  }
-
   // Clean up proxies for dead browser processes
+  // Only clean up orphaned config files where the proxy process itself is dead
   pub async fn cleanup_dead_proxies(
     &self,
     app_handle: tauri::AppHandle,
   ) -> Result<Vec<u32>, String> {
-    let dead_pids = {
-      let proxies = self.active_proxies.lock().unwrap();
-      proxies
-        .keys()
-        .filter(|&&pid| pid != 0 && !self.is_process_running(pid)) // Skip temporary PID 0
-        .copied()
-        .collect::<Vec<u32>>()
+    // Don't stop proxies for dead browser processes - let them run indefinitely
+    // The proxy processes are idle and don't consume CPU when not in use
+    // Only clean up config files where the proxy process itself is dead (see below)
+    let dead_pids: Vec<u32> = Vec::new();
+
+    // Clean up orphaned proxy configs (only where proxy process is definitely dead)
+    // IMPORTANT: Only clean up configs where the proxy process itself is dead
+    // If the proxy process is running (even if idle), leave it alone
+    // The user doesn't care if proxy processes run indefinitely as long as they're not consuming CPU
+    let orphaned_configs = {
+      use crate::proxy_storage::{is_process_running, list_proxy_configs};
+      use std::time::{SystemTime, UNIX_EPOCH};
+
+      let all_configs = list_proxy_configs();
+      let tracked_proxy_ids: std::collections::HashSet<String> = {
+        let proxies = self.active_proxies.lock().unwrap();
+        proxies.values().map(|p| p.id.clone()).collect()
+      };
+
+      // Get current time for grace period check
+      let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+      all_configs
+        .into_iter()
+        .filter(|config| {
+          // If proxy is tracked in active_proxies, it's definitely not orphaned
+          if tracked_proxy_ids.contains(&config.id) {
+            return false;
+          }
+
+          // Extract creation time from proxy ID (format: proxy_{timestamp}_{random})
+          // This gives us a grace period for newly created proxies
+          let proxy_age = config
+            .id
+            .strip_prefix("proxy_")
+            .and_then(|s| s.split('_').next())
+            .and_then(|s| s.parse::<u64>().ok())
+            .map(|created_at| now.saturating_sub(created_at))
+            .unwrap_or(0);
+
+          // Grace period: don't clean up proxies created in the last 120 seconds
+          // This prevents race conditions during startup (increased from 60 to 120 for safety)
+          if proxy_age < 120 {
+            log::debug!(
+              "Skipping cleanup of proxy {} - too new (age: {}s)",
+              config.id,
+              proxy_age
+            );
+            return false;
+          }
+
+          // ONLY clean up if we can verify the proxy process is dead
+          // If proxy process is running, leave it alone (even if idle)
+          if let Some(proxy_pid) = config.pid {
+            // Check if proxy process is actually dead
+            if !is_process_running(proxy_pid) {
+              // Proxy process is dead, clean up the config file
+              log::info!(
+                "Proxy {} process (PID {}) is dead, will clean up config",
+                config.id,
+                proxy_pid
+              );
+              return true;
+            }
+            // Proxy process is running - leave it alone
+            log::debug!(
+              "Skipping cleanup of proxy {} - process (PID {}) is still running",
+              config.id,
+              proxy_pid
+            );
+            return false;
+          }
+
+          // No PID in config - can't verify if process is dead
+          // Be conservative: don't clean up (might be starting up or PID not set yet)
+          log::debug!(
+            "Skipping cleanup of proxy {} - no PID in config (might be starting up)",
+            config.id
+          );
+          false
+        })
+        .collect::<Vec<_>>()
     };
 
-    for dead_pid in &dead_pids {
-      log::info!("Cleaning up proxy for dead browser process PID: {dead_pid}");
-      let _ = self.stop_proxy(app_handle.clone(), *dead_pid).await;
+    // Clean up orphaned config files (proxy process is dead)
+    for config in orphaned_configs {
+      log::info!(
+        "Cleaning up orphaned proxy config: {} (proxy process is dead)",
+        config.id
+      );
+      // Just delete the config file - the process is already dead
+      use crate::proxy_storage::delete_proxy_config;
+      delete_proxy_config(&config.id);
     }
 
     // Emit event for reactive UI updates

src-tauri/src/proxy_server.rs

@@ -602,11 +602,35 @@ pub async fn run_proxy_server(config: ProxyConfig) -> Result<(), Box<dyn std::er
   // Start a background task to periodically flush traffic stats to disk
   tokio::spawn(async move {
     let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(1));
+    interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+    let mut last_activity_time = std::time::Instant::now();
+    let mut last_byte_count = 0u64;
+
     loop {
       interval.tick().await;
       if let Some(tracker) = get_traffic_tracker() {
-        if let Err(e) = tracker.flush_to_disk() {
-          log::error!("Failed to flush traffic stats: {}", e);
+        let (sent, recv, requests) = tracker.get_snapshot();
+        let current_bytes = sent + recv;
+        let bytes_changed = current_bytes != last_byte_count;
+        let time_since_activity = last_activity_time.elapsed();
+        let has_traffic = current_bytes > 0 || requests > 0;
+
+        // Always flush if we have traffic, or if bytes changed, or if it's been less than 30s since activity
+        // This ensures traffic is always persisted, even during active periods
+        let should_flush =
+          has_traffic || bytes_changed || time_since_activity < std::time::Duration::from_secs(30);
+
+        if should_flush {
+          if let Err(e) = tracker.flush_to_disk() {
+            log::error!("Failed to flush traffic stats: {}", e);
+          } else {
+            // Update tracking state after successful flush
+            if has_traffic || bytes_changed {
+              last_activity_time = std::time::Instant::now();
+            }
+            // After flush, bytes are reset to 0, so update last_byte_count
+            last_byte_count = 0;
+          }
         }
       }
     }

src-tauri/src/proxy_storage.rs

@@ -133,6 +133,6 @@ pub fn generate_proxy_id() -> String {
 
 pub fn is_process_running(pid: u32) -> bool {
   use sysinfo::{Pid, System};
-  let system = System::new_all();
+  let system = System::new();
   system.process(Pid::from(pid as usize)).is_some()
 }

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Donut",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "identifier": "com.donutbrowser",
   "build": {
     "beforeDevCommand": "pnpm copy-proxy-binary && pnpm dev",