feat: (iroh-automerge-repo) Delete, Subscribe, and persistent NodeID (#127)

* feat: (iroh-automerge-repo) Delete, Subscribe, and persistent NodeID

* Fix: address review feedback

* Apply clippy changes to frosty

* chore: Update samod version

* Small style fixes

---------

Co-authored-by: Philipp Krüger <[email protected]>

Author: relves

frosty/src/main.rs

@@ -392,16 +392,14 @@ async fn cosign_daemon(args: CosignArgs) -> anyhow::Result<()> {
             .extension()
             .map(|ext| ext == "secret")
             .unwrap_or_default()
+            && let Some(stem) = path.file_stem()
+            && let Some(text) = stem.to_str()
         {
-            if let Some(stem) = path.file_stem() {
-                if let Some(text) = stem.to_str() {
-                    let key = iroh::PublicKey::from_str(text)?;
-                    let secret_share_bytes = fs::read(&path)?;
-                    let secret_share = SecretShare::deserialize(&secret_share_bytes)?;
-                    let key_package = frost::keys::KeyPackage::try_from(secret_share)?;
-                    keys.push((key, key_package));
-                }
-            }
+            let key = iroh::PublicKey::from_str(text)?;
+            let secret_share_bytes = fs::read(&path)?;
+            let secret_share = SecretShare::deserialize(&secret_share_bytes)?;
+            let key_package = frost::keys::KeyPackage::try_from(secret_share)?;
+            keys.push((key, key_package));
         }
     }
     if !keys.is_empty() {

iroh-automerge-repo/Cargo.lock

@@ -9,7 +9,7 @@ bytes = "1.10.1"
 derive_more = { version = "2.0.1", features = ["debug"] }
 iroh = "0.91.1"
 n0-future = "0.2"
-samod = { version = "0.2.0", features = ["tokio"] }
+samod = { version = "0.2.1", features = ["tokio"] }
 tokio = { version = "1.47.1", features = ["sync", "net"] }
 tokio-util = { version = "0.7.15", features = ["codec"] }
 tracing = "0.1.41"
@@ -18,3 +18,5 @@ tracing = "0.1.41"
 automerge = "0.6.1"
 clap = { version = "4.5.41", features = ["derive"] }
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+rand = "0.8.5"
+hex = "0.4.3"

iroh-automerge-repo/Cargo.toml

@@ -3,17 +3,27 @@ use std::str::FromStr;
 use anyhow::Context;
 use automerge::{Automerge, ReadDoc, transaction::Transactable};
 use clap::Parser;
+use hex::encode;
 use iroh::NodeId;
 use iroh_automerge_repo::IrohRepo;
-use samod::{DocumentId, PeerId, Samod};
+
+use samod::{DocumentId, PeerId, Samod, storage::TokioFilesystemStorage};
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Args {
-    /// A NodeId to connect to to keep syncing with
+    /// A NodeId to connect to and keep syncing with
     #[clap(long)]
     sync_with: Option<NodeId>,
 
+    /// Path where storage files will be created
+    #[clap(long, default_value = ".")]
+    storage_path: String,
+
+    /// Print the secret key
+    #[clap(long)]
+    print_secret_key: bool,
+
     #[clap(subcommand)]
     command: Commands,
 }
@@ -45,6 +55,21 @@ pub enum Commands {
         /// The document's ID
         doc: String,
     },
+    /// Subscribe to a document and print changes as they occur
+    Subscribe {
+        /// The document's ID to subscribe to
+        doc: String,
+    },
+    /// Delete a key from the document
+    Delete {
+        /// The document's ID of the document to modify
+        doc: String,
+
+        /// The key you want to delete
+        key: String,
+    },
+    /// Host the app and serve existing documents from the automerge-repo stored in at config-path
+    Host,
 }
 
 #[tokio::main]
@@ -55,10 +80,56 @@ async fn main() -> anyhow::Result<()> {
 
     let args = Args::parse();
 
-    let endpoint = iroh::Endpoint::builder().discovery_n0().bind().await?;
+    // Pull in the secret key from the environment variable if it exists
+    // This key is the public Node ID used to identify the node in the network
+    // If not provided, a random key will be generated, and a new Node ID will
+    // be assigned each time the app is started
+    let secret_key = match std::env::var("IROH_SECRET") {
+        Ok(key_hex) => match iroh::SecretKey::from_str(&key_hex) {
+            Ok(key) => Some(key),
+            Err(_) => {
+                println!("invalid IROH_SECRET provided: not valid hex");
+                None
+            }
+        },
+        Err(_) => None,
+    };
+
+    let secret_key = match secret_key {
+        Some(key) => {
+            println!("Using existing key: {}", key.public());
+            key
+        }
+        None => {
+            println!("Generating new key");
+            let mut rng = rand::rngs::OsRng;
+            iroh::SecretKey::generate(&mut rng)
+        }
+    };
+
+    if args.print_secret_key {
+        println!("Secret Key: {}", encode(secret_key.to_bytes()));
+        println!(
+            "Set env var for persistent Node ID: export IROH_SECRET={}",
+            encode(secret_key.to_bytes())
+        );
+    }
+
+    let endpoint = iroh::Endpoint::builder()
+        .discovery_n0()
+        .secret_key(secret_key)
+        .bind()
+        .await?;
+
+    println!("Node ID: {}", endpoint.node_id());
 
     let samod = Samod::build_tokio()
         .with_peer_id(PeerId::from_string(endpoint.node_id().to_string()))
+        .with_storage(TokioFilesystemStorage::new(format!(
+            "{}/{}",
+            args.storage_path,
+            endpoint.node_id()
+        )))
         .load()
         .await;
     let proto = IrohRepo::new(endpoint.clone(), samod);
@@ -100,6 +171,17 @@ async fn main() -> anyhow::Result<()> {
                 .map_err(debug_err)?;
             println!("Updated document");
         }
+        Commands::Delete { doc, key } => {
+            let doc_id = DocumentId::from_str(&doc).context("Couldn't parse document ID")?;
+            let doc = proto
+                .repo()
+                .find(doc_id)
+                .await?
+                .context("Couldn't find document with this ID")?;
+            doc.with_document(|doc| doc.transact(|tx| tx.delete(automerge::ROOT, key)))
+                .map_err(debug_err)?;
+            println!("Key deleted!");
+        }
         Commands::Print { doc } => {
             let doc_id = DocumentId::from_str(&doc).context("Couldn't parse document ID")?;
             let doc = proto
@@ -115,6 +197,62 @@ async fn main() -> anyhow::Result<()> {
                 anyhow::Ok(())
             })?;
         }
+        Commands::Subscribe { doc } => {
+            let doc_id = DocumentId::from_str(&doc).context("Couldn't parse document ID")?;
+            let doc = proto
+                .repo()
+                .find(doc_id.clone())
+                .await?
+                .context("Couldn't find document with this ID")?;
+
+            println!("Subscribing to document {} for changes...", doc_id);
+
+            // Print initial state
+            println!("Initial document state:");
+            doc.with_document(|doc| {
+                for key in doc.keys(automerge::ROOT) {
+                    let (value, _) = doc.get(automerge::ROOT, &key)?.expect("missing value");
+                    println!("  {key}={value}");
+                }
+                anyhow::Ok(())
+            })?;
+
+            // Set up polling for changes (no push available yet)
+            tokio::spawn(async move {
+                // Track the last known heads to detect changes
+                let mut last_heads = doc.with_document(|doc| doc.get_heads());
+                loop {
+                    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+                    let current_heads = doc.with_document(|doc| doc.get_heads());
+                    if current_heads == last_heads {
+                        continue;
+                    }
+
+                    last_heads = current_heads;
+
+                    println!("Document changed! New state:");
+
+                    // When changes are detected, print the updated document contents...
+                    if let Err(e) = doc.with_document(|current_doc| {
+                        for key in current_doc.keys(automerge::ROOT) {
+                            let (value, _) = current_doc
+                                .get(automerge::ROOT, &key)?
+                                .expect("missing value");
+                            println!("  {key}={value}");
+                        }
+                        anyhow::Ok(())
+                    }) {
+                        eprintln!("Error reading document content: {e}");
+                    }
+                }
+            });
+        }
+        Commands::Host => {
+            println!("Hosting existing documents...");
+            println!("Repository is now hosted and ready for sync operations.");
+            println!("Other nodes can connect to sync with this repository.");
+        }
     }
 
     println!("Waiting for Ctrl+C");