Lightweight coding agent that runs in your terminal
Rust
Preserve Windows runtime registration failure diagnostics (#53426)
zm-oaif60516235442
diff --git a/codex-rs/windows-sandbox-service/src/registered_runtime.rs b/codex-rs/windows-sandbox-service/src/registered_runtime.rsindex cab3386bd3..abf1468d51 100644--- a/codex-rs/windows-sandbox-service/src/registered_runtime.rs+++ b/codex-rs/windows-sandbox-service/src/registered_runtime.rs@@ -39,6 +39,7 @@ use crate::package_lifecycle::with_owner_impersonation;mod known_folder;mod metadata;+mod registration_result;mod removal;pub(crate) use metadata::remove as remove_metadata;@@ -168,7 +169,7 @@ pub(crate) fn provision(// As with provisioning, retain the request's resources until Windows finishes.// A client timeout or an unreadable status cannot safely release the profile.let mut status_error_logged = false;- loop {+ let status = loop {if shutdown.load(Ordering::Acquire) {// The typed error bypasses all response conversion and cleanup. Keep the// in-flight operation and its profile alive until this own-process service exits.@@ -177,8 +178,12 @@ pub(crate) fn provision(}match operation.Status() {Ok(AsyncStatus::Started) => {}- Ok(AsyncStatus::Completed | AsyncStatus::Canceled | AsyncStatus::Error) => {- break;+ Ok(+ status @ (AsyncStatus::Completed+ | AsyncStatus::Canceled+ | AsyncStatus::Error),+ ) => {+ break status;}status => {if !status_error_logged {@@ -193,12 +198,8 @@ pub(crate) fn provision(}}std::thread::sleep(Duration::from_millis(50));- }- operation- .GetResults()- .and_then(|result| result.ExtendedErrorCode())- .and_then(windows::core::HRESULT::ok)- .context("finish managed runtime package registration")?;+ };+ registration_result::RegistrationResult::read(&operation, status).check()?;ensure!(registered_packages(&profile.user_sid, &family).context("verify managed runtime package registration")?diff --git a/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result.rs b/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result.rsnew file mode 100644index 0000000000..e186b4b34a--- /dev/null+++ b/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result.rs@@ -0,0 +1,80 @@+//! Retains the distinct native registration failure codes and deployment activity ID.+//! Diagnostic getters never replace the completion error or turn success into failure.+//! Free-form Windows ErrorText stays in Windows deployment diagnostics, not this summary.++use anyhow::Context;+use anyhow::Result;+use windows::Foundation::AsyncStatus;+use windows::Foundation::IAsyncOperationWithProgress;+use windows::Management::Deployment::DeploymentProgress;+use windows::Management::Deployment::DeploymentResult;+use windows::core::GUID;+use windows::core::HRESULT;++pub(super) struct RegistrationResult {+ status: AsyncStatus,+ async_error: windows::core::Result<HRESULT>,+ // Keep GetResults failure separate from failure to read ExtendedErrorCode.+ result: windows::core::Result<DeploymentDetails>,+}++struct DeploymentDetails {+ extended_error: windows::core::Result<HRESULT>,+ activity_id: windows::core::Result<GUID>,+}++impl RegistrationResult {+ /// The caller must first observe a terminal status while retaining the profile/token.+ pub(super) fn read(+ operation: &IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress>,+ status: AsyncStatus,+ ) -> Self {+ Self {+ status,+ async_error: operation.ErrorCode(),+ result: operation.GetResults().map(|result| DeploymentDetails {+ extended_error: result.ExtendedErrorCode(),+ activity_id: result.ActivityId(),+ }),+ }+ }++ pub(super) fn check(self) -> Result<()> {+ let Self {+ status,+ async_error,+ result,+ } = self;+ let async_error = match async_error {+ Ok(code) => format!("{code:?}"),+ Err(error) => format!("unavailable({:?})", error.code()),+ };+ let context = format!(+ "finish managed runtime package registration: status={} async_error={async_error}",+ status.0,+ );+ let details = result.map_err(|error| {+ let summary = format!("{context} phase=GetResults get_results={:?}", error.code());+ anyhow::Error::new(error).context(summary)+ })?;+ let activity_id = match details.activity_id {+ Ok(id) => format!("{id:?}"),+ Err(error) => format!("unavailable({:?})", error.code()),+ };+ let context = format!("{context} get_results=0x00000000 activity_id={activity_id}");+ let extended_error = details.extended_error.map_err(|error| {+ let summary = format!(+ "{context} phase=ExtendedErrorCode getter_error={:?}",+ error.code()+ );+ anyhow::Error::new(error).context(summary)+ })?;+ extended_error.ok().with_context(|| {+ format!("{context} phase=deployment extended_error={extended_error:?}")+ })+ }+}++#[cfg(test)]+#[path = "registration_result_tests.rs"]+mod tests;diff --git a/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result_tests.rs b/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result_tests.rsnew file mode 100644index 0000000000..5586b1fe6c--- /dev/null+++ b/codex-rs/windows-sandbox-service/src/registered_runtime/registration_result_tests.rs@@ -0,0 +1,93 @@+//! Completion diagnostics preserve native errors without depending on account mutation.++use super::*;+use pretty_assertions::assert_eq;++const ACCESS_DENIED: HRESULT = HRESULT(0x80070005_u32 as i32);+const CANCELED: HRESULT = HRESULT(0x800704C7_u32 as i32);+const ASYNC_FAILURE: HRESULT = HRESULT(0x80073D19_u32 as i32);+const DEPLOYMENT_FAILURE: HRESULT = HRESULT(0x80073D28_u32 as i32);++#[test]+fn retains_different_async_and_deployment_errors_with_activity() {+ let activity_id = GUID::from_u128(0x1b60fffa_59b3_0002_d8d5_611bb359dd01);+ let error = RegistrationResult {+ status: AsyncStatus::Error,+ async_error: Ok(ASYNC_FAILURE),+ result: Ok(DeploymentDetails {+ extended_error: Ok(DEPLOYMENT_FAILURE),+ activity_id: Ok(activity_id),+ }),+ }+ .check()+ .unwrap_err();+ assert_eq!(+ error.to_string(),+ format!(+ "finish managed runtime package registration: status=3 async_error={ASYNC_FAILURE:?} get_results=0x00000000 activity_id={activity_id:?} phase=deployment extended_error={DEPLOYMENT_FAILURE:?}"+ )+ );+ assert_eq!(+ error.downcast_ref::<windows::core::Error>().unwrap().code(),+ DEPLOYMENT_FAILURE+ );+}++#[test]+fn get_results_errors_keep_original_hresult_and_phase() {+ for (status, code) in [+ (AsyncStatus::Error, ACCESS_DENIED),+ (AsyncStatus::Canceled, CANCELED),+ ] {+ let error = RegistrationResult {+ status,+ async_error: Ok(code),+ result: Err(windows::core::Error::from_hresult(code)),+ }+ .check()+ .unwrap_err();+ assert_eq!(+ error.to_string(),+ format!(+ "finish managed runtime package registration: status={} async_error={code:?} phase=GetResults get_results={code:?}",+ status.0+ )+ );+ assert_eq!(+ error.downcast_ref::<windows::core::Error>().unwrap().code(),+ code+ );+ }+}++#[test]+fn diagnostic_getter_failures_do_not_mask_completion_or_leak_text() {+ let private_error = || windows::core::Error::new(ACCESS_DENIED, "private deployment path");+ for code in [HRESULT(0), CANCELED] {+ let result = RegistrationResult {+ status: AsyncStatus::Completed,+ async_error: Err(private_error()),+ result: Ok(DeploymentDetails {+ extended_error: code.ok().map(|()| code),+ activity_id: Err(private_error()),+ }),+ }+ .check();+ if code.is_err() {+ let error = result.unwrap_err();+ assert_eq!(+ error.to_string(),+ format!(+ "finish managed runtime package registration: status=1 async_error=unavailable({ACCESS_DENIED:?}) get_results=0x00000000 activity_id=unavailable({ACCESS_DENIED:?}) phase=ExtendedErrorCode getter_error={CANCELED:?}"+ )+ );+ assert_eq!(+ error.downcast_ref::<windows::core::Error>().unwrap().code(),+ CANCELED+ );+ assert!(!format!("{error:#}").contains("private deployment path"));+ } else {+ assert_eq!(result.unwrap(), ());+ }+ }+}