11 files changed, 829 insertions, 256 deletions

diff --git a/Cargo.lock b/Cargo.lock
index e5191e5..7b373f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1601,6 +1601,7 @@ dependencies = [
  "scrypt",
  "serde",
  "serde_json",
+ "serde_yaml",
  "serial_test",
  "test_utils",
  "tokio",
@@ -2555,6 +2556,19 @@ dependencies = [
 ]
 
 [[package]]
+name = "serde_yaml"
+version = "0.9.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cc7a1570e38322cfe4154732e5110f887ea57e22b76f4bfd32b5bdd3368666c"
+dependencies = [
+ "indexmap 2.1.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
 name = "serial_test"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3028,6 +3042,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "unsafe-libyaml"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa"
+
+[[package]]
 name = "untrusted"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/Cargo.toml b/Cargo.toml
index f578333..78360a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,6 +29,7 @@ passwords = "3.1.13"
 scrypt = "0.11.0"
 serde = { version = "1.0.181", features = ["derive"] }
 serde_json = "1.0.105"
+serde_yaml = "0.9.27"
 tokio = "1.33.0"
 zeroize = "1.6.0"
 
diff --git a/src/git.rs b/src/git.rs
index e2d8196..29670eb 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -1,6 +1,6 @@
-use std::env::current_dir;
 #[cfg(test)]
 use std::path::PathBuf;
+use std::{env::current_dir, path::Path};
 
 use anyhow::{bail, Context, Result};
 use git2::{Oid, Revwalk};
@@ -30,6 +30,8 @@ impl Repo {
 // pub type Sha1 = [u8; 20];
 
 pub trait RepoActions {
+    fn get_path(&self) -> Result<&Path>;
+    fn get_origin_url(&self) -> Result<String>;
     fn get_local_branch_names(&self) -> Result<Vec<String>>;
     fn get_main_or_master_branch(&self) -> Result<(&str, Sha1Hash)>;
     fn get_checked_out_branch_name(&self) -> Result<String>;
@@ -61,6 +63,23 @@ pub trait RepoActions {
 }
 
 impl RepoActions for Repo {
+    fn get_path(&self) -> Result<&Path> {
+        self.git_repo
+            .path()
+            .parent()
+            .context("cannot find repositiory path as .git has  no parent")
+    }
+
+    fn get_origin_url(&self) -> Result<String> {
+        Ok(self
+            .git_repo
+            .find_remote("origin")
+            .context("cannot find origin")?
+            .url()
+            .context("cannot find origin url")?
+            .to_string())
+    }
+
     fn get_main_or_master_branch(&self) -> Result<(&str, Sha1Hash)> {
         let main_branch_name = {
             let local_branches = self
@@ -860,6 +879,18 @@ mod tests {
         }
     }
 
+    mod get_origin_url {
+        use super::*;
+
+        #[test]
+        fn returns_origin_url() -> Result<()> {
+            let test_repo = GitTestRepo::default();
+            test_repo.add_remote("origin", "https://localhost:1000")?;
+            let git_repo = Repo::from_path(&test_repo.dir)?;
+            assert_eq!(git_repo.get_origin_url()?, "https://localhost:1000");
+            Ok(())
+        }
+    }
     mod get_checked_out_branch_name {
         use super::*;
 
diff --git a/src/repo_ref.rs b/src/repo_ref.rs
index a92b5b3..a5b35c9 100644
--- a/src/repo_ref.rs
+++ b/src/repo_ref.rs
@@ -1,20 +1,26 @@
+use std::{fs::File, io::BufReader, str::FromStr};
+
 use anyhow::{bail, Context, Result};
-use nostr::Tag;
+use nostr::{secp256k1::XOnlyPublicKey, FromBech32, Tag, ToBech32};
+use serde::{Deserialize, Serialize};
 
 #[cfg(not(test))]
 use crate::client::Client;
-use crate::client::Connect;
 #[cfg(test)]
 use crate::client::MockConnect;
+use crate::{
+    client::Connect,
+    git::{Repo, RepoActions},
+};
 
 #[derive(Default)]
 pub struct RepoRef {
     pub name: String,
     pub description: String,
     pub root_commit: String,
+    pub git_server: String,
     pub relays: Vec<String>,
-    // git_server: String,
-    // other maintainers
+    pub maintainers: Vec<XOnlyPublicKey>,
     // code languages and hashtags
 }
 
@@ -35,6 +41,10 @@ impl TryFrom<nostr::Event> for RepoRef {
             r.description = t.as_vec()[1].clone();
         }
 
+        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("git-server")) {
+            r.git_server = t.as_vec()[1].clone();
+        }
+
         if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("d")) {
             r.root_commit = t.as_vec()[1].clone();
         }
@@ -46,6 +56,15 @@ impl TryFrom<nostr::Event> for RepoRef {
             .map(|t| t.as_vec()[1].clone())
             .collect();
 
+        for tag in event.tags.iter().filter(|t| t.as_vec()[0].eq("p")) {
+            let pk = tag.as_vec()[1].clone();
+            r.maintainers.push(
+                nostr_sdk::prelude::XOnlyPublicKey::from_str(&pk)
+                    .context(format!("cannot convert {pk} into a valid nostr public key"))
+                    .context("invalid repository event")?,
+            );
+        }
+
         Ok(r)
     }
 }
@@ -62,10 +81,17 @@ impl RepoRef {
                     Tag::Reference(format!("r-{}", self.root_commit)),
                     Tag::Name(self.name.clone()),
                     Tag::Description(self.description.clone()),
+                    Tag::Generic(
+                        nostr::TagKind::Custom("git-server".to_string()),
+                        vec![self.git_server.clone()],
+                    ),
+                    Tag::Reference(self.git_server.clone()),
                 ],
                 self.relays.iter().map(|r| Tag::Relay(r.into())).collect(),
-                // git_servers
-                // other maintainers
+                self.maintainers
+                    .iter()
+                    .map(|pk| Tag::PubKey(*pk, None))
+                    .collect(),
                 // code languages and hashtags
             ]
             .concat(),
@@ -76,24 +102,30 @@ impl RepoRef {
 }
 
 pub async fn fetch(
+    git_repo: &Repo,
     root_commit: String,
     #[cfg(test)] client: &MockConnect,
     #[cfg(not(test))] client: &Client,
     // TODO: more rubust way of finding repo events
-    relays: Vec<String>,
+    fallback_relays: Vec<String>,
 ) -> Result<RepoRef> {
-    // TODO: fetch relay information from file
+    let repo_config = get_repo_config_from_yaml(git_repo);
 
-    let events: Vec<nostr::Event> = client
-        .get_events(
-            relays,
-            vec![
-                nostr::Filter::default()
-                    .kind(nostr::Kind::Custom(REPO_REF_KIND))
-                    .identifier(root_commit),
-            ],
-        )
-        .await?;
+    // TODO: check events only from maintainers. get relay list of maintainters.
+    // check those relays.
+
+    let mut repo_event_filter = nostr::Filter::default()
+        .kind(nostr::Kind::Custom(REPO_REF_KIND))
+        .identifier(root_commit);
+
+    let mut relays = fallback_relays;
+    if let Ok(repo_config) = repo_config {
+        repo_event_filter =
+            repo_event_filter.pubkeys(extract_pks(repo_config.maintainers.clone())?);
+        relays = repo_config.relays.clone();
+    }
+
+    let events: Vec<nostr::Event> = client.get_events(relays, vec![repo_event_filter]).await?;
 
     RepoRef::try_from(
         events
@@ -105,6 +137,68 @@ pub async fn fetch(
     )
 }
 
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
+pub struct RepoConfigYaml {
+    pub maintainers: Vec<String>,
+    pub relays: Vec<String>,
+}
+
+pub fn get_repo_config_from_yaml(git_repo: &Repo) -> Result<RepoConfigYaml> {
+    let path = git_repo.get_path()?.join("maintainers.yaml");
+    let file = File::open(path)
+        .context("should open maintainers.yaml if it exists")
+        .context("maintainers.yaml doesnt exist")?;
+    let reader = BufReader::new(file);
+    let repo_config_yaml: RepoConfigYaml = serde_yaml::from_reader(reader)
+        .context("should read maintainers.yaml with serde_yaml")
+        .context("maintainers.yaml incorrectly formatted")?;
+    Ok(repo_config_yaml)
+}
+
+pub fn extract_pks(pk_strings: Vec<String>) -> Result<Vec<XOnlyPublicKey>> {
+    let mut pks: Vec<XOnlyPublicKey> = vec![];
+    for s in pk_strings {
+        pks.push(
+            nostr_sdk::prelude::XOnlyPublicKey::from_bech32(s.clone())
+                .context(format!("cannot convert {s} into a valid nostr public key"))?,
+        );
+    }
+    Ok(pks)
+}
+
+pub fn save_repo_config_to_yaml(
+    git_repo: &Repo,
+    maintainers: Vec<XOnlyPublicKey>,
+    relays: Vec<String>,
+) -> Result<()> {
+    let path = git_repo.get_path()?.join("maintainers.yaml");
+    let file = if path.exists() {
+        std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(path)
+            .context("cannot open maintainers.yaml file with write and truncate options")?
+    } else {
+        std::fs::File::create(path).context("cannot create maintainers.yaml file")?
+    };
+    let mut maintainers_npubs = vec![];
+    for m in maintainers {
+        maintainers_npubs.push(
+            m.to_bech32()
+                .context("cannot convert public key into npub")?,
+        );
+    }
+    serde_yaml::to_writer(
+        file,
+        &RepoConfigYaml {
+            maintainers: maintainers_npubs,
+            relays,
+        },
+    )
+    .context("cannot write maintainers to maintainers.yaml file serde_yaml")
+}
+
 #[cfg(test)]
 mod tests {
     use test_utils::*;
@@ -116,7 +210,9 @@ mod tests {
             name: "test name".to_string(),
             description: "test description".to_string(),
             root_commit: "23471389461".to_string(),
+            git_server: "https://localhost:1000".to_string(),
             relays: vec!["ws://relay1.io".to_string(), "ws://relay2.io".to_string()],
+            maintainers: vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],
         }
         .to_event(&TEST_KEY_1_KEYS)
         .unwrap()
@@ -146,12 +242,28 @@ mod tests {
         }
 
         #[test]
+        fn git_server() {
+            assert_eq!(
+                RepoRef::try_from(create()).unwrap().git_server,
+                "https://localhost:1000",
+            )
+        }
+
+        #[test]
         fn relays() {
             assert_eq!(
                 RepoRef::try_from(create()).unwrap().relays,
                 vec!["ws://relay1.io".to_string(), "ws://relay2.io".to_string()],
             )
         }
+
+        #[test]
+        fn maintainers() {
+            assert_eq!(
+                RepoRef::try_from(create()).unwrap().maintainers,
+                vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],
+            )
+        }
     }
 
     mod to_event {
@@ -186,6 +298,21 @@ mod tests {
             }
 
             #[test]
+            fn git_server() {
+                assert!(create().tags.iter().any(|t| t.as_vec()[0].eq("git-server")
+                    && t.as_vec()[1].eq("https://localhost:1000")))
+            }
+
+            #[test]
+            fn git_server_as_reference() {
+                assert!(
+                    create().tags.iter().any(
+                        |t| t.as_vec()[0].eq("r") && t.as_vec()[1].eq("https://localhost:1000")
+                    )
+                )
+            }
+
+            #[test]
             fn root_commit_as_reference() {
                 assert!(
                     create()
@@ -209,8 +336,27 @@ mod tests {
             }
 
             #[test]
+            fn maintainers() {
+                let event = create();
+                let p_tags = event
+                    .tags
+                    .iter()
+                    .filter(|t| t.as_vec()[0].eq("p"))
+                    .collect::<Vec<&nostr::Tag>>();
+                assert_eq!(p_tags[0].as_vec().len(), 2);
+                assert_eq!(
+                    p_tags[0].as_vec()[1],
+                    TEST_KEY_1_KEYS.public_key().to_string()
+                );
+                assert_eq!(
+                    p_tags[1].as_vec()[1],
+                    TEST_KEY_2_KEYS.public_key().to_string()
+                );
+            }
+
+            #[test]
             fn no_other_tags() {
-                assert_eq!(create().tags.len(), 6)
+                assert_eq!(create().tags.len(), 10)
             }
         }
     }
diff --git a/src/sub_commands/claim.rs b/src/sub_commands/claim.rs
index c0d26dd..2573267 100644
--- a/src/sub_commands/claim.rs
+++ b/src/sub_commands/claim.rs
@@ -10,7 +10,7 @@ use crate::{
     client::Connect,
     git::{Repo, RepoActions},
     login,
-    repo_ref::RepoRef,
+    repo_ref::{extract_pks, get_repo_config_from_yaml, save_repo_config_to_yaml, RepoRef},
     Cli,
 };
 
@@ -22,6 +22,9 @@ pub struct SubCommandArgs {
     #[clap(short, long)]
     /// optional description
     description: Option<String>,
+    #[clap(short, long, value_parser, num_args = 1..)]
+    /// relays contributors push patches and comments to
+    relays: Vec<String>,
 }
 
 pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
@@ -37,6 +40,8 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
 
     // TODO: check for empty repo
     // TODO: check for existing maintaiers file
+
+    let repo_config_result = get_repo_config_from_yaml(&git_repo);
     // TODO: check for other claims
 
     let name = match &args.title {
@@ -50,6 +55,8 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             .input(PromptInputParms::default().with_prompt("description (Optional)"))?,
     };
 
+    let git_server = git_repo.get_origin_url()?;
+
     #[cfg(not(test))]
     let mut client = Client::default();
     #[cfg(test)]
@@ -59,11 +66,41 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
 
     client.set_keys(&keys).await;
 
-    // TODO: choice input defaulting to user relay list filtered by non paid relays
-    let repo_relays: Vec<String> = vec![
-        "ws://localhost:8055".to_string(),
-        "ws://localhost:8056".to_string(),
-    ];
+    let mut maintainers = vec![keys.public_key()];
+
+    let repo_relays: Vec<String> = if !args.relays.is_empty() {
+        args.relays.clone()
+    } else if let Ok(config) = &repo_config_result {
+        config.relays.clone()
+    } else {
+        // TODO: choice input defaulting to user relay list filtered by non paid relays
+        // TODO: allow manual input for more relays
+        // TODO: reccommend some free relays
+        user_ref.relays.write()
+    };
+
+    if let Ok(config) = &repo_config_result {
+        maintainers = extract_pks(config.maintainers.clone())?;
+    }
+
+    // if yaml file doesnt exist or needs updating
+    if match &repo_config_result {
+        Ok(config) => {
+            !(extract_pks(config.maintainers.clone())?.eq(&maintainers)
+                && config.relays.eq(&repo_relays))
+        }
+        Err(_) => true,
+    } {
+        save_repo_config_to_yaml(&git_repo, maintainers.clone(), repo_relays.clone())?;
+        println!(
+            "maintainers.yaml {}. commit and push.",
+            if repo_config_result.is_err() {
+                "created"
+            } else {
+                "updated"
+            }
+        );
+    }
 
     println!("publishing repostory reference...");
 
@@ -71,10 +108,13 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         name,
         description,
         root_commit: root_commit.to_string(),
+        git_server,
         relays: repo_relays.clone(),
+        maintainers,
     }
     .to_event(&keys)?;
 
+    // TODO: send repo event to blaster
     send_events(
         &client,
         vec![repo_event],
diff --git a/src/sub_commands/prs/create.rs b/src/sub_commands/prs/create.rs
index 5c4e578..5e41a56 100644
--- a/src/sub_commands/prs/create.rs
+++ b/src/sub_commands/prs/create.rs
@@ -100,12 +100,12 @@ pub async fn launch(
         generate_pr_and_patch_events(&title, &description, &to_branch, &git_repo, &ahead, &keys)?;
 
     let repo_ref = repo_ref::fetch(
+        &git_repo,
         git_repo
             .get_root_commit(&to_branch)
             .context("failed to get root commit of the repository")?
             .to_string(),
         &client,
-        // TODO: get relay list from local yaml file
         user_ref.relays.write(),
     )
     .await?;
diff --git a/src/sub_commands/prs/list.rs b/src/sub_commands/prs/list.rs
index 13f29fd..a6aa8b7 100644
--- a/src/sub_commands/prs/list.rs
+++ b/src/sub_commands/prs/list.rs
@@ -45,6 +45,7 @@ pub async fn launch(
     let client = <MockConnect as std::default::Default>::default();
 
     let repo_ref = repo_ref::fetch(
+        &git_repo,
         root_commit.to_string(),
         &client,
         client.get_more_fallback_relays().clone(),
diff --git a/src/sub_commands/pull.rs b/src/sub_commands/pull.rs
index a6513e8..a656e09 100644
--- a/src/sub_commands/pull.rs
+++ b/src/sub_commands/pull.rs
@@ -38,6 +38,7 @@ pub async fn launch() -> Result<()> {
     let client = <MockConnect as std::default::Default>::default();
 
     let repo_ref = repo_ref::fetch(
+        &git_repo,
         root_commit.to_string(),
         &client,
         client.get_more_fallback_relays().clone(),
diff --git a/src/sub_commands/push.rs b/src/sub_commands/push.rs
index 968aa0a..7c64bb2 100644
--- a/src/sub_commands/push.rs
+++ b/src/sub_commands/push.rs
@@ -41,6 +41,7 @@ pub async fn launch(cli_args: &Cli) -> Result<()> {
     let mut client = <MockConnect as std::default::Default>::default();
 
     let repo_ref = repo_ref::fetch(
+        &git_repo,
         root_commit.to_string(),
         &client,
         client.get_more_fallback_relays().clone(),
diff --git a/test_utils/src/git.rs b/test_utils/src/git.rs
index af87a3a..7f0b4c7 100644
--- a/test_utils/src/git.rs
+++ b/test_utils/src/git.rs
@@ -146,6 +146,11 @@ impl GitTestRepo {
             .context(format!("cannot find branch {branch_name}"))?;
         Ok(branch.into_reference().peel_to_commit()?.id())
     }
+
+    pub fn add_remote(&self, name: &str, url: &str) -> Result<()> {
+        self.git_repo.remote(name, url)?;
+        Ok(())
+    }
 }
 
 impl Drop for GitTestRepo {
diff --git a/tests/claim.rs b/tests/claim.rs
index 61be68b..cd845f7 100644
--- a/tests/claim.rs
+++ b/tests/claim.rs
@@ -11,260 +11,509 @@ fn when_no_main_or_master_branch_return_error() -> Result<()> {
     Ok(())
 }
 
-mod sends_repoistory_to_relays {
-    use futures::join;
-    use test_utils::relay::Relay;
+fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
+    p.expect("searching for your details...\r\n")?;
+    p.expect("\r")?;
+    p.expect("logged in as fred\r\n")?;
+    // // p.expect("searching for existing claims on repository...\r\n")?;
+    p.expect("maintainers.yaml created. commit and push.\r\n")?;
+    p.expect("publishing repostory reference...\r\n")?;
+    Ok(())
+}
 
+mod when_repo_not_previously_claimed {
     use super::*;
 
-    fn prep_git_repo() -> Result<GitTestRepo> {
-        let test_repo = GitTestRepo::default();
-        test_repo.populate()?;
-        Ok(test_repo)
-    }
+    mod when_repo_relays_specified_as_arguments {
+        use futures::join;
+        use test_utils::relay::Relay;
 
-    fn cli_tester_claim(git_repo: &GitTestRepo) -> CliTester {
-        CliTester::new_from_dir(
-            &git_repo.dir,
-            [
-                "--nsec",
-                TEST_KEY_1_NSEC,
-                "--password",
-                TEST_PASSWORD,
-                "--disable-cli-spinners",
-                "claim",
-                "--title",
-                "example-name",
-                "--description",
-                "example-description",
-            ],
-        )
-    }
+        use super::*;
 
-    fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
-        p.expect("searching for your details...\r\n")?;
-        p.expect("\r")?;
-        p.expect("logged in as fred\r\n")?;
-        // // p.expect("searching for existing claims on repository...\r\n")?;
-        p.expect("publishing repostory reference...\r\n")?;
-        Ok(())
-    }
+        fn prep_git_repo() -> Result<GitTestRepo> {
+            let test_repo = GitTestRepo::default();
+            test_repo.populate()?;
+            test_repo.add_remote("origin", "https://localhost:1000")?;
+            Ok(test_repo)
+        }
 
-    async fn prep_run_claim() -> Result<(
-        Relay<'static>,
-        Relay<'static>,
-        Relay<'static>,
-        Relay<'static>,
-        Relay<'static>,
-    )> {
-        let git_repo = prep_git_repo()?;
-        // fallback (51,52) user write (53, 55) repo (55, 56)
-        let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
-            Relay::new(
-                8051,
-                None,
-                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
-                    relay.respond_events(
-                        client_id,
-                        &subscription_id,
-                        &vec![
-                            generate_test_key_1_metadata_event("fred"),
-                            generate_test_key_1_relay_list_event(),
-                        ],
-                    )?;
+        fn cli_tester_claim(git_repo: &GitTestRepo) -> CliTester {
+            CliTester::new_from_dir(
+                &git_repo.dir,
+                [
+                    "--nsec",
+                    TEST_KEY_1_NSEC,
+                    "--password",
+                    TEST_PASSWORD,
+                    "--disable-cli-spinners",
+                    "claim",
+                    "--title",
+                    "example-name",
+                    "--description",
+                    "example-description",
+                    "--relays",
+                    "ws://localhost:8055",
+                    "ws://localhost:8056",
+                ],
+            )
+        }
+
+        async fn prep_run_claim() -> Result<(
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+        )> {
+            let git_repo = prep_git_repo()?;
+            // fallback (51,52) user write (53, 55) repo (55, 56)
+            let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                Relay::new(
+                    8051,
+                    None,
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ),
+                Relay::new(8052, None, None),
+                Relay::new(8053, None, None),
+                Relay::new(8055, None, None),
+                Relay::new(8056, None, None),
+            );
+
+            // // check relay had the right number of events
+            let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                let mut p = cli_tester_claim(&git_repo);
+                p.expect_end_eventually()?;
+                for p in [51, 52, 53, 55, 56] {
+                    relay::shutdown_relay(8000 + p)?;
+                }
+                Ok(())
+            });
+
+            // launch relay
+            let _ = join!(
+                r51.listen_until_close(),
+                r52.listen_until_close(),
+                r53.listen_until_close(),
+                r55.listen_until_close(),
+                r56.listen_until_close(),
+            );
+            cli_tester_handle.join().unwrap()?;
+            Ok((r51, r52, r53, r55, r56))
+        }
+
+        mod sent_to_correct_relays {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
+                let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55] {
+                    assert_eq!(
+                        relay
+                            .events
+                            .iter()
+                            .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                            .count(),
+                        1,
+                    );
+                }
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
+                let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r55, &r56] {
+                    assert_eq!(
+                        relay
+                            .events
+                            .iter()
+                            .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                            .count(),
+                        1,
+                    );
+                }
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn event_not_sent_to_fallback_relay() -> Result<()> {
+                let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r51, &r52] {
+                    assert_eq!(
+                        relay
+                            .events
+                            .iter()
+                            .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                            .count(),
+                        0,
+                    );
+                }
+                Ok(())
+            }
+        }
+
+        mod yaml_file {
+            use std::{fs, io::Read};
+
+            use super::*;
+
+            async fn async_run_test() -> Result<()> {
+                let git_repo = prep_git_repo()?;
+                // fallback (51,52) user write (53, 55) repo (55, 56)
+                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                    Relay::new(
+                        8051,
+                        None,
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![
+                                    generate_test_key_1_metadata_event("fred"),
+                                    generate_test_key_1_relay_list_event(),
+                                ],
+                            )?;
+                            Ok(())
+                        }),
+                    ),
+                    Relay::new(8052, None, None),
+                    Relay::new(8053, None, None),
+                    Relay::new(8055, None, None),
+                    Relay::new(8056, None, None),
+                );
+
+                // // check relay had the right number of events
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    let mut p = cli_tester_claim(&git_repo);
+                    p.expect_end_eventually()?;
+
+                    let yaml_path = git_repo.dir.join("maintainers.yaml");
+
+                    assert!(yaml_path.exists());
+
+                    let mut file = fs::File::open(yaml_path).expect("no such file");
+                    let mut file_contents = "".to_string();
+                    let _ = file.read_to_string(&mut file_contents);
+                    assert_eq!(
+                        file_contents,
+                        format!(
+                            "\
+                        maintainers:\n\
+                        - {TEST_KEY_1_NPUB}\n\
+                        relays:\n\
+                        - ws://localhost:8055\n\
+                        - ws://localhost:8056\n\
+                        "
+                        ),
+                    );
+                    for p in [51, 52, 53, 55, 56] {
+                        relay::shutdown_relay(8000 + p)?;
+                    }
                     Ok(())
-                }),
-            ),
-            Relay::new(8052, None, None),
-            Relay::new(8053, None, None),
-            Relay::new(8055, None, None),
-            Relay::new(8056, None, None),
-        );
-
-        // // check relay had the right number of events
-        let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-            let mut p = cli_tester_claim(&git_repo);
-            p.expect_end_eventually()?;
-            for p in [51, 52, 53, 55, 56] {
-                relay::shutdown_relay(8000 + p)?;
+                });
+
+                // launch relay
+                let _ = join!(
+                    r51.listen_until_close(),
+                    r52.listen_until_close(),
+                    r53.listen_until_close(),
+                    r55.listen_until_close(),
+                    r56.listen_until_close(),
+                );
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
             }
