refactor: 代理节点架构重构与功能增强

aether-proxy:
- 重构 main.rs，拆分为 app/state/hardware/net 模块
- setup.rs 拆分为 setup/tui.rs + setup/service.rs，支持 systemd 服务管理子命令
- 新增 delegate 端点，支持后端通过代理节点转发请求而非传统 CONNECT 代理
- 注册时上报硬件信息（CPU/内存/fd_limit）和估算最大并发数
- 心跳上报活跃连接数，支持远程下发 node_name 配置
- HTTP 转发时剥离 X-Forwarded-* 等敏感头部
- 切换到 rustls-tls，降低日志级别减少噪音

后端:
- 从 http_client.py 提取代理相关逻辑至 proxy_node/resolver.py
- 从 routes.py 提取业务逻辑至 proxy_node/service.py
- handler 支持 delegate 模式（通过代理节点 HTTP 端点转发而非 CONNECT 隧道）
- ProxyNode 模型新增 hardware_info 和 estimated_max_concurrency 字段

前端:
- 新增 HardwareTooltip 组件展示节点硬件信息
- 远程配置支持下发 node_name

aether-proxy/src/registration/client.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 use tracing::{debug, error, info, warn};
 
 use crate::config::Config;
+use crate::hardware::HardwareInfo;
 
 /// Heartbeat-specific error that distinguishes "node not found" (needs
 /// re-registration) from transient / other failures.
