feat: rework auth flow

Author: Dennor

.github/workflows/build.yaml

@@ -62,10 +62,15 @@ jobs:
           cp result-binaries/bin/x86_64-pc-windows-gnu/client.exe release-artifacts/client-x86_64-windows.exe
           cp result-binaries/bin/x86_64-pc-windows-gnu/mcp-client.exe release-artifacts/mcp-client-x86_64-windows.exe
 
-          # macOS binaries
+          # macOS x86_64 binaries
           cp result-binaries/bin/x86_64-apple-darwin/server release-artifacts/server-x86_64-darwin
           cp result-binaries/bin/x86_64-apple-darwin/client release-artifacts/client-x86_64-darwin
           cp result-binaries/bin/x86_64-apple-darwin/mcp-client release-artifacts/mcp-client-x86_64-darwin
+
+          # macOS aarch64 binaries
+          cp result-binaries/bin/aarch64-apple-darwin/server release-artifacts/server-aarch64-darwin
+          cp result-binaries/bin/aarch64-apple-darwin/client release-artifacts/client-aarch64-darwin
+          cp result-binaries/bin/aarch64-apple-darwin/mcp-client release-artifacts/mcp-client-aarch64-darwin
       - name: Create GitHub Release
         if: inputs.create-release
         uses: softprops/action-gh-release@v2

Cargo.lock

@@ -32,6 +32,7 @@ toml = "0.8"
 anyhow = "1"
 thiserror = "1"
 # Utilities
+async-trait = "0.1"
 uuid = {version = "1", features = ["v4"]}
 rand = "0.8"
 tracing = "0.1"
@@ -40,7 +41,8 @@ dirs = "6"
 keyring = "3"
 hex = "0.4"
 open = "5"
+chrono = {version = "0.4", features = ["serde"]}
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"

Cargo.toml

@@ -17,6 +17,10 @@ tonic.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 
+[lib]
+name = "client"
+path = "src/lib.rs"
+
 [package]
 name = "client"
 edition.workspace = true

client/Cargo.toml

@@ -1,6 +1,6 @@
 //! Client-specific configuration
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
@@ -29,9 +29,14 @@ impl Config {
         config_path()
     }
 
