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, 279 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..b709d44
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,279 @@
+mod config;
+mod db;
+mod discovery;
+mod git_mirror;
+mod health;
+mod nostr_mirror;
+mod signing;
+
+use anyhow::Result;
+use clap::Parser;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Parser, Debug)]
+#[command(name = "grasp-mirror", about = "GRASP mirror daemon")]
+struct Cli {
+    #[arg(short, long, default_value = "config.toml")]
+    config: PathBuf,
+
+    #[command(subcommand)]
+    command: Option<Command>,
+}
+
+#[derive(clap::Subcommand, Debug)]
+enum Command {
+    Daemon,
+    Status,
+    Verify,
+    MirrorOnce,
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
+        )
+        .init();
+
+    let cli = Cli::parse();
+    let config = config::ResolvedConfig::load(&cli.config)?;
+
+    tracing::info!(
+        npubs = config.npubs.len(),
+        servers = config.servers.known.len(),
+        index_relays = config.discovery.index_relays.len(),
+        "starting grasp-mirror"
+    );
+
+    let db = db::MirrorDb::open(&config.storage.database).await?;
+
+    match cli.command.unwrap_or(Command::Daemon) {
+        Command::Daemon => run_daemon(config, db).await,
+        Command::Status => run_status(db).await,
+        Command::Verify => run_verify(config).await,
+        Command::MirrorOnce => run_mirror_once(config, db).await,
+    }
+}
+
+fn build_nostr_client(relay_urls: &[String]) -> nostr_sdk::Client {
+    let client = nostr_sdk::Client::default();
+    for url in relay_urls {
+        let _ = client.add_relay(url);
+    }
+    client
+}
+
+async fn run_daemon(config: config::ResolvedConfig, db: db::MirrorDb) -> Result<()> {
+    let db = Arc::new(db);
+    let config = Arc::new(config);
+
+    let servers = health::verify_all_servers(&config.servers.known).await;
+    let healthy: Vec<_> = servers
+        .values()
+        .filter(|s| s.is_grasp_server())
+        .cloned()
+        .collect();
+
+    tracing::info!(
+        total = servers.len(),
+        healthy = healthy.len(),
+        "server verification complete"
+    );
+
+    let healthy = Arc::new(healthy);
+
+    let relay_urls = config.relay_urls();
+    let nostr_client = build_nostr_client(&relay_urls);
+    nostr_client.connect().await;
+
+    let mirror = git_mirror::GitMirror::new(&config.storage.mirror_dir);
+    let nostr_mirror = nostr_mirror::NostrMirror::new(nostr_client.clone());
+
+    let mut interval = tokio::time::interval(std::time::Duration::from_secs(
+        config.discovery.poll_interval_secs,
+    ));
+
+    tracing::info!(
+        "daemon started, polling every {}s",
+        config.discovery.poll_interval_secs
+    );
+
+    loop {
+        tokio::select! {
+            _ = interval.tick() => {
+                if let Err(e) = mirror_cycle(
+                    &config,
+                    &db,
+                    &nostr_client,
+                    &mirror,
+                    &nostr_mirror,
+                    &healthy,
+                ).await {
+                    tracing::error!(error = %e, "mirror cycle failed");
+                }
+            }
+            _ = tokio::signal::ctrl_c() => {
+                tracing::info!("shutting down");
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn mirror_cycle(
+    config: &Arc<config::ResolvedConfig>,
+    db: &Arc<db::MirrorDb>,
+    nostr_client: &nostr_sdk::Client,
+    mirror: &git_mirror::GitMirror,
+    nostr_mirror: &nostr_mirror::NostrMirror,
+    servers: &Arc<Vec<health::GraspServer>>,
+) -> Result<()> {
+    tracing::info!("starting mirror cycle");
+
+    let relay_urls = config.relay_urls();
+    let repos = discovery::discover_repos_from_relays(nostr_client, &config.npubs, &relay_urls)
+        .await?;
+
+    tracing::info!(count = repos.len(), "discovered repos");
+
+    discovery::persist_discovered_repos(db, &repos).await?;
+
+    let server_map: std::collections::HashMap<String, health::GraspServer> = servers
+        .iter()
+        .map(|s| (s.domain.clone(), s.clone()))
+        .collect();
+
+    for repo in &repos {
+        let missing = discovery::identify_missing_servers(repo, &server_map);
+
+        if missing.is_empty() {
+            tracing::debug!(identifier = %repo.identifier, "repo already on all servers");
+            continue;
+        }
+
+        tracing::info!(
+            identifier = %repo.identifier,
+            missing = missing.iter().map(|s| s.domain.as_str()).collect::<Vec<_>>().join(", "),
+            "mirroring to missing servers"
+        );
+
+        mirror.mirror_repo_to_servers(db, repo, &missing).await?;
+        nostr_mirror.forward_repo_events(db, repo, servers).await?;
+    }
+
+    nostr_mirror
+        .sync_all_events(db, &config.npubs, servers)
+        .await?;
+
+    tracing::info!("mirror cycle complete");
+    Ok(())
+}
+
+async fn run_status(db: db::MirrorDb) -> Result<()> {
+    let repos = db.get_all_repos().await?;
+    let syncs = db.get_sync_summary().await?;
+
+    println!("=== GRASP Mirror Status ===\n");
+    println!("Repos tracked: {}\n", repos.len());
+
+    for repo in &repos {
+        println!("  {} ({})", repo.identifier, &repo.pubkey[..12]);
+    }
+
+    println!("\nSync records: {}\n", syncs.len());
+    for sync in &syncs {
+        let status = if sync.git_synced && sync.nostr_synced {
+            "OK"
+        } else if sync.error.is_some() {
+            "ERR"
+        } else {
+            "PENDING"
+        };
+        println!(
+            "  repo:{} server:{} git:{} nostr:{} [{}]",
+            sync.repo_id,
+            sync.server_domain,
+            if sync.git_synced { "Y" } else { "N" },
+            if sync.nostr_synced { "Y" } else { "N" },
+            status,
+        );
+        if let Some(err) = &sync.error {
+            println!("    error: {}", err);
+        }
+    }
+
+    Ok(())
+}
+
+async fn run_verify(config: config::ResolvedConfig) -> Result<()> {
+    let servers = health::verify_all_servers(&config.servers.known).await;
+
+    println!("=== GRASP Server Verification ===\n");
+
+    for (domain, server) in &servers {
+        let grasp = server.is_grasp_server();
+        let version = server
+            .nip11
+            .as_ref()
+            .and_then(|i| i.version.clone())
+            .unwrap_or_else(|| "unknown".to_string());
+        let grasps = server
+            .nip11
+            .as_ref()
+            .and_then(|i| i.supported_grasps.clone())
+            .map(|g| g.join(", "))
+            .unwrap_or_else(|| "NONE".to_string());
+
+        println!(
+            "  {} [{}] v={} GRASP={}",
+            domain,
+            if grasp { "OK" } else { "SKIP" },
+            version,
+            grasps,
+        );
+    }
+
+    let healthy = servers.values().filter(|s| s.is_grasp_server()).count();
+    println!(
+        "\n{}/{} verified as GRASP servers",
+        healthy,
+        servers.len()
+    );
+
+    Ok(())
+}
+
+async fn run_mirror_once(config: config::ResolvedConfig, db: db::MirrorDb) -> Result<()> {
+    let db = Arc::new(db);
+    let config = Arc::new(config);
+
+    let servers = health::verify_all_servers(&config.servers.known).await;
+    let healthy: Vec<_> = servers
+        .values()
+        .filter(|s| s.is_grasp_server())
+        .cloned()
+        .collect();
+
+    let relay_urls = config.relay_urls();
+    let nostr_client = build_nostr_client(&relay_urls);
+    nostr_client.connect().await;
+
+    let mirror = git_mirror::GitMirror::new(&config.storage.mirror_dir);
+    let nostr_mirror = nostr_mirror::NostrMirror::new(nostr_client.clone());
+    let healthy = Arc::new(healthy);
+
+    mirror_cycle(
+        &config,
+        &db,
+        &nostr_client,
+        &mirror,
+        &nostr_mirror,
+        &healthy,
+    )
+    .await
+}