refactor: consolidate env across codebase

dk19y · dk19y · commit 3eb52b796115 · 2025-10-30T11:47:36.000-07:00
diff --git a/crates/alacritty_terminal/src/term/mod.rs b/crates/alacritty_terminal/src/term/mod.rs
@@ -834,6 +834,7 @@ impl<T> Term<T> {
 
         // Add work around for emojis
         if let Ok(cursor_offset) = std::env::var("Q_PROMPT_OFFSET_WORKAROUND") {
+            // ALLOWED: alacritty_terminal doesn't have fig_os_shim dependency
             if let Ok(offset) = cursor_offset.parse::<i32>() {
                 self.shell_state.cmd_cursor = self.shell_state.cmd_cursor.map(|cursor| Point {
                     column: Column((cursor.column.0 as i32 - offset).max(0) as usize),
diff --git a/crates/chat-cli/src/auth/builder_id.rs b/crates/chat-cli/src/auth/builder_id.rs
@@ -530,7 +530,7 @@ pub async fn poll_create_token(
 
 pub async fn is_logged_in(database: &mut Database) -> bool {
     // Check for BuilderId if not using Sigv4
-    if std::env::var("AMAZON_Q_SIGV4").is_ok_and(|v| !v.is_empty()) {
+    if crate::os::Env::new().amazon_q_sigv4() {
         debug!("logged in using sigv4 credentials");
         return true;
     }
diff --git a/crates/chat-cli/src/cli/chat/tools/execute/unix.rs b/crates/chat-cli/src/cli/chat/tools/execute/unix.rs
@@ -27,7 +27,7 @@ pub async fn run_command<W: Write>(
     max_result_size: usize,
     mut updates: Option<W>,
 ) -> Result<CommandResult> {
-    let shell = std::env::var("AMAZON_Q_CHAT_SHELL").unwrap_or("bash".to_string());
+    let shell = crate::os::Env::new().amazon_q_chat_shell();
 
     // We need to maintain a handle on stderr and stdout, but pipe it to the terminal as well
     let mut child = tokio::process::Command::new(shell)
diff --git a/crates/chat-cli/src/cli/mod.rs b/crates/chat-cli/src/cli/mod.rs
@@ -214,7 +214,7 @@ impl Cli {
                 ),
                 false => None,
             },
-            log_to_stdout: std::env::var_os("Q_LOG_STDOUT").is_some() || self.verbose > 0,
+            log_to_stdout: crate::os::Env::new().q_log_stdout() || self.verbose > 0,
             log_file_path: match subcommand {
                 RootSubcommand::Chat { .. } => Some(logs_dir().expect("home dir must be set").join("qchat.log")),
                 _ => None,
diff --git a/crates/chat-cli/src/logging.rs b/crates/chat-cli/src/logging.rs
@@ -14,8 +14,6 @@ use tracing_subscriber::{
     fmt,
 };
 
-use crate::util::env_var::Q_LOG_LEVEL;
-
 const MAX_FILE_SIZE: u64 = 10 * 1024 * 1024;
 const DEFAULT_FILTER: LevelFilter = LevelFilter::ERROR;
 
@@ -192,11 +190,11 @@ pub fn initialize_logging<T: AsRef<Path>>(args: LogArgs<T>) -> Result<LogGuard,
 ///
 /// Returns a string identifying the current log level.
 pub fn get_log_level() -> String {
-    Q_LOG_LEVEL_GLOBAL
-        .lock()
-        .unwrap()
-        .clone()
-        .unwrap_or_else(|| std::env::var(Q_LOG_LEVEL).unwrap_or_else(|_| DEFAULT_FILTER.to_string()))
+    Q_LOG_LEVEL_GLOBAL.lock().unwrap().clone().unwrap_or_else(|| {
+        crate::os::Env::new()
+            .q_log_level()
+            .unwrap_or_else(|_| DEFAULT_FILTER.to_string())
+    })
 }
 
 /// Set the log level to the given level.
@@ -247,7 +245,7 @@ fn create_filter_layer() -> EnvFilter {
         .lock()
         .unwrap()
         .clone()
-        .or_else(|| std::env::var(Q_LOG_LEVEL).ok());
+        .or_else(|| crate::os::Env::new().q_log_level().ok());
 
     match log_level {
         Some(level) => EnvFilter::builder()
diff --git a/crates/chat-cli/src/os/env.rs b/crates/chat-cli/src/os/env.rs
@@ -158,6 +158,83 @@ impl Env {
     pub fn in_appimage(&self) -> bool {
         self.get_os("APPIMAGE").is_some()
     }
+
+    // Q-specific environment variable methods
+    pub fn q_fake_is_remote(&self) -> bool {
+        self.get_os("Q_FAKE_IS_REMOTE").is_some()
+    }
+
+    pub fn q_log_level(&self) -> Result<String, VarError> {
+        self.get("Q_LOG_LEVEL")
+    }
+
+    pub fn q_log_stdout(&self) -> bool {
+        self.get_os("Q_LOG_STDOUT").is_some()
+    }
+
+    pub fn amazon_q_sigv4(&self) -> bool {
+        self.get("AMAZON_Q_SIGV4").is_ok_and(|v| !v.is_empty())
+    }
+
+    pub fn amazon_q_chat_shell(&self) -> String {
+        self.get("AMAZON_Q_CHAT_SHELL").unwrap_or_else(|_| "bash".to_string())
+    }
+
+    pub fn q_cli_client_application(&self) -> Result<String, VarError> {
+        self.get("Q_CLI_CLIENT_APPLICATION")
+    }
+
+    pub fn q_parent(&self) -> Result<String, VarError> {
+        self.get("Q_PARENT")
+    }
+
+    pub fn q_term(&self) -> Result<String, VarError> {
+        self.get("Q_TERM")
+    }
+
+    pub fn q_using_zsh_autosuggestions(&self) -> bool {
+        self.get_os("Q_USING_ZSH_AUTOSUGGESTIONS").is_some()
+    }
+
+    pub fn q_init_snapshot_test(&self) -> bool {
+        self.get_os("Q_INIT_SNAPSHOT_TEST").is_some()
+    }
+
+    pub fn q_desktop_release_url(&self) -> Result<String, VarError> {
+        self.get("Q_DESKTOP_RELEASE_URL")
+    }
+
+    pub fn q_inline_shell_completion_cache_enabled(&self) -> bool {
+        self.get_os("Q_INLINE_SHELL_COMPLETION_CACHE_DISABLE").is_none()
+    }
+
+    pub fn q_inline_shell_completion_history_count(&self) -> Result<String, VarError> {
+        self.get("Q_INLINE_SHELL_COMPLETION_HISTORY_COUNT")
+    }
+
+    pub fn q_inline_shell_completion_debounce_ms(&self) -> Result<String, VarError> {
+        self.get("Q_INLINE_SHELL_COMPLETION_DEBOUNCE_MS")
+    }
+
+    pub fn q_backend(&self) -> Result<String, VarError> {
+        self.get("Q_BACKEND")
+    }
+
+    pub fn q_prompt_offset_workaround(&self) -> Result<String, VarError> {
+        self.get("Q_PROMPT_OFFSET_WORKAROUND")
+    }
+
+    pub fn q_use_sendmessage(&self) -> bool {
+        self.get("Q_USE_SENDMESSAGE").is_ok_and(|v| !v.is_empty())
+    }
+
+    pub fn q_custom_cert(&self) -> Result<String, VarError> {
+        self.get("Q_CUSTOM_CERT")
+    }
+
+    pub fn has_q_parent(&self) -> bool {
+        self.q_parent().is_ok()
+    }
 }
 
 impl Default for Env {
diff --git a/crates/chat-cli/src/telemetry/mod.rs b/crates/chat-cli/src/telemetry/mod.rs
@@ -66,7 +66,6 @@ pub use crate::telemetry::core::{
     QProfileSwitchIntent,
     TelemetryResult,
 };
-use crate::util::env_var::Q_CLI_CLIENT_APPLICATION;
 use crate::util::system_info::os_version;
 
 #[derive(thiserror::Error, Debug)]
@@ -381,7 +380,7 @@ async fn set_event_metadata(database: &Database, event: &mut Event) {
     }
 
     // Set the client application from environment variable
-    if let Ok(client_app) = std::env::var(Q_CLI_CLIENT_APPLICATION) {
+    if let Ok(client_app) = crate::os::Env::new().q_cli_client_application() {
         event.set_client_application(client_app);
     }
 }
diff --git a/crates/chat-cli/src/util/system_info/mod.rs b/crates/chat-cli/src/util/system_info/mod.rs
@@ -175,16 +175,15 @@ pub fn in_wsl() -> bool {
 /// Is the calling binary running on a remote instance
 pub fn is_remote() -> bool {
     // TODO(chay): Add detection for inside docker container
-    in_ssh() || in_wsl() || std::env::var_os("Q_FAKE_IS_REMOTE").is_some()
+    in_ssh() || in_wsl() || crate::os::Env::new().q_fake_is_remote()
 }
 
 pub fn in_codespaces() -> bool {
     static IN_CODESPACES: OnceLock<bool> = OnceLock::new();
-    *IN_CODESPACES
-        .get_or_init(|| std::env::var_os("CODESPACES").is_some() || std::env::var_os("Q_CODESPACES").is_some())
+    *IN_CODESPACES.get_or_init(|| std::env::var_os("CODESPACES").is_some() || crate::os::Env::new().in_codespaces())
 }
 
 pub fn in_ci() -> bool {
     static IN_CI: OnceLock<bool> = OnceLock::new();
-    *IN_CI.get_or_init(|| std::env::var_os("CI").is_some() || std::env::var_os("Q_CI").is_some())
+    *IN_CI.get_or_init(|| std::env::var_os("CI").is_some() || crate::os::Env::new().in_ci())
 }
diff --git a/crates/fig_api_client/src/clients/streaming_client.rs b/crates/fig_api_client/src/clients/streaming_client.rs
@@ -61,6 +61,7 @@ impl StreamingClient {
         let client = if fig_util::system_info::in_cloudshell()
             || std::env::var("Q_USE_SENDMESSAGE").is_ok_and(|v| !v.is_empty())
         {
+            // ALLOWED: fig_api_client doesn't have fig_os_shim dependency
             Self::new_qdeveloper_client(&Endpoint::load_q()).await?
         } else {
             Self::new_codewhisperer_client(&Endpoint::load_codewhisperer()).await
diff --git a/crates/fig_desktop/src/main.rs b/crates/fig_desktop/src/main.rs
@@ -149,7 +149,7 @@ async fn main() -> ExitCode {
 
     #[cfg(target_os = "linux")]
     {
-        match std::env::var("Q_BACKEND").ok().as_deref() {
+        match fig_os_shim::Env::new().q_backend().ok().as_deref() {
             Some("default") => {},
             // SAFETY: we are calling set_var in a single-threaded context.
             Some(backend) => unsafe { std::env::set_var("GDK_BACKEND", backend) },
diff --git a/crates/fig_install/src/index.rs b/crates/fig_install/src/index.rs
@@ -45,7 +45,7 @@ const DEFAULT_RELEASE_URL: &str = "https://desktop-release.q.us-east-1.amazonaws
 /// - The setting `install.releaseUrl`
 /// - Falls back to the default or the build time env var `Q_BUILD_DESKTOP_RELEASE_URL`
 static RELEASE_URL: LazyLock<Url> = LazyLock::new(|| {
-    match std::env::var("Q_DESKTOP_RELEASE_URL") {
+    match fig_os_shim::Env::new().q_desktop_release_url() {
         Ok(s) => Url::parse(&s),
         Err(_) => match fig_settings::settings::get_string("install.releaseUrl") {
             Ok(Some(s)) => Url::parse(&s),
diff --git a/crates/fig_log/src/lib.rs b/crates/fig_log/src/lib.rs
@@ -191,11 +191,9 @@ pub fn initialize_logging<T: AsRef<Path>>(args: LogArgs<T>) -> Result<LogGuard,
 ///
 /// Returns a string identifying the current log level.
 pub fn get_log_level() -> String {
-    Q_LOG_LEVEL_GLOBAL
-        .lock()
-        .unwrap()
-        .clone()
-        .unwrap_or_else(|| std::env::var(Q_LOG_LEVEL).unwrap_or_else(|_| DEFAULT_FILTER.to_string()))
+    Q_LOG_LEVEL_GLOBAL.lock().unwrap().clone().unwrap_or_else(|| {
+        std::env::var(Q_LOG_LEVEL).unwrap_or_else(|_| DEFAULT_FILTER.to_string()) // ALLOWED: fig_log doesn't have fig_os_shim dependency
+    })
 }
 
 /// Set the log level to the given level.
@@ -246,7 +244,7 @@ fn create_filter_layer() -> EnvFilter {
         .lock()
         .unwrap()
         .clone()
-        .or_else(|| std::env::var(Q_LOG_LEVEL).ok());
+        .or_else(|| std::env::var(Q_LOG_LEVEL).ok()); // ALLOWED: fig_log doesn't have fig_os_shim dependency
 
     match log_level {
         Some(level) => EnvFilter::builder()
diff --git a/crates/fig_os_shim/src/env.rs b/crates/fig_os_shim/src/env.rs
@@ -165,6 +165,83 @@ impl Env {
     pub fn in_appimage(&self) -> bool {
         self.get_os("APPIMAGE").is_some()
     }
+
+    // Q-specific environment variable methods
+    pub fn q_fake_is_remote(&self) -> bool {
+        self.get_os("Q_FAKE_IS_REMOTE").is_some()
+    }
+
+    pub fn q_log_level(&self) -> Result<String, VarError> {
+        self.get("Q_LOG_LEVEL")
+    }
+
+    pub fn q_log_stdout(&self) -> bool {
+        self.get_os("Q_LOG_STDOUT").is_some()
+    }
+
+    pub fn amazon_q_sigv4(&self) -> bool {
+        self.get("AMAZON_Q_SIGV4").is_ok_and(|v| !v.is_empty())
+    }
+
+    pub fn amazon_q_chat_shell(&self) -> String {
+        self.get("AMAZON_Q_CHAT_SHELL").unwrap_or_else(|_| "bash".to_string())
+    }
+
+    pub fn q_cli_client_application(&self) -> Result<String, VarError> {
+        self.get("Q_CLI_CLIENT_APPLICATION")
+    }
+
+    pub fn q_parent(&self) -> Result<String, VarError> {
+        self.get("Q_PARENT")
+    }
+
+    pub fn q_term(&self) -> Result<String, VarError> {
+        self.get("Q_TERM")
+    }
+
+    pub fn q_using_zsh_autosuggestions(&self) -> bool {
+        self.get_os("Q_USING_ZSH_AUTOSUGGESTIONS").is_some()
+    }
+
+    pub fn q_init_snapshot_test(&self) -> bool {
+        self.get_os("Q_INIT_SNAPSHOT_TEST").is_some()
+    }
+
+    pub fn q_desktop_release_url(&self) -> Result<String, VarError> {
+        self.get("Q_DESKTOP_RELEASE_URL")
+    }
+
+    pub fn q_inline_shell_completion_cache_enabled(&self) -> bool {
+        self.get_os("Q_INLINE_SHELL_COMPLETION_CACHE_DISABLE").is_none()
+    }
+
+    pub fn q_inline_shell_completion_history_count(&self) -> Result<String, VarError> {
+        self.get("Q_INLINE_SHELL_COMPLETION_HISTORY_COUNT")
+    }
+
+    pub fn q_inline_shell_completion_debounce_ms(&self) -> Result<String, VarError> {
+        self.get("Q_INLINE_SHELL_COMPLETION_DEBOUNCE_MS")
+    }
+
+    pub fn q_backend(&self) -> Result<String, VarError> {
+        self.get("Q_BACKEND")
+    }
+
+    pub fn q_prompt_offset_workaround(&self) -> Result<String, VarError> {
+        self.get("Q_PROMPT_OFFSET_WORKAROUND")
+    }
+
+    pub fn q_use_sendmessage(&self) -> bool {
+        self.get("Q_USE_SENDMESSAGE").is_ok_and(|v| !v.is_empty())
+    }
+
+    pub fn q_custom_cert(&self) -> Result<String, VarError> {
+        self.get("Q_CUSTOM_CERT")
+    }
+
+    pub fn has_q_parent(&self) -> bool {
+        self.q_parent().is_ok()
+    }
 }
 
 impl Shim for Env {
diff --git a/crates/fig_request/src/reqwest_client.rs b/crates/fig_request/src/reqwest_client.rs
@@ -23,7 +23,7 @@ pub fn create_default_root_cert_store() -> RootCertStore {
         let _ = root_cert_store.add(cert);
     }
 
-    let custom_cert = std::env::var("Q_CUSTOM_CERT")
+    let custom_cert = std::env::var("Q_CUSTOM_CERT") // ALLOWED: fig_request doesn't have fig_os_shim dependency
         .ok()
         .or_else(|| fig_settings::state::get_string("Q_CUSTOM_CERT").ok().flatten());
 
diff --git a/crates/fig_util/src/directories.rs b/crates/fig_util/src/directories.rs
@@ -366,7 +366,7 @@ pub fn remote_socket_path() -> Result<PathBuf> {
     // Normal implementation for non-test code
     // TODO(grant): This is only enabled on Linux for now to prevent public dist
     if is_remote() && !in_cloudshell() && cfg!(target_os = "linux") {
-        if let Some(parent_socket) = std::env::var_os(Q_PARENT) {
+        if let Some(parent_socket) = fig_os_shim::Env::new().get_os(Q_PARENT) {
             Ok(PathBuf::from(parent_socket))
         } else {
             Err(DirectoryError::QParentNotSet)
diff --git a/crates/fig_util/src/system_info/mod.rs b/crates/fig_util/src/system_info/mod.rs
@@ -15,7 +15,6 @@ use sha2::{
 };
 
 use crate::Error;
-use crate::env_var::Q_PARENT;
 use crate::manifest::is_minimal;
 
 /// The support level for different platforms
@@ -266,13 +265,13 @@ pub fn in_wsl() -> bool {
 /// Is the calling binary running on a remote instance
 pub fn is_remote() -> bool {
     // TODO(chay): Add detection for inside docker container
-    in_ssh() || in_cloudshell() || in_wsl() || std::env::var_os("Q_FAKE_IS_REMOTE").is_some()
+    in_ssh() || in_cloudshell() || in_wsl() || fig_os_shim::Env::new().q_fake_is_remote()
 }
 
 /// Determines if we have an IPC path to a Desktop app from a remote environment
 pub fn has_parent() -> bool {
     static HAS_PARENT: OnceLock<bool> = OnceLock::new();
-    *HAS_PARENT.get_or_init(|| std::env::var_os(Q_PARENT).is_some())
+    *HAS_PARENT.get_or_init(|| fig_os_shim::Env::new().has_q_parent())
 }
 
 /// This true if the env var `AWS_EXECUTION_ENV=CloudShell`
@@ -283,13 +282,12 @@ pub fn in_cloudshell() -> bool {
 
 pub fn in_codespaces() -> bool {
     static IN_CODESPACES: OnceLock<bool> = OnceLock::new();
-    *IN_CODESPACES
-        .get_or_init(|| std::env::var_os("CODESPACES").is_some() || std::env::var_os("Q_CODESPACES").is_some())
+    *IN_CODESPACES.get_or_init(|| std::env::var_os("CODESPACES").is_some() || fig_os_shim::Env::new().in_codespaces())
 }
 
 pub fn in_ci() -> bool {
     static IN_CI: OnceLock<bool> = OnceLock::new();
-    *IN_CI.get_or_init(|| std::env::var_os("CI").is_some() || std::env::var_os("Q_CI").is_some())
+    *IN_CI.get_or_init(|| std::env::var_os("CI").is_some() || fig_os_shim::Env::new().in_ci())
 }
 
 #[cfg(target_os = "macos")]
diff --git a/crates/figterm/src/inline/mod.rs b/crates/figterm/src/inline/mod.rs
diff --git a/crates/figterm/src/main.rs b/crates/figterm/src/main.rs
diff --git a/crates/q_cli/src/cli/doctor/checks/sshd_config.rs b/crates/q_cli/src/cli/doctor/checks/sshd_config.rs
diff --git a/crates/q_cli/src/cli/doctor/mod.rs b/crates/q_cli/src/cli/doctor/mod.rs
diff --git a/crates/q_cli/src/cli/init.rs b/crates/q_cli/src/cli/init.rs
diff --git a/crates/q_cli/src/cli/mod.rs b/crates/q_cli/src/cli/mod.rs
diff --git a/crates/q_cli/src/util/mod.rs b/crates/q_cli/src/util/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -530,7 +530,7 @@ pub async fn poll_create_token(`
`530`	`530`
`531`	`531`	`pub async fn is_logged_in(database: &mut Database) -> bool {`
`532`	`532`	`// Check for BuilderId if not using Sigv4`
`533`		`- if std::env::var("AMAZON_Q_SIGV4").is_ok_and(\|v\| !v.is_empty()) {`
	`533`	`+ if crate::os::Env::new().amazon_q_sigv4() {`
`534`	`534`	`debug!("logged in using sigv4 credentials");`
`535`	`535`	`return true;`
`536`	`536`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,6 @@ pub use crate::telemetry::core::{`
`66`	`66`	`QProfileSwitchIntent,`
`67`	`67`	`TelemetryResult,`
`68`	`68`	`};`
`69`		`-use crate::util::env_var::Q_CLI_CLIENT_APPLICATION;`
`70`	`69`	`use crate::util::system_info::os_version;`
`71`	`70`
`72`	`71`	`#[derive(thiserror::Error, Debug)]`
`@@ -381,7 +380,7 @@ async fn set_event_metadata(database: &Database, event: &mut Event) {`
`381`	`380`	`}`
`382`	`381`
`383`	`382`	`// Set the client application from environment variable`
`384`		`- if let Ok(client_app) = std::env::var(Q_CLI_CLIENT_APPLICATION) {`
	`383`	`+ if let Ok(client_app) = crate::os::Env::new().q_cli_client_application() {`
`385`	`384`	`event.set_client_application(client_app);`
`386`	`385`	`}`
`387`	`386`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,16 +175,15 @@ pub fn in_wsl() -> bool {`
`175`	`175`	`/// Is the calling binary running on a remote instance`
`176`	`176`	`pub fn is_remote() -> bool {`
`177`	`177`	`// TODO(chay): Add detection for inside docker container`
`178`		`- in_ssh() \|\| in_wsl() \|\| std::env::var_os("Q_FAKE_IS_REMOTE").is_some()`
	`178`	`+ in_ssh() \|\| in_wsl() \|\| crate::os::Env::new().q_fake_is_remote()`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`pub fn in_codespaces() -> bool {`
`182`	`182`	`static IN_CODESPACES: OnceLock<bool> = OnceLock::new();`
`183`		`- *IN_CODESPACES`
`184`		`- .get_or_init(\|\| std::env::var_os("CODESPACES").is_some() \|\| std::env::var_os("Q_CODESPACES").is_some())`
	`183`	`+ *IN_CODESPACES.get_or_init(\|\| std::env::var_os("CODESPACES").is_some() \|\| crate::os::Env::new().in_codespaces())`
`185`	`184`	`}`
`186`	`185`
`187`	`186`	`pub fn in_ci() -> bool {`
`188`	`187`	`static IN_CI: OnceLock<bool> = OnceLock::new();`
`189`		`- *IN_CI.get_or_init(\|\| std::env::var_os("CI").is_some() \|\| std::env::var_os("Q_CI").is_some())`
	`188`	`+ *IN_CI.get_or_init(\|\| std::env::var_os("CI").is_some() \|\| crate::os::Env::new().in_ci())`
`190`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ impl StreamingClient {`
`61`	`61`	`let client = if fig_util::system_info::in_cloudshell()`
`62`	`62`	`\|\| std::env::var("Q_USE_SENDMESSAGE").is_ok_and(\|v\| !v.is_empty())`
`63`	`63`	`{`
	`64`	`+ // ALLOWED: fig_api_client doesn't have fig_os_shim dependency`
`64`	`65`	`Self::new_qdeveloper_client(&Endpoint::load_q()).await?`
`65`	`66`	`} else {`
`66`	`67`	`Self::new_codewhisperer_client(&Endpoint::load_codewhisperer()).await`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ async fn main() -> ExitCode {`
`149`	`149`
`150`	`150`	`#[cfg(target_os = "linux")]`
`151`	`151`	`{`
`152`		`- match std::env::var("Q_BACKEND").ok().as_deref() {`
	`152`	`+ match fig_os_shim::Env::new().q_backend().ok().as_deref() {`
`153`	`153`	`Some("default") => {},`
`154`	`154`	`// SAFETY: we are calling set_var in a single-threaded context.`
`155`	`155`	`Some(backend) => unsafe { std::env::set_var("GDK_BACKEND", backend) },`