fix: fix linux zbus panicking

Fixes zbus on Linux panicking due to the crate
spawning a runtime inside of our own runtime. This
is avoided by using the sync mode of the crate
instead of async. Additionally, keyring operations
have been wrapped in spawn_blocking to avoid
blocking the async runtime.

CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Fixed
+- Colour deprecate output to match yank output by @daimond113
+- Fix zbus panic on Linux by @daimond113
+
 ## [0.6.0-rc.1] - 2025-02-06
 ### Added
 - Improve installation experience by @lukadev-0

Cargo.lock

@@ -381,30 +381,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "async-executor"
-version = "1.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30ca9a001c1e8ba5149f91a74362376cc6bc5b919d92d988668657bd570bdcec"
-dependencies = [
- "async-task",
- "concurrent-queue",
- "fastrand",
- "futures-lite",
- "slab",
-]
-
-[[package]]
-name = "async-fs"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
-dependencies = [
- "async-lock",
- "blocking",
- "futures-lite",
-]
-
 [[package]]
 name = "async-io"
 version = "2.4.0"
@@ -2918,7 +2894,6 @@ dependencies = [
  "security-framework 2.11.1",
  "security-framework 3.2.0",
  "windows-sys 0.59.0",
- "zbus",
 ]
 
 [[package]]
@@ -4987,7 +4962,6 @@ dependencies = [
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "tracing",
  "windows-sys 0.52.0",
 ]
 
@@ -5893,15 +5867,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"
 dependencies = [
  "async-broadcast",
- "async-executor",
- "async-fs",
- "async-io",
- "async-lock",
  "async-process",
  "async-recursion",
- "async-task",
  "async-trait",
- "blocking",
  "enumflags2",
  "event-listener",
  "futures-core",
@@ -5915,7 +5883,6 @@ dependencies = [
  "serde_repr",
  "sha1",
  "static_assertions",
- "tokio",
  "tracing",
  "uds_windows",
  "windows-sys 0.52.0",

Cargo.toml

@@ -77,7 +77,7 @@ serde_json = { version = "1.0.136", optional = true }
 
 anyhow = { version = "1.0.95", optional = true }
 open = { version = "5.3.2", optional = true }
-keyring = { version = "3.6.1", features = ["crypto-rust", "windows-native", "apple-native", "async-secret-service", "tokio"], optional = true }
+keyring = { version = "3.6.1", features = ["crypto-rust", "windows-native", "apple-native", "sync-secret-service"], optional = true }
 console = { version = "0.15.10", optional = true }
 toml_edit = { version = "0.22.22", optional = true }
 clap = { version = "4.5.26", features = ["derive"], optional = true }

src/cli/auth.rs

@@ -5,9 +5,10 @@ use keyring::Entry;
 use reqwest::header::AUTHORIZATION;
 use serde::{ser::SerializeMap, Deserialize, Serialize};
 use std::collections::BTreeMap;
+use tokio::task::spawn_blocking;
 use tracing::instrument;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Tokens(pub BTreeMap<gix::Url, String>);
 
 impl Serialize for Tokens {
@@ -46,37 +47,50 @@ pub async fn get_tokens() -> anyhow::Result<Tokens> {
 		return Ok(config.tokens);
 	}
 
-	match Entry::new("tokens", env!("CARGO_PKG_NAME")) {
+	let keyring_tokens = spawn_blocking(|| match Entry::new("tokens", env!("CARGO_PKG_NAME")) {
 		Ok(entry) => match entry.get_password() {
-			Ok(token) => {
+			Ok(token) => serde_json::from_str(&token)
-				tracing::debug!("using tokens from keyring");
+				.map(Some)
-				return serde_json::from_str(&token).context("failed to parse tokens");
+				.context("failed to parse tokens"),
-			}
+			Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => Ok(None),
-			Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => {}
+			Err(e) => Err(e.into()),
-			Err(e) => return Err(e.into()),
 		},
-		Err(keyring::Error::PlatformFailure(_)) => {}
+		Err(keyring::Error::PlatformFailure(_)) => Ok(None),
-		Err(e) => return Err(e.into()),
+		Err(e) => Err(e.into()),
+	})
+	.await
+	.unwrap()?;
+
+	if let Some(tokens) = keyring_tokens {
+		tracing::debug!("using tokens from keyring");
+		return Ok(tokens);
 	}
 
-	Ok(Tokens(BTreeMap::new()))
+	Ok(Tokens::default())
 }
 
 #[instrument(level = "trace")]
 pub async fn set_tokens(tokens: Tokens) -> anyhow::Result<()> {
-	let entry = Entry::new("tokens", env!("CARGO_PKG_NAME"))?;
 	let json = serde_json::to_string(&tokens).context("failed to serialize tokens")?;
 
-	match entry.set_password(&json) {
+	let to_keyring = spawn_blocking(move || {
-		Ok(()) => {
+		let entry = Entry::new("tokens", env!("CARGO_PKG_NAME"))?;
-			tracing::debug!("tokens saved to keyring");
+
-			return Ok(());
+		match entry.set_password(&json) {
+			Ok(()) => Ok::<_, anyhow::Error>(true),
+			Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => Ok(false),
+			Err(e) => Err(e.into()),
 		}
-		Err(keyring::Error::PlatformFailure(_) | keyring::Error::NoEntry) => {}
+	})
-		Err(e) => return Err(e.into()),
+	.await
+	.unwrap()?;
+
+	if to_keyring {
+		tracing::debug!("tokens saved to keyring");
+		return Ok(());
 	}
 
-	tracing::debug!("tokens saved to config");
+	tracing::debug!("saving tokens to config");
 
 	let mut config = read_config().await?;
 	config.tokens = tokens;

src/cli/config.rs

@@ -24,7 +24,7 @@ impl Default for CliConfig {
 		Self {
 			default_index: "https://github.com/pesde-pkg/index".try_into().unwrap(),
 
-			tokens: Tokens(Default::default()),
+			tokens: Tokens::default(),
 
 			last_checked_updates: None,
 		}