@dainprotocol/tunnel 1.1.6 → 1.1.7

package/dist/client/index.js

@@ -136,6 +136,7 @@ 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;
@@ -149,14 +150,18 @@ 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) {
@@ -250,6 +255,11 @@ 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
@@ -260,8 +270,13 @@ 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',
@@ -272,17 +287,22 @@ 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 received (${chunkStr.length} bytes):`, chunkStr.substring(0, 200));
+                    console.log(`[Tunnel Client] SSE chunk ${++eventCount} received (${chunkStr.length} bytes)`);
+                    console.log(`[Tunnel Client] Chunk preview:`, 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';
@@ -300,18 +320,27 @@ class DainTunnel extends events_1.EventEmitter {
                             data = data.substring(0, data.length - 1);
                         }
                         // Forward to server
-                        console.log(`[Tunnel Client] Forwarding SSE event: ${event}, data length: ${data.length}`);
+                        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}`);
                         if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                            this.ws.send(JSON.stringify({
+                            const forwardMessage = {
                                 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',
@@ -319,10 +348,15 @@ 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',
@@ -334,15 +368,20 @@ class DainTunnel extends events_1.EventEmitter {
             });
             // Write request body for POST requests
             if (message.body && message.method !== 'GET') {
-                req.write(Buffer.from(message.body, 'base64'));
+                const bodyBuffer = Buffer.from(message.body, 'base64');
+                console.log(`[Tunnel Client] Writing request body (${bodyBuffer.length} bytes)`);
+                req.write(bodyBuffer);
             }
             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('Error establishing SSE connection:', error);
+            console.error(`[Tunnel Client] CRITICAL ERROR establishing SSE connection:`, error);
             if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                 this.ws.send(JSON.stringify({
                     type: 'sse',
@@ -354,11 +393,17 @@ 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

@@ -300,21 +300,54 @@ 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.log(`SSE connection not found: ${data.id}`);
+            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`);
             return;
         }
+        console.log(`[Tunnel Server] ✓ SSE connection found for ${data.id}`);
         const { res } = connection;
-        if (data.event) {
-            res.write(`event: ${data.event}\n`);
+        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`);
+            // 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 ======`);
         }
-        // Write data as-is (don't split - data is already properly formatted)
-        res.write(`data: ${data.data}\n`);
-        res.write('\n');
-        // Check if this is a "close" event
-        if (data.event === 'close') {
-            res.end();
+        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);
+            }
             this.sseConnections.delete(data.id);
         }
     }
@@ -346,9 +379,14 @@ 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;
@@ -366,8 +404,12 @@ class DainTunnelServer {
             console.log(`Tunnel not found after retries: ${tunnelId}`);
             return res.status(404).send("Tunnel not found");
         }
-        // Check for SSE request
-        if (req.headers.accept && req.headers.accept.includes('text/event-stream')) {
+        // 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`);
             return this.handleSSERequest(req, res, tunnelId, tunnel);
         }
         // Handle regular HTTP request
@@ -390,37 +432,118 @@ class DainTunnelServer {
     handleSSERequest(req, res, tunnelId, tunnel) {
         // Setup SSE connection
         const sseId = (0, uuid_1.v4)();
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive'
-        });
-        // Send initial connection event
-        res.write('\n');
-        // 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
-            }));
+        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);
             this.sseConnections.delete(sseId);
-        });
+            if (!res.headersSent) {
+                res.status(500).send('SSE setup failed');
+            }
+        }
     }
     removeTunnel(ws) {
         try {

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "",
   "main": "dist/index.js",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "tsc",
+    "build:types": "tsc --emitDeclarationOnly",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run build && npm run build:types",
+    "start-server": "ts-node src/server/start.ts"
+  },
   "keywords": [],
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "^1.3.6",
+    "@dainprotocol/service-sdk": "^2.0.31",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/eventsource": "^3.0.0",
@@ -68,12 +76,5 @@
         "./dist/server/*.d.ts"
       ]
     }
-  },
-  "scripts": {
-    "build": "tsc",
-    "build:types": "tsc --emitDeclarationOnly",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "start-server": "ts-node src/server/start.ts"
   }
-}
+}