@dainprotocol/tunnel 1.1.14 → 1.1.17

package/dist/client/index.d.ts

@@ -12,6 +12,7 @@ declare class DainTunnel extends EventEmitter {
     private secret;
     private webSocketClients;
     private sseClients;
+    private httpAgent;
     constructor(serverUrl: string, apiKey: string);
     /**
      * Sign a challenge using HMAC-SHA256

package/dist/client/index.js

@@ -29,6 +29,13 @@ class DainTunnel extends events_1.EventEmitter {
         this.apiKey = apiKey;
         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
+        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
+        });
     }
     /**
      * Sign a challenge using HMAC-SHA256
@@ -46,10 +53,8 @@ class DainTunnel extends events_1.EventEmitter {
     async connect() {
         return new Promise((resolve, reject) => {
             try {
-                console.log(`Connecting to WebSocket server: ${this.serverUrl}`);
                 this.ws = new ws_1.default(this.serverUrl);
                 this.ws.on("open", async () => {
-                    console.log('WebSocket connection opened');
                     this.reconnectAttempts = 0;
                     try {
                         const challenge = await this.requestChallenge();
@@ -65,46 +70,51 @@ class DainTunnel extends events_1.EventEmitter {
                         this.emit("connected");
                     }
                     catch (err) {
-                        console.error('Error during challenge-response:', err);
                         reject(err);
                     }
                 });
                 this.ws.on("message", (data) => {
                     try {
-                        const message = JSON.parse(data);
-                        this.handleMessage(message, resolve);
+                        this.handleMessage(JSON.parse(data), resolve);
                     }
                     catch (err) {
-                        console.error('Error handling message:', err);
                         reject(err);
                     }
                 });
                 this.ws.on("close", () => {
-                    console.log('WebSocket connection closed');
+                    // Clean up all active SSE connections
+                    for (const [, client] of this.sseClients) {
+                        try {
+                            client.destroy();
+                        }
+                        catch (e) { /* ignore */ }
+                    }
+                    this.sseClients.clear();
+                    // Clean up all WebSocket clients
+                    for (const [, client] of this.webSocketClients) {
+                        try {
+                            if (client.readyState === ws_1.default.OPEN)
+                                client.close(1001);
+                        }
+                        catch (e) { /* ignore */ }
+                    }
+                    this.webSocketClients.clear();
                     if (this.tunnelUrl) {
                         this.emit("disconnected");
                         this.attemptReconnect();
                     }
                     else {
-                        // If we haven't received a tunnelUrl yet, just reject
-                        reject(new Error("Connection closed before tunnel was established"));
+                        reject(new Error("Connection closed before tunnel established"));
                     }
                 });
-                this.ws.on("error", (error) => {
-                    // Prevent unhandled error events
-                    // Don't reject here, the close handler will be called after an error
-                    this.emit("error", error);
-                });
-                // Add a timeout to reject the promise if connection takes too long
+                this.ws.on("error", (error) => this.emit("error", error));
                 setTimeout(() => {
                     if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-                        const timeoutError = new Error("Connection timeout");
-                        reject(timeoutError);
+                        reject(new Error("Connection timeout"));
                     }
                 }, 10000);
             }
             catch (err) {
-                console.error('Error creating WebSocket:', err);
                 reject(err);
             }
         });
@@ -170,65 +180,37 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     handleWebSocketConnection(message) {
+        var _a;
         try {
-            console.log(`Creating local WebSocket connection to: ws://localhost:${this.port}${message.path}`);
-            // Create a WebSocket connection to the local server
             const client = new ws_1.default(`ws://localhost:${this.port}${message.path}`, {
                 headers: message.headers
             });
-            // Store the client
             this.webSocketClients.set(message.id, client);
-            // Handle connection open
-            client.on('open', () => {
-                console.log(`Local WebSocket connection opened: ${message.id}`);
-            });
-            // Handle messages from the local server
             client.on('message', (data) => {
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.send(JSON.stringify({
-                        type: 'websocket',
-                        id: message.id,
-                        event: 'message',
-                        data: data.toString('base64')
-                    }));
+                var _a;
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'websocket', id: message.id, event: 'message', data: data.toString('base64') }));
                 }
             });
-            // Handle close
             client.on('close', () => {
-                console.log(`Local WebSocket connection closed: ${message.id}`);
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.send(JSON.stringify({
-                        type: 'websocket',
-                        id: message.id,
-                        event: 'close'
-                    }));
+                var _a;
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'websocket', id: message.id, event: 'close' }));
                 }
                 this.webSocketClients.delete(message.id);
             });
