1use std::path::{Path, PathBuf};
10use std::sync::OnceLock;
11
12use ipatool_core::api::{auth, bag, download as core_download, purchase as core_purchase, versions};
13use ipatool_core::client::AppleClient;
14use ipatool_core::guid::generate_machine_identity;
15use ipatool_core::ipa::patch::patch_ipa;
16use ipatool_core::model::Account;
17use ipatool_core::sap::{self, ActionSigner};
18use tokio::runtime::Runtime;
19
20use crate::client::{AuthInfo, DownloadRequest, LoginRequest, VersionInfo};
21use crate::error::{IpatoolError, Result};
22use crate::purchases::{self, OwnedApp};
23use crate::session;
24
25fn runtime() -> &'static Runtime {
26 static RT: OnceLock<Runtime> = OnceLock::new();
27 RT.get_or_init(|| {
28 tokio::runtime::Builder::new_multi_thread()
29 .enable_all()
30 .build()
31 .expect("tokio runtime")
32 })
33}
34
35fn map_err(e: impl std::fmt::Display) -> IpatoolError {
36 IpatoolError::msg(e.to_string())
37}
38
39fn new_client() -> Result<AppleClient> {
40 session::ensure_dirs()?;
41 let machine = generate_machine_identity().map_err(map_err)?;
42 let cookies = session::cookies_path();
43 let cache = session::cache_dir().ok_or_else(|| IpatoolError::msg("HOME not set"))?;
44 AppleClient::new(machine, cookies.as_deref(), cache).map_err(map_err)
45}
46
47fn save_cookies(client: &AppleClient) {
48 if let Some(path) = session::cookies_path() {
49 if client.save_cookies(&path).is_ok() {
50 session::chmod_secret_file(&path);
51 }
52 }
53}
54
55fn note(progress: &mut dyn FnMut(&str), msg: &str) {
56 progress(msg);
57}
58
59pub fn sap_cache_ready() -> bool {
61 let Some(dir) = session::cache_dir() else {
62 return false;
63 };
64 ["CommerceKit", "CommerceCore", "CoreFP", "CoreFP.icxs"]
65 .iter()
66 .all(|name| dir.join(name).is_file())
67}
68
69fn sap_progress_msg() -> &'static str {
70 if sap_cache_ready() {
71 "progress.sap_cached"
72 } else {
73 "progress.sap_download"
74 }
75}
76
77pub(crate) fn normalize_auth_code(code: Option<&str>) -> Result<Option<String>> {
79 let Some(code) = code else {
80 return Ok(None);
81 };
82 let mut code = code.trim().to_string();
83 if code.starts_with("\u{1b}[200~") && code.ends_with("\u{1b}[201~") {
84 code = code
85 .trim_start_matches("\u{1b}[200~")
86 .trim_end_matches("\u{1b}[201~")
87 .to_string();
88 }
89 let digits: String = code.chars().filter(|c| !c.is_whitespace()).collect();
90 if digits.is_empty() {
91 return Ok(None);
92 }
93 if digits.len() != 6 || !digits.chars().all(|c| c.is_ascii_digit()) {
94 return Err(IpatoolError::msg("2FA code must contain exactly six digits"));
95 }
96 Ok(Some(digits))
97}
98
99pub fn auth_info() -> Result<AuthInfo> {
100 let Some(acc) = session::load_account()? else {
101 return Err(IpatoolError::msg("not logged in"));
102 };
103 Ok(AuthInfo {
104 email: acc.email,
105 name: acc.name,
106 storefront: acc.store_front,
107 success: true,
108 })
109}
110
111pub fn login(req: &LoginRequest) -> Result<AuthInfo> {
112 login_with(req, &mut |_| {})
113}
114
115pub fn login_with(req: &LoginRequest, progress: &mut dyn FnMut(&str)) -> Result<AuthInfo> {
116 note(progress, "progress.preparing_session");
117 session::ensure_dirs()?;
118 let auth_code = normalize_auth_code(req.auth_code.as_deref())?;
119 let mut client = new_client()?;
120
121 note(progress, "progress.fetch_bag");
122 let bag_cfg = runtime()
123 .block_on(bag::fetch_bag(&client))
124 .map_err(map_err)?;
125
126 note(progress, sap_progress_msg());
127 let signer = runtime()
128 .block_on(sap::new_default_signer(
129 &client,
130 &bag_cfg.sap,
131 client.hardware_id(),
132 ))
133 .map_err(map_err)?;
134
135 note(
136 progress,
137 if auth_code.is_some() {
138 "progress.auth_2fa"
139 } else {
140 "progress.auth"
141 },
142 );
143 let account = runtime()
144 .block_on(auth::login(
145 &client,
146 &req.email,
147 &req.password,
148 auth_code.as_deref(),
149 &bag_cfg.auth_endpoint,
150 Some(&signer as &dyn ActionSigner),
151 ))
152 .map_err(|e| {
153 let s = e.to_string();
154 let lower = s.to_lowercase();
155 if auth_code.is_some()
156 && (lower.contains("badlogin")
157 || lower.contains("verification")
158 || lower.contains("auth code"))
159 {
160 IpatoolError::msg("apple did not complete verification; try a fresh 2FA code")
161 } else if lower.contains("auth code")
162 || lower.contains("2fa")
163 || lower.contains("verification")
164 || lower.contains("badlogin")
165 {
166 IpatoolError::msg("auth code required")
167 } else {
168 map_err(e)
169 }
170 })?;
171
172 note(progress, "progress.saving_session");
174 let mut account = account;
175 account.password = Some(req.password.clone());
176 client.set_account(account.clone());
177 session::save_account(&account)?;
178 save_cookies(&client);
179
180 note(progress, "progress.login_complete");
181 Ok(AuthInfo {
182 email: account.email,
183 name: account.name,
184 storefront: account.store_front,
185 success: true,
186 })
187}
188
189pub fn revoke() -> Result<()> {
190 session::delete_account()?;
191 if let Some(p) = session::cookies_path() {
192 let _ = std::fs::remove_file(p);
193 }
194 Ok(())
195}
196
197pub fn require_account() -> Result<Account> {
198 session::load_account()?.ok_or_else(|| IpatoolError::msg("not logged in"))
199}
200
201pub fn purchase(app_id: i64) -> Result<()> {
202 purchase_with(app_id, &mut |_| {})
203}
204
205pub fn purchase_with(app_id: i64, progress: &mut dyn FnMut(&str)) -> Result<()> {
206 note(progress, "progress.loading_account");
207 let account = require_account()?;
208 let client = new_client()?;
209 note(progress, "progress.purchasing");
210 runtime()
211 .block_on(core_purchase::purchase(&client, app_id, &account))
212 .map_err(map_err)?;
213 save_cookies(&client);
214 note(progress, "progress.purchase_done");
215 Ok(())
216}
217
218pub fn list_versions(app_id: i64) -> Result<Vec<String>> {
219 list_versions_with(app_id, &mut |_| {})
220}
221
222pub fn list_versions_with(app_id: i64, progress: &mut dyn FnMut(&str)) -> Result<Vec<String>> {
223 note(progress, "progress.loading_account");
224 let account = require_account()?;
225 let client = new_client()?;
226 note(progress, "progress.fetch_versions");
227 let out = runtime()
228 .block_on(versions::list_versions(&client, app_id, &account))
229 .map_err(map_err)?;
230 Ok(out
231 .versions
232 .into_iter()
233 .map(|v| v.external_version_id)
234 .collect())
235}
236
237pub fn get_version_metadata(app_id: i64, external_version_id: &str) -> Result<VersionInfo> {
238 get_version_metadata_with(app_id, external_version_id, &mut |_| {})
239}
240
241pub fn get_version_metadata_with(
242 app_id: i64,
243 external_version_id: &str,
244 progress: &mut dyn FnMut(&str),
245) -> Result<VersionInfo> {
246 note(progress, "progress.version_meta");
247 let account = require_account()?;
248 let client = new_client()?;
249 let meta = runtime()
250 .block_on(versions::get_version_metadata(
251 &client,
252 app_id,
253 &account,
254 external_version_id,
255 ))
256 .map_err(map_err)?;
257 Ok(VersionInfo {
258 external_id: external_version_id.to_string(),
259 display_version: meta
260 .bundle_short_version
261 .or(meta.bundle_version)
262 .unwrap_or_default(),
263 release_date: meta.release_date.unwrap_or_default(),
264 })
265}
266
267pub fn download(req: &DownloadRequest) -> Result<String> {
268 download_with(req, &mut |_| {}, false)
269}
270
271pub fn download_with(
273 req: &DownloadRequest,
274 progress: &mut dyn FnMut(&str),
275 show_file_progress: bool,
276) -> Result<String> {
277 let app_id = req
278 .app_id
279 .ok_or_else(|| IpatoolError::msg("app id required"))?;
280 note(progress, "progress.loading_account");
281 let mut account = require_account()?;
282 let client = new_client()?;
283
284 let item = {
288 let mut last_err: Option<ipatool_core::error::ClientError> = None;
289 let mut acquired_license = false;
290 let mut downloaded = None;
291
292 for _ in 0..3 {
293 if last_err.as_ref().is_some_and(|e| e.is_token_expired()) {
294 if account.password.is_none() {
295 break;
296 }
297 note(progress, "progress.reauth");
298 note(progress, "progress.fetch_bag");
299 let bag_cfg = runtime()
300 .block_on(bag::fetch_bag(&client))
301 .map_err(map_err)?;
302 note(progress, sap_progress_msg());
303 let signer = runtime()
304 .block_on(sap::new_default_signer(
305 &client,
306 &bag_cfg.sap,
307 client.hardware_id(),
308 ))
309 .map_err(map_err)?;
310 let pw = account.password.clone().unwrap();
311 note(progress, "progress.auth");
312 account = runtime()
313 .block_on(auth::login(
314 &client,
315 &account.email,
316 &pw,
317 None,
318 &bag_cfg.auth_endpoint,
319 Some(&signer as &dyn ActionSigner),
320 ))
321 .map_err(map_err)?;
322 account.password = Some(pw);
323 session::save_account(&account)?;
324 save_cookies(&client);
325 }
326
327 if last_err.as_ref().is_some_and(|e| e.is_license_not_found())
328 && req.purchase
329 && !acquired_license
330 {
331 note(progress, "progress.ensure_license");
332 match runtime().block_on(core_purchase::purchase(&client, app_id, &account)) {
333 Ok(()) => {}
334 Err(e) if e.is_license_already_exists() => {}
335 Err(e) => return Err(map_err(e)),
336 }
337 acquired_license = true;
338 save_cookies(&client);
339 }
340
341 note(
342 progress,
343 if last_err.is_some() {
344 "progress.retry_download_info"
345 } else {
346 "progress.download_info"
347 },
348 );
349 match runtime().block_on(core_download::get_download_info(
350 &client,
351 app_id,
352 &account,
353 req.external_version_id.as_deref(),
354 )) {
355 Ok(item) => {
356 downloaded = Some(item);
357 break;
358 }
359 Err(e) => {
360 let retry = (e.is_token_expired() && account.password.is_some())
361 || (e.is_license_not_found() && req.purchase && !acquired_license);
362 last_err = Some(e);
363 if !retry {
364 break;
365 }
366 }
367 }
368 }
369
370 match downloaded {
371 Some(item) => item,
372 None => {
373 return Err(map_err(
374 last_err.unwrap_or_else(|| {
375 ipatool_core::error::ClientError::UnexpectedResponse(
376 "download failed".into(),
377 )
378 }),
379 ))
380 }
381 }
382 };
383
384 let out = req
385 .output
386 .clone()
387 .unwrap_or_else(|| format!("{app_id}.ipa"));
388 let out_path = PathBuf::from(&out);
389 let tmp = out_path.with_extension("ipa.partial");
390
391 note(progress, "progress.downloading_ipa");
392 runtime()
393 .block_on(core_download::download_file(
394 &client,
395 &item.url,
396 &tmp,
397 show_file_progress,
398 ))
399 .map_err(map_err)?;
400
401 note(progress, "progress.patching");
402 patch_ipa(&tmp, &out_path, &item, &account.email).map_err(map_err)?;
403 let _ = std::fs::remove_file(&tmp);
404 save_cookies(&client);
405 note(progress, "progress.download_complete");
406 Ok(out_path.display().to_string())
407}
408
409pub fn list_purchases() -> Result<Vec<OwnedApp>> {
410 list_purchases_with(&mut |_| {})
411}
412
413pub fn list_purchases_with(progress: &mut dyn FnMut(&str)) -> Result<Vec<OwnedApp>> {
414 note(progress, "progress.loading_account");
415 let account = require_account()?;
416 let client = new_client()?;
417
418 note(progress, "progress.fetch_bag");
419 let bag = runtime()
420 .block_on(bag::fetch_bag(&client))
421 .map_err(map_err)?;
422
423 note(progress, sap_progress_msg());
424 let signer = runtime()
425 .block_on(sap::new_default_signer(
426 &client,
427 &bag.sap,
428 client.hardware_id(),
429 ))
430 .map_err(map_err)?;
431
432 note(progress, "progress.history_ios");
433 let mut apps = runtime().block_on(purchases::fetch_owned_apps_store(
434 &client, &account, &signer, "34",
435 ))?;
436 note(progress, "progress.history_mac");
437 apps.extend(runtime().block_on(purchases::fetch_owned_apps_store(
438 &client, &account, &signer, "13",
439 ))?);
440 let apps = purchases::merge_apps(apps);
441 save_cookies(&client);
442 note(
443 progress,
444 &format!("progress.history_ready\x1f{}", apps.len()),
445 );
446 Ok(apps)
447}
448
449pub fn download_to(path: &Path, app_id: i64, external_version_id: Option<&str>) -> Result<String> {
450 download(&DownloadRequest {
451 app_id: Some(app_id),
452 bundle_id: None,
453 output: Some(path.display().to_string()),
454 external_version_id: external_version_id.map(str::to_string),
455 purchase: true,
456 keychain_passphrase: None,
457 })
458}
459
460#[cfg(test)]
461mod tests {
462 use super::normalize_auth_code;
463
464 #[test]
465 fn auth_code_strips_spaces() {
466 let c = normalize_auth_code(Some("12 34 56")).unwrap().unwrap();
467 assert_eq!(c, "123456");
468 }
469
470 #[test]
471 fn auth_code_rejects_non_digits() {
472 assert!(normalize_auth_code(Some("12ab56")).is_err());
473 }
474
475 #[test]
476 fn auth_code_empty_is_none() {
477 assert!(normalize_auth_code(None).unwrap().is_none());
478 assert!(normalize_auth_code(Some(" ")).unwrap().is_none());
479 }
480}