feat: initial implementation of grasp-mirror daemon

GRASP mirror daemon that discovers repos from watched npubs and mirrors
git data + Nostr events across all known GRASP servers for redundancy.

Features:
- Configurable npub watch list via .env (MIRROR_NPUBS)
- TOML config for GRASP server list, index relays, storage paths
- NIP-11 verification of GRASP servers on startup
- Discovery of repos via kind:30617 announcements on index relays
- Git mirroring (bare clone + push --mirror) to missing GRASP servers
- Nostr event forwarding to all GRASP server embedded relays
- SQLite state tracking for sync status and event dedup
- Optional signing key for updating announcements with new clone URLs
- CLI subcommands: daemon, status, verify, mirror-once

Architecture:
  config.rs    - TOML + .env config loading
  db.rs        - SQLite state tracking
  health.rs    - NIP-11 GRASP server verification
  discovery.rs - Relay subscription, kind:30617 parsing
  git_mirror.rs - Bare clone + push to GRASP servers
  nostr_mirror.rs - Event forwarding to all GRASP relays
  signing.rs   - Optional announcement updates
  main.rs      - CLI entry point, daemon loop

1 files changed, 142 insertions, 0 deletions

diff --git a/src/discovery.rs b/src/discovery.rs
new file mode 100644
index 0000000..59b9f2c
--- /dev/null
+++ b/src/discovery.rs
@@ -0,0 +1,142 @@
+use crate::db::MirrorDb;
+use crate::health::GraspServer;
+use anyhow::{Context, Result};
+use nostr::Kind;
+use nostr_sdk::prelude::*;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct DiscoveredRepo {
+    pub pubkey: PublicKey,
+    pub identifier: String,
+    pub event_id: EventId,
+    pub clone_urls: Vec<String>,
+    pub relay_urls: Vec<String>,
+}
+
+pub async fn discover_repos_from_relays(
+    client: &nostr_sdk::Client,
+    npubs: &[PublicKey],
+    relay_urls: &[String],
+) -> Result<Vec<DiscoveredRepo>> {
+    for url in relay_urls {
+        if let Err(e) = client.add_relay(url).await {
+            tracing::warn!(relay = %url, error = %e, "failed to add relay");
+            continue;
+        }
+    }
+    client.connect().await;
+
+    let mut repos = Vec::new();
+
+    for pk in npubs {
+        let filter = Filter::new()
+            .kind(Kind::Custom(30617))
+            .author(*pk)
+            .limit(50);
+
+        let events = client
+            .fetch_events(filter, std::time::Duration::from_secs(30))
+            .await
+            .context("failed to fetch events from relays")?;
+
+        for event in events.into_iter() {
+            if let Some(repo) = parse_announcement(&event) {
+                repos.push(repo);
+            }
+        }
+    }
+
+    tracing::info!(count = repos.len(), "discovered repos from relays");
+    Ok(repos)
+}
+
+fn parse_announcement(event: &Event) -> Option<DiscoveredRepo> {
+    let mut identifier = None;
+    let mut clone_urls = Vec::new();
+    let mut relay_urls = Vec::new();
+
+    for tag in event.tags.iter() {
+        let tag_vec = tag.clone().to_vec();
+        if tag_vec.len() < 2 {
+            continue;
+        }
+        match tag_vec[0].as_str() {
+            "d" => identifier = Some(tag_vec[1].clone()),
+            "clone" => clone_urls.push(tag_vec[1].clone()),
+            "relays" => relay_urls.push(tag_vec[1].clone()),
+            _ => {}
+        }
+    }
+
+    let identifier = identifier?;
+    if clone_urls.is_empty() {
+        tracing::warn!(
+            identifier = %identifier,
+            "repo announcement has no clone URLs"
+        );
+    }
+
+    Some(DiscoveredRepo {
+        pubkey: event.pubkey,
+        identifier,
+        event_id: event.id,
+        clone_urls,
+        relay_urls,
+    })
+}
+
+pub async fn persist_discovered_repos(
+    db: &MirrorDb,
+    repos: &[DiscoveredRepo],
+) -> Result<HashMap<String, i64>> {
+    let mut repo_ids = HashMap::new();
+    for repo in repos {
+        let pk_hex = repo.pubkey.to_hex();
+        match db
+            .upsert_repo(&pk_hex, &repo.identifier, &repo.event_id.to_hex())
+            .await
+        {
+            Ok(id) => {
+                tracing::debug!(
+                    identifier = %repo.identifier,
+                    repo_id = id,
+                    "persisted repo"
+                );
+                repo_ids.insert(format!("{}:{}", pk_hex, repo.identifier), id);
+            }
+            Err(e) => {
+                tracing::error!(
+                    identifier = %repo.identifier,
+                    error = %e,
+                    "failed to persist repo"
+                );
+            }
+        }
+    }
+    Ok(repo_ids)
+}
+
+pub fn identify_missing_servers(
+    repo: &DiscoveredRepo,
+    servers: &HashMap<String, GraspServer>,
+) -> Vec<GraspServer> {
+    let mut missing = Vec::new();
+
+    for (_domain, server) in servers {
+        if !server.is_grasp_server() {
+            continue;
+        }
+
+        let has_clone = repo
+            .clone_urls
+            .iter()
+            .any(|url| url.contains(&server.domain));
+
+        if !has_clone {
+            missing.push(server.clone());
+        }
+    }
+
+    missing
+}