Change sbot::init to not panic and instead return an error

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "golgi"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 authors = ["Max Fowler <max@mfowler.info>", "Andrew Reid <glyph@mycelial.technology>"]
 readme = "README.md"

src/error.rs

@@ -34,6 +34,8 @@ pub enum GolgiError {
     Rpc(RpcError),
     /// Go-sbot error.
     Sbot(String),
+    /// Error initializing Go-sbot.
+    SbotInit(String),
     /// SSB sigil-link error.
     SigilLink(String),
     /// JSON serialization or deserialization error.
@@ -57,6 +59,7 @@ impl std::error::Error for GolgiError {
             GolgiError::Feed(ref err) => Some(err),
             GolgiError::Rpc(ref err) => Some(err),
             GolgiError::Sbot(_) => None,
+            GolgiError::SbotInit(_) => None,
             GolgiError::SigilLink(_) => None,
             GolgiError::SerdeJson(ref err) => Some(err),
             GolgiError::ContentType(_) => None,
@@ -78,6 +81,9 @@ impl std::fmt::Display for GolgiError {
             // then have the core display msg be: "SSB RPC error: {}", context
             GolgiError::Rpc(ref err) => write!(f, "SSB RPC failure: {}", err),
             GolgiError::Sbot(ref err) => write!(f, "Sbot returned an error response: {}", err),
+            GolgiError::SbotInit(ref err) => {
+                write!(f, "Sbot encountered an initialization error: {}", err)
+            }
             GolgiError::SigilLink(ref context) => write!(f, "SSB blob ID error: {}", context),
             GolgiError::SerdeJson(_) => write!(f, "Failed to serialize JSON slice"),
             //GolgiError::WhoAmI(ref err) => write!(f, "{}", err),

src/sbot.rs

@@ -75,25 +75,35 @@ impl Sbot {
         };
 
         let OwnedIdentity { pk, sk, id } = match keystore {
-            Keystore::Patchwork => keystore::from_patchwork_local()
+            Keystore::Patchwork => keystore::from_patchwork_local().await.map_err(|_err| {
-                .await
+                GolgiError::SbotInit(
-                .expect("couldn't read local patchwork secret from default location"),
+                    "couldn't read local patchwork secret from default location".to_string(),
-            Keystore::GoSbot => keystore::from_gosbot_local()
+                )
-                .await
+            })?,
-                .expect("couldn't read local go-sbot secret from default location"),
+            Keystore::GoSbot => keystore::from_gosbot_local().await.map_err(|_err| {
+                GolgiError::SbotInit(
+                    "couldn't read local go-sbot secret from default location".to_string(),
+                )
+            })?,
             Keystore::CustomGoSbot(key_path) => {
                 keystore::from_custom_gosbot_keypath(key_path.to_string())
                     .await
-                    .unwrap_or_else(|_| {
+                    .map_err(|_err| {
-                        panic!("couldn't read local go-sbot secret from: {}", key_path)
+                        GolgiError::SbotInit(format!(
-                    })
+                            "couldn't read local go-sbot secret from: {}",
+                            key_path
+                        ))
+                    })?
             }
             Keystore::CustomPatchwork(key_path) => {
                 keystore::from_custom_patchwork_keypath(key_path.to_string())
                     .await
-                    .unwrap_or_else(|_| {
+                    .map_err(|_err| {
-                        panic!("couldn't read local patchwork secret from: {}", key_path)
+                        GolgiError::SbotInit(format!(
-                    })
+                            "couldn't read local patchwork secret from: {}",
+                            key_path
+                        ))
+                    })?
             }
         };