feat: dashboard provider support and session creation improvements (#1092)

Add provider icons and session creation from the dashboard UI.
Sessions can now be created with cloud providers (Browserbase,
Browserless, Browser Use, Kernel) in addition to local engines.

CLI changes:
- Track provider via .provider files alongside .engine files
- Add WaitUntil::None variant to skip lifecycle event waits for providers
- Auto-set waitUntil=none when --provider is used with navigate
- Fix Browser Use: use direct WSS connection (wss://connect.browser-use.com)
- Add connect_cdp_direct for providers with page-level CDP proxies
- Fix resolve_cdp_url to convert https:// provider URLs to wss://
- Treat empty CDP session_id as None (omit from protocol messages)
- Fix Browserbase: send explicit JSON body + Content-Type header
- Increase CDP connect timeout to 25s for remote providers
- Clean up .provider files on session close

Dashboard changes:
- Show provider or engine icon per session in sidebar
- New session dialog with unified engine/provider selector grid
- Async session creation with loading state and error display
- Kill zombie daemons on provider connection failure
- Parse CLI JSON error output for user-friendly messages
- Default new session URL to https://agent-browser.dev

cli/src/native/actions.rs

@@ -1618,8 +1618,13 @@ async fn handle_launch(cmd: &Value, state: &mut DaemonState) -> Result<Value, St
                 return launch_safari(cmd, state).await;
             }
             _ => {
-                let (ws_url, provider_session) = providers::connect_provider(provider).await?;
-                match BrowserManager::connect_cdp(&ws_url).await {
+                let conn = providers::connect_provider(provider).await?;
+                let connect_result = if conn.direct_page {
+                    BrowserManager::connect_cdp_direct(&conn.ws_url).await
+                } else {
+                    BrowserManager::connect_cdp(&conn.ws_url).await
+                };
+                match connect_result {
                     Ok(mgr) => {
                         state.reset_input_state();
                         state.browser = Some(mgr);
@@ -1627,10 +1632,11 @@ async fn handle_launch(cmd: &Value, state: &mut DaemonState) -> Result<Value, St
                         state.start_fetch_handler();
                         state.start_dialog_handler();
                         state.update_stream_client().await;
+                        write_provider_file(&state.session_id, provider);
                         return Ok(json!({ "launched": true, "provider": provider }));
                     }
                     Err(e) => {
-                        if let Some(ref ps) = provider_session {
+                        if let Some(ref ps) = conn.session {
                             providers::close_provider_session(ps).await;
                         }
                         return Err(e);
@@ -1810,6 +1816,7 @@ async fn launch_ios(cmd: &Value, state: &mut DaemonState) -> Result<Value, Strin
     state.backend_type = BackendType::WebDriver;
     state.engine = "safari".to_string();
     write_engine_file(&state.session_id, &state.engine);
+    write_provider_file(&state.session_id, "ios");
     write_extensions_file(&state.session_id);
     state.reset_input_state();
 
@@ -1857,6 +1864,7 @@ async fn launch_safari(cmd: &Value, state: &mut DaemonState) -> Result<Value, St
     state.backend_type = BackendType::WebDriver;
     state.engine = "safari".to_string();
     write_engine_file(&state.session_id, &state.engine);
+    write_provider_file(&state.session_id, "safari");
     write_extensions_file(&state.session_id);
     state.reset_input_state();
 
@@ -4555,6 +4563,18 @@ fn remove_engine_file(session_id: &str) {
     let _ = fs::remove_file(engine_file_path(session_id));
 }
 
+fn provider_file_path(session_id: &str) -> PathBuf {
+    get_socket_dir().join(format!("{}.provider", session_id))
+}
+
+fn write_provider_file(session_id: &str, provider: &str) {
+    let _ = fs::write(provider_file_path(session_id), provider);
+}
+
+fn remove_provider_file(session_id: &str) {
+    let _ = fs::remove_file(provider_file_path(session_id));
+}
+
 fn extensions_file_path(session_id: &str) -> PathBuf {
     get_socket_dir().join(format!("{}.extensions", session_id))
 }
@@ -4644,6 +4664,7 @@ async fn handle_stream_disable(state: &mut DaemonState) -> Result<Value, String>
     state.stream_client = None;
     remove_stream_file(&state.session_id)?;
     remove_engine_file(&state.session_id);
+    remove_provider_file(&state.session_id);
 
     Ok(json!({ "disabled": true }))
 }