rad-auth: create profile when not found

Be careful about when to attempt creating a profile.  Errors could
trigger creating a profile even when unrelated to it not existing.

Profile::load(..) is altered to distinguish between these cases.

Signed-off-by: Slack Coder <slackcoder@server.ky>

radicle-tools/src/rad-auth.rs

@@ -1,9 +1,16 @@
+use radicle::profile;
+use radicle::Profile;
+
 fn main() -> anyhow::Result<()> {
-    let keypair = radicle::crypto::KeyPair::generate();
-    radicle::crypto::ssh::agent::register(&keypair.sk)?;
-
-    let profile = radicle::Profile::init(keypair)?;
-
+    let profile = match Profile::load() {
+        Ok(v) => v,
+        Err(profile::Error::NotFound(_)) => {
+            let keypair = radicle::crypto::KeyPair::generate();
+            radicle::crypto::ssh::agent::register(&keypair.sk)?;
+            radicle::Profile::init(keypair)?
+        }
+        Err(err) => anyhow::bail!(err),
+    };
     println!("id: {}", profile.id());
     println!("home: {}", profile.home.display());
 

radicle/src/keystore.rs

@@ -58,15 +58,21 @@ impl UnsafeKeystore {
         Ok(())
     }
 
-    pub fn get(&self) -> Result<(PublicKey, SecretKey), Error> {
-        let public = fs::read(self.path.join("radicle.pub"))?;
+    pub fn get(&self) -> Result<Option<(PublicKey, SecretKey)>, Error> {
+        let public = self.path.join("radicle.pub");
+        let secret = self.path.join("radicle");
+        if !public.exists() && !secret.exists() {
+            return Ok(None);
+        }
+
+        let public = fs::read(public)?;
         let public = String::from_utf8(public)?;
         let public = PublicKey::from_pem(&public)?;
 
-        let secret = fs::read(self.path.join("radicle"))?;
+        let secret = fs::read(secret)?;
         let secret = String::from_utf8(secret)?;
         let secret = SecretKey::from_pem(&secret)?;
 
-        Ok((public, secret))
+        Ok(Some((public, secret)))
     }
 }

radicle/src/profile.rs

@@ -13,12 +13,24 @@
 use std::path::PathBuf;
 use std::{env, io};
 
+use thiserror::Error;
+
 use crate::crypto::{KeyPair, PublicKey, SecretKey, Signature, Signer};
-use crate::keystore::{Error, UnsafeKeystore};
+use crate::keystore::UnsafeKeystore;
 use crate::node;
 use crate::storage::git::transport;
 use crate::storage::git::Storage;
 
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    #[error(transparent)]
+    KeyStore(#[from] crate::keystore::Error),
+    #[error("no profile found at the filepath '{0}'")]
+    NotFound(PathBuf),
+}
+
 #[derive(Debug)]
 pub struct UnsafeSigner {
     pub public: PublicKey,
@@ -65,7 +77,9 @@ impl Profile {
 
     pub fn load() -> Result<Self, Error> {
         let home = self::home()?;
-        let (public, secret) = UnsafeKeystore::new(&home.join("keys")).get()?;
+        let (public, secret) = UnsafeKeystore::new(&home.join("keys"))
+            .get()?
+            .ok_or_else(|| Error::NotFound(home.clone()))?;
         let signer = UnsafeSigner { public, secret };
         let storage = Storage::open(&home.join("storage"))?;