@dainprotocol/tunnel 1.1.25 → 1.1.26

package/dist/client/index.d.ts

@@ -13,12 +13,24 @@ declare class DainTunnel extends EventEmitter {
     private webSocketClients;
     private sseClients;
     private httpAgent;
+    private heartbeatInterval;
+    private readonly HEARTBEAT_INTERVAL;
     constructor(serverUrl: string, apiKey: string);
     /**
      * Sign a challenge using HMAC-SHA256
      * @private
      */
     private signChallenge;
+    /**
+     * Start client-side heartbeat to detect connection issues early
+     * @private
+     */
+    private startHeartbeat;
+    /**
+     * Stop the client-side heartbeat
+     * @private
+     */
+    private stopHeartbeat;
     start(port: number): Promise<string>;
     private connect;
     private requestChallenge;
@@ -28,6 +40,7 @@ declare class DainTunnel extends EventEmitter {
     private handleWebSocketMessage;
     private handleSSEConnection;
     private handleSSEClose;
+    private readonly REQUEST_TIMEOUT;
     private forwardRequest;
     private sendMessage;
     private attemptReconnect;

package/dist/client/index.js

@@ -21,6 +21,11 @@ class DainTunnel extends events_1.EventEmitter {
         this.reconnectDelay = 5000;
         this.webSocketClients = new Map();
         this.sseClients = new Map();
+        // Heartbeat interval for client-side liveness
+        this.heartbeatInterval = null;
+        this.HEARTBEAT_INTERVAL = 25000; // 25 seconds (less than server's 30s)
+        // Client-side timeout (less than server's 30s to respond before server times out)
+        this.REQUEST_TIMEOUT = 25000;
         // Parse API key to extract agentId and secret
         const parsed = (0, auth_1.parseAPIKey)(apiKey);
         if (!parsed) {
@@ -30,11 +35,12 @@ class DainTunnel extends events_1.EventEmitter {
         this.tunnelId = `${parsed.orgId}_${parsed.agentId}`; // orgId_agentId to prevent collisions
         this.secret = parsed.secret; // secret for HMAC signatures
         // High-frequency optimization: Create reusable HTTP agent with connection pooling
+        // Aligned with server's MAX_CONCURRENT_REQUESTS_PER_TUNNEL = 100
         this.httpAgent = new http_1.default.Agent({
             keepAlive: true,
             keepAliveMsecs: 30000, // Keep connections alive for 30s
-            maxSockets: 50, // Allow up to 50 concurrent connections to local service
-            maxFreeSockets: 10, // Keep up to 10 idle connections
+            maxSockets: 100, // Match server's concurrent request limit
+            maxFreeSockets: 20, // Keep more idle connections for burst traffic
         });
     }
     /**
@@ -46,12 +52,62 @@ class DainTunnel extends events_1.EventEmitter {
             .update(challenge)
             .digest('hex');
     }
+    /**
+     * Start client-side heartbeat to detect connection issues early
+     * @private
+     */
+    startHeartbeat() {
+        this.stopHeartbeat(); // Clear any existing heartbeat
+        this.heartbeatInterval = setInterval(() => {
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                try {
+                    this.ws.ping();
+                }
+                catch (error) {
+                    // Ping failed, connection might be dead
+                    this.emit("error", new Error("Heartbeat ping failed"));
+                }
+            }
+        }, this.HEARTBEAT_INTERVAL);
+    }
+    /**
+     * Stop the client-side heartbeat
+     * @private
+     */
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
     async start(port) {
         this.port = port;
         return this.connect();
     }
     async connect() {
         return new Promise((resolve, reject) => {
+            let resolved = false;
+            let connectionTimeoutId = null;
+            const cleanup = () => {
+                if (connectionTimeoutId) {
+                    clearTimeout(connectionTimeoutId);
+                    connectionTimeoutId = null;
+                }
+            };
+            const safeResolve = (value) => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(value);
+                }
+            };
+            const safeReject = (error) => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    reject(error);
+                }
+            };
             try {
                 this.ws = new ws_1.default(this.serverUrl);
                 this.ws.on("open", async () => {
@@ -67,21 +123,25 @@ class DainTunnel extends events_1.EventEmitter {
                             tunnelId: this.tunnelId,
                             apiKey: this.apiKey // Send API key for server validation
                         });
+                        // Start heartbeat after successful authentication
+                        this.startHeartbeat();
                         this.emit("connected");
                     }
                     catch (err) {
-                        reject(err);
+                        safeReject(err);
                     }
                 });
                 this.ws.on("message", (data) => {
                     try {
-                        this.handleMessage(JSON.parse(data), resolve);
+                        this.handleMessage(JSON.parse(data), safeResolve);
                     }
                     catch (err) {
-                        reject(err);
+                        safeReject(err);
                     }
                 });
                 this.ws.on("close", () => {
+                    // Stop heartbeat on disconnect
+                    this.stopHeartbeat();
                     // Clean up all active SSE connections
                     for (const [, client] of this.sseClients) {
                         try {
@@ -104,18 +164,26 @@ class DainTunnel extends events_1.EventEmitter {
                         this.attemptReconnect();
                     }
                     else {
-                        reject(new Error("Connection closed before tunnel established"));
+                        safeReject(new Error("Connection closed before tunnel established"));
                     }
                 });
                 this.ws.on("error", (error) => this.emit("error", error));
-                setTimeout(() => {
-                    if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-                        reject(new Error("Connection timeout"));
+                // Connection timeout with proper cleanup
+                connectionTimeoutId = setTimeout(() => {
+                    if (!resolved && (!this.ws || this.ws.readyState !== ws_1.default.OPEN)) {
+                        safeReject(new Error("Connection timeout"));
+                        // Close the WebSocket if it's still trying to connect
+                        if (this.ws) {
+                            try {
+                                this.ws.terminate();
+                            }
+                            catch (e) { /* ignore */ }
+                        }
                     }
                 }, 10000);
             }
             catch (err) {
-                reject(err);
+                safeReject(err);
             }
         });
     }
@@ -125,23 +193,39 @@ class DainTunnel extends events_1.EventEmitter {
                 reject(new Error("WebSocket is not connected"));
                 return;
             }
-            this.ws.send(JSON.stringify({ type: "challenge_request" }));
+            let resolved = false;
+            let timeoutId = null;
+            const cleanup = () => {
+                if (this.ws) {
+                    this.ws.removeListener("message", challengeHandler);
+                }
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+            };
             const challengeHandler = (message) => {
-                const data = JSON.parse(message);
-                if (data.type === "challenge") {
-                    if (this.ws) {
-                        this.ws.removeListener("message", challengeHandler);
+                try {
+                    const data = JSON.parse(message);
+                    if (data.type === "challenge" && !resolved) {
+                        resolved = true;
+                        cleanup();
+                        resolve(data.challenge);
                     }
-                    resolve(data.challenge);
+                }
+                catch (e) {
+                    // Ignore parse errors for non-challenge messages
                 }
             };
             this.ws.on("message", challengeHandler);
+            this.ws.send(JSON.stringify({ type: "challenge_request" }));
             // Add a timeout for the challenge request
-            setTimeout(() => {
-                if (this.ws) {
-                    this.ws.removeListener("message", challengeHandler);
+            timeoutId = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    reject(new Error("Challenge request timeout"));
                 }
-                reject(new Error("Challenge request timeout"));
             }, 5000);
         });
     }
