restorekit-cli 0.4.3

CLI for DFU-restoring Apple Silicon Macs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use std::path::PathBuf;

use indicatif::ProgressBar;
use restorekit::progress::Event;
use restorekit::{firmware, Error, Result};

use super::render;

/// Resolve and download firmware. With no `identifier`, detects the DFU device
/// and resolves firmware for it automatically.
pub fn run(
    identifier: Option<String>,
    os_version: Option<String>,
    ecid: Option<u64>,
    cache_dir: Option<PathBuf>,
    json: bool,
) -> Result<()> {
    let identifier = match identifier {
        Some(id) => id,
        None => {
            let device = super::dfu::select_device(ecid, json)?;
            let identity = device
                .identity
                .as_ref()
                .expect("selected device carries an identity");
            let id = device
                .identifier()
                .ok_or(Error::UnknownModel {
                    cpid: identity.cpid,
                    bdid: identity.bdid,
                })?
                .to_string();
            if !json {
                println!(
                    "Detected {} in {} mode.",
                    device.display_name(),
                    device.mode
                );
            }
            id
        }
    };

    if !json {
        println!("Resolving firmware for {identifier}...");
    }
    let fw = firmware::resolve(&identifier, os_version.as_deref())?;

    if json {
        render::emit_json(&Event::FirmwareResolved {
            identifier: fw.identifier.clone(),
            version: fw.version.clone(),
            build: fw.build.clone(),
            size: fw.size,
            url: fw.url.clone(),
        });
    } else {
        println!(
            "  macOS {} (build {}), {:.1} GB",
            fw.version,
            fw.build,
            fw.size as f64 / 1e9
        );
    }

    let cache = match cache_dir {
        Some(d) => d,
        None => firmware::default_cache_dir()?,
    };

    let bar = ProgressBar::hidden();
    let path = firmware::download(&cache, &fw, &mut |event| {
        render::download(&bar, event, json)
    })?;
    bar.finish_and_clear();

    if !json {
        println!("Firmware ready: {}", path.display());
    }
    Ok(())
}