run_stack/

self_update.rs

//! `rst self-update`: refresh a cargo-installed binary and migrate configs.
//!
//! The npm package's self-update lives in its Node CLI. This binary is
//! installed via cargo, so the equivalent is `cargo install run-stack --force`,
//! then JSON→TOML and essential-services config migration.

use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;

use anyhow::{Context, Result};

use crate::config::Config;
use crate::workspace::Workspace;

const CRATE_NAME: &str = "run-stack";

pub fn run(verbose: bool) -> Result<i32> {
    let current = env!("CARGO_PKG_VERSION");
    let latest = latest_crates_version(CRATE_NAME);

    match latest.as_deref() {
        Some(latest) if latest == current => {
            println!("Already on latest ({current}). Nothing to install.");
        }
        Some(latest) if !is_newer(latest, current) => {
            println!(
                "Local {current} is newer than crates.io {latest} — skipping install."
            );
        }
        Some(latest) => {
            println!("Updating {CRATE_NAME} {current} → {latest} via cargo ...");
            let code = cargo_install(CRATE_NAME, Some(latest), verbose)?;
            if code != 0 {
                return Ok(code);
            }
            println!();
            println!("Updated to {latest}.");
        }
        None => {
            println!(
                "Updating {CRATE_NAME} from {current} via cargo \
                 (could not resolve latest, using crates.io default) ..."
            );
            let code = cargo_install(CRATE_NAME, None, verbose)?;
            if code != 0 {
                return Ok(code);
            }
            println!();
            println!("Updated to latest.");
        }
    }

    let migrated = migrate_configs()?;
    if migrated > 0 {
        println!("Migrated config in {migrated} workspace(s).");
    } else {
        println!("Config-layout workspaces pick up new defaults on the next command.");
    }
    println!("Verify: rst --version");
    Ok(0)
}

fn cargo_install(name: &str, version: Option<&str>, verbose: bool) -> Result<i32> {
    let mut args = vec!["install".to_string(), name.to_string(), "--force".into()];
    if let Some(version) = version {
        args.push("--version".into());
        args.push(version.to_string());
    }
    if verbose {
        args.push("--verbose".into());
    }
    println!("  $ cargo {}", args.join(" "));
    let status = Command::new("cargo")
        .args(&args)
        .status()
        .context("running cargo — is the Rust toolchain installed?")?;
    Ok(status.code().unwrap_or(1))
}

fn latest_crates_version(name: &str) -> Option<String> {
    let output = Command::new("cargo")
        .args(["search", name, "--limit", "1"])
        .env("CARGO_TERM_COLOR", "never")
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let text = String::from_utf8_lossy(&output.stdout);
    let line = text.lines().next()?;
    let start = line.find('"')? + 1;
    let end = line[start..].find('"')? + start;
    let version = line[start..end].to_string();
    if parse_version(&version).is_some() {
        Some(version)
    } else {
        None
    }
}

fn parse_version(text: &str) -> Option<(u64, u64, u64)> {
    let mut parts = text.split('.');
    let major = parts.next()?.parse().ok()?;
    let minor = parts.next()?.parse().ok()?;
    let patch = parts.next().unwrap_or("0").parse().ok()?;
    Some((major, minor, patch))
}

fn is_newer(candidate: &str, current: &str) -> bool {
    match (parse_version(candidate), parse_version(current)) {
        (Some(left), Some(right)) => left > right,
        _ => candidate != current,
    }
}

/// JSON→TOML and missing `essential`, for every known workspace.
pub fn migrate_configs() -> Result<usize> {
    let mut count = 0;
    for root in known_workspace_roots() {
        if migrate_workspace(&root)? {
            count += 1;
        }
    }
    Ok(count)
}

fn migrate_workspace(root: &Path) -> Result<bool> {
    let run_dir = root.join(".run");
    let toml_path = run_dir.join("run.config.toml");
    let json_path = run_dir.join("run.config.json");

    let source = if toml_path.is_file() {
        toml_path.clone()
    } else if json_path.is_file() {
        json_path.clone()
    } else {
        return Ok(false);
    };

    let mut config = Config::load(&source)?;
    let mut changed = config.ensure_essential();
    let from_json = source
        .extension()
        .is_some_and(|ext| ext.eq_ignore_ascii_case("json"));
    if from_json || changed || source != toml_path {
        config.save(&toml_path)?;
        changed = true;
        if from_json {
            let _ = fs::remove_file(&source);
            eprintln!(
                "Migrated {} → {}",
                source.display(),
                toml_path.display()
            );
        } else if changed {
            eprintln!("Updated {}", toml_path.display());
        }
    }
    Ok(changed)
}

fn known_workspace_roots() -> Vec<PathBuf> {
    let mut roots = Vec::new();
    if let Ok(cwd) = env::current_dir() {
        if let Ok(workspace) = Workspace::find(&cwd) {
            roots.push(workspace.root);
        }
    }
    if let Some(home) = env::var_os("HOME") {
        let registry = PathBuf::from(home).join(".run/services.json");
        if let Ok(text) = fs::read_to_string(&registry) {
            if let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) {
                if let Some(object) = value.as_object() {
                    for key in object.keys() {
                        let root = PathBuf::from(key);
                        let has = root.join(".run/run.config.toml").is_file()
                            || root.join(".run/run.config.json").is_file();
                        if has && !roots.iter().any(|existing| existing == &root) {
                            roots.push(root);
                        }
                    }
                }
            }
        }
    }
    roots
}