feat: publish state event to stale grasp relays before sync push

FetchReport now captures the full state event seen on each relay during
the nostr fetch (state_per_relay: HashMap<RelayUrl, Option<Event>>).
ngit sync uses this to identify grasp server relays with a missing or
outdated state event and publishes the current state event to them
before attempting git pushes, preventing rejections. An existing login
is loaded silently (no prompt, no profile fetch) to provide a signer
for NIP-42 auth if requested.

1 files changed, 57 insertions, 0 deletions

diff --git a/src/lib/client.rs b/src/lib/client.rs
index 3f1f22e..8ae9820 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -840,6 +840,33 @@ impl Connect for Client {
             let events: Vec<nostr::Event> = get_events_of(&relay, filters.clone(), pb).await?;
             // TODO: try reconcile
 
+            // Track the best state event seen from this relay so callers can
+            // determine which relays have a stale or absent state event.
+            // We must do this before process_fetched_events because the local
+            // database only stores the canonical latest event; per-relay
+            // visibility is only available here.
+            for event in &events {
+                if event.kind.eq(&STATE_KIND) {
+                    let entry = report
+                        .state_per_relay
+                        .entry(relay_url.clone())
+                        .or_insert(None);
+                    let is_newer = entry.as_ref().is_none_or(|existing: &nostr::Event| {
+                        event.created_at.gt(&existing.created_at)
+                            || (event.created_at.eq(&existing.created_at)
+                                && event.id.gt(&existing.id))
+                    });
+                    if is_newer {
+                        *entry = Some(event.clone());
+                    }
+                }
+            }
+            // Mark relay as queried even if no state event was returned.
+            report
+                .state_per_relay
+                .entry(relay_url.clone())
+                .or_insert(None);
+
             process_fetched_events(
                 events,
                 &request,
@@ -2018,6 +2045,30 @@ pub fn consolidate_fetch_reports(reports: Vec<Result<FetchReport>>) -> FetchRepo
         for c in relay_report.profile_updates {
             report.profile_updates.insert(c);
         }
+        // Per-relay state events are independent: each relay entry is kept as-is.
+        // If a relay appears in multiple per-relay reports (shouldn't happen in
+        // practice but possible in tests), keep the newer event.
+        for (relay_url, maybe_event) in relay_report.state_per_relay {
+            match report.state_per_relay.entry(relay_url) {
+                std::collections::hash_map::Entry::Vacant(e) => {
+                    e.insert(maybe_event);
+                }
+                std::collections::hash_map::Entry::Occupied(mut e) => {
+                    let keep = match (e.get(), &maybe_event) {
+                        (None, Some(_)) => true,
+                        (Some(existing), Some(incoming)) => {
+                            incoming.created_at.gt(&existing.created_at)
+                                || (incoming.created_at.eq(&existing.created_at)
+                                    && incoming.id.gt(&existing.id))
+                        }
+                        _ => false,
+                    };
+                    if keep {
+                        e.insert(maybe_event);
+                    }
+                }
+            }
+        }
     }
     report
 }
@@ -2146,6 +2197,12 @@ pub struct FetchReport {
     statuses: HashSet<EventId>,
     contributor_profiles: HashSet<PublicKey>,
     profile_updates: HashSet<PublicKey>,
+    /// The best (newest) state event seen on each relay during the fetch.
+    /// `None` as a value means the relay was queried but returned no state
+    /// event at all.  Relays that were never queried are absent from the map.
+    /// This is the only point at which per-relay state visibility is available;
+    /// the local database only stores the canonical latest event.
+    pub state_per_relay: HashMap<RelayUrl, Option<nostr::Event>>,
 }
 
 impl Display for FetchReport {