-            Ok(())
-        });
-
-        // launch relay
-        let _ = join!(
-            r51.listen_until_close(),
-            r52.listen_until_close(),
-            r53.listen_until_close(),
-            r55.listen_until_close(),
-            r56.listen_until_close(),
-        );
-        cli_tester_handle.join().unwrap()?;
-        Ok((r51, r52, r53, r55, r56))
-    }
 
-    mod sent_to_correct_relays {
-        use super::*;
+            #[test]
+            #[serial]
+            fn contains_maintainers_and_relays() -> Result<()> {
+                futures::executor::block_on(async_run_test())?;
+                Ok(())
+            }
+        }
+
+        mod tags {
+            use super::*;
 
-        #[test]
-        #[serial]
-        fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
-            let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55] {
-                assert_eq!(
-                    relay
+            #[test]
+            #[serial]
+            fn root_commit_as_d_replaceable_event_identifier() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
                         .events
                         .iter()
-                        .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                        .count(),
-                    1,
-                );
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("d")
+                        && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
+                }
+                Ok(())
             }
-            Ok(())
-        }
 
-        #[test]
-        #[serial]
-        fn only_1_repository_kind_event_sent_to_repo_relays() -> Result<()> {
-            let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r55, &r56] {
-                assert_eq!(
-                    relay
+            #[test]
+            #[serial]
+            fn root_commit_as_reference() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
                         .events
                         .iter()
-                        .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                        .count(),
-                    1,
-                );
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    // root commit 'r' tag with 'r-' prefix
+                    assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("r")
+                        && t.as_vec()[1].eq("r-9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
+                }
+                Ok(())
             }
