feat(proxy-tunnel): 增强隧道连接稳定性与恢复速度

- writer 增加 WebSocket Ping keepalive，防止中间代理空闲超时断开
- 服务端增加应用层 PING 循环（30s 间隔），空闲超时延长至 180s
- 重连基础延迟从 1000ms 降低到 500ms
- 节点缓存 TTL 缩短至 15s，不可用节点 TTL 缩短至 5s 加速恢复感知
- 心跳检测间隔从 30s 缩短到 15s

aether-proxy/src/config.rs

@@ -206,7 +206,7 @@ pub struct Config {
     #[arg(
         long,
         env = "AETHER_PROXY_TUNNEL_RECONNECT_BASE_MS",
-        default_value_t = 1000
+        default_value_t = 500
     )]
     pub tunnel_reconnect_base_ms: u64,
 

aether-proxy/src/tunnel/client.rs

@@ -54,8 +54,9 @@ pub async fn connect_and_run(
     // Split into read/write halves
     let (ws_sink, ws_read) = futures_util::StreamExt::split(ws_stream);
 
-    // Spawn writer task
-    let (frame_tx, mut writer_handle) = writer::spawn_writer(ws_sink);
+    // Spawn writer task (with WebSocket ping keepalive)
+    let ping_interval = Duration::from_secs(state.config.tunnel_ping_interval_secs);
+    let (frame_tx, mut writer_handle) = writer::spawn_writer(ws_sink, ping_interval);
 
     // Spawn heartbeat task
     let hb_handle = heartbeat::spawn(

aether-proxy/src/tunnel/writer.rs

@@ -1,13 +1,17 @@
 //! Dedicated WebSocket writer task.
 //!
 //! All frame writes go through an mpsc channel to a single writer task,
-//! avoiding contention on the WebSocket sink.
+//! avoiding contention on the WebSocket sink.  The writer also sends
+//! periodic WebSocket Ping frames to keep the connection alive through
+//! intermediary proxies (Nginx, Cloudflare, etc.).
+
+use std::time::Duration;
 
 use futures_util::SinkExt;
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
 use tokio_tungstenite::tungstenite::Message;
-use tracing::{debug, error};
+use tracing::{debug, error, trace};
 
 use super::protocol::Frame;
 
@@ -15,18 +19,40 @@ use super::protocol::Frame;
 pub type FrameSender = mpsc::Sender<Frame>;
 
 /// Spawn the writer task. Returns the sender and a JoinHandle for cleanup.
-pub fn spawn_writer<S>(mut sink: S) -> (FrameSender, JoinHandle<()>)
+///
+/// `ping_interval` controls WebSocket-level Ping frequency (typically 15s).
+/// This keeps the connection alive through intermediary proxies/load-balancers.
+pub fn spawn_writer<S>(mut sink: S, ping_interval: Duration) -> (FrameSender, JoinHandle<()>)
 where
     S: SinkExt<Message, Error = tokio_tungstenite::tungstenite::Error> + Unpin + Send + 'static,
 {
     let (tx, mut rx) = mpsc::channel::<Frame>(256);
 
     let handle = tokio::spawn(async move {
-        while let Some(frame) = rx.recv().await {
-            let data = frame.encode();
-            if let Err(e) = sink.send(Message::Binary(data.into())).await {
-                error!(error = %e, "failed to write frame to WebSocket");
-                break;
+        let mut ping_ticker = tokio::time::interval(ping_interval);
+        ping_ticker.tick().await; // skip first immediate tick
+
+        loop {
+            tokio::select! {
+                frame = rx.recv() => {
+                    match frame {
+                        Some(frame) => {
+                            let data = frame.encode();
+                            if let Err(e) = sink.send(Message::Binary(data.into())).await {
+                                error!(error = %e, "failed to write frame to WebSocket");
+                                break;
+                            }
+                        }
+                        None => break, // all senders dropped
+                    }
+                }
+                _ = ping_ticker.tick() => {
+                    if let Err(e) = sink.send(Message::Ping(vec![])).await {
+                        error!(error = %e, "failed to send WebSocket ping");
+                        break;
+                    }
+                    trace!("sent WebSocket ping");
+                }
             }
         }
         debug!("writer task exiting");