fix: clarify CLI tunnel startup

Author: Programmer-Red

Cargo.lock

@@ -9,7 +9,7 @@ homepage     = "https://github.com/Programmer-Red/LabStreamGate"
 license      = "MIT"
 repository   = "https://github.com/Programmer-Red/LabStreamGate"
 rust-version = "1.95"
-version      = "0.6.3"
+version      = "0.6.4"
 
 [profile.release]
 codegen-units = 1

Cargo.toml

@@ -20,6 +20,16 @@ LabStreamGate 是 xujclab 靶机的本地连接器。它会把题目页给出的
 3. 点击「使用 LabStreamGate 连接」，首次使用时在客户端中允许 xujclab。
 4. 按题目页显示的本机地址连接，例如 `127.0.0.1:32123`。
 
+### 使用 CLI
+
+CLI 不需要 `sudo`。将题目页提供的完整 WSS 地址粘贴到命令末尾：
+
+```bash
+./labstreamgate connect 'wss://chall.xujclab.com/你的通道ID'
+```
+
+启动后终端会显示一个本地连接地址，例如 `127.0.0.1:54813`。保持 CLI 运行，再让浏览器、nc、SSH 或调试器连接这个本地地址。CLI 会一直等待本地连接，这是正常状态；按 `Ctrl+C` 退出。
+
 macOS 如果提示应用无法打开，先将应用拖入「应用程序」，再执行：
 
 ```bash

README.md

@@ -1,8 +1,11 @@
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
-use tokio::net::{TcpListener, TcpStream};
+use tokio::{
+    net::{TcpListener, TcpStream},
+    time::timeout,
+};
 use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info};
 use url::Url;
 use wsrx::proxy;
 
@@ -13,55 +16,75 @@ pub async fn launch(
 ) {
     let log_json = log_json.unwrap_or(false);
     init_logger(log_json);
-    let port = port.unwrap_or(0);
-    let host = host.unwrap_or(String::from("127.0.0.1"));
-    let listener = TcpListener::bind(format!("{host}:{port}"))
-        .await
-        .expect("failed to bind port");
-    let Ok(url) = Url::parse(&address) else {
-        error!("Invalid url, please check your input.");
+    let Ok(parsed_url) = Url::parse(&address) else {
+        eprintln!("连接地址无效，请粘贴题目页提供的完整 ws:// 或 wss:// 地址。");
         return;
     };
-    if url.scheme() != "ws" && url.scheme() != "wss" {
-        error!("Invalid url scheme, only `ws` and `wss` are supported.");
+    if parsed_url.scheme() != "ws" && parsed_url.scheme() != "wss" {
+        eprintln!("连接地址协议无效，只支持 ws:// 或 wss://。");
         return;
     }
-    let url = url.as_ref().to_string();
-    info!(
-        "Hi, I am not RX, RX is here -> {}",
-        listener.local_addr().unwrap()
-    );
-    warn!(
-        "wsrx will not report non-critical errors by default, you can set `RUST_LOG=wsrx=debug` to see more details."
-    );
+
+    let port = port.unwrap_or(0);
+    let host = host.unwrap_or(String::from("127.0.0.1"));
+    let listener = match TcpListener::bind(format!("{host}:{port}")).await {
+        Ok(listener) => listener,
+        Err(err) => {
+            eprintln!("无法创建本地监听地址 {host}:{port}：{err}");
+            return;
+        }
+    };
+    let local_addr = listener
+        .local_addr()
+        .expect("failed to read local listener address");
+    let url = parsed_url.as_ref().to_string();
+
+    println!("LabStreamGate CLI 已启动");
+    println!("本地连接地址：{local_addr}");
+    println!("远端通道：{url}");
+    println!("请保持此进程运行，并让浏览器、nc、SSH 或调试器连接上面的本地地址。");
+    println!("无需使用 sudo；按 Ctrl+C 退出。\n");
+    info!(local = %local_addr, remote = %url, "local tunnel listener started");
 
     let token = CancellationToken::new();
     let url = Arc::new(url);
 
-    // This loop will "run forever"
     loop {
-        let Ok((tcp, _)) = listener.accept().await else {
-            error!("Failed to accept tcp connection, exiting.");
-            token.cancel();
-            return;
+        let accepted = tokio::select! {
+            result = listener.accept() => result,
+            result = tokio::signal::ctrl_c() => {
+                if let Err(err) = result {
+                    error!("failed to listen for Ctrl+C: {err}");
+                }
+                println!("\nLabStreamGate CLI 已退出。");
+                token.cancel();
+                return;
+            }
+        };
+        let (tcp, peer_addr) = match accepted {
+            Ok(connection) => connection,
+            Err(err) => {
+                eprintln!("本地监听失败，LabStreamGate CLI 已退出：{err}");
+                token.cancel();
+                return;
+            }
         };
 
         if token.is_cancelled() {
             return;
         }
 
         let url = url.clone();
-        let peer_addr = tcp.peer_addr().unwrap();
-
-        info!("CREATE remote <-wsrx-> {}", peer_addr);
+        println!("收到本地连接 {peer_addr}，正在连接远端通道……");
+        info!(remote = %url, peer = %peer_addr, "opening remote tunnel connection");
 
         let token = token.clone();
         tokio::spawn(async move {
             match proxy_ws_addr(url.as_ref(), tcp, token).await {
-                Ok(_) => {}
+                Ok(_) => println!("本地连接 {peer_addr} 已关闭。"),
                 Err(e) => {
-                    info!("REMOVE remote <-wsrx-> {} with error", peer_addr);
-                    debug!("TCP connection closed: {}", e);
+                    eprintln!("连接远端通道失败（本地连接 {peer_addr}）：{e}");
+                    debug!(peer = %peer_addr, error = %e, "TCP connection closed with error");
                 }
             }
         });
@@ -72,8 +95,15 @@ async fn proxy_ws_addr(
     addr: impl AsRef<str>, tcp: TcpStream, token: CancellationToken,
 ) -> Result<(), wsrx::Error> {
     let peer_addr = tcp.peer_addr().unwrap();
-    let (ws, _) = tokio_tungstenite::connect_async(addr.as_ref()).await?;
+    let (ws, _) = timeout(
+        Duration::from_secs(15),
+        tokio_tungstenite::connect_async(addr.as_ref()),
+    )
+    .await
+    .map_err(|_| {
+        std::io::Error::new(std::io::ErrorKind::TimedOut, "连接远端通道超时（15 秒）")
+    })??;
     proxy(ws.into(), tcp, token).await?;
-    info!("REMOVE remote <-wsrx-> {}", peer_addr);
+    info!(peer = %peer_addr, "remote tunnel connection closed");
     Ok(())
 }

crates/wsrx/src/cli/connect.rs

@@ -6,15 +6,15 @@ pub fn init_logger(json: bool) {
         tracing_subscriber::registry()
             .with(
                 tracing_subscriber::EnvFilter::try_from_default_env()
-                    .unwrap_or_else(|_| "wsrx=info,tower_http=info".into()),
+                    .unwrap_or_else(|_| "labstreamgate=info,wsrx=info,tower_http=info".into()),
             )
             .with(tracing_subscriber::fmt::layer().json())
             .init();
     } else {
         tracing_subscriber::registry()
             .with(
                 tracing_subscriber::EnvFilter::try_from_default_env()
-                    .unwrap_or_else(|_| "wsrx=info,tower_http=info".into()),
+                    .unwrap_or_else(|_| "labstreamgate=info,wsrx=info,tower_http=info".into()),
             )
             .with(tracing_subscriber::fmt::layer())
             .init();

crates/wsrx/src/cli/logger.rs

@@ -11,7 +11,7 @@ Unicode True
 !define DESCRIPTION                  "Controlled TCP-over-WebSocket forwarding tunnel."
 !define VERSIONMAJOR                 0
 !define VERSIONMINOR                 6
-!define VERSIONBUILD                 3
+!define VERSIONBUILD                 4
 !define INSTALL_DIR_DEFAULT          "$PROGRAMFILES64\${APPNAME}"
 !define MUI_ABORTWARNING
 !define MUI_FINISHPAGE_RUN