restorekit-cli 0.4.3

use std::path::PathBuf;

use clap::{Parser, Subcommand};

mod commands;

#[derive(Parser)]
#[command(name = "restorekit", version, about = "DFU-restore Apple Silicon Macs")]
struct Cli {
    /// Emit machine-readable JSON lines instead of human output.
    #[arg(long, global = true)]
    json: bool,

    /// Firmware cache directory (default: $XDG_CONFIG_HOME/restorekit/firmwares).
    #[arg(long, global = true)]
    cache_dir: Option<PathBuf>,

    /// Verbose output (streams idevicerestore's detailed restore log).
    #[arg(short, long, global = true)]
    verbose: bool,

    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// List every connected Apple device, with its mode and ECID.
    List,
    /// Reboot the cabled target Mac into DFU mode (Apple Silicon macOS host, root).
    Dfu(TargetArgs),
    /// Reboot the cabled target Mac back into normal mode.
    Reboot(TargetArgs),
    /// Resolve and download firmware for the detected (or specified) Mac.
    Download {
        /// Model identifier (e.g. MacBookPro17,1). Defaults to the DFU device.
        #[arg(long)]
        identifier: Option<String>,
        /// Pin a macOS version (e.g. 26.5.2). Defaults to the latest signed build.
        #[arg(long)]
        os_version: Option<String>,
        /// Detect the model from a specific Mac by ECID (hex like 0xc60a812345678,
        /// or decimal) when several are in DFU mode. See `restorekit list`.
        #[arg(long, value_parser = parse_ecid)]
        ecid: Option<u64>,
    },
    /// Erase and restore the target Mac: triggers DFU entry if needed, then
    /// downloads firmware and restores. This wipes all data on the target.
    Restore(RestoreArgs),
    /// Revive the target Mac: reinstall firmware without erasing user data —
    /// use this to recover a Mac bricked by a failed update.
    Revive(ReviveArgs),
    /// Show or manage the firmware cache.
    Cache {
        /// Delete all cached firmware.
        #[arg(long)]
        clear: bool,
        /// Print only the cache directory path.
        #[arg(long)]
        path: bool,
    },
    /// Show, export, or clear the capture/restore history.
    #[cfg(feature = "history")]
    History {
        #[command(subcommand)]
        action: HistoryAction,
    },
    /// Bind the WinUSB driver so restorekit can reach the cabled Mac (elevates).
    #[cfg(target_os = "windows")]
    SetupDriver {
        /// Internal: this copy was relaunched already elevated.
        #[arg(long, hide = true)]
        elevated: bool,
        /// Internal: file the elevated copy writes its outcome to.
        #[arg(long, hide = true)]
        result_file: Option<PathBuf>,
    },
}

/// Which cabled target `dfu` / `reboot` should act on. With neither flag, the
/// host's sole DFU-capable port is used.
#[derive(clap::Args)]
struct TargetArgs {
    /// Target the Mac with this ECID (hex like 0xc60a812345678, or decimal),
    /// resolving the DFU port it's cabled to. See `restorekit list`.
    #[arg(long, value_parser = parse_ecid, conflicts_with = "port")]
    ecid: Option<u64>,
    /// Target a specific DFU-capable port by its RID. See `restorekit list`.
    #[arg(long)]
    port: Option<i32>,
}

impl TargetArgs {
    fn into_target(self) -> restorekit::DfuTarget {
        match (self.ecid, self.port) {
            (Some(e), _) => restorekit::DfuTarget::Ecid(e),
            (_, Some(rid)) => restorekit::DfuTarget::Port(rid),
            _ => restorekit::DfuTarget::Auto,
        }
    }
}

#[cfg(feature = "history")]
#[derive(Subcommand)]
enum HistoryAction {
    /// List logged devices, newest first.
    List,
    /// Export the whole history to a CSV file.
    Export {
        /// Destination CSV path.
        path: PathBuf,
    },
    /// Delete all logged history.
    Clear,
}

/// Firmware selection and target arguments shared by `restore` and `revive`.
#[derive(clap::Args)]
struct FirmwareArgs {
    /// Restore from a local IPSW instead of downloading.
    #[arg(long)]
    ipsw: Option<PathBuf>,
    /// Pin a macOS version (e.g. 26.5.2).
    #[arg(long)]
    os_version: Option<String>,
    /// Override the detected model identifier.
    #[arg(long)]
    identifier: Option<String>,
    /// Target a specific Mac by ECID (hex like 0xc60a812345678, or decimal)
    /// when several are in DFU mode. See `restorekit list`.
    #[arg(long, value_parser = parse_ecid)]
    ecid: Option<u64>,
}

