fix: update Rust to 1.85 and format code

- Update Dockerfile to use Rust 1.85 for edition2024 support
- Run cargo fmt on all source files

Author: echobt

docker/Dockerfile

@@ -1,5 +1,5 @@
 # term-executor service Dockerfile
-FROM rust:1.78-slim-bookworm AS builder
+FROM rust:1.85-slim-bookworm AS builder
 
 # Install dependencies
 RUN apt-get update && apt-get install -y \

src/api/http/handlers.rs

@@ -8,11 +8,11 @@ use axum::{
 use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
+use crate::basilica::VerificationResult;
 use crate::crypto::verify_validator_signature;
 use crate::error::ExecutorError;
 use crate::executor::{ExecutionRequest, ExecutionResult, ExecutionStatus, TaskSpec};
 use crate::AppState;
-use crate::basilica::VerificationResult;
 
 /// Health check response
 #[derive(Serialize)]
@@ -47,7 +47,12 @@ pub async fn verify_instance(
 
     // Verify validator signature
     let message = format!("verify:{}:{}", instance_id, req.timestamp);
-    verify_validator_signature(&req.validator_hotkey, &req.signature, &message, req.timestamp)?;
+    verify_validator_signature(
+        &req.validator_hotkey,
+        &req.signature,
+        &message,
+        req.timestamp,
+    )?;
 
     // Verify the instance
     let result = state.engine.verify_instance(&instance_id).await?;
@@ -99,7 +104,12 @@ pub async fn execute_task(
         "execute:{}:{}:{}",
         req.instance_id, req.task.id, req.timestamp
     );
-    verify_validator_signature(&req.validator_hotkey, &req.signature, &message, req.timestamp)?;
+    verify_validator_signature(
+        &req.validator_hotkey,
+        &req.signature,
+        &message,
+        req.timestamp,
+    )?;
 
     // Create execution request
     let exec_request = ExecutionRequest {
@@ -174,7 +184,12 @@ pub async fn cancel_execution(
 
     // Verify validator signature
     let message = format!("cancel:{}:{}", execution_id, req.timestamp);
-    verify_validator_signature(&req.validator_hotkey, &req.signature, &message, req.timestamp)?;
+    verify_validator_signature(
+        &req.validator_hotkey,
+        &req.signature,
+        &message,
+        req.timestamp,
+    )?;
 
     // Cancel
     state.engine.cancel(&execution_id).await?;

src/api/http/middleware.rs

@@ -1,12 +1,6 @@
 //! HTTP middleware
 
-use axum::{
-    body::Body,
-    extract::Request,
-    http::StatusCode,
-    middleware::Next,
-    response::Response,
-};
+use axum::{body::Body, extract::Request, http::StatusCode, middleware::Next, response::Response};
 use tracing::warn;
 
 /// Authentication middleware (placeholder)

src/api/http/routes.rs

@@ -24,18 +24,17 @@ pub fn create_router(state: AppState) -> Router {
     Router::new()
         // Health check
         .route("/health", get(handlers::health_check))
-        
         // Instance verification
         .route("/v1/instances/:id/verify", post(handlers::verify_instance))
-        
         // Execution endpoints
         .route("/v1/execute", post(handlers::execute_task))
         .route("/v1/executions/:id", get(handlers::get_execution))
-        .route("/v1/executions/:id/cancel", post(handlers::cancel_execution))
-        
+        .route(
+            "/v1/executions/:id/cancel",
+            post(handlers::cancel_execution),
+        )
         // Stats
         .route("/v1/stats", get(handlers::get_stats))
-        
         // Apply middleware
         .layer(cors)
         .layer(TraceLayer::new_for_http())

src/basilica/client.rs

@@ -113,10 +113,9 @@ impl BasilicaClient {
             )));
         }
 
-        let exec_response: ExecResponse = response
-            .json()
-            .await
-            .map_err(|e| ExecutorError::BasilicaApi(format!("Failed to parse exec response: {}", e)))?;
+        let exec_response: ExecResponse = response.json().await.map_err(|e| {
+            ExecutorError::BasilicaApi(format!("Failed to parse exec response: {}", e))
+        })?;
 
         info!(
             "Exec completed on {}: exit_code={}, duration={}ms",
@@ -234,10 +233,7 @@ impl BasilicaClient {
             info!("Instance {} verified successfully", instance_id);
             Ok(VerificationResult::success(instance_id, &metadata))
         } else {
-            warn!(
-                "Instance {} verification failed: {:?}",
-                instance_id, errors
-            );
+            warn!("Instance {} verification failed: {:?}", instance_id, errors);
             Ok(VerificationResult::failure(instance_id, &metadata, errors))
         }
     }
@@ -273,7 +269,8 @@ impl BasilicaClient {
             }
         }
 
-        Err(last_error.unwrap_or_else(|| ExecutorError::ExecutionFailed("Unknown error".to_string())))
+        Err(last_error
+            .unwrap_or_else(|| ExecutorError::ExecutionFailed("Unknown error".to_string())))
     }
 }
 

