v4.5.9

changelog.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 2026-03-16 - 4.5.9 - fix(remoteingress-core)
+delay stream close until downstream response draining finishes to prevent truncated transfers
+
+- Waits for the hub-to-client download task to finish before sending the stream CLOSE frame
+- Prevents upstream reads from being cancelled mid-response during asymmetric transfers such as git fetch
+- Retains the existing timeout so stalled downloads still clean up safely
+
+## 2026-03-16 - 4.5.8 - fix(remoteingress-core)
+ensure upstream writes cancel promptly and reliably deliver CLOSE_BACK frames
+
+- listen for stream cancellation while waiting on upstream write timeouts so FRAME_CLOSE does not block for up to 60 seconds
+- replace try_send with send().await when emitting CLOSE_BACK frames to avoid silently dropping close notifications when the data channel is full
+
 ## 2026-03-16 - 4.5.7 - fix(remoteingress-core)
 improve tunnel reconnect and frame write efficiency
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/remoteingress",
-  "version": "4.5.7",
+  "version": "4.5.9",
   "private": false,
   "description": "Edge ingress tunnel for DcRouter - accepts incoming TCP connections at network edge and tunnels them to DcRouter SmartProxy preserving client IP via PROXY protocol v1.",
   "main": "dist_ts/index.js",

rust/crates/remoteingress-core/src/edge.rs

@@ -749,27 +749,24 @@ async fn handle_client_connection(
         }
     }
 
-    // Send CLOSE frame via DATA channel (must arrive AFTER last DATA for this stream).
+    // Wait for the download task (hub → client) to finish BEFORE sending CLOSE.
-    // Use send().await to guarantee delivery (try_send silently drops if channel full).
+    // Upload EOF (client done sending) does NOT mean the response is done.
-    if !client_token.is_cancelled() {
+    // For asymmetric transfers like git fetch (small request, large response),
-        let close_frame = encode_frame(stream_id, FRAME_CLOSE, &[]);
+    // the response is still streaming when the upload finishes.
-        let _ = tunnel_data_tx.send(close_frame).await;
+    // Sending CLOSE before the response finishes would cause the hub to cancel
-    }
+    // the upstream reader mid-response, truncating the data.
-
-    // Wait for the download task (hub → client) to finish draining all buffered
-    // response data. Upload EOF just means the client is done sending; the download
-    // must continue until all response data has been written to the client.
-    // This is critical for asymmetric transfers like git fetch (small request, large response).
-    // The download task will exit when:
-    //   - back_rx returns None (back_tx dropped below after await, or hub sent CLOSE_BACK)
-    //   - client_write fails (client disconnected)
-    //   - client_token is cancelled
     let _ = tokio::time::timeout(
         Duration::from_secs(300),  // 5 min max wait for download to finish
         &mut hub_to_client,
     ).await;
 
-    // Now safe to clean up — download has finished or timed out
+    // NOW send CLOSE — the response has been fully delivered (or timed out).
+    if !client_token.is_cancelled() {
+        let close_frame = encode_frame(stream_id, FRAME_CLOSE, &[]);
+        let _ = tunnel_data_tx.send(close_frame).await;
+    }
+
+    // Clean up
     {
         let mut writers = client_writers.lock().await;
         writers.remove(&stream_id);

rust/crates/remoteingress-core/src/hub.rs

@@ -541,10 +541,16 @@ async fn handle_edge_connection(
                                                         match data {
                                                             Some(data) => {
                                                                 let len = data.len() as u32;
-                                                                match tokio::time::timeout(
+                                                                // Check cancellation alongside the write so we respond
-                                                                    Duration::from_secs(60),
+                                                                // promptly to FRAME_CLOSE instead of blocking up to 60s.
-                                                                    up_write.write_all(&data),
+                                                                let write_result = tokio::select! {
-                                                                ).await {
+                                                                    r = tokio::time::timeout(
+                                                                        Duration::from_secs(60),
+                                                                        up_write.write_all(&data),
+                                                                    ) => r,
+                                                                    _ = writer_token.cancelled() => break,
+                                                                };
+                                                                match write_result {
                                                                     Ok(Ok(())) => {}
                                                                     Ok(Err(_)) => break,
                                                                     Err(_) => {
@@ -619,10 +625,11 @@ async fn handle_edge_connection(
                                             }
                                         }
 
-                                        // Send CLOSE_BACK via DATA channel (must arrive AFTER last DATA_BACK)
+                                        // Send CLOSE_BACK via DATA channel (must arrive AFTER last DATA_BACK).
+                                        // Use send().await to guarantee delivery (try_send silently drops if full).
                                         if !stream_token.is_cancelled() {
                                             let close_frame = encode_frame(stream_id, FRAME_CLOSE_BACK, &[]);
-                                            let _ = data_writer_tx.try_send(close_frame);
+                                            let _ = data_writer_tx.send(close_frame).await;
                                         }
 
                                         writer_for_edge_data.abort();
@@ -632,10 +639,11 @@ async fn handle_edge_connection(
 
                                     if let Err(e) = result {
                                         log::error!("Stream {} error: {}", stream_id, e);
-                                        // Send CLOSE_BACK via DATA channel on error (must arrive after any DATA_BACK)
+                                        // Send CLOSE_BACK via DATA channel on error (must arrive after any DATA_BACK).
+                                        // Use send().await to guarantee delivery.
                                         if !stream_token.is_cancelled() {
                                             let close_frame = encode_frame(stream_id, FRAME_CLOSE_BACK, &[]);
-                                            let _ = data_writer_tx.try_send(close_frame);
+                                            let _ = data_writer_tx.send(close_frame).await;
                                         }
                                     }
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/remoteingress',
-  version: '4.5.7',
+  version: '4.5.9',
   description: 'Edge ingress tunnel for DcRouter - accepts incoming TCP connections at network edge and tunnels them to DcRouter SmartProxy preserving client IP via PROXY protocol v1.'
 }