-            // Handle errors
             client.on('error', (error) => {
-                console.error(`Local WebSocket connection error: ${message.id}`, error.message);
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.send(JSON.stringify({
-                        type: 'websocket',
-                        id: message.id,
-                        event: 'error',
-                        data: error.message
-                    }));
+                var _a;
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'websocket', id: message.id, event: 'error', data: error.message }));
                 }
                 this.webSocketClients.delete(message.id);
             });
             this.emit("websocket_connection", { id: message.id, path: message.path });
         }
         catch (error) {
-            console.error('Error establishing WebSocket connection:', error);
-            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                this.ws.send(JSON.stringify({
-                    type: 'websocket',
-                    id: message.id,
-                    event: 'error',
-                    data: error.message
-                }));
+            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'websocket', id: message.id, event: 'error', data: error.message }));
             }
         }
     }
@@ -250,134 +232,80 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     handleSSEConnection(message) {
+        var _a;
         try {
-            console.log(`[SSE E2E] Client: Establishing SSE connection ${message.id} to localhost:${this.port}${message.path}`);
-            // Create an EventSource-like stream to the local server
-            // Since Node.js doesn't have a built-in EventSource, we'll use HTTP
             const options = {
                 hostname: 'localhost',
                 port: this.port,
                 path: message.path,
-                method: message.method || 'GET', // Use provided method (supports POST tool calls)
+                method: message.method || 'GET',
                 headers: message.headers,
+                agent: this.httpAgent,
             };
             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}`);
-                    if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                        this.ws.send(JSON.stringify({
-                            type: 'sse',
-                            id: message.id,
-                            event: 'error',
-                            data: `Server responded with status code ${res.statusCode}`
-                        }));
+                    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;
                 }
-                // Optimize socket for low-latency streaming
                 const socket = res.socket || res.connection;
-                if (socket && socket.setNoDelay) {
-                    socket.setNoDelay(true); // Disable Nagle's algorithm
-                }
-                console.log(`[SSE E2E] Client: Service accepted SSE connection ${message.id}, streaming started`);
-                // Process SSE stream
+                if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
+                    socket.setNoDelay(true);
                 let buffer = '';
-                let eventCount = 0;
                 res.on('data', (chunk) => {
-                    const chunkStr = chunk.toString();
-                    buffer += chunkStr;
-                    // Process complete SSE messages
+                    var _a;
+                    buffer += chunk.toString();
                     while (buffer.includes('\n\n')) {
-                        const messageEndIndex = buffer.indexOf('\n\n');
-                        const messageData = buffer.substring(0, messageEndIndex);
-                        buffer = buffer.substring(messageEndIndex + 2);
-                        // Parse the SSE message
-                        const lines = messageData.split('\n');
-                        let event = 'message';
-                        let data = '';
-                        for (const line of lines) {
-                            if (line.startsWith('event:')) {
+                        const idx = buffer.indexOf('\n\n');
+                        const msgData = buffer.substring(0, idx);
+                        buffer = buffer.substring(idx + 2);
+                        let event = 'message', data = '';
+                        for (const line of msgData.split('\n')) {
+                            if (line.startsWith('event:'))
                                 event = line.substring(6).trim();
-                            }
-                            else if (line.startsWith('data:')) {
+                            else if (line.startsWith('data:'))
                                 data += line.substring(5).trim() + '\n';
-                            }
-                        }
-                        // Remove trailing newline
-                        if (data.endsWith('\n')) {
-                            data = data.substring(0, data.length - 1);
                         }
-                        eventCount++;
-                        // Only log key events (not every progress update)
-                        if (event === 'error' || event === 'close' || event === 'end' || eventCount === 1) {
-                            console.log(`[SSE E2E] Client→Server: Forwarding event="${event}" for ${message.id} (total events: ${eventCount})`);
-                        }
-                        // Forward to server
-                        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                            this.ws.send(JSON.stringify({
-                                type: 'sse',
-                                id: message.id,
-                                event,
-                                data
-                            }));
+                        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) {
+                            this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event, data }));
                         }
                     }
                 });
                 res.on('end', () => {
-                    console.log(`[SSE E2E] Client: Service stream ended for ${message.id} (total events sent: ${eventCount})`);
-                    if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                        this.ws.send(JSON.stringify({
-                            type: 'sse',
-                            id: message.id,
-                            event: 'close',
-                            data: 'Connection closed'
-                        }));
+                    var _a;
+                    if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                        this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'close', data: 'Connection closed' }));
                     }
                 });
             });
             req.on('error', (error) => {
-                console.log(`[SSE E2E] Client: ❌ Request error for ${message.id}: ${error.message}`);
-                if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                    this.ws.send(JSON.stringify({
-                        type: 'sse',
-                        id: message.id,
-                        event: 'error',
-                        data: error.message
-                    }));
+                var _a;
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'sse', id: message.id, event: 'error', data: error.message }));
                 }
             });
-            // Write request body for POST requests
-            if (message.body && message.method !== 'GET') {
+            if (message.body && message.method !== 'GET')
                 req.write(Buffer.from(message.body, 'base64'));
-            }
             req.end();
-            // Store a reference to abort the connection later if needed
             this.sseClients.set(message.id, req);
             this.emit("sse_connection", { id: message.id, path: message.path });
         }
         catch (error) {
-            console.error(`[SSE E2E] Client: ❌ Error establishing SSE connection ${message.id}:`, error);
-            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-                this.ws.send(JSON.stringify({
-                    type: 'sse',
-                    id: message.id,
-                    event: 'error',
-                    data: 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) {
-            // Abort the request if it's still active
             client.destroy();
             this.sseClients.delete(message.id);
-            console.log(`[SSE E2E] Client: Destroyed local service connection for ${message.id}`);
-        }
-        else {
-            console.log(`[SSE E2E] Client: No active connection found for ${message.id} (already cleaned up)`);
         }
     }
     forwardRequest(request) {
@@ -388,6 +316,7 @@ class DainTunnel extends events_1.EventEmitter {
                 path: request.path,
                 method: request.method,
                 headers: request.headers,
+                agent: this.httpAgent, // Use connection pooling
             };
             const req = http_1.default.request(options, (res) => {
                 let body = Buffer.from([]);
@@ -422,25 +351,14 @@ class DainTunnel extends events_1.EventEmitter {
     attemptReconnect() {
         if (this.reconnectAttempts < this.maxReconnectAttempts) {
             this.reconnectAttempts++;
-            console.log(`Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
             setTimeout(async () => {
                 try {
                     await this.connect();
-                    // If the connect succeeds but we don't have a tunnelUrl yet, we're still initializing
-                    if (!this.tunnelUrl) {
-                        console.log('Reconnected but tunnelUrl not set. Waiting for tunnel URL...');
-                    }
-                    else {
-                        console.log(`Reconnected successfully. Tunnel URL: ${this.tunnelUrl}`);
-                    }
-                }
-                catch (error) {
-                    console.error(`Reconnection attempt ${this.reconnectAttempts} failed:`, error);
                 }
+                catch (error) { /* ignore */ }
             }, this.reconnectDelay);
         }
         else {
-            console.log('Maximum reconnection attempts reached');
             this.emit("max_reconnect_attempts");
         }
     }
