Enhance iii-cli update functionality and documentation (#1)

- Updated README.md to clarify update commands for iii-cli and managed binaries.
- Modified cli.rs to reflect new self-update commands and improve help text.
- Implemented self-update functionality in update.rs to allow iii-cli to update itself.
- Adjusted main.rs to handle self-update logic and notify users after updating.
- Added SELF_SPEC for iii-cli in registry.rs to manage its update process and ensure platform support.
- Included tests for SELF_SPEC to validate its properties and ensure it is not part of the binary registry.

Author: andersonleal

README.md

@@ -124,13 +124,20 @@ Output example:
 
 ### Update Binaries
 
-Update all installed binaries to their latest versions:
+Update iii-cli and all installed binaries to their latest versions:
 
 ```bash
 iii-cli update
 ```
 
-Update a specific binary:
+Update only iii-cli itself:
+
+```bash
+iii-cli update self
+iii-cli update iii-cli
+```
+
+Update a specific managed binary:
 
 ```bash
 iii-cli update console

src/cli.rs

@@ -5,7 +5,7 @@ use clap::{Parser, Subcommand};
     name = "iii-cli",
     about = "Unified CLI dispatcher for iii tools",
     version,
-    after_help = "COMMANDS:\n  console    Launch the iii web console\n  create     Create a new iii project from a template\n  motia      Create a new Motia project from a template\n  start      Start the iii process communication engine\n  update     Update managed binaries to their latest versions\n  list       Show installed binaries and their versions"
+    after_help = "COMMANDS:\n  console    Launch the iii web console\n  create     Create a new iii project from a template\n  motia      Create a new Motia project from a template\n  start      Start the iii process communication engine\n  update     Update iii-cli and managed binaries to their latest versions\n  list       Show installed binaries and their versions\n\nSELF-UPDATE:\n  iii-cli update              Update iii-cli + all managed binaries\n  iii-cli update self         Update only iii-cli\n  iii-cli update iii-cli      Update only iii-cli\n  iii-cli update console      Update only iii-console"
 )]
 pub struct Cli {
     /// Disable background update and advisory checks
@@ -62,10 +62,11 @@ pub enum Commands {
         args: Vec<String>,
     },
 
-    /// Update managed binaries to their latest versions
+    /// Update iii-cli and managed binaries to their latest versions
     Update {
-        /// Specific command or binary to update (e.g., "console", "create").
-        /// If omitted, updates all installed binaries.
+        /// Specific command or binary to update (e.g., "console", "self").
+        /// Use "self" or "iii-cli" to update only iii-cli.
+        /// If omitted, updates iii-cli and all installed binaries.
         #[arg(name = "command")]
         target: Option<String>,
     },

src/main.rs

@@ -229,6 +229,10 @@ async fn handle_update(target: Option<&str>) -> i32 {
     }
 
     let results = match target {
+        Some("iii-cli" | "self") => {
+            // Self-update only
+            vec![update::self_update(&client, &mut app_state).await]
+        }
         Some(cmd) => {
             // Update specific binary
             let spec = match registry::resolve_binary_for_update(cmd) {
@@ -241,15 +245,30 @@ async fn handle_update(target: Option<&str>) -> i32 {
             vec![update::update_binary(&client, spec, &mut app_state).await]
         }
         None => {
-            // Update all
+            // Update all (includes self-update)
             eprintln!("  Checking all binaries for updates...");
             update::update_all(&client, &mut app_state).await
         }
     };
 
     // Print results
+    let mut self_updated = false;
     for result in &results {
         update::print_update_result(result);
+        if let Ok(update::UpdateResult::Updated { binary, .. }) = result {
+            if binary == "iii-cli" {
+                self_updated = true;
+            }
+        }
+    }
+
+    // Print restart note after self-update
+    if self_updated {
+        eprintln!();
+        eprintln!(
+            "  {} iii-cli has been updated. Restart your shell or run the command again to use the new version.",
+            "note:".cyan(),
+        );
     }
 
     // Save state

src/registry.rs

@@ -24,6 +24,24 @@ pub struct CommandMapping {
     pub binary_subcommand: Option<&'static str>,
 }
 
+/// Specification for iii-cli itself (the dispatcher).
+/// Kept separate from REGISTRY because iii-cli is not a dispatched binary.
+pub static SELF_SPEC: BinarySpec = BinarySpec {
+    name: "iii-cli",
+    repo: "iii-hq/iii-cli",
+    has_checksum: true,
+    supported_targets: &[
+        "aarch64-apple-darwin",
+        "x86_64-apple-darwin",
+        "x86_64-pc-windows-msvc",
+        "aarch64-pc-windows-msvc",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-gnu",
+    ],
+    commands: &[],
+};
+
 /// The compiled-in binary registry
 pub static REGISTRY: &[BinarySpec] = &[
     BinarySpec {
@@ -226,4 +244,37 @@ mod tests {
         assert!(spec.has_checksum);
     }
 
+    #[test]
+    fn test_self_spec_fields() {
+        assert_eq!(SELF_SPEC.name, "iii-cli");
+        assert_eq!(SELF_SPEC.repo, "iii-hq/iii-cli");
+        assert!(SELF_SPEC.has_checksum);
+        assert!(SELF_SPEC.commands.is_empty());
+    }
+
+    #[test]
+    fn test_self_spec_supported_targets() {
+        assert!(SELF_SPEC.supported_targets.contains(&"aarch64-apple-darwin"));
+        assert!(SELF_SPEC.supported_targets.contains(&"x86_64-apple-darwin"));
+        assert!(SELF_SPEC.supported_targets.contains(&"x86_64-unknown-linux-gnu"));
+        assert!(SELF_SPEC.supported_targets.contains(&"x86_64-unknown-linux-musl"));
+        assert!(SELF_SPEC.supported_targets.contains(&"aarch64-unknown-linux-gnu"));
+        assert!(SELF_SPEC.supported_targets.contains(&"x86_64-pc-windows-msvc"));
+        assert!(SELF_SPEC.supported_targets.contains(&"aarch64-pc-windows-msvc"));
+        assert_eq!(SELF_SPEC.supported_targets.len(), 7);
+    }
+
+    #[test]
+    fn test_self_spec_not_in_registry() {
+        for spec in REGISTRY {
+            assert_ne!(spec.name, "iii-cli", "iii-cli should not be in REGISTRY");
+        }
+    }
+
+    #[test]
+    fn test_self_spec_platform_support() {
+        let result = crate::platform::check_platform_support(&SELF_SPEC);
+        assert!(result.is_ok());
+    }
+
 }

src/update.rs

@@ -194,11 +194,85 @@ pub async fn update_binary(
     })
 }
 
-/// Update all installed binaries.
+/// Update iii-cli itself to the latest version.
+pub async fn self_update(
+    client: &reqwest::Client,
+    state: &mut AppState,
+) -> Result<UpdateResult, UpdateError> {
+    let spec = &registry::SELF_SPEC;
+
+    platform::check_platform_support(spec)?;
+
+    eprintln!("  Checking for updates to {}...", spec.name);
+
+    let release = github::fetch_latest_release(client, spec).await?;
+    let latest_version = github::parse_release_version(&release.tag_name)
+        .map_err(|e| UpdateError::VersionParse(e.to_string()))?;
+
+    let current_version = Version::parse(env!("CARGO_PKG_VERSION"))
+        .expect("CARGO_PKG_VERSION is always valid semver");
+
+    if current_version >= latest_version {
+        return Ok(UpdateResult::AlreadyUpToDate {
+            binary: spec.name.to_string(),
+            version: current_version,
+        });
+    }
+
+    let asset_name = platform::asset_name(spec.name);
+    let asset = github::find_asset(&release, &asset_name).ok_or_else(|| {
+        UpdateError::Github(IiiGithubError::Network(
+            crate::error::NetworkError::AssetNotFound {
+                binary: spec.name.to_string(),
+                platform: platform::current_target().to_string(),
+            },
+        ))
+    })?;
+
+    let checksum_url = if spec.has_checksum {
+        let checksum_name = platform::checksum_asset_name(spec.name);
+        github::find_asset(&release, &checksum_name)
+            .map(|a| a.browser_download_url.clone())
+    } else {
+        None
+    };
+
+    eprintln!(
+        "  Updating {} to v{}...",
+        spec.name,
+        latest_version
+    );
+
+    // Install to the standard managed location (~/.local/bin/iii-cli),
+    // consistent with install.sh and other managed binaries.
+    let target_path = platform::binary_path(spec.name);
+
+    download::download_and_install(
+        client,
+        spec,
+        asset,
+        checksum_url.as_deref(),
+        &target_path,
+    )
+    .await?;
+
+    state.record_install(spec.name, latest_version.clone(), asset_name);
+
+    Ok(UpdateResult::Updated {
+        binary: spec.name.to_string(),
+        from: Some(current_version),
+        to: latest_version,
+    })
+}
+
+/// Update all installed binaries (including iii-cli itself).
 pub async fn update_all(
     client: &reqwest::Client,
     state: &mut AppState,
 ) -> Vec<Result<UpdateResult, UpdateError>> {
+    // Self-update first
+    let mut results = vec![self_update(client, state).await];
+
     let specs: Vec<&BinarySpec> = registry::all_binaries()
         .into_iter()
         .filter(|spec| {
@@ -208,7 +282,6 @@ pub async fn update_all(
         })
         .collect();
 
-    let mut results = Vec::new();
     for spec in specs {
         results.push(update_binary(client, spec, state).await);
     }