fix: Kline streaming - handle symbol/interval in parent message

src/cli.rs

@@ -324,6 +324,13 @@ pub enum StreamCommands {
     },
     /// Stream public trades (public channel)
     Trade { symbol: String },
+    /// Stream candlestick/kline data (public channel)
+    Kline {
+        symbol: String,
+        /// Interval: 3S, 1, 5, 15, 60 (minutes), 1D (day)
+        #[arg(short, long, default_value = "3S")]
+        interval: String,
+    },
     /// Stream order updates (authenticated)
     Order,
     /// Stream position updates (authenticated)

src/commands.rs

@@ -759,6 +759,37 @@ pub async fn handle_stream(command: StreamCommands, verbose: bool) -> Result<()>
                 }
             }
         }
+        StreamCommands::Kline { symbol, interval } => {
+            let ws = StandXWebSocket::without_auth_with_verbose(verbose)?;
+            // Subscribe with interval parameter embedded in topic
+            ws.subscribe_with_interval("kline", Some(&symbol), Some(&interval))
+                .await?;
+            let mut rx = ws.connect().await?;
+
+            println!("Streaming kline for {} [{}]", symbol, interval);
+            println!("Press Ctrl+C to exit\n");
+
+            while let Some(msg) = rx.recv().await {
+                if let WsMessage::Kline(data) = msg {
+                    // Convert timestamp to readable time
+                    let time_str = chrono::DateTime::from_timestamp_millis(data.time)
+                        .map(|dt| dt.format("%H:%M:%S").to_string())
+                        .unwrap_or_else(|| data.time.to_string());
+
+                    println!(
+                        "📊 Kline: {} [{}] {}\nO: {}  H: {}  L: {}  C: {}  Vol: {:.3}",
+                        data.symbol.unwrap_or_default(),
+                        data.interval.unwrap_or_default(),
+                        time_str,
+                        data.open,
+                        data.high,
+                        data.low,
+                        data.close,
+                        data.volume
+                    );
+                }
+            }
+        }
         // User-level authenticated channels
         StreamCommands::Order => {
             let ws = StandXWebSocket::new_with_verbose(verbose)?;

src/models.rs

@@ -135,6 +135,24 @@ pub struct PriceData {
     pub timestamp: String,
 }
 
+/// Kline/candlestick data
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct KlineData {
+    pub symbol: Option<String>,
+    pub interval: Option<String>,
+    pub time: i64,
+    #[serde(deserialize_with = "string_or_number_to_string")]
+    pub open: String,
+    #[serde(deserialize_with = "string_or_number_to_string")]
+    pub high: String,
+    #[serde(deserialize_with = "string_or_number_to_string")]
+    pub low: String,
+    #[serde(deserialize_with = "string_or_number_to_string")]
+    pub close: String,
+    pub volume: f64,
+    pub volume_quote: f64,
+}
+
 /// Order book level
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct OrderBookLevel {