-            Ok(())
-        }
 
-        #[test]
-        #[serial]
-        fn event_not_sent_to_fallback_relay() -> Result<()> {
-            let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r51, &r52] {
-                assert_eq!(
-                    relay
+            #[test]
+            #[serial]
+            fn name() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
                         .events
                         .iter()
-                        .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                        .count(),
-                    0,
-                );
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    assert!(
+                        event
+                            .tags
+                            .iter()
+                            .any(|t| t.as_vec()[0].eq("name") && t.as_vec()[1].eq("example-name"))
+                    );
+                }
+                Ok(())
             }
-            Ok(())
-        }
-    }
 
-    mod tags {
-        use super::*;
+            #[test]
+            #[serial]
+            fn description() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
 
-        #[test]
-        #[serial]
-        fn root_commit_as_d_replaceable_event_identifier() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55, &r56] {
-                let event: &nostr::Event = relay
-                    .events
-                    .iter()
-                    .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                    .unwrap();
-
-                assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("d")
-                    && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
+                    assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("description")
+                        && t.as_vec()[1].eq("example-description")));
+                }
+                Ok(())
             }
-            Ok(())
-        }
 
-        #[test]
-        #[serial]
-        fn root_commit_as_reference() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55, &r56] {
-                let event: &nostr::Event = relay
-                    .events
-                    .iter()
-                    .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                    .unwrap();
-
-                // root commit 'r' tag with 'r-' prefix
-                assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("r")
-                    && t.as_vec()[1].eq("r-9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
+            #[test]
+            #[serial]
+            fn git_server() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    assert!(event.tags.iter().any(|t| t.as_vec()[0].eq("git-server")
+                        && t.as_vec()[1].eq("https://localhost:1000")));
+                }
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn git_server_as_reference() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    assert!(event.tags.iter().any(
+                        |t| t.as_vec()[0].eq("r") && t.as_vec()[1].eq("https://localhost:1000")
+                    ));
+                }
+                Ok(())
             }