#[derive(clap::Args)]
struct RestoreArgs {
    #[command(flatten)]
    firmware: FirmwareArgs,
    /// Skip the erase confirmation prompt.
    #[arg(long)]
    yes: bool,
}

#[derive(clap::Args)]
struct ReviveArgs {
    #[command(flatten)]
    firmware: FirmwareArgs,
}

/// Parse an ECID: `0x`-prefixed or bare hex, or decimal.
fn parse_ecid(s: &str) -> Result<u64, String> {
    let s = s.trim();
    let parsed = if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
        u64::from_str_radix(hex, 16)
    } else if s.bytes().all(|b| b.is_ascii_digit()) {
        s.parse()
    } else {
        u64::from_str_radix(s, 16)
    };
    parsed.map_err(|_| format!("invalid ECID '{s}': expected hex (0x…) or decimal"))
}

impl FirmwareArgs {
    fn into_opts(
        self,
        revive: bool,
        yes: bool,
        cache_dir: Option<PathBuf>,
        json: bool,
        verbose: bool,
    ) -> commands::restore::Opts {
        commands::restore::Opts {
            revive,
            ipsw: self.ipsw,
            os_version: self.os_version,
            identifier: self.identifier,
            ecid: self.ecid,
            yes,
            cache_dir,
            json,
            verbose,
        }
    }
}

fn main() {
    // Internal: this copy was relaunched elevated to run the restore-mode driver
    // watcher (see restorekit::driver). Handle it before clap and exit.
    #[cfg(target_os = "windows")]
    {
        let args: Vec<String> = std::env::args().collect();
        if let Some(i) = args
            .iter()
            .position(|a| a == restorekit::driver::RESTORE_WATCH_ARG)
        {
            if let Some(liveness) = args.get(i + 1) {
                restorekit::driver::run_restore_mode_watch_worker(std::path::Path::new(liveness));
            }
            return;
        }
    }

    let cli = Cli::parse();
    let result = match cli.command {
        Command::List => commands::list::run(cli.json),
        Command::Dfu(t) => commands::dfu::enter(cli.json, t.into_target()),
        Command::Reboot(t) => commands::dfu::reboot(cli.json, t.into_target()),
        Command::Download {
            identifier,
            os_version,
            ecid,
        } => commands::download::run(identifier, os_version, ecid, cli.cache_dir, cli.json),
        Command::Restore(args) => commands::restore::run(args.firmware.into_opts(
            false,
            args.yes,
            cli.cache_dir,
            cli.json,
            cli.verbose,
        )),
        Command::Revive(args) => commands::restore::run(args.firmware.into_opts(
            true,
            false,
            cli.cache_dir,
            cli.json,
            cli.verbose,
        )),
        Command::Cache { clear, path } => commands::cache::run(cli.cache_dir, clear, path),
        #[cfg(feature = "history")]
        Command::History { action } => match action {
            HistoryAction::List => commands::history::list(cli.json),
            HistoryAction::Export { path } => commands::history::export(path),
            HistoryAction::Clear => commands::history::clear(),
        },
        #[cfg(target_os = "windows")]
        Command::SetupDriver {
            elevated,
            result_file,
        } => commands::setup_driver::run(cli.json, elevated, result_file),
    };

    if let Err(e) = result {
        if cli.json {
            println!(
                "{}",
                serde_json::json!({ "event": "error", "message": e.to_string() })
            );
        } else {
            eprintln!("error: {e}");
        }
        std::process::exit(1);
    }
}

#[cfg(test)]
mod tests {
    use super::parse_ecid;

    #[test]
    fn parses_ecid_forms() {
        assert_eq!(parse_ecid("0xC60A812345678").unwrap(), 0xc60a812345678);
        assert_eq!(parse_ecid("0Xc60a812345678").unwrap(), 0xc60a812345678);
        assert_eq!(parse_ecid("12345").unwrap(), 12345);
        assert_eq!(parse_ecid("c60a812345678").unwrap(), 0xc60a812345678);
        assert!(parse_ecid("nope!").is_err());
        assert!(parse_ecid("").is_err());
    }
}