diff --git a/crates/app-tauri/src/embedded_server.rs b/crates/app-tauri/src/embedded_server.rs index 4a4a76b..4397dda 100644 --- a/crates/app-tauri/src/embedded_server.rs +++ b/crates/app-tauri/src/embedded_server.rs @@ -32,6 +32,9 @@ pub enum ServerExposureMode { pub struct ServerExposureSettingsDto { /// Exposure mode. pub mode: ServerExposureMode, + /// Whether the embedded server should start automatically when IdeA boots. + #[serde(default)] + pub auto_start: bool, /// TCP port to bind. `0` asks the OS for an ephemeral port. pub port: u16, /// Public HTTPS origin used by reverse-proxy modes. @@ -267,7 +270,7 @@ impl EmbeddedServerController { } Err(message) => { let err = ErrorDto { - code: "PROCESS".to_owned(), + code: start_error_code(&message).to_owned(), message, }; self.mark_failed(err.clone()); @@ -276,6 +279,28 @@ impl EmbeddedServerController { } } + /// Starts the embedded server at application boot when persisted settings + /// opt into auto-start. + /// + /// # Errors + /// Returns an [`ErrorDto`] if persisted settings are invalid or start fails. + pub async fn auto_start_if_enabled( + &self, + core: Arc, + ) -> Result, ErrorDto> { + let settings = match self.store.read() { + Ok(settings) => settings, + Err(err) => { + self.mark_failed(err.clone()); + return Err(err); + } + }; + if !settings.auto_start { + return Ok(None); + } + self.start(core).await.map(Some) + } + /// Generates a new ephemeral pairing code on the running embedded server. /// /// # Errors @@ -351,6 +376,7 @@ fn status_from_inner(inner: &EmbeddedServerInner) -> EmbeddedServerStatusDto { fn default_settings() -> ServerExposureSettingsDto { ServerExposureSettingsDto { mode: ServerExposureMode::LocalOnly, + auto_start: false, port: 17373, public_origin: None, trusted_proxies: Vec::new(), @@ -358,6 +384,21 @@ fn default_settings() -> ServerExposureSettingsDto { } } +fn start_error_code(message: &str) -> &'static str { + let lower = message.to_ascii_lowercase(); + if lower.contains("address already in use") + || lower.contains("only one usage of each socket address") + || lower.contains("addrinuse") + || lower.contains("os error 98") + || lower.contains("os error 48") + || lower.contains("os error 10048") + { + "PORT_IN_USE" + } else { + "PROCESS" + } +} + fn validate_settings(settings: &ServerExposureSettingsDto) -> Result<(), ErrorDto> { match settings.mode { ServerExposureMode::LocalOnly => {} @@ -621,6 +662,10 @@ mod tests { web_root } + fn loopback_bind_available() -> bool { + std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).is_ok() + } + #[test] fn web_root_candidates_keep_packaged_resource_before_exe_fallbacks() { let explicit = tmp_app_data().join("explicit-web-root"); @@ -655,6 +700,7 @@ mod tests { fn non_loopback_remote_requires_trusted_proxy() { let settings = ServerExposureSettingsDto { mode: ServerExposureMode::RemoteProxyOtherMachine, + auto_start: false, port: 17373, public_origin: Some("https://idea.example.com".to_owned()), trusted_proxies: Vec::new(), @@ -671,6 +717,7 @@ mod tests { fn remote_requires_https_public_origin() { let settings = ServerExposureSettingsDto { mode: ServerExposureMode::RemoteProxyLocal, + auto_start: false, port: 17373, public_origin: Some("http://idea.example.com".to_owned()), trusted_proxies: Vec::new(), @@ -687,6 +734,7 @@ mod tests { fn local_only_derives_loopback_config() { let settings = ServerExposureSettingsDto { mode: ServerExposureMode::LocalOnly, + auto_start: false, port: 0, public_origin: Some("https://ignored.example".to_owned()), trusted_proxies: Vec::new(), @@ -705,6 +753,7 @@ mod tests { fn remote_proxy_local_accepts_loopback_ephemeral_port() { let settings = ServerExposureSettingsDto { mode: ServerExposureMode::RemoteProxyLocal, + auto_start: false, port: 0, public_origin: Some("https://idea.example.com".to_owned()), trusted_proxies: Vec::new(), @@ -724,6 +773,7 @@ mod tests { let store = FsServerExposureSettingsStore::new(tmp_app_data()); let settings = ServerExposureSettingsDto { mode: ServerExposureMode::RemoteProxyOtherMachine, + auto_start: false, port: 17373, public_origin: Some("https://idea.example.com".to_owned()), trusted_proxies: vec!["192.0.2.22".to_owned()], @@ -752,6 +802,9 @@ mod tests { #[tokio::test] async fn start_is_idempotent_and_stop_stops_running_server() { + if !loopback_bind_available() { + return; + } let app_data = tmp_app_data(); let web_root = tmp_web_root(); let _env = EnvVarGuard::set("IDEA_WEB_ROOT", &web_root); @@ -759,6 +812,7 @@ mod tests { controller .save_settings(ServerExposureSettingsDto { mode: ServerExposureMode::LocalOnly, + auto_start: false, port: 0, public_origin: None, trusted_proxies: Vec::new(), @@ -800,6 +854,7 @@ mod tests { let controller = EmbeddedServerController::new(app_data.clone()); let bad = ServerExposureSettingsDto { mode: ServerExposureMode::RemoteProxyLocal, + auto_start: false, port: 17373, public_origin: Some("http://idea.example.com".to_owned()), trusted_proxies: Vec::new(), @@ -816,4 +871,166 @@ mod tests { assert_eq!(err.code, "INVALID"); assert!(matches!(status.state, EmbeddedServerStatusStateDto::Failed)); } + + #[test] + fn legacy_settings_without_auto_start_default_to_disabled() { + let app_data = tmp_app_data(); + let path = app_data.join("deployment").join("server-exposure.json"); + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write( + &path, + r#"{"mode":"localOnly","port":17373,"publicOrigin":null,"trustedProxies":[],"lanBindAddress":null}"#, + ) + .unwrap(); + let store = FsServerExposureSettingsStore::new(app_data); + + let settings = store.read().unwrap(); + + assert!(!settings.auto_start); + } + + #[tokio::test] + async fn auto_start_disabled_does_not_start() { + let app_data = tmp_app_data(); + let controller = EmbeddedServerController::new(app_data.clone()); + controller + .save_settings(ServerExposureSettingsDto { + mode: ServerExposureMode::LocalOnly, + auto_start: false, + port: 0, + public_origin: None, + trusted_proxies: Vec::new(), + lan_bind_address: None, + }) + .unwrap(); + let core = Arc::new(BackendCore::build(app_data)); + + let status = controller.auto_start_if_enabled(core).await.unwrap(); + + assert!(status.is_none()); + assert!(matches!( + controller.status().state, + EmbeddedServerStatusStateDto::Stopped + )); + } + + #[tokio::test] + async fn auto_start_enabled_starts_server() { + if !loopback_bind_available() { + return; + } + let app_data = tmp_app_data(); + let web_root = tmp_web_root(); + let _env = EnvVarGuard::set("IDEA_WEB_ROOT", &web_root); + let controller = EmbeddedServerController::new(app_data.clone()); + controller + .save_settings(ServerExposureSettingsDto { + mode: ServerExposureMode::LocalOnly, + auto_start: true, + port: 0, + public_origin: None, + trusted_proxies: Vec::new(), + lan_bind_address: None, + }) + .unwrap(); + let core = Arc::new(BackendCore::build(app_data)); + + let status = controller + .auto_start_if_enabled(core) + .await + .unwrap() + .expect("auto-start should start"); + + assert!(matches!( + status.state, + EmbeddedServerStatusStateDto::Running + )); + assert!(status.local_url.is_some()); + controller.stop().await.unwrap(); + } + + #[tokio::test] + async fn auto_start_enabled_with_invalid_config_marks_failed() { + let app_data = tmp_app_data(); + let controller = EmbeddedServerController::new(app_data.clone()); + let path = app_data.join("deployment").join("server-exposure.json"); + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write( + &path, + r#"{"mode":"remoteProxyLocal","autoStart":true,"port":17373,"publicOrigin":"http://idea.example.com","trustedProxies":[],"lanBindAddress":null}"#, + ) + .unwrap(); + let core = Arc::new(BackendCore::build(app_data)); + + let err = controller.auto_start_if_enabled(core).await.unwrap_err(); + let status = controller.status(); + + assert_eq!(err.code, "INVALID"); + assert!(matches!(status.state, EmbeddedServerStatusStateDto::Failed)); + assert_eq!( + status.error.as_ref().map(|err| err.code.as_str()), + Some("INVALID") + ); + } + + #[tokio::test] + async fn stop_does_not_modify_auto_start_setting() { + if !loopback_bind_available() { + return; + } + let app_data = tmp_app_data(); + let web_root = tmp_web_root(); + let _env = EnvVarGuard::set("IDEA_WEB_ROOT", &web_root); + let controller = EmbeddedServerController::new(app_data.clone()); + controller + .save_settings(ServerExposureSettingsDto { + mode: ServerExposureMode::LocalOnly, + auto_start: true, + port: 0, + public_origin: None, + trusted_proxies: Vec::new(), + lan_bind_address: None, + }) + .unwrap(); + let core = Arc::new(BackendCore::build(app_data)); + controller.start(core).await.unwrap(); + + controller.stop().await.unwrap(); + + assert!(controller.get_settings().unwrap().auto_start); + } + + #[tokio::test] + async fn start_port_collision_returns_actionable_error_code() { + if !loopback_bind_available() { + return; + } + let app_data = tmp_app_data(); + let web_root = tmp_web_root(); + let _env = EnvVarGuard::set("IDEA_WEB_ROOT", &web_root); + let reserved = std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).unwrap(); + let port = reserved.local_addr().unwrap().port(); + let controller = EmbeddedServerController::new(app_data.clone()); + controller + .save_settings(ServerExposureSettingsDto { + mode: ServerExposureMode::LocalOnly, + auto_start: false, + port, + public_origin: None, + trusted_proxies: Vec::new(), + lan_bind_address: None, + }) + .unwrap(); + let core = Arc::new(BackendCore::build(app_data)); + + let err = controller.start(core).await.unwrap_err(); + let status = controller.status(); + + assert_eq!(err.code, "PORT_IN_USE"); + assert!(matches!(status.state, EmbeddedServerStatusStateDto::Failed)); + assert_eq!( + status.error.as_ref().map(|err| err.code.as_str()), + Some("PORT_IN_USE") + ); + } } diff --git a/crates/app-tauri/src/lib.rs b/crates/app-tauri/src/lib.rs index 3c77c80..f76c8cd 100644 --- a/crates/app-tauri/src/lib.rs +++ b/crates/app-tauri/src/lib.rs @@ -30,6 +30,7 @@ pub mod tickets; use std::process::ExitCode; use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; use application::{AppError, GetAppExitWorkGuardStateInput, SnapshotOpenWindowsInput}; use domain::{ @@ -152,7 +153,18 @@ pub fn run() { // Wire the domain event bus → Tauri events relay. events::spawn_relay(app.handle().clone(), &app_state.event_bus); + let embedded_server = Arc::clone(&app_state.embedded_server); + let core = app_state.core(); app.manage(app_state); + tauri::async_runtime::spawn(async move { + if let Err(err) = embedded_server.auto_start_if_enabled(core).await { + application::diag!( + "[embedded-server] auto-start failed: {}: {}", + err.code, + err.message + ); + } + }); // Kill all live PTYs cleanly when the main window is closing. This is // independent of the per-view (navigation/layout) lifecycle — those