-            Ok(())
-        }
 
-        #[test]
-        #[serial]
-        fn name() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55, &r56] {
-                let event: &nostr::Event = relay
-                    .events
-                    .iter()
-                    .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                    .unwrap();
-
-                assert!(
-                    event
+            #[test]
+            #[serial]
+            fn relays() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    let relay_tags = event
                         .tags
                         .iter()
-                        .any(|t| t.as_vec()[0].eq("name") && t.as_vec()[1].eq("example-name"))
-                );
+                        .filter(|t| t.as_vec()[0].eq("relay"))
+                        .collect::<Vec<&nostr::Tag>>();
+                    assert_eq!(relay_tags[0].as_vec()[1], "ws://localhost:8055");
+                    assert_eq!(relay_tags[1].as_vec()[1], "ws://localhost:8056");
+                }
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn current_user_tagged_indicating_maintainer() -> Result<()> {
+                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55, &r56] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    let relay_tags = event
+                        .tags
+                        .iter()
+                        .filter(|t| t.as_vec()[0].eq("p"))
+                        .collect::<Vec<&nostr::Tag>>();
+                    assert_eq!(relay_tags.len(), 1);
+                    assert_eq!(
+                        relay_tags[0].as_vec()[1],
+                        TEST_KEY_1_KEYS.public_key().to_string()
+                    );
+                }
+                Ok(())
             }
