feat: added --dry-run to wkg publish

crates/wasm-pkg-client/src/lib.rs

@@ -85,6 +85,9 @@ pub struct PublishOpts {
     pub package: Option<(PackageRef, Version)>,
     /// Override the registry to publish to.
     pub registry: Option<Registry>,
+    /// If true, resolve the package, version, and registry but do not call the
+    /// backend to publish.
+    pub dry_run: bool,
 }
 
 /// A read-only registry client.
@@ -181,8 +184,9 @@ impl Client {
         let source = self
             .resolve_source(&package, additional_options.registry)
             .await?;
+
         source
-            .publish(&package, &version, data)
+            .publish(&package, &version, data, additional_options.dry_run)
             .await
             .map(|_| (package, version))
     }

crates/wasm-pkg-client/src/local.rs

@@ -112,11 +112,15 @@ impl PackagePublisher for LocalBackend {
         package: &PackageRef,
         version: &Version,
         mut data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), Error> {
         let package_dir = self.package_dir(package);
         // Ensure the package directory exists.
         tokio::fs::create_dir_all(package_dir).await?;
         let path = self.version_path(package, version);
+        if dry_run {
+            return Ok(());
+        }
         let mut out = tokio::fs::File::create(path).await?;
         tokio::io::copy(&mut data, &mut out)
             .await

crates/wasm-pkg-client/src/oci/mod.rs

@@ -101,6 +101,13 @@ impl OciBackend {
                 Ok(auth)
             })
             .await
+            .map_err(|e| {
+                if let Error::RegistryError(anyhow_err) = e {
+                    Error::RegistryError(anyhow_err.context(reference.repository().to_owned()))
+                } else {
+                    e
+                }
+            })
             .cloned()
     }
 

crates/wasm-pkg-client/src/oci/publisher.rs

