refactor(sandbox): implement unified sandbox manager and introduce E2B provider

Cargo.toml

@@ -30,7 +30,7 @@ flock-agent     = { path = "crates/flock-agent" }
 flock-workflow  = { path = "crates/flock-workflow" }
 
 # LangGraph
-langgraph   = { version = "0.2.4", features = ["prebuilt", "providers", "sqlite"] }
+langgraph   = { version = "0.2.5", features = ["prebuilt", "providers", "sqlite"] }
 
 tokio   = { version = "1", features = ["full"] }
 tokio-stream = "0.1"

crates/flock-agent/src/agent_setup_helpers.rs

@@ -21,7 +21,7 @@ use super::sinks::OutputSink;
 /// when the global sandbox is configured.
 pub async fn filter_sandbox_tools(config: &Config, registry: &mut ToolRegistry) {
     let is_sandbox_configured = if let Some(db) = &config.db_manager {
-        flock_tools::daytona::get_sandbox_config(db).await.is_some()
+        flock_tools::sandbox_core::config::get_sandbox_config(db).await.is_some()
     } else {
         false
     };

crates/flock-core/src/config/settings/types.rs

@@ -147,13 +147,24 @@ impl Default for SessionConfig {
 pub struct SandboxConfig {
     #[serde(default)]
     pub enabled: bool,
+    #[serde(default = "default_sandbox_provider")]
+    pub provider: Option<String>,
     pub api_url: Option<String>,
     pub api_key: Option<String>,
     pub api_key_encrypted: Option<String>,
     pub api_key_nonce: Option<String>,
+    pub e2b_api_key: Option<String>,
+    pub e2b_api_key_encrypted: Option<String>,
+    pub e2b_api_key_nonce: Option<String>,
+    pub e2b_api_url: Option<String>,
     pub snapshot: Option<String>,
 }
 
+pub fn default_sandbox_provider() -> Option<String> {
+    Some("e2b".to_string())
+}
+
+
 // --- Default value functions ---
 pub fn default_provider() -> String {
     "anthropic".to_string()

crates/flock-tools/src/lib.rs

@@ -4,10 +4,11 @@ pub mod adapter;
 pub mod file_cache;
 pub mod tool_executor;
 
-pub mod daytona;
+pub mod sandbox_core;
 pub mod registry;
 pub mod tools;
 
+
 pub use tools::{baidu, builtin, google, math, mcp, openweather, sandbox, serper};
 
 /// Snapshot of all registered tools and their provider metadata.

crates/flock-tools/src/daytona/config.rs → crates/flock-tools/src/sandbox_core/config.rs

@@ -4,17 +4,47 @@ use flock_core::config::settings::SandboxConfig;
 /// 获取当前启用的沙盒配置。若未启用或未配置，则返回 None。
 pub async fn get_sandbox_config(db: &DbManager) -> Option<SandboxConfig> {
     let mut cfg: SandboxConfig = db.get_config("sandbox").await?;
+
+    // Decrypt Daytona key
     if let (Some(ct), Some(n)) = (&cfg.api_key_encrypted, &cfg.api_key_nonce) {
         if let Ok(salt) = db.get_or_create_salt().await {
             if let Ok(decrypted) = flock_core::crypto::decrypt_value(ct, n, &salt) {
                 cfg.api_key = Some(decrypted);
             }
         }
     }
-    if cfg.enabled && cfg.api_url.is_some() && cfg.api_key.is_some() {
-        Some(cfg)
-    } else {
-        None
+
+    // Decrypt E2B key
+    if let (Some(ct), Some(n)) = (&cfg.e2b_api_key_encrypted, &cfg.e2b_api_key_nonce) {
+        if let Ok(salt) = db.get_or_create_salt().await {
+            if let Ok(decrypted) = flock_core::crypto::decrypt_value(ct, n, &salt) {
+                cfg.e2b_api_key = Some(decrypted);
+            }
+        }
+    }
+
+    if !cfg.enabled {
+        return None;
+    }
+
+    let provider = cfg.provider.as_deref().unwrap_or("e2b");
+    match provider {
+        "e2b" => {
+            if cfg.e2b_api_key.is_some() {
+                Some(cfg)
+            } else {
+                None
+            }
+        }
+        "daytona" => {
+            if cfg.api_url.is_some() && cfg.api_key.is_some() {
+                Some(cfg)
+            } else {
+                None
+            }
+        }
+        "local" => Some(cfg),
+        _ => None,
     }
 }
 

crates/flock-tools/src/daytona/exec.rs → crates/flock-tools/src/sandbox_core/daytona/exec.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use flock_core::db::DbManager;
-use crate::daytona::config::get_sandbox_config;
+use crate::sandbox_core::config::get_sandbox_config;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DaytonaSandboxResponse {
@@ -22,26 +22,24 @@ struct ExecuteResponse {
     pub exit_code: Option<i32>,
 }
 
-/// 在沙盒中执行指令，带有端点兼容重试机制
+/// 在 Daytona 沙盒中执行指令（通过 Toolbox API），带端点兼容重试机制
 pub async fn execute_command_in_sandbox(
     db: &DbManager,
     sandbox_id: &str,
     command: &str,
 ) -> anyhow::Result<(String, i32)> {
     let cfg = get_sandbox_config(db).await
-        .ok_or_else(|| anyhow::anyhow!("云端 Daytona 沙箱未配置或未启用"))?;
+        .ok_or_else(|| anyhow::anyhow!("Daytona 沙箱未配置或未启用"))?;
 
     let api_url = cfg.api_url.as_ref().unwrap().trim_end_matches('/');
     let api_key = cfg.api_key.as_ref().unwrap();
-
-    // 生成 Toolbox 执行请求 of URL list
+
     let urls = if api_url.contains("app.daytona.io") {
         vec!(
             format!("https://proxy.app.daytona.io/toolbox/{}/toolbox/process/execute", sandbox_id),
             format!("https://proxy.app.daytona.io/toolbox/{}/process/execute", sandbox_id),
         )
     } else {
-        // 自建模式
         let base = api_url.trim_end_matches("/api").trim_end_matches("/");
         vec!(
             format!("{}/toolbox/{}/toolbox/process/execute", base, sandbox_id),
@@ -80,12 +78,10 @@ pub async fn execute_command_in_sandbox(
                             return Err(anyhow::anyhow!("解析执行响应失败。原始响应体: {}", resp_text));
                         }
                     } else if status == reqwest::StatusCode::NOT_FOUND {
-                        // 如果 404，我们尝试下一个候选 endpoint
                         last_error = Some(anyhow::anyhow!("Toolbox API 返回 404: {}", url));
                         continue;
                     } else if status.is_server_error() || status.as_u16() == 502 || status.as_u16() == 503 {
                         last_error = Some(anyhow::anyhow!("Toolbox API 响应服务端错误 ({}): {}", url, status));
-                        // 可能是沙盒内的 agent 还没完全起来，继续重试
                     } else {
                         let err_body = resp.text().await.unwrap_or_default();
                         return Err(anyhow::anyhow!("Toolbox API 响应失败 ({}): {}", url, err_body));
@@ -96,8 +92,7 @@ pub async fn execute_command_in_sandbox(
                 }
             }
         }
-
-        // 如果不是最后一次尝试，等待一小段时间再重试
+
         if attempt < max_retries {
             tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
         }

crates/flock-tools/src/daytona/fs.rs → crates/flock-tools/src/sandbox_core/daytona/fs.rs

@@ -1,5 +1,6 @@
 use flock_core::db::DbManager;
-use crate::daytona::{execute_command_in_sandbox, get_or_create_active_sandbox};
+use crate::sandbox_core::daytona::execute_command_in_sandbox;
+use crate::sandbox_core::manager::get_or_create_active_sandbox;
 use serde::{Deserialize, Serialize};
 use std::path::{Component, Path};