From d6df0b3b7093c5dbd63591e8fb56e9c9d044429e Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 13:28:40 -0500 Subject: [PATCH 01/16] fix(browser): carry typed free-space refusals to the page --- capsules/browser-engine-adapter/src/main.rs | 4 + .../browser-engine-adapter/src/supervisor.rs | 8 ++ capsules/browser-engine-adapter/src/tests.rs | 31 +++++++ capsules/browser/browser/browser-status.js | 14 +++ .../browser/browser/browser-status.test.mjs | 36 ++++++++ elastos/CHANGELOG.md | 1 + .../elastos-common/src/browser_protocol.rs | 26 ++++++ .../src/browser_protocol/tests.rs | 21 +++++ .../elastos-server/src/api/gateway_browser.rs | 52 +++++++++-- .../src/api/gateway_browser_route_tests.rs | 66 ++++++++++++++ .../api/gateway_tests/support_providers.rs | 28 ++++-- .../src/bin/browser-vz-engine-supervisor.rs | 87 ++++++++++++++++--- scripts/browser-launch-refusal.test.mjs | 56 ++++++++++++ scripts/browser-vm-control-service.mjs | 19 +++- scripts/browser-vm-engine-supervisor.mjs | 11 ++- 15 files changed, 425 insertions(+), 35 deletions(-) create mode 100644 scripts/browser-launch-refusal.test.mjs diff --git a/capsules/browser-engine-adapter/src/main.rs b/capsules/browser-engine-adapter/src/main.rs index 026ff4d2d..4dcce0bd9 100644 --- a/capsules/browser-engine-adapter/src/main.rs +++ b/capsules/browser-engine-adapter/src/main.rs @@ -155,6 +155,8 @@ enum Response { adapter: Option, #[serde(skip_serializing_if = "Option::is_none")] launch_settlement_result: Option, + #[serde(skip_serializing_if = "Option::is_none")] + refusal: Option, }, } @@ -173,6 +175,7 @@ impl Response { message: message.into(), adapter: None, launch_settlement_result: None, + refusal: None, } } @@ -182,6 +185,7 @@ impl Response { message: error.message, adapter: Some(adapter.id.clone()), launch_settlement_result: error.launch_settlement_result, + refusal: error.refusal, } } } diff --git a/capsules/browser-engine-adapter/src/supervisor.rs b/capsules/browser-engine-adapter/src/supervisor.rs index e140d3433..464afbe06 100644 --- a/capsules/browser-engine-adapter/src/supervisor.rs +++ b/capsules/browser-engine-adapter/src/supervisor.rs @@ -25,6 +25,7 @@ pub(super) struct SupervisorLaunchError { pub(super) code: String, pub(super) message: String, pub(super) launch_settlement_result: Option, + pub(super) refusal: Option, } impl SupervisorLaunchError { @@ -33,6 +34,7 @@ impl SupervisorLaunchError { code: "engine_process_unavailable".to_string(), message: message.into(), launch_settlement_result: None, + refusal: None, } } } @@ -45,6 +47,8 @@ struct TypedSupervisorLaunchError { message: String, #[serde(default)] launch_settlement_result: Option, + #[serde(default)] + refusal: Option, } fn supervisor_launch_error( @@ -67,6 +71,10 @@ fn supervisor_launch_error( code: error.code, message: error.message, launch_settlement_result, + refusal: error + .refusal + .as_ref() + .and_then(elastos_common::browser_protocol::BrowserLaunchRefusal::from_value), }; } SupervisorLaunchError::process(format!( diff --git a/capsules/browser-engine-adapter/src/tests.rs b/capsules/browser-engine-adapter/src/tests.rs index a054dec44..0e97a21c8 100644 --- a/capsules/browser-engine-adapter/src/tests.rs +++ b/capsules/browser-engine-adapter/src/tests.rs @@ -738,6 +738,37 @@ fn reconcile_terminal_vz_settlement(mutate: impl FnOnce(&mut Value)) -> Value { .unwrap() } +#[test] +fn supervisor_space_refusal_reaches_the_adapter_response() { + use std::os::unix::process::ExitStatusExt; + let adapter: AdapterConfig = serde_json::from_value(json!({ + "id": "browser-vm-product", "kind": "chromium_microvm", + "display_modes": ["webrtc_remote_display"], + })) + .unwrap(); + for (code, available, valid) in [ + ("insufficient_free_space", json!(8589934591_u64), true), + ("unknown", json!(8589934591_u64), false), + ("insufficient_free_space", json!(-1), false), + ] { + let refusal = + json!({"code": code, "required_bytes": 8589934592_u64, "available_bytes": available}); + let stderr = json!({ + "schema": "elastos.browser.engine.launch-error/v1", "code": "launch_refused", + "message": "private engine text", "refusal": refusal, + }) + .to_string(); + let error = + supervisor_launch_error(std::process::ExitStatus::from_raw(42 << 8), &stderr, None); + let response = serde_json::to_value(Response::supervisor_error(&adapter, error)).unwrap(); + if valid { + assert_eq!(response["refusal"], refusal); + } else { + assert!(response.get("refusal").is_none()); + } + } +} + #[test] fn exact_vz_did_not_act_settlement_survives_supervisor_failure() { let generation = format!("sha256:{}", "7".repeat(64)); diff --git a/capsules/browser/browser/browser-status.js b/capsules/browser/browser/browser-status.js index 599393c62..58d0f0bc2 100644 --- a/capsules/browser/browser/browser-status.js +++ b/capsules/browser/browser/browser-status.js @@ -65,6 +65,20 @@ export function friendlyOpenError(error) { return "Browser session expired. Reopening from Home..."; } const outcome = runtimeOpenOutcome(error); + const refusal = error?.payload?.refusal; + if ( + ["terminal_pre_effect_failure", "terminal_post_effect_cleanup"].includes(outcome?.state) && + outcome.effects.page_acquired === false && outcome.effects.vm_acquired === false && + outcome.effects.stream_acquired === false && + refusal && Object.keys(refusal).length === 3 && + refusal.code === "insufficient_free_space" && + Number.isSafeInteger(refusal.required_bytes) && Number.isSafeInteger(refusal.available_bytes) && + refusal.available_bytes >= 0 && refusal.available_bytes < refusal.required_bytes + ) { + const required = (Math.ceil(refusal.required_bytes / 100_000_000) / 10).toFixed(1); + const available = (Math.floor(refusal.available_bytes / 100_000_000) / 10).toFixed(1); + return `Browser needs ${required} GB free on this computer to open; ${available} GB are free. Free some space, then open Browser again.`; + } if (outcome?.state === "terminal_pre_effect_failure" && error?.payload?.stage === "viewer_compatibility") { return error.payload.code === "unsupported_viewer_display_mode" ? "This Browser view needs a streamed display. Open Browser from Home with its default display." diff --git a/capsules/browser/browser/browser-status.test.mjs b/capsules/browser/browser/browser-status.test.mjs index 75f12c1ae..e3c1bba3f 100644 --- a/capsules/browser/browser/browser-status.test.mjs +++ b/capsules/browser/browser/browser-status.test.mjs @@ -51,6 +51,42 @@ function openError(state, effects) { return error; } +test("space refusal reports required and available decimal GB after safe cleanup", () => { + for (const state of ["terminal_pre_effect_failure", "terminal_post_effect_cleanup"]) { + const error = openError(state); + error.payload.refusal = { + code: "insufficient_free_space", required_bytes: 8589934592, available_bytes: 8589934591, + }; + error.payload.message = "private engine error text"; + assert.equal(friendlyOpenError(error), "Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again."); + } +}); + +test("invalid, unknown and pending refusals keep the generic failure", () => { + const error = openError("terminal_post_effect_cleanup"); + const generic = friendlyOpenError(error); + error.message = "Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again."; + assert.equal(friendlyOpenError(error), generic, "message text grants no refusal code"); + for (const refusal of [ + undefined, + { code: "unknown", required_bytes: 20, available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: "20", available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: 10, available_bytes: 20 }, + { code: "insufficient_free_space", required_bytes: 20, available_bytes: -1 }, + { code: "insufficient_free_space", required_bytes: 2 ** 53, available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: 20, available_bytes: 10, message: "private" }, + ]) { + error.payload.refusal = refusal; + assert.equal(friendlyOpenError(error), generic); + } + error.payload.refusal = { code: "insufficient_free_space", required_bytes: 20, available_bytes: 10 }; + error.payload.outcome.state = "cleanup_pending"; + assert.match(friendlyOpenError(error), /finishing cleanup/); + error.payload.outcome.state = "terminal_post_effect_cleanup"; + error.payload.outcome.effects.vm_acquired = true; + assert.equal(friendlyOpenError(error), generic); +}); + test("pre-effect open failure never claims a missing terminal close", () => { const error = openError("terminal_pre_effect_failure"); diff --git a/elastos/CHANGELOG.md b/elastos/CHANGELOG.md index 7b8b72168..665648f03 100644 --- a/elastos/CHANGELOG.md +++ b/elastos/CHANGELOG.md @@ -8,6 +8,7 @@ release's Added, Changed, Fixed, Removed and Security bullets before you update; ### Fixed +- When Browser cannot open because the computer is short of space, it says how much space it needs. - Open apps, including Chat, stay connected while Home runs, and reconnect by themselves after a network drop or a restart. - Closing Browser no longer fails after a minute when another program happens to use a port Browser's media relay may need. diff --git a/elastos/crates/elastos-common/src/browser_protocol.rs b/elastos/crates/elastos-common/src/browser_protocol.rs index be1a16ffc..0a3a54425 100644 --- a/elastos/crates/elastos-common/src/browser_protocol.rs +++ b/elastos/crates/elastos-common/src/browser_protocol.rs @@ -18,6 +18,32 @@ pub const BROWSER_ENGINE_CLEANUP_BINDING_SCHEMA: &str = "elastos.browser.engine- pub const BROWSER_ENGINE_CLEANUP_RESULT_SCHEMA: &str = "elastos.browser.engine-cleanup-result/v2"; pub const MAX_BROWSER_ENGINE_ADAPTERS: usize = 64; +/// Person-actionable launch refusals. Runtime exposes only this closed set; +/// engine diagnostics stay with the Engine. +#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)] +#[serde(tag = "code", rename_all = "snake_case", deny_unknown_fields)] +pub enum BrowserLaunchRefusal { + InsufficientFreeSpace { + required_bytes: u64, + available_bytes: u64, + }, +} + +impl BrowserLaunchRefusal { + pub fn from_value(value: &Value) -> Option { + let refusal: Self = serde_json::from_value(value.clone()).ok()?; + match refusal { + Self::InsufficientFreeSpace { + required_bytes, + available_bytes, + } if available_bytes < required_bytes && required_bytes < (1_u64 << 53) => { + Some(refusal) + } + _ => None, + } + } +} + #[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum BrowserDisplayMode { diff --git a/elastos/crates/elastos-common/src/browser_protocol/tests.rs b/elastos/crates/elastos-common/src/browser_protocol/tests.rs index 6c94b8c35..d90a00a55 100644 --- a/elastos/crates/elastos-common/src/browser_protocol/tests.rs +++ b/elastos/crates/elastos-common/src/browser_protocol/tests.rs @@ -261,3 +261,24 @@ fn readiness_accepts_only_the_declared_state_and_reason_fields() { assert!(serde_json::from_value::(value).is_err()); } } + +#[test] +fn launch_refusal_accepts_only_known_codes_and_safe_byte_counts() { + let good = json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}); + assert_eq!( + serde_json::to_value(BrowserLaunchRefusal::from_value(&good).unwrap()).unwrap(), + good + ); + for (key, value) in [ + ("code", json!("unknown")), + ("required_bytes", json!("8589934592")), + ("available_bytes", json!(-1)), + ("available_bytes", json!(8589934592_u64)), + ("required_bytes", json!(1_u64 << 53)), + ("message", json!("private")), + ] { + let mut bad = good.clone(); + bad[key] = value; + assert!(BrowserLaunchRefusal::from_value(&bad).is_none()); + } +} diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 67f5a1e5a..16d534ae0 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -964,7 +964,11 @@ async fn execute_browser_open( &message, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err(BrowserOpenFailure::text( + status, + "Browser Engine failed to start cleanly.".to_string(), + ) + .with_outcome(outcome)); } }; if engine_response @@ -988,6 +992,37 @@ async fn execute_browser_open( &engine_response, ) .await; + if let Some(refusal) = engine_response + .get("refusal") + .and_then(elastos_common::browser_protocol::BrowserLaunchRefusal::from_value) + { + let outcome = match exact_did_not_act { + Some(outcome) => outcome, + None => { + reconcile_dispatched_browser_launch_failure( + state, + &launch_reservation, + &context.principal_id, + authority.verified_context().launch_id(), + &engine_stream_id, + stream_cleanup.clone(), + "Browser launch refused", + ) + .await + } + }; + return Err(BrowserOpenFailure::json( + StatusCode::SERVICE_UNAVAILABLE, + serde_json::json!({ + "schema": "elastos.browser.open-error/v1", + "ok": false, + "code": "launch_refused", + "message": "Browser cannot open.", + "refusal": refusal, + }), + ) + .with_outcome(outcome)); + } if matches!( code, "engine_unavailable" | "byte_transport_unavailable" | "display_session_unavailable" @@ -1009,7 +1044,7 @@ async fn execute_browser_open( }; return Err(BrowserOpenFailure::provider( "browser-engine", - anyhow::anyhow!("browser-engine provider unavailable: {}", message), + anyhow::anyhow!("Browser Engine is unavailable."), ) .with_outcome(outcome)); } @@ -1038,7 +1073,7 @@ async fn execute_browser_open( "schema": "elastos.browser.open-error/v1", "ok": false, "code": code, - "message": message, + "message": "Browser launch refused.", }), ) .with_outcome(outcome)); @@ -1060,7 +1095,7 @@ async fn execute_browser_open( }; return Err(BrowserOpenFailure::provider( "browser-engine", - anyhow::anyhow!(message.to_string()), + anyhow::anyhow!("Browser Engine failed to start cleanly."), ) .with_outcome(outcome)); } @@ -1075,10 +1110,11 @@ async fn execute_browser_open( &message, ) .await; - return Err( - BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)) - .with_outcome(outcome), - ); + return Err(BrowserOpenFailure::provider( + "browser-engine", + anyhow::anyhow!("Browser Engine failed to start cleanly."), + ) + .with_outcome(outcome)); } let raw_engine_page = match provider_response_data(&engine_response) { Some(data) => data, diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index e40e8719b..f621a01d2 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -3183,6 +3183,72 @@ async fn test_exact_terminal_vz_settlement_releases_restart_reconciliation_oblig assert!(!dir.path().join("browser-streams").exists()); } +#[tokio::test] +async fn test_browser_space_refusal_preserves_counts_and_cleanup_ownership() { + for (suffix, valid, terminal) in [ + ("", true, true), + ("", true, false), + ("unknown", false, true), + ("counts", false, true), + ] { + let dir = tempfile::tempdir().unwrap(); + write_browser_vz_transport_test_config(dir.path()); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let (state, close_calls, reconciliation_calls) = browser_engine_reconciliation_test_state( + dir.path(), + if terminal { + MockDispatchedBrowserLaunchFailure::TerminalVzSettlement + } else { + MockDispatchedBrowserLaunchFailure::MismatchedTerminalVzSettlement + }, + ) + .await; + let response = gateway_router(state).oneshot( + test_browser_request("localhost:61180", "null").method("POST") + .uri("/api/apps/browser/open").header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(Body::from(serde_json::json!({ + "url": format!("https://space-refusal.invalid/{suffix}"), + "reason": "space refusal keeps cleanup ownership", + "display_mode": "webrtc_remote_display", "guarantee_level": "mechanism_microvm", + }).to_string())).unwrap(), + ).await.unwrap(); + assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE); + let body = axum::body::to_bytes(response.into_body(), usize::MAX) + .await + .unwrap(); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("private engine diagnostic")); + if valid { + assert_eq!( + payload["refusal"], + serde_json::json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}) + ); + } else { + assert!(payload.get("refusal").is_none()); + } + assert_eq!( + payload["outcome"]["state"], + if terminal { + "terminal_post_effect_cleanup" + } else { + "cleanup_pending" + } + ); + if terminal { + assert_eq!(payload["outcome"]["effects"]["page_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["vm_acquired"], false); + } + assert_eq!(reconciliation_calls.count(), 1); + assert!(close_calls.snapshot().await.is_empty()); + assert_eq!( + browser_launch_reconciliation_obligation_count(dir.path()).await, + usize::from(!terminal) + ); + } +} + #[tokio::test] async fn test_browser_profile_recovery_requires_exact_terminal_settlement() { for (failure, terminal) in [ diff --git a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs index 073422331..3badb744b 100644 --- a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs +++ b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs @@ -3943,6 +3943,22 @@ impl Provider for MockReconciliatingBrowserEngineProvider { "launch_settlement_result": settlement, })); } + if request["url"] + .as_str() + .is_some_and(|url| url.contains("space-refusal.invalid")) + { + let mut refusal = json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}); + if request["url"].as_str().unwrap().contains("unknown") { + refusal["code"] = json!("unknown"); + } + if request["url"].as_str().unwrap().contains("counts") { + refusal["available_bytes"] = json!(-1); + } + return Ok(json!({ + "status": "error", "code": "launch_refused", + "message": "private engine diagnostic", "refusal": refusal, + })); + } if matches!( self.failure, MockDispatchedBrowserLaunchFailure::TerminalVzSettlement @@ -4553,9 +4569,7 @@ struct MockBitcoinChallenge { /// capsules/wallet-provider), so a caller holding a newer launch of the same /// session is refused exactly as it is live; the session binding alone would /// let that case through. -fn mock_wallet_authority_binding( - authority: &elastos_wallet_contract::WalletAuthorityV2, -) -> String { +fn mock_wallet_authority_binding(authority: &elastos_wallet_contract::WalletAuthorityV2) -> String { let bytes = serde_json::to_vec(&json!({ "principal_id": authority.principal_id, "session_id": authority.session_id, @@ -6514,8 +6528,12 @@ impl MockWalletProvider { } // The real wallet binds the outcome to the approval's ORIGINAL authority // (validate_chain_outcome_target): a later launch must not attach it. - if approval.get("authority_binding").and_then(|value| value.as_str()) - != request.get("authority_binding").and_then(|value| value.as_str()) + if approval + .get("authority_binding") + .and_then(|value| value.as_str()) + != request + .get("authority_binding") + .and_then(|value| value.as_str()) { return Ok(json!({ "status": "error", diff --git a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs index 462098e51..7a78f194f 100644 --- a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs +++ b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs @@ -3217,6 +3217,14 @@ fn prepare_launch_rootfs(paths: &LaunchPaths) -> Result Option { let required = seed_bytes.saturating_add(ROOTFS_OVERLAY_FREE_FLOOR); - // Tenths of a GB: the need rounded up, the free space rounded down. - let tenths = |tenths: u64| format!("{}.{}", tenths / 10, tenths % 10); (available < required).then(|| { - format!( - "Browser needs {} GB free on this computer to open; {} GB are free. Free some space, then open Browser again.", - tenths(required.div_ceil(100_000_000)), - tenths(available / 100_000_000) - ) + json!({ + "schema": "elastos.browser.engine.launch-error/v1", + "code": "launch_refused", + "message": "Browser cannot open.", + "refusal": elastos_common::browser_protocol::BrowserLaunchRefusal::InsufficientFreeSpace { + required_bytes: required, + available_bytes: available, + }, + }).to_string() }) } +#[cfg(not(target_os = "linux"))] +fn available_launch_bytes(path: &Path) -> Result { + use std::os::unix::ffi::OsStrExt; + let path = std::ffi::CString::new(path.as_os_str().as_bytes()).map_err(|e| e.to_string())?; + let mut stats = std::mem::MaybeUninit::::uninit(); + // SAFETY: path is NUL-terminated and statvfs initializes stats on success. + if unsafe { libc::statvfs(path.as_ptr(), stats.as_mut_ptr()) } != 0 { + return Err(format!("free space: {}", std::io::Error::last_os_error())); + } + // SAFETY: statvfs succeeded. + let stats = unsafe { stats.assume_init() }; + Ok(u64::from(stats.f_bavail).saturating_mul(stats.f_frsize)) +} + /// Linux boots a per-launch qcow2 overlay whose backing file is the /// read-only seed: guest writes go to the overlay and everything else is /// read from the seed, so a launch copies nothing (#90: copying the 4 GiB @@ -6012,6 +6034,42 @@ mod tests { VzLaunchOwner::new(VzLaunchIdentity::from_launch(&launch), paths, transport) } + #[tokio::test] + async fn space_refusal_before_vm_start_keeps_first_open_profile_usable() { + let root = tempfile::tempdir().unwrap(); + let mut owner = cleanup_owner_fixture(root.path()); + let disk = root.path().join("BrowserProfiles/default/profile.ext4"); + fs::create_dir_all(disk.parent().unwrap()).unwrap(); + fs::set_permissions(disk.parent().unwrap(), fs::Permissions::from_mode(0o700)).unwrap(); + let request = json!({"profile": { + "schema": "elastos.browser.profile/v1", "scope": "active_principal", + "profile_key": format!("profile-{}", "a".repeat(64)), "disk_path": disk, + "storage": "principal_owned_profile_disk", + "storage_posture": "principal_owned_reset_scoped_unprotected", + "protected_storage": false, "encrypted": false, "recoverable": false, + "recovery": "not_recovery_kit_packaged", "reset": "whole_profile", + "uri": "localhost://Users/0123456789ab/BrowserProfiles/default/profile.ext4", + "public_uri": "localhost://Users/self/BrowserProfiles/default/profile.ext4", + }}); + owner.session_directory = true; + create_owned_launch_paths(&owner.paths, &owner.transport, &mut owner.acquired_paths) + .unwrap(); + owner.profile_disk = Some(prepare_browser_profile_disk(&request).unwrap()); + assert!(owner.profile_disk.as_ref().unwrap().initialize); + let before = fs::metadata(&disk).unwrap(); + let refusal = rootfs_overlay_space_refusal(4 * 1024 * 1024 * 1024, 0).unwrap(); + let settlement: Value = + serde_json::from_str(&owner.finish_cleanup(&refusal, None).await).unwrap(); + assert_eq!(settlement["state"], "terminal_post_effect_cleanup"); + assert_eq!(settlement["effects"]["vm"], false); + let reason: Value = serde_json::from_str(settlement["message"].as_str().unwrap()).unwrap(); + assert_eq!(reason["refusal"]["code"], "insufficient_free_space"); + let reopened = prepare_browser_profile_disk(&request).unwrap(); + assert!(reopened.initialize); + assert_eq!(fs::metadata(&disk).unwrap().ino(), before.ino()); + assert_eq!(fs::metadata(&disk).unwrap().len(), before.len()); + } + #[test] fn native_cleanup_rejects_cached_and_uncertain_vm_states() { assert!(native_vm_absence_proved("Stopped")); @@ -8222,17 +8280,18 @@ mod tests { assert!(other.exists()); } - #[cfg(target_os = "linux")] #[test] fn a_launch_refuses_an_overlay_the_disk_could_not_hold() { // The worst case is every seed block rewritten, plus the update floor. let seed = 4 * 1024 * 1024 * 1024; let required = seed + ROOTFS_OVERLAY_FREE_FLOOR; assert_eq!(rootfs_overlay_space_refusal(seed, required), None); - assert_eq!( - rootfs_overlay_space_refusal(seed, required - 1).as_deref(), - Some("Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again.") - ); + let error = rootfs_overlay_space_refusal(seed, required - 1).unwrap(); + let typed: Value = serde_json::from_str(&error).unwrap(); + assert_eq!(typed["schema"], "elastos.browser.engine.launch-error/v1"); + assert_eq!(typed["refusal"]["code"], "insufficient_free_space"); + assert_eq!(typed["refusal"]["required_bytes"], required); + assert_eq!(typed["refusal"]["available_bytes"], required - 1); } #[cfg(not(target_os = "linux"))] diff --git a/scripts/browser-launch-refusal.test.mjs b/scripts/browser-launch-refusal.test.mjs new file mode 100644 index 000000000..89bff6c17 --- /dev/null +++ b/scripts/browser-launch-refusal.test.mjs @@ -0,0 +1,56 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import http from "node:http"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { launcherError, launchRefusalFields } from "./browser-vm-control-service.mjs"; +import { postJsonOverUnix } from "./browser-vm-engine-supervisor.mjs"; + +const refusal = { code: "insufficient_free_space", required_bytes: 8589934592, available_bytes: 8589934591 }; +const typed = { schema: "elastos.browser.engine.launch-error/v1", code: "launch_refused", message: "Browser cannot open.", refusal }; + +test("control service recovers typed space refusal from native cleanup receipt", () => { + const settlement = { + schema: "elastos.browser.vz-launch-settlement/v1", state: "terminal_post_effect_cleanup", + message: JSON.stringify(typed), binding_hash: `sha256:${"a".repeat(64)}`, + generation: `sha256:${"b".repeat(64)}`, page_id: "page:test", vm_id: "vm:test", + stream_id: "stream:test", media_stream_id: "stream:media", + effects: Object.fromEntries(["session_directory", "control_socket", "ordinary_stream_bridge", "media_stream_bridge", "turn_process", "supervisor_child", "vm"].map(k => [k, k === "session_directory"])), + absence: Object.fromEntries(["child_absent", "supervisor_child_absent", "control_socket_absent", "route_absent", "turn_listener_absent", "turn_relay_ports_absent", "ordinary_stream_bridge_absent", "media_stream_bridge_absent", "session_directory_absent", "vm_absent"].map(k => [k, true])), + }; + const error = launcherError("launch failed", JSON.stringify(settlement)); + assert.equal(error.code, "launch_refused"); + assert.deepEqual(error.refusal, refusal); + assert.equal(error.launch_settlement, "terminal_post_effect_cleanup"); +}); + +test("control service accepts only the closed, bounded refusal shape", () => { + assert.deepEqual(launcherError("failed", JSON.stringify(typed)).refusal, refusal); + for (const bad of [ + { ...refusal, code: "unknown" }, { ...refusal, required_bytes: "8589934592" }, + { ...refusal, required_bytes: 2 ** 53 }, { ...refusal, available_bytes: -1 }, + { ...refusal, available_bytes: refusal.required_bytes }, { ...refusal, message: "private" }, + ]) { + assert.equal(launcherError("failed", JSON.stringify({ ...typed, refusal: bad })).refusal, undefined); + } + assert.equal(launcherError("failed", "arbitrary engine failure").refusal, undefined); +}); + +test("supervisor carries the control service's safe refusal through its Unix response", async t => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "browser-refusal-")); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const socket = path.join(root, "control.sock"); + const server = http.createServer((_request, response) => { + const error = launcherError("failed", JSON.stringify(typed)); + response.writeHead(400, { "content-type": "application/json" }); + response.end(JSON.stringify({ code: error.code, message: error.message, ...launchRefusalFields(error) })); + }); + await new Promise(resolve => server.listen(socket, resolve)); + t.after(() => new Promise(resolve => server.close(resolve))); + await assert.rejects(postJsonOverUnix(socket, "/pages", {}, 1000), error => { + assert.equal(error.code, "launch_refused"); + assert.deepEqual(error.refusal, refusal); + return true; + }); +}); diff --git a/scripts/browser-vm-control-service.mjs b/scripts/browser-vm-control-service.mjs index f7b1bb6d6..c4b12c185 100755 --- a/scripts/browser-vm-control-service.mjs +++ b/scripts/browser-vm-control-service.mjs @@ -2714,6 +2714,7 @@ function typedLauncherError(parsed) { !exactObjectKeys(parsed, [ "schema", "code", "message", ...(hasSettlement ? ["launch_settlement_result"] : []), + ...(Object.hasOwn(parsed, "refusal") ? ["refusal"] : []), ]) || parsed.schema !== "elastos.browser.engine.launch-error/v1" || typeof parsed.code !== "string" || @@ -2722,6 +2723,7 @@ function typedLauncherError(parsed) { throw new Error("Browser launcher returned an invalid typed launch error"); } const error = codedError(parsed.code, parsed.message); + Object.assign(error, launchRefusalFields(parsed)); if (hasSettlement) { error.vz_launch_settlement = validateVzLaunchSettlement( parsed.launch_settlement_result, @@ -2731,7 +2733,17 @@ function typedLauncherError(parsed) { return error; } -function launcherError(message, stderr) { +export function launchRefusalFields(payload) { + const refusal = payload?.refusal; + if (!exactObjectKeys(refusal, ["code", "required_bytes", "available_bytes"]) || + refusal.code !== "insufficient_free_space" || + !Number.isSafeInteger(refusal.required_bytes) || + !Number.isSafeInteger(refusal.available_bytes) || + refusal.available_bytes < 0 || refusal.available_bytes >= refusal.required_bytes) return {}; + return { refusal: { code: refusal.code, required_bytes: refusal.required_bytes, available_bytes: refusal.available_bytes } }; +} + +export function launcherError(message, stderr) { const detail = String(stderr || "").trim(); if (!detail) return new Error(message); const bounded = detail.length > 8192 ? detail.slice(-8192) : detail; @@ -2747,9 +2759,7 @@ function launcherError(message, stderr) { let error = new Error(settlement.message || message); try { const typed = JSON.parse(settlement.message); - if (exactObjectKeys(typed, ["schema", "code", "message"])) { - error = typedLauncherError(typed); - } + error = typedLauncherError(typed); } catch {} error.vz_launch_settlement = settlement; error.launch_settlement = settlement.state; @@ -4972,6 +4982,7 @@ function main() { ...(typeof error?.code === "string" ? { code: error.code, message } : { error: message }), + ...launchRefusalFields(error), ...(error?.vz_launch_settlement ? { launch_settlement_result: diff --git a/scripts/browser-vm-engine-supervisor.mjs b/scripts/browser-vm-engine-supervisor.mjs index 543c51b7d..f22e5f876 100755 --- a/scripts/browser-vm-engine-supervisor.mjs +++ b/scripts/browser-vm-engine-supervisor.mjs @@ -27,15 +27,16 @@ const INVOCATION_ONLY_VM_ENV = new Set([ ]); class BrowserLaunchError extends Error { - constructor(code, message, launchSettlementResult = undefined) { + constructor(code, message, launchSettlementResult = undefined, refusal = undefined) { super(message); this.code = code; this.launch_settlement_result = launchSettlementResult; + this.refusal = refusal; } } -function launchError(code, message, launchSettlementResult = undefined) { - return new BrowserLaunchError(code, message, launchSettlementResult); +function launchError(code, message, launchSettlementResult = undefined, refusal = undefined) { + return new BrowserLaunchError(code, message, launchSettlementResult, refusal); } function fail(error) { @@ -45,6 +46,7 @@ function fail(error) { schema: "elastos.browser.engine.launch-error/v1", code: error.code, message, + ...(error.refusal === undefined ? {} : { refusal: error.refusal }), ...(error.launch_settlement_result === undefined ? {} : { launch_settlement_result: error.launch_settlement_result }), @@ -473,7 +475,7 @@ function collectPreflight({ dataDir, platform }) { }; } -function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { +export function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { validateAbsolutePath(socketPath, CONTROL_SOCKET_ENV); const bytes = Buffer.from(JSON.stringify(body)); return new Promise((resolve, reject) => { @@ -507,6 +509,7 @@ function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { parsed.code || "engine_process_unavailable", parsed.message || parsed.error || `Browser VM control returned ${response.statusCode}`, parsed.launch_settlement_result, + parsed.refusal, ) : new Error(parsed.error || parsed.message || `Browser VM control returned ${response.statusCode}`), ); From dc9c146db6700ecb61e0436808b4ce9765c22544 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 13:31:01 -0500 Subject: [PATCH 02/16] test(browser): keep refusal checks with the private parser --- .../browser-engine-adapter/src/supervisor.rs | 36 +++++++++++++++++++ capsules/browser-engine-adapter/src/tests.rs | 31 ---------------- 2 files changed, 36 insertions(+), 31 deletions(-) diff --git a/capsules/browser-engine-adapter/src/supervisor.rs b/capsules/browser-engine-adapter/src/supervisor.rs index 464afbe06..c7ca67273 100644 --- a/capsules/browser-engine-adapter/src/supervisor.rs +++ b/capsules/browser-engine-adapter/src/supervisor.rs @@ -854,3 +854,39 @@ mod private_request_tests { let _ = fs::remove_file(marker); } } + +#[cfg(test)] +mod refusal_tests { + use super::*; + + #[test] + fn supervisor_space_refusal_reaches_the_adapter_response() { + use std::os::unix::process::ExitStatusExt; + let adapter: AdapterConfig = serde_json::from_value(json!({ + "id": "browser-vm-product", "kind": "chromium_microvm", + "display_modes": ["webrtc_remote_display"], + })) + .unwrap(); + for (code, available, valid) in [ + ("insufficient_free_space", json!(8589934591_u64), true), + ("unknown", json!(8589934591_u64), false), + ("insufficient_free_space", json!(-1), false), + ] { + let refusal = json!({"code": code, "required_bytes": 8589934592_u64, "available_bytes": available}); + let stderr = json!({ + "schema": "elastos.browser.engine.launch-error/v1", "code": "launch_refused", + "message": "private engine text", "refusal": refusal, + }) + .to_string(); + let error = + supervisor_launch_error(std::process::ExitStatus::from_raw(42 << 8), &stderr, None); + let response = + serde_json::to_value(Response::supervisor_error(&adapter, error)).unwrap(); + if valid { + assert_eq!(response["refusal"], refusal); + } else { + assert!(response.get("refusal").is_none()); + } + } + } +} diff --git a/capsules/browser-engine-adapter/src/tests.rs b/capsules/browser-engine-adapter/src/tests.rs index 0e97a21c8..a054dec44 100644 --- a/capsules/browser-engine-adapter/src/tests.rs +++ b/capsules/browser-engine-adapter/src/tests.rs @@ -738,37 +738,6 @@ fn reconcile_terminal_vz_settlement(mutate: impl FnOnce(&mut Value)) -> Value { .unwrap() } -#[test] -fn supervisor_space_refusal_reaches_the_adapter_response() { - use std::os::unix::process::ExitStatusExt; - let adapter: AdapterConfig = serde_json::from_value(json!({ - "id": "browser-vm-product", "kind": "chromium_microvm", - "display_modes": ["webrtc_remote_display"], - })) - .unwrap(); - for (code, available, valid) in [ - ("insufficient_free_space", json!(8589934591_u64), true), - ("unknown", json!(8589934591_u64), false), - ("insufficient_free_space", json!(-1), false), - ] { - let refusal = - json!({"code": code, "required_bytes": 8589934592_u64, "available_bytes": available}); - let stderr = json!({ - "schema": "elastos.browser.engine.launch-error/v1", "code": "launch_refused", - "message": "private engine text", "refusal": refusal, - }) - .to_string(); - let error = - supervisor_launch_error(std::process::ExitStatus::from_raw(42 << 8), &stderr, None); - let response = serde_json::to_value(Response::supervisor_error(&adapter, error)).unwrap(); - if valid { - assert_eq!(response["refusal"], refusal); - } else { - assert!(response.get("refusal").is_none()); - } - } -} - #[test] fn exact_vz_did_not_act_settlement_survives_supervisor_failure() { let generation = format!("sha256:{}", "7".repeat(64)); From 10ed570938b7fe475948fc3d3fc3964224f1c513 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 13:52:43 -0500 Subject: [PATCH 03/16] fix(browser): preserve engine failure status when hiding diagnostics --- .../elastos-server/src/api/gateway_browser.rs | 55 ++++++++++++++----- .../src/api/gateway_browser_route_tests.rs | 9 ++- 2 files changed, 49 insertions(+), 15 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 16d534ae0..61143c37d 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -189,6 +189,15 @@ impl BrowserOpenFailure { Self::text(status, message) } + fn engine_provider(message: impl Into) -> Self { + let (status, _) = + gateway_provider_error_tuple("browser-engine", anyhow::anyhow!(message.into())); + Self::text( + status, + "Browser Engine failed to start cleanly.".to_string(), + ) + } + fn into_response(self) -> Response { let status = self.status; (status, Json(self.status_value())).into_response() @@ -1042,10 +1051,9 @@ async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::provider( - "browser-engine", - anyhow::anyhow!("Browser Engine is unavailable."), - ) + return Err(BrowserOpenFailure::engine_provider(format!( + "browser-engine provider unavailable: {message}", + )) .with_outcome(outcome)); } if matches!( @@ -1093,11 +1101,7 @@ async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::provider( - "browser-engine", - anyhow::anyhow!("Browser Engine failed to start cleanly."), - ) - .with_outcome(outcome)); + return Err(BrowserOpenFailure::engine_provider(message).with_outcome(outcome)); } if let Some(message) = provider_response_error_message(&engine_response) { let outcome = reconcile_dispatched_browser_launch_failure( @@ -1110,11 +1114,7 @@ async fn execute_browser_open( &message, ) .await; - return Err(BrowserOpenFailure::provider( - "browser-engine", - anyhow::anyhow!("Browser Engine failed to start cleanly."), - ) - .with_outcome(outcome)); + return Err(BrowserOpenFailure::engine_provider(message).with_outcome(outcome)); } let raw_engine_page = match provider_response_data(&engine_response) { Some(data) => data, @@ -4663,6 +4663,33 @@ fn browser_display_error_response(error: BrowserDisplayError) -> Response { mod browser_open_outcome_tests { use super::*; + #[test] + fn engine_error_keeps_status_while_projection_keeps_diagnostics_private() { + for (message, status) in [ + ( + "browser-engine provider unavailable: private diagnostic", + StatusCode::SERVICE_UNAVAILABLE, + ), + ( + "private host blocked: private diagnostic", + StatusCode::FORBIDDEN, + ), + ( + "invalid engine reply: private diagnostic", + StatusCode::BAD_REQUEST, + ), + ("page not found: private diagnostic", StatusCode::NOT_FOUND), + ("private diagnostic", StatusCode::INTERNAL_SERVER_ERROR), + ] { + let failure = BrowserOpenFailure::engine_provider(message); + assert_eq!(failure.status, status); + assert_eq!( + failure.status_value()["message"], + "Browser Engine failed to start cleanly." + ); + } + } + #[test] fn failed_open_serializes_cleanup_pending_separately_from_pre_effect_failure() { let pending = BrowserOpenFailure::text( diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index f621a01d2..b9f70aa77 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -3214,7 +3214,14 @@ async fn test_browser_space_refusal_preserves_counts_and_cleanup_ownership() { "display_mode": "webrtc_remote_display", "guarantee_level": "mechanism_microvm", }).to_string())).unwrap(), ).await.unwrap(); - assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE); + assert_eq!( + response.status(), + if valid { + StatusCode::SERVICE_UNAVAILABLE + } else { + StatusCode::INTERNAL_SERVER_ERROR + } + ); let body = axum::body::to_bytes(response.into_body(), usize::MAX) .await .unwrap(); From f04b239a202e526ad389cb89ff882ea9dd1394a2 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 15:54:07 -0500 Subject: [PATCH 04/16] fix(browser): keep overlay capacity checks on Linux --- .../src/bin/browser-vz-engine-supervisor.rs | 24 ++----------------- 1 file changed, 2 insertions(+), 22 deletions(-) diff --git a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs index 7a78f194f..f98ef3b15 100644 --- a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs +++ b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs @@ -3217,14 +3217,6 @@ fn prepare_launch_rootfs(paths: &LaunchPaths) -> Result Option { let required = seed_bytes.saturating_add(ROOTFS_OVERLAY_FREE_FLOOR); (available < required).then(|| { @@ -3285,20 +3279,6 @@ fn rootfs_overlay_space_refusal(seed_bytes: u64, available: u64) -> Option Result { - use std::os::unix::ffi::OsStrExt; - let path = std::ffi::CString::new(path.as_os_str().as_bytes()).map_err(|e| e.to_string())?; - let mut stats = std::mem::MaybeUninit::::uninit(); - // SAFETY: path is NUL-terminated and statvfs initializes stats on success. - if unsafe { libc::statvfs(path.as_ptr(), stats.as_mut_ptr()) } != 0 { - return Err(format!("free space: {}", std::io::Error::last_os_error())); - } - // SAFETY: statvfs succeeded. - let stats = unsafe { stats.assume_init() }; - Ok(u64::from(stats.f_bavail).saturating_mul(stats.f_frsize)) -} - /// Linux boots a per-launch qcow2 overlay whose backing file is the /// read-only seed: guest writes go to the overlay and everything else is /// read from the seed, so a launch copies nothing (#90: copying the 4 GiB From fc0b12ef5484bb401e2a02b68aaad7572bea7e8a Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 16:17:24 -0500 Subject: [PATCH 05/16] test(browser): keep missing-transport diagnostics private --- .../elastos-server/src/api/gateway_browser_route_tests.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index b9f70aa77..8f393c1ee 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -1064,8 +1064,12 @@ async fn test_browser_open_fails_closed_without_attached_engine_transport() { let body = axum::body::to_bytes(response.into_body(), usize::MAX) .await .unwrap(); - let message = String::from_utf8(body.to_vec()).unwrap(); - assert!(message.contains("adapter_ipc")); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert!(!String::from_utf8_lossy(&body).contains("adapter_ipc")); } #[tokio::test] From 5dc8304a5eb57d09ef6a99806abd98aed375351b Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 17:26:33 -0500 Subject: [PATCH 06/16] fix(browser): keep engine diagnostics private and test refusal transport Keep Browser Engine diagnostics private in the shared open-failure constructor, with a fixed public message and provider_error code. Preserve status classification and cleanup outcomes. Exercise a private path through a malformed engine receipt and the provider constructor. Drive refusal envelopes through real supervisor stderr and the control service HTTP response, including invalid codes and counts. Before/after: both Rust privacy assertions fail before and pass after. The transport tests fail on response assertions at 344284ebb (0/7 pass) and pass here (7/7). Validation: - cargo fmt --all -- --check; chain-provider cargo fmt -- --check - cargo clippy -p elastos-server --all-targets -- -D warnings - cargo test -p elastos-server --all-targets gateway_browser -- --nocapture: 228 pass - Browser Node tests: 1280 pass across 72 files - ./scripts/test-source-gate.sh: pass; 2 Linux pidfd checks skipped on macOS - ./scripts/test-behaviour.sh: 2189 pass - node --test scripts/check-product-data.test.mjs: 105 pass - git diff --check --- .../elastos-server/src/api/gateway_browser.rs | 46 +++++- .../src/api/gateway_browser_route_tests.rs | 6 + .../api/gateway_tests/support_providers.rs | 6 + scripts/browser-launch-refusal.test.mjs | 145 +++++++++++++----- 4 files changed, 155 insertions(+), 48 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 61143c37d..62d44c52a 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -186,16 +186,21 @@ impl BrowserOpenFailure { fn provider(scheme: &str, err: anyhow::Error) -> Self { let (status, message) = gateway_provider_error_tuple(scheme, err); - Self::text(status, message) + if scheme == "browser-engine" { + Self::json( + status, + serde_json::json!({ + "code": "provider_error", + "message": "Browser Engine failed to start cleanly.", + }), + ) + } else { + Self::text(status, message) + } } fn engine_provider(message: impl Into) -> Self { - let (status, _) = - gateway_provider_error_tuple("browser-engine", anyhow::anyhow!(message.into())); - Self::text( - status, - "Browser Engine failed to start cleanly.".to_string(), - ) + Self::provider("browser-engine", anyhow::anyhow!(message.into())) } fn into_response(self) -> Response { @@ -4663,6 +4668,33 @@ fn browser_display_error_response(error: BrowserDisplayError) -> Response { mod browser_open_outcome_tests { use super::*; + #[tokio::test] + async fn engine_provider_constructor_keeps_all_diagnostics_out_of_response_bodies() { + for message in [ + "browser-engine provider unavailable: /private/engine/rootfs.img", + "private host blocked: /private/engine/rootfs.img", + "invalid engine reply: /private/engine/rootfs.img", + "page not found: /private/engine/rootfs.img", + "engine failed: /private/engine/rootfs.img", + ] { + let expected_status = + gateway_provider_error_tuple("browser-engine", anyhow::anyhow!(message)).0; + let response = BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)) + .into_response(); + assert_eq!(response.status(), expected_status); + let body = axum::body::to_bytes(response.into_body(), usize::MAX) + .await + .unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("/private/engine/rootfs.img")); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert_eq!(payload["code"], "provider_error"); + } + } + #[test] fn engine_error_keeps_status_while_projection_keeps_diagnostics_private() { for (message, status) in [ diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index 8f393c1ee..33ef85ace 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -3445,6 +3445,12 @@ async fn test_browser_malformed_success_reconciles_instead_of_releasing_ownershi .await .unwrap(); let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("/private/engine/rootfs.img")); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert_eq!(payload["code"], "provider_error"); assert_eq!(payload["outcome"]["state"], "terminal_post_effect_cleanup"); assert_eq!(close_calls.snapshot().await.len(), 1); assert_eq!(reconciliation_calls.count(), 1); diff --git a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs index 3badb744b..8869514bd 100644 --- a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs +++ b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs @@ -4007,6 +4007,12 @@ impl Provider for MockReconciliatingBrowserEngineProvider { "provider": "browser-engine-adapter", "protocol_version": "2.1", "page_id": "unsafe page id", + "direct_network": false, + "wallet_injection": false, + "display_session": { + "schema": "elastos.browser.display-session/v1", + "mode": "/private/engine/rootfs.img", + }, } })), MockDispatchedBrowserLaunchFailure::PendingThenTerminal diff --git a/scripts/browser-launch-refusal.test.mjs b/scripts/browser-launch-refusal.test.mjs index 89bff6c17..1d8a02b2c 100644 --- a/scripts/browser-launch-refusal.test.mjs +++ b/scripts/browser-launch-refusal.test.mjs @@ -4,53 +4,116 @@ import http from "node:http"; import fs from "node:fs"; import os from "node:os"; import path from "node:path"; -import { launcherError, launchRefusalFields } from "./browser-vm-control-service.mjs"; -import { postJsonOverUnix } from "./browser-vm-engine-supervisor.mjs"; +import { spawn } from "node:child_process"; +import { once } from "node:events"; +import { fileURLToPath } from "node:url"; const refusal = { code: "insufficient_free_space", required_bytes: 8589934592, available_bytes: 8589934591 }; const typed = { schema: "elastos.browser.engine.launch-error/v1", code: "launch_refused", message: "Browser cannot open.", refusal }; -test("control service recovers typed space refusal from native cleanup receipt", () => { - const settlement = { - schema: "elastos.browser.vz-launch-settlement/v1", state: "terminal_post_effect_cleanup", - message: JSON.stringify(typed), binding_hash: `sha256:${"a".repeat(64)}`, - generation: `sha256:${"b".repeat(64)}`, page_id: "page:test", vm_id: "vm:test", - stream_id: "stream:test", media_stream_id: "stream:media", - effects: Object.fromEntries(["session_directory", "control_socket", "ordinary_stream_bridge", "media_stream_bridge", "turn_process", "supervisor_child", "vm"].map(k => [k, k === "session_directory"])), - absence: Object.fromEntries(["child_absent", "supervisor_child_absent", "control_socket_absent", "route_absent", "turn_listener_absent", "turn_relay_ports_absent", "ordinary_stream_bridge_absent", "media_stream_bridge_absent", "session_directory_absent", "vm_absent"].map(k => [k, true])), - }; - const error = launcherError("launch failed", JSON.stringify(settlement)); - assert.equal(error.code, "launch_refused"); - assert.deepEqual(error.refusal, refusal); - assert.equal(error.launch_settlement, "terminal_post_effect_cleanup"); -}); - -test("control service accepts only the closed, bounded refusal shape", () => { - assert.deepEqual(launcherError("failed", JSON.stringify(typed)).refusal, refusal); - for (const bad of [ - { ...refusal, code: "unknown" }, { ...refusal, required_bytes: "8589934592" }, - { ...refusal, required_bytes: 2 ** 53 }, { ...refusal, available_bytes: -1 }, - { ...refusal, available_bytes: refusal.required_bytes }, { ...refusal, message: "private" }, - ]) { - assert.equal(launcherError("failed", JSON.stringify({ ...typed, refusal: bad })).refusal, undefined); - } - assert.equal(launcherError("failed", "arbitrary engine failure").refusal, undefined); -}); - -test("supervisor carries the control service's safe refusal through its Unix response", async t => { +async function controlServiceResponse(t, envelope) { + // Exercise the real supervisor stderr -> control service -> HTTP body path. const root = fs.mkdtempSync(path.join(os.tmpdir(), "browser-refusal-")); - t.after(() => fs.rmSync(root, { recursive: true, force: true })); const socket = path.join(root, "control.sock"); - const server = http.createServer((_request, response) => { - const error = launcherError("failed", JSON.stringify(typed)); - response.writeHead(400, { "content-type": "application/json" }); - response.end(JSON.stringify({ code: error.code, message: error.message, ...launchRefusalFields(error) })); + const launcher = path.join(root, "launcher.mjs"); + fs.writeFileSync(launcher, ` + for await (const chunk of process.stdin) {} // Drain the launch request. + console.error(process.env.TEST_LAUNCH_ERROR); + process.exit(73); + `); + const env = { ...process.env, + TEST_LAUNCH_ERROR: JSON.stringify(envelope), + ELASTOS_BROWSER_VM_CONTROL_SERVICE_CONFIG: JSON.stringify({ + schema: "elastos.browser.vm-control-service.config/v1", + control_socket_path: socket, launcher_program: process.execPath, + launcher_args: [launcher], persistent_launcher: true, + launch_timeout_ms: 3000, shutdown_timeout_ms: 1000, + }), + }; + delete env.ELASTOS_UPDATE_PARENT_PIPE; + const service = spawn(process.execPath, [fileURLToPath(new URL("./browser-vm-control-service.mjs", import.meta.url))], { + env, stdio: ["ignore", "pipe", "pipe"], + }); + let stderr = ""; + service.stderr.on("data", chunk => { stderr = (stderr + chunk).slice(-8192); }); + t.after(async () => { + if (service.exitCode === null && service.signalCode === null) { + const exited = once(service, "exit"); + service.kill("SIGTERM"); + const timer = setTimeout(() => service.kill("SIGKILL"), 3000); + try { await exited; } finally { clearTimeout(timer); } + } + fs.rmSync(root, { recursive: true, force: true }); }); - await new Promise(resolve => server.listen(socket, resolve)); - t.after(() => new Promise(resolve => server.close(resolve))); - await assert.rejects(postJsonOverUnix(socket, "/pages", {}, 1000), error => { - assert.equal(error.code, "launch_refused"); - assert.deepEqual(error.refusal, refusal); - return true; + await new Promise((resolve, reject) => { + let stdout = ""; + const timer = setTimeout(() => reject(new Error(`control service readiness timed out: ${stderr}`)), 5000); + service.once("error", reject); + service.once("exit", () => { clearTimeout(timer); reject(new Error(`control service exited: ${stderr}`)); }); + service.stdout.on("data", chunk => { + stdout += chunk; + if (stdout.includes('"schema":"elastos.browser.vm-control-service.ready/v1"')) { + clearTimeout(timer); + resolve(); + } + }); }); + const body = JSON.stringify({ + schema: "elastos.browser.vm-engine.open/v1", + launch_request: { + schema: "elastos.browser.engine.launch-request/v1", + adapter: "browser-vm-product", engine: "chromium_microvm", + url: "https://example.com/", stream_id: "stream:refusal", + lifecycle_generation: "sha256:refusal", target: "tls://example.com:443", + principal_id: "person:local:refusal", network_mode: "runtime_net_only", + direct_network: false, wallet_injection: false, + display_mode: "webrtc_remote_display", guarantee_level: "mechanism_microvm", + }, + requirements: { + substrate: "microvm", display_mode: "webrtc_remote_display", + backend_class: "product_compositor", network_mode: "runtime_net_only", direct_network: false, + }, + }); + return new Promise((resolve, reject) => { + const request = http.request({ socketPath: socket, path: "/pages", method: "POST", + headers: { "content-type": "application/json", "content-length": Buffer.byteLength(body) }, + }, response => { + const chunks = []; + response.on("data", chunk => chunks.push(chunk)); + response.on("error", reject); + response.on("end", () => { + try { resolve({ status: response.statusCode, body: JSON.parse(Buffer.concat(chunks)) }); } + catch (error) { reject(error); } + }); + }); + request.setTimeout(5000, () => request.destroy(new Error("control service response timed out"))); + request.on("error", reject); + request.end(body); + }); +} + +test("control service response carries typed refusal code and counts from supervisor stderr", async t => { + const response = await controlServiceResponse(t, typed); + assert.equal(response.status, 400); + assert.equal(response.body.code, "launch_refused"); + assert.equal(response.body.message, "Browser cannot open."); + assert.deepEqual(response.body.refusal, refusal); }); + + +for (const [name, bad] of [ + ["unknown code", { ...refusal, code: "unknown" }], + ["string count", { ...refusal, required_bytes: "8589934592" }], + ["unsafe count", { ...refusal, required_bytes: 2 ** 53 }], + ["negative count", { ...refusal, available_bytes: -1 }], + ["equal counts", { ...refusal, available_bytes: refusal.required_bytes }], + ["extra field", { ...refusal, message: "private" }], +]) { + test(`control service response falls back for refusal with ${name}`, async t => { + const response = await controlServiceResponse(t, { ...typed, refusal: bad }); + assert.equal(response.status, 400); + assert.equal(response.body.code, "launch_refused"); + assert.equal(response.body.message, "Browser cannot open."); + assert.equal(response.body.refusal, undefined); + }); +} From 0494d7ccf210e430dfa45cc80e3f9fe183118d10 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 20:50:02 -0500 Subject: [PATCH 07/16] fix(browser): preserve transfer guidance and private open diagnostics Keep Runtime profile-placement refusals typed through Engine selection so Browser receives the existing transfer instructions. Retain Engine open diagnostics in private warnings with their HTTP status. Cover the foreign-placement route response, provider text that imitates transfer guidance, and log capture in an isolated test process. Preserve the existing Mac overlay boundary and error status classification. --- .../elastos-server/src/api/gateway_browser.rs | 69 ++++++++++++++++++- .../src/api/gateway_browser_remote.rs | 27 +++++++- .../src/api/gateway_browser_route_tests.rs | 45 ++++++++++++ 3 files changed, 137 insertions(+), 4 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 62d44c52a..3d5abc5cd 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -187,6 +187,7 @@ impl BrowserOpenFailure { fn provider(scheme: &str, err: anyhow::Error) -> Self { let (status, message) = gateway_provider_error_tuple(scheme, err); if scheme == "browser-engine" { + tracing::warn!(status = status.as_u16(), error = %message, "Browser Engine open failed"); Self::json( status, serde_json::json!({ @@ -658,7 +659,17 @@ async fn execute_browser_open( .await { Ok(choice) => choice, - Err(error) => return Err(BrowserOpenFailure::provider("browser-engine", error)), + Err(error) => { + if let Some(transfer) = + error.downcast_ref::() + { + return Err(BrowserOpenFailure::text( + StatusCode::INTERNAL_SERVER_ERROR, + transfer.to_string(), + )); + } + return Err(BrowserOpenFailure::provider("browser-engine", error)); + } }; let engine_route_provider = if let Some(choice) = &remote_choice { choice.2.clone() @@ -4676,6 +4687,7 @@ mod browser_open_outcome_tests { "invalid engine reply: /private/engine/rootfs.img", "page not found: /private/engine/rootfs.img", "engine failed: /private/engine/rootfs.img", + "This Browser profile requires an approved transfer: /private/engine/rootfs.img", ] { let expected_status = gateway_provider_error_tuple("browser-engine", anyhow::anyhow!(message)).0; @@ -4695,6 +4707,61 @@ mod browser_open_outcome_tests { } } + #[test] + fn engine_provider_constructor_logs_private_diagnostics() { + // Parallel route tests use this callsite too. Keep the capture in a + // fresh process with one subscriber and one selected test. + const CHILD: &str = "ELASTOS_TEST_BROWSER_OPEN_LOG_CHILD"; + if std::env::var_os(CHILD).is_none() { + let qualified = concat!( + module_path!(), + "::engine_provider_constructor_logs_private_diagnostics" + ); + let name = qualified.split_once("::").unwrap().1; + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", name, "--nocapture", "--color", "never"]) + .env(CHILD, "1") + .output() + .unwrap(); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success() && stdout.contains("1 passed;"), + "{stdout}\n{}", + String::from_utf8_lossy(&output.stderr) + ); + return; + } + #[derive(Clone)] + struct LogWriter(std::sync::Arc>>); + impl std::io::Write for LogWriter { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let output = std::sync::Arc::new(std::sync::Mutex::new(Vec::new())); + let writer = LogWriter(std::sync::Arc::clone(&output)); + let subscriber = tracing_subscriber::fmt() + .with_max_level(tracing::Level::WARN) + .with_ansi(false) + .without_time() + .with_writer(move || writer.clone()) + .finish(); + let _subscriber = tracing::subscriber::set_default(subscriber); + let message = "browser-engine provider unavailable: /private/engine/rootfs.img"; + let failure = BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)); + assert_eq!(failure.status, StatusCode::SERVICE_UNAVAILABLE); + assert!(!failure.status_value().to_string().contains(message)); + let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); + assert!(log.contains("WARN"), "{log}"); + assert!(log.contains("Browser Engine open failed"), "{log}"); + assert!(log.contains("status=503"), "{log}"); + assert!(log.contains(message), "{log}"); + } + #[test] fn engine_error_keeps_status_while_projection_keeps_diagnostics_private() { for (message, status) in [ diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs b/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs index 2eabff5bb..5c5e060bb 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs @@ -1601,6 +1601,27 @@ pub(super) fn unresolved_preparation( })) } +#[derive(Debug)] +pub(super) enum ProfileTransferRequired { + OwningRuntime, + BeforeRemotePlacement, +} + +impl std::fmt::Display for ProfileTransferRequired { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(match self { + Self::OwningRuntime => { + "This Browser profile requires an approved transfer from its owning Runtime" + } + Self::BeforeRemotePlacement => { + "This Browser profile requires an approved transfer before remote placement" + } + }) + } +} + +impl std::error::Error for ProfileTransferRequired {} + pub(super) fn require_profile_placement( data_dir: &FsPath, principal: &str, @@ -1618,7 +1639,7 @@ pub(super) fn require_profile_placement( !placements .iter() .any(|p| p.principal_id == principal && peer != Some(p.peer.as_str())), - "This Browser profile requires an approved transfer from its owning Runtime" + ProfileTransferRequired::OwningRuntime ); ensure!( !records @@ -1626,7 +1647,7 @@ pub(super) fn require_profile_placement( .any(|binding| binding.principal_id == principal && binding.dispatch_started && peer != binding.grant["peer_did"].as_str()), - "This Browser profile requires an approved transfer from its owning Runtime" + ProfileTransferRequired::OwningRuntime ); Ok(()) } @@ -1686,7 +1707,7 @@ pub(super) async fn select( browser_profile_launch_descriptor(&gateway.data_dir, &context.principal_id)?; ensure!( !local_profile.exists(), - "This Browser profile requires an approved transfer before remote placement" + ProfileTransferRequired::BeforeRemotePlacement ); Ok(Some((grant, adapter_id, id))) } diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index 33ef85ace..1f806c8a0 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -3414,6 +3414,51 @@ async fn test_browser_launch_response_loss_reconciles_and_closes_exact_effect() ); } +#[tokio::test] +async fn test_browser_open_preserves_profile_transfer_instruction() { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let state = browser_engine_attached_test_state(dir.path()).await; + let placements = dir + .path() + .join("Runtime/BrowserLifecycle/remote-engine-profiles"); + std::fs::create_dir_all(&placements).unwrap(); + std::fs::write( + placements.join("foreign.json"), + json!({"principal_id": authority.principal_id, "peer": "runtime-b"}).to_string(), + ) + .unwrap(); + let response = gateway_router(state) + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(Body::from( + r#"{"url":"https://placement.invalid/","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "This Browser profile requires an approved transfer from its owning Runtime" + ); + assert_eq!(payload["outcome"]["state"], "terminal_pre_effect_failure"); + assert_eq!(payload["outcome"]["effects"]["page_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["vm_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["stream_acquired"], false); + assert_eq!(browser_page_session_count(dir.path()).await, 0); +} + #[tokio::test] async fn test_browser_malformed_success_reconciles_instead_of_releasing_ownership() { let dir = tempfile::tempdir().unwrap(); From 1540c8646900af96ec9aee3104b9ea1a742b9078 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 22:51:24 -0500 Subject: [PATCH 08/16] fix(browser): project open diagnostics at one response boundary --- .../crates/elastos-server/src/api/gateway.rs | 9 +- .../elastos-server/src/api/gateway_browser.rs | 412 +++++++++++++----- .../src/api/gateway_browser_route_tests.rs | 203 +++++++++ 3 files changed, 508 insertions(+), 116 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway.rs b/elastos/crates/elastos-server/src/api/gateway.rs index b38d21375..ad5e9b7a1 100644 --- a/elastos/crates/elastos-server/src/api/gateway.rs +++ b/elastos/crates/elastos-server/src/api/gateway.rs @@ -1384,6 +1384,10 @@ fn gateway_provider_error_response(scheme: &str, err: anyhow::Error) -> Response } fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode, String) { + (gateway_provider_error_status(scheme, &err), err.to_string()) +} + +fn gateway_provider_error_status(scheme: &str, err: &anyhow::Error) -> StatusCode { let text = err.to_string(); let unavailable = format!("{scheme} provider unavailable"); let forbidden = text.contains("home launch token") @@ -1393,7 +1397,7 @@ fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode || text.contains("private host blocked") || text.contains("private IP blocked") || text.contains("private network"); - let status = if forbidden { + if forbidden { StatusCode::FORBIDDEN } else if text.contains(&unavailable) { StatusCode::SERVICE_UNAVAILABLE @@ -1408,8 +1412,7 @@ fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode StatusCode::BAD_REQUEST } else { StatusCode::INTERNAL_SERVER_ERROR - }; - (status, text) + } } fn inbox_error_response(err: anyhow::Error) -> Response { diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 3d5abc5cd..2574c9f99 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -86,8 +86,16 @@ pub(super) struct BrowserProviderResourceCall { pub(super) request: serde_json::Value, } +// Diagnostics stay private until the failure is consumed by status_value. +// Public messages accept only static copy or closed, typed public errors. #[derive(Debug)] struct BrowserOpenFailure { + diagnostic: anyhow::Error, + public: BrowserOpenPublicFailure, +} + +#[derive(Debug)] +struct BrowserOpenPublicFailure { status: StatusCode, body: BrowserOpenFailureBody, outcome: serde_json::Value, @@ -95,8 +103,49 @@ struct BrowserOpenFailure { #[derive(Debug)] enum BrowserOpenFailureBody { - Text(String), - Json(serde_json::Value), + Message { + code: BrowserOpenFailureCode, + message: &'static str, + }, + Compatibility(BrowserCompatibilityError), + Refused(elastos_common::browser_protocol::BrowserLaunchRefusal), + ExitPolicy { + url: String, + }, +} + +#[derive(Debug, Clone, Copy)] +enum BrowserOpenFailureCode { + RequestRejected, + RuntimeError, + ProviderError, + ProfileTransferRequired, + BrowserCapacityUnavailable, + ResourcesInUse, + ProfileRecoveryRequired, +} + +impl BrowserOpenFailureCode { + fn as_str(self) -> &'static str { + match self { + Self::RequestRejected => "request_rejected", + Self::RuntimeError => "runtime_error", + Self::ProviderError => "provider_error", + Self::ProfileTransferRequired => "profile_transfer_required", + Self::BrowserCapacityUnavailable => "browser_capacity_unavailable", + Self::ResourcesInUse => "resources_in_use", + Self::ProfileRecoveryRequired => "profile_recovery_required", + } + } + + fn capacity(code: &str) -> Option { + match code { + "browser_capacity_unavailable" => Some(Self::BrowserCapacityUnavailable), + "resources_in_use" => Some(Self::ResourcesInUse), + "profile_recovery_required" => Some(Self::ProfileRecoveryRequired), + _ => None, + } + } } fn browser_open_outcome( @@ -163,40 +212,102 @@ fn browser_launch_reconciliation_pending_outcome() -> serde_json::Value { } impl BrowserOpenFailure { - fn text(status: StatusCode, message: impl Into) -> Self { + fn new(status: StatusCode, public: BrowserOpenFailureBody, diagnostic: anyhow::Error) -> Self { Self { - status, - body: BrowserOpenFailureBody::Text(message.into()), - outcome: browser_terminal_pre_effect_outcome(), + diagnostic, + public: BrowserOpenPublicFailure { + status, + body: public, + outcome: browser_terminal_pre_effect_outcome(), + }, } } - fn json(status: StatusCode, body: serde_json::Value) -> Self { - Self { + fn message( + status: StatusCode, + code: BrowserOpenFailureCode, + message: &'static str, + diagnostic: anyhow::Error, + ) -> Self { + Self::new( status, - body: BrowserOpenFailureBody::Json(body), - outcome: browser_terminal_pre_effect_outcome(), - } + BrowserOpenFailureBody::Message { code, message }, + diagnostic, + ) + } + + fn request(message: &'static str, diagnostic: anyhow::Error) -> Self { + Self::message( + StatusCode::BAD_REQUEST, + BrowserOpenFailureCode::RequestRejected, + message, + diagnostic, + ) + } + + fn runtime(status: StatusCode, diagnostic: impl Into) -> Self { + let diagnostic = diagnostic.into(); + // Preserve Runtime admission guidance as fixed public copy. Even an + // unexpected engine diagnostic here can only select a fixed message. + let message = match diagnostic.as_str() { + "Browser lifecycle already owns a different open intent" => + "Browser lifecycle already owns a different open intent", + "Browser instance already owns an active or in-flight open" => + "Browser instance already owns an active or in-flight open", + "Browser instance already owns an active or launching lifecycle" => + "Browser instance already owns an active or launching lifecycle", + "Browser lifecycle is already active or launching for this verified launch" => + "Browser lifecycle is already active or launching for this verified launch", + "Browser cleanup is pending for this account; no replacement page may open before terminal provider closure" => + "Browser cleanup is pending for this account; wait for cleanup, then open Browser again.", + text if text.starts_with("Browser capacity unavailable:") => + "Browser capacity is full. Close an unused Browser page, then try again.", + _ => "Browser could not open. Try again.", + }; + Self::message( + status, + BrowserOpenFailureCode::RuntimeError, + message, + anyhow::anyhow!(diagnostic), + ) + } + + fn engine(status: StatusCode, diagnostic: anyhow::Error) -> Self { + Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "Browser Engine failed to start cleanly.", + diagnostic, + ) } fn with_outcome(mut self, outcome: serde_json::Value) -> Self { - self.outcome = outcome; + self.public.outcome = outcome; self } - fn provider(scheme: &str, err: anyhow::Error) -> Self { - let (status, message) = gateway_provider_error_tuple(scheme, err); - if scheme == "browser-engine" { - tracing::warn!(status = status.as_u16(), error = %message, "Browser Engine open failed"); - Self::json( + fn provider(scheme: &str, diagnostic: anyhow::Error) -> Self { + let status = gateway_provider_error_status(scheme, &diagnostic); + match scheme { + "browser-engine" => Self::engine(status, diagnostic), + "net" => Self::message( status, - serde_json::json!({ - "code": "provider_error", - "message": "Browser Engine failed to start cleanly.", - }), - ) - } else { - Self::text(status, message) + BrowserOpenFailureCode::ProviderError, + "net provider unavailable.", + diagnostic, + ), + "exit" => Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "exit provider unavailable. No Browser Exit provider is configured.", + diagnostic, + ), + _ => Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "Browser could not open. Try again.", + diagnostic, + ), } } @@ -205,32 +316,61 @@ impl BrowserOpenFailure { } fn into_response(self) -> Response { - let status = self.status; + let status = self.public.status; (status, Json(self.status_value())).into_response() } - fn status_value(&self) -> serde_json::Value { - let mut value = match &self.body { - BrowserOpenFailureBody::Text(message) => serde_json::json!({ - "schema": "elastos.browser.open-error/v1", - "ok": false, + // This consuming projection is the single diagnostic boundary for both + // direct HTTP failures and background open-job results. Polling reuses only + // the public value, so it cannot log the diagnostic again. + fn status_value(self) -> serde_json::Value { + let BrowserOpenPublicFailure { + status, + body, + outcome, + } = self.public; + let mut value = match body { + BrowserOpenFailureBody::Message { code, message } => serde_json::json!({ + "code": code.as_str(), "message": message, }), - BrowserOpenFailureBody::Json(body) => body.clone(), + BrowserOpenFailureBody::Compatibility(error) => { + let mut body = + serde_json::to_value(&error).expect("Browser compatibility error serializes"); + body["message"] = serde_json::json!(error.to_string()); + body["stage"] = serde_json::json!(if matches!( + error, + BrowserCompatibilityError::EngineNotReady { .. } + ) { + "engine_readiness" + } else { + "engine_compatibility" + }); + body + } + BrowserOpenFailureBody::Refused(refusal) => serde_json::json!({ + "code": "launch_refused", + "message": "Browser cannot open.", + "refusal": refusal, + }), + BrowserOpenFailureBody::ExitPolicy { url } => serde_json::json!({ + "code": "exit_policy_blocked", + "message": format!("Browser Exit policy blocked {url}. Runtime keeps direct host networking disabled."), + }), }; - if let Some(object) = value.as_object_mut() { - object - .entry("schema".to_string()) - .or_insert_with(|| serde_json::json!("elastos.browser.open-error/v1")); - object - .entry("ok".to_string()) - .or_insert_with(|| serde_json::json!(false)); - object.insert("outcome".to_string(), self.outcome.clone()); - object.insert( - "http_status".to_string(), - serde_json::json!(self.status.as_u16()), - ); - } + let code = value["code"] + .as_str() + .expect("closed Browser open failure code"); + tracing::warn!( + status = status.as_u16(), + code, + error = %format!("{:#}", self.diagnostic), + "Browser Engine open failed" + ); + value["schema"] = serde_json::json!("elastos.browser.open-error/v1"); + value["ok"] = serde_json::json!(false); + value["outcome"] = outcome; + value["http_status"] = serde_json::json!(status.as_u16()); value } } @@ -435,19 +575,27 @@ pub(super) async fn browser_app_open( let authority = match require_runtime_wallet_authority(&state.data_dir, &headers, &[BROWSER_CAPSULE_ID]) { Ok(authority) => authority, - Err(err) => return gateway_provider_error_response("browser", err), + Err(err) => return BrowserOpenFailure::provider("browser", err).into_response(), }; let context = authority.home_launch_context(); let home_token = home_launch_token_header(&headers); let request_origin = match browser_request_origin(&headers) { Ok(origin) => Some(origin), - Err(_) => return (StatusCode::BAD_REQUEST, "invalid gateway origin").into_response(), + Err(err) => { + return BrowserOpenFailure::request("invalid gateway origin", err).into_response() + } }; if input.async_open { let owner_launch_id = authority.verified_context().launch_id(); let browser_instance = match browser_instance_id(input.browser_instance.clone()) { Ok(value) => value, - Err(message) => return (StatusCode::BAD_REQUEST, message).into_response(), + Err(message) => { + return BrowserOpenFailure::request( + "invalid Browser instance binding", + anyhow::anyhow!(message), + ) + .into_response() + } }; let intent_hash = browser_open_intent_hash(&input); let reservation = match create_browser_open_job( @@ -460,7 +608,9 @@ pub(super) async fn browser_app_open( .await { Ok(reservation) => reservation, - Err((status, message)) => return (status, message).into_response(), + Err((status, message)) => { + return BrowserOpenFailure::runtime(status, message).into_response() + } }; let job = reservation.handle; let open_id = job.id.clone(); @@ -597,17 +747,15 @@ async fn execute_browser_open( } = input; let (url, target) = match browser_url_to_stream_target(&requested_url) { Ok(value) => value, - Err(err) => { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), - )) - } + Err(err) => return Err(BrowserOpenFailure::request( + "Only http and https addresses with a host and known port can be opened by Browser.", + err, + )), }; if let Err(err) = validate_browser_launch_contract(display_mode, guarantee_level) { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), + return Err(BrowserOpenFailure::request( + "Choose a supported display_mode and guarantee_level; operator_rbi requires webrtc_remote_display.", + err, )); } let registry = match state.provider_registry.as_ref().cloned() { @@ -627,23 +775,38 @@ async fn execute_browser_open( let stream_nonce = browser_stream_nonce(&open_request_id); let remote_exit_id = match browser_remote_exit_id(remote_exit_id) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid remote_exit_id", + anyhow::anyhow!(message), + )) + } }; let requested_adapter_id = match browser_engine_adapter_id(adapter_id) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid adapter_id", + anyhow::anyhow!(message), + )) + } }; let browser_instance = match browser_instance_id(browser_instance) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid Browser instance binding", + anyhow::anyhow!(message), + )) + } }; let viewport = match viewport { Some(viewport) => match browser_viewport_value(viewport) { Ok(value) => Some(value), Err(err) => { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), + return Err(BrowserOpenFailure::request( + "Browser viewport must be within 320x240 and 3840x2160.", + err, )) } }, @@ -663,9 +826,16 @@ async fn execute_browser_open( if let Some(transfer) = error.downcast_ref::() { - return Err(BrowserOpenFailure::text( + return Err(BrowserOpenFailure::message( StatusCode::INTERNAL_SERVER_ERROR, - transfer.to_string(), + BrowserOpenFailureCode::ProfileTransferRequired, + match transfer { + gateway_browser_remote::ProfileTransferRequired::OwningRuntime => + "This Browser profile requires an approved transfer from its owning Runtime", + gateway_browser_remote::ProfileTransferRequired::BeforeRemotePlacement => + "This Browser profile requires an approved transfer before remote placement", + }, + error, )); } return Err(BrowserOpenFailure::provider("browser-engine", error)); @@ -703,18 +873,11 @@ async fn execute_browser_open( let (adapter_id, verified_rootfs) = match resolved_adapter { Ok(adapter_id) => adapter_id, Err(error) => { - let mut body = - serde_json::to_value(&error).expect("Browser compatibility error serializes"); - body["message"] = serde_json::json!(error.to_string()); - body["stage"] = serde_json::json!(if matches!( - error, - BrowserCompatibilityError::EngineNotReady { .. } - ) { - "engine_readiness" - } else { - "engine_compatibility" - }); - return Err(BrowserOpenFailure::json(StatusCode::BAD_REQUEST, body)); + return Err(BrowserOpenFailure::new( + StatusCode::BAD_REQUEST, + BrowserOpenFailureBody::Compatibility(error.clone()), + error.into(), + )); } }; let (_, profile) = @@ -750,7 +913,7 @@ async fn execute_browser_open( let launch_reservation = match reserve_browser_launch(&state.data_dir, &context.principal_id, lifecycle).await { Ok(reservation) => reservation, - Err((status, message)) => return Err(BrowserOpenFailure::text(status, message)), + Err((status, message)) => return Err(BrowserOpenFailure::runtime(status, message)), }; if let Err((status, message)) = append_browser_effect_audit_or_500( &state.data_dir, @@ -768,7 +931,7 @@ async fn execute_browser_open( }, ) { release_browser_launch(&launch_reservation).await; - return Err(BrowserOpenFailure::text(status, message)); + return Err(BrowserOpenFailure::runtime(status, message)); } mark_browser_launch_preparing_image(&launch_reservation).await; let stream_request = serde_json::json!({ @@ -784,7 +947,11 @@ async fn execute_browser_open( Ok(receipt) => receipt, Err((provider, err)) => { release_browser_launch(&launch_reservation).await; - return Err(BrowserOpenFailure::provider(provider, err)); + let mut failure = BrowserOpenFailure::provider(provider, err); + if failure.public.status == StatusCode::FORBIDDEN { + failure.public.body = BrowserOpenFailureBody::ExitPolicy { url: url.clone() }; + } + return Err(failure); } }; let stream_cleanup = browser_stream_cleanup(&stream_session); @@ -952,7 +1119,7 @@ async fn execute_browser_open( false, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err(BrowserOpenFailure::runtime(status, message).with_outcome(outcome)); } }; if vz_transport_launch.is_some() { @@ -989,11 +1156,9 @@ async fn execute_browser_open( &message, ) .await; - return Err(BrowserOpenFailure::text( - status, - "Browser Engine failed to start cleanly.".to_string(), - ) - .with_outcome(outcome)); + return Err( + BrowserOpenFailure::engine(status, anyhow::anyhow!(message)).with_outcome(outcome) + ); } }; if engine_response @@ -1036,15 +1201,10 @@ async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::json( + return Err(BrowserOpenFailure::new( StatusCode::SERVICE_UNAVAILABLE, - serde_json::json!({ - "schema": "elastos.browser.open-error/v1", - "ok": false, - "code": "launch_refused", - "message": "Browser cannot open.", - "refusal": refusal, - }), + BrowserOpenFailureBody::Refused(refusal), + anyhow::anyhow!(message.to_string()), ) .with_outcome(outcome)); } @@ -1072,10 +1232,7 @@ async fn execute_browser_open( )) .with_outcome(outcome)); } - if matches!( - code, - "browser_capacity_unavailable" | "resources_in_use" | "profile_recovery_required" - ) { + if let Some(public_code) = BrowserOpenFailureCode::capacity(code) { let outcome = match exact_did_not_act { Some(outcome) => outcome, None => { @@ -1091,14 +1248,11 @@ async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::json( + return Err(BrowserOpenFailure::message( StatusCode::SERVICE_UNAVAILABLE, - serde_json::json!({ - "schema": "elastos.browser.open-error/v1", - "ok": false, - "code": code, - "message": "Browser launch refused.", - }), + public_code, + "Browser launch refused.", + anyhow::anyhow!(message.to_string()), ) .with_outcome(outcome)); } @@ -1467,7 +1621,7 @@ async fn execute_browser_open( true, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err(BrowserOpenFailure::runtime(status, message).with_outcome(outcome)); } Ok(serde_json::json!({ "schema": "elastos.browser.open-result/v1", @@ -4708,14 +4862,14 @@ mod browser_open_outcome_tests { } #[test] - fn engine_provider_constructor_logs_private_diagnostics() { + fn engine_failure_projection_logs_private_error_chain_once() { // Parallel route tests use this callsite too. Keep the capture in a // fresh process with one subscriber and one selected test. const CHILD: &str = "ELASTOS_TEST_BROWSER_OPEN_LOG_CHILD"; if std::env::var_os(CHILD).is_none() { let qualified = concat!( module_path!(), - "::engine_provider_constructor_logs_private_diagnostics" + "::engine_failure_projection_logs_private_error_chain_once" ); let name = qualified.split_once("::").unwrap().1; let output = std::process::Command::new(std::env::current_exe().unwrap()) @@ -4752,14 +4906,46 @@ mod browser_open_outcome_tests { .finish(); let _subscriber = tracing::subscriber::set_default(subscriber); let message = "browser-engine provider unavailable: /private/engine/rootfs.img"; - let failure = BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)); - assert_eq!(failure.status, StatusCode::SERVICE_UNAVAILABLE); + let failure = BrowserOpenFailure::provider( + "browser-engine", + anyhow::anyhow!(message) + .context("browser-engine provider unavailable: open request failed"), + ); + assert_eq!(failure.public.status, StatusCode::SERVICE_UNAVAILABLE); + assert!( + output.lock().unwrap().is_empty(), + "constructors keep diagnostics for the projection" + ); assert!(!failure.status_value().to_string().contains(message)); let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); assert!(log.contains("WARN"), "{log}"); assert!(log.contains("Browser Engine open failed"), "{log}"); assert!(log.contains("status=503"), "{log}"); assert!(log.contains(message), "{log}"); + assert!(log.contains("open request failed"), "{log}"); + assert_eq!( + log.matches("Browser Engine open failed").count(), + 1, + "{log}" + ); + } + + #[test] + fn runtime_admission_copy_keeps_diagnostic_text_private() { + let conflict = "Browser lifecycle already owns a different open intent"; + assert_eq!( + BrowserOpenFailure::runtime(StatusCode::CONFLICT, conflict).status_value()["message"], + conflict, + ); + for diagnostic in [ + format!("{conflict}: /private/engine/rootfs.img"), + "Browser capacity unavailable: /private/engine/rootfs.img".to_string(), + "/private/engine/rootfs.img".to_string(), + ] { + let public = BrowserOpenFailure::runtime(StatusCode::SERVICE_UNAVAILABLE, diagnostic) + .status_value(); + assert!(!public.to_string().contains("/private/engine/rootfs.img")); + } } #[test] @@ -4781,7 +4967,7 @@ mod browser_open_outcome_tests { ("private diagnostic", StatusCode::INTERNAL_SERVER_ERROR), ] { let failure = BrowserOpenFailure::engine_provider(message); - assert_eq!(failure.status, status); + assert_eq!(failure.public.status, status); assert_eq!( failure.status_value()["message"], "Browser Engine failed to start cleanly." @@ -4791,13 +4977,13 @@ mod browser_open_outcome_tests { #[test] fn failed_open_serializes_cleanup_pending_separately_from_pre_effect_failure() { - let pending = BrowserOpenFailure::text( + let pending = BrowserOpenFailure::runtime( StatusCode::SERVICE_UNAVAILABLE, "Browser cleanup remains owned by Runtime", ) .with_outcome(browser_cleanup_pending_outcome(true, true, false)) .status_value(); - let pre_effect = BrowserOpenFailure::text( + let pre_effect = BrowserOpenFailure::runtime( StatusCode::SERVICE_UNAVAILABLE, "Browser VM was not acquired", ) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index 1f806c8a0..d958df8f6 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -1,5 +1,208 @@ use super::*; +#[derive(Clone)] +struct BrowserOpenLogWriter(Arc>>); + +impl std::io::Write for BrowserOpenLogWriter { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +fn browser_open_route_log(test: &str) -> Option>>> { + // A fresh process gives spawned open jobs and the route one subscriber, + // independent of parallel tests and tracing's cached callsite interests. + const CHILD: &str = "ELASTOS_TEST_BROWSER_OPEN_ROUTE_LOG_CHILD"; + if std::env::var(CHILD).as_deref() != Ok(test) { + let name = format!("{}::{test}", module_path!()); + let name = name.split_once("::").unwrap().1; + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", name, "--nocapture", "--color", "never"]) + .env(CHILD, test) + .output() + .unwrap(); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success() && stdout.contains("1 passed;"), + "{stdout}\n{}", + String::from_utf8_lossy(&output.stderr) + ); + return None; + } + let output = Arc::new(std::sync::Mutex::new(Vec::new())); + let writer = BrowserOpenLogWriter(Arc::clone(&output)); + tracing::subscriber::set_global_default( + tracing_subscriber::fmt() + .with_max_level(tracing::Level::WARN) + .with_ansi(false) + .without_time() + .with_writer(move || writer.clone()) + .finish(), + ) + .unwrap(); + Some(output) +} + +async fn browser_open_failure_log_route( + async_open: bool, + url: &str, + diagnostic: &str, + code: &str, + log: &Arc>>, +) { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let (state, _, _) = browser_engine_reconciliation_test_state( + dir.path(), + if code == "provider_error" { + MockDispatchedBrowserLaunchFailure::ResponseLoss + } else { + MockDispatchedBrowserLaunchFailure::DidNotActResourcesInUse + }, + ) + .await; + let app = gateway_router(state); + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token.clone()) + .header(CONTENT_TYPE, "application/json") + .body(Body::from( + json!({ + "url": url, + "display_mode": "webrtc_remote_display", + "guarantee_level": "operator_rbi", + "async_open": async_open, + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!( + response.status(), + if async_open { + StatusCode::ACCEPTED + } else { + StatusCode::SERVICE_UNAVAILABLE + } + ); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let mut payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + if async_open { + let status_url = payload["status_url"].as_str().unwrap().to_string(); + let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(10); + loop { + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .uri(&status_url) + .header("x-elastos-home-token", token.clone()) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + payload = serde_json::from_slice(&body).unwrap(); + if payload["status"] == "failed" { + payload = payload["error"].take(); + break; + } + assert!(tokio::time::Instant::now() < deadline, "{payload}"); + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + } + let captured = String::from_utf8(log.lock().unwrap().clone()).unwrap(); + let events: Vec<_> = captured + .lines() + .filter(|line| line.contains("Browser Engine open failed")) + .collect(); + assert_eq!(events.len(), 1, "{captured}"); + let event = events[0]; + assert!(event.contains("WARN"), "{event}"); + assert!(event.contains("status=503"), "{event}"); + assert!(event.contains(&format!("code=\"{code}\"")), "{event}"); + assert!(event.contains(diagnostic), "{event}"); + // Assert the complete public projection, including cleanup ownership. + assert_eq!( + payload, + json!({ + "schema": "elastos.browser.open-error/v1", "ok": false, + "code": code, + "message": if code == "provider_error" { + "Browser Engine failed to start cleanly." + } else { + "Browser launch refused." + }, + "http_status": 503, + "outcome": { + "schema": "elastos.browser.open-outcome/v1", + "state": "terminal_post_effect_cleanup", + "effects": {"page_acquired": code == "provider_error", "vm_acquired": code == "provider_error", "stream_acquired": true}, + }, + }) + ); + assert_eq!( + browser_launch_reconciliation_obligation_count(dir.path()).await, + 0 + ); + log.lock().unwrap().clear(); +} + +#[tokio::test] +async fn test_browser_open_transport_failure_logs_private_diagnostic_once() { + let Some(log) = + browser_open_route_log("test_browser_open_transport_failure_logs_private_diagnostic_once") + else { + return; + }; + for async_open in [false, true] { + browser_open_failure_log_route( + async_open, + "https://response-loss.invalid/", + "simulated browser-engine launch response loss", + "provider_error", + &log, + ) + .await; + } +} + +#[tokio::test] +async fn test_browser_open_capacity_failure_logs_private_diagnostic_once() { + let Some(log) = + browser_open_route_log("test_browser_open_capacity_failure_logs_private_diagnostic_once") + else { + return; + }; + for async_open in [false, true] { + browser_open_failure_log_route( + async_open, + "https://resources-in-use.invalid/", + "simulated Browser VM resource lease conflict", + "resources_in_use", + &log, + ) + .await; + } +} + #[derive(Default)] struct InspectionTestProvider { calls: std::sync::atomic::AtomicUsize, From 13445f1d306bc2f54765078f76b33c9eb98db5f8 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 23:21:11 -0500 Subject: [PATCH 09/16] fix(browser): retain open failure results through resource cleanup --- elastos/crates/elastos-server/src/api/gateway_browser.rs | 6 +++++- .../elastos-server/src/api/gateway_browser_route_tests.rs | 2 ++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 2574c9f99..7542075f0 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -3497,7 +3497,6 @@ async fn release_browser_page_and_stream_for_principal( let _ = release_browser_page_for_principal(&state.data_dir, page_id, principal_id, owner_launch_id) .await; - forget_browser_open_job_for_owner(&state.data_dir, principal_id, owner_launch_id).await; cleanup_result } @@ -4224,6 +4223,11 @@ pub(super) async fn browser_app_page_close( } else { close_browser_stream_cleanup(&state, page_cleanup.stream_cleanup).await }; + // Explicit close owns result retirement. Automatic open-failure cleanup + // keeps the job so its pending callback can publish the public error. + forget_browser_open_job_for_owner(&state.data_dir, &principal_id, &cleanup_owner_launch_id) + .await; + let terminal = if engine_result.is_ok() && stream_result.is_ok() { commit_browser_terminal_cleanup( &state, diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index d958df8f6..ff6137410 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -116,9 +116,11 @@ async fn browser_open_failure_log_route( ) .await .unwrap(); + let status = response.status(); let body = axum::body::to_bytes(response.into_body(), 32768) .await .unwrap(); + assert_eq!(status, StatusCode::OK, "{}", String::from_utf8_lossy(&body)); payload = serde_json::from_slice(&body).unwrap(); if payload["status"] == "failed" { payload = payload["error"].take(); From 3e24f3f553507a07192fe3a15b8bf1bc23410d18 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Thu, 5 Nov 2026 23:59:39 -0500 Subject: [PATCH 10/16] fix(browser): retain provider causes through open projection --- .../elastos-server/src/api/gateway_browser.rs | 8 ++- .../src/api/gateway_browser_response.rs | 71 +++++++++++++------ .../src/api/gateway_browser_route_tests.rs | 31 ++++++++ 3 files changed, 84 insertions(+), 26 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 7542075f0..611ae9a4e 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -1143,9 +1143,10 @@ async fn execute_browser_open( ); } } - let engine_response = match browser_provider_resource_response(state, engine_call).await { + let engine_response = match browser_provider_resource_result(state, engine_call).await { Ok(value) => value, - Err((status, message)) => { + Err(failure) => { + let message = format!("{:#}", failure.diagnostic); let outcome = reconcile_dispatched_browser_launch_failure( state, &launch_reservation, @@ -1157,7 +1158,8 @@ async fn execute_browser_open( ) .await; return Err( - BrowserOpenFailure::engine(status, anyhow::anyhow!(message)).with_outcome(outcome) + BrowserOpenFailure::engine(failure.status, failure.diagnostic) + .with_outcome(outcome), ); } }; diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_response.rs b/elastos/crates/elastos-server/src/api/gateway_browser_response.rs index 4e7e9852e..3c256d79f 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_response.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_response.rs @@ -53,15 +53,34 @@ pub(in crate::api::gateway) fn browser_provider_resource_call( }) } +#[derive(Debug)] +pub(in crate::api::gateway) struct BrowserProviderResourceFailure { + pub(in crate::api::gateway) status: StatusCode, + pub(in crate::api::gateway) diagnostic: anyhow::Error, + response_message: String, +} + pub(in crate::api::gateway) async fn browser_provider_resource_response( state: &GatewayState, call: BrowserProviderResourceCall, ) -> Result { + browser_provider_resource_result(state, call) + .await + .map_err(|failure| (failure.status, failure.response_message)) +} + +// Keep the original cause until the operation chooses its public projection. +pub(in crate::api::gateway) async fn browser_provider_resource_result( + state: &GatewayState, + call: BrowserProviderResourceCall, +) -> Result { let registry = state.provider_registry.as_ref().ok_or_else(|| { - ( - StatusCode::SERVICE_UNAVAILABLE, - format!("{} provider unavailable", call.scheme), - ) + let response_message = format!("{} provider unavailable", call.scheme); + BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: anyhow::anyhow!(response_message.clone()), + response_message, + } })?; if call.scheme == "browser-engine" && (call.request.get("page_id").is_some() @@ -71,34 +90,40 @@ pub(in crate::api::gateway) async fn browser_provider_resource_response( Ok(Some(binding)) => { return gateway_browser_remote::dispatch_consumer(state, &binding, &call.request) .await - .map_err(|_| { - ( - StatusCode::SERVICE_UNAVAILABLE, - "Remote Runtime Engine operation is unavailable or pending settlement" - .into(), - ) + .map_err(|diagnostic| { + let message = + "Remote Runtime Engine operation is unavailable or pending settlement"; + BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: diagnostic.context(message), + response_message: message.into(), + } }) } Ok(None) => {} - Err(_) => { - return Err(( - StatusCode::SERVICE_UNAVAILABLE, - "Remote Runtime Engine ownership is unavailable".into(), - )) + Err(diagnostic) => { + let message = "Remote Runtime Engine ownership is unavailable"; + return Err(BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: diagnostic.context(message), + response_message: message.into(), + }); } } } registry .send_raw(call.scheme, &call.request) .await - .map_err(|err| { - ( - StatusCode::SERVICE_UNAVAILABLE, - format!( - "{} provider unavailable for {}: {}", - call.scheme, call.resource, err - ), - ) + .map_err(|diagnostic| BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + response_message: format!( + "{} provider unavailable for {}: {}", + call.scheme, call.resource, diagnostic + ), + diagnostic: anyhow::anyhow!(diagnostic).context(format!( + "{} provider unavailable for {}", + call.scheme, call.resource + )), }) } diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index ff6137410..f241079c8 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -10081,3 +10081,34 @@ async fn test_browser_operator_inspection_fill_bootstrap_and_detach_scope() { ); } } + +#[tokio::test] +async fn test_browser_open_provider_transport_preserves_remote_cause() { + let dir = tempfile::tempdir().unwrap(); + let state = browser_engine_attached_test_state(dir.path()).await; + let call = || BrowserProviderResourceCall { + scheme: "browser-engine", + resource: "elastos://browser-engine/launch".to_string(), + request: json!({"op": "launch", "lifecycle_generation": "test-generation"}), + }; + // The real remote-binding validator rejects this missing requester before + // dispatch. Its private cause must survive the adapter's public message. + let failure = browser_provider_resource_result(&state, call()) + .await + .unwrap_err(); + assert_eq!(failure.status, StatusCode::SERVICE_UNAVAILABLE); + let diagnostic = format!("{:#}", failure.diagnostic); + assert!( + diagnostic.contains("Browser requester required"), + "{diagnostic}" + ); + assert!( + diagnostic.contains("Remote Runtime Engine ownership is unavailable"), + "{diagnostic}" + ); + let (status, message) = browser_provider_resource_response(&state, call()) + .await + .unwrap_err(); + assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE); + assert_eq!(message, "Remote Runtime Engine ownership is unavailable"); +} From 48379fec1c3044d9668e7999bb2620dbc60fcb44 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 00:12:26 -0500 Subject: [PATCH 11/16] test(browser): import provider cause guard helpers explicitly --- .../elastos-server/src/api/gateway_browser_route_tests.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index f241079c8..4a6bcde8c 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -10084,6 +10084,11 @@ async fn test_browser_operator_inspection_fill_bootstrap_and_detach_scope() { #[tokio::test] async fn test_browser_open_provider_transport_preserves_remote_cause() { + use crate::api::gateway::gateway_browser::{ + browser_provider_resource_response, browser_provider_resource_result, + BrowserProviderResourceCall, + }; + let dir = tempfile::tempdir().unwrap(); let state = browser_engine_attached_test_state(dir.path()).await; let call = || BrowserProviderResourceCall { From 8444794dc923eb85ffceac67ccec5202cce308f3 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 00:17:50 -0500 Subject: [PATCH 12/16] fix(browser): keep public policy errors to the requested host --- .../elastos-server/src/api/gateway_browser.rs | 12 ++++++++---- .../src/api/gateway_browser_route_tests.rs | 13 ++++++++++++- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 611ae9a4e..461facb6d 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -110,7 +110,7 @@ enum BrowserOpenFailureBody { Compatibility(BrowserCompatibilityError), Refused(elastos_common::browser_protocol::BrowserLaunchRefusal), ExitPolicy { - url: String, + host: String, }, } @@ -353,9 +353,9 @@ impl BrowserOpenFailure { "message": "Browser cannot open.", "refusal": refusal, }), - BrowserOpenFailureBody::ExitPolicy { url } => serde_json::json!({ + BrowserOpenFailureBody::ExitPolicy { host } => serde_json::json!({ "code": "exit_policy_blocked", - "message": format!("Browser Exit policy blocked {url}. Runtime keeps direct host networking disabled."), + "message": format!("Browser Exit policy blocked {host}. Runtime keeps direct host networking disabled."), }), }; let code = value["code"] @@ -892,7 +892,11 @@ async fn execute_browser_open( let lifecycle = BrowserLaunchLifecycle { owner_launch_id: authority.verified_context().launch_id().to_string(), browser_instance: browser_instance.clone(), - url: url.clone(), + host: url::Url::parse(&url) + .expect("validated Browser URL") + .host_str() + .expect("validated Browser host") + .to_owned(), exit_id: browser_lifecycle_exit_id(remote_exit_id.as_deref()), engine_route_provider: engine_route_provider.clone(), selected_engine_adapter: Some(adapter_id.clone()), diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index 4a6bcde8c..c63d5edb7 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -1438,7 +1438,7 @@ async fn test_browser_open_returns_forbidden_when_exit_policy_blocks_host() { .header("x-elastos-home-token", token) .header(CONTENT_TYPE, "application/json") .body(Body::from( - r#"{"url":"https://whatismyip.com/","reason":"check exit IP","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, + r#"{"url":"https://fixture-user:fixture-password@whatismyip.com/fixture-path?token=fixture-query","reason":"check exit IP","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, )) .unwrap(), ) @@ -1451,6 +1451,17 @@ async fn test_browser_open_returns_forbidden_when_exit_policy_blocks_host() { let message = String::from_utf8(body.to_vec()).unwrap(); assert!(message.contains("whatismyip.com")); assert!(message.contains("direct host networking")); + for private in [ + "fixture-user", + "fixture-password", + "fixture-path", + "fixture-query", + ] { + assert!( + !message.contains(private), + "private URL parts in public error: {message}" + ); + } } #[tokio::test] From d84ff4ec46f20b275252b0ed58b24a80861af227 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 00:51:50 -0500 Subject: [PATCH 13/16] fix(browser): scope host extraction to the public policy error --- .../elastos-server/src/api/gateway_browser.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 461facb6d..efeca3f64 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -892,11 +892,7 @@ async fn execute_browser_open( let lifecycle = BrowserLaunchLifecycle { owner_launch_id: authority.verified_context().launch_id().to_string(), browser_instance: browser_instance.clone(), - host: url::Url::parse(&url) - .expect("validated Browser URL") - .host_str() - .expect("validated Browser host") - .to_owned(), + url: url.clone(), exit_id: browser_lifecycle_exit_id(remote_exit_id.as_deref()), engine_route_provider: engine_route_provider.clone(), selected_engine_adapter: Some(adapter_id.clone()), @@ -953,7 +949,13 @@ async fn execute_browser_open( release_browser_launch(&launch_reservation).await; let mut failure = BrowserOpenFailure::provider(provider, err); if failure.public.status == StatusCode::FORBIDDEN { - failure.public.body = BrowserOpenFailureBody::ExitPolicy { url: url.clone() }; + failure.public.body = BrowserOpenFailureBody::ExitPolicy { + host: url::Url::parse(&url) + .expect("validated Browser URL") + .host_str() + .expect("validated Browser host") + .to_owned(), + }; } return Err(failure); } From 5d71010e2605f42164b938dbcee76fc75ec8ef1f Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 02:31:02 -0500 Subject: [PATCH 14/16] test(browser): assert typed admission conflict responses --- .../elastos-server/src/api/gateway_browser_route_tests.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index c63d5edb7..7134f1030 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -2213,8 +2213,13 @@ async fn test_browser_async_open_rejects_second_owner_for_same_browser_instance( let second_body = axum::body::to_bytes(second.into_body(), usize::MAX) .await .unwrap(); + let conflict: serde_json::Value = serde_json::from_slice(&second_body).unwrap(); + assert_eq!(conflict["schema"], "elastos.browser.open-error/v1"); + assert_eq!(conflict["code"], "runtime_error"); + assert_eq!(conflict["http_status"], 409); + assert_eq!(conflict["outcome"]["state"], "terminal_pre_effect_failure"); assert_eq!( - String::from_utf8(second_body.to_vec()).unwrap(), + conflict["message"], "Browser instance already owns an active or in-flight open" ); From 9ac8c94a2c315fb4ac7c8383b607e6d3c4b81bb3 Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 05:53:51 -0500 Subject: [PATCH 15/16] fix(browser): preserve open failure recovery and ownership Restore Runtime-authored sign-in errors and plain open-job admission conflicts. Keep fixed Exit reasons and viewer-ingress guidance, log request and Runtime admission rejections at debug, and preserve remote preparation error chains. Test the route bodies with the real Browser consumers, including sign-in expiry after gateway admission. --- .../elastos-server/src/api/gateway_browser.rs | 85 ++++++-- .../src/api/gateway_browser_route_tests.rs | 201 +++++++++++++++++- 2 files changed, 264 insertions(+), 22 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index efeca3f64..2e524b739 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -299,9 +299,26 @@ impl BrowserOpenFailure { "exit" => Self::message( status, BrowserOpenFailureCode::ProviderError, - "exit provider unavailable. No Browser Exit provider is configured.", + match diagnostic.to_string().as_str() { + "Remote Carrier Exit is not permitted for this principal" => + "Remote Carrier Exit is not permitted for this principal", + "Remote Carrier Exit active stream quota is exhausted" => + "Remote Carrier Exit active stream quota is exhausted", + "Remote Carrier Exit grant is expired" => + "Remote Carrier Exit grant is expired", + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking" => + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking", + _ => "exit provider unavailable.", + }, diagnostic, ), + "browser" if diagnostic.to_string() == "Runtime viewer ingress capacity unavailable" => + Self::message( + status, + BrowserOpenFailureCode::RuntimeError, + "Runtime viewer ingress capacity unavailable", + diagnostic, + ), _ => Self::message( status, BrowserOpenFailureCode::ProviderError, @@ -361,12 +378,19 @@ impl BrowserOpenFailure { let code = value["code"] .as_str() .expect("closed Browser open failure code"); - tracing::warn!( - status = status.as_u16(), + if matches!( code, - error = %format!("{:#}", self.diagnostic), - "Browser Engine open failed" - ); + "request_rejected" | "runtime_error" | "profile_transfer_required" + ) { + tracing::debug!(status = status.as_u16(), code, "Browser open rejected"); + } else { + tracing::warn!( + status = status.as_u16(), + code, + error = %format!("{:#}", self.diagnostic), + "Browser Engine open failed" + ); + } value["schema"] = serde_json::json!("elastos.browser.open-error/v1"); value["ok"] = serde_json::json!(false); value["outcome"] = outcome; @@ -575,7 +599,7 @@ pub(super) async fn browser_app_open( let authority = match require_runtime_wallet_authority(&state.data_dir, &headers, &[BROWSER_CAPSULE_ID]) { Ok(authority) => authority, - Err(err) => return BrowserOpenFailure::provider("browser", err).into_response(), + Err(err) => return gateway_provider_error_response("browser", err), }; let context = authority.home_launch_context(); let home_token = home_launch_token_header(&headers); @@ -608,9 +632,7 @@ pub(super) async fn browser_app_open( .await { Ok(reservation) => reservation, - Err((status, message)) => { - return BrowserOpenFailure::runtime(status, message).into_response() - } + Err((status, message)) => return (status, message).into_response(), }; let job = reservation.handle; let open_id = job.id.clone(); @@ -1006,7 +1028,6 @@ async fn execute_browser_open( &profile, &stream_session, &serde_json::json!({"url":url,"viewport":viewport,"display_mode":display_mode,"guarantee_level":guarantee_level, "owner_launch_id":authority.verified_context().launch_id(),"browser_instance":browser_instance})).await .map(|(transport, viewer)| {remote_viewer = Some(viewer); Some(transport)}) - .map_err(|error| error.to_string()) } else { prepare_browser_vz_transport_launch( &state.data_dir, @@ -1023,10 +1044,11 @@ async fn execute_browser_open( .unwrap_or_default(), }, ) + .map_err(anyhow::Error::msg) }; let vz_transport_launch = match prepared_transport { Ok(launch) => launch, - Err(message) => { + Err(error) => { let outcome = release_browser_open_resources( state, &launch_reservation, @@ -1034,10 +1056,7 @@ async fn execute_browser_open( false, ) .await; - return Err( - BrowserOpenFailure::provider("browser", anyhow::anyhow!(message)) - .with_outcome(outcome), - ); + return Err(BrowserOpenFailure::provider("browser", error).with_outcome(outcome)); } }; if let Some(transport) = vz_transport_launch.as_ref() { @@ -4845,6 +4864,40 @@ fn browser_display_error_response(error: BrowserDisplayError) -> Response { mod browser_open_outcome_tests { use super::*; + #[test] + fn runtime_viewer_ingress_capacity_copy_keeps_its_cause_private() { + let diagnostic = anyhow::anyhow!("private listener configuration") + .context("Runtime viewer ingress capacity unavailable"); + let failure = BrowserOpenFailure::provider("browser", diagnostic); + assert_eq!(failure.diagnostic.chain().count(), 2); + let public = failure.status_value(); + assert_eq!( + public["message"], + "Runtime viewer ingress capacity unavailable" + ); + assert!(!public + .to_string() + .contains("private listener configuration")); + } + + #[test] + fn exit_failure_copy_preserves_each_known_reason_and_keeps_diagnostics_private() { + for message in [ + "Remote Carrier Exit is not permitted for this principal", + "Remote Carrier Exit active stream quota is exhausted", + "Remote Carrier Exit grant is expired", + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking", + ] { + let public = BrowserOpenFailure::provider("exit", anyhow::anyhow!(message)).status_value(); + assert_eq!(public["message"], message); + } + let public = BrowserOpenFailure::provider("exit", anyhow::anyhow!( + "exit provider unavailable: No Browser Exit provider is configured for stream; /private/exit/socket failed" + )).status_value(); + assert_eq!(public["message"], "exit provider unavailable."); + assert!(!public.to_string().contains("/private/exit/socket")); + } + #[tokio::test] async fn engine_provider_constructor_keeps_all_diagnostics_out_of_response_bodies() { for message in [ diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index 7134f1030..b95f939ee 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -1,8 +1,195 @@ use super::*; +fn browser_open_response_consumers(status: StatusCode, body: &[u8]) -> serde_json::Value { + use std::io::Write; + let mut child = std::process::Command::new("node") + .args([ + "--input-type=module", + "-e", + r#" +import { readFileSync } from 'node:fs'; +import { pathToFileURL } from 'node:url'; +const root = process.argv[1]; +const { friendlyOpenError, isAuthoritySessionError, runtimeOpenOutcome } = + await import(pathToFileURL(`${root}/capsules/browser/browser/browser-status.js`)); +const { browserOpenResponseEvidence } = + await import(pathToFileURL(`${root}/scripts/lib/browser-open-failure.mjs`)); +const { createRuntimeApi } = + await import(pathToFileURL(`${root}/capsules/browser/browser/browser-runtime-api.js`)); +const { status, body } = JSON.parse(readFileSync(0, 'utf8')); +globalThis.fetch = async () => new Response(body, { status }); +let error; +try { await createRuntimeApi({}).fetchJson('/api/apps/browser/open'); } +catch (failure) { error = failure; } +console.log(JSON.stringify({ + authority: isAuthoritySessionError(error), message: friendlyOpenError(error), + outcome: runtimeOpenOutcome(error), + evidence: await browserOpenResponseEvidence({ + json: async () => JSON.parse(body), text: async () => body, + }), +})); +"#, + ]) + .arg(concat!(env!("CARGO_MANIFEST_DIR"), "/../../..")) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::piped()) + .spawn() + .unwrap(); + child + .stdin + .take() + .unwrap() + .write_all( + json!({"status": status.as_u16(), "body": std::str::from_utf8(body).unwrap()}) + .to_string() + .as_bytes(), + ) + .unwrap(); + let output = child.wait_with_output().unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + serde_json::from_slice(&output.stdout).unwrap() +} + +#[tokio::test] +async fn test_browser_open_expired_token_reopens_from_home_without_engine_warning() { + let Some(log) = browser_open_route_log( + "test_browser_open_expired_token_reopens_from_home_without_engine_warning", + ) else { + return; + }; + for after_admission in [false, true] { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let context = + runtime_wallet_authority_for_app_token(dir.path(), BROWSER_CAPSULE_ID, &token) + .home_launch_context(); + let (app, token) = if after_admission { + (gateway_router(test_state(dir.path())), token) + } else { + // Mount the route itself: the outer admission gate deliberately + // gives an already-expired token a generic refusal. + ( + axum::Router::new() + .route( + "/api/apps/browser/open", + axum::routing::post(gateway_browser::browser_app_open), + ) + .with_state(test_state(dir.path())), + issue_expired_home_launch_token_with_context( + dir.path(), + BROWSER_CAPSULE_ID, + &context, + ) + .unwrap(), + ) + }; + let data_dir = dir.path().to_path_buf(); + let body = Body::from_stream(futures_lite::stream::unfold( + Some((data_dir, context)), + move |state| async move { + let (data_dir, context) = state?; + if after_admission { + // Real gateway admission passes first. Expire sign-in when + // JSON extraction reads the body, before the handler checks it. + let now = crate::auth::now_ts(); + let mut grant = + crate::auth::load_active_session_grant(&data_dir, &context.session_id, now) + .unwrap(); + grant.expires_at = now; + crate::auth::store_session_grant(&data_dir, grant).unwrap(); + } + Some((Ok::<_, std::io::Error>(axum::body::Bytes::from_static( + br#"{"url":"https://example.com/","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi","async_open":true}"#, + )), None)) + }, + )); + let response = app + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(body) + .unwrap(), + ) + .await + .unwrap(); + let status = response.status(); + assert_eq!(status, StatusCode::FORBIDDEN); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let consumer = browser_open_response_consumers(status, &body); + assert_eq!( + consumer["authority"], + true, + "{}", + String::from_utf8_lossy(&body) + ); + assert_eq!( + consumer["message"], + "Browser session expired. Reopening from Home..." + ); + } + assert!(!String::from_utf8(log.lock().unwrap().clone()) + .unwrap() + .contains("Browser Engine open failed")); +} + #[derive(Clone)] struct BrowserOpenLogWriter(Arc>>); +#[tokio::test] +async fn test_browser_open_validation_errors_do_not_warn_about_engine_failure() { + let Some(log) = browser_open_route_log( + "test_browser_open_validation_errors_do_not_warn_about_engine_failure", + ) else { + return; + }; + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let app = gateway_router(test_state(dir.path())); + for mut input in [ + json!({"url":"file:///private/browser"}), + json!({"url":"https://example.com/", "display_mode":"native_surface"}), + json!({"url":"https://example.com/", "async_open":true, "browser_instance":"invalid"}), + ] { + input + .as_object_mut() + .unwrap() + .entry("display_mode") + .or_insert(json!("webrtc_remote_display")); + input["guarantee_level"] = json!("operator_rbi"); + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token.clone()) + .header(CONTENT_TYPE, "application/json") + .body(Body::from(input.to_string())) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::BAD_REQUEST); + } + let captured = String::from_utf8(log.lock().unwrap().clone()).unwrap(); + assert!( + !captured.contains("Browser Engine open failed"), + "{captured}" + ); +} + impl std::io::Write for BrowserOpenLogWriter { fn write(&mut self, bytes: &[u8]) -> std::io::Result { self.0.lock().unwrap().extend_from_slice(bytes); @@ -2213,15 +2400,17 @@ async fn test_browser_async_open_rejects_second_owner_for_same_browser_instance( let second_body = axum::body::to_bytes(second.into_body(), usize::MAX) .await .unwrap(); - let conflict: serde_json::Value = serde_json::from_slice(&second_body).unwrap(); - assert_eq!(conflict["schema"], "elastos.browser.open-error/v1"); - assert_eq!(conflict["code"], "runtime_error"); - assert_eq!(conflict["http_status"], 409); - assert_eq!(conflict["outcome"]["state"], "terminal_pre_effect_failure"); assert_eq!( - conflict["message"], + std::str::from_utf8(&second_body).unwrap(), "Browser instance already owns an active or in-flight open" ); + let consumer = browser_open_response_consumers(StatusCode::CONFLICT, &second_body); + assert_eq!(consumer["outcome"], serde_json::Value::Null); + assert_eq!(consumer["authority"], false); + assert_eq!( + consumer["evidence"]["admission_reason"], + "instance_open_in_flight" + ); for _ in 0..20 { let auth_state = crate::auth::load_auth_state(dir.path()).unwrap(); From 50f0306eeb4a87a3373143c57c75f23533179c5a Mon Sep 17 00:00:00 2001 From: Anders Alm Date: Fri, 6 Nov 2026 08:07:59 -0500 Subject: [PATCH 16/16] fix(browser): retain Runtime fault diagnostics and Exit refusal Restore full private Runtime diagnostic chains at the single failure projection. Warn for fallback faults and keep specific Runtime refusals at debug. Preserve fixed public copy for a selected Exit node host-policy refusal. Regression evidence: 7 passed / 2 failed before; 9 passed after. Both pre-effect and post-cleanup audit failures log their cause exactly once at WARN. Checks: workspace and chain-provider fmt; server all-targets Clippy with -D warnings; server lib (3297 passed, 27 ignored), bin (217), integration (1); Browser Node (1284); source gate and behaviour (2199); git diff --check. All Cargo and suites ran through elastos-heavy. --- .../elastos-server/src/api/gateway_browser.rs | 83 +++++++++++++++++-- 1 file changed, 78 insertions(+), 5 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index 2e524b739..71768008c 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -308,6 +308,9 @@ impl BrowserOpenFailure { "Remote Carrier Exit grant is expired", "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking" => "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking", + text if text.starts_with("Selected Browser Exit node does not allow host ") + && text.ends_with("; exit-provider refuses direct host networking") => + "Selected Browser Exit node does not allow this host; exit-provider refuses direct host networking", _ => "exit provider unavailable.", }, diagnostic, @@ -378,11 +381,17 @@ impl BrowserOpenFailure { let code = value["code"] .as_str() .expect("closed Browser open failure code"); - if matches!( - code, - "request_rejected" | "runtime_error" | "profile_transfer_required" - ) { + if matches!(code, "request_rejected" | "profile_transfer_required") { tracing::debug!(status = status.as_u16(), code, "Browser open rejected"); + } else if code == "runtime_error" + && value["message"] != "Browser could not open. Try again." + { + tracing::debug!( + status = status.as_u16(), + code, + error = %format!("{:#}", self.diagnostic), + "Browser open rejected" + ); } else { tracing::warn!( status = status.as_u16(), @@ -4898,6 +4907,19 @@ mod browser_open_outcome_tests { assert!(!public.to_string().contains("/private/exit/socket")); } + #[test] + fn selected_exit_host_refusal_keeps_specific_public_copy() { + let diagnostic = anyhow::anyhow!("private Exit configuration").context( + "Selected Browser Exit node does not allow host example.com; exit-provider refuses direct host networking" + ); + let public = BrowserOpenFailure::provider("exit", diagnostic).status_value(); + assert_eq!( + public["message"], + "Selected Browser Exit node does not allow this host; exit-provider refuses direct host networking" + ); + assert!(!public.to_string().contains("private Exit configuration")); + } + #[tokio::test] async fn engine_provider_constructor_keeps_all_diagnostics_out_of_response_bodies() { for message in [ @@ -4964,7 +4986,7 @@ mod browser_open_outcome_tests { let output = std::sync::Arc::new(std::sync::Mutex::new(Vec::new())); let writer = LogWriter(std::sync::Arc::clone(&output)); let subscriber = tracing_subscriber::fmt() - .with_max_level(tracing::Level::WARN) + .with_max_level(tracing::Level::DEBUG) .with_ansi(false) .without_time() .with_writer(move || writer.clone()) @@ -4993,6 +5015,57 @@ mod browser_open_outcome_tests { 1, "{log}" ); + + for (status, message, outcome, level) in [ + ( + StatusCode::INTERNAL_SERVER_ERROR, + "Browser effect audit failed: audit storage unavailable", + browser_terminal_pre_effect_outcome(), + "WARN", + ), + ( + StatusCode::INTERNAL_SERVER_ERROR, + "Browser effect audit failed: audit storage unavailable", + browser_terminal_post_effect_outcome(), + "WARN", + ), + ( + StatusCode::CONFLICT, + "Browser lifecycle already owns a different open intent", + browser_terminal_pre_effect_outcome(), + "DEBUG", + ), + ] { + output.lock().unwrap().clear(); + let mut failure = + BrowserOpenFailure::runtime(status, message).with_outcome(outcome.clone()); + failure.diagnostic = failure.diagnostic.context("private Runtime fault context"); + assert!(output.lock().unwrap().is_empty()); + let public = failure.status_value(); + assert_eq!(public["http_status"], status.as_u16()); + assert_eq!(public["outcome"], outcome); + assert!(!public.to_string().contains("private Runtime fault context")); + if level == "WARN" { + assert_eq!(public["message"], "Browser could not open. Try again."); + assert!(!public.to_string().contains(message)); + } else { + assert_eq!(public["message"], message); + } + let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); + assert_eq!(log.lines().count(), 1, "{log}"); + assert!(log.contains(level), "{log}"); + assert!(log.contains("code=\"runtime_error\""), "{log}"); + assert!(log.contains("error="), "{log}"); + assert_eq!(log.matches(message).count(), 1, "{log}"); + assert_eq!( + log.matches("private Runtime fault context").count(), + 1, + "{log}" + ); + if level == "DEBUG" { + assert!(!log.contains("WARN"), "{log}"); + } + } } #[test]