fix(cli): image-management Docker parity (inspect array, rmi by short-id/--force, commit --change, tag validation)

Found via the runtime/CLI parity probe (round 2):
- image-inspect now prints a top-level JSON array (like docker image inspect), so `inspect X | jq '.[0]'` works.
- rmi resolves a bare lowercase-hex image id (Docker 12-hex short id), not only sha256:-prefixed refs; digest_matches prefix-matches the stored hex. With multiple tags sharing a digest, rmi errors 'ambiguous' (correct) and `rmi -f <id>` now removes ALL matching references instead of erroring.
- commit --change CMD/ENTRYPOINT honor exec form (["a","b"]) and ENV/LABEL accept the legacy space-separated form, by reusing import.rs's parsers (previously commit wrapped exec arrays in sh -c => exit 127, and dropped space-form ENV).
- tag rejects an uppercase repository name ('repository name must be lowercase'), like Docker, instead of silently creating a bad tag.

All verified on Linux.

Author: Roy Lin

src/cli/src/commands/commit.rs

@@ -246,16 +246,17 @@ fn apply_changes(config: &mut serde_json::Value, changes: &[String]) {
     for change in changes {
         let trimmed = change.trim();
         if let Some(rest) = trimmed.strip_prefix("CMD ") {
-            config["config"]["Cmd"] = serde_json::json!(["/bin/sh", "-c", rest]);
+            // Honor exec form (CMD ["a","b"]) vs shell form, like Docker/import.
+            config["config"]["Cmd"] = super::import::parse_exec_or_shell(rest);
         } else if let Some(rest) = trimmed.strip_prefix("ENTRYPOINT ") {
-            config["config"]["Entrypoint"] = serde_json::json!(["/bin/sh", "-c", rest]);
+            config["config"]["Entrypoint"] = super::import::parse_exec_or_shell(rest);
         } else if let Some(rest) = trimmed.strip_prefix("ENV ") {
-            if let Some((k, v)) = rest.split_once('=') {
-                let env = config["config"]["Env"]
-                    .as_array_mut()
-                    .map(|a| a.clone())
+            // Accept both KEY=VALUE and the legacy space-separated KEY VALUE form.
+            if let Ok((k, v)) = super::import::parse_key_value(rest) {
+                let mut env = config["config"]["Env"]
+                    .as_array()
+                    .cloned()
                     .unwrap_or_default();
-                let mut env = env;
                 env.push(serde_json::json!(format!("{k}={v}")));
                 config["config"]["Env"] = serde_json::json!(env);
             }
@@ -272,13 +273,12 @@ fn apply_changes(config: &mut serde_json::Value, changes: &[String]) {
         } else if let Some(rest) = trimmed.strip_prefix("USER ") {
             config["config"]["User"] = serde_json::json!(rest);
         } else if let Some(rest) = trimmed.strip_prefix("LABEL ") {
-            if let Some((k, v)) = rest.split_once('=') {
-                let labels = config["config"]["Labels"]
+            if let Ok((k, v)) = super::import::parse_key_value(rest) {
+                let mut labels = config["config"]["Labels"]
                     .as_object()
                     .cloned()
                     .unwrap_or_default();
-                let mut labels = labels;
-                labels.insert(k.to_string(), serde_json::json!(v));
+                labels.insert(k, serde_json::json!(v));
                 config["config"]["Labels"] = serde_json::json!(labels);
             }
         }

src/cli/src/commands/image_inspect.rs

@@ -75,7 +75,9 @@ fn build_image_inspect_json(
         "LayerCount": oci.layer_paths().len(),
     });
 
-    Ok(serde_json::to_string_pretty(&output)?)
+    // Docker's inspect family always returns a top-level JSON array (even for a
+    // single image), so tooling can do `inspect X | jq '.[0].Config'`.
+    Ok(serde_json::to_string_pretty(&serde_json::json!([output]))?)
 }
 
 #[cfg(test)]

src/cli/src/commands/image_tag.rs

@@ -13,7 +13,28 @@ pub struct ImageTagArgs {
     pub target: String,
 }
 
+/// Validate a tag target's reference grammar. Docker requires the repository
+/// name (everything before the `:tag`/`@digest`) to be lowercase.
+fn validate_tag_target(target: &str) -> Result<(), String> {
+    let without_digest = target.split('@').next().unwrap_or(target);
+    let last_slash = without_digest.rfind('/');
+    // Strip a trailing `:tag` only when the colon is part of the tag, not a
+    // `registry:port`.
+    let repo = match without_digest.rfind(':') {
+        Some(colon) if last_slash.is_none_or(|slash| colon > slash) => &without_digest[..colon],
+        _ => without_digest,
+    };
+    if repo.bytes().any(|b| b.is_ascii_uppercase()) {
+        return Err(format!(
+            "invalid reference format: repository name must be lowercase: '{target}'"
+        ));
+    }
+    Ok(())
+}
+
 pub async fn execute(args: ImageTagArgs) -> Result<(), Box<dyn std::error::Error>> {
+    validate_tag_target(&args.target)?;
+
     let store = super::open_image_store()?;
     let images = store.list().await;
 
@@ -47,6 +68,15 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_validate_tag_target_rejects_uppercase_repo() {
+        assert!(validate_tag_target("BadRepo:Tag").is_err());
+        assert!(validate_tag_target("myrepo:V1").is_ok()); // uppercase tag is fine
+        assert!(validate_tag_target("localhost:5000/myrepo:tag").is_ok());
+        assert!(validate_tag_target("alpine:latest").is_ok());
+        assert!(validate_tag_target("ns/Sub:tag").is_err());
+    }
+
     #[test]
     fn test_tag_source_resolution_accepts_normalized_alias() {
         let images = vec![stored("docker.io/library/alpine:latest")];

src/cli/src/commands/import.rs

@@ -209,7 +209,7 @@ fn apply_changes(
 }
 
 /// Parse a CMD/ENTRYPOINT value as a JSON array (exec form) or a shell string.
-fn parse_exec_or_shell(rest: &str) -> serde_json::Value {
+pub(crate) fn parse_exec_or_shell(rest: &str) -> serde_json::Value {
     let t = rest.trim();
     if t.starts_with('[') {
         if let Ok(v) = serde_json::from_str::<Vec<String>>(t) {
@@ -220,7 +220,7 @@ fn parse_exec_or_shell(rest: &str) -> serde_json::Value {
     serde_json::json!(["/bin/sh", "-c", t])
 }
 
-fn parse_key_value(rest: &str) -> Result<(String, String), String> {
+pub(crate) fn parse_key_value(rest: &str) -> Result<(String, String), String> {
     if let Some((k, v)) = rest.split_once('=') {
         Ok((k.trim().to_string(), v.trim().to_string()))
     } else if let Some((k, v)) = rest.split_once(char::is_whitespace) {

src/cli/src/commands/rmi.rs

@@ -27,37 +27,48 @@ pub async fn execute(args: RmiArgs) -> Result<(), Box<dyn std::error::Error>> {
 
     for query in &args.images {
         let images = store.list().await;
-        let target = match image_usage::resolve_stored_image(&images, query) {
-            Ok(Some(target)) => target,
-            Ok(None) if args.force => continue,
-            Ok(None) => {
-                errors.push(format!("{query}: Image not found"));
-                continue;
+        // `--force` removes every reference matching the query (Docker: a digest
+        // id with multiple tags is untagged-all); without force a single
+        // unambiguous match is required.
+        let targets: Vec<_> = if args.force {
+            let all = image_usage::all_matching_images(&images, query);
+            if all.is_empty() {
+                continue; // force: ignore not-found
             }
-            Err(error) => {
-                errors.push(format!("{query}: {error}"));
-                continue;
+            all
+        } else {
+            match image_usage::resolve_stored_image(&images, query) {
+                Ok(Some(target)) => vec![target],
+                Ok(None) => {
+                    errors.push(format!("{query}: Image not found"));
+                    continue;
+                }
+                Err(error) => {
+                    errors.push(format!("{query}: {error}"));
+                    continue;
+                }
             }
         };
 
-        if image_usage::is_protected_reference(&target.reference, &protected_images) {
-            errors.push(format!(
-                "{}: image is referenced by an existing box; remove the box before removing this image",
-                target.reference
-            ));
-            continue;
-        }
-
-        match store.remove(&target.reference).await {
-            Ok(()) => {
-                println!("Removed: {}", target.reference);
+        for target in targets {
+            if image_usage::is_protected_reference(&target.reference, &protected_images) {
+                errors.push(format!(
+                    "{}: image is referenced by an existing box; remove the box before removing this image",
+                    target.reference
+                ));
+                continue;
             }
-            Err(e) => {
-                if args.force {
-                    // Silently skip not-found errors in force mode
-                    continue;
+
+            match store.remove(&target.reference).await {
+                Ok(()) => {
+                    println!("Removed: {}", target.reference);
+                }
+                Err(e) => {
+                    if args.force {
+                        continue; // silently skip not-found in force mode
+                    }
+                    errors.push(format!("{}: {e}", target.reference));
                 }
-                errors.push(format!("{}: {e}", target.reference));
             }
         }
     }

src/cli/src/image_usage.rs

@@ -120,6 +120,23 @@ pub fn resolve_stored_image(
     Ok(None)
 }
 
+/// All images matching `query` (exact, then alias, then digest — first mode
+/// with any match wins). Used by `rmi --force`, where an ambiguous digest
+/// should remove every reference sharing it rather than erroring.
+pub fn all_matching_images(images: &[StoredImage], query: &str) -> Vec<StoredImage> {
+    let query = query.trim();
+    if query.is_empty() {
+        return Vec::new();
+    }
+    for mode in [MatchMode::Exact, MatchMode::Alias, MatchMode::Digest] {
+        let matches = matching_images(images, query, mode);
+        if !matches.is_empty() {
+            return matches;
+        }
+    }
+    Vec::new()
+}
+
 pub fn resolve_required_stored_image(
     images: &[StoredImage],
     query: &str,
@@ -179,17 +196,33 @@ fn ambiguous_reference_error(query: &str, matches: &[StoredImage]) -> String {
 }
 
 fn is_digest_reference(reference: &str) -> bool {
-    reference.starts_with("sha256:")
+    if reference.starts_with("sha256:") {
+        return true;
+    }
+    // A bare lowercase-hex string is a Docker image id (short id = 12 hex,
+    // full = 64). Tags/repos that happen to be all-hex are still matched first
+    // by Exact/Alias, so this only catches genuine id queries.
+    let len = reference.len();
+    (12..=64).contains(&len)
+        && reference
+            .bytes()
+            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
 }
 
 fn digest_matches(stored_digest: &str, query: &str) -> bool {
     if stored_digest == query {
         return true;
     }
-    let Some(query_hex) = query.strip_prefix("sha256:") else {
+    // Accept both `sha256:<hex>` and a bare `<hex>` query, prefix-matching the
+    // stored digest's hex (so `rmi 5b10f432ef3d` resolves the image).
+    let query_hex = query.strip_prefix("sha256:").unwrap_or(query);
+    if query_hex.is_empty() {
         return false;
-    };
-    !query_hex.is_empty() && stored_digest.starts_with(query)
+    }
+    let stored_hex = stored_digest
+        .strip_prefix("sha256:")
+        .unwrap_or(stored_digest);
+    stored_hex.starts_with(query_hex)
 }
 
 pub fn normalize_reference(reference: &str) -> String {
@@ -396,6 +429,21 @@ mod tests {
         assert!(digest_matches("sha256:abcdef123456", "sha256:abcdef123456"));
         assert!(digest_matches("sha256:abcdef123456", "sha256:abcdef"));
         assert!(!digest_matches("sha256:abcdef123456", "sha256:"));
-        assert!(!digest_matches("sha256:abcdef123456", "abcdef"));
+        // A bare hex query prefix-matches the stored digest's hex (Docker short id).
+        assert!(digest_matches("sha256:abcdef123456", "abcdef"));
+        assert!(!digest_matches("sha256:abcdef123456", "ffffff"));
+    }
+
+    #[test]
+    fn test_is_digest_reference_bare_hex_short_id() {
+        assert!(is_digest_reference("sha256:abc"));
+        // 12-hex Docker short id.
+        assert!(is_digest_reference("5b10f432ef3d"));
+        // Normal tags/repos are not treated as digests.
+        assert!(!is_digest_reference("alpine"));
+        assert!(!is_digest_reference("v1"));
+        assert!(!is_digest_reference("latest"));
+        // Uppercase hex is not a valid image id.
+        assert!(!is_digest_reference("5B10F432EF3D"));
     }
 }