@@ -176,6 +260,20 @@ class DainTunnel extends events_1.EventEmitter {
             this.emit("request_handled", { request, response });
         }
         catch (error) {
+            // Send error response back to server instead of just emitting an event
+            // This prevents 30-second timeouts when the local service is unreachable
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            const errorResponse = {
+                type: "response",
+                requestId: request.id,
+                status: 502, // Bad Gateway - indicates upstream error
+                headers: { "content-type": "application/json" },
+                body: Buffer.from(JSON.stringify({
+                    error: "Bad Gateway",
+                    message: `Failed to forward request to local service: ${errorMessage}`
+                })).toString("base64")
+            };
+            this.sendMessage(errorResponse);
             this.emit("request_error", { request, error });
         }
     }
@@ -271,10 +369,16 @@ class DainTunnel extends events_1.EventEmitter {
                 // Helper to process SSE events from buffer
                 const processBuffer = () => {
                     var _a;
+                    // FIX: Normalize CRLF to LF for cross-platform SSE compatibility
+                    // Some SSE implementations use \r\n\r\n instead of \n\n
+                    buffer = buffer.replace(/\r\n/g, '\n');
                     while (buffer.includes('\n\n')) {
                         const idx = buffer.indexOf('\n\n');
                         const msgData = buffer.substring(0, idx);
                         buffer = buffer.substring(idx + 2);
+                        // Skip empty messages and keepalive comments
+                        if (!msgData.trim() || msgData.startsWith(':'))
+                            continue;
                         let event = 'message', data = '';
                         for (const line of msgData.split('\n')) {
                             if (line.startsWith('event:'))
@@ -284,7 +388,8 @@ class DainTunnel extends events_1.EventEmitter {
                         }
                         if (data.endsWith('\n'))
                             data = data.slice(0, -1);
-                        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                        // Only send if we have actual data
+                        if (data && ((_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 }));
                         }
                     }
@@ -333,6 +438,28 @@ class DainTunnel extends events_1.EventEmitter {
     }
     forwardRequest(request) {
         return new Promise((resolve, reject) => {
+            let resolved = false;
+            let timeoutId = null;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+            };
+            const safeResolve = (response) => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(response);
+                }
+            };
+            const safeReject = (error) => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    reject(error);
+                }
+            };
             const options = {
                 hostname: 'localhost',
                 port: this.port,
@@ -340,6 +467,7 @@ class DainTunnel extends events_1.EventEmitter {
                 method: request.method,
                 headers: request.headers,
                 agent: this.httpAgent, // Use connection pooling
+                timeout: this.REQUEST_TIMEOUT, // Socket timeout
             };
             const req = http_1.default.request(options, (res) => {
                 let body = Buffer.from([]);
@@ -350,7 +478,7 @@ class DainTunnel extends events_1.EventEmitter {
                     const headers = { ...res.headers };
                     delete headers['transfer-encoding'];
                     delete headers['content-length'];
-                    resolve({
+                    safeResolve({
                         type: 'response',
                         requestId: request.id,
                         status: res.statusCode,
@@ -358,8 +486,21 @@ class DainTunnel extends events_1.EventEmitter {
                         body: body.toString('base64'),
                     });
                 });
+                res.on('error', safeReject);
             });
-            req.on('error', reject);
+            // Handle request timeout
+            req.on('timeout', () => {
+                req.destroy();
+                safeReject(new Error(`Request timeout after ${this.REQUEST_TIMEOUT}ms`));
+            });
+            req.on('error', safeReject);
+            // Additional safety timeout
+            timeoutId = setTimeout(() => {
+                if (!resolved) {
+                    req.destroy();
+                    safeReject(new Error(`Request timeout after ${this.REQUEST_TIMEOUT}ms`));
+                }
+            }, this.REQUEST_TIMEOUT);
             if (request.body && request.method !== 'GET') {
                 req.write(Buffer.from(request.body, 'base64'));
             }
@@ -388,6 +529,8 @@ class DainTunnel extends events_1.EventEmitter {
     async stop() {
         return new Promise(async (resolve) => {
             try {
+                // Stop heartbeat first
+                this.stopHeartbeat();
                 // Close all WebSocket clients
                 for (const [id, client] of this.webSocketClients.entries()) {
                     try {
@@ -422,6 +565,8 @@ class DainTunnel extends events_1.EventEmitter {
                     }
                     this.ws = null;
                 }
+                // Reset tunnel URL so reconnect doesn't happen
+                this.tunnelUrl = null;
                 // Destroy the HTTP agent to close pooled connections
                 if (this.httpAgent) {
                     this.httpAgent.destroy();

package/dist/server/index.d.ts

@@ -11,6 +11,10 @@ declare class DainTunnelServer {
     private wsConnections;
     private tunnelRequestCount;
     private readonly MAX_CONCURRENT_REQUESTS_PER_TUNNEL;
+    /**
+     * Safely send a message to a WebSocket, handling errors gracefully
+     */
+    private safeSend;
     constructor(hostname: string, port: number);
     private setupExpressRoutes;
     private setupWebSocketServer;

package/dist/server/index.js

@@ -16,34 +16,22 @@ let idCounter = 0;
 function fastId() {
     return `${Date.now().toString(36)}-${(idCounter++).toString(36)}-${(0, crypto_1.randomBytes)(4).toString('hex')}`;
 }
-/**
- * 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 {
-        // Node.js TCP sockets use cork/uncork for buffering control
-        // We uncork to force immediate transmission of buffered data
-        const socket = res.socket;
-        if (socket) {
-            // If socket is corked, uncork it to flush immediately
-            if (socket.uncork) {
-                socket.uncork();
-            }
-            // Disable Nagle's algorithm for low-latency streaming
-            if (socket.setNoDelay && !socket._noDelay) {
-                socket.setNoDelay(true);
+class DainTunnelServer {
+    /**
+     * Safely send a message to a WebSocket, handling errors gracefully
+     */
+    safeSend(ws, data) {
+        try {
+            if (ws.readyState === ws_1.default.OPEN) {
+                ws.send(JSON.stringify(data));
+                return true;
             }
         }
+        catch (error) {
+            console.error("[Tunnel] SafeSend error:", error);
+        }
+        return false;
     }
-    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;
         this.port = port;
@@ -90,6 +78,29 @@ class DainTunnelServer {
         this.setupWebSocketServer();
     }
     setupExpressRoutes() {
+        // Health check endpoint for App Platform / load balancers
+        // Skip WebSocket upgrade requests - let WebSocket server handle them
+        this.app.get("/", (req, res, next) => {
+            if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') {
+                return next();
+            }
+            res.status(200).json({
+                status: "healthy",
+                tunnels: this.tunnels.size,
+                pendingRequests: this.pendingRequests.size,
+                sseConnections: this.sseConnections.size,
+                wsConnections: this.wsConnections.size,
+                uptime: process.uptime()
+            });
+        });
+        this.app.get("/health", (req, res) => {
+            res.status(200).json({
+                status: "ok",
+                tunnels: this.tunnels.size,
+                pendingRequests: this.pendingRequests.size,
+                uptime: process.uptime()
+            });
+        });
         // Generic route handler for all tunnel requests
         this.app.use("/:tunnelId", this.handleRequest.bind(this));
     }
@@ -161,46 +172,56 @@ class DainTunnelServer {
         }
         // Create a WebSocket connection ID
         const wsConnectionId = fastId();
-        // Store this connection
+        // Store this connection with tunnelId for proper cleanup
         this.wsConnections.set(wsConnectionId, {
             clientSocket: ws,
             id: wsConnectionId,
             path: remainingPath,
-            headers: req.headers
+            headers: req.headers,
+            tunnelId: tunnelId
         });
         // Notify tunnel client about the new WebSocket connection
-        tunnel.ws.send(JSON.stringify({
+        this.safeSend(tunnel.ws, {
             type: "websocket_connection",
             id: wsConnectionId,
             path: remainingPath,
             headers: req.headers
-        }));
+        });
         // Handle messages from the client
         ws.on("message", (data) => {
-            tunnel.ws.send(JSON.stringify({
-                type: "websocket",
-                id: wsConnectionId,
-                event: "message",
-                data: data.toString('base64')
-            }));
+            const currentTunnel = this.tunnels.get(tunnelId);
+            if (currentTunnel) {
+                this.safeSend(currentTunnel.ws, {
+                    type: "websocket",
+                    id: wsConnectionId,
+                    event: "message",
+                    data: data.toString('base64')
+                });
+            }
         });
         // Handle client disconnection
         ws.on("close", () => {
-            tunnel.ws.send(JSON.stringify({
-                type: "websocket",
-                id: wsConnectionId,
-                event: "close"
-            }));
+            const currentTunnel = this.tunnels.get(tunnelId);
+            if (currentTunnel) {
+                this.safeSend(currentTunnel.ws, {
+                    type: "websocket",
+                    id: wsConnectionId,
+                    event: "close"
+                });
+            }
             this.wsConnections.delete(wsConnectionId);
         });
         // Handle errors
         ws.on("error", (error) => {
-            tunnel.ws.send(JSON.stringify({
-                type: "websocket",
-                id: wsConnectionId,
-                event: "error",
-                data: error.message
-            }));
+            const currentTunnel = this.tunnels.get(tunnelId);
+            if (currentTunnel) {
+                this.safeSend(currentTunnel.ws, {
+                    type: "websocket",
+                    id: wsConnectionId,
+                    event: "error",
+                    data: error.message
+                });
+            }
         });
     }
     handleChallengeRequest(ws) {
@@ -259,29 +280,49 @@ class DainTunnelServer {
             this.tunnels.set(tunnelId, { id: tunnelId, ws });
             // Save tunnel ID on the WebSocket object for easy lookup on close
             ws.tunnelId = tunnelId;
-            // Add a periodic ping to keep the connection alive (silent - no logging)
+            // Liveness detection: track pong responses
+            let isAlive = true;
+            let missedPongs = 0;
+            const MAX_MISSED_PONGS = 2; // Allow 2 missed pongs before considering dead
+            // Handle pong responses to verify connection is alive
+            ws.on("pong", () => {
+                isAlive = true;
+                missedPongs = 0;
+            });
+            // Add a periodic ping to keep the connection alive and detect dead connections
             const intervalId = setInterval(() => {
-                if (this.tunnels.has(tunnelId)) {
-                    const tunnel = this.tunnels.get(tunnelId);
-                    if (tunnel && tunnel.ws === ws && ws.readyState === ws_1.default.OPEN) {
-                        try {
-                            ws.ping();
-                        }
-                        catch (error) {
-                            clearInterval(intervalId);
-                        }
+                if (!this.tunnels.has(tunnelId)) {
+                    clearInterval(intervalId);
+                    return;
+                }
+                const tunnel = this.tunnels.get(tunnelId);
+                if (!tunnel || tunnel.ws !== ws || ws.readyState !== ws_1.default.OPEN) {
+                    clearInterval(intervalId);
+                    if (tunnel && tunnel.ws === ws) {
+                        this.tunnels.delete(tunnelId);
                     }
-                    else {
+                    return;
+                }
+                // Check if previous ping was acknowledged
+                if (!isAlive) {
+                    missedPongs++;
+                    if (missedPongs >= MAX_MISSED_PONGS) {
+                        console.log(`[Tunnel] ${tunnelId} failed liveness check (${missedPongs} missed pongs), terminating`);
                         clearInterval(intervalId);
-                        if (tunnel && tunnel.ws === ws) {
-                            this.tunnels.delete(tunnelId);
-                        }
+                        ws.terminate(); // Force close without waiting for close handshake
+                        return;
                     }
                 }
-                else {
+                // Send new ping and mark as waiting for pong
+                isAlive = false;
+                try {
+                    ws.ping();
+                }
+                catch (error) {
                     clearInterval(intervalId);
+                    ws.terminate();
                 }
-            }, 30000); // Ping every 30 seconds (reduced frequency)
+            }, 30000); // Ping every 30 seconds
             // Store the interval ID on the WebSocket object so we can clean it up
             ws.keepAliveInterval = intervalId;
             ws.on("close", () => clearInterval(intervalId));
@@ -299,10 +340,12 @@ class DainTunnelServer {
         }
     }
     handleResponseMessage(data) {
+        console.log(`[Response] Received for: ${data.requestId}, status: ${data.status}`);
         const pendingRequest = this.pendingRequests.get(data.requestId);
         if (pendingRequest) {
             const { res, startTime, tunnelId, timeoutId } = pendingRequest;
             const endTime = Date.now();
+            console.log(`[Response] Completed in ${endTime - startTime}ms`);
             // Clear the timeout since we received a response
             if (timeoutId) {
                 clearTimeout(timeoutId);
@@ -323,58 +366,59 @@ class DainTunnelServer {
         }
     }
     handleSSEMessage(data) {
+        console.log(`[SSE] Received message: id=${data.id}, event=${data.event}`);
         const connection = this.sseConnections.get(data.id);
-        if (!connection)
+        if (!connection) {
+            console.log(`[SSE] Connection not found for id: ${data.id}`);
             return;
+        }
         const { res, tunnelId } = connection;
-        const conn = connection;
         // Skip 'connected' event - we already wrote headers
-        if (data.event === 'connected')
+        if (data.event === 'connected') {
+            console.log(`[SSE] Received 'connected' event, skipping`);
             return;
-        // Handle close event
+        }
+        // Handle close event - end the response and cleanup
         if (data.event === 'close') {
-            const tunnel = this.tunnels.get(tunnelId);
-            if (tunnel)
-                tunnel.ws.send(JSON.stringify({ type: "sse_close", id: data.id }));
-            if (!conn.clientDisconnected && res.writable) {
-                try {
-                    res.end();
-                }
-                catch (_a) { }
+            try {
+                res.end();
             }
+            catch (_a) { }
             this.cleanupSSEConnection(data.id, tunnelId);
             return;
         }
-        // Handle error - send as SSE error event (headers already written)
+        // Handle error event
         if (data.event === 'error') {
-            if (!conn.clientDisconnected && res.writable) {
-                try {
-                    res.write(`event: error\ndata: ${data.data}\n\n`);
-                    flushSSE(res);
-                    res.end();
-                }
-                catch (_b) { }
+            try {
+                res.write(`event: error\ndata: ${data.data}\n\n`);
+                res.end();
             }
+            catch (_b) { }
             this.cleanupSSEConnection(data.id, tunnelId);
             return;
         }
-        // Skip if client disconnected
-        if (conn.clientDisconnected || !res.writable) {
-            conn.clientDisconnected = true;
-            return;
-        }
-        // Forward SSE event
+        // Forward SSE event to client
         try {
-            if (data.event)
+            if (data.event) {
                 res.write(`event: ${data.event}\n`);
-            res.write(`data: ${data.data.replace(/\n/g, '\ndata: ')}\n\n`);
-            flushSSE(res);
+            }
+            // Split data by newlines and send each line with data: prefix
+            const dataLines = data.data.split('\n');
+            for (const line of dataLines) {
+                res.write(`data: ${line}\n`);
+            }
+            res.write('\n');
         }
         catch (_c) {
-            conn.clientDisconnected = true;
+            // Client disconnected
+            this.cleanupSSEConnection(data.id, tunnelId);
         }
     }
     cleanupSSEConnection(id, tunnelId) {
+        const connection = this.sseConnections.get(id);
+        if (connection === null || connection === void 0 ? void 0 : connection.keepAliveInterval) {
+            clearInterval(connection.keepAliveInterval);
+        }
         const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
         this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
         this.sseConnections.delete(id);
@@ -404,7 +448,9 @@ class DainTunnelServer {
         }
     }
     async handleRequest(req, res) {
+        var _a;
         const tunnelId = req.params.tunnelId;
+        console.log(`[Request] ${req.method} /${tunnelId}${req.url}, Accept: ${(_a = req.headers.accept) === null || _a === void 0 ? void 0 : _a.substring(0, 30)}`);
         // 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
@@ -420,8 +466,18 @@ class DainTunnelServer {
             }
         }
         if (!tunnel) {
-            return res.status(404).send("Tunnel not found");
+            const available = Array.from(this.tunnels.keys());
+            console.log(`[Request] Tunnel not found: ${tunnelId}, available tunnels: [${available.join(', ')}], count: ${available.length}`);
+            // Decrement counter since we incremented speculatively
+            const count = this.tunnelRequestCount.get(tunnelId) || 1;
+            this.tunnelRequestCount.set(tunnelId, Math.max(0, count - 1));
+            return res.status(502).json({
+                error: "Bad Gateway",
+                message: `Tunnel "${tunnelId}" not connected. The service may be offline or reconnecting.`,
+                availableTunnels: available.length
+            });
         }
+        console.log(`[Request] Tunnel found: ${tunnelId}, wsState: ${tunnel.ws.readyState}`);
         // High-frequency optimization: Check WebSocket buffer and apply backpressure
         if (tunnel.ws.bufferedAmount > 1024 * 1024) {
             return res.status(503).json({ error: "Service Unavailable", message: "Tunnel high load" });
@@ -453,60 +509,87 @@ class DainTunnelServer {
             }
         }, REQUEST_TIMEOUT);
         this.pendingRequests.set(requestId, { res, startTime, tunnelId, timeoutId });
-        tunnel.ws.send(JSON.stringify({
+        console.log(`[Request] Sending to tunnel client: ${requestId}, wsState: ${tunnel.ws.readyState}, buffered: ${tunnel.ws.bufferedAmount}`);
+        // FIX: Only include body if it has actual content (not empty buffer)
+        // Empty buffer is truthy but should be treated as no body
+        const hasBody = req.method !== "GET" && req.method !== "HEAD" &&
+            req.body && Buffer.isBuffer(req.body) && req.body.length > 0;
+        const sent = this.safeSend(tunnel.ws, {
             type: "request",
             id: requestId,
             method: req.method,
             path: req.url,
             headers: req.headers,
-            body: req.method !== "GET" && req.method !== "HEAD" && req.body
-                ? req.body.toString("base64")
-                : undefined,
-        }));
+            body: hasBody ? req.body.toString("base64") : undefined,
+        });
+        console.log(`[Request] Sent to tunnel client: ${sent}`);
+        // If send failed, clean up immediately
+        if (!sent) {
+            clearTimeout(timeoutId);
+            this.pendingRequests.delete(requestId);
+            const count = this.tunnelRequestCount.get(tunnelId) || 1;
+            this.tunnelRequestCount.set(tunnelId, Math.max(0, count - 1));
+            if (!res.headersSent) {
+                res.status(502).json({ error: "Bad Gateway", message: "Tunnel connection lost" });
+            }
+        }
     }
     handleSSERequest(req, res, tunnelId, tunnel) {
+        var _a;
         const sseId = fastId();
-        // Optimize TCP for streaming
-        const socket = req.socket || req.connection;
-        if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
-            socket.setNoDelay(true);
-        // Write SSE headers immediately to keep browser connection alive
+        console.log(`[SSE] New request: ${sseId}, tunnel: ${tunnelId}, path: ${req.url}`);
+        // Setup SSE headers
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
-            'X-Accel-Buffering': 'no',
+            'Connection': 'keep-alive'
         });
-        res.flushHeaders();
-        res.write(': connected\n\n');
-        flushSSE(res);
+        // Flush headers and send immediate keepalive to establish the stream
+        (_a = res.flushHeaders) === null || _a === void 0 ? void 0 : _a.call(res);
+        res.write(':keepalive\n\n');
+        // Send periodic keep-alive comments to prevent proxy timeouts
+        const keepAliveIntervalMs = 5000;
+        const keepAliveInterval = setInterval(() => {
+            try {
+                if (!res.writableEnded) {
+                    res.write(':keepalive\n\n');
+                }
+                else {
+                    clearInterval(keepAliveInterval);
+                }
+            }
+            catch (_a) {
+                clearInterval(keepAliveInterval);
+            }
+        }, keepAliveIntervalMs);
+        // Store the SSE connection
         this.sseConnections.set(sseId, {
-            req, res, id: sseId, tunnelId,
-            clientDisconnected: false
+            req, res, id: sseId, tunnelId, keepAliveInterval
         });
-        // Forward to tunnel client
-        tunnel.ws.send(JSON.stringify({
+        // FIX: Only include body if it has actual content (not empty buffer)
+        const hasBody = req.method !== "GET" && req.body &&
+            Buffer.isBuffer(req.body) && req.body.length > 0;
+        // Notify the tunnel client about the new SSE connection
+        const sent = this.safeSend(tunnel.ws, {
             type: "sse_connection",
             id: sseId,
             path: req.url,
             method: req.method,
             headers: req.headers,
-            body: req.method !== "GET" && req.body ? req.body.toString("base64") : undefined
-        }));
-        // 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;
-                setTimeout(() => {
-                    if (this.sseConnections.has(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);
-            }
+            body: hasBody ? req.body.toString("base64") : undefined
+        });
+        console.log(`[SSE] Sent sse_connection to tunnel client: ${sent}`);
+        if (!sent) {
+            console.log(`[SSE] Failed to send sse_connection, cleaning up`);
+            this.cleanupSSEConnection(sseId, tunnelId);
+            res.end();
+            return;
+        }
+        // Handle client disconnect
+        req.on('close', () => {
+            console.log(`[SSE] Client disconnected: ${sseId}`);
+            this.safeSend(tunnel.ws, { type: "sse_close", id: sseId });
+            this.cleanupSSEConnection(sseId, tunnelId);
         });
     }
     removeTunnel(ws) {
@@ -549,6 +632,10 @@ class DainTunnelServer {
                 // Close all SSE connections associated with this tunnel
                 for (const [sseId, sseConnection] of this.sseConnections.entries()) {
                     if (sseConnection.tunnelId === removedTunnelId) {
+                        // Clear keepalive interval to prevent memory leak
+                        if (sseConnection.keepAliveInterval) {
+                            clearInterval(sseConnection.keepAliveInterval);
+                        }
                         try {
                             sseConnection.res.end();
                         }
@@ -558,7 +645,7 @@ class DainTunnelServer {
                 }
                 // Close all WebSocket connections associated with this tunnel
                 for (const [wsId, wsConnection] of this.wsConnections.entries()) {
-                    if (wsConnection.path.startsWith(`/${removedTunnelId}/`)) {
+                    if (wsConnection.tunnelId === removedTunnelId) {
                         try {
                             wsConnection.clientSocket.close(1001, "Tunnel closed");
                         }

package/dist/server/start.js

@@ -7,6 +7,15 @@ const index_1 = __importDefault(require("./index"));
 const dotenv_1 = __importDefault(require("dotenv"));
 // Load environment variables from .env file
 dotenv_1.default.config();
+// Handle uncaught exceptions to prevent server crashes
+process.on('uncaughtException', (error) => {
+    console.error('[Fatal] Uncaught exception:', error);
+    // Don't exit - try to keep serving
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('[Fatal] Unhandled rejection at:', promise, 'reason:', reason);
+    // Don't exit - try to keep serving
+});
 const port = parseInt(process.env.PORT || '3000', 10);
 const hostname = process.env.HOSTNAME || 'localhost';
 const server = new index_1.default(hostname, port);
@@ -19,3 +28,13 @@ server.start()
     console.error('Failed to start DainTunnel Server:', error);
     process.exit(1);
 });
+// Graceful shutdown on SIGTERM (sent by App Platform)
+process.on('SIGTERM', () => {
+    console.log('[Server] SIGTERM received, shutting down gracefully...');
+    server.stop().then(() => {
+        console.log('[Server] Graceful shutdown complete');
+        process.exit(0);
+    }).catch(() => {
+        process.exit(1);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.1.25",
+  "version": "1.1.26",
   "description": "",
   "main": "dist/index.js",
   "private": false,
@@ -13,13 +13,14 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "prepublishOnly": "npm run build && npm run build:types",
+    "start": "node dist/server/start.js",
     "start-server": "ts-node src/server/start.ts"
   },
   "keywords": [],
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "2.0.59",
+    "@dainprotocol/service-sdk": "2.0.75",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/eventsource": "^3.0.0",