feat: M1.1 完成 + M1.2 启动 — 全量更新

M1.1 收尾:
- 24项 P0/P1/P2 bug 修复 (Rust 107 tests + Flutter 15 tests)
- Flutter App v0.3: cupertino_icons 修复, 单元测试, 调试面板, APK 52.6MB
- 示例插件完善: manifest.json + 请求/响应示范 + 7个测试
- API 文档重写 (以 routes.rs 为唯一权威)
- MILESTONES.md 更新至 100%

M1.2 启动:
- P0: 插件管理 API 闭环 (handle_manager_message Custom 分支 + broadcast_plugin_states)
- ServiceManager 集成测试 8/8 (tests/m1_2_service_manager.rs)
- M1.2 测试计划 (docs/M1.2_TEST_PLAN.md, 18个E2E场景)
- 动态插件系统: auto_rollback + version_manager GC + 路径穿越防护

总计: Rust 115/115 测试, Flutter 15/15 测试, 零 warning

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/plugins/http/mod.rs

@@ -11,7 +11,9 @@ use anyhow::{Context, Result};
 use serde::Serialize;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
+use std::thread::JoinHandle;
 use tokio::sync::broadcast;
+use tokio::sync::{oneshot, Mutex as AsyncMutex};
 
 #[derive(Serialize)]
 struct WsEvent<'a, T> {
