Update wasmer --version logic, integrate wapm-cli

Cargo.toml

@@ -50,6 +50,7 @@ members = [
     "lib/c-api/tests/wasmer-c-api-test-runner",
     "lib/c-api/examples/wasmer-capi-examples-runner",
     "lib/types",
+    "lib/registry",
     "tests/wasi-wast",
     "tests/lib/wast",
     "tests/lib/compiler-test-derive",

lib/cli/Cargo.toml

@@ -37,12 +37,14 @@ wasmer-wasi-experimental-io-devices = { version = "=3.0.0-beta.2", path = "../wa
 wasmer-wast = { version = "=3.0.0-beta.2", path = "../../tests/lib/wast", optional = true }
 wasmer-cache = { version = "=3.0.0-beta.2", path = "../cache", optional = true }
 wasmer-types = { version = "=3.0.0-beta.2", path = "../types" }
+wasmer-registry = { version = "=3.0.0-beta.2", path = "../registry" }
 wasmer-object = { version = "=3.0.0-beta.2", path = "../object", optional = true }
 wasmer-vfs  = { version = "=3.0.0-beta.2", path = "../vfs", default-features = false, features = ["host-fs"] }
 atty = "0.2"
 colored = "2.0"
 anyhow = "1.0"
-clap = { version = "3.1", features = ["derive"] }
+spinner = "0.5.0"
+clap = { version = "3.2.22", features = ["derive"] }
 # For the function names autosuggestion
 distance = "0.4"
 # For the inspect subcommand
@@ -56,6 +58,12 @@ http_req  = { version="^0.8", default-features = false, features = ["rust-tls"],
 dirs = { version = "4.0", optional = true }
 serde_json = { version = "1.0", optional = true }
 target-lexicon = { version = "0.12", features = ["std"] }
+prettytable-rs = "0.9.0"
+wapm-toml = "0.1.2"
+walkdir = "2.3.2"
+
+[build-dependencies]
+chrono = { version = "^0.4", default-features = false, features = [ "std", "clock" ] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 unix_mode = "0.1.3"

lib/cli/build.rs

@@ -1,4 +1,26 @@
+use chrono::prelude::*;
+use std::process::Command;
+
 pub fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-env-changed=WASMER_INSTALL_PREFIX");
+    // Set WASMER_GIT_HASH
+    let git_hash = Command::new("git")
+        .args(&["rev-parse", "HEAD"])
+        .output()
+        .ok()
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .unwrap_or_default();
+    println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH={}", git_hash);
+
+    if git_hash.len() > 5 {
+        println!(
+            "cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT={}",
+            &git_hash[..5]
+        );
+    } else {
+        println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT=??????");
+    }
+
+    let utc: DateTime<Utc> = Utc::now();
+    let date = utc.format("%Y-%m-%d").to_string();
+    println!("cargo:rustc-env=WASMER_BUILD_DATE={}", date);
 }

lib/cli/src/cli.rs

@@ -10,13 +10,12 @@ use crate::commands::CreateExe;
 use crate::commands::CreateObj;
 #[cfg(feature = "wast")]
 use crate::commands::Wast;
-use crate::commands::{Cache, Config, Inspect, Run, SelfUpdate, Validate};
+use crate::commands::{Cache, Config, Inspect, Run, RunWithoutFile, SelfUpdate, Validate};
 use crate::error::PrettyError;
-use anyhow::Result;
-
 use clap::{ErrorKind, Parser};
+use wasmer_registry::get_all_local_packages;
 
-#[derive(Parser)]
+#[derive(Parser, Debug)]
 #[cfg_attr(
     not(feature = "headless"),
     clap(
@@ -146,7 +145,7 @@ enum WasmerCLIOptions {
 }
 
 impl WasmerCLIOptions {
-    fn execute(&self) -> Result<()> {
+    fn execute(&self) -> Result<(), anyhow::Error> {
         match self {
             Self::Run(options) => options.execute(),
             Self::SelfUpdate(options) => options.execute(),
@@ -174,6 +173,10 @@ pub fn wasmer_main() {
     #[cfg(windows)]
     colored::control::set_virtual_terminal(true).unwrap();
 
+    PrettyError::report(wasmer_main_inner())
+}
+
+fn wasmer_main_inner() -> Result<(), anyhow::Error> {
     // We try to run wasmer with the normal arguments.
     // Eg. `wasmer <SUBCOMMAND>`
     // In case that fails, we fallback trying the Run subcommand directly.
@@ -183,6 +186,32 @@ pub fn wasmer_main() {
     // we assume that we're registered via binfmt_misc
     let args = std::env::args().collect::<Vec<_>>();
     let binpath = args.get(0).map(|s| s.as_ref()).unwrap_or("");
+
+    let firstarg = args.get(1).map(|s| s.as_str());
+    let secondarg = args.get(2).map(|s| s.as_str());
+
+    match (firstarg, secondarg) {
+        (None, _) | (Some("help"), _) | (Some("--help"), _) => {
+            return print_help(true);
+        }
+        (Some("-h"), _) => {
+            return print_help(false);
+        }
+        (Some("-vV"), _)
+        | (Some("version"), Some("--verbose"))
+        | (Some("--version"), Some("--verbose")) => {
+            return print_version(true);
+        }
+
+        (Some("-v"), _) | (Some("-V"), _) | (Some("version"), _) | (Some("--version"), _) => {
+            return print_version(false);
+        }
+        (Some("list"), _) => {
+            return print_packages();
+        }
+        _ => {}
+    }
+
     let command = args.get(1);
     let options = if cfg!(target_os = "linux") && binpath.ends_with("wasmer-binfmt-interpreter") {
         WasmerCLIOptions::Run(Run::from_binfmt_args())
@@ -204,5 +233,244 @@ pub fn wasmer_main() {
         }
     };
 
-    PrettyError::report(options.execute());
+    // Check if the file is a package name
+    if let WasmerCLIOptions::Run(r) = &options {
+        if !r.path.exists() {
+            let package = format!("{}", r.path.display());
+            if let Ok(mut sv) = split_version(&package) {
+                let mut package_download_info = None;
+                if !sv.package.contains('/') {
+                    let sp = spinner::SpinnerBuilder::new(format!(
+                        "Looking up command {} ...",
+                        sv.package
+                    ))
+                    .spinner(vec![
+                        "⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷", " ", "⠁", "⠂", "⠄", "⡀", "⢀", "⠠",
+                        "⠐", "⠈",
+                    ])
+                    .start();
+
+                    for registry in
+                        wasmer_registry::get_all_available_registries().unwrap_or_default()
+                    {
+                        let result =
+                            wasmer_registry::query_command_from_registry(&registry, &sv.package);
+                        print!("\r\n");
+                        let command = sv.package.clone();
+                        if let Ok(o) = result {
+                            package_download_info = Some(o.clone());
+                            sp.close();
+                            sv.package = o.package;
+                            sv.version = Some(o.version);
+                            sv.command = Some(command);
+                            break;
+                        }
+                    }
+                }
+
+                if let Some(package) =
+                    wasmer_registry::get_local_package(&sv.package, sv.version.as_deref())
+                {
+                    let local_package_wasm_path = wasmer_registry::get_package_local_wasm_file(
+                        &package.registry,
+                        &package.name,
+                        &package.version,
+                    )
+                    .map_err(|e| anyhow!("{e}"))?;
+
+                    // Try finding the local package
+                    let mut args_without_package = args.clone();
+                    args_without_package.remove(1);
+
+                    let mut run_args = RunWithoutFile::try_parse_from(args_without_package.iter())?;
+                    run_args.command_name = sv.command.clone();
+                    return run_args
+                        .into_run_args(local_package_wasm_path, Some(package.manifest))
+                        .execute();
+                }
+
+                // else: local package not found
+                let sp =
+                    spinner::SpinnerBuilder::new(format!("Installing package {} ...", sv.package))
+                        .spinner(vec![
+                            "⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷", " ", "⠁", "⠂", "⠄", "⡀", "⢀",
+                            "⠠", "⠐", "⠈",
+                        ])
+                        .start();
+
+                let v = sv.version.as_deref();
+                let result =
+                    wasmer_registry::install_package(&sv.package, v, package_download_info);
+                sp.close();
+                print!("\r\n");
+                match result {
+                    Ok((package, buf)) => {
+                        // Try auto-installing the remote package
+                        let mut args_without_package = args.clone();
+                        args_without_package.remove(1);
+
+                        let mut run_args =
+                            RunWithoutFile::try_parse_from(args_without_package.iter())?;
+                        run_args.command_name = sv.command.clone();
+
+                        return run_args
+                            .into_run_args(buf, Some(package.manifest))
+                            .execute();
+                    }
+                    Err(e) => {
+                        println!("{e}");
+                        return Ok(());
+                    }
+                }
+            }
+        }
+    }
+
+    options.execute()
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+struct SplitVersion {
+    package: String,
+    version: Option<String>,
+    command: Option<String>,
+}
+
+fn split_version(s: &str) -> Result<SplitVersion, anyhow::Error> {
+    let prohibited_package_names = [
+        "run",
+        "cache",
+        "validate",
+        "compile",
+        "create-exe",
+        "create-obj",
+        "config",
+        "inspect",
+        "wast",
+        "help",
+    ];
+
+    let package_version = s.split('@').collect::<Vec<_>>();
+    let (mut package, mut version) = match *package_version.as_slice() {
+        [p, v] => (p.trim().to_string(), Some(v.trim().to_string())),
+        [p] => (p.trim().to_string(), None),
+        _ => {
+            return Err(anyhow!("Invalid package / version: {s:?}"));
+        }
+    };
+
+    let version_clone = version.clone().unwrap_or_default();
+    let command = if package.contains(':') {
+        let package_command = version_clone.split('@').collect::<Vec<_>>();
+        let (p, c) = match package_command.as_slice() {
+            [p, v] => (p.trim().to_string(), Some(v.trim().to_string())),
+            [p] => (p.trim().to_string(), None),
+            _ => {
+                return Err(anyhow!("Invalid package / command: {s:?}"));
+            }
+        };
+        package = p;
+        c
+    } else if version_clone.contains(':') {
+        let version_command = version_clone.split('@').collect::<Vec<_>>();
+        let (v, command) = match version_command.as_slice() {
+            [p, v] => (p.trim().to_string(), Some(v.trim().to_string())),
+            [p] => (p.trim().to_string(), None),
+            _ => {
+                return Err(anyhow!("Invalid version / command: {s:?}"));
+            }
+        };
+        version = Some(v);
+        command
+    } else {
+        None
+    };
+
+    if prohibited_package_names.contains(&package.trim()) {
+        return Err(anyhow::anyhow!("Invalid package name {package:?}"));
+    }
+
+    Ok(SplitVersion {
+        package,
+        version,
+        command,
+    })
+}
+
+fn print_packages() -> Result<(), anyhow::Error> {
+    use prettytable::{format, row, Table};
+
+    let rows = get_all_local_packages()
+        .into_iter()
+        .map(|pkg| {
+            let commands = pkg
+                .manifest
+                .command
+                .unwrap_or_default()
+                .iter()
+                .map(|c| c.get_name())
+                .collect::<Vec<_>>()
+                .join(" \r\n");
+
+            row![pkg.registry, pkg.name, pkg.version, commands]
+        })
+        .collect::<Vec<_>>();
+
+    let empty_table = rows.is_empty();
+    if empty_table {
+        println!("--------------------------------------");
+        println!("Registry  Package  Version  Commands ");
+        println!("======================================");
+        println!();
+    } else {
+        let mut table = Table::init(rows);
+        table.set_titles(row!["Registry", "Package", "Version", "Commands"]);
+        table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
+        table.set_format(*format::consts::FORMAT_NO_COLSEP);
+        let _ = table.printstd();
+    }
+
+    Ok(())
+}
+
+fn print_help(verbose: bool) -> Result<(), anyhow::Error> {
+    use clap::CommandFactory;
+    let mut cmd = WasmerCLIOptions::command();
+    if verbose {
+        let _ = cmd.print_long_help();
+    } else {
+        let _ = cmd.print_help();
+    }
+    Ok(())
+}
+
+#[allow(unused_mut, clippy::vec_init_then_push)]
+fn print_version(verbose: bool) -> Result<(), anyhow::Error> {
+    if !verbose {
+        println!("wasmer {}", env!("CARGO_PKG_VERSION"));
+    } else {
+        println!(
+            "wasmer {} ({} {})",
+            env!("CARGO_PKG_VERSION"),
+            env!("WASMER_BUILD_GIT_HASH_SHORT"),
+            env!("WASMER_BUILD_DATE")
+        );
+        println!("binary: {}", env!("CARGO_PKG_NAME"));
+        println!("commit-hash: {}", env!("WASMER_BUILD_GIT_HASH"));
+        println!("commit-date: {}", env!("WASMER_BUILD_DATE"));
+        println!("host: {}", target_lexicon::HOST);
+        println!("compiler: {}", {
+            let mut s = Vec::<&'static str>::new();
+
+            #[cfg(feature = "singlepass")]
+            s.push("singlepass");
+            #[cfg(feature = "cranelift")]
+            s.push("cranelift");
+            #[cfg(feature = "llvm")]
+            s.push("llvm");
+
+            s.join(",")
+        });
+    }
+    Ok(())
 }

lib/cli/src/commands/binfmt.rs

@@ -8,7 +8,7 @@ use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 use Action::*;
 
-#[derive(Parser, Clone, Copy)]
+#[derive(Debug, Parser, Clone, Copy)]
 enum Action {
     /// Register wasmer as binfmt interpreter
     Register,
@@ -22,7 +22,7 @@ enum Action {
 ///
 /// Check the wasmer repository for a systemd service definition example
 /// to automate the process at start-up.
-#[derive(Parser)]
+#[derive(Debug, Parser)]
 pub struct Binfmt {
     // Might be better to traverse the mount list
     /// Mount point of binfmt_misc fs