-            Ok(())
         }
 
-        #[test]
-        #[serial]
-        fn description() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55, &r56] {
-                let event: &nostr::Event = relay
-                    .events
-                    .iter()
-                    .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                    .unwrap();
-
-                assert!(
-                    event.tags.iter().any(|t| t.as_vec()[0].eq("description")
-                        && t.as_vec()[1].eq("example-description"))
+        mod cli_ouput {
+            use super::*;
+
+            async fn run_test_async() -> Result<()> {
+                let git_repo = prep_git_repo()?;
+
+                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                    Relay::new(
+                        8051,
+                        None,
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![
+                                    generate_test_key_1_metadata_event("fred"),
+                                    generate_test_key_1_relay_list_event(),
+                                ],
+                            )?;
+                            Ok(())
+                        }),
+                    ),
+                    Relay::new(8052, None, None),
+                    Relay::new(8053, None, None),
+                    Relay::new(8055, None, None),
+                    Relay::new(8056, None, None),
                 );
+
+                // // check relay had the right number of events
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    let mut p = cli_tester_claim(&git_repo);
+                    expect_msgs_first(&mut p)?;
+                    relay::expect_send_with_progress(
+                        &mut p,
+                        vec![
+                            (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
+                            (" [my-relay] ws://localhost:8053", true, ""),
+                            (" [repo-relay] ws://localhost:8056", true, ""),
+                        ],
+                        1,
+                    )?;
+                    p.expect_end_with_whitespace()?;
+                    for p in [51, 52, 53, 55, 56] {
+                        relay::shutdown_relay(8000 + p)?;
+                    }
+                    Ok(())
+                });
+
+                // launch relay
+                let _ = join!(
+                    r51.listen_until_close(),
+                    r52.listen_until_close(),
+                    r53.listen_until_close(),
+                    r55.listen_until_close(),
+                    r56.listen_until_close(),
+                );
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
             }
