split into workspace so CLI can be a standalone crate

src-tauri/src/srv/creddy_server.rs

@@ -9,8 +9,9 @@ use crate::shortcuts::{self, ShortcutAction};
 use crate::state::AppState;
 use super::{
     CloseWaiter,
-    Request,
-    Response,
+    CliCredential,
+    CliRequest,
+    CliResponse,
     Stream,
 };
 
@@ -43,13 +44,12 @@ async fn handle(
     let waiter = CloseWaiter { stream: &mut stream };
 
 
-    let req: Request = serde_json::from_slice(&buf)?;
+    let req: CliRequest = serde_json::from_slice(&buf)?;
     let res = match req {
-        Request::GetAwsCredentials { name, base } => get_aws_credentials(
+        CliRequest::GetCredential{ name, base } => get_aws_credentials(
             name, base, client, app_handle, waiter
         ).await,
-        Request::InvokeShortcut(action) => invoke_shortcut(action).await,
-        Request::GetSshSignature(_) => return Err(HandlerError::Denied),
+        CliRequest::InvokeShortcut(action) => invoke_shortcut(action).await,
     };
 
     // doesn't make sense to send the error to the client if the client has already left
@@ -63,9 +63,9 @@ async fn handle(
 }
 
 
-async fn invoke_shortcut(action: ShortcutAction) -> Result<Response, HandlerError> {
+async fn invoke_shortcut(action: ShortcutAction) -> Result<CliResponse, HandlerError> {
     shortcuts::exec_shortcut(action);
-    Ok(Response::Empty)
+    Ok(CliResponse::Empty)
 }
 
 
@@ -75,7 +75,7 @@ async fn get_aws_credentials(
     client: Client,
     app_handle: AppHandle,
     mut waiter: CloseWaiter<'_>,
-) -> Result<Response, HandlerError> {
+) -> Result<CliResponse, HandlerError> {
     let state = app_handle.state::<AppState>();
     let rehide_ms = {
         let config = state.config.read().await;
@@ -108,11 +108,11 @@ async fn get_aws_credentials(
             Approval::Approved => {
                 if response.base {
                     let creds = state.get_aws_base(name).await?;
-                    Ok(Response::AwsBase(creds))
+                    Ok(CliResponse::Credential(CliCredential::AwsBase(creds)))
                 }
                 else {
-                    let creds = state.get_aws_session(name).await?;
-                    Ok(Response::AwsSession(creds.clone()))
+                    let creds = state.get_aws_session(name).await?.clone();
+                    Ok(CliResponse::Credential(CliCredential::AwsSession(creds)))
                 }
             },
             Approval::Denied => Err(HandlerError::Denied),
@@ -129,4 +129,4 @@ async fn get_aws_credentials(
 
     lease.release();
     result
-}
+}

src-tauri/src/srv/mod.rs

@@ -6,7 +6,6 @@ use tauri::{
 };
 use tokio::io::AsyncReadExt;
 use serde::{Serialize, Deserialize};
-use ssh_agent_lib::proto::message::SignRequest;
 
 use crate::credentials::{AwsBaseCredential, AwsSessionCredential};
 use crate::errors::*;
@@ -15,25 +14,32 @@ use crate::shortcuts::ShortcutAction;
 pub mod creddy_server;
 pub mod agent;
 use platform::Stream;
-pub use platform::addr;
 
 
+// These types match what's defined in creddy_cli, but they are separate types
+// so that we avoid polluting the standalone CLI with a bunch of dependencies
+// that would make it impossible to build a completely static-linked version
 #[derive(Debug, Serialize, Deserialize)]
-pub enum Request {
-    GetAwsCredentials {
+pub enum CliRequest {
+    GetCredential {
         name: Option<String>,
         base: bool,
     },
-    GetSshSignature(SignRequest),
     InvokeShortcut(ShortcutAction),
 }
 
 
 #[derive(Debug, Serialize, Deserialize)]
-pub enum Response {
+pub enum CliResponse {
+    Credential(CliCredential),
+    Empty,
+}
+
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CliCredential {
     AwsBase(AwsBaseCredential),
     AwsSession(AwsSessionCredential),
-    Empty,
 }
 
 
@@ -92,7 +98,7 @@ mod platform {
     pub type Stream = UnixStream;
 
     pub fn bind(sock_name: &str) -> std::io::Result<(UnixListener, PathBuf)> {
-        let path = addr(sock_name);
+        let path = creddy_cli::server_addr(sock_name);
         match std::fs::remove_file(&path) {
             Ok(_) => (),
             Err(e) if e.kind() == ErrorKind::NotFound => (),
@@ -112,14 +118,6 @@ mod platform {
 
         Ok((stream, pid))
     }
-
-
-    pub fn addr(sock_name: &str) -> PathBuf {
-        let mut path = dirs::runtime_dir()
-            .unwrap_or_else(|| PathBuf::from("/tmp"));
-        path.push(format!("{sock_name}.sock"));
-        path
-    }
 }
 
 
@@ -140,7 +138,7 @@ mod platform {
     pub type Stream = NamedPipeServer;
 
     pub fn bind(sock_name: &str) -> std::io::Result<(String, NamedPipeServer)> {
-        let addr = addr(sock_name);
+        let addr = creddy_cli::server_addr(sock_name);
         let listener = ServerOptions::new()
             .first_pipe_instance(true)
             .create(&addr)?;
@@ -163,8 +161,4 @@ mod platform {
         unsafe { GetNamedPipeClientProcessId(handle, &mut pid as *mut u32)? };
         Ok((stream, pid))
     }
-
-    pub fn addr(sock_name: &str) -> String {
-        format!(r"\\.\pipe\{sock_name}")
-    }
 }