Revert "refactor(tunnel): 移除 proxy 连接 idle timeout 机制"

This reverts commit b004551fe5.

apps/aether-gateway/src/tunnel/embedded/hub.rs

@@ -27,6 +27,7 @@ pub enum SendStatus {
 #[derive(Debug, Clone, Copy)]
 pub struct ConnConfig {
     pub ping_interval: Duration,
+    pub idle_timeout: Duration,
     pub outbound_queue_capacity: usize,
 }
 

apps/aether-gateway/src/tunnel/embedded/local_relay.rs

@@ -490,6 +490,7 @@ mod tests {
             ControlPlaneClient::disabled(),
             ConnConfig {
                 ping_interval: Duration::from_secs(15),
+                idle_timeout: Duration::from_secs(0),
                 outbound_queue_capacity: 128,
             },
             128,

apps/aether-gateway/src/tunnel/embedded/proxy_conn.rs

@@ -3,6 +3,7 @@
 /// Handles the lifecycle of a single aether-proxy connection:
 /// accept -> authenticate (headers) -> read loop -> cleanup
 use std::sync::Arc;
+use std::time::Duration;
 
 use aether_runtime::bounded_queue;
 use axum::extract::ws::{Message, WebSocket};
@@ -107,7 +108,7 @@ pub async fn handle_proxy_connection(
     let reader_hub = hub.clone();
     let reader_conn = conn.clone();
     let reader = tokio::spawn(async move {
-        run_proxy_reader(ws_rx, reader_hub, reader_conn).await;
+        run_proxy_reader(ws_rx, reader_hub, reader_conn, cfg.idle_timeout).await;
     });
 
     let _ = reader.await;
@@ -115,7 +116,7 @@ pub async fn handle_proxy_connection(
     conn.request_close();
     hub.unregister_proxy(conn_id, &node_id);
     drop(conn);
-    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    tokio::time::sleep(Duration::from_millis(100)).await;
     writer.abort();
     let _ = writer.await;
 }
@@ -124,11 +125,25 @@ async fn run_proxy_reader(
     mut ws_rx: futures_util::stream::SplitStream<WebSocket>,
     hub: Arc<HubRouter>,
     conn: Arc<ProxyConn>,
+    idle_timeout: Duration,
 ) {
+    let idle_enabled = !idle_timeout.is_zero();
     let mut oversized_count = 0u32;
     let mut frames_received: u64 = 0;
     loop {
-        let msg = ws_rx.next().await;
+        let msg = if idle_enabled {
+            tokio::select! {
+                msg = ws_rx.next() => msg,
+                _ = tokio::time::sleep(idle_timeout) => {
+                    warn!(conn_id = conn.id, node_id = %conn.node_id, "proxy idle timeout");
+                    let _ = conn.send(Message::Binary(protocol::encode_goaway().into()));
+                    conn.request_close();
+                    break;
+                }
+            }
+        } else {
+            ws_rx.next().await
+        };
 
         match msg {
             Some(Ok(Message::Binary(data))) => {