@@ -481,6 +399,10 @@ class DainTunnel extends events_1.EventEmitter {
                     }
                     this.ws = null;
                 }
+                // Destroy the HTTP agent to close pooled connections
+                if (this.httpAgent) {
+                    this.httpAgent.destroy();
+                }
                 // Wait for all connections to close properly
                 await new Promise(resolve => setTimeout(resolve, 500));
                 resolve();

package/dist/server/index.d.ts

@@ -9,6 +9,8 @@ declare class DainTunnelServer {
     private challenges;
     private sseConnections;
     private wsConnections;
+    private tunnelRequestCount;
+    private readonly MAX_CONCURRENT_REQUESTS_PER_TUNNEL;
     constructor(hostname: string, port: number);
     private setupExpressRoutes;
     private setupWebSocketServer;

package/dist/server/index.js

@@ -6,12 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
 const ws_1 = __importDefault(require("ws"));
-const uuid_1 = require("uuid");
 const body_parser_1 = __importDefault(require("body-parser"));
-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");
+// High-frequency optimization: Fast ID generation using crypto.randomBytes
+// ~10x faster than uuid v4 for high-frequency scenarios
+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
@@ -48,30 +52,40 @@ class DainTunnelServer {
         this.challenges = new Map();
         this.sseConnections = new Map();
         this.wsConnections = new Map();
+        // High-frequency optimization: Track active request count per tunnel for backpressure
+        this.tunnelRequestCount = new Map();
+        this.MAX_CONCURRENT_REQUESTS_PER_TUNNEL = 100;
         this.app = (0, express_1.default)();
         this.server = http_1.default.createServer(this.app);
+        // High-frequency optimization: Configure server for better throughput
+        this.server.keepAliveTimeout = 65000; // Keep connections alive longer (default 5s)
+        this.server.headersTimeout = 66000; // Must be higher than keepAliveTimeout
+        this.server.maxHeadersCount = 100; // Limit header count for security
         this.wss = new ws_1.default.Server({
             server: this.server,
-            path: undefined // Allow connections on any path
+            path: undefined, // Allow connections on any path
+            // High-frequency optimization: Increase backlog and disable per-message deflate
+            backlog: 100,
+            perMessageDeflate: false, // Disable compression for lower latency
+            maxPayload: 100 * 1024 * 1024, // 100MB max payload
         });
-        // Use cors middleware
-        this.app.use((0, cors_1.default)({
-            origin: '*',
-            methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-            credentials: true
-        }));
-        // Update CORS middleware
+        // Single optimized CORS middleware (avoid duplicate cors() + manual headers)
         this.app.use((req, res, next) => {
             res.header("Access-Control-Allow-Origin", "*");
             res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-            res.header("Access-Control-Allow-Headers", 'X-DAIN-SIGNATURE, X-DAIN-SMART-ACCOUNT-PDA, X-DAIN-AGENT-ID, X-DAIN-ORG-ID, X-DAIN-ADDRESS, X-DAIN-TIMESTAMP, Content-Type, Authorization, Accept, Origin, X-Requested-With');
-            if (req.method === "OPTIONS") {
-                return res.sendStatus(200);
-            }
+            res.header("Access-Control-Allow-Headers", "X-DAIN-SIGNATURE, X-DAIN-SMART-ACCOUNT-PDA, X-DAIN-AGENT-ID, X-DAIN-ORG-ID, X-DAIN-ADDRESS, X-DAIN-TIMESTAMP, X-DAIN-WEBHOOK-URL, Content-Type, Authorization, Accept, Origin, X-Requested-With");
+            res.header("Access-Control-Allow-Credentials", "true");
+            if (req.method === "OPTIONS")
+                return res.sendStatus(204);
             next();
         });
-        // Add body-parser middleware
-        this.app.use(body_parser_1.default.raw({ type: "*/*", limit: "100mb" }));
+        // Add body-parser middleware (skip for GET/HEAD/OPTIONS which don't have bodies)
+        this.app.use((req, res, next) => {
+            if (req.method === 'GET' || req.method === 'HEAD' || req.method === 'OPTIONS') {
+                return next();
+            }
+            body_parser_1.default.raw({ type: "*/*", limit: "100mb" })(req, res, next);
+        });
         this.setupExpressRoutes();
         this.setupWebSocketServer();
     }
@@ -83,25 +97,19 @@ class DainTunnelServer {
         // Handle WebSocket connections from tunnel clients
         this.wss.on("connection", (ws, req) => {
             var _a;
-            console.log("New WebSocket connection");
             try {
-                // Check if this is a tunnel client connection or a user connection to be proxied
                 const url = (0, url_1.parse)(req.url || '', true);
                 const pathParts = ((_a = url.pathname) === null || _a === void 0 ? void 0 : _a.split('/')) || [];
-                console.log(`WebSocket connection path: ${url.pathname}`);
                 // Client tunnel connection has no tunnelId in the path (or is at root)
                 if (!url.pathname || url.pathname === '/' || pathParts.length <= 1 || !pathParts[1]) {
-                    console.log("Handling as tunnel client connection");
                     this.handleTunnelClientConnection(ws, req);
                 }
                 else {
-                    // This is a WebSocket connection to be proxied through the tunnel
-                    console.log(`Handling as proxied WebSocket connection for path: ${url.pathname}`);
                     this.handleProxiedWebSocketConnection(ws, req);
                 }
             }
             catch (error) {
-                console.error("Error in WebSocket connection setup:", error);
+                console.error("[Tunnel] WebSocket setup error:", error);
                 ws.close(1011, "Internal server error");
             }
         });
@@ -111,7 +119,6 @@ class DainTunnelServer {
         ws.on("message", (message) => {
             try {
                 const data = JSON.parse(message);
-                console.log(`Received WebSocket message: ${data.type}`);
                 if (data.type === "challenge_request") {
                     this.handleChallengeRequest(ws);
                 }
@@ -129,17 +136,12 @@ class DainTunnelServer {
                 }
             }
             catch (error) {
-                console.error("Error processing message:", error);
+                console.error("[Tunnel] Message error:", error);
                 ws.close(1008, "Invalid message");
             }
         });
-        ws.on("close", () => {
-            console.log("WebSocket connection closed");
-            this.removeTunnel(ws);
-        });
-        ws.on("error", (error) => {
-            console.error("WebSocket error:", error);
-        });
+        ws.on("close", () => this.removeTunnel(ws));
+        ws.on("error", (error) => console.error("[Tunnel] WS error:", error));
     }
     // Handle incoming WebSocket connections to be proxied through the tunnel
     handleProxiedWebSocketConnection(ws, req) {
@@ -153,15 +155,12 @@ class DainTunnelServer {
         const tunnelId = pathParts[1];
         const remainingPath = '/' + pathParts.slice(2).join('/');
         const tunnel = this.tunnels.get(tunnelId);
-        console.log(`Handling WebSocket connection for tunnel: ${tunnelId}, path: ${remainingPath}`);
-        console.log(`Available tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
         if (!tunnel) {
-            console.log(`Tunnel not found for WebSocket connection: ${tunnelId}`);
             ws.close(1008, "Tunnel not found");
             return;
         }
         // Create a WebSocket connection ID
-        const wsConnectionId = (0, uuid_1.v4)();
+        const wsConnectionId = fastId();
         // Store this connection
         this.wsConnections.set(wsConnectionId, {
             clientSocket: ws,
@@ -205,10 +204,12 @@ class DainTunnelServer {
         });
     }
     handleChallengeRequest(ws) {
-        const challenge = (0, uuid_1.v4)();
-        const challengeObj = { ws, challenge };
+        const challenge = fastId();
+        const challengeObj = { ws, challenge, timestamp: Date.now() };
         this.challenges.set(challenge, challengeObj);
         ws.send(JSON.stringify({ type: "challenge", challenge }));
+        // Auto-cleanup expired challenges (30 second TTL)
+        setTimeout(() => this.challenges.delete(challenge), 30000);
     }
     handleStartMessage(ws, data) {
         const { challenge, signature, tunnelId, apiKey } = data;
@@ -250,34 +251,27 @@ class DainTunnelServer {
             }
             // If tunnel already exists, remove old one
             if (this.tunnels.has(tunnelId)) {
-                console.log(`Tunnel ${tunnelId} already exists, replacing it`);
                 const oldTunnel = this.tunnels.get(tunnelId);
                 if (oldTunnel && oldTunnel.ws !== ws) {
                     oldTunnel.ws.close(1000, "Replaced by new connection");
                 }
             }
             this.tunnels.set(tunnelId, { id: tunnelId, ws });
-            console.log(`Tunnel added: ${tunnelId}`);
-            console.log(`Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
             // Save tunnel ID on the WebSocket object for easy lookup on close
             ws.tunnelId = tunnelId;
-            // Add a periodic check to ensure the tunnel is still in the map
+            // Add a periodic ping to keep the connection alive (silent - no logging)
             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) {
-                        console.log(`Tunnel ${tunnelId} still active`);
-                        // Send a ping to keep the connection alive
                         try {
                             ws.ping();
                         }
                         catch (error) {
-                            console.error(`Error sending ping to tunnel ${tunnelId}:`, error);
                             clearInterval(intervalId);
                         }
                     }
                     else {
-                        console.log(`Tunnel ${tunnelId} exists but WebSocket state is invalid, cleaning up`);
                         clearInterval(intervalId);
                         if (tunnel && tunnel.ws === ws) {
                             this.tunnels.delete(tunnelId);
@@ -285,23 +279,19 @@ class DainTunnelServer {
                     }
                 }
                 else {
-                    console.log(`Tunnel ${tunnelId} not found in periodic check`);
                     clearInterval(intervalId);
                 }
-            }, 5000); // Check every 5 seconds
+            }, 30000); // Ping every 30 seconds (reduced frequency)
             // Store the interval ID on the WebSocket object so we can clean it up
             ws.keepAliveInterval = intervalId;
-            ws.on("close", () => {
-                console.log(`WebSocket for tunnel ${tunnelId} closed, clearing interval`);
-                clearInterval(intervalId);
-            });
+            ws.on("close", () => clearInterval(intervalId));
             let tunnelUrl = `${this.hostname}`;
             if (process.env.SKIP_PORT !== "true") {
                 tunnelUrl += `:${this.port}`;
             }
             tunnelUrl += `/${tunnelId}`;
             ws.send(JSON.stringify({ type: "tunnelUrl", url: tunnelUrl }));
-            console.log(`New tunnel created: ${tunnelUrl}`);
+            console.log(`[Tunnel] Created: ${tunnelUrl}`);
         }
         catch (error) {
             console.error(`Error in handleStartMessage for tunnel ${tunnelId}:`, error);
@@ -311,8 +301,15 @@ class DainTunnelServer {
     handleResponseMessage(data) {
         const pendingRequest = this.pendingRequests.get(data.requestId);
         if (pendingRequest) {
-            const { res, startTime } = pendingRequest;
+            const { res, startTime, tunnelId, timeoutId } = pendingRequest;
             const endTime = Date.now();
+            // Clear the timeout since we received a response
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Decrement request counter for backpressure tracking
+            const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
+            this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
             const headers = { ...data.headers };
             delete headers["transfer-encoding"];
             delete headers["content-length"];
@@ -322,99 +319,57 @@ class DainTunnelServer {
                 .set(headers)
                 .set("Content-Length", bodyBuffer.length.toString())
                 .send(bodyBuffer);
-            console.log(`Request handled: ${data.requestId}, Duration: ${endTime - startTime}ms`);
             this.pendingRequests.delete(data.requestId);
         }
     }
     handleSSEMessage(data) {
         const connection = this.sseConnections.get(data.id);
         if (!connection) {
-            console.log(`[SSE E2E] Server: Connection not found for ${data.id} (already cleaned up)`);
+            console.log(`[SSE Debug] handleSSEMessage: No connection found for ${data.id}, event=${data.event}`);
             return;
         }
         const { res, tunnelId } = connection;
         const clientDisconnected = connection.clientDisconnected;
-        // Check if this is a "close" event - this is when we should clean up
         const isCloseEvent = data.event === 'close';
+        console.log(`[SSE Debug] handleSSEMessage: id=${data.id}, event=${data.event}, clientDisconnected=${clientDisconnected}, isClose=${isCloseEvent}`);
         if (isCloseEvent) {
-            console.log(`[SSE E2E] Server: Received close event for ${data.id}, cleaning up`);
-            // Now we can safely send sse_close to tunnel client
             const tunnel = this.tunnels.get(tunnelId);
             if (tunnel) {
-                tunnel.ws.send(JSON.stringify({
-                    type: "sse_close",
-                    id: data.id
-                }));
-                console.log(`[SSE E2E] Server→Client: Sent sse_close command for ${data.id}`);
+                tunnel.ws.send(JSON.stringify({ type: "sse_close", id: data.id }));
             }
-            // End the response if client is still connected
             if (!clientDisconnected && res.writable) {
                 try {
-                    res.write(`event: ${data.event}\n`);
-                    res.write(`data: ${data.data}\n`);
-                    res.write('\n');
+                    res.write(`event: ${data.event}\ndata: ${data.data}\n\n`);
                     flushSSE(res);
                     res.end();
-                    console.log(`[SSE E2E] Server→Browser: Sent close event and ended response for ${data.id}`);
-                }
-                catch (error) {
-                    console.error(`[SSE E2E] Server: ❌ Error writing close event for ${data.id}:`, error);
                 }
+                catch (error) { /* ignore */ }
             }
-            else {
-                console.log(`[SSE E2E] Server: Browser already disconnected for ${data.id}, skipping close event`);
-            }
+            // Decrement request counter for backpressure tracking
+            const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
+            this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
             this.sseConnections.delete(data.id);
             return;
         }
-        // If client disconnected, don't try to write (but don't fail either - let service finish)
-        if (clientDisconnected) {
-            // Only log first discard and key events to avoid spam
-            if (!(connection.discardCount)) {
-                connection.discardCount = 0;
-            }
-            connection.discardCount++;
-            if (connection.discardCount === 1 || data.event === 'error' || data.event === 'end') {
-                console.log(`[SSE E2E] Server: Discarding event="${data.event}" for ${data.id} - browser disconnected (total discarded: ${connection.discardCount})`);
-            }
-            return;
-        }
-        // Check if response is still writable before attempting to write
-        if (!res.writable) {
-            console.log(`[SSE E2E] Server: Response no longer writable for ${data.id}, marking as disconnected`);
+        if (clientDisconnected || !res.writable) {
             connection.clientDisconnected = true;
             return;
         }
         try {
-            if (data.event) {
+            if (data.event)
                 res.write(`event: ${data.event}\n`);
-            }
-            // Write data as-is (don't split - data is already properly formatted)
-            res.write(`data: ${data.data}\n`);
-            res.write('\n');
-            // Force immediate flush to prevent buffering
-            // This is critical for SSE - without it, events may be delayed or lost
+            const escapedData = data.data.replace(/\n/g, '\ndata: ');
+            res.write(`data: ${escapedData}\n\n`);
             flushSSE(res);
-            // Only log key events to avoid spam
-            if (!(connection.eventCount)) {
-                connection.eventCount = 0;
-            }
-            connection.eventCount++;
-            if (connection.eventCount === 1 || data.event === 'error' || data.event === 'end') {
-                console.log(`[SSE E2E] Server→Browser: Forwarded event="${data.event}" for ${data.id} (total events: ${connection.eventCount})`);
-            }
         }
         catch (error) {
-            console.error(`[SSE E2E] Server: ❌ Error writing SSE message for ${data.id}:`, error);
             connection.clientDisconnected = true;
         }
     }
     handleWebSocketMessage(data) {
         const connection = this.wsConnections.get(data.id);
-        if (!connection) {
-            console.log(`WebSocket connection not found: ${data.id}`);
+        if (!connection)
             return;
-        }
         const { clientSocket } = connection;
         if (data.event === 'message' && data.data) {
             const messageData = Buffer.from(data.data, 'base64');
@@ -447,41 +402,57 @@ class DainTunnelServer {
         while (retries > 0 && !tunnel) {
             tunnel = this.tunnels.get(tunnelId);
             if (!tunnel) {
-                console.log(`Tunnel not found: ${tunnelId}, retrying... (${retries} attempts left)`);
-                console.log(`Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
-                await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms before retrying
+                await new Promise(resolve => setTimeout(resolve, 100));
                 retries--;
             }
         }
         if (!tunnel) {
-            console.log(`Tunnel not found after retries: ${tunnelId}`);
             return res.status(404).send("Tunnel not found");
         }
+        // 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" });
+        }
+        // Check concurrent request limit per tunnel
+        const currentCount = this.tunnelRequestCount.get(tunnelId) || 0;
+        if (currentCount >= this.MAX_CONCURRENT_REQUESTS_PER_TUNNEL) {
+            return res.status(503).json({ error: "Service Unavailable", message: "Too many concurrent requests" });
+        }
+        this.tunnelRequestCount.set(tunnelId, currentCount + 1);
         // 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
-        const requestId = (0, uuid_1.v4)();
+        const requestId = fastId();
         const startTime = Date.now();
-        this.pendingRequests.set(requestId, { res, startTime });
-        const requestMessage = {
+        // Set a timeout for the request (30 seconds)
+        const REQUEST_TIMEOUT = 30000;
+        const timeoutId = setTimeout(() => {
+            const pendingRequest = this.pendingRequests.get(requestId);
+            if (pendingRequest) {
+                const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
+                this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
+                this.pendingRequests.delete(requestId);
+                if (!res.headersSent) {
+                    res.status(504).json({ error: "Gateway Timeout", message: "Request timed out" });
+                }
+            }
+        }, REQUEST_TIMEOUT);
+        this.pendingRequests.set(requestId, { res, startTime, tunnelId, timeoutId });
+        tunnel.ws.send(JSON.stringify({
             type: "request",
             id: requestId,
             method: req.method,
             path: req.url,
             headers: req.headers,
-            body: req.method !== "GET" && req.body
+            body: req.method !== "GET" && req.method !== "HEAD" && req.body
                 ? req.body.toString("base64")
                 : undefined,
-        };
-        tunnel.ws.send(JSON.stringify(requestMessage));
-        console.log(`Request forwarded: ${requestId}, Method: ${req.method}, Path: ${req.url}`);
+        }));
     }
     handleSSERequest(req, res, tunnelId, tunnel) {
-        // Setup SSE connection
-        const sseId = (0, uuid_1.v4)();
-        console.log(`[SSE E2E] Server: Establishing SSE connection ${sseId} from browser to ${req.url}`);
+        const sseId = fastId();
         // Optimize TCP socket for low-latency streaming
         const socket = req.socket || req.connection;
         if (socket && socket.setNoDelay) {
@@ -497,113 +468,114 @@ class DainTunnelServer {
         // 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');
+        // Send SSE comment to keep connection alive and verify it's working
+        // Comments start with : and are ignored by EventSource but flush the buffer
+        res.write(': connected\n\n');
         // Flush the initial write
         flushSSE(res);
-        // Store the SSE connection
-        this.sseConnections.set(sseId, {
-            req,
-            res,
-            id: sseId,
-            tunnelId
-        });
-        console.log(`[SSE E2E] Server→Client: Forwarding SSE connection request ${sseId} to tunnel client`);
-        // Notify the tunnel client about the new SSE connection
+        this.sseConnections.set(sseId, { req, res, id: sseId, tunnelId });
         tunnel.ws.send(JSON.stringify({
             type: "sse_connection",
             id: sseId,
             path: req.url,
-            method: req.method, // Include HTTP method for POST tool calls
+            method: req.method,
             headers: req.headers,
             body: req.method !== "GET" && req.body ? req.body.toString("base64") : undefined
         }));
-        // Handle client disconnect
         req.on('close', () => {
-            console.log(`[SSE E2E] Server: Browser disconnected from SSE ${sseId}`);
-            // DO NOT immediately send sse_close to tunnel client!
-            // The local service may still be processing and sending SSE events.
-            // Instead, mark this connection as "client disconnected" and let the
-            // local service finish naturally. We'll clean up when we receive the
-            // final "close" event from the service, or when the connection errors.
+            console.log(`[SSE Debug] req.close fired for ${sseId} - client disconnected`);
             const connection = this.sseConnections.get(sseId);
             if (connection) {
-                // Mark as client disconnected, but keep the tunnel client connection alive
                 connection.clientDisconnected = true;
-                console.log(`[SSE E2E] Server: Marked ${sseId} as browser-disconnected (service can still finish)`);
+                // Clean up after a short delay to allow any pending events to be handled
+                setTimeout(() => {
+                    if (this.sseConnections.has(sseId)) {
+                        console.log(`[SSE Debug] Cleaning up SSE connection ${sseId} after client disconnect`);
+                        // Decrement request counter for backpressure tracking
+                        const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
+                        this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
+                        this.sseConnections.delete(sseId);
+                        // Notify tunnel client to close the connection
+                        const tunnel = this.tunnels.get(tunnelId);
+                        if (tunnel && tunnel.ws.readyState === ws_1.default.OPEN) {
+                            tunnel.ws.send(JSON.stringify({ type: "sse_close", id: sseId }));
+                        }
+                    }
+                }, 100);
             }
         });
+        req.on('error', (err) => {
+            console.log(`[SSE Debug] req.error fired for ${sseId}:`, err.message);
+        });
     }
     removeTunnel(ws) {
         try {
-            // Clear any interval timer
-            if (ws.keepAliveInterval) {
+            if (ws.keepAliveInterval)
                 clearInterval(ws.keepAliveInterval);
-            }
-            // If we saved tunnelId on the WebSocket object, use it for faster lookup
             const tunnelId = ws.tunnelId;
             let removedTunnelId = tunnelId;
             if (tunnelId && this.tunnels.has(tunnelId)) {
                 const tunnel = this.tunnels.get(tunnelId);
-                if (tunnel && tunnel.ws === ws) {
+                if (tunnel && tunnel.ws === ws)
                     this.tunnels.delete(tunnelId);
-                    console.log(`Tunnel removed using stored ID: ${tunnelId}`);
-                }
             }
             else {
-                // Fall back to iterating through all tunnels
                 removedTunnelId = undefined;
                 for (const [id, tunnel] of this.tunnels.entries()) {
                     if (tunnel.ws === ws) {
                         this.tunnels.delete(id);
                         removedTunnelId = id;
-                        console.log(`Tunnel removed: ${id}`);
                         break;
                     }
                 }
             }
             if (removedTunnelId) {
-                console.log(`Tunnel ${removedTunnelId} removed. Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
+                this.tunnelRequestCount.delete(removedTunnelId);
+                // Close all pending HTTP requests associated with this tunnel
+                for (const [requestId, pendingRequest] of this.pendingRequests.entries()) {
+                    if (pendingRequest.tunnelId === removedTunnelId) {
+                        try {
+                            if (pendingRequest.timeoutId)
+                                clearTimeout(pendingRequest.timeoutId);
+                            if (!pendingRequest.res.headersSent) {
+                                pendingRequest.res.status(502).json({ error: "Bad Gateway", message: "Tunnel closed" });
+                            }
+                        }
+                        catch (error) { /* ignore */ }
+                        this.pendingRequests.delete(requestId);
+                    }
+                }
                 // Close all SSE connections associated with this tunnel
                 for (const [sseId, sseConnection] of this.sseConnections.entries()) {
                     if (sseConnection.tunnelId === removedTunnelId) {
                         try {
                             sseConnection.res.end();
                         }
-                        catch (error) {
-                            console.error(`Error closing SSE connection ${sseId}:`, error);
-                        }
+                        catch (error) { /* ignore */ }
                         this.sseConnections.delete(sseId);
                     }
                 }
                 // Close all WebSocket connections associated with this tunnel
                 for (const [wsId, wsConnection] of this.wsConnections.entries()) {
-                    const wsPath = wsConnection.path;
-                    if (wsPath.startsWith(`/${removedTunnelId}/`)) {
+                    if (wsConnection.path.startsWith(`/${removedTunnelId}/`)) {
                         try {
                             wsConnection.clientSocket.close(1001, "Tunnel closed");
                         }
-                        catch (error) {
-                            console.error(`Error closing WebSocket connection ${wsId}:`, error);
-                        }
+                        catch (error) { /* ignore */ }
                         this.wsConnections.delete(wsId);
                     }
                 }
             }
-            else {
-                console.log(`No tunnel found to remove for the closed WebSocket connection`);
-            }
-            // Also remove any pending challenges for this WebSocket
+            // Remove any pending challenges for this WebSocket
             for (const [challenge, challengeObj] of this.challenges.entries()) {
                 if (challengeObj.ws === ws) {
                     this.challenges.delete(challenge);
-                    console.log(`Challenge removed for closed WebSocket`);
                     break;
                 }
             }
         }
         catch (error) {
-            console.error("Error in removeTunnel:", error);
+            console.error("[Tunnel] Remove error:", error);
         }
     }
     async start() {

package/package.json

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