add registry support to plug subcommand

Author: calvinrp

Cargo.lock

@@ -23,6 +23,8 @@ wac-types = { workspace = true }
 wac-graph = { workspace = true }
 wac-resolver = { workspace = true, default-features = false }
 wac-parser = { workspace = true, default-features = false }
+warg-client = { workspace = true, optional = true }
+warg-protocol = { workspace = true, optional = true }
 anyhow = { workspace = true }
 clap = { workspace = true }
 pretty_env_logger = { workspace = true }
@@ -43,7 +45,7 @@ indicatif = { workspace = true, optional = true }
 default = ["wit", "registry"]
 wat = ["wac-resolver/wat"]
 wit = ["wac-resolver/wit"]
-registry = ["wac-resolver/registry", "dep:indicatif"]
+registry = ["wac-resolver/registry", "dep:indicatif", "dep:warg-client", "dep:warg-protocol"]
 
 [workspace.dependencies]
 wac-parser = { path = "crates/wac-parser", version = "0.1.0", default-features = false }

Cargo.toml

@@ -3,24 +3,69 @@ use std::{
     path::PathBuf,
 };
 
-use anyhow::{bail, Context as _, Result};
+use anyhow::{anyhow, bail, Context as _, Error, Result};
 use clap::Args;
+use std::borrow::Cow;
+use std::str::FromStr;
 use wac_graph::{CompositionGraph, EncodeOptions, NodeId, PackageId};
 use wac_types::{Package, SubtypeChecker};
 
+#[cfg(feature = "registry")]
+use warg_client::FileSystemClient;
+
+#[cfg(feature = "registry")]
+use warg_protocol::registry::PackageName;
+
+/// The package path or registry package name.
+#[derive(Clone, Debug)]
+pub enum PackageRef {
+    /// The local file path to the component.
+    LocalPath(PathBuf),
+    /// The registry package name.
+    #[cfg(feature = "registry")]
+    RegistryPackage(PackageName), // TODO handle package versions
+}
+
+impl FromStr for PackageRef {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if cfg!(not(feature = "registry")) {
+            return Ok(Self::LocalPath(PathBuf::from(s)));
+        }
+
+        #[cfg(feature = "registry")]
+        if let Ok(package_name) = PackageName::new(s) {
+            // only `namespace:package-name` without file extensions is valid
+            Ok(Self::RegistryPackage(package_name))
+        } else {
+            Ok(Self::LocalPath(PathBuf::from(s)))
+        }
+    }
+}
+
+impl std::fmt::Display for PackageRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::LocalPath(path) => write!(f, "{}", path.display()),
+            Self::RegistryPackage(name) => write!(f, "{}", name),
+        }
+    }
+}
+
 /// Plugs the exports of any number of 'plug' components into the imports of a 'socket' component.
 #[derive(Args)]
 #[clap(disable_version_flag = true)]
 pub struct PlugCommand {
-    /// The path to the plug component.
+    /// The local path to the plug component or the registry package name.
     ///
     /// More than one plug can be supplied.
     #[clap(long = "plug", value_name = "PLUG_PATH", required = true)]
-    pub plugs: Vec<PathBuf>,
+    pub plugs: Vec<PackageRef>,
 
-    /// The path to the socket component
+    /// The local path to the socket component or the registry package name.
     #[clap(value_name = "SOCKET_PATH", required = true)]
-    pub socket: PathBuf,
+    pub socket: PackageRef,
 
     /// Whether to emit the WebAssembly text format.
     #[clap(long, short = 't')]
@@ -31,6 +76,11 @@ pub struct PlugCommand {
     /// If not specified, the output will be written to stdout.
     #[clap(long, short = 'o')]
     pub output: Option<PathBuf>,
+
+    /// The URL of the registry to use.
+    #[cfg(feature = "registry")]
+    #[clap(long, value_name = "URL")]
+    pub registry: Option<String>,
 }
 
 impl PlugCommand {
@@ -39,10 +89,28 @@ impl PlugCommand {
         log::debug!("executing plug command");
         let mut graph = CompositionGraph::new();
 
-        let socket = std::fs::read(&self.socket).with_context(|| {
+        #[cfg(feature = "registry")]
+        let client = FileSystemClient::new_with_default_config(self.registry.as_deref()).ok();
+
+        let socket_path = match &self.socket {
+            #[cfg(feature = "registry")]
+            PackageRef::RegistryPackage(name) => {
+                client
+                    .as_ref()
+                    .ok_or_else(|| {
+                        anyhow!("Warg registry is not configured. Package `{name}` was not found.")
+                    })?
+                    .download(name, &semver::VersionReq::STAR)
+                    .await?
+                    .ok_or_else(|| anyhow!("package `{name}` was not found"))?
+                    .path
+            }
+            PackageRef::LocalPath(path) => path.clone(),
+        };
+        let socket = std::fs::read(&socket_path).with_context(|| {
             format!(
-                "failed to read socket component `{path}`",
-                path = self.socket.display()
+                "failed to read socket component `{socket}`",
+                socket = self.socket
             )
         })?;
 
@@ -53,24 +121,40 @@ impl PlugCommand {
         // Collect the plugs by their names
         let mut plugs_by_name = std::collections::HashMap::<_, Vec<_>>::new();
         for plug in self.plugs.iter() {
-            let name = plug
-                .file_stem()
-                .map(|fs| fs.to_string_lossy())
-                .with_context(|| format!("path to plug '{}' was not a file", plug.display()))?;
+            let name = match plug {
+                PackageRef::RegistryPackage(name) => Cow::Borrowed(name.as_ref()),
+                PackageRef::LocalPath(path) => path
+                    .file_stem()
+                    .map(|fs| fs.to_string_lossy())
+                    .with_context(|| format!("path to plug '{}' was not a file", plug))?,
+            };
+
             // TODO(rylev): sanitize the name to ensure it's a valid package identifier.
             plugs_by_name.entry(name).or_default().push(plug);
         }
 
         // Plug each plug into the socket.
-        for (name, plug_paths) in plugs_by_name {
-            for (i, plug_path) in plug_paths.iter().enumerate() {
-                let mut name = format!("plug:{name}");
+        for (name, plug_refs) in plugs_by_name {
+            for (i, plug_ref) in plug_refs.iter().enumerate() {
+                let (mut name, path) = match plug_ref {
+                    PackageRef::RegistryPackage(name) => (
+                        name.as_ref().to_string(),
+                        client
+                            .as_ref()
+                            .ok_or_else(|| anyhow!("Warg registry is not configured. Package `{name}` was not found."))?
+                            .download(name, &semver::VersionReq::STAR)
+                            .await?
+                            .ok_or_else(|| anyhow!("package `{name}` was not found"))?
+                            .path,
+                    ),
+                    PackageRef::LocalPath(path) => (format!("plug:{name}"), path.clone()),
+                };
                 // If there's more than one plug with the same name, append an index to the name.
-                if plug_paths.len() > 1 {
+                if plug_refs.len() > 1 {
                     use core::fmt::Write;
                     write!(&mut name, "{i}").unwrap();
                 }
-                plug_into_socket(&name, plug_path, socket, socket_instantiation, &mut graph)?;
+                plug_into_socket(&name, &path, socket, socket_instantiation, &mut graph)?;
             }
         }