@@ -35,6 +36,10 @@ struct RegisterRequest {
     tls_enabled: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     tls_cert_fingerprint: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    hardware_info: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    estimated_max_concurrency: Option<u64>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -56,6 +61,7 @@ struct HeartbeatRequest {
 /// Remote configuration pushed by the Aether management backend.
 #[derive(Debug, Clone, Deserialize)]
 pub struct RemoteConfig {
+    pub node_name: Option<String>,
     pub allowed_ports: Option<Vec<u16>>,
     pub log_level: Option<String>,
     pub heartbeat_interval: Option<u64>,
@@ -119,6 +125,7 @@ impl AetherClient {
         public_ip: &str,
         tls_enabled: bool,
         tls_cert_fingerprint: Option<&str>,
+        hw: Option<&HardwareInfo>,
     ) -> anyhow::Result<String> {
         let url = format!("{}/api/admin/proxy-nodes/register", self.base_url);
         let body = RegisterRequest {
@@ -129,6 +136,8 @@ impl AetherClient {
             heartbeat_interval: config.heartbeat_interval,
             tls_enabled,
             tls_cert_fingerprint: tls_cert_fingerprint.map(|s| s.to_string()),
+            hardware_info: hw.and_then(|h| serde_json::to_value(h).ok()),
+            estimated_max_concurrency: hw.map(|h| h.estimated_max_concurrency),
         };
 
         info!(
@@ -215,10 +224,13 @@ impl AetherClient {
                     config_version,
                 }
             }
-            Err(_) => HeartbeatResult {
-                remote_config: None,
-                config_version: 0,
-            },
+            Err(e) => {
+                debug!(error = %e, "failed to parse heartbeat response body");
+                HeartbeatResult {
+                    remote_config: None,
+                    config_version: 0,
+                }
+            }
         };
 
         debug!(node_id = %node_id, config_version = result.config_version, "heartbeat ok");
@@ -260,36 +272,3 @@ impl AetherClient {
         }
     }
 }
-
-/// Auto-detect public IP by querying external services.
-pub async fn detect_public_ip() -> anyhow::Result<String> {
-    let endpoints = [
-        "https://api.ipify.org",
-        "https://ifconfig.me/ip",
-        "https://icanhazip.com",
-    ];
-
-    let client = Client::builder()
-        .timeout(std::time::Duration::from_secs(5))
-        .build()?;
-
-    for endpoint in &endpoints {
-        match client.get(*endpoint).send().await {
-            Ok(resp) if resp.status().is_success() => {
-                let ip = resp.text().await?.trim().to_string();
-                if !ip.is_empty() {
-                    info!(ip = %ip, source = %endpoint, "detected public IP");
-                    return Ok(ip);
-                }
-            }
-            Ok(resp) => {
-                debug!(endpoint = %endpoint, status = %resp.status(), "IP detection failed");
-            }
-            Err(e) => {
-                debug!(endpoint = %endpoint, error = %e, "IP detection failed");
-            }
-        }
-    }
-
-    anyhow::bail!("failed to detect public IP from any source; use --public-ip")
-}

aether-proxy/src/registration/heartbeat.rs

@@ -1,11 +1,12 @@
-use std::sync::{Arc, RwLock};
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 use tokio::sync::watch;
 use tracing::{debug, error, info, warn};
 
-use crate::config::Config;
-use crate::registration::client::{AetherClient, HeartbeatError};
-use crate::runtime::{self, SharedDynamicConfig};
+use crate::registration::client::HeartbeatError;
+use crate::runtime;
+use crate::state::AppState;
 
 /// Run periodic heartbeat task until shutdown signal.
 ///
@@ -16,19 +17,11 @@ use crate::runtime::{self, SharedDynamicConfig};
 /// When the heartbeat response includes a `remote_config`, it is applied
 /// to the [`DynamicConfig`](crate::runtime::DynamicConfig) so the proxy
 /// picks up changes without a restart.
-pub async fn run(
-    client: Arc<AetherClient>,
-    node_id: Arc<RwLock<String>>,
-    config: Arc<Config>,
-    public_ip: String,
-    tls_fingerprint: Option<String>,
-    dynamic: SharedDynamicConfig,
-    mut shutdown_rx: watch::Receiver<bool>,
-) {
+pub async fn run(state: &Arc<AppState>, mut shutdown_rx: watch::Receiver<bool>) {
     let mut consecutive_failures: u32 = 0;
 
     // Skip the first tick (registration already acts as initial heartbeat)
-    let initial_interval = dynamic.read().unwrap().heartbeat_interval;
+    let initial_interval = state.dynamic.read().unwrap().heartbeat_interval;
     tokio::select! {
         _ = tokio::time::sleep(std::time::Duration::from_secs(initial_interval)) => {}
         _ = shutdown_rx.changed() => {
@@ -38,12 +31,17 @@ pub async fn run(
     }
 
     loop {
-        let current_node_id = node_id.read().unwrap().clone();
+        let current_node_id = state.node_id.read().unwrap().clone();
+        let active_conns = state.active_connections.load(Ordering::Relaxed) as i64;
 
-        match client.heartbeat(&current_node_id, None, None, None).await {
+        match state
+            .aether_client
+            .heartbeat(&current_node_id, Some(active_conns), None, None)
+            .await
+        {
             Ok(result) => {
                 if consecutive_failures > 0 {
-                    debug!(
+                    info!(
                         previous_failures = consecutive_failures,
                         "heartbeat recovered"
                     );
@@ -52,7 +50,7 @@ pub async fn run(
 
                 // Apply remote config if present and version changed
                 if let Some(ref remote) = result.remote_config {
-                    runtime::apply_remote_config(&dynamic, remote, result.config_version);
+                    runtime::apply_remote_config(&state.dynamic, remote, result.config_version);
                 }
             }
             Err(HeartbeatError::NodeNotFound(_)) => {
@@ -60,19 +58,24 @@ pub async fn run(
                     old_node_id = %current_node_id,
                     "node not found, re-registering"
                 );
-                match client.register(
-                    &config,
-                    &public_ip,
-                    config.enable_tls,
-                    tls_fingerprint.as_deref(),
-                ).await {
+                match state
+                    .aether_client
+                    .register(
+                        &state.config,
+                        &state.public_ip,
+                        state.config.enable_tls,
+                        state.tls_fingerprint.as_deref(),
+                        Some(&state.hardware_info),
+                    )
+                    .await
+                {
                     Ok(new_id) => {
                         info!(
                             old_node_id = %current_node_id,
                             new_node_id = %new_id,
                             "re-registered successfully"
                         );
-                        *node_id.write().unwrap() = new_id;
+                        *state.node_id.write().unwrap() = new_id;
                         consecutive_failures = 0;
                     }
                     Err(e) => {
@@ -96,7 +99,7 @@ pub async fn run(
         }
 
         // Read interval from dynamic config (may have been updated remotely)
-        let interval_secs = dynamic.read().unwrap().heartbeat_interval;
+        let interval_secs = state.dynamic.read().unwrap().heartbeat_interval;
 
         tokio::select! {
             _ = tokio::time::sleep(std::time::Duration::from_secs(interval_secs)) => {}