-            Ok(())
-        }
 
-        #[test]
-        #[serial]
-        fn relays() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
-            for relay in [&r53, &r55, &r56] {
-                let event: &nostr::Event = relay
-                    .events
-                    .iter()
-                    .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
-                    .unwrap();
-
-                let relay_tags = event
-                    .tags
-                    .iter()
-                    .filter(|t| t.as_vec()[0].eq("relay"))
-                    .collect::<Vec<&nostr::Tag>>();
-                assert_eq!(relay_tags[0].as_vec()[1], "ws://localhost:8055");
-                assert_eq!(relay_tags[1].as_vec()[1], "ws://localhost:8056");
+            #[test]
+            #[serial]
+            fn check_cli_output() -> Result<()> {
+                futures::executor::block_on(run_test_async())?;
+                Ok(())
             }
-            Ok(())
         }
     }
 
-    mod cli_ouput {
+    mod when_repo_relays_not_specified {
+        use futures::join;
+        use test_utils::relay::Relay;
+
         use super::*;
 
-        async fn run_test_async() -> Result<()> {
-            let git_repo = prep_git_repo()?;
+        fn prep_git_repo() -> Result<GitTestRepo> {
+            let test_repo = GitTestRepo::default();
+            test_repo.populate()?;
+            test_repo.add_remote("origin", "https://localhost:1000")?;
+            Ok(test_repo)
+        }
+
+        fn cli_tester_claim(git_repo: &GitTestRepo) -> CliTester {
+            CliTester::new_from_dir(
+                &git_repo.dir,
+                [
+                    "--nsec",
+                    TEST_KEY_1_NSEC,
+                    "--password",
+                    TEST_PASSWORD,
+                    "--disable-cli-spinners",
+                    "claim",
+                    "--title",
+                    "example-name",
+                    "--description",
+                    "example-description",
+                ],
+            )
+        }
 
+        async fn prep_run_claim() -> Result<(
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+        )> {
+            let git_repo = prep_git_repo()?;
+            // fallback (51,52) user write (53, 55) repo (55, 56)
             let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
                 Relay::new(
                     8051,
@@ -290,17 +539,7 @@ mod sends_repoistory_to_relays {
             // // check relay had the right number of events
             let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
                 let mut p = cli_tester_claim(&git_repo);
-                expect_msgs_first(&mut p)?;
-                relay::expect_send_with_progress(
-                    &mut p,
-                    vec![
-                        (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
-                        (" [my-relay] ws://localhost:8053", true, ""),
-                        (" [repo-relay] ws://localhost:8056", true, ""),
-                    ],
-                    1,
-                )?;
-                p.expect_end_with_whitespace()?;
+                p.expect_end_eventually()?;
                 for p in [51, 52, 53, 55, 56] {
                     relay::shutdown_relay(8000 + p)?;
                 }
@@ -316,14 +555,102 @@ mod sends_repoistory_to_relays {
                 r56.listen_until_close(),
             );
             cli_tester_handle.join().unwrap()?;
-            Ok(())
+            Ok((r51, r52, r53, r55, r56))
+        }
+
+        mod tags {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn relays_match_user_write_relays() -> Result<()> {
+                let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?;
+                for relay in [&r53, &r55] {
+                    let event: &nostr::Event = relay
+                        .events
+                        .iter()
+                        .find(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .unwrap();
+
+                    let relay_tags = event
+                        .tags
+                        .iter()
+                        .filter(|t| t.as_vec()[0].eq("relay"))
+                        .collect::<Vec<&nostr::Tag>>();
+                    assert_eq!(relay_tags[0].as_vec()[1], "ws://localhost:8053");
+                    assert_eq!(relay_tags[1].as_vec()[1], "ws://localhost:8055");
+                }
+                Ok(())
+            }
         }
 
-        #[test]
-        #[serial]
-        fn check_cli_output() -> Result<()> {
-            futures::executor::block_on(run_test_async())?;
-            Ok(())
+        mod cli_ouput {
+            use super::*;
+
+            async fn run_test_async() -> Result<()> {
+                let git_repo = prep_git_repo()?;
+
+                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                    Relay::new(
+                        8051,
+                        None,
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![
+                                    generate_test_key_1_metadata_event("fred"),
+                                    generate_test_key_1_relay_list_event(),
+                                ],
+                            )?;
+                            Ok(())
+                        }),
+                    ),
+                    Relay::new(8052, None, None),
+                    Relay::new(8053, None, None),
+                    Relay::new(8055, None, None),
+                    Relay::new(8056, None, None),
+                );
+
+                // // check relay had the right number of events
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    let mut p = cli_tester_claim(&git_repo);
+                    expect_msgs_first(&mut p)?;
+                    relay::expect_send_with_progress(
+                        &mut p,
+                        vec![
+                            (" [my-relay] [repo-relay] ws://localhost:8053", true, ""),
+                            (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
+                        ],
+                        1,
+                    )?;
+                    p.expect_end_with_whitespace()?;
+                    for p in [51, 52, 53, 55, 56] {
+                        relay::shutdown_relay(8000 + p)?;
+                    }
+                    Ok(())
+                });
+
+                // launch relay
+                let _ = join!(
+                    r51.listen_until_close(),
+                    r52.listen_until_close(),
+                    r53.listen_until_close(),
+                    r55.listen_until_close(),
+                    r56.listen_until_close(),
+                );
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn check_cli_output() -> Result<()> {
+                futures::executor::block_on(run_test_async())?;
+                Ok(())
+            }
         }
     }
 }
+
+// TODO: when_updating_existing_repoistory