@dainprotocol/tunnel 1.1.17 → 1.1.21

package/dist/client/index.js

@@ -234,26 +234,39 @@ class DainTunnel extends events_1.EventEmitter {
     handleSSEConnection(message) {
         var _a;
         try {
-            const options = {
+            const req = http_1.default.request({
                 hostname: 'localhost',
                 port: this.port,
                 path: message.path,
                 method: message.method || 'GET',
                 headers: message.headers,
                 agent: this.httpAgent,
-            };
-            const req = http_1.default.request(options, (res) => {
+            }, (res) => {
                 var _a;
+                // Non-200 response - forward error to tunnel server
                 if (res.statusCode !== 200) {
-                    res.resume();
-                    if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
-                        this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'error', data: `Status ${res.statusCode}` }));
-                    }
+                    let errorBody = '';
+                    res.on('data', (chunk) => { errorBody += chunk.toString(); });
+                    res.on('end', () => {
+                        var _a;
+                        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                            this.ws.send(JSON.stringify({
+                                type: 'sse', id: message.id, event: 'error',
+                                data: `Status ${res.statusCode}: ${errorBody.substring(0, 200)}`
+                            }));
+                        }
+                    });
                     return;
                 }
+                // Optimize TCP for streaming
                 const socket = res.socket || res.connection;
                 if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
                     socket.setNoDelay(true);
+                // Notify tunnel server that local service accepted
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'connected', data: '' }));
+                }
+                // Stream SSE events to tunnel server
                 let buffer = '';
                 res.on('data', (chunk) => {
                     var _a;
@@ -279,7 +292,7 @@ class DainTunnel extends events_1.EventEmitter {
                 res.on('end', () => {
                     var _a;
                     if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
-                        this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'close', data: 'Connection closed' }));
+                        this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'close', data: '' }));
                     }
                 });
             });

package/dist/server/index.d.ts

