Fix error message when trying to run a nonexistent path

lib/cli/src/cli.rs

@@ -344,14 +344,34 @@ fn test_split_version() {
     );
 }
 
+#[derive(Debug)]
+pub(crate) enum SplitVersionError {
+    InvalidCommandName(anyhow::Error, Option<anyhow::Error>),
+    Other(anyhow::Error),
+}
+
+impl std::error::Error for SplitVersionError {}
+
+impl fmt::Display for SplitVersionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SplitVersionError::InvalidCommandName(i, _) => {
+                write!(f, "invalid command name")?;
+                i.fmt(f)
+            }
+            SplitVersionError::Other(i) => i.fmt(f),
+        }
+    }
+}
+
 impl SplitVersion {
-    pub fn parse(s: &str) -> Result<SplitVersion, anyhow::Error> {
+    pub fn parse(s: &str) -> Result<SplitVersion, SplitVersionError> {
         s.parse()
     }
 }
 
 impl FromStr for SplitVersion {
-    type Err = anyhow::Error;
+    type Err = SplitVersionError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let command = WasmerCLIOptions::command();
@@ -364,6 +384,13 @@ impl FromStr for SplitVersion {
 
         let mut no_version = false;
 
+        if s.starts_with('/') || s.contains("..") {
+            return Err(SplitVersionError::InvalidCommandName(
+                anyhow!("package {s:?} seems to be a path"),
+                None,
+            ));
+        }
+
         let captures = if re1.is_match(s) {
             re1.captures(s)
                 .map(|c| {
@@ -402,34 +429,48 @@ impl FromStr for SplitVersion {
                 })
                 .unwrap_or_default()
         } else {
-            return Err(anyhow::anyhow!("Invalid package version: {s:?}"));
+            // maybe a command
+            return Err(SplitVersionError::Other(anyhow::anyhow!(
+                "Invalid package version: {s:?}"
+            )));
         };
 
         let mut namespace = match captures.get(1).cloned() {
             Some(s) => s,
             None => {
-                return Err(anyhow::anyhow!(
+                return Err(SplitVersionError::Other(anyhow::anyhow!(
                     "Invalid package version: {s:?}: no namespace"
-                ))
+                )))
             }
         };
 
         let name = match captures.get(2).cloned() {
             Some(s) => s,
-            None => return Err(anyhow::anyhow!("Invalid package version: {s:?}: no name")),
+            None => {
+                return Err(SplitVersionError::Other(anyhow::anyhow!(
+                    "Invalid package version: {s:?}: no name"
+                )))
+            }
         };
 
         let mut registry = None;
         if namespace.contains('/') {
             let (r, n) = namespace.rsplit_once('/').unwrap();
-            let mut real_registry = r.to_string();
-            if !real_registry.ends_with("graphql") {
-                real_registry = format!("{real_registry}/graphql");
+            let real_registry = r.to_string();
+
+            if !real_registry.contains('.') {
+                let err = anyhow::anyhow!(
+                    "expected a dot if using a URL shorthand (e.g. {real_registry}.com)"
+                );
+                return Err(SplitVersionError::InvalidCommandName(
+                    err,
+                    Some(anyhow::anyhow!(
+                        "invalid registry or namespace {real_registry:?}"
+                    )),
+                ));
             }
-            if !real_registry.contains("://") {
-                real_registry = format!("https://{real_registry}");
-            }
-            registry = Some(real_registry);
+
+            registry = Some(wasmer_registry::format_graphql(&real_registry));
             namespace = n.to_string();
         }
 
@@ -446,10 +487,12 @@ impl FromStr for SplitVersion {
         };
 
         let svp = sv.package.clone();
-        anyhow::ensure!(
-            !prohibited_package_names.any(|s| s == sv.package.trim()),
-            "Invalid package name {svp:?}"
-        );
+        if prohibited_package_names.any(|s| s == sv.package.trim()) {
+            return Err(SplitVersionError::InvalidCommandName(
+                anyhow::anyhow!("Invalid package name {svp:?}"),
+                None,
+            ));
+        }
 
         Ok(sv)
     }

lib/cli/src/commands/run.rs

@@ -1,4 +1,4 @@
-use crate::cli::SplitVersion;
+use crate::cli::{SplitVersion, SplitVersionError};
 use crate::common::get_cache_dir;
 #[cfg(feature = "debug")]
 use crate::logging;
@@ -859,9 +859,22 @@ pub(crate) fn try_run_package_or_file(
     let package = format!("{}", r.path.display());
 
     let mut is_fake_sv = false;
-    let mut sv = match SplitVersion::parse(&package) {
+    let new_split_version = SplitVersion::parse(&package);
+    let mut sv = match new_split_version {
         Ok(o) => o,
-        Err(_) => {
+        Err(SplitVersionError::InvalidCommandName(e, context)) => {
+            let mut e = Err(anyhow::anyhow!(
+                "Invalid command {package:?}, file {package:?} not found either"
+            )
+            .context(e));
+
+            if let Some(c) = context {
+                e = e.context(c);
+            }
+
+            return e.context(anyhow::anyhow!("{}", r.path.display()));
+        }
+        Err(SplitVersionError::Other(_)) => {
             let mut fake_sv = SplitVersion {
                 original: package.to_string(),
                 registry: None,

tests/integration/cli/tests/run.rs

@@ -156,6 +156,34 @@ fn run_whoami_works() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn run_wasi_works_non_existent() -> anyhow::Result<()> {
+    let output = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("does/not/exist")
+        .output()?;
+
+    let stderr = std::str::from_utf8(&output.stderr).unwrap();
+
+    let stderr_lines = stderr
+        .lines()
+        .map(|s| s.trim().to_string())
+        .collect::<Vec<_>>();
+
+    assert_eq!(
+        stderr_lines,
+        vec![
+            "error: does/not/exist".to_string(),
+            "│   1: invalid registry or namespace \"does\"".to_string(),
+            "│   2: expected a dot if using a URL shorthand (e.g. does.com)".to_string(),
+            "╰─▶ 3: Invalid command \"does/not/exist\", file \"does/not/exist\" not found either"
+                .to_string(),
+        ]
+    );
+
+    Ok(())
+}
+
 #[test]
 fn run_wasi_works() -> anyhow::Result<()> {
     let output = Command::new(get_wasmer_path())