isideload/examples/minimal/src/main.rs

use std::{env, path::PathBuf};

use idevice::usbmuxd::{UsbmuxdAddr, UsbmuxdConnection};
use isideload::{
    anisette::remote_v3::RemoteV3AnisetteProvider,
    auth::apple_account::AppleAccount,
    dev::{
        certificates::DevelopmentCertificate, developer_session::DeveloperSession,
        teams::DeveloperTeam,
    },
    sideload::{SideloaderBuilder, TeamSelection, builder::MaxCertsBehavior},
    util::keyring_storage::KeyringStorage,
};

use tracing::Level;
use tracing_subscriber::FmtSubscriber;

#[tokio::main]
async fn main() {
    isideload::init().expect("Failed to initialize error reporting");
    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::INFO)
        .finish();
    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");

    let args: Vec<String> = env::args().collect();

    let apple_id = args
        .get(1)
        .expect("Please provide the Apple ID to use for installation");
    let apple_password = args.get(2).expect("Please provide the Apple ID password");
    let app_path = PathBuf::from(
        args.get(3)
            .expect("Please provide the path to the app to install"),
    );

    let get_2fa_code = || {
        let mut code = String::new();
        println!("Enter 2FA code:");
        std::io::stdin().read_line(&mut code).unwrap();
        Some(code.trim().to_string())
    };

    let account = AppleAccount::builder(apple_id)
        .anisette_provider(RemoteV3AnisetteProvider::default().set_serial_number("2".to_string()))
        .login(apple_password, get_2fa_code)
        .await;

    let mut account = account.unwrap();

    let dev_session = DeveloperSession::from_account(&mut account)
        .await
        .expect("Failed to create developer session");

    let usbmuxd = UsbmuxdConnection::default().await;
    if usbmuxd.is_err() {
        panic!("Failed to connect to usbmuxd: {:?}", usbmuxd.err());
    }
    let mut usbmuxd = usbmuxd.unwrap();

    let devs = usbmuxd.get_devices().await.unwrap();
    if devs.is_empty() {
        panic!("No devices found");
    }

    let provider = devs
        .first()
        .unwrap()
        .to_provider(UsbmuxdAddr::from_env_var().unwrap(), "isideload-demo");

    let team_selection_prompt = |teams: &Vec<DeveloperTeam>| {
        println!("Please select a team:");
        for (index, team) in teams.iter().enumerate() {
            println!(
                "{}: {} ({})",
                index + 1,
                team.name.as_deref().unwrap_or("<Unnamed>"),
                team.team_id
            );
        }
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();
        let selection = input.trim().parse::<usize>().ok()?;
        if selection == 0 || selection > teams.len() {
            return None;
        }
        Some(teams[selection - 1].team_id.clone())
    };

    let cert_selection_prompt = |certs: &Vec<DevelopmentCertificate>| {
        println!("Maximum number of certificates reached. Please select certificates to revoke:");
        for (index, cert) in certs.iter().enumerate() {
            println!(
                "({}) {}: {}",
                index + 1,
                cert.name.as_deref().unwrap_or("<Unnamed>"),
                cert.machine_name.as_deref().unwrap_or("<No Machine Name>"),
            );
        }
        println!("Enter the numbers of the certificates to revoke, separated by commas:");
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();
        let selections: Vec<usize> = input
            .trim()
            .split(',')
            .filter_map(|s| s.trim().parse::<usize>().ok())
            .filter(|&n| n > 0 && n <= certs.len())
            .collect();
        if selections.is_empty() {
            return None;
        }
        Some(
            selections
                .into_iter()
                .map(|n| certs[n - 1].serial_number.clone().unwrap_or_default())
                .collect::<Vec<_>>(),
        )
    };

    let mut sideloader = SideloaderBuilder::new(dev_session, apple_id.to_string())
        .team_selection(TeamSelection::PromptOnce(team_selection_prompt))
        .max_certs_behavior(MaxCertsBehavior::Prompt(Box::new(cert_selection_prompt)))
        .storage(Box::new(KeyringStorage::new("minimal".to_string())))
        .machine_name("isideload-minimal".to_string())
        .build();

    let result = sideloader.install_app(&provider, app_path, true).await;
    match result {
        Ok(_) => println!("App installed successfully"),
        Err(e) => panic!("{}", e),
    }
}