@dainprotocol/tunnel 1.1.7 → 1.1.9

package/dist/client/index.js

@@ -136,7 +136,6 @@ class DainTunnel extends events_1.EventEmitter {
         });
     }
     handleMessage(message, resolve) {
-        console.log(`[Tunnel Client] Received message type: ${message.type}`);
         switch (message.type) {
             case "tunnelUrl":
                 this.tunnelUrl = message.url;
@@ -150,18 +149,14 @@ class DainTunnel extends events_1.EventEmitter {
                 this.handleWebSocketConnection(message);
                 break;
             case "sse_connection":
-                console.log(`[Tunnel Client] Routing to handleSSEConnection`);
                 this.handleSSEConnection(message);
                 break;
             case "sse_close":
-                console.log(`[Tunnel Client] Routing to handleSSEClose`);
                 this.handleSSEClose(message);
                 break;
             case "websocket":
                 this.handleWebSocketMessage(message);
                 break;
-            default:
-                console.log(`[Tunnel Client] Unknown message type: ${message.type}`);
         }
     }
     async handleRequest(request) {
@@ -255,11 +250,6 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     handleSSEConnection(message) {
-        console.log(`[Tunnel Client] ====== SSE CONNECTION HANDLER START ======`);
-        console.log(`[Tunnel Client] SSE ID: ${message.id}`);
-        console.log(`[Tunnel Client] Path: ${message.path}`);
-        console.log(`[Tunnel Client] Method: ${message.method}`);
-        console.log(`[Tunnel Client] Local port: ${this.port}`);
         try {
             // Create an EventSource-like stream to the local server
             // Since Node.js doesn't have a built-in EventSource, we'll use HTTP
@@ -270,13 +260,8 @@ class DainTunnel extends events_1.EventEmitter {
                 method: message.method || 'GET', // Use provided method (supports POST tool calls)
                 headers: message.headers,
             };
-            console.log(`[Tunnel Client] Creating HTTP request to: http://localhost:${this.port}${message.path}`);
-            console.log(`[Tunnel Client] Request headers:`, JSON.stringify(message.headers, null, 2));
             const req = http_1.default.request(options, (res) => {
-                console.log(`[Tunnel Client] Response received with status: ${res.statusCode}`);
-                console.log(`[Tunnel Client] Response headers:`, JSON.stringify(res.headers, null, 2));
                 if (res.statusCode !== 200) {
-                    console.error(`[Tunnel Client] ❌ Non-200 status code: ${res.statusCode}`);
                     if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                         this.ws.send(JSON.stringify({
                             type: 'sse',
@@ -287,22 +272,17 @@ class DainTunnel extends events_1.EventEmitter {
                     }
                     return;
                 }
-                console.log(`[Tunnel Client] ✓ Starting SSE stream processing for ${message.id}`);
                 // Process SSE stream
                 let buffer = '';
-                let eventCount = 0;
                 res.on('data', (chunk) => {
                     const chunkStr = chunk.toString();
-                    console.log(`[Tunnel Client] SSE chunk ${++eventCount} received (${chunkStr.length} bytes)`);
-                    console.log(`[Tunnel Client] Chunk preview:`, chunkStr.substring(0, 200));
+                    console.log(`[Tunnel Client] SSE chunk received (${chunkStr.length} bytes):`, chunkStr.substring(0, 200));
                     buffer += chunkStr;
                     // Process complete SSE messages
-                    let messagesProcessed = 0;
                     while (buffer.includes('\n\n')) {
                         const messageEndIndex = buffer.indexOf('\n\n');
                         const messageData = buffer.substring(0, messageEndIndex);
                         buffer = buffer.substring(messageEndIndex + 2);
-                        console.log(`[Tunnel Client] Processing SSE message ${++messagesProcessed}:`, messageData);
                         // Parse the SSE message
                         const lines = messageData.split('\n');
                         let event = 'message';
@@ -320,27 +300,18 @@ class DainTunnel extends events_1.EventEmitter {
                             data = data.substring(0, data.length - 1);
                         }
                         // Forward to server
-                        console.log(`[Tunnel Client] Forwarding SSE event to tunnel server:`);
-                        console.log(`[Tunnel Client]   SSE ID: ${message.id}`);
-                        console.log(`[Tunnel Client]   Event: ${event}`);
-                        console.log(`[Tunnel Client]   Data length: ${data.length}`);
+                        console.log(`[Tunnel Client] Forwarding SSE event: ${event}, data length: ${data.length}`);
                         if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                            const forwardMessage = {
+                            this.ws.send(JSON.stringify({
                                 type: 'sse',
                                 id: message.id,
                                 event,
                                 data
-                            };
-                            this.ws.send(JSON.stringify(forwardMessage));
-                            console.log(`[Tunnel Client] ✓ SSE event forwarded to tunnel server`);
-                        }
-                        else {
-                            console.error(`[Tunnel Client] ❌ Cannot forward SSE event - WebSocket not open`);
+                            }));
                         }
                     }
                 });
                 res.on('end', () => {
-                    console.log(`[Tunnel Client] SSE stream ended for ${message.id}`);
                     if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                         this.ws.send(JSON.stringify({
                             type: 'sse',
@@ -348,15 +319,10 @@ class DainTunnel extends events_1.EventEmitter {
                             event: 'close',
                             data: 'Connection closed'
                         }));
-                        console.log(`[Tunnel Client] Sent close event to tunnel server`);
                     }
                 });
-                res.on('error', (error) => {
-                    console.error(`[Tunnel Client] Response stream error for ${message.id}:`, error);
-                });
             });
             req.on('error', (error) => {
-                console.error(`[Tunnel Client] ❌ Request error for ${message.id}:`, error);
                 if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                     this.ws.send(JSON.stringify({
                         type: 'sse',
@@ -368,20 +334,15 @@ class DainTunnel extends events_1.EventEmitter {
             });
             // Write request body for POST requests
             if (message.body && message.method !== 'GET') {
-                const bodyBuffer = Buffer.from(message.body, 'base64');
-                console.log(`[Tunnel Client] Writing request body (${bodyBuffer.length} bytes)`);
-                req.write(bodyBuffer);
+                req.write(Buffer.from(message.body, 'base64'));
             }
             req.end();
-            console.log(`[Tunnel Client] Request sent to local service`);
             // Store a reference to abort the connection later if needed
             this.sseClients.set(message.id, req);
-            console.log(`[Tunnel Client] SSE client stored. Total SSE clients: ${this.sseClients.size}`);
             this.emit("sse_connection", { id: message.id, path: message.path });
-            console.log(`[Tunnel Client] ====== SSE CONNECTION HANDLER COMPLETE ======`);
         }
         catch (error) {
-            console.error(`[Tunnel Client] CRITICAL ERROR establishing SSE connection:`, error);
+            console.error('Error establishing SSE connection:', error);
             if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                 this.ws.send(JSON.stringify({
                     type: 'sse',
@@ -393,17 +354,11 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     handleSSEClose(message) {
-        console.log(`[Tunnel Client] SSE close requested for: ${message.id}`);
         const client = this.sseClients.get(message.id);
         if (client) {
-            console.log(`[Tunnel Client] Destroying SSE client: ${message.id}`);
             // Abort the request if it's still active
             client.destroy();
             this.sseClients.delete(message.id);
-            console.log(`[Tunnel Client] SSE client destroyed. Remaining: ${this.sseClients.size}`);
-        }
-        else {
-            console.log(`[Tunnel Client] SSE client not found: ${message.id}`);
         }
     }
     forwardRequest(request) {

package/dist/server/index.js

@@ -12,6 +12,31 @@ const cors_1 = __importDefault(require("cors"));
 const auth_1 = require("@dainprotocol/service-sdk/service/auth");
 const crypto_1 = require("crypto");
 const url_1 = require("url");
+/**
+ * Force immediate flush of SSE data to prevent buffering
+ * SSE requires immediate delivery; Node.js res.write() doesn't guarantee this
+ *
+ * @param res Express response object
+ */
+function flushSSE(res) {
+    try {
+        // Access underlying socket to force flush
+        // Type assertion needed as Express types don't expose socket methods
+        const socket = res.socket;
+        if (socket && typeof socket.flush === 'function') {
+            socket.flush();
+        }
+        // Fallback: try connection property (older Node.js versions)
+        const connection = res.connection;
+        if (connection && typeof connection.flush === 'function') {
+            connection.flush();
+        }
+    }
+    catch (error) {
+        // Flush is best-effort; log but don't fail the request
+        console.error('[SSE Flush] Error flushing socket:', error);
+    }
+}
 class DainTunnelServer {
     constructor(hostname, port) {
         this.hostname = hostname;
@@ -300,55 +325,46 @@ class DainTunnelServer {
         }
     }
     handleSSEMessage(data) {
-        var _a;
-        console.log(`[Tunnel Server] ====== RECEIVED SSE MESSAGE ======`);
-        console.log(`[Tunnel Server] SSE ID: ${data.id}`);
-        console.log(`[Tunnel Server] Event: ${data.event}`);
-        console.log(`[Tunnel Server] Data length: ${((_a = data.data) === null || _a === void 0 ? void 0 : _a.length) || 0}`);
-        console.log(`[Tunnel Server] Active SSE connections: ${this.sseConnections.size}`);
-        console.log(`[Tunnel Server] Active SSE IDs: ${Array.from(this.sseConnections.keys()).join(', ')}`);
         const connection = this.sseConnections.get(data.id);
         if (!connection) {
-            console.error(`[Tunnel Server] ❌ SSE connection not found: ${data.id}`);
-            console.error(`[Tunnel Server] Available connections: ${Array.from(this.sseConnections.keys()).join(', ')}`);
-            console.error(`[Tunnel Server] This means either:`);
-            console.error(`[Tunnel Server]   1. The connection was never created (handleSSERequest not called)`);
-            console.error(`[Tunnel Server]   2. The connection was already closed`);
-            console.error(`[Tunnel Server]   3. There's an ID mismatch`);
+            console.log(`SSE connection not found: ${data.id}`);
             return;
         }
-        console.log(`[Tunnel Server] ✓ SSE connection found for ${data.id}`);
         const { res } = connection;
+        // Check if response is still writable before attempting to write
+        if (!res.writable) {
+            console.log(`SSE connection ${data.id} is no longer writable`);
+            this.sseConnections.delete(data.id);
+            return;
+        }
         try {
             if (data.event) {
                 res.write(`event: ${data.event}\n`);
-                console.log(`[Tunnel Server] Wrote event: ${data.event}`);
             }
             // Write data as-is (don't split - data is already properly formatted)
             res.write(`data: ${data.data}\n`);
             res.write('\n');
-            console.log(`[Tunnel Server] Wrote ${data.data.length} bytes of data`);
+            // Force immediate flush to prevent buffering
+            // This is critical for SSE - without it, events may be delayed or lost
+            flushSSE(res);
             // Check if this is a "close" event
             if (data.event === 'close') {
-                console.log(`[Tunnel Server] Close event received, ending SSE connection ${data.id}`);
-                // Clear keepalive interval if it exists
-                if (connection.keepaliveInterval) {
-                    clearInterval(connection.keepaliveInterval);
-                    console.log(`[Tunnel Server] Cleared keepalive interval for ${data.id}`);
-                }
                 res.end();
                 this.sseConnections.delete(data.id);
-                console.log(`[Tunnel Server] SSE connection closed. Remaining: ${this.sseConnections.size}`);
             }
-            console.log(`[Tunnel Server] ====== SSE MESSAGE HANDLED ======`);
         }
         catch (error) {
-            console.error(`[Tunnel Server] Error writing SSE message for ${data.id}:`, error);
-            // Clear keepalive interval if it exists
-            if (connection === null || connection === void 0 ? void 0 : connection.keepaliveInterval) {
-                clearInterval(connection.keepaliveInterval);
-            }
+            console.error(`Error writing SSE message for ${data.id}:`, error);
             this.sseConnections.delete(data.id);
+            // Best-effort cleanup: try to end the response
+            try {
+                if (res.writable) {
+                    res.end();
+                }
+            }
+            catch (endError) {
+                console.error(`Error ending SSE connection ${data.id}:`, endError);
+            }
         }
     }
     handleWebSocketMessage(data) {
@@ -379,14 +395,9 @@ class DainTunnelServer {
     }
     async handleRequest(req, res) {
         const tunnelId = req.params.tunnelId;
-        // Log incoming request with headers for debugging
-        console.log(`[Tunnel Server] Incoming request: ${req.method} ${req.url} to tunnel ${tunnelId}`);
-        console.log(`[Tunnel Server] Accept header: "${req.headers.accept}"`);
-        console.log(`[Tunnel Server] Content-Type: "${req.headers['content-type']}"`);
         // Check for upgraded connections (WebSockets) - these are handled by the WebSocket server
         if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') {
             // This is handled by the WebSocket server now
-            console.log(`[Tunnel Server] WebSocket upgrade detected, skipping`);
             return;
         }
         let tunnel;
@@ -404,12 +415,8 @@ class DainTunnelServer {
             console.log(`Tunnel not found after retries: ${tunnelId}`);
             return res.status(404).send("Tunnel not found");
         }
-        // Check for SSE request - more robust check
-        const acceptHeader = (req.headers.accept || '').toLowerCase();
-        const isSSE = acceptHeader.includes('text/event-stream');
-        console.log(`[Tunnel Server] Is SSE request: ${isSSE} (accept: "${acceptHeader}")`);
-        if (isSSE) {
-            console.log(`[Tunnel Server] Routing to SSE handler`);
+        // Check for SSE request
+        if (req.headers.accept && req.headers.accept.includes('text/event-stream')) {
             return this.handleSSERequest(req, res, tunnelId, tunnel);
         }
         // Handle regular HTTP request
@@ -432,118 +439,44 @@ class DainTunnelServer {
     handleSSERequest(req, res, tunnelId, tunnel) {
         // Setup SSE connection
         const sseId = (0, uuid_1.v4)();
-        console.log(`[Tunnel Server] ====== SSE CONNECTION SETUP START ======`);
-        console.log(`[Tunnel Server] SSE ID: ${sseId}`);
-        console.log(`[Tunnel Server] Tunnel ID: ${tunnelId}`);
-        console.log(`[Tunnel Server] Path: ${req.url}`);
-        console.log(`[Tunnel Server] Method: ${req.method}`);
-        try {
-            // CRITICAL: Disable TCP buffering (Nagle's algorithm) to ensure immediate data sending
-            // Without this, the initial keepalive may be buffered and not reach the browser,
-            // causing it to close the connection immediately
-            if (req.socket) {
-                req.socket.setNoDelay(true);
-                req.socket.setTimeout(0);
-                console.log(`[Tunnel Server] Socket configured: noDelay=true, timeout=0 for ${sseId}`);
-            }
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                'Connection': 'keep-alive',
-                'X-Accel-Buffering': 'no', // Disable nginx buffering
-                'Content-Encoding': 'identity', // Prevent compression middleware from buffering
-                'Transfer-Encoding': 'chunked' // Ensure chunked encoding for streaming
-            });
-            console.log(`[Tunnel Server] SSE headers written for ${sseId}`);
-            // Send initial connection event - MUST be sent immediately to prevent browser timeout
-            res.write(': keepalive\n\n');
-            // Force flush if available (some environments support this)
-            if (typeof res.flush === 'function') {
-                res.flush();
-                console.log(`[Tunnel Server] Response flushed for ${sseId}`);
-            }
-            console.log(`[Tunnel Server] Initial keepalive sent for ${sseId}`);
-            // Send keepalive comments every 5 seconds to prevent timeout
-            const keepaliveInterval = setInterval(() => {
-                if (this.sseConnections.has(sseId)) {
-                    try {
-                        res.write(': keepalive\n\n');
-                        console.log(`[Tunnel Server] Keepalive sent for ${sseId}`);
-                    }
-                    catch (error) {
-                        console.error(`[Tunnel Server] Error sending keepalive for ${sseId}:`, error);
-                        clearInterval(keepaliveInterval);
-                        this.sseConnections.delete(sseId);
-                    }
-                }
-                else {
-                    clearInterval(keepaliveInterval);
-                }
-            }, 5000);
-            // Store the SSE connection BEFORE notifying tunnel client
-            this.sseConnections.set(sseId, {
-                req,
-                res,
-                id: sseId,
-                tunnelId,
-                keepaliveInterval
-            });
-            console.log(`[Tunnel Server] SSE connection stored. Total connections: ${this.sseConnections.size}`);
-            console.log(`[Tunnel Server] Active SSE IDs: ${Array.from(this.sseConnections.keys()).join(', ')}`);
-            // Notify the tunnel client about the new SSE connection
-            const sseConnectionMessage = {
-                type: "sse_connection",
-                id: sseId,
-                path: req.url,
-                method: req.method, // Include HTTP method for POST tool calls
-                headers: req.headers,
-                body: req.method !== "GET" && req.body ? req.body.toString("base64") : undefined
-            };
-            console.log(`[Tunnel Server] Sending sse_connection message to tunnel client`);
-            try {
-                tunnel.ws.send(JSON.stringify(sseConnectionMessage));
-                console.log(`[Tunnel Server] sse_connection message sent successfully for ${sseId}`);
-            }
-            catch (sendError) {
-                console.error(`[Tunnel Server] FAILED to send sse_connection message for ${sseId}:`, sendError);
-                // Clean up the SSE connection if we can't notify the client
-                this.sseConnections.delete(sseId);
-                res.status(500).end();
-                return;
-            }
-            // Handle client disconnect
-            req.on('close', () => {
-                console.log(`[Tunnel Server] SSE client disconnected: ${sseId}`);
-                console.log(`[Tunnel Server] Connection was active for tunnel: ${tunnelId}`);
-                clearInterval(keepaliveInterval);
-                try {
-                    tunnel.ws.send(JSON.stringify({
-                        type: "sse_close",
-                        id: sseId
-                    }));
-                    console.log(`[Tunnel Server] Sent sse_close message for ${sseId}`);
-                }
-                catch (closeError) {
-                    console.error(`[Tunnel Server] Error sending sse_close message:`, closeError);
-                }
-                this.sseConnections.delete(sseId);
-                console.log(`[Tunnel Server] SSE connection removed. Remaining: ${this.sseConnections.size}`);
-            });
-            // Add error handler for the response
-            res.on('error', (error) => {
-                console.error(`[Tunnel Server] SSE response error for ${sseId}:`, error);
-                clearInterval(keepaliveInterval);
-                this.sseConnections.delete(sseId);
-            });
-            console.log(`[Tunnel Server] ====== SSE CONNECTION SETUP COMPLETE ======`);
-        }
-        catch (error) {
-            console.error(`[Tunnel Server] CRITICAL ERROR in handleSSERequest for ${sseId}:`, error);
+        // Set SSE headers with anti-buffering directives
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no', // Disable nginx buffering
+        });
+        // Flush headers immediately to establish SSE connection
+        // Without this, headers may be buffered, delaying connection setup
+        res.flushHeaders();
+        // Send initial connection event
+        res.write('\n');
+        // Flush the initial write
+        flushSSE(res);
+        // Store the SSE connection
+        this.sseConnections.set(sseId, {
+            req,
+            res,
+            id: sseId,
+            tunnelId
+        });
+        // Notify the tunnel client about the new SSE connection
+        tunnel.ws.send(JSON.stringify({
+            type: "sse_connection",
+            id: sseId,
+            path: req.url,
+            method: req.method, // Include HTTP method for POST tool calls
+            headers: req.headers,
+            body: req.method !== "GET" && req.body ? req.body.toString("base64") : undefined
+        }));
+        // Handle client disconnect
+        req.on('close', () => {
+            tunnel.ws.send(JSON.stringify({
+                type: "sse_close",
+                id: sseId
+            }));
             this.sseConnections.delete(sseId);
-            if (!res.headersSent) {
-                res.status(500).send('SSE setup failed');
-            }
-        }
+        });
     }
     removeTunnel(ws) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "",
   "main": "dist/index.js",
   "private": false,
@@ -19,7 +19,7 @@
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "^2.0.31",
+    "@dainprotocol/service-sdk": "^2.0.30",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/eventsource": "^3.0.0",