@@ -15,6 +15,7 @@ impl PackagePublisher for OciBackend {
         package: &PackageRef,
         version: &Version,
         mut data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error> {
         // NOTE(thomastaylor312): oci-client doesn't support publishing from a stream or reader, so
         // we have to read all the data in for now. Once we can address that upstream, we'll be able
@@ -64,10 +65,12 @@ impl PackagePublisher for OciBackend {
 
         let reference: Reference = self.make_reference(package, Some(version));
         let auth = self.auth(&reference, RegistryOperation::Push).await?;
-        self.client
-            .push(&reference, &auth, layer, config, Some(annotations))
-            .await
-            .map_err(crate::Error::RegistryError)?;
+        if !dry_run {
+            self.client
+                .push(&reference, &auth, layer, config, Some(annotations))
+                .await
+                .map_err(crate::Error::RegistryError)?;
+        }
         Ok(())
     }
 }

crates/wasm-pkg-client/src/publisher.rs

@@ -10,5 +10,6 @@ pub trait PackagePublisher: Send + Sync {
         package: &PackageRef,
         version: &Version,
         data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error>;
 }

crates/wasm-pkg-client/src/warg/publisher.rs

@@ -18,6 +18,7 @@ impl PackagePublisher for WargBackend {
         package: &PackageRef,
         version: &Version,
         data: PublishingSource,
+        dry_run: bool,
     ) -> Result<(), crate::Error> {
         // store the Wasm in Warg cache, so that it is available to Warg client for uploading
         let content = self
@@ -37,6 +38,10 @@ impl PackagePublisher for WargBackend {
         // convert package name to Warg package name
         let name = super::package_ref_to_name(package)?;
 
+        if dry_run {
+            return Ok(());
+        }
+
         // start Warg publish, using the keyring to sign
         let version = version.clone();
         let info = PublishInfo {

crates/wasm-pkg-common/Cargo.toml

@@ -30,6 +30,7 @@ sha2 = { workspace = true }
 tokio = { workspace = true, optional = true, features = ["fs"] }
 toml = { workspace = true, optional = true }
 thiserror = { workspace = true }
+tracing.workspace = true
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt"] }

crates/wasm-pkg-common/src/config.rs

@@ -118,6 +118,8 @@ impl Config {
             Some(path) => path,
             None => return Ok(None),
         };
+
+        tracing::debug!(path = %path.display(), "using global config");
         let contents = match tokio::fs::read_to_string(&path).await {
             Ok(contents) => contents,
             Err(err) if err.kind() == ErrorKind::NotFound => return Ok(None),

crates/wasm-pkg-core/src/config.rs

@@ -30,6 +30,7 @@ pub struct Config {
 impl Config {
     /// Loads a configuration file from the given path.
     pub async fn load_from_path(path: impl AsRef<Path>) -> Result<Config> {
+        tracing::info!(path = %path.as_ref().display(), "loading wkg config file");
         let contents = tokio::fs::read_to_string(path)
             .await
             .context("unable to load config from file")?;

crates/wasm-pkg-core/src/resolver.rs

@@ -530,7 +530,8 @@ impl<'a> DependencyResolver<'a> {
             } else {
                 let versions =
                     load_package(&mut self.packages, &self.client, dependency.package.clone())
-                        .await?
+                        .await
+                        .with_context(|| format!("package: {}", dependency.package.clone()))?
                         .with_context(|| {
                             format!(
                                 "package `{name}` was not found in component registry",

crates/wasm-pkg-core/src/wit.rs

@@ -54,6 +54,7 @@ pub async fn build_package(
 ) -> Result<(PackageRef, Option<Version>, Vec<u8>)> {
     let dependencies = resolve_dependencies(config, &wit_dir, Some(lock_file), client)
         .await
+        .with_context(|| format!("wit_dir: {}", wit_dir.as_ref().display()))
         .context("Unable to resolve dependencies")?;
 
     lock_file.update_dependencies(&dependencies);
@@ -179,16 +180,17 @@ pub async fn resolve_dependencies(
     let mut resolver = DependencyResolver::new_with_client(client, lock_file)?;
     // add deps from config first in case they're local deps and then add deps from the directory
     if let Some(overrides) = config.overrides.as_ref() {
+        tracing::debug!("detected config overrides");
         for (pkg, ovr) in overrides.iter() {
             let pkg: PackageRef = pkg.parse().context("Unable to parse as a package ref")?;
             let dep = match (ovr.path.as_ref(), ovr.version.as_ref()) {
                 (Some(path), v) => {
                     if v.is_some() {
                         tracing::warn!("Ignoring version override for local package");
                     }
-                    let path = tokio::fs::canonicalize(path)
-                        .await
-                        .with_context(|| format!("resolving local dependency {}", path.display()))?;
+                    let path = tokio::fs::canonicalize(path).await.with_context(|| {
+                        format!("resolving local dependency {}", path.display())
+                    })?;
                     Dependency::Local(path)
                 }
                 (None, Some(version)) => Dependency::Package(RegistryPackage {

crates/wkg/src/main.rs

@@ -51,6 +51,7 @@ impl Common {
     /// Helper to load the config from the given path
     pub async fn load_config(&self) -> anyhow::Result<Config> {
         if let Some(config_file) = self.config.as_ref() {
+            tracing::info!(config = %config_file.display());
             Config::from_file(config_file)
                 .await
                 .context(format!("error loading config file {config_file:?}"))
@@ -237,6 +238,10 @@ struct PublishArgs {
     #[arg(long, env = "WKG_PACKAGE")]
     package: Option<PackageSpec>,
 
+    /// Attempt package, version, and registry resolution without publishing.
+    #[arg(long)]
+    dry_run: bool,
+
     #[command(flatten)]
     common: Common,
 }
@@ -262,10 +267,15 @@ impl PublishArgs {
                 PublishOpts {
                     package,
                     registry: self.registry_args.registry,
+                    dry_run: self.dry_run,
                 },
             )
             .await?;
-        println!("Published {}@{}", package, version);
+        if self.dry_run {
+            println!("Aborting publish due to dry run: {}@{}", package, version);
+        } else {
+            println!("Published {}@{}", package, version);
+        }
         Ok(())
     }
 }