@dainprotocol/tunnel 1.1.16 → 1.1.18

package/dist/client/index.js

@@ -233,6 +233,8 @@ class DainTunnel extends events_1.EventEmitter {
     }
     handleSSEConnection(message) {
         var _a;
+        const startTime = Date.now();
+        console.log(`[SSE E2E] Client: Establishing SSE connection ${message.id} to localhost:${this.port}${message.path}`);
         try {
             const options = {
                 hostname: 'localhost',
@@ -245,16 +247,19 @@ class DainTunnel extends events_1.EventEmitter {
             const req = http_1.default.request(options, (res) => {
                 var _a;
                 if (res.statusCode !== 200) {
+                    console.log(`[SSE E2E] Client: Service returned status ${res.statusCode} for ${message.id}`);
                     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}` }));
                     }
                     return;
                 }
+                console.log(`[SSE E2E] Client: Service accepted SSE connection ${message.id}, streaming started`);
                 const socket = res.socket || res.connection;
                 if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
                     socket.setNoDelay(true);
                 let buffer = '';
+                let eventCount = 0;
                 res.on('data', (chunk) => {
                     var _a;
                     buffer += chunk.toString();
@@ -271,13 +276,20 @@ class DainTunnel extends events_1.EventEmitter {
                         }
                         if (data.endsWith('\n'))
                             data = data.slice(0, -1);
+                        eventCount++;
+                        console.log(`[SSE E2E] Client: Received event #${eventCount} from service for ${message.id}: ${event} (${Date.now() - startTime}ms)`);
                         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, data }));
+                            console.log(`[SSE E2E] Client: Forwarded event to tunnel server for ${message.id}`);
+                        }
+                        else {
+                            console.log(`[SSE E2E] Client: WebSocket closed, cannot forward event for ${message.id}`);
                         }
                     }
                 });
                 res.on('end', () => {
                     var _a;
+                    console.log(`[SSE E2E] Client: Service closed connection for ${message.id} after ${eventCount} events (${Date.now() - startTime}ms)`);
                     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' }));
                     }
@@ -285,6 +297,7 @@ class DainTunnel extends events_1.EventEmitter {
             });
             req.on('error', (error) => {
                 var _a;
+                console.log(`[SSE E2E] Client: Request error for ${message.id}: ${error.message}`);
                 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: error.message }));
                 }
@@ -296,17 +309,23 @@ class DainTunnel extends events_1.EventEmitter {
             this.emit("sse_connection", { id: message.id, path: message.path });
         }
         catch (error) {
+            console.log(`[SSE E2E] Client: Exception for ${message.id}: ${error.message}`);
             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: error.message }));
             }
         }
     }
     handleSSEClose(message) {
+        console.log(`[SSE E2E] Client: Received close command from server for ${message.id}`);
         const client = this.sseClients.get(message.id);
         if (client) {
+            console.log(`[SSE E2E] Client: Destroying local service connection for ${message.id}`);
             client.destroy();
             this.sseClients.delete(message.id);
         }
+        else {
+            console.log(`[SSE E2E] Client: No active connection found for ${message.id} (already closed?)`);
+        }
     }
     forwardRequest(request) {
         return new Promise((resolve, reject) => {

package/dist/server/index.js

@@ -324,11 +324,14 @@ class DainTunnelServer {
     }
     handleSSEMessage(data) {
         const connection = this.sseConnections.get(data.id);
-        if (!connection)
+        if (!connection) {
+            console.log(`[SSE Debug] handleSSEMessage: No connection found for ${data.id}, event=${data.event}`);
             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 tunnel = this.tunnels.get(tunnelId);
             if (tunnel) {
@@ -480,12 +483,14 @@ class DainTunnelServer {
             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`);
             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));
@@ -499,6 +504,9 @@ class DainTunnelServer {
                 }, 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.16",
+  "version": "1.1.18",
   "description": "",
   "main": "dist/index.js",
   "private": false,