taskkill /F /IM nginx.exe

Claw/Server/SmartClaw/src/websocket_client.rs

@@ -1,16 +1,19 @@
-use tokio_tungstenite::{connect_async, tungstenite::Message};
+use tokio_tungstenite::{connect_async, tungstenite::Message, tungstenite::http::Request};
 use futures_util::{SinkExt, StreamExt};
 use serde_json::json;
 use std::sync::Arc;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, Mutex};
 use tokio::time::{interval, Duration};
 use shared::{TaskRequest, TaskResponse};
+use base64::Engine as _;
+use base64::engine::general_purpose;
+use rand::Rng;
 
 /// WebSocket 客户端连接管理器
 pub struct WebSocketClient {
     gateway_url: String,
-    sender: Arc<std::sync::Mutex<Option<mpsc::Sender<String>>>>,
-    is_connected: Arc<std::sync::Mutex<bool>>,
+    sender: Arc<Mutex<Option<mpsc::Sender<String>>>>,
+    is_connected: Arc<Mutex<bool>>,
 }
 
 impl WebSocketClient {
@@ -18,8 +21,8 @@ impl WebSocketClient {
     pub fn new(gateway_url: String) -> Self {
         Self {
             gateway_url,
-            sender: Arc::new(std::sync::Mutex::new(None)),
-            is_connected: Arc::new(std::sync::Mutex::new(false)),
+            sender: Arc::new(Mutex::new(None)),
+            is_connected: Arc::new(Mutex::new(false)),
         }
     }
 
@@ -27,22 +30,46 @@ impl WebSocketClient {
     pub async fn connect(&self) -> Result<(), Box<dyn std::error::Error>> {
         println!("🔌 正在连接到网关服务: {}", self.gateway_url);
         
-        let ws_url = format!("{}/ws", self.gateway_url.replace("http://", "ws://").replace("https://", "wss://"));
+        let ws_url = format!("{}/api/v1/ws/control", self.gateway_url.replace("http://", "ws://").replace("https://", "wss://"));
         println!("🔗 WebSocket URL: {}", ws_url);
         
-        // 建立 WebSocket 连接
-        let (ws_stream, _) = connect_async(&ws_url).await?;
+        // 生成随机的 Sec-WebSocket-Key
+        let mut key = [0u8; 16];
+        rand::thread_rng().fill(&mut key);
+        let sec_websocket_key = general_purpose::STANDARD.encode(&key);
+        
+        // 建立 WebSocket 连接，添加API密钥和标准 WebSocket 握手头
+        let request = Request::builder()
+            .uri(&ws_url)
+            .header("Host", "pactgo.cn")
+            .header("X-API-Key", "claw_secret_key")
+            .header("Upgrade", "websocket")
+            .header("Connection", "Upgrade")
+            .header("Sec-WebSocket-Key", sec_websocket_key)
+            .header("Sec-WebSocket-Version", "13")
+            .body(())?;
+        
+        println!("🔗 正在建立WebSocket连接...");
+        println!("📋 请求URL: {}", ws_url);
+        println!("📋 HTTP版本: {:?}", request.version());
+        println!("📋 请求头:");
+        for (name, value) in request.headers() {
+            println!("  {}: {:?}", name, value);
+        }
+        
+        let (ws_stream, response) = connect_async(request).await?;
         println!("✅ WebSocket 连接建立");
+        println!("📋 响应状态: {}", response.status());
         
         // 设置连接状态
-        *self.is_connected.lock().unwrap() = true;
+        *self.is_connected.lock().await = true;
         
         // 分割流
         let (mut write, mut read) = ws_stream.split();
         
         // 创建消息通道
         let (tx, mut rx) = mpsc::channel::<String>(100);
-        *self.sender.lock().unwrap() = Some(tx);
+        *self.sender.lock().await = Some(tx);
         
         // 启动消息发送循环
         let _write_handle = tokio::spawn(async move {
@@ -67,13 +94,13 @@ impl WebSocketClient {
                     }
                     Ok(Message::Close(_)) => {
                         println!("🔚 收到关闭消息");
-                        *is_connected_clone.lock().unwrap() = false;
+                        *is_connected_clone.lock().await = false;
                         break;
                     }
                     Ok(_) => {}
                     Err(e) => {
                         println!("❌ 接收消息错误: {}", e);
-                        *is_connected_clone.lock().unwrap() = false;
+                        *is_connected_clone.lock().await = false;
                         break;
                     }
                 }
@@ -89,7 +116,7 @@ impl WebSocketClient {
                 loop {
                     heartbeat_interval.tick().await;
                     
-                    let connected = *is_connected.lock().unwrap();
+                    let connected = *is_connected.lock().await;
                     if !connected {
                         println!("💔 心跳检测到连接已断开");
                         break;
@@ -115,7 +142,7 @@ impl WebSocketClient {
             "timestamp": chrono::Utc::now().timestamp()
         }).to_string();
         
-        if let Some(sender) = &*self.sender.lock().unwrap() {
+        if let Some(sender) = &*self.sender.lock().await {
             let _ = sender.send(connect_msg).await;
         }
         
@@ -150,7 +177,7 @@ impl WebSocketClient {
 
     /// 发送消息
     pub async fn send_message(&self, message: String) -> Result<(), Box<dyn std::error::Error>> {
-        if let Some(sender) = &*self.sender.lock().unwrap() {
+        if let Some(sender) = &*self.sender.lock().await {
             sender.send(message).await.map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
             Ok(())
         } else {
@@ -171,14 +198,14 @@ impl WebSocketClient {
     }
 
     /// 检查连接状态
-    pub fn is_connected(&self) -> bool {
-        *self.is_connected.lock().unwrap()
+    pub async fn is_connected(&self) -> bool {
+        *self.is_connected.lock().await
     }
 
     /// 断开连接
-    pub fn disconnect(&self) {
-        *self.is_connected.lock().unwrap() = false;
-        *self.sender.lock().unwrap() = None;
+    pub async fn disconnect(&self) {
+        *self.is_connected.lock().await = false;
+        *self.sender.lock().await = None;
         println!("🔌 WebSocket 连接已断开");
     }
 }
@@ -208,7 +235,7 @@ impl WebSocketClientManager {
     }
 
     /// 停止客户端
-    pub fn stop(&self) {
-        self.client.disconnect();
+    pub async fn stop(&self) {
+        self.client.disconnect().await;
     }
 }