@@ -20,6 +20,7 @@ declare class DainTunnelServer {
     private handleStartMessage;
     private handleResponseMessage;
     private handleSSEMessage;
+    private cleanupSSEConnection;
     private handleWebSocketMessage;
     private handleRequest;
     private handleSSERequest;

package/dist/server/index.js

@@ -324,48 +324,61 @@ class DainTunnelServer {
     }
     handleSSEMessage(data) {
         const connection = this.sseConnections.get(data.id);
-        if (!connection) {
-            console.log(`[SSE Debug] handleSSEMessage: No connection found for ${data.id}, event=${data.event}`);
+        if (!connection)
             return;
-        }
         const { res, tunnelId } = connection;
-        const clientDisconnected = connection.clientDisconnected;
-        const isCloseEvent = data.event === 'close';
-        console.log(`[SSE Debug] handleSSEMessage: id=${data.id}, event=${data.event}, clientDisconnected=${clientDisconnected}, isClose=${isCloseEvent}`);
-        if (isCloseEvent) {
+        const conn = connection;
+        // Skip 'connected' event - we already wrote headers
+        if (data.event === 'connected')
+            return;
+        // Handle close event
+        if (data.event === 'close') {
             const tunnel = this.tunnels.get(tunnelId);
-            if (tunnel) {
+            if (tunnel)
                 tunnel.ws.send(JSON.stringify({ type: "sse_close", id: data.id }));
+            if (!conn.clientDisconnected && res.writable) {
+                try {
+                    res.end();
+                }
+                catch (_a) { }
             }
-            if (!clientDisconnected && res.writable) {
+            this.cleanupSSEConnection(data.id, tunnelId);
+            return;
+        }
+        // Handle error - send as SSE error event (headers already written)
+        if (data.event === 'error') {
+            if (!conn.clientDisconnected && res.writable) {
                 try {
-                    res.write(`event: ${data.event}\ndata: ${data.data}\n\n`);
+                    res.write(`event: error\ndata: ${data.data}\n\n`);
                     flushSSE(res);
                     res.end();
                 }
-                catch (error) { /* ignore */ }
+                catch (_b) { }
             }
-            // Decrement request counter for backpressure tracking
-            const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
-            this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
-            this.sseConnections.delete(data.id);
+            this.cleanupSSEConnection(data.id, tunnelId);
             return;
         }
-        if (clientDisconnected || !res.writable) {
-            connection.clientDisconnected = true;
+        // Skip if client disconnected
+        if (conn.clientDisconnected || !res.writable) {
+            conn.clientDisconnected = true;
             return;
         }
+        // Forward SSE event
         try {
             if (data.event)
                 res.write(`event: ${data.event}\n`);
-            const escapedData = data.data.replace(/\n/g, '\ndata: ');
-            res.write(`data: ${escapedData}\n\n`);
+            res.write(`data: ${data.data.replace(/\n/g, '\ndata: ')}\n\n`);
             flushSSE(res);
         }
-        catch (error) {
-            connection.clientDisconnected = true;
+        catch (_c) {
+            conn.clientDisconnected = true;
         }
     }
+    cleanupSSEConnection(id, tunnelId) {
+        const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
+        this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
+        this.sseConnections.delete(id);
+    }
     handleWebSocketMessage(data) {
         const connection = this.wsConnections.get(data.id);
         if (!connection)
@@ -453,27 +466,24 @@ class DainTunnelServer {
     }
     handleSSERequest(req, res, tunnelId, tunnel) {
         const sseId = fastId();
-        // Optimize TCP socket for low-latency streaming
+        // Optimize TCP for streaming
         const socket = req.socket || req.connection;
-        if (socket && socket.setNoDelay) {
-            socket.setNoDelay(true); // Disable Nagle's algorithm for immediate transmission
-        }
-        // Set SSE headers with anti-buffering directives
-        // Note: Do NOT set 'Connection: keep-alive' - it's forbidden in HTTP/2 and will cause immediate disconnect
+        if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
+            socket.setNoDelay(true);
+        // Write SSE headers immediately to keep browser connection alive
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
-            'X-Accel-Buffering': 'no', // Disable nginx buffering
+            'X-Accel-Buffering': 'no',
         });
-        // Flush headers immediately to establish SSE connection
-        // Without this, headers may be buffered, delaying connection setup
         res.flushHeaders();
-        // Send SSE comment to keep connection alive and verify it's working
-        // Comments start with : and are ignored by EventSource but flush the buffer
         res.write(': connected\n\n');
-        // Flush the initial write
         flushSSE(res);
-        this.sseConnections.set(sseId, { req, res, id: sseId, tunnelId });
+        this.sseConnections.set(sseId, {
+            req, res, id: sseId, tunnelId,
+            clientDisconnected: false
+        });
+        // Forward to tunnel client
         tunnel.ws.send(JSON.stringify({
             type: "sse_connection",
             id: sseId,
@@ -482,31 +492,22 @@ class DainTunnelServer {
             headers: req.headers,
             body: req.method !== "GET" && req.body ? req.body.toString("base64") : undefined
         }));
-        req.on('close', () => {
-            console.log(`[SSE Debug] req.close fired for ${sseId} - client disconnected`);
+        // Track response close (not request close) - for POST SSE, req closes immediately
+        res.on('close', () => {
             const connection = this.sseConnections.get(sseId);
             if (connection) {
                 connection.clientDisconnected = true;
-                // Clean up after a short delay to allow any pending events to be handled
                 setTimeout(() => {
                     if (this.sseConnections.has(sseId)) {
-                        console.log(`[SSE Debug] Cleaning up SSE connection ${sseId} after client disconnect`);
-                        // Decrement request counter for backpressure tracking
-                        const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
-                        this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
-                        this.sseConnections.delete(sseId);
-                        // Notify tunnel client to close the connection
-                        const tunnel = this.tunnels.get(tunnelId);
-                        if (tunnel && tunnel.ws.readyState === ws_1.default.OPEN) {
-                            tunnel.ws.send(JSON.stringify({ type: "sse_close", id: sseId }));
+                        this.cleanupSSEConnection(sseId, tunnelId);
+                        const t = this.tunnels.get(tunnelId);
+                        if ((t === null || t === void 0 ? void 0 : t.ws.readyState) === ws_1.default.OPEN) {
+                            t.ws.send(JSON.stringify({ type: "sse_close", id: sseId }));
                         }
                     }
                 }, 100);
             }
         });
-        req.on('error', (err) => {
-            console.log(`[SSE Debug] req.error fired for ${sseId}:`, err.message);
-        });
     }
     removeTunnel(ws) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.1.17",
+  "version": "1.1.21",
   "description": "",
   "main": "dist/index.js",
   "private": false,
@@ -19,7 +19,7 @@
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "2.0.56",
+    "@dainprotocol/service-sdk": "2.0.57",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/eventsource": "^3.0.0",
@@ -77,4 +77,4 @@
       ]
     }
   }
-}
+}