@@ -36,6 +38,7 @@ struct PendingWifiResponse {
 }
 
 pub(crate) struct HttpState {
+    wifi_request_lock: AsyncMutex<()>,
     wifi_response: Mutex<PendingWifiResponse>,
     wifi_response_cv: Condvar,
     last_wifi_result: Mutex<Option<String>>,
@@ -60,6 +63,7 @@ impl HttpState {
         };
 
         Self {
+            wifi_request_lock: AsyncMutex::new(()),
             wifi_response: Mutex::new(PendingWifiResponse {
                 version: 0,
                 payload: None,
@@ -202,6 +206,8 @@ impl HttpState {
 pub struct HttpPlugin {
     ctx: Option<PluginContext>,
     state: Option<Arc<HttpState>>,
+    shutdown_tx: Option<oneshot::Sender<()>>,
+    server_thread: Option<JoinHandle<()>>,
 }
 
 impl HttpPlugin {
@@ -209,6 +215,8 @@ impl HttpPlugin {
         Self {
             ctx: None,
             state: None,
+            shutdown_tx: None,
+            server_thread: None,
         }
     }
 }
@@ -244,6 +252,8 @@ impl Plugin for HttpPlugin {
     }
 
     fn start(&mut self) -> Result<()> {
+        self.stop()?;
+
         let ctx = self
             .ctx
             .as_ref()
@@ -263,7 +273,9 @@ impl Plugin for HttpPlugin {
                 .context("http plugin state is not initialized")?,
         );
 
-        std::thread::spawn(move || {
+        let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+        let server_thread = std::thread::spawn(move || {
             let runtime = match tokio::runtime::Builder::new_multi_thread()
                 .enable_all()
                 .build()
@@ -294,10 +306,18 @@ impl Plugin for HttpPlugin {
                 }
 
                 println!("[HttpPlugin] listening on http://{addr}");
-                warp::serve(routes).run(addr).await;
+                warp::serve(routes)
+                    .bind_with_graceful_shutdown(addr, async move {
+                        let _ = shutdown_rx.await;
+                    })
+                    .1
+                    .await;
             });
         });
 
+        self.shutdown_tx = Some(shutdown_tx);
+        self.server_thread = Some(server_thread);
+
         Ok(())
     }
 
@@ -344,6 +364,16 @@ impl Plugin for HttpPlugin {
     }
 
     fn stop(&mut self) -> Result<()> {
+        if let Some(shutdown_tx) = self.shutdown_tx.take() {
+            let _ = shutdown_tx.send(());
+        }
+
+        if let Some(server_thread) = self.server_thread.take() {
+            server_thread
+                .join()
+                .map_err(|_| anyhow::anyhow!("http server thread panicked"))?;
+        }
+
         Ok(())
     }
 }

src/plugins/http/routes.rs

@@ -10,11 +10,16 @@ use serde_json::Value;
 use std::convert::Infallible;
 use std::path::{Path, PathBuf};
 use std::sync::{mpsc, Arc};
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
+use tokio::io::AsyncWriteExt;
 use warp::http::StatusCode;
 use warp::multipart::FormData;
 use warp::{Filter, Reply};
 
+const MAX_UPLOAD_FILE_SIZE: u64 = 100 * 1024 * 1024;
+static UPLOAD_TMP_COUNTER: AtomicU64 = AtomicU64::new(0);
+
 #[derive(Deserialize)]
 struct WifiConnectRequest {
     ssid: String,
@@ -801,28 +806,13 @@ async fn handle_video_upload(
             continue;
         }
 
-        let data = match part
-            .stream()
-            .try_fold(Vec::new(), |mut acc, buf| async move {
-                acc.extend_from_slice(buf.chunk());
-                Ok(acc)
-            })
-            .await
-        {
-            Ok(data) => data,
-            Err(error) => {
-                return Ok(error_json(
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    &format!("读取文件失败: {error}"),
-                ));
-            }
-        };
-
-        if let Err(error) = std::fs::write(dir.join(&safe_name), &data) {
-            return Ok(error_json(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                &format!("保存文件失败: {error}"),
-            ));
+        if let Err(error) = stream_upload_part(part, &dir.join(&safe_name)).await {
+            let status = if error.contains("文件大小超过限制") {
+                StatusCode::PAYLOAD_TOO_LARGE
+            } else {
+                StatusCode::INTERNAL_SERVER_ERROR
+            };
+            return Ok(error_json(status, &error));
         }
 
         uploaded.push(safe_name);
@@ -959,6 +949,7 @@ async fn wifi_request(
     state: Arc<HttpState>,
     command: WifiCommand,
 ) -> Result<Value, warp::reply::Response> {
+    let _request_guard = state.wifi_request_lock.lock().await;
     let version = match state.wifi_response.lock() {
         Ok(guard) => guard.version,
         Err(_) => {
@@ -1044,6 +1035,69 @@ async fn wifi_request(
     Ok(payload)
 }
 
+async fn stream_upload_part(
+    part: warp::multipart::Part,
+    destination: &Path,
+) -> Result<(), String> {
+    let parent = destination
+        .parent()
+        .ok_or_else(|| "上传目标目录无效".to_string())?;
+    let temp_path = parent.join(format!(
+        ".upload-{}-{}.part",
+        std::process::id(),
+        UPLOAD_TMP_COUNTER.fetch_add(1, Ordering::Relaxed)
+    ));
+
+    let mut file = match tokio::fs::File::create(&temp_path).await {
+        Ok(file) => file,
+        Err(error) => return Err(format!("创建临时文件失败: {error}")),
+    };
+
+    let mut total_size = 0u64;
+    let mut stream = part.stream();
+
+    while let Some(chunk) = match stream.try_next().await {
+        Ok(chunk) => chunk,
+        Err(error) => {
+            let _ = tokio::fs::remove_file(&temp_path).await;
+            return Err(format!("读取文件失败: {error}"));
+        }
+    } {
+        let chunk_size = chunk.remaining() as u64;
+        total_size = total_size.saturating_add(chunk_size);
+        if total_size > MAX_UPLOAD_FILE_SIZE {
+            let _ = file.flush().await;
+            drop(file);
+            let _ = tokio::fs::remove_file(&temp_path).await;
+            return Err(format!(
+                "文件大小超过限制: 单文件最大 {} MB",
+                MAX_UPLOAD_FILE_SIZE / 1024 / 1024
+            ));
+        }
+
+        if let Err(error) = file.write_all(chunk.chunk()).await {
+            drop(file);
+            let _ = tokio::fs::remove_file(&temp_path).await;
+            return Err(format!("写入临时文件失败: {error}"));
+        }
+    }
+
+    if let Err(error) = file.flush().await {
+        drop(file);
+        let _ = tokio::fs::remove_file(&temp_path).await;
+        return Err(format!("刷新临时文件失败: {error}"));
+    }
+
+    drop(file);
+
+    if let Err(error) = tokio::fs::rename(&temp_path, destination).await {
+        let _ = tokio::fs::remove_file(&temp_path).await;
+        return Err(format!("保存文件失败: {error}"));
+    }
+
+    Ok(())
+}
+
 async fn websocket_session(
     ws: warp::ws::WebSocket,
     tx: mpsc::Sender<Envelope>,
@@ -1369,20 +1423,13 @@ fn file_upload_route(
                     continue;
                 }
 
-                let data = match part
-                    .stream()
-                    .try_fold(Vec::new(), |mut acc, buf| async move {
-                        acc.extend_from_slice(buf.chunk());
-                        Ok(acc)
-                    })
-                    .await
-                {
-                    Ok(d) => d,
-                    Err(e) => return Ok(error_json(StatusCode::INTERNAL_SERVER_ERROR, &format!("读取失败: {e}"))),
-                };
-
-                if let Err(e) = std::fs::write(&dest, &data) {
-                    return Ok(error_json(StatusCode::INTERNAL_SERVER_ERROR, &format!("保存失败: {e}")));
+                if let Err(error) = stream_upload_part(part, &dest).await {
+                    let status = if error.contains("文件大小超过限制") {
+                        StatusCode::PAYLOAD_TOO_LARGE
+                    } else {
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    };
+                    return Ok(error_json(status, &error));
                 }
                 uploaded.push(safe_name);
             }