feat: update proxy ui to accept credential outside url too

src-tauri/Info.plist

@@ -6,6 +6,8 @@
 	<string>Donut Browser needs camera access to enable camera functionality in web browsers. Each website will still ask for your permission individually.</string>
 	<key>NSMicrophoneUsageDescription</key>
 	<string>Donut Browser needs microphone access to enable microphone functionality in web browsers. Each website will still ask for your permission individually.</string>
+	<key>NSLocalNetworkUsageDescription</key>
+	<string>Donut Browser has proxy functionality that requires local network access. You can deny this functionality if you don't plan on setting proxies for browser profiles.</string>
 	<key>CFBundleDisplayName</key>
 	<string>Donut Browser</string>
 	<key>CFBundleName</key>

src-tauri/assets/template.pac

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

src-tauri/src/proxy_manager.rs

@@ -47,7 +47,7 @@ impl ProxyManager {
         return Ok(ProxySettings {
           enabled: true,
           proxy_type: proxy.upstream_type.clone(),
-          host: "localhost".to_string(),
+          host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
           port: proxy.local_port,
           username: None,
           password: None,
@@ -74,11 +74,11 @@ impl ProxyManager {
       None
     };
 
-    // Start a new proxy using the nodecar binary
+    // Start a new proxy using the nodecar binary with the correct CLI interface
     let mut nodecar = app_handle
       .shell()
       .sidecar("nodecar")
-      .unwrap()
+      .map_err(|e| format!("Failed to create sidecar: {e}"))?
       .arg("proxy")
       .arg("start")
       .arg("--host")
@@ -101,11 +101,19 @@ impl ProxyManager {
       nodecar = nodecar.arg("--port").arg(port.to_string());
     }
 
-    let output = nodecar.output().await.unwrap();
+    // Execute the command and wait for it to complete
+    // The nodecar binary should start the worker and then exit
+    let output = nodecar
+      .output()
+      .await
+      .map_err(|e| format!("Failed to execute nodecar: {e}"))?;
 
     if !output.status.success() {
       let stderr = String::from_utf8_lossy(&output.stderr);
-      return Err(format!("Proxy start failed: {stderr}"));
+      let stdout = String::from_utf8_lossy(&output.stdout);
+      return Err(format!(
+        "Proxy start failed - stdout: {stdout}, stderr: {stderr}"
+      ));
     }
 
     let json_string =
@@ -148,7 +156,7 @@ impl ProxyManager {
     Ok(ProxySettings {
       enabled: true,
       proxy_type: "http".to_string(),
-      host: "localhost".to_string(),
+      host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
       port: proxy_info.local_port,
       username: None,
       password: None,
@@ -196,7 +204,7 @@ impl ProxyManager {
     proxies.get(&browser_pid).map(|proxy| ProxySettings {
       enabled: true,
       proxy_type: "http".to_string(),
-      host: "localhost".to_string(),
+      host: "127.0.0.1".to_string(), // Use 127.0.0.1 instead of localhost for better compatibility
       port: proxy.local_port,
       username: None,
       password: None,
@@ -355,7 +363,7 @@ mod tests {
     assert!(proxy_settings.is_some());
     let settings = proxy_settings.unwrap();
     assert!(settings.enabled);
-    assert_eq!(settings.host, "localhost");
+    assert_eq!(settings.host, "127.0.0.1");
     assert_eq!(settings.port, 8080);
 
     // Test non-existent browser PID
@@ -407,7 +415,7 @@ mod tests {
         let browser_pid = (1000 + i) as u32;
         let proxy_info = ProxyInfo {
           id: format!("proxy_{i}"),
-          local_url: format!("http://localhost:{}", 8000 + i),
+          local_url: format!("http://127.0.0.1:{}", 8000 + i),
           upstream_host: "127.0.0.1".to_string(),
           upstream_port: 3128,
           upstream_type: "http".to_string(),
@@ -454,21 +462,19 @@ mod tests {
     let upstream_addr = upstream_listener.local_addr()?;
 
     // Spawn upstream server
-    tokio::spawn(async move {
-      loop {
-        if let Ok((stream, _)) = upstream_listener.accept().await {
-          let io = TokioIo::new(stream);
-          tokio::task::spawn(async move {
-            let _ = http1::Builder::new()
-              .serve_connection(
-                io,
-                service_fn(|_req| async {
-                  Ok::<_, hyper::Error>(Response::new(Full::new(Bytes::from("Upstream OK"))))
-                }),
-              )
-              .await;
-          });
-        }
+    let server_handle = tokio::spawn(async move {
+      while let Ok((stream, _)) = upstream_listener.accept().await {
+        let io = TokioIo::new(stream);
+        tokio::task::spawn(async move {
+          let _ = http1::Builder::new()
+            .serve_connection(
+              io,
+              service_fn(|_req| async {
+                Ok::<_, hyper::Error>(Response::new(Full::new(Bytes::from("Upstream OK"))))
+              }),
+            )
+            .await;
+        });
       }
     });
 
@@ -487,7 +493,8 @@ mod tests {
       .arg("--type")
       .arg("http");
 
-    let output = cmd.output()?;
+    // Set a timeout for the command
+    let output = tokio::time::timeout(Duration::from_secs(10), async { cmd.output() }).await??;
 
     if output.status.success() {
       let stdout = String::from_utf8(output.stdout)?;
@@ -499,12 +506,33 @@ mod tests {
       assert!(config["localUrl"].is_string());
 
       let proxy_id = config["id"].as_str().unwrap();
+      let local_port = config["localPort"].as_u64().unwrap();
+
+      // Wait for proxy worker to start
+      println!("Waiting for proxy worker to start...");
+      tokio::time::sleep(Duration::from_secs(3)).await;
+
+      // Test that the local port is listening
+      let mut port_test = Command::new("nc");
+      port_test
+        .arg("-z")
+        .arg("127.0.0.1")
+        .arg(local_port.to_string());
+
+      let port_output = port_test.output()?;
+      if port_output.status.success() {
+        println!("Proxy is listening on port {local_port}");
+      } else {
+        println!("Warning: Proxy port {local_port} is not listening");
+      }
 
       // Test stopping the proxy
       let mut stop_cmd = Command::new(&nodecar_path);
       stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
 
-      let stop_output = stop_cmd.output()?;
+      let stop_output =
+        tokio::time::timeout(Duration::from_secs(5), async { stop_cmd.output() }).await??;
+
       assert!(stop_output.status.success());
 
       println!("Integration test passed: nodecar proxy start/stop works correctly");
@@ -514,6 +542,9 @@ mod tests {
       return Err(format!("Nodecar command failed: {stderr}").into());
     }
 
+    // Clean up server
+    server_handle.abort();
+
     Ok(())
   }
 
@@ -552,4 +583,166 @@ mod tests {
     assert_eq!(proxy_settings.username.as_ref().unwrap(), "user");
     assert_eq!(proxy_settings.password.as_ref().unwrap(), "pass");
   }
+
+  // Test the CLI detachment specifically - ensure the CLI exits properly
+  #[tokio::test]
+  async fn test_cli_exits_after_proxy_start() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test that the CLI exits quickly with a mock upstream
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("httpbin.org")
+      .arg("--proxy-port")
+      .arg("80")
+      .arg("--type")
+      .arg("http");
+
+    let start_time = std::time::Instant::now();
+    let output = tokio::time::timeout(Duration::from_secs(3), async { cmd.output() }).await;
+
+    match output {
+      Ok(Ok(cmd_output)) => {
+        let execution_time = start_time.elapsed();
+        println!("CLI completed in {execution_time:?}");
+
+        // Should complete very quickly if properly detached
+        assert!(
+          execution_time < Duration::from_secs(3),
+          "CLI took too long ({execution_time:?}), should exit immediately after starting worker"
+        );
+
+        if cmd_output.status.success() {
+          let stdout = String::from_utf8(cmd_output.stdout)?;
+          let config: serde_json::Value = serde_json::from_str(&stdout)?;
+          
+          // Clean up - try to stop the proxy
+          if let Some(proxy_id) = config["id"].as_str() {
+            let mut stop_cmd = Command::new(&nodecar_path);
+            stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+            let _ = stop_cmd.output();
+          }
+        }
+
+        println!("CLI detachment test passed - CLI exited in {execution_time:?}");
+      }
+      Ok(Err(e)) => {
+        return Err(format!("Command execution failed: {e}").into());
+      }
+      Err(_) => {
+        return Err("CLI command timed out - this indicates improper detachment".into());
+      }
+    }
+
+    Ok(())
+  }
+
+  // Test that validates proper CLI detachment behavior
+  #[tokio::test]
+  async fn test_cli_detachment_behavior() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test that the CLI command exits quickly even with a real upstream
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("httpbin.org") // Use a known good endpoint
+      .arg("--proxy-port")
+      .arg("80")
+      .arg("--type")
+      .arg("http");
+
+    let start_time = std::time::Instant::now();
+    let output = tokio::time::timeout(Duration::from_secs(5), async { cmd.output() }).await??;
+    let execution_time = start_time.elapsed();
+
+    // Command should complete very quickly if properly detached
+    assert!(
+      execution_time < Duration::from_secs(5),
+      "CLI command took {execution_time:?}, should complete in under 5 seconds for proper detachment"
+    );
+
+    println!("CLI detachment test: command completed in {execution_time:?}");
+
+    if output.status.success() {
+      let stdout = String::from_utf8(output.stdout)?;
+      let config: serde_json::Value = serde_json::from_str(&stdout)?;
+      let proxy_id = config["id"].as_str().unwrap();
+
+      // Clean up
+      let mut stop_cmd = Command::new(&nodecar_path);
+      stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+      let _ = stop_cmd.output();
+
+      println!("CLI detachment test passed");
+    } else {
+      // Even if the upstream fails, the CLI should still exit quickly
+      println!("CLI command failed but exited quickly as expected");
+    }
+
+    Ok(())
+  }
+
+  // Test that validates URL encoding for special characters in credentials
+  #[tokio::test]
+  async fn test_proxy_credentials_encoding() -> Result<(), Box<dyn std::error::Error>> {
+    let nodecar_path = ensure_nodecar_binary().await?;
+
+    // Test with credentials that include special characters
+    let mut cmd = Command::new(&nodecar_path);
+    cmd
+      .arg("proxy")
+      .arg("start")
+      .arg("--host")
+      .arg("test.example.com")
+      .arg("--proxy-port")
+      .arg("8080")
+      .arg("--type")
+      .arg("http")
+      .arg("--username")
+      .arg("user@domain.com") // Contains @ symbol
+      .arg("--password")
+      .arg("pass word!"); // Contains space and special character
+
+    let output = tokio::time::timeout(Duration::from_secs(5), async { cmd.output() }).await??;
+
+    if output.status.success() {
+      let stdout = String::from_utf8(output.stdout)?;
+      let config: serde_json::Value = serde_json::from_str(&stdout)?;
+
+      let upstream_url = config["upstreamUrl"].as_str().unwrap();
+
+      println!("Generated upstream URL: {upstream_url}");
+
+      // Verify that special characters are properly encoded
+      assert!(upstream_url.contains("user%40domain.com"));
+      // The password may be encoded as "pass%20word!" or "pass%20word%21" depending on implementation
+      assert!(upstream_url.contains("pass%20word"));
+
+      println!("URL encoding test passed - special characters handled correctly");
+
+      // Clean up
+      let proxy_id = config["id"].as_str().unwrap();
+      let mut stop_cmd = Command::new(&nodecar_path);
+      stop_cmd.arg("proxy").arg("stop").arg("--id").arg(proxy_id);
+      let _ = stop_cmd.output();
+    } else {
+      // This test might fail if the upstream doesn't exist, but we mainly care about URL construction
+      let stdout = String::from_utf8(output.stdout)?;
+      let stderr = String::from_utf8(output.stderr)?;
+      println!("Command failed (expected for non-existent upstream):");
+      println!("Stdout: {stdout}");
+      println!("Stderr: {stderr}");
+
+      // The important thing is that the command completed quickly
+      println!("URL encoding test completed - credentials should be properly encoded");
+    }
+
+    Ok(())
+  }
 }