src/cleanup/manager.rs

@@ -130,10 +130,8 @@ impl CleanupManager {
     async fn stop_on_instance(&self, instance_id: &str) -> anyhow::Result<()> {
         // Send a kill signal to any agent processes
         // This is best-effort cleanup
-        let request = crate::basilica::ExecRequest::shell(
-            "pkill -f '/agent/agent' 2>/dev/null || true",
-            10,
-        );
+        let request =
+            crate::basilica::ExecRequest::shell("pkill -f '/agent/agent' 2>/dev/null || true", 10);
 
         match self.basilica.exec(instance_id, &request, None).await {
             Ok(_) => debug!("Sent cleanup signal to instance {}", instance_id),

src/cleanup/registry.rs

@@ -252,9 +252,7 @@ mod tests {
             .await
             .unwrap();
 
-        registry
-            .update_state("c1", ContainerState::Completed)
-            .await;
+        registry.update_state("c1", ContainerState::Completed).await;
 
         let container = registry.get("c1").await.unwrap();
         assert_eq!(container.state, ContainerState::Completed);

src/crypto/mod.rs

@@ -48,7 +48,10 @@ pub fn verify_validator_signature(
         ));
     }
 
-    debug!("Signature verified for hotkey {}", &hotkey[..16.min(hotkey.len())]);
+    debug!(
+        "Signature verified for hotkey {}",
+        &hotkey[..16.min(hotkey.len())]
+    );
 
     Ok(())
 }
@@ -114,7 +117,12 @@ mod tests {
         let timestamp = chrono::Utc::now().timestamp();
         let message = format!("test:{}:{}", "instance-123", timestamp);
 
-        let result = verify_validator_signature("invalid-hotkey", "0".repeat(128).as_str(), &message, timestamp);
+        let result = verify_validator_signature(
+            "invalid-hotkey",
+            "0".repeat(128).as_str(),
+            &message,
+            timestamp,
+        );
         assert!(matches!(result, Err(ExecutorError::InvalidHotkey(_))));
     }
 }

src/executor/engine.rs

@@ -230,9 +230,7 @@ impl ExecutionEngine {
                 self.metrics
                     .execution_failed(&exec.request.task.id, &e.to_string());
 
-                self.queue
-                    .mark_failed(execution_id, &e.to_string())
-                    .await;
+                self.queue.mark_failed(execution_id, &e.to_string()).await;
             }
         }
     }

src/executor/queue.rs

@@ -234,9 +234,9 @@ impl ExecutionQueue {
                 ExecutionStatus::Pending => pending += 1,
                 ExecutionStatus::Running => running += 1,
                 ExecutionStatus::Completed => completed += 1,
-                ExecutionStatus::Failed | ExecutionStatus::Cancelled | ExecutionStatus::TimedOut => {
-                    failed += 1
-                }
+                ExecutionStatus::Failed
+                | ExecutionStatus::Cancelled
+                | ExecutionStatus::TimedOut => failed += 1,
             }
         }