Resolve identities root inside setup() for Android/iOS (#7)

* Resolve identities root inside setup() so Android can initialize

On desktop, identities root comes from $DMP_DESKTOP_HOME /
$DMP_CONFIG_HOME / $HOME, resolved before the Tauri builder runs.
Mobile sandboxes don't expose $HOME, so that path bombed with
'cannot resolve identities root' before any UI could come up — the
process exit-2'd inside the JNI bridge and crash-looped.

Defer root resolution to the setup() callback. On Android/iOS,
ask Tauri for app_local_data_dir() (per-app private storage,
guaranteed writable). Desktop behavior is unchanged: same env-driven
resolution, same error surface if HOME is unset.

Verified locally: APK now gets past the early HOME crash. A separate
tao/Tauri runtime panic in onActivityCreate is the next blocker —
filed separately.

* gitignore: drop src-tauri/gen/ regenerated by mobile init

Tauri rebuilds gen/android (and gen/ios when wired) on every
`cargo tauri android init`, so we don't track it. Eliminates the
'1 uncommitted change' warning when local mobile builds run on
the side. Promote to a tracked dir if/when we customize the
AndroidManifest / icons / signing config.

* clippy: collapse nested if/let blocks into 2024 if-let chains

Rust 1.95 + edition 2024 promoted `clippy::collapsible_if` and the
`if let chains` syntax. CI runs clippy with `-D warnings`, so the
four pre-existing nested patterns now fail the build:

  src/commands/identity.rs:485
  src/commands/nodes.rs:403
  src/commands/nodes.rs:482
  src/commands/nodes.rs:869

Mechanical rewrite — same control flow, same behavior, just expressed
as `if let X && cond { ... }` instead of `if let X { if cond { ... } }`.
Required edition 2024 (already set on this branch via main).

Author: oscarvalenzuelab

.gitignore

@@ -5,6 +5,11 @@ node_modules
 /package
 dist/
 
+# Tauri mobile scaffolding — regenerated by `tauri android/ios init`
+# on every build. Commit explicitly only once we need to customize the
+# AndroidManifest / icons / signing config.
+src-tauri/gen/
+
 # Environment / local overrides
 .env
 .env.*

src-tauri/src/commands/identity.rs

@@ -482,10 +482,10 @@ pub async fn update_publish_config(
     // can't swap them at runtime, so drop it and let the UI re-prompt
     // for the passphrase before the next unlock.
     let mut guard = state.active.write().await;
-    if let Some(active) = guard.as_ref() {
-        if active.username == username {
-            *guard = None;
-        }
+    if let Some(active) = guard.as_ref()
+        && active.username == username
+    {
+        *guard = None;
     }
     drop(guard);
 

src-tauri/src/commands/nodes.rs

@@ -400,10 +400,10 @@ async fn directory_feed_cache_slot() -> &'static DirectoryFeedCache {
 /// enrichment on top of the curated list.
 async fn fetch_directory_feed() -> Vec<DirectoryNode> {
     let slot = directory_feed_cache_slot().await;
-    if let Some((stored_at, ref cached)) = *slot.lock() {
-        if stored_at.elapsed() < DIRECTORY_FEED_TTL {
-            return cached.clone();
-        }
+    if let Some((stored_at, ref cached)) = *slot.lock()
+        && stored_at.elapsed() < DIRECTORY_FEED_TTL
+    {
+        return cached.clone();
     }
 
     let Ok(client) = reqwest::ClientBuilder::new()
@@ -479,10 +479,10 @@ pub async fn list_known_nodes() -> CommandResult<Vec<KnownNodeStatus>> {
     let mut slots: Vec<Option<DiscoveredNode>> =
         (0..WELL_KNOWN_NODES.len()).map(|_| None).collect();
     while let Some(joined) = set.join_next().await {
-        if let Ok((idx, live)) = joined {
-            if let Some(slot) = slots.get_mut(idx) {
-                *slot = live;
-            }
+        if let Ok((idx, live)) = joined
+            && let Some(slot) = slots.get_mut(idx)
+        {
+            *slot = live;
         }
     }
 
@@ -866,10 +866,10 @@ fn strip_endpoint_to_host(endpoint: &str) -> String {
     let host_only = no_scheme.split('/').next().unwrap_or(no_scheme);
     // Handle bracketed IPv6 literals: `[::1]:8443` → `::1`,
     // `[::1]` → `::1`. Python's CLI does the same.
-    if let Some(rest) = host_only.strip_prefix('[') {
-        if let Some(end) = rest.find(']') {
-            return rest[..end].to_string();
-        }
+    if let Some(rest) = host_only.strip_prefix('[')
+        && let Some(end) = rest.find(']')
+    {
+        return rest[..end].to_string();
     }
     if let Some((host, _port)) = host_only.rsplit_once(':') {
         // Bare-IPv6 (more than one `:`, no brackets) isn't a valid

src-tauri/src/lib.rs

@@ -24,32 +24,39 @@ fn version() -> String {
 
 /// Build the Tauri runtime.
 ///
-/// Identities-root resolution order mirrors the CLI:
-/// `$DMP_DESKTOP_HOME` > `$DMP_CONFIG_HOME/identities` >
-/// `$HOME/.dmp/identities`.
+/// Identities-root resolution differs by platform:
+///   - Desktop: `$DMP_DESKTOP_HOME` > `$DMP_CONFIG_HOME/identities` >
+///     `$HOME/.dmp/identities` (mirrors the CLI).
+///   - Mobile (Android / iOS): the per-app local-data directory the OS
+///     hands us via `app.path().app_local_data_dir()`. Mobile sandboxes
+///     don't expose `$HOME` so the env-driven resolution can't run, and
+///     identities have to live inside the app's private storage.
+///
+/// The mobile branch needs the `App` handle, so root resolution is
+/// deferred into the `setup()` callback rather than computed before the
+/// builder runs.
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     init_tracing();
 
-    let root = match AppState::default_root() {
-        Ok(p) => p,
-        Err(e) => {
-            eprintln!("dnsmesh-desktop: cannot resolve identities root: {e:#}");
-            std::process::exit(2);
-        }
-    };
-    if let Err(e) = std::fs::create_dir_all(&root) {
-        eprintln!(
-            "dnsmesh-desktop: cannot create identities root {}: {e}",
-            root.display()
-        );
-        std::process::exit(2);
-    }
-    let app_state = AppState::new(root);
-
     tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
-        .manage(app_state)
+        .setup(|app| {
+            use tauri::Manager;
+            let root = if cfg!(any(target_os = "android", target_os = "ios")) {
+                app.path()
+                    .app_local_data_dir()
+                    .map_err(|e| format!("app_local_data_dir unavailable: {e}"))?
+                    .join("identities")
+            } else {
+                AppState::default_root()
+                    .map_err(|e| format!("cannot resolve identities root: {e:#}"))?
+            };
+            std::fs::create_dir_all(&root)
+                .map_err(|e| format!("cannot create identities root {}: {e}", root.display()))?;
+            app.manage(AppState::new(root));
+            Ok(())
+        })
         .invoke_handler(tauri::generate_handler![
             version,
             // identity