feat(login): store in git config and use cache

replace ngit yaml file config with:
 * nsec / ncryptsec / npub in git config in nostr.* namespace
 * sql database cache for metadata and relay events

allow different logins to be used for different git repositories by
storing login in local git config

16 files changed, 593 insertions, 1694 deletions

diff --git a/Cargo.lock b/Cargo.lock
index bf0032e..850da5b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -956,6 +956,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
 name = "fastrand"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -971,6 +983,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
 
 [[package]]
+name = "flatbuffers"
+version = "23.5.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dac53e22462d78c16d64a1cd22371b54cc3fe94aa15e7886a2fa6e5d1ab8640"
+dependencies = [
+ "bitflags 1.3.2",
+ "rustc_version",
+]
+
+[[package]]
 name = "float-cmp"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1197,6 +1219,15 @@ dependencies = [
 ]
 
 [[package]]
+name = "hashlink"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+dependencies = [
+ "hashbrown",
+]
+
+[[package]]
 name = "heck"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1513,6 +1544,17 @@ dependencies = [
 ]
 
 [[package]]
+name = "libsqlite3-sys"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
 name = "libssh2-sys"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1717,7 +1759,9 @@ dependencies = [
  "keyring",
  "mockall",
  "nostr",
+ "nostr-database",
  "nostr-sdk",
+ "nostr-sqlite",
  "once_cell",
  "passwords",
  "rexpect 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1811,6 +1855,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a88a72f92fbd5d2514db36e07a864646f1c1f44931c4a5ea195f6961029af4b3"
 dependencies = [
  "async-trait",
+ "flatbuffers",
  "lru",
  "nostr",
  "thiserror",
@@ -1869,6 +1914,21 @@ dependencies = [
 ]
 
 [[package]]
+name = "nostr-sqlite"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418555707a30105f738b3a54a1ae13ffca5e7ec10b4d27a8c20bedde636233c3"
+dependencies = [
+ "async-trait",
+ "nostr",
+ "nostr-database",
+ "rusqlite",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
 name = "nostr-zapper"
 version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2509,6 +2569,20 @@ dependencies = [
 ]
 
 [[package]]
+name = "rusqlite"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b838eba278d213a8beaf485bd313fd580ca4505a00d5871caeb1457c55322cae"
+dependencies = [
+ "bitflags 2.5.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
+[[package]]
 name = "rustc-demangle"
 version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/Cargo.toml b/Cargo.toml
index a57f9d4..e25fd51 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,9 @@ git2 = "0.18.1"
 indicatif = "0.17.7"
 keyring = "2.0.5"
 nostr = "0.32.0"
+nostr-database = "0.32.0"
 nostr-sdk = "0.32.0"
+nostr-sqlite = "0.32.0"
 passwords = "3.1.13"
 scrypt = "0.11.0"
 serde = { version = "1.0.181", features = ["derive"] }
diff --git a/src/config.rs b/src/config.rs
index 7fca446..56619b8 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,107 +1,19 @@
-use std::{fs::File, io::BufReader};
-
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
 use directories::ProjectDirs;
-#[cfg(test)]
-use mockall::*;
-use nostr::{PublicKey, ToBech32};
+use nostr::PublicKey;
 use serde::{self, Deserialize, Serialize};
 
-#[derive(Default)]
-#[allow(clippy::module_name_repetitions)]
-pub struct ConfigManager;
-
-#[cfg_attr(test, automock)]
-#[allow(clippy::module_name_repetitions)]
-pub trait ConfigManagement {
-    fn load(&self) -> Result<MyConfig>;
-    fn save(&self, cfg: &MyConfig) -> Result<()>;
-}
-
 pub fn get_dirs() -> Result<ProjectDirs> {
     ProjectDirs::from("", "CodeCollaboration", "ngit").ok_or(anyhow!(
         "should find operating system home directories with rust-directories crate"
     ))
 }
 
-impl ConfigManagement for ConfigManager {
-    fn load(&self) -> Result<MyConfig> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        if config_path.exists() {
-            let file =
-                File::open(config_path).context("should open application configuration file")?;
-            let reader = BufReader::new(file);
-            let config: MyConfig = serde_json::from_reader(reader)
-                .context("should read config from config file with serde_json")?;
-            Ok(config)
-        } else {
-            Ok(MyConfig::default())
-        }
-    }
-    fn save(&self, cfg: &MyConfig) -> Result<()> {
-        let dirs = get_dirs()?;
-        let config_path = dirs.config_dir().join("config.json");
-        let file = if config_path.exists() {
-            std::fs::OpenOptions::new()
-                .create(true)
-                .write(true)
-                .truncate(true)
-                .open(config_path)
-                .context(
-                    "should open application configuration file with write and truncate options",
-                )?
-        } else {
-            std::fs::create_dir_all(dirs.config_dir())
-                .context("should create application config directories")?;
-            std::fs::File::create(config_path).context("should create application config file")?
-        };
-        serde_json::to_writer_pretty(file, cfg)
-            .context("should write configuration to config file with serde_json")
-    }
-}
-
-#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
-#[allow(clippy::module_name_repetitions)]
-pub struct MyConfig {
-    pub version: u8,
-    pub users: Vec<UserRef>,
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRef {
     pub public_key: PublicKey,
-    pub encrypted_key: String,
     pub metadata: UserMetadata,
     pub relays: UserRelays,
-    pub last_checked: u64,
-}
-
-impl UserRef {
-    pub fn new(public_key: PublicKey, encrypted_key: String) -> Self {
-        Self {
-            public_key,
-            encrypted_key,
-            relays: UserRelays {
-                relays: vec![],
-                created_at: 0,
-            },
-            metadata: UserMetadata {
-                #[allow(clippy::expect_used)]
-                name: public_key
-                    .to_bech32()
-                    .expect("public key should always produce bech32"),
-                // name: format!(
-                //     "{}",
-                //     public_key
-                //         .to_bech32()
-                //         .expect("public key should always produce bech32"),
-                // )
-                // .as_str()[..10].to_string(),
-                created_at: 0,
-            },
-            last_checked: 0,
-        }
-    }
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -132,100 +44,3 @@ pub struct UserRelayRef {
     pub read: bool,
     pub write: bool,
 }
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-    use serial_test::serial;
-
-    use super::*;
-
-    fn backup_existing_config() -> Result<()> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        let backup_config_path = get_dirs()?.config_dir().join("config-backup.json");
-        if config_path.exists() {
-            std::fs::rename(config_path, backup_config_path)?;
-        }
-        Ok(())
-    }
-
-    fn restore_config_backup() -> Result<()> {
-        let config_path = get_dirs()?.config_dir().join("config.json");
-        let backup_config_path = get_dirs()?.config_dir().join("config-backup.json");
-        if config_path.exists() {
-            std::fs::remove_file(&config_path)?;
-        }
-        if backup_config_path.exists() {
-            std::fs::rename(backup_config_path, config_path)?;
-        }
-        Ok(())
-    }
-
-    mod load {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn when_config_file_doesnt_exist_defaults_are_returned() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            assert_eq!(c.load()?, MyConfig::default());
-            restore_config_backup()?;
-            Ok(())
-        }
-
-        #[test]
-        #[serial]
-        fn when_config_file_exists_it_is_returned() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let new_config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load()?, new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-    }
-
-    mod save {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn when_config_file_doesnt_config_is_saved() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let new_config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load().unwrap(), new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-
-        #[test]
-        #[serial]
-        fn when_config_file_exists_new_config_is_saved() -> Result<()> {
-            backup_existing_config()?;
-            let c = ConfigManager;
-            let config = MyConfig {
-                version: 255,
-                ..MyConfig::default()
-            };
-            c.save(&config)?;
-            let new_config = MyConfig {
-                version: 254,
-                ..MyConfig::default()
-            };
-            c.save(&new_config)?;
-            assert_eq!(c.load().unwrap(), new_config);
-            restore_config_backup()?;
-            Ok(())
-        }
-    }
-}
diff --git a/src/key_handling/encryption.rs b/src/key_handling/encryption.rs
index 3f4ee41..3841d50 100644
--- a/src/key_handling/encryption.rs
+++ b/src/key_handling/encryption.rs
@@ -1,46 +1,31 @@
 use anyhow::Result;
-#[cfg(test)]
-use mockall::*;
 use nostr::{prelude::*, Keys};
 
-#[derive(Default)]
-pub struct Encryptor;
-
-#[cfg_attr(test, automock)]
-pub trait EncryptDecrypt {
-    /// requires less CPU time if the password is long
-    fn encrypt_key(&self, keys: &Keys, password: &str) -> Result<String>;
-    fn decrypt_key(&self, encrypted_key: &str, password: &str) -> Result<Keys>;
+pub fn encrypt_key(keys: &Keys, password: &str) -> Result<String> {
+    let log2_rounds: u8 = if password.len() > 20 {
+        // we have enough of entropy - no need to spend CPU time adding much more
+        1
+    } else {
+        println!("this may take a few seconds...");
+        // default (scrypt::Params::RECOMMENDED_LOG_N) is 17 but 30s is too long to wait
+        15
+    };
+    Ok(nostr::nips::nip49::EncryptedSecretKey::new(
+        keys.secret_key()?,
+        password,
+        log2_rounds,
+        KeySecurity::Medium,
+    )?
+    .to_bech32()?)
 }
 
-/// approach and code adapted from nostr gossip client
-impl EncryptDecrypt for Encryptor {
-    fn encrypt_key(&self, keys: &Keys, password: &str) -> Result<String> {
-        let log2_rounds: u8 = if password.len() > 20 {
-            // we have enough of entropy - no need to spend CPU time adding much more
-            1
-        } else {
-            println!("this may take a few seconds...");
-            // default (scrypt::Params::RECOMMENDED_LOG_N) is 17 but 30s is too long to wait
-            15
-        };
-        Ok(nostr::nips::nip49::EncryptedSecretKey::new(
-            keys.secret_key()?,
-            password,
-            log2_rounds,
-            KeySecurity::Medium,
-        )?
-        .to_bech32()?)
-    }
-
-    fn decrypt_key(&self, encrypted_key: &str, password: &str) -> Result<nostr::Keys> {
-        let encrypted_key = nostr::nips::nip49::EncryptedSecretKey::from_bech32(encrypted_key)?;
-        // to request that log_n gets exposed
-        if encrypted_key.log_n() > 14 {
-            println!("this may take a few seconds...");
-        }
-        Ok(nostr::Keys::new(encrypted_key.to_secret_key(password)?))
+pub fn decrypt_key(encrypted_key: &str, password: &str) -> Result<nostr::Keys> {
+    let encrypted_key = nostr::nips::nip49::EncryptedSecretKey::from_bech32(encrypted_key)?;
+    // to request that log_n gets exposed
+    if encrypted_key.log_n() > 14 {
+        println!("this may take a few seconds...");
     }
+    Ok(nostr::Keys::new(encrypted_key.to_secret_key(password)?))
 }
 
 #[cfg(test)]
@@ -51,7 +36,7 @@ mod tests {
 
     #[test]
     fn encrypt_key_produces_string_prefixed_with() -> Result<()> {
-        let s = Encryptor.encrypt_key(&nostr::Keys::generate(), TEST_PASSWORD)?;
+        let s = encrypt_key(&nostr::Keys::generate(), TEST_PASSWORD)?;
         assert!(s.starts_with("ncryptsec"));
         Ok(())
     }
@@ -59,8 +44,7 @@ mod tests {
     #[test]
     // ensures password encryption hasn't changed
     fn decrypts_with_strong_password_from_reference_string() -> Result<()> {
-        let encryptor = Encryptor;
-        let decrypted_key = encryptor.decrypt_key(TEST_KEY_1_ENCRYPTED, TEST_PASSWORD)?;
+        let decrypted_key = decrypt_key(TEST_KEY_1_ENCRYPTED, TEST_PASSWORD)?;
 
         assert_eq!(
             format!(
@@ -78,8 +62,7 @@ mod tests {
     #[test]
     // ensures password encryption hasn't changed
     fn decrypts_with_weak_password_from_reference_string() -> Result<()> {
-        let encryptor = Encryptor;
-        let decrypted_key = encryptor.decrypt_key(TEST_KEY_1_ENCRYPTED_WEAK, TEST_WEAK_PASSWORD)?;
+        let decrypted_key = decrypt_key(TEST_KEY_1_ENCRYPTED_WEAK, TEST_WEAK_PASSWORD)?;
 
         assert_eq!(
             format!(
@@ -96,10 +79,9 @@ mod tests {
 
     #[test]
     fn decrypts_key_encrypted_using_encrypt_key() -> Result<()> {
-        let encryptor = Encryptor;
         let key = nostr::Keys::generate();
-        let s = encryptor.encrypt_key(&key, TEST_PASSWORD)?;
-        let newkey = encryptor.decrypt_key(s.as_str(), TEST_PASSWORD)?;
+        let s = encrypt_key(&key, TEST_PASSWORD)?;
+        let newkey = decrypt_key(s.as_str(), TEST_PASSWORD)?;
 
         assert_eq!(
             format!("{}", key.secret_key().unwrap().to_bech32().unwrap()),
@@ -110,10 +92,9 @@ mod tests {
 
     #[test]
     fn decrypt_key_successfully_decrypts_key_encrypted_using_encrypt_key() -> Result<()> {
-        let encryptor = Encryptor;
         let key = nostr::Keys::generate();
-        let s = encryptor.encrypt_key(&key, TEST_PASSWORD)?;
-        let newkey = encryptor.decrypt_key(s.as_str(), TEST_PASSWORD)?;
+        let s = encrypt_key(&key, TEST_PASSWORD)?;
+        let newkey = decrypt_key(s.as_str(), TEST_PASSWORD)?;
 
         assert_eq!(
             format!("{}", key.secret_key().unwrap().to_bech32().unwrap()),
diff --git a/src/key_handling/mod.rs b/src/key_handling/mod.rs
index bcb10df..81c4253 100644
--- a/src/key_handling/mod.rs
+++ b/src/key_handling/mod.rs
@@ -1,2 +1 @@
 pub mod encryption;
-pub mod users;
diff --git a/src/key_handling/users.rs b/src/key_handling/users.rs
deleted file mode 100644
index a79a977..0000000
--- a/src/key_handling/users.rs
+++ /dev/null
@@ -1,1174 +0,0 @@
-use std::{str::FromStr, time::SystemTime};
-
-use anyhow::{Context, Result};
-use async_trait::async_trait;
-use nostr::prelude::*;
-use zeroize::Zeroize;
-
-use super::encryption::{EncryptDecrypt, Encryptor};
-#[cfg(not(test))]
-use crate::client::Client;
-#[cfg(test)]
-use crate::client::MockConnect;
-use crate::{
-    cli_interactor::{Interactor, InteractorPrompt, PromptInputParms, PromptPasswordParms},
-    client::Connect,
-    config::{
-        self, ConfigManagement, ConfigManager, UserMetadata, UserRef, UserRelayRef, UserRelays,
-    },
-};
-
-#[derive(Default)]
-pub struct UserManager {
-    config_manager: ConfigManager,
-    interactor: Interactor,
-    encryptor: Encryptor,
-}
-
-#[async_trait]
-pub trait UserManagement {
-    fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys>;
-    async fn get_user(
-        &self,
-        #[cfg(test)] client: &MockConnect,
-        #[cfg(not(test))] client: &Client,
-        public_key: &PublicKey,
-        after: u64,
-    ) -> Result<UserRef>;
-    fn get_user_from_cache(&self, public_key: &PublicKey) -> Result<UserRef>;
-    fn add_user_to_config(
-        &self,
-        public_key: PublicKey,
-        encrypted_secret_key: Option<String>,
-        overwrite: bool,
-    ) -> Result<()>;
-}
-
-#[cfg(test)]
-use duplicate::duplicate_item;
-#[cfg_attr(test, duplicate_item(UserManager; [UserManager]; [self::tests::MockUserManager]))]
-#[async_trait]
-impl UserManagement for UserManager {
-    fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys> {
-        let mut prompt = "login with nsec (or hex private key)";
-        let keys = loop {
-            let pk = match nsec.clone() {
-                Some(nsec) => nsec,
-                None => self
-                    .interactor
-                    .input(PromptInputParms::default().with_prompt(prompt))
-                    .context("failed to get nsec input from interactor")?,
-            };
-            match Keys::from_str(&pk) {
-                Ok(key) => {
-                    break key;
-                }
-                Err(e) => {
-                    if nsec.is_some() {
-                        return Err(e).context(
-                            "invalid nsec - supplied parameter could not be converted into a nostr private key",
-                        );
-                    }
-                    prompt = "invalid nsec. try again with nsec (or hex private key)";
-                }
-            }
-        };
-
-        let mut pass = match password.clone() {
-            Some(pass) => pass,
-            None => self
-                .interactor
-                .password(
-                    PromptPasswordParms::default()
-                        .with_prompt("encrypt with password")
-                        .with_confirm(),
-                )
-                .context("failed to get password input from interactor.password")?,
-        };
-
-        let encrypted_secret_key = self
-            .encryptor
-            .encrypt_key(&keys, &pass)
-            .context("failed to encrypt nsec with password.")?;
-        pass.zeroize();
-
-        self.add_user_to_config(keys.public_key(), Some(encrypted_secret_key), true)?;
-
-        Ok(keys)
-    }
-
-    fn add_user_to_config(
-        &self,
-        public_key: PublicKey,
-        encrypted_secret_key: Option<String>,
-        overwrite: bool,
-    ) -> Result<()> {
-        let user_ref = config::UserRef::new(public_key, encrypted_secret_key.unwrap_or_default());
-
-        let mut cfg = self.config_manager.load().context("failed to load application config to find and remove any old versions of the user's encrypted key")?;
-        // don't overwrite unless specified
-        if !overwrite
-            && cfg
-                .users
-                .clone()
-                .into_iter()
-                .any(|r| r.public_key.eq(&public_key))
-        {
-            return Ok(());
-        }
-        // if overwrite remove any duplicate entries for key before adding it to config
-        cfg.users = cfg
-            .users
-            .clone()
-            .into_iter()
-            .filter(|r| !r.public_key.eq(&public_key))
-            .collect();
-        cfg.users.push(user_ref);
-        self.config_manager
-            .save(&cfg)
-            .context("failed to save application configuration with new user details in")
-    }
-
-    fn get_user_from_cache(&self, public_key: &PublicKey) -> Result<UserRef> {
-        let cfg = self
-            .config_manager
-            .load()
-            .context("failed to load application config")?;
-        Ok(cfg
-            .users
-            .iter()
-            .find(|u| u.public_key.eq(public_key))
-            .context(format!("pubkey isn't a current user: {public_key}"))?
-            .clone())
-    }
-    /// get UserRef fetching most recent user relays and metadata infomation
-    /// from
-    #[allow(clippy::too_many_lines)]
-    async fn get_user(
-        &self,
-        #[cfg(test)] client: &MockConnect,
-        #[cfg(not(test))] client: &Client,
-        public_key: &PublicKey,
-        use_cache_unless_checked_more_than_x_secs_ago: u64,
-    ) -> Result<UserRef> {
-        let cfg = self
-            .config_manager
-            .load()
-            .context("failed to load application config")?;
-        let mut user_ref = cfg
-            .users
-            .iter()
-            .find(|u| u.public_key.eq(public_key))
-            .context(format!("pubkey isn't a current user: {public_key}"))?
-            .clone();
-        // return cache if last fetched was within X minutes
-        if !unix_timestamp_after_now_plus_secs(
-            user_ref.last_checked,
-            use_cache_unless_checked_more_than_x_secs_ago,
-        ) {
-            return Ok(user_ref);
-        }
-
-        let mut relays_to_search = if user_ref.relays.write().is_empty() {
-            client.get_fallback_relays().clone()
-        } else {
-            user_ref.relays.write()
-        };
-
-        let mut relays_searched: Vec<String> = vec![];
-
-        loop {
-            for r in &relays_to_search {
-                if !relays_searched.iter().any(|sr| r.eq(sr)) {
-                    relays_searched.push(r.clone());
-                }
-            }
-
-            let events: Vec<Event> = match client
-                .get_events(
-                    relays_to_search,
-                    vec![
-                        nostr::Filter::default()
-                            .author(*public_key)
-                            .since(nostr::Timestamp::from(user_ref.metadata.created_at + 1))
-                            .kind(Kind::Metadata),
-                        nostr::Filter::default()
-                            .author(*public_key)
-                            .since(nostr::Timestamp::from(user_ref.relays.created_at + 1))
-                            .kind(Kind::RelayList),
-                    ],
-                )
-                .await
-            {
-                Ok(events) => events,
-                Err(_) => {
-                    return Ok(user_ref.clone());
-                }
-            };
-
-            user_ref.last_checked = SystemTime::now()
-                .duration_since(SystemTime::UNIX_EPOCH)
-                .context("system time should be after the year 1970")?
-                .as_secs();
-
-            if let Some(new_metadata_event) = events
-                .iter()
-                .filter(|e| e.kind.eq(&nostr::Kind::Metadata) && e.pubkey.eq(public_key))
-                .max_by_key(|e| e.created_at)
-            {
-                if new_metadata_event.created_at.as_u64() > user_ref.metadata.created_at {
-                    let metadata = nostr::Metadata::from_json(new_metadata_event.content.clone())
-                        .context("metadata cannot be found in kind 0 event content")?;
-                    user_ref.metadata = UserMetadata {
-                        name: if let Some(n) = metadata.name {
-                            n
-                        } else if let Some(n) = metadata.custom.get("displayName") {
-                            // strip quote marks that custom.get() adds
-                            let binding = n.to_string();
-                            let mut chars = binding.chars();
-                            chars.next();
-                            chars.next_back();
-                            chars.as_str().to_string()
-                        } else if let Some(n) = metadata.display_name {
-                            n
-                        } else {
-                            user_ref.metadata.name
-                        },
-                        created_at: new_metadata_event.created_at.as_u64(),
-                    };
-                }
-            };
-
-            if let Some(new_relays_event) = events
-                .iter()
-                .filter(|e| e.kind.eq(&nostr::Kind::RelayList) && e.pubkey.eq(public_key))
-                .max_by_key(|e| e.created_at)
-            {
-                if new_relays_event.created_at.as_u64() > user_ref.relays.created_at {
-                    let new_relay_list = UserRelays {
-                        relays: new_relays_event
-                            .tags
-                            .iter()
-                            .filter(|t| {
-                                t.kind().eq(&nostr::TagKind::SingleLetter(
-                                    SingleLetterTag::lowercase(Alphabet::R),
-                                ))
-                            })
-                            .map(|t| UserRelayRef {
-                                url: t.as_vec()[1].clone(),
-                                read: t.as_vec().len() == 2 || t.as_vec()[2].eq("read"),
-                                write: t.as_vec().len() == 2 || t.as_vec()[2].eq("write"),
-                            })
-                            .collect(),
-                        created_at: new_relays_event.created_at.as_u64(),
-                    };
-                    let new_relays: Vec<String> = new_relay_list
-                        .write()
-                        .iter()
-                        .filter(|r| !relays_searched.iter().any(|or| r.eq(&or)))
-                        .map(std::clone::Clone::clone)
-                        .collect();
-                    user_ref.relays = new_relay_list;
-
-                    if !new_relays.is_empty() {
-                        relays_to_search = new_relays;
-                        continue;
-                    }
-                }
-            };
-
-            // remove any duplicate entries for key before adding it to config
-            let mut cfg = self.config_manager.load().context("failed to load application config to find and remove any old versions of the user's encrypted key")?;
-            cfg.users = cfg
-                .users
-                .clone()
-                .into_iter()
-                .filter(|r| !r.public_key.eq(public_key))
-                .collect();
-            cfg.users.push(user_ref.clone());
-            self.config_manager
-                .save(&cfg)
-                .context("failed to save application configuration with new user details in")?;
-            break;
-        }
-        Ok(user_ref)
-    }
-}
-
-fn unix_timestamp_after_now_plus_secs(timestamp: u64, secs: u64) -> bool {
-    if let Ok(now) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
-        now.as_secs() > (timestamp + secs)
-    } else {
-        true
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use nostr;
-    use test_utils::*;
-
-    use super::*;
-    use crate::{
-        cli_interactor::MockInteractorPrompt,
-        config::{MockConfigManagement, MyConfig, UserRef},
-        key_handling::encryption::MockEncryptDecrypt,
-    };
-
-    #[derive(Default)]
-    pub struct MockUserManager {
-        pub config_manager: MockConfigManagement,
-        pub interactor: MockInteractorPrompt,
-        pub encryptor: MockEncryptDecrypt,
-    }
-
-    mod add {
-        use super::*;
-
-        impl MockUserManager {
-            fn add_return_expected_responses(mut self) -> Self {
-                self.config_manager
-                    .expect_load()
-                    .returning(|| Ok(MyConfig::default()));
-                self.config_manager.expect_save().returning(|_| Ok(()));
-                self.interactor
-                    .expect_input()
-                    .returning(|_| Ok(TEST_KEY_1_NSEC.into()));
-                self.interactor
-                    .expect_password()
-                    .returning(|_| Ok(TEST_PASSWORD.into()));
-                self.encryptor
-                    .expect_encrypt_key()
-                    .returning(|_, _| Ok(TEST_KEY_1_ENCRYPTED.into()));
-                self
-            }
-        }
-
-        fn reuable_user_isnt_prompted(nsec: &str) {
-            let mut m = MockUserManager::default().add_return_expected_responses();
-            m.interactor = MockInteractorPrompt::default();
-            m.interactor.expect_input().never();
-            m.interactor.expect_password().never();
-            let _ = m.add(&Some(nsec.into()), &Some(TEST_PASSWORD.to_string()));
-        }
-
-        fn reuable_config_isnt_modified(nsec: &str) {
-            let mut m = MockUserManager::default();
-            m.config_manager.expect_save().never();
-            let _ = m.add(&Some(nsec.into()), &Some(TEST_PASSWORD.to_string()));
-        }
-
-        mod when_valid_nsec_and_password_is_passed {
-            use super::*;
-
-            #[test]
-            fn user_isnt_prompted() {
-                reuable_user_isnt_prompted(TEST_KEY_1_NSEC);
-            }
-
-            #[test]
-            fn results_in_correct_keys() {
-                let mut m = MockUserManager::default().add_return_expected_responses();
-                m.interactor = MockInteractorPrompt::default();
-                m.interactor.expect_input().never();
-                m.interactor.expect_password().never();
-                let r = m.add(
-                    &Some(TEST_KEY_1_NSEC.into()),
-                    &Some(TEST_PASSWORD.to_string()),
-                );
-                assert!(r.is_ok(), "should result in keys");
-                assert!(
-                    r.is_ok_and(|k| k
-                        .secret_key()
-                        .is_ok_and(|k| k.display_secret().to_string().eq(TEST_KEY_1_SK_HEX))),
-                    "keys should reflect nsec"
-                );
-            }
-        }
-        mod when_invalid_nsec_is_passed_with_password {
-            use super::*;
-
-            #[test]
-            fn user_isnt_prompted() {
-                reuable_user_isnt_prompted(TEST_INVALID_NSEC);
-            }
-
-            #[test]
-            fn config_isnt_modified() {
-                reuable_config_isnt_modified(TEST_INVALID_NSEC);
-            }
-
-            #[test]
-            fn results_in_an_error() {
-                let m = MockUserManager::default();
-                assert!(
-                    m.add(
-                        &Some(TEST_INVALID_NSEC.into()),
-                        &Some(TEST_PASSWORD.to_string())
-                    )
-                    .is_err(),
-                    "should result in an error"
-                );
-            }
-        }
-        mod when_no_nsec_is_passed {
-            use super::*;
-
-            #[test]
-            fn prompt_for_nsec_and_password() {
-                let mut m = MockUserManager::default().add_return_expected_responses();
-
-                m.interactor = MockInteractorPrompt::new();
-                m.interactor
-                    .expect_input()
-                    .once()
-                    .withf(|p| p.prompt.eq("login with nsec (or hex private key)"))
-                    .returning(|_| Ok(TEST_KEY_1_NSEC.into()));
-                m.interactor
-                    .expect_password()
-                    .once()
-                    .withf(|p| p.prompt.eq("encrypt with password"))
-                    .returning(|_| Ok(TEST_KEY_1_NSEC.into()));
-
-                let _ = m.add(&None, &None);
-            }
-
-            #[test]
-            fn results_in_correct_keys() {
-                let m = MockUserManager::default().add_return_expected_responses();
-
-                let r = m.add(&None, &None);
-                assert!(r.is_ok(), "should result in keys");
-                assert!(
-                    r.is_ok_and(|k| k
-                        .secret_key()
-                        .is_ok_and(|k| k.display_secret().to_string().eq(TEST_KEY_1_SK_HEX))),
-                    "keys should reflect nsec"
-                );
-            }
-
-            #[test]
-            fn stores_encrypted_key_in_config() {
-                let mut m = MockUserManager::default().add_return_expected_responses();
-
-                m.config_manager = MockConfigManagement::new();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(MyConfig::default()));
-                m.config_manager
-                    .expect_save()
-                    .withf(|cfg| {
-                        cfg.users.len().eq(&1)
-                            && cfg.users[0].encrypted_key.eq(TEST_KEY_1_ENCRYPTED)
-                    })
-                    .returning(|_| Ok(()));
-
-                let _ = m.add(&None, &None);
-            }
-
-            #[test]
-            fn stored_key_encrypted_with_password() {
-                let mut m = MockUserManager::default().add_return_expected_responses();
-
-                m.encryptor = MockEncryptDecrypt::new();
-                m.encryptor
-                    .expect_encrypt_key()
-                    .once()
-                    .withf(|k, p| {
-                        k.eq(&Keys::from_str(TEST_KEY_1_NSEC).unwrap()) && p.eq(TEST_PASSWORD)
-                    })
-                    .returning(|_, _| Ok(TEST_KEY_1_ENCRYPTED.into()));
-
-                let _ = m.add(&None, &None);
-            }
-
-            mod when_user_key_already_stored {
-                use super::*;
-                use crate::config::UserRef;
-
-                /// key overwritten as password may have changed
-                #[test]
-                fn key_not_saved_as_duplicate_but_encrypted_key_overwritten() {
-                    let mut m = MockUserManager::default().add_return_expected_responses();
-
-                    m.config_manager = MockConfigManagement::default();
-                    m.config_manager.expect_load().returning(|| {
-                        Ok(MyConfig {
-                            users: vec![UserRef::new(
-                                TEST_KEY_1_KEYS.public_key(),
-                                TEST_KEY_2_ENCRYPTED.into(),
-                            )],
-                            ..MyConfig::default()
-                        })
-                    });
-                    m.config_manager
-                        .expect_save()
-                        .withf(|cfg| {
-                            cfg.users.len() == 1
-                                && cfg.users[0].encrypted_key.eq(TEST_KEY_1_ENCRYPTED)
-                        })
-                        .returning(|_| Ok(()));
-
-                    let _ = m.add(&None, &None);
-                }
-            }
-
-            mod when_multiple_users_added {
-                use super::*;
-
-                #[test]
-                fn both_user_keys_are_stored() {
-                    let mut m = MockUserManager::default().add_return_expected_responses();
-
-                    m.config_manager = MockConfigManagement::default();
-                    m.config_manager.expect_load().returning(|| {
-                        Ok(MyConfig {
-                            users: vec![UserRef::new(
-                                TEST_KEY_2_KEYS.public_key(),
-                                TEST_KEY_2_ENCRYPTED.into(),
-                            )],
-                            ..MyConfig::default()
-                        })
-                    });
-                    m.config_manager
-                        .expect_save()
-                        .withf(|cfg| {
-                            cfg.users.len() == 2
-                            // latest user stored at end of array
-                            && cfg.users[1].encrypted_key.eq(TEST_KEY_1_ENCRYPTED)
-                        })
-                        .returning(|_| Ok(()));
-
-                    let _ = m.add(&None, &None);
-                }
-            }
-        }
-    }
-
-    fn now_timestamp() -> u64 {
-        SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .unwrap()
-            .as_secs()
-    }
-    fn roughly_now(timestamp: u64) -> bool {
-        let now = now_timestamp();
-        timestamp < now + 100 && timestamp > now - 100
-    }
-
-    mod get_user {
-        use anyhow::anyhow;
-
-        use super::*;
-        use crate::client::MockConnect;
-
-        fn generate_relaylist_event() -> nostr::Event {
-            nostr::event::EventBuilder::new(
-                nostr::Kind::RelayList,
-                "",
-                [
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://fredswrite1.relay/").unwrap(),
-                        metadata: Some(RelayMetadata::Write),
-                    }),
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://fredsread1.relay/").unwrap(),
-                        metadata: Some(RelayMetadata::Read),
-                    }),
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://fredsreadwrite.relay/").unwrap(),
-                        metadata: None,
-                    }),
-                ],
-            )
-            .to_event(&TEST_KEY_1_KEYS)
-            .unwrap()
-        }
-
-        fn generate_relaylist_event_user_2() -> nostr::Event {
-            nostr::event::EventBuilder::new(
-                nostr::Kind::RelayList,
-                "",
-                [
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://carolswrite1.relay/").unwrap(),
-                        metadata: Some(RelayMetadata::Write),
-                    }),
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://carolsread1.relay/").unwrap(),
-                        metadata: Some(RelayMetadata::Read),
-                    }),
-                    nostr::Tag::from_standardized(nostr::TagStandard::RelayMetadata {
-                        relay_url: nostr::Url::from_str("wss://carolsreadwrite.relay/").unwrap(),
-                        metadata: None,
-                    }),
-                ],
-            )
-            .to_event(&TEST_KEY_2_KEYS)
-            .unwrap()
-        }
-
-        fn fallback_relays() -> Vec<String> {
-            vec!["ws://fallback1".to_string(), "ws://fallback2".to_string()].clone()
-        }
-
-        fn generate_mock_client() -> MockConnect {
-            let mut client = <MockConnect as std::default::Default>::default();
-            client
-                .expect_get_fallback_relays()
-                .return_const(fallback_relays());
-            client
-        }
-
-        fn generate_standard_config() -> MyConfig {
-            MyConfig {
-                users: vec![UserRef {
-                    public_key: TEST_KEY_1_KEYS.public_key(),
-                    encrypted_key: TEST_KEY_1_ENCRYPTED.to_string(),
-                    metadata: UserMetadata {
-                        name: "Fred".to_string(),
-                        created_at: 10,
-                    },
-                    relays: UserRelays {
-                        relays: vec![
-                            UserRelayRef {
-                                url: "ws://existingread".to_string(),
-                                read: true,
-                                write: false,
-                            },
-                            UserRelayRef {
-                                url: "ws://existingreadwrite".to_string(),
-                                read: true,
-                                write: true,
-                            },
-                            UserRelayRef {
-                                url: "ws://existingwrite".to_string(),
-                                read: false,
-                                write: true,
-                            },
-                        ],
-                        created_at: 10,
-                    },
-                    last_checked: now_timestamp() - (60 * 60), // 1h ago
-                }],
-                ..MyConfig::default()
-            }
-            .clone()
-        }
-
-        fn expected_userrelayrefs_write1() -> UserRelayRef {
-            UserRelayRef {
-                url: "wss://fredswrite1.relay/".into(),
-                read: false,
-                write: true,
-            }
-            .clone()
-        }
-
-        fn expected_userrelayrefs_read_write1() -> UserRelayRef {
-            UserRelayRef {
-                url: "wss://fredsreadwrite.relay/".into(),
-                read: true,
-                write: true,
-            }
-            .clone()
-        }
-
-        fn expected_userrelayrefs() -> Vec<UserRelayRef> {
-            vec![
-                expected_userrelayrefs_write1(),
-                UserRelayRef {
-                    url: "wss://fredsread1.relay/".into(),
-                    read: true,
-                    write: false,
-                },
-                expected_userrelayrefs_read_write1(),
-            ]
-        }
-
-        mod when_within_caching_time_window {
-            use super::*;
-
-            #[tokio::test]
-            async fn returns_cached_details_without_checking_relays_or_updaing_config() -> Result<()>
-            {
-                let mut m = MockUserManager::default();
-                let client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                let res = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        24 * 60 * 60, // within 24 hours
-                    )
-                    .await?;
-                assert_eq!(res.metadata.name, "Fred");
-                assert_eq!(res.relays.relays[0].url, "ws://existingread");
-                Ok(())
-            }
-        }
-
-        mod returns_userref_with_latest_details_from_events_on_relays {
-            use super::*;
-
-            #[tokio::test]
-            async fn name() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
-
-                let res = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                assert_eq!(res.metadata.name, "fred");
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn name_ignoring_other_users_events() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client.expect_get_events().returning(|_, _| {
-                    Ok(vec![
-                        generate_test_key_2_metadata_event("carole"),
-                        generate_test_key_1_metadata_event_old("fred"),
-                    ])
-                });
-
-                let res = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                assert_eq!(res.metadata.name, "fred");
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn relays() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client.expect_get_events().returning(|_, _| {
-                    Ok(vec![
-                        generate_test_key_1_metadata_event("fred"),
-                        generate_relaylist_event(),
-                    ])
-                });
-
-                let res = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn relays_ignoring_other_users_events() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client.expect_get_events().returning(|_, _| {
-                    Ok(vec![
-                        make_event_old_or_change_user(
-                            generate_relaylist_event(),
-                            &TEST_KEY_1_KEYS,
-                            10000,
-                        ),
-                        generate_relaylist_event_user_2(),
-                    ])
-                });
-
-                let res = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
-                Ok(())
-            }
-        }
-
-        mod saves_updates_to_config {
-            use super::*;
-
-            #[tokio::test]
-            async fn saves_name_to_config() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| cfg.users[0].metadata.name.eq("fred"))
-                    .returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn updates_metadata_created_at() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| roughly_now(cfg.users[0].metadata.created_at))
-                    .returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn saves_relays_to_config() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| expected_userrelayrefs().eq(&cfg.users[0].relays.relays))
-                    .returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn updates_relays_created_at() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| roughly_now(cfg.users[0].relays.created_at))
-                    .returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn when_no_changes_updates_last_updated() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
-                    .returning(|_| Ok(()));
-                client.expect_get_events().returning(|_, _| Ok(vec![]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn when_changes_updates_last_updated() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager
-                    .expect_save()
-                    .once()
-                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
-                    .returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-        }
-
-        mod fetches_from_correct_relays {
-            use super::*;
-            #[tokio::test]
-            async fn when_userref_write_relays_present_fetches_only_from_them() -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager
-                    .expect_load()
-                    .returning(|| Ok(generate_standard_config()));
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .once()
-                    .withf(move |relays, _filters| {
-                        vec![
-                            "ws://existingreadwrite".to_string(),
-                            "ws://existingwrite".to_string(),
-                        ]
-                        .eq(relays)
-                    })
-                    .returning(|_, _| Ok(vec![]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            #[tokio::test]
-            async fn when_userref_write_relays_not_present_fetches_from_fallback_relays()
-            -> Result<()> {
-                let mut m = MockUserManager::default();
-                let mut client = generate_mock_client();
-                m.config_manager.expect_load().returning(|| {
-                    Ok(MyConfig {
-                        users: vec![UserRef {
-                            relays: UserRelays {
-                                relays: vec![],
-                                created_at: 0,
-                            },
-                            ..generate_standard_config().users[0].clone()
-                        }],
-                        ..generate_standard_config()
-                    })
-                });
-                m.config_manager.expect_save().returning(|_| Ok(()));
-                client
-                    .expect_get_events()
-                    .once()
-                    .withf(move |relays, _filters| fallback_relays().eq(relays))
-                    .returning(|_, _| Ok(vec![]));
-
-                let _ = m
-                    .get_user(
-                        &client,
-                        &TEST_KEY_1_KEYS.public_key(),
-                        5 * 60, // 5 mins ago
-                    )
-                    .await?;
-                Ok(())
-            }
-
-            mod fetches_from_new_relays_discovered_in_incoming_relay_list {
-                use super::*;
-
-                #[tokio::test]
-                async fn when_all_relays_in_list_are_new_finds_name() -> Result<()> {
-                    let mut m = MockUserManager::default();
-                    let mut client = generate_mock_client();
-                    m.config_manager.expect_load().returning(|| {
-                        Ok(MyConfig {
-                            users: vec![UserRef {
-                                relays: UserRelays {
-                                    relays: vec![],
-                                    created_at: 0,
-                                },
-                                ..generate_standard_config().users[0].clone()
-                            }],
-                            ..generate_standard_config()
-                        })
-                    });
-                    m.config_manager.expect_save().returning(|_| Ok(()));
-                    client
-                        .expect_get_events()
-                        .times(2)
-                        .withf(move |relays, _filters| {
-                            fallback_relays().eq(relays)
-                                || UserRelays {
-                                    relays: expected_userrelayrefs(),
-                                    created_at: 0,
-                                }
-                                .write()
-                                .eq(relays)
-                        })
-                        .returning(|relays, _| {
-                            if fallback_relays().eq(&relays) {
-                                Ok(vec![generate_relaylist_event()])
-                            } else if (UserRelays {
-                                relays: expected_userrelayrefs(),
-                                created_at: 0,
-                            })
-                            .write()
-                            .eq(&relays)
-                            {
-                                Ok(vec![generate_test_key_1_metadata_event("fred")])
-                            } else {
-                                Ok(vec![])
-                            }
-                        });
-
-                    let res = m
-                        .get_user(
-                            &client,
-                            &TEST_KEY_1_KEYS.public_key(),
-                            5 * 60, // 5 mins ago
-                        )
-                        .await?;
-                    assert_eq!(res.metadata.name, "fred");
-                    Ok(())
-                }
-
-                #[tokio::test]
-                async fn only_fetches_from_newly_added_relays() -> Result<()> {
-                    let mut m = MockUserManager::default();
-                    let mut client = generate_mock_client();
-                    m.config_manager.expect_load().returning(|| {
-                        Ok(MyConfig {
-                            users: vec![UserRef {
-                                relays: UserRelays {
-                                    relays: vec![expected_userrelayrefs_write1()],
-                                    created_at: 0,
-                                },
-                                ..generate_standard_config().users[0].clone()
-                            }],
-                            ..generate_standard_config()
-                        })
-                    });
-                    m.config_manager.expect_save().returning(|_| Ok(()));
-                    client
-                        .expect_get_events()
-                        .times(2)
-                        .withf(move |relays, _filters| {
-                            vec![expected_userrelayrefs_write1().url].eq(relays)
-                                || vec![expected_userrelayrefs_read_write1().url].eq(relays)
-                        })
-                        .returning(|relays, _| {
-                            if vec![expected_userrelayrefs_write1().url].eq(&relays) {
-                                Ok(vec![generate_relaylist_event()])
-                            } else if vec![expected_userrelayrefs_read_write1().url].eq(&relays) {
-                                Ok(vec![generate_test_key_1_metadata_event("fred")])
-                            } else {
-                                Ok(vec![])
-                            }
-                        });
-
-                    let res = m
-                        .get_user(
-                            &client,
-                            &TEST_KEY_1_KEYS.public_key(),
-                            5 * 60, // 5 mins ago
-                        )
-                        .await?;
-                    assert_eq!(res.metadata.name, "fred");
-                    Ok(())
-                }
-            }
-        }
-
-        #[tokio::test]
-        async fn when_failed_to_fetch_events_returns_cached_details() -> Result<()> {
-            let mut m = MockUserManager::default();
-            let mut client = generate_mock_client();
-            m.config_manager
-                .expect_load()
-                .returning(|| Ok(generate_standard_config()));
-            client
-                .expect_get_events()
-                .returning(|_, _| Err(anyhow!("test error")));
-
-            let res = m
-                .get_user(
-                    &client,
-                    &TEST_KEY_1_KEYS.public_key(),
-                    5 * 60, // 10 mins ago
-                )
-                .await?;
-            assert_eq!(res.metadata.name, "Fred");
-            Ok(())
-        }
-    }
-}
diff --git a/src/login.rs b/src/login.rs
index 4cdf3c1..58d1b87 100644
--- a/src/login.rs
+++ b/src/login.rs
@@ -2,130 +2,407 @@ use std::str::FromStr;
 
 use anyhow::{bail, Context, Result};
 use nostr::PublicKey;
-use zeroize::Zeroize;
+use nostr_database::Order;
+use nostr_sdk::{Alphabet, FromBech32, JsonUtil, Kind, NostrDatabase, SingleLetterTag, ToBech32};
+use nostr_sqlite::SQLiteDatabase;
 
 #[cfg(not(test))]
 use crate::client::Client;
 #[cfg(test)]
 use crate::client::MockConnect;
 use crate::{
-    cli_interactor::{Interactor, InteractorPrompt, PromptPasswordParms},
-    config::{ConfigManagement, ConfigManager, UserRef},
-    key_handling::{
-        encryption::{EncryptDecrypt, Encryptor},
-        users::{UserManagement, UserManager},
+    cli_interactor::{
+        Interactor, InteractorPrompt, PromptConfirmParms, PromptInputParms, PromptPasswordParms,
     },
+    client::Connect,
+    config::{get_dirs, UserMetadata, UserRef, UserRelayRef, UserRelays},
+    git::{Repo, RepoActions},
+    key_handling::encryption::{decrypt_key, encrypt_key},
 };
 
 /// handles the encrpytion and storage of key material
 pub async fn launch(
+    git_repo: &Repo,
     nsec: &Option<String>,
     password: &Option<String>,
     #[cfg(test)] client: Option<&MockConnect>,
     #[cfg(not(test))] client: Option<&Client>,
+    change_user: bool,
 ) -> Result<(nostr::Keys, UserRef)> {
-    // if nsec parameter
-    let key = if let Some(nsec_unwrapped) = nsec {
-        // get key or fail without prompts
-        let key = nostr::Keys::from_str(nsec_unwrapped).context("invalid nsec parameter")?;
-
-        // if password, add user to enable password login in future
-        if password.is_some() {
-            UserManager::default()
-                .add(nsec, password)
-                .context("could not store identity")?;
-        } else {
-            UserManager::default().add_user_to_config(key.public_key(), None, false)?;
+    if let Ok(keys) = match get_keys_without_prompts(git_repo, nsec, password, change_user) {
+        Ok(keys) => Ok(keys),
+        Err(error) => {
+            if error
+                .to_string()
+                .eq("git config item nostr.nsec is an ncryptsec")
+            {
+                println!(
+                    "login as {}",
+                    if let Ok(public_key) = PublicKey::from_bech32(
+                        get_config_item(git_repo, "nostr.npub")
+                            .unwrap_or("unknown ncryptsec".to_string()),
+                    ) {
+                        if let Ok(user_ref) = get_user_details(&public_key, client).await {
+                            user_ref.metadata.name
+                        } else {
+                            "unknown ncryptsec".to_string()
+                        }
+                    } else {
+                        "unknown ncryptsec".to_string()
+                    }
+                );
+                loop {
+                    // prompt for password
+                    let password = Interactor::default()
+                        .password(PromptPasswordParms::default().with_prompt("password"))
+                        .context("failed to get password input from interactor.password")?;
+                    if let Ok(keys) = get_keys_with_password(git_repo, &password) {
+                        break Ok(keys);
+                    }
+                    println!("incorrect password");
+                }
+            } else {
+                if nsec.is_some() {
+                    bail!(error);
+                }
+                Err(error)
+            }
         }
-        key
+    } {
+        // get user ref
+        let user_ref = get_user_details(&keys.public_key(), client).await?;
+        print_logged_in_as(&user_ref, client.is_none())?;
+        Ok((keys, user_ref))
     } else {
-        let cfg = ConfigManager
-            .load()
-            .context("failed to load application config")?;
-        // if encrypted nsec present
-        if cfg.users.last().is_some() && !cfg.users.last().unwrap().encrypted_key.is_empty() {
-            // unfortunately this line is unstable in rust:
-            // if let Some(user) = cfg.users.last()  && !user.encrypted_key.is_empty() {
-            let user = cfg.users.last().unwrap();
-            let mut pass = if let Some(p) = password.clone() {
-                p
-            } else {
-                println!("login as {}", &user.metadata.name);
-                Interactor::default()
-                    .password(PromptPasswordParms::default().with_prompt("password"))
-                    .context("failed to get password input from interactor.password")?
-            };
-
-            let key_result = Encryptor
-                .decrypt_key(&user.encrypted_key, pass.as_str())
-                .context("failed to decrypt key with provided password");
-            pass.zeroize();
-
-            key_result.context(format!("failed to log in as {}", &user.metadata.name))?
+        fresh_login(git_repo, client, change_user).await
+    }
+}
+
+fn print_logged_in_as(user_ref: &UserRef, offline_mode: bool) -> Result<()> {
+    if !offline_mode && user_ref.metadata.created_at.eq(&0) {
+        println!("cannot find your account metadata (name, etc) on relays");
+    } else if !offline_mode && user_ref.metadata.name.eq(&user_ref.public_key.to_bech32()?) {
+        println!("cannot extract account name from account metadata...");
+    } else if !offline_mode && user_ref.relays.created_at.eq(&0) {
+        println!(
+            "cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience."
+        );
+    }
+    println!("logged in as {}", user_ref.metadata.name);
+    Ok(())
+}
+
+fn get_keys_without_prompts(
+    git_repo: &Repo,
+    nsec: &Option<String>,
+    password: &Option<String>,
+    save_local: bool,
+) -> Result<nostr::Keys> {
+    if let Some(nsec) = nsec {
+        get_keys_from_nsec(git_repo, nsec, password, save_local)
+    } else if let Some(password) = password {
+        get_keys_with_password(git_repo, password)
+    } else if !save_local {
+        get_keys_with_git_config_nsec_without_prompts(git_repo)
+    } else {
+        bail!("user wants prompts to specify new keys")
+    }
+}
+
+fn get_keys_from_nsec(
+    git_repo: &Repo,
+    nsec: &String,
+    password: &Option<String>,
+    save_local: bool,
+) -> Result<nostr::Keys> {
+    #[allow(unused_assignments)]
+    let mut s = String::new();
+    let keys = if nsec.contains("ncryptsec") {
+        s = nsec.to_string();
+        decrypt_key(
+            nsec,
+            password
+                .clone()
+                .context("password must be supplied when using ncryptsec as nsec parameter")?
+                .as_str(),
+        )
+        .context("failed to decrypt key with provided password")
+        .context("failed to decrypt ncryptsec supplied as nsec with password")?
+    } else {
+        s = nsec.to_string();
+        nostr::Keys::from_str(nsec).context("invalid nsec parameter")?
+    };
+    if save_local {
+        if let Some(password) = password {
+            s = encrypt_key(&keys, password)?;
         }
-        // no encrypted nsec present
-        else {
-            // no nsec but password supplied
-            if password.is_some() {
-                bail!("no nsec available to decrypt with specified password");
+        git_repo
+            .save_git_config_item("nostr.nsec", &s, false)
+            .context("failed to save encrypted nsec in local git config nostr.nsec")?;
+        git_repo.save_git_config_item("nostr.npub", &keys.public_key().to_bech32()?, false)?;
+    }
+    Ok(keys)
+}
+
+fn get_keys_with_password(git_repo: &Repo, password: &str) -> Result<nostr::Keys> {
+    decrypt_key(
+        &git_repo
+            .get_git_config_item("nostr.nsec", false)
+            .context("failed get git config")?
+            .context("git config item nostr.nsec doesn't exist so cannot decrypt it")?,
+        password,
+    )
+    .context("failed to decrypt stored nsec key with provided password")
+}
+
+fn get_keys_with_git_config_nsec_without_prompts(git_repo: &Repo) -> Result<nostr::Keys> {
+    let nsec = &git_repo
+        .get_git_config_item("nostr.nsec", false)
+        .context("failed get git config")?
+        .context("git config item nostr.nsec doesn't exist")?;
+    if nsec.contains("ncryptsec") {
+        bail!("git config item nostr.nsec is an ncryptsec")
+    }
+    nostr::Keys::from_str(nsec).context("invalid nsec parameter")
+}
+
+async fn fresh_login(
+    git_repo: &Repo,
+    #[cfg(test)] client: Option<&MockConnect>,
+    #[cfg(not(test))] client: Option<&Client>,
+    always_save: bool,
+) -> Result<(nostr::Keys, UserRef)> {
+    // prompt for nsec
+    let mut prompt = "login with nsec";
+    let keys = loop {
+        match nostr::Keys::from_str(
+            &Interactor::default()
+                .input(PromptInputParms::default().with_prompt(prompt))
+                .context("failed to get nsec input from interactor")?,
+        ) {
+            Ok(key) => {
+                break key;
+            }
+            Err(_) => {
+                prompt = "invalid nsec. try again with nsec (or hex private key)";
             }
-            // otherwise add new user with nsec and password prompts
-            UserManager::default()
-                .add(nsec, password)
-                .context("failed to add user")?
         }
     };
+    // lookup profile
+    // save keys
+    if let Err(error) = save_keys(git_repo, &keys, always_save) {
+        println!("{error}");
+    }
+    let user_ref = get_user_details(&keys.public_key(), client).await?;
+    print_logged_in_as(&user_ref, client.is_none())?;
+    Ok((keys, user_ref))
+}
+
+fn save_keys(git_repo: &Repo, keys: &nostr::Keys, always_save: bool) -> Result<()> {
+    let store = always_save
+        || Interactor::default()
+            .confirm(PromptConfirmParms::default().with_prompt("save login details?"))?;
+
+    let global = !Interactor::default().confirm(
+        PromptConfirmParms::default()
+            .with_prompt("just for this repository?")
+            .with_default(false),
+    )?;
+
+    let encrypt = Interactor::default().confirm(
+        PromptConfirmParms::default()
+            .with_prompt("require password?")
+            .with_default(false),
+    )?;
 
-    // get user details
-    let user_ref = if let Some(client) = client {
-        get_user_details(&key.public_key(), client).await?
+    if store {
+        let npub = keys.public_key().to_bech32()?;
+        let nsec_string = if encrypt {
+            let password = Interactor::default()
+                .password(
+                    PromptPasswordParms::default()
+                        .with_prompt("encrypt with password")
+                        .with_confirm(),
+                )
+                .context("failed to get password input from interactor.password")?;
+            encrypt_key(keys, &password)?
+        } else {
+            keys.secret_key()?.to_bech32()?
+        };
+
+        if let Err(error) = git_repo.save_git_config_item("nostr.nsec", &nsec_string, global) {
+            if global {
+                println!("failed to edit global git config instead");
+                if Interactor::default().confirm(
+                    PromptConfirmParms::default()
+                        .with_prompt("save in repository git config?")
+                        .with_default(true),
+                )? {
+                    git_repo.save_git_config_item("nostr.nsec", &nsec_string, false)?;
+                    git_repo.save_git_config_item("nostr.npub", &npub, false)?;
+                }
+            } else {
+                bail!(error)
+            }
+        } else {
+            git_repo.save_git_config_item("nostr.npub", &npub, global)?;
+        };
+    };
+    Ok(())
+}
+
+fn get_config_item(git_repo: &Repo, name: &str) -> Result<String> {
+    git_repo
+        .get_git_config_item(name, false)
+        .context("failed get git config")?
+        .context(format!("git config item {name} doesn't exist"))
+}
+
+fn extract_user_metadata(
+    public_key: &nostr::PublicKey,
+    events: &[nostr::Event],
+) -> Result<UserMetadata> {
+    let event = events
+        .iter()
+        .filter(|e| e.kind.eq(&nostr::Kind::Metadata) && e.pubkey.eq(public_key))
+        .max_by_key(|e| e.created_at);
+
+    let metadata: Option<nostr::Metadata> = if let Some(event) = event {
+        Some(
+            nostr::Metadata::from_json(event.content.clone())
+                .context("metadata cannot be found in kind 0 event content")?,
+        )
     } else {
-        // this will get user details with name as npub
-        UserManager::default()
-            .get_user_from_cache(&key.public_key())?
-            .clone()
+        None
     };
 
-    // print logged in
-    println!("logged in as {}", user_ref.metadata.name);
+    Ok(UserMetadata {
+        name: if let Some(metadata) = metadata {
+            if let Some(n) = metadata.name {
+                n
+            } else if let Some(n) = metadata.custom.get("displayName") {
+                // strip quote marks that custom.get() adds
+                let binding = n.to_string();
+                let mut chars = binding.chars();
+                chars.next();
+                chars.next_back();
+                chars.as_str().to_string()
+            } else if let Some(n) = metadata.display_name {
+                n
+            } else {
+                public_key.to_bech32()?
+            }
+        } else {
+            public_key.to_bech32()?
+        },
+        created_at: if let Some(event) = event {
+            event.created_at.as_u64()
+        } else {
+            0
+        },
+    })
+}
 
-    Ok((key, user_ref.clone()))
+fn extract_user_relays(public_key: &nostr::PublicKey, events: &[nostr::Event]) -> UserRelays {
+    let event = events
+        .iter()
+        .filter(|e| e.kind.eq(&nostr::Kind::RelayList) && e.pubkey.eq(public_key))
+        .max_by_key(|e| e.created_at);
+
+    UserRelays {
+        relays: if let Some(event) = event {
+            event
+                .tags
+                .iter()
+                .filter(|t| {
+                    t.kind()
+                        .eq(&nostr::TagKind::SingleLetter(SingleLetterTag::lowercase(
+                            Alphabet::R,
+                        )))
+                })
+                .map(|t| UserRelayRef {
+                    url: t.as_vec()[1].clone(),
+                    read: t.as_vec().len() == 2 || t.as_vec()[2].eq("read"),
+                    write: t.as_vec().len() == 2 || t.as_vec()[2].eq("write"),
+                })
+                .collect()
+        } else {
+            vec![]
+        },
+        created_at: if let Some(event) = event {
+            event.created_at.as_u64()
+        } else {
+            0
+        },
+    }
 }
 
 async fn get_user_details(
     public_key: &PublicKey,
-    #[cfg(test)] client: &crate::client::MockConnect,
-    #[cfg(not(test))] client: &Client,
+    #[cfg(test)] client: Option<&crate::client::MockConnect>,
+    #[cfg(not(test))] client: Option<&Client>,
 ) -> Result<UserRef> {
-    let term = console::Term::stdout();
-    term.write_line("searching for profile and relay updates...")?;
-    let user_manager = UserManager::default();
-    let user_ref = user_manager
-        .get_user(
-            client,
-            public_key,
-            // use cache for 3 minutes
-            3 * 60,
-        )
-        .await?;
-    term.clear_last_lines(1)?;
-    if user_ref.metadata.created_at.eq(&0) {
-        println!("cannot find your account metadata (name, etc) on relays",);
-        // TODO use secondary fallback list of relays.
-        // TODO better reporting of what relays were checked and what the user
-        //      here is a starter:
-        //      cannot find account details on relays:
-        //       - purplepages.xyz
-        //       - fallbackrelay1
-        //       - ...
-        //      would you like to:
-        //        [-] proceed anyway
-        //         - add custom fallback relays
-    } else if user_ref.relays.created_at.eq(&0) {
-        println!(
-            "cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience."
-        );
-        // TODO better guidance on how to do this
+    if client.is_some() {
+        println!("searching for profile and relay updates...");
     }
+    let database = SQLiteDatabase::open(get_dirs()?.config_dir().join("cache.sqlite")).await?;
+    let mut events: Vec<nostr::Event> = vec![];
+    let filters = vec![
+        nostr::Filter::default()
+            .author(*public_key)
+            .kind(Kind::Metadata),
+        nostr::Filter::default()
+            .author(*public_key)
+            .kind(Kind::RelayList),
+    ];
+    if let Ok(cached_events) = database.query(filters.clone(), Order::Asc).await {
+        for event in cached_events {
+            events.push(event);
+        }
+    }
+    let mut relays_to_search = if let Some(client) = client {
+        client.get_fallback_relays().clone()
+    } else {
+        vec![]
+    };
+    let mut relays_searched = vec![];
+    let user_ref = loop {
+        if let Some(client) = client {
+            for event in client
+                .get_events(relays_to_search.clone(), filters.clone())
+                .await
+                .unwrap_or(vec![])
+            {
+                let _ = database.save_event(&event).await;
+                events.push(event);
+            }
+        }
+
+        #[allow(clippy::clone_on_copy)]
+        let user_ref = UserRef {
+            public_key: public_key.clone(),
+            metadata: extract_user_metadata(public_key, &events)?,
+            relays: extract_user_relays(public_key, &events),
+        };
+
+        if client.is_none() {
+            break user_ref;
+        }
+        for r in &relays_to_search {
+            relays_searched.push(r.clone());
+        }
+
+        relays_to_search = user_ref
+            .relays
+            .write()
+            .iter()
+            .filter(|r| !relays_searched.iter().any(|or| r.eq(&or)))
+            .map(std::clone::Clone::clone)
+            .collect();
+        if !relays_to_search.is_empty() {
+            continue;
+        }
+        break user_ref;
+    };
     Ok(user_ref)
 }
diff --git a/src/sub_commands/init.rs b/src/sub_commands/init.rs
index edaca15..4d1bdfb 100644
--- a/src/sub_commands/init.rs
+++ b/src/sub_commands/init.rs
@@ -59,7 +59,14 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     #[cfg(test)]
     let mut client = <MockConnect as std::default::Default>::default();
 
-    let (keys, user_ref) = login::launch(&cli_args.nsec, &cli_args.password, Some(&client)).await?;
+    let (keys, user_ref) = login::launch(
+        &git_repo,
+        &cli_args.nsec,
+        &cli_args.password,
+        Some(&client),
+        false,
+    )
+    .await?;
 
     client.set_keys(&keys).await;
 
diff --git a/src/sub_commands/login.rs b/src/sub_commands/login.rs
index 43ce480..e71d431 100644
--- a/src/sub_commands/login.rs
+++ b/src/sub_commands/login.rs
@@ -1,11 +1,11 @@
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap;
 
 #[cfg(not(test))]
 use crate::client::Client;
 #[cfg(test)]
 use crate::client::MockConnect;
-use crate::{client::Connect, login, Cli};
+use crate::{client::Connect, git::Repo, login, Cli};
 
 #[derive(clap::Args)]
 pub struct SubCommandArgs {
@@ -15,8 +15,9 @@ pub struct SubCommandArgs {
 }
 
 pub async fn launch(args: &Cli, command_args: &SubCommandArgs) -> Result<()> {
+    let git_repo = Repo::discover().context("cannot find a git repository")?;
     if command_args.offline {
-        login::launch(&args.nsec, &args.password, None).await?;
+        login::launch(&git_repo, &args.nsec, &args.password, None, true).await?;
         Ok(())
     } else {
         #[cfg(not(test))]
@@ -24,7 +25,7 @@ pub async fn launch(args: &Cli, command_args: &SubCommandArgs) -> Result<()> {
         #[cfg(test)]
         let client = <MockConnect as std::default::Default>::default();
 
-        login::launch(&args.nsec, &args.password, Some(&client)).await?;
+        login::launch(&git_repo, &args.nsec, &args.password, Some(&client), true).await?;
         client.disconnect().await?;
         Ok(())
     }
diff --git a/src/sub_commands/push.rs b/src/sub_commands/push.rs
index fefe102..ade2ff8 100644
--- a/src/sub_commands/push.rs
+++ b/src/sub_commands/push.rs
@@ -148,7 +148,14 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         ahead.len()
     );
 
-    let (keys, user_ref) = login::launch(&cli_args.nsec, &cli_args.password, Some(&client)).await?;
+    let (keys, user_ref) = login::launch(
+        &git_repo,
+        &cli_args.nsec,
+        &cli_args.password,
+        Some(&client),
+        false,
+    )
+    .await?;
 
     client.set_keys(&keys).await;
 
diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index c8d900c..8971d8b 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -178,7 +178,14 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     } else {
         None
     };
-    let (keys, user_ref) = login::launch(&cli_args.nsec, &cli_args.password, Some(&client)).await?;
+    let (keys, user_ref) = login::launch(
+        &git_repo,
+        &cli_args.nsec,
+        &cli_args.password,
+        Some(&client),
+        false,
+    )
+    .await?;
 
     client.set_keys(&keys).await;
 
diff --git a/test_utils/src/lib.rs b/test_utils/src/lib.rs
index ff1f41b..bf6c37b 100644
--- a/test_utils/src/lib.rs
+++ b/test_utils/src/lib.rs
@@ -952,17 +952,20 @@ where
 }
 
 fn backup_existing_config() -> Result<()> {
-    let config_path = get_dirs().config_dir().join("config.json");
-    let backup_config_path = get_dirs().config_dir().join("config-backup.json");
+    let config_path = get_dirs().config_dir().join("cache.sqlite");
+    let backup_config_path = get_dirs().config_dir().join("cache-backup.sqlite");
+    if !backup_config_path.exists() {
+        std::fs::rename(&config_path, backup_config_path)?;
+    }
     if config_path.exists() {
-        std::fs::rename(config_path, backup_config_path)?;
+        std::fs::remove_file(&config_path)?;
     }
     Ok(())
 }
 
 fn restore_config_backup() -> Result<()> {
-    let config_path = get_dirs().config_dir().join("config.json");
-    let backup_config_path = get_dirs().config_dir().join("config-backup.json");
+    let config_path = get_dirs().config_dir().join("cache.sqlite");
+    let backup_config_path = get_dirs().config_dir().join("cache-backup.sqlite");
     if config_path.exists() {
         std::fs::remove_file(&config_path)?;
     }
diff --git a/tests/init.rs b/tests/init.rs
index 40b5a45..4e4b04f 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -4,7 +4,6 @@ use test_utils::{git::GitTestRepo, *};
 
 fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
     p.expect("searching for profile and relay updates...\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")?;
diff --git a/tests/login.rs b/tests/login.rs
index 371a7e7..aaadf00 100644
--- a/tests/login.rs
+++ b/tests/login.rs
@@ -2,17 +2,24 @@ use anyhow::Result;
 use serial_test::serial;
 use test_utils::*;
 
-static EXPECTED_NSEC_PROMPT: &str = "login with nsec (or hex private key)";
+static EXPECTED_NSEC_PROMPT: &str = "login with nsec";
+static EXPECTED_LOCAL_REPOSITORY_PROMPT: &str = "just for this repository?";
+static EXPECTED_REQUIRE_PASSWORD_PROMPT: &str = "require password?";
 static EXPECTED_SET_PASSWORD_PROMPT: &str = "encrypt with password";
 static EXPECTED_SET_PASSWORD_CONFIRM_PROMPT: &str = "confirm password";
-static EXPECTED_PASSWORD_PROMPT: &str = "password";
 
-fn standard_login() -> Result<CliTester> {
+fn standard_first_time_login_encrypting_nsec() -> Result<CliTester> {
     let mut p = CliTester::new(["login", "--offline"]);
 
     p.expect_input_eventually(EXPECTED_NSEC_PROMPT)?
         .succeeds_with(TEST_KEY_1_NSEC)?;
 
+    p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+        .succeeds_with(Some(true))?;
+
+    p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+        .succeeds_with(Some(true))?;
+
     p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
         .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
         .succeeds_with(TEST_PASSWORD)?;
@@ -56,16 +63,14 @@ mod with_relays {
                             p.expect_input(EXPECTED_NSEC_PROMPT)?
                                 .succeeds_with(TEST_KEY_1_NSEC)?;
 
-                            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                                .succeeds_with(TEST_PASSWORD)?;
+                            p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                                .succeeds_with(Some(true))?;
+
+                            p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                                .succeeds_with(Some(false))?;
 
                             p.expect("searching for profile and relay updates...\r\n")?;
-                            p.expect("\r")?;
 
-                            // p.expect_end_with(
-                            //     format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str(),
-                            // )?;
                             p.expect_end_with("logged in as fred\r\n")?;
                             for p in [51, 52] {
                                 shutdown_relay(8000 + p)?;
@@ -97,12 +102,15 @@ mod with_relays {
                             p.expect_input(EXPECTED_NSEC_PROMPT)?
                                 .succeeds_with(TEST_KEY_1_NSEC)?;
 
-                            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                                .succeeds_with(TEST_PASSWORD)?;
+                            p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                                .succeeds_with(Some(true))?;
+
+                            p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                                .succeeds_with(Some(false))?;
 
                             p.expect("searching for profile and relay updates...\r\n")?;
-                            p.expect("\r")?;
+
+                            p.expect("cannot extract account name from account metadata...\r\n")?;
 
                             p.expect_end_with(
                                 format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str(),
@@ -220,19 +228,6 @@ mod with_relays {
                     #[serial]
                     async fn displays_npub_when_metadata_contains_no_name_displayname_or_display_name()
                     -> Result<()> {
-                        println!(
-                            "displayName: {}",
-                            nostr::Metadata::new()
-                                .custom_field("displayName", "fred")
-                                .custom
-                                .get("displayName")
-                                .unwrap()
-                        );
-                        println!(
-                            "name: {}",
-                            nostr::Metadata::new().name("fred").name.unwrap()
-                        );
-
                         run_test_displays_fallback_to_npub(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
@@ -240,7 +235,7 @@ mod with_relays {
                                     &subscription_id,
                                     &vec![
                                         nostr::event::EventBuilder::metadata(
-                                            &nostr::Metadata::new(),
+                                            &nostr::Metadata::new().about("other info in metadata"),
                                         )
                                         .to_event(&TEST_KEY_1_KEYS)
                                         .unwrap(),
@@ -419,7 +414,6 @@ mod with_relays {
                                 let mut p = CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC]);
 
                                 p.expect("searching for profile and relay updates...\r\n")?;
-                                p.expect("\r")?;
 
                                 p.expect_end_with("logged in as fred\r\n")?;
                                 for p in [51, 52] {
@@ -482,7 +476,6 @@ mod with_relays {
                                 let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
 
                                 p.expect("searching for profile and relay updates...\r\n")?;
-                                p.expect("\r")?;
 
                                 p.expect_end_with("logged in as fred\r\n")?;
                                 for p in [51, 52] {
@@ -541,7 +534,6 @@ mod with_relays {
                                 ]);
 
                                 p.expect("searching for profile and relay updates...\r\n")?;
-                                p.expect("\r")?;
 
                                 p.expect_end_with("logged in as fred\r\n")?;
                                 for p in [51, 52] {
@@ -585,12 +577,14 @@ mod with_relays {
                             p.expect_input(EXPECTED_NSEC_PROMPT)?
                                 .succeeds_with(TEST_KEY_1_NSEC)?;
 
-                            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                                .succeeds_with(TEST_PASSWORD)?;
+                            p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                                .succeeds_with(Some(true))?;
+
+                            p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                                .succeeds_with(Some(false))?;
 
                             p.expect("searching for profile and relay updates...\r\n")?;
-                            p.expect("\r")?;
+
                             p.expect(
                                 "cannot find your account metadata (name, etc) on relays\r\n",
                             )?;
@@ -649,12 +643,14 @@ mod with_relays {
                             p.expect_input(EXPECTED_NSEC_PROMPT)?
                                 .succeeds_with(TEST_KEY_1_NSEC)?;
 
-                            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                                .succeeds_with(TEST_PASSWORD)?;
+                            p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                                .succeeds_with(Some(true))?;
+
+                            p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                                .succeeds_with(Some(false))?;
 
                             p.expect("searching for profile and relay updates...\r\n")?;
-                            p.expect("\r")?;
+
                             p.expect("cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience.\r\n")?;
 
                             p.expect_end_with("logged in as fred\r\n")?;
@@ -677,11 +673,6 @@ mod with_relays {
         mod when_second_time_login_and_details_already_fetched {
             use super::*;
 
-            // TODO: the following two tests would require a fake config file or
-            // fake time
-            //  - uses_relays_from_user_relay_list
-            //  - dislays_correct_name - when_local_metadata_is_the_most_recent
-
             mod uses_cache {
                 use super::*;
 
@@ -730,7 +721,6 @@ mod with_relays {
                             let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
 
                             p.expect("searching for profile and relay updates...\r\n")?;
-                            p.expect("\r")?;
 
                             p.expect_end_eventually_with("logged in as fred\r\n")?;
 
@@ -770,12 +760,13 @@ mod with_relays {
                         p.expect_input(EXPECTED_NSEC_PROMPT)?
                             .succeeds_with(TEST_KEY_1_NSEC)?;
 
-                        p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                            .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                            .succeeds_with(TEST_PASSWORD)?;
+                        p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                            .succeeds_with(Some(true))?;
+
+                        p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                            .succeeds_with(Some(false))?;
 
                         p.expect("searching for profile and relay updates...\r\n")?;
-                        p.expect("\r")?;
 
                         p.expect_end_with("logged in as fred\r\n")?;
                         for p in [51, 52, 53, 55] {
@@ -842,7 +833,7 @@ mod with_offline_flag {
         #[serial]
         fn prompts_for_nsec_and_password() -> Result<()> {
             before()?;
-            standard_login()?;
+            standard_first_time_login_encrypting_nsec()?;
             after()
         }
 
@@ -855,6 +846,12 @@ mod with_offline_flag {
                 p.expect_input(EXPECTED_NSEC_PROMPT)?
                     .succeeds_with(TEST_KEY_1_NSEC)?;
 
+                p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
+                p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
                 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
                     .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
                     .succeeds_with(TEST_PASSWORD)?;
@@ -872,6 +869,12 @@ mod with_offline_flag {
                 p.expect_input(EXPECTED_NSEC_PROMPT)?
                     .succeeds_with(TEST_KEY_1_SK_HEX)?;
 
+                p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
+                p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
                 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
                     .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
                     .succeeds_with(TEST_PASSWORD)?;
@@ -904,6 +907,12 @@ mod with_offline_flag {
                     p.expect_input(invalid_nsec_response)?
                         .succeeds_with(TEST_KEY_1_NSEC)?;
 
+                    p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                        .succeeds_with(Some(true))?;
+
+                    p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                        .succeeds_with(Some(true))?;
+
                     p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
                         .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
                         .succeeds_with(TEST_PASSWORD)?;
@@ -914,53 +923,6 @@ mod with_offline_flag {
         }
     }
 
-    mod when_second_time_login {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn prints_login_as_npub() -> Result<()> {
-            with_fresh_config(|| {
-                standard_login()?.exit()?;
-
-                CliTester::new(["login", "--offline"])
-                    .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                    .exit()
-            })
-        }
-
-        #[test]
-        #[serial]
-        fn prompts_for_password_and_succeeds_with_logged_in_as_npub() -> Result<()> {
-            with_fresh_config(|| {
-                standard_login()?.exit()?;
-
-                let mut p = CliTester::new(["login", "--offline"]);
-
-                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                    .succeeds_with(TEST_PASSWORD)?;
-
-                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-            })
-        }
-
-        #[test]
-        #[serial]
-        fn when_invalid_password_exit_with_error() -> Result<()> {
-            with_fresh_config(|| {
-                standard_login()?.exit()?;
-
-                let mut p = CliTester::new(["login", "--offline"]);
-
-                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                    .succeeds_with(TEST_INVALID_PASSWORD)?;
-                p.expect_end_with(format!("Error: failed to log in as {}\r\n\r\nCaused by:\r\n    0: failed to decrypt key with provided password\r\n    1: ChaCha20Poly1305: aead::Error\r\n", TEST_KEY_1_NPUB).as_str())
-            })
-        }
-    }
-
     mod when_called_with_nsec_parameter_only {
         use super::*;
 
@@ -996,7 +958,7 @@ mod with_offline_flag {
             #[serial]
             fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
                 with_fresh_config(|| {
-                    standard_login()?.exit()?;
+                    standard_first_time_login_encrypting_nsec()?.exit()?;
 
                     CliTester::new(["login", "--offline", "--nsec", TEST_KEY_2_NSEC])
                         .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
@@ -1035,26 +997,6 @@ mod with_offline_flag {
 
         #[test]
         #[serial]
-        fn remembers_identity() -> Result<()> {
-            with_fresh_config(|| {
-                CliTester::new([
-                    "login",
-                    "--offline",
-                    "--nsec",
-                    TEST_KEY_1_NSEC,
-                    "--password",
-                    TEST_PASSWORD,
-                ])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
-
-                CliTester::new(["login", "--offline"])
-                    .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                    .exit()
-            })
-        }
-
-        #[test]
-        #[serial]
         fn parameters_can_be_called_globally() -> Result<()> {
             with_fresh_config(|| {
                 CliTester::new([
@@ -1076,7 +1018,7 @@ mod with_offline_flag {
             #[serial]
             fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
                 with_fresh_config(|| {
-                    standard_login()?.exit()?;
+                    standard_first_time_login_encrypting_nsec()?.exit()?;
 
                     CliTester::new([
                         "login",
@@ -1089,28 +1031,6 @@ mod with_offline_flag {
                     .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
                 })
             }
-
-            #[test]
-            #[serial]
-            fn remembers_identity() -> Result<()> {
-                with_fresh_config(|| {
-                    standard_login()?.exit()?;
-
-                    CliTester::new([
-                        "login",
-                        "--offline",
-                        "--nsec",
-                        TEST_KEY_2_NSEC,
-                        "--password",
-                        TEST_PASSWORD,
-                    ])
-                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())?;
-
-                    CliTester::new(["login", "--offline"])
-                        .expect(format!("login as {}\r\n", TEST_KEY_2_NPUB).as_str())?
-                        .exit()
-                })
-            }
         }
 
         mod when_provided_with_new_password {
@@ -1120,7 +1040,7 @@ mod with_offline_flag {
             #[serial]
             fn password_changes() -> Result<()> {
                 with_fresh_config(|| {
-                    standard_login()?.exit()?;
+                    standard_first_time_login_encrypting_nsec()?.exit()?;
 
                     CliTester::new([
                         "login",
@@ -1157,31 +1077,6 @@ mod with_offline_flag {
         }
     }
 
-    mod when_called_with_password_parameter_only {
-        use super::*;
-
-        #[test]
-        #[serial]
-        fn when_nsec_stored_logs_in_without_prompts() -> Result<()> {
-            with_fresh_config(|| {
-                standard_login()?.exit()?;
-
-                CliTester::new(["login", "--offline", "--password", TEST_PASSWORD])
-                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-            })
-        }
-
-        #[test]
-        #[serial]
-        fn when_no_nsec_stored_logs_error() -> Result<()> {
-            with_fresh_config(|| {
-                CliTester::new(["login", "--offline", "--password", TEST_PASSWORD]).expect_end_with(
-                    "Error: no nsec available to decrypt with specified password\r\n",
-                )
-            })
-        }
-    }
-
     mod when_weak_password {
         use super::*;
 
@@ -1195,23 +1090,34 @@ mod with_offline_flag {
                 p.expect_input(EXPECTED_NSEC_PROMPT)?
                     .succeeds_with(TEST_KEY_1_NSEC)?;
 
+                p.expect_confirm(EXPECTED_LOCAL_REPOSITORY_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
+                p.expect_confirm(EXPECTED_REQUIRE_PASSWORD_PROMPT, Some(false))?
+                    .succeeds_with(Some(true))?;
+
                 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
                     .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
                     .succeeds_with(TEST_WEAK_PASSWORD)?;
 
                 p.expect("this may take a few seconds...\r\n")?;
 
-                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
+                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
 
-                p = CliTester::new_with_timeout(10000, ["login", "--offline"]);
+                // commented out as 'login' command now assumes you want to
+                // login as a new user
+                // p = CliTester::new_with_timeout(10000, ["login",
+                // "--offline"]);
 
-                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                    .succeeds_with(TEST_WEAK_PASSWORD)?;
+                // p.expect(format!("login as {}\r\n",
+                // TEST_KEY_1_NPUB).as_str())?
+                //     .expect_password(EXPECTED_PASSWORD_PROMPT)?
+                //     .succeeds_with(TEST_WEAK_PASSWORD)?;
 
-                p.expect("this may take a few seconds...\r\n")?;
+                // p.expect("this may take a few seconds...\r\n")?;
 
-                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+                // p.expect_end_with(format!("logged in as {}\r\n",
+                // TEST_KEY_1_NPUB).as_str())
             })
         }
     }
diff --git a/tests/push.rs b/tests/push.rs
index 5fe1f15..fe711c1 100644
--- a/tests/push.rs
+++ b/tests/push.rs
@@ -347,7 +347,6 @@ mod when_branch_is_checked_out {
                             "1 commits ahead. preparing to create creating patch events.\r\n",
                         )?;
                         p.expect("searching for profile and relay updates...\r\n")?;
-                        p.expect("\r")?;
                         p.expect("logged in as fred\r\n")?;
                         p.expect("pushing 1 commits\r\n")?;
 
@@ -593,7 +592,6 @@ mod when_branch_is_checked_out {
                         p.expect("355bdf1 add a4.md\r\n")?;
                         p.expect("dbd1115 add a3.md\r\n")?;
                         p.expect("searching for profile and relay updates...\r\n")?;
-                        p.expect("\r")?;
                         p.expect("logged in as fred\r\n")?;
                         p.expect("posting 2 patches without a covering letter...\r\n")?;
 
diff --git a/tests/send.rs b/tests/send.rs
index 22216a8..2c95e1e 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -134,7 +134,6 @@ fn expect_msgs_first(p: &mut CliTester, include_cover_letter: bool) -> Result<()
     p.expect("fe973a8 add t4.md\r\n")?;
     p.expect("232efb3 add t3.md\r\n")?;
     p.expect("searching for profile and relay updates...\r\n")?;
-    p.expect("\r")?;
     p.expect("logged in as fred\r\n")?;
     p.expect(format!(
         "posting 2 patches {} a covering letter...\r\n",
@@ -1163,7 +1162,6 @@ mod when_range_ommited_prompts_for_selection_defaulting_ahead_of_main {
         p.expect("fe973a8 add t4.md\r\n")?;
         p.expect("232efb3 add t3.md\r\n")?;
         p.expect("searching for profile and relay updates...\r\n")?;
-        p.expect("\r")?;
         p.expect("logged in as fred\r\n")?;
         p.expect("posting 2 patches without a covering letter...\r\n")?;
         Ok(())
@@ -1358,7 +1356,6 @@ mod root_proposal_specified_using_in_reply_to_with_range_of_head_2_and_cover_let
         p.expect("fe973a8 add t4.md\r\n")?;
         p.expect("232efb3 add t3.md\r\n")?;
         p.expect("searching for profile and relay updates...\r\n")?;
-        p.expect("\r")?;
         p.expect("logged in as fred\r\n")?;
         p.expect(format!(
             "posting 2 patches {} a covering letter...\r\n",