refactor: comprehensive audit — fix bugs, harden security, deduplicate providers, add CI/Docker

Phase 1: Fix compilation (config_path Option<PathBuf>, streaming test, stale test cleanup)
Phase 2: Fix critical bugs (remove block_on deadlocks in 4 providers, fix broken SQL query builder)
Phase 3: Security hardening (session manager, real auth, token masking, Gemini key to header, password policy)
Phase 4: Implement stubs (real provider test, /proc health metrics, client/provider/backup endpoints, has_images)
Phase 5: Code quality (shared provider helpers, explicit re-exports, all Clippy warnings fixed, unwrap removal, 6 unused deps removed, dashboard split into 7 sub-modules)
Phase 6: Infrastructure (GitHub Actions CI, multi-stage Dockerfile, rustfmt.toml, clippy.toml, script fixes)

src/client/mod.rs

@@ -5,10 +5,10 @@
 //! 2. Client usage tracking
 //! 3. Client rate limit configuration
 
+use anyhow::Result;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
-use sqlx::{SqlitePool, Row};
-use anyhow::Result;
+use sqlx::{Row, SqlitePool};
 use tracing::{info, warn};
 
 /// Client information
@@ -58,7 +58,7 @@ impl ClientManager {
     /// Create a new client
     pub async fn create_client(&self, request: CreateClientRequest) -> Result<Client> {
         let rate_limit = request.rate_limit_per_minute.unwrap_or(60);
-        
+
         // First insert the client
         sqlx::query(
             r#"
@@ -72,11 +72,13 @@ impl ClientManager {
         .bind(rate_limit)
         .execute(&self.db_pool)
         .await?;
-        
+
         // Then fetch the created client
-        let client = self.get_client(&request.client_id).await?
+        let client = self
+            .get_client(&request.client_id)
+            .await?
             .ok_or_else(|| anyhow::anyhow!("Failed to retrieve created client"))?;
-        
+
         info!("Created client: {} ({})", client.name, client.client_id);
         Ok(client)
     }
@@ -96,7 +98,7 @@ impl ClientManager {
         .bind(client_id)
         .fetch_optional(&self.db_pool)
         .await?;
-        
+
         if let Some(row) = row {
             let client = Client {
                 id: row.get("id"),
@@ -124,69 +126,68 @@ impl ClientManager {
         if current_client.is_none() {
             return Ok(None);
         }
-        
+
         // Build update query dynamically based on provided fields
-        let mut updates = Vec::new();
         let mut query_builder = sqlx::QueryBuilder::new("UPDATE clients SET ");
         let mut has_updates = false;
-        
+
         if let Some(name) = &request.name {
-            updates.push("name = ");
+            query_builder.push("name = ");
             query_builder.push_bind(name);
             has_updates = true;
         }
-        
+
         if let Some(description) = &request.description {
             if has_updates {
                 query_builder.push(", ");
             }
-            updates.push("description = ");
+            query_builder.push("description = ");
             query_builder.push_bind(description);
             has_updates = true;
         }
-        
+
         if let Some(is_active) = request.is_active {
             if has_updates {
                 query_builder.push(", ");
             }
-            updates.push("is_active = ");
+            query_builder.push("is_active = ");
             query_builder.push_bind(is_active);
             has_updates = true;
         }
-        
+
         if let Some(rate_limit) = request.rate_limit_per_minute {
             if has_updates {
                 query_builder.push(", ");
             }
-            updates.push("rate_limit_per_minute = ");
+            query_builder.push("rate_limit_per_minute = ");
             query_builder.push_bind(rate_limit);
             has_updates = true;
         }
-        
+
         // Always update the updated_at timestamp
         if has_updates {
             query_builder.push(", ");
         }
         query_builder.push("updated_at = CURRENT_TIMESTAMP");
-        
+
         if !has_updates {
             // No updates to make
             return self.get_client(client_id).await;
         }
-        
+
         query_builder.push(" WHERE client_id = ");
         query_builder.push_bind(client_id);
-        
+
         let query = query_builder.build();
         query.execute(&self.db_pool).await?;
-        
+
         // Fetch the updated client
         let updated_client = self.get_client(client_id).await?;
-        
+
         if updated_client.is_some() {
             info!("Updated client: {}", client_id);
         }
-        
+
         Ok(updated_client)
     }
 
@@ -194,7 +195,7 @@ impl ClientManager {
     pub async fn list_clients(&self, limit: Option<i64>, offset: Option<i64>) -> Result<Vec<Client>> {
         let limit = limit.unwrap_or(100);
         let offset = offset.unwrap_or(0);
-        
+
         let rows = sqlx::query(
             r#"
             SELECT 
@@ -204,13 +205,13 @@ impl ClientManager {
             FROM clients
             ORDER BY created_at DESC
             LIMIT ? OFFSET ?
-            "#
+            "#,
         )
         .bind(limit)
         .bind(offset)
         .fetch_all(&self.db_pool)
         .await?;
-        
+
         let mut clients = Vec::new();
         for row in rows {
             let client = Client {
@@ -228,37 +229,30 @@ impl ClientManager {
             };
             clients.push(client);
         }
-        
+
         Ok(clients)
     }
 
     /// Delete a client
     pub async fn delete_client(&self, client_id: &str) -> Result<bool> {
-        let result = sqlx::query(
-            "DELETE FROM clients WHERE client_id = ?"
-        )
-        .bind(client_id)
-        .execute(&self.db_pool)
-        .await?;
-        
+        let result = sqlx::query("DELETE FROM clients WHERE client_id = ?")
+            .bind(client_id)
+            .execute(&self.db_pool)
+            .await?;
+
         let deleted = result.rows_affected() > 0;
-        
+
         if deleted {
             info!("Deleted client: {}", client_id);
         } else {
             warn!("Client not found for deletion: {}", client_id);
         }
-        
+
         Ok(deleted)
     }
 
     /// Update client usage statistics after a request
-    pub async fn update_client_usage(
-        &self,
-        client_id: &str,
-        tokens: i64,
-        cost: f64,
-    ) -> Result<()> {
+    pub async fn update_client_usage(&self, client_id: &str, tokens: i64, cost: f64) -> Result<()> {
         sqlx::query(
             r#"
             UPDATE clients 
@@ -268,14 +262,14 @@ impl ClientManager {
                 total_cost = total_cost + ?,
                 updated_at = CURRENT_TIMESTAMP
             WHERE client_id = ?
-            "#
+            "#,
         )
         .bind(tokens)
         .bind(cost)
         .bind(client_id)
         .execute(&self.db_pool)
         .await?;
-        
+
         Ok(())
     }
 
@@ -286,12 +280,12 @@ impl ClientManager {
             SELECT total_requests, total_tokens, total_cost
             FROM clients
             WHERE client_id = ?
-            "#
+            "#,
         )
         .bind(client_id)
         .fetch_optional(&self.db_pool)
         .await?;
-        
+
         if let Some(row) = row {
             let total_requests: i64 = row.get("total_requests");
             let total_tokens: i64 = row.get("total_tokens");
@@ -307,4 +301,4 @@ impl ClientManager {
         let client = self.get_client(client_id).await?;
         Ok(client.map(|c| c.is_active).unwrap_or(false))
     }
-}
+}