-    /// Load configuration from file
+    /// Load configuration from the default path
     pub fn load() -> Result<Self> {
-        let path = Self::config_path()?;
+        Self::load_from(Self::config_path()?)
+    }
+    
+    /// Load configuration from a specific path
+    pub fn load_from<P: AsRef<Path>>(path: P) -> Result<Self> {
+        let path = path.as_ref();
 
         if !path.exists() {
             bail!(
@@ -40,7 +45,7 @@ impl Config {
             );
         }
 
-        let contents = std::fs::read_to_string(&path)
+        let contents = std::fs::read_to_string(path)
             .context("Failed to read config file")?;
 
         toml::from_str(&contents)

client/src/config.rs

@@ -1,120 +1,46 @@
-use anyhow::{Context, Result};
-use api::{
-    GetConfigRequest, HttpResponse,
-    relay_service_client::RelayServiceClient,
-};
-use tokio_stream::StreamExt;
-use tonic::{
-    Request,
-    metadata::MetadataValue,
-    transport::Channel,
-};
+use api::HttpResponse;
+use common::RelayClient;
 
 use crate::proxy::Proxy;
 
 pub struct GrpcClient {
-    channel: Channel,
-    access_token: String,
+    relay_client: RelayClient,
 }
 
 impl GrpcClient {
-    pub async fn connect(server_address: &str, access_token: String) -> Result<Self> {
-        let channel = Channel::from_shared(server_address.to_string())?
-            .connect()
-            .await
-            .context("Failed to connect to server")?;
-        
-        Ok(Self {
-            channel,
-            access_token,
-        })
-    }
-    
-    fn create_client(&self) -> RelayServiceClient<Channel> {
-        RelayServiceClient::new(self.channel.clone())
+    pub async fn connect(server_address: &str, access_token: String) -> anyhow::Result<Self> {
+        let relay_client = RelayClient::connect(server_address, access_token).await?;
+        Ok(Self { relay_client })
     }
-    
-    fn add_auth<T>(&self, request: &mut Request<T>) -> Result<()> {
-        let token: MetadataValue<_> = format!("Bearer {}", self.access_token)
-            .parse()
-            .context("Invalid token format")?;
-        request.metadata_mut().insert("authorization", token);
-        Ok(())
-    }
-    
-    pub async fn get_config(&self) -> Result<api::ClientConfig> {
-        let mut client = self.create_client();
-        let mut request = Request::new(GetConfigRequest {});
-        self.add_auth(&mut request)?;
-        
-        let response = client.get_config(request).await
-            .context("GetConfig RPC failed")?;
-        
-        response.into_inner().config
-            .context("Server returned empty config")
+
+    pub async fn get_config(&mut self) -> anyhow::Result<api::ClientConfig> {
+        self.relay_client.get_config().await
     }
-    
-    pub async fn run_webhook_stream(&self, proxy: Proxy) -> Result<()> {
-        let mut client = self.create_client();
-        
-        // Create channel for sending responses
-        let (response_tx, response_rx) = tokio::sync::mpsc::channel::<HttpResponse>(32);
-        let response_stream = tokio_stream::wrappers::ReceiverStream::new(response_rx);
-        
-        let mut request = Request::new(response_stream);
-        self.add_auth(&mut request)?;
-        
-        let response = client.do_webhook(request).await
-            .context("DoWebhook RPC failed")?;
-        
-        let mut request_stream = response.into_inner();
-        
-        tracing::info!("Connected to webhook stream");
-        
-        while let Some(result) = request_stream.next().await {
-            match result {
-                Ok(http_request) => {
+
+    pub async fn run_webhook_stream(&self, proxy: Proxy) -> anyhow::Result<()> {
+        self.relay_client
+            .run_webhook_loop(move |http_request| {
+                let proxy = proxy.clone();
+                async move {
                     let request_id = http_request.request_id.clone();
-                    tracing::info!(
-                        request_id = %request_id,
-                        method = %http_request.method,
-                        path = %http_request.path,
-                        "Received webhook request"
-                    );
-                    
-                    // Forward to local endpoint
-                    let response = match proxy.forward(http_request).await {
+                    match proxy.forward(http_request).await {
                         Ok(resp) => resp,
                         Err(e) => {
                             tracing::error!(
                                 request_id = %request_id,
                                 error = %e,
                                 "Failed to forward request"
                             );
-                            // Return error response
                             HttpResponse {
                                 request_id,
                                 status_code: 502,
                                 headers: Default::default(),
                                 body: format!("Failed to forward request: {}", e).into_bytes(),
                             }
                         }
-                    };
-                    
-                    // Send response back to server
-                    if response_tx.send(response).await.is_err() {
-                        tracing::error!("Failed to send response to server stream");
-                        break;
                     }
                 }
-                Err(e) => {
-                    tracing::error!(error = %e, "Error receiving from server");
-                    break;
-                }
-            }
-        }
-        
-        tracing::info!("Webhook stream ended");
-        Ok(())
+            })
+            .await
     }
 }

client/src/grpc.rs

@@ -0,0 +1,77 @@
+//! Webhook relay client library
+//!
+//! This module provides the core client functionality for connecting to a webhook
+//! relay server and forwarding requests to a local endpoint.
+
+mod grpc;
+mod proxy;
+
+pub use common::AuthProvider;
+pub use proxy::Proxy;
+
+use std::sync::Arc;
+
+use anyhow::Result;
+use grpc::GrpcClient;
+
+/// Configuration for running the client
+pub struct ClientConfig<A: AuthProvider> {
+    /// gRPC server address (e.g., "http://localhost:50051")
+    pub server_address: String,
+    /// Authentication provider for obtaining access tokens
+    pub auth_provider: A,
+    /// Local endpoint to forward webhooks to (e.g., "http://localhost:3000")
+    pub local_endpoint: String,
+}
+
+/// Result of starting the client - contains the endpoint URL and a handle to stop it
+pub struct ClientHandle {
+    /// The webhook endpoint URL assigned by the server
+    pub endpoint: String,
+    /// Handle to abort the client task
+    abort_handle: tokio::task::AbortHandle,
+}
+
+impl ClientHandle {
+    /// Stop the client
+    pub fn stop(&self) {
+        self.abort_handle.abort();
+    }
+}
+
+/// Start the webhook relay client.
+///
+/// This connects to the relay server, gets the assigned endpoint, and starts
+/// forwarding webhooks to the local endpoint in the background.
+///
+/// Returns a handle containing the endpoint URL and a way to stop the client.
+pub async fn run_client<A: AuthProvider + 'static>(config: ClientConfig<A>) -> Result<ClientHandle> {
+    let auth_provider = Arc::new(config.auth_provider);
+    
+    // Get initial access token
+    let access_token = auth_provider.get_access_token().await?;
+    
+    // Connect to server
+    let mut grpc_client = GrpcClient::connect(&config.server_address, access_token).await?;
+
+    // Get config (establishes session, returns endpoint)
+    let client_config = grpc_client.get_config().await?;
+    let endpoint = client_config.endpoint.clone();
+
+    tracing::info!(endpoint = %endpoint, "Client connected, starting webhook stream");
+
+    // Create proxy
+    let proxy = Proxy::new(config.local_endpoint);
+
+    // Spawn the webhook stream handler
+    let join_handle = tokio::spawn(async move {
+        if let Err(e) = grpc_client.run_webhook_stream(proxy).await {
+            tracing::error!(error = %e, "Webhook stream error");
+        }
+    });
+
+    Ok(ClientHandle {
+        endpoint,
+        abort_handle: join_handle.abort_handle(),
+    })
+}