@dainprotocol/tunnel 1.1.26 → 1.1.30

package/dist/client/index.js

@@ -9,6 +9,17 @@ const http_1 = __importDefault(require("http"));
 const events_1 = require("events");
 const crypto_1 = require("crypto");
 const auth_1 = require("@dainprotocol/service-sdk/service/auth");
+const TIMEOUTS = {
+    HEARTBEAT: 25000,
+    REQUEST: 25000,
+    CONNECTION: 10000,
+    CHALLENGE: 5000,
+    RECONNECT_DELAY: 5000,
+    SHUTDOWN_GRACE: 500,
+};
+const RECONNECT = {
+    MAX_ATTEMPTS: 5,
+};
 class DainTunnel extends events_1.EventEmitter {
     constructor(serverUrl, apiKey) {
         super();
@@ -17,63 +28,56 @@ class DainTunnel extends events_1.EventEmitter {
         this.tunnelUrl = null;
         this.port = null;
         this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 5;
-        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
+        console.log('[DainTunnel] ========================================');
+        console.log('[DainTunnel] FIXED VERSION WITH X-FORWARDED-HOST SUPPORT');
+        console.log('[DainTunnel] ========================================');
         const parsed = (0, auth_1.parseAPIKey)(apiKey);
         if (!parsed) {
             throw new Error('Invalid API key format. Expected: sk_agent_{agentId}_{orgId}_{secret}');
         }
         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
-        // Aligned with server's MAX_CONCURRENT_REQUESTS_PER_TUNNEL = 100
+        this.tunnelId = `${parsed.orgId}_${parsed.agentId}`;
+        this.secret = parsed.secret;
         this.httpAgent = new http_1.default.Agent({
             keepAlive: true,
-            keepAliveMsecs: 30000, // Keep connections alive for 30s
-            maxSockets: 100, // Match server's concurrent request limit
-            maxFreeSockets: 20, // Keep more idle connections for burst traffic
+            keepAliveMsecs: 30000,
+            maxSockets: 100,
+            maxFreeSockets: 20,
         });
     }
-    /**
-     * Sign a challenge using HMAC-SHA256
-     * @private
-     */
     signChallenge(challenge) {
-        return (0, crypto_1.createHmac)('sha256', this.secret)
-            .update(challenge)
-            .digest('hex');
+        return (0, crypto_1.createHmac)('sha256', this.secret).update(challenge).digest('hex');
+    }
+    safeSend(data) {
+        var _a;
+        try {
+            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                this.ws.send(JSON.stringify(data));
+                return true;
+            }
+        }
+        catch (_b) {
+            // Connection lost during send
+        }
+        return false;
     }
-    /**
-     * Start client-side heartbeat to detect connection issues early
-     * @private
-     */
     startHeartbeat() {
-        this.stopHeartbeat(); // Clear any existing heartbeat
+        this.stopHeartbeat();
         this.heartbeatInterval = setInterval(() => {
-            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            var _a;
+            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
                 try {
                     this.ws.ping();
                 }
-                catch (error) {
-                    // Ping failed, connection might be dead
+                catch (_b) {
                     this.emit("error", new Error("Heartbeat ping failed"));
                 }
             }
-        }, this.HEARTBEAT_INTERVAL);
+        }, TIMEOUTS.HEARTBEAT);
     }
-    /**
-     * Stop the client-side heartbeat
-     * @private
-     */
     stopHeartbeat() {
         if (this.heartbeatInterval) {
             clearInterval(this.heartbeatInterval);
@@ -88,25 +92,20 @@ class DainTunnel extends events_1.EventEmitter {
         return new Promise((resolve, reject) => {
             let resolved = false;
             let connectionTimeoutId = null;
-            const cleanup = () => {
+            const finish = (value, error) => {
+                if (resolved)
+                    return;
+                resolved = true;
                 if (connectionTimeoutId) {
                     clearTimeout(connectionTimeoutId);
                     connectionTimeoutId = null;
                 }
-            };
-            const safeResolve = (value) => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
-                    resolve(value);
-                }
-            };
-            const safeReject = (error) => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
+                if (error) {
                     reject(error);
                 }
+                else {
+                    resolve(value);
+                }
             };
             try {
                 this.ws = new ws_1.default(this.serverUrl);
@@ -115,78 +114,74 @@ class DainTunnel extends events_1.EventEmitter {
                     try {
                         const challenge = await this.requestChallenge();
                         const signature = this.signChallenge(challenge);
-                        this.sendMessage({
+                        this.safeSend({
                             type: "start",
                             port: this.port,
                             challenge,
                             signature,
                             tunnelId: this.tunnelId,
-                            apiKey: this.apiKey // Send API key for server validation
+                            apiKey: this.apiKey
                         });
-                        // Start heartbeat after successful authentication
                         this.startHeartbeat();
                         this.emit("connected");
                     }
                     catch (err) {
-                        safeReject(err);
+                        finish(undefined, err);
                     }
                 });
                 this.ws.on("message", (data) => {
                     try {
-                        this.handleMessage(JSON.parse(data), safeResolve);
+                        this.handleMessage(JSON.parse(data), (url) => finish(url));
                     }
                     catch (err) {
-                        safeReject(err);
+                        finish(undefined, err);
                     }
                 });
                 this.ws.on("close", () => {
-                    // Stop heartbeat on disconnect
                     this.stopHeartbeat();
-                    // 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();
+                    this.cleanupAllClients();
                     if (this.tunnelUrl) {
                         this.emit("disconnected");
                         this.attemptReconnect();
                     }
                     else {
-                        safeReject(new Error("Connection closed before tunnel established"));
+                        finish(undefined, new Error("Connection closed before tunnel established"));
                     }
                 });
                 this.ws.on("error", (error) => this.emit("error", error));
-                // Connection timeout with proper cleanup
                 connectionTimeoutId = setTimeout(() => {
+                    var _a;
                     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 */ }
+                        finish(undefined, new Error("Connection timeout"));
+                        try {
+                            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.terminate();
                         }
+                        catch (_b) { }
                     }
-                }, 10000);
+                }, TIMEOUTS.CONNECTION);
             }
             catch (err) {
-                safeReject(err);
+                finish(undefined, err);
             }
         });
     }
+    cleanupAllClients() {
+        for (const client of this.sseClients.values()) {
+            try {
+                client.destroy();
+            }
+            catch (_a) { }
+        }
+        this.sseClients.clear();
+        for (const client of this.webSocketClients.values()) {
+            try {
+                if (client.readyState === ws_1.default.OPEN)
+                    client.close(1001);
+            }
+            catch (_b) { }
+        }
+        this.webSocketClients.clear();
+    }
     async requestChallenge() {
         return new Promise((resolve, reject) => {
             if (!this.ws) {
@@ -195,38 +190,37 @@ class DainTunnel extends events_1.EventEmitter {
             }
             let resolved = false;
             let timeoutId = null;
-            const cleanup = () => {
-                if (this.ws) {
-                    this.ws.removeListener("message", challengeHandler);
-                }
+            const finish = (challenge, error) => {
+                var _a;
+                if (resolved)
+                    return;
+                resolved = true;
+                (_a = this.ws) === null || _a === void 0 ? void 0 : _a.removeListener("message", challengeHandler);
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
                 }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(challenge);
+                }
             };
             const challengeHandler = (message) => {
                 try {
                     const data = JSON.parse(message);
-                    if (data.type === "challenge" && !resolved) {
-                        resolved = true;
-                        cleanup();
-                        resolve(data.challenge);
+                    if (data.type === "challenge") {
+                        finish(data.challenge);
                     }
                 }
-                catch (e) {
-                    // Ignore parse errors for non-challenge messages
-                }
+                catch (_a) { }
             };
             this.ws.on("message", challengeHandler);
             this.ws.send(JSON.stringify({ type: "challenge_request" }));
-            // Add a timeout for the challenge request
             timeoutId = setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
-                    reject(new Error("Challenge request timeout"));
-                }
-            }, 5000);
+                finish(undefined, new Error("Challenge request timeout"));
+            }, TIMEOUTS.CHALLENGE);
         });
     }
     handleMessage(message, resolve) {
@@ -256,141 +250,138 @@ class DainTunnel extends events_1.EventEmitter {
     async handleRequest(request) {
         try {
             const response = await this.forwardRequest(request);
-            this.sendMessage(response);
+            this.safeSend(response);
             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 = {
+            this.safeSend({
                 type: "response",
                 requestId: request.id,
-                status: 502, // Bad Gateway - indicates upstream error
+                status: 502,
                 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 });
         }
     }
     handleWebSocketConnection(message) {
-        var _a;
+        const sendWsEvent = (event, data) => {
+            this.safeSend({ type: 'websocket', id: message.id, event, data });
+        };
         try {
+            // Preserve original host for JWT audience validation
+            const headers = { ...message.headers };
+            const originalHost = message.headers.host;
+            if (originalHost && !headers['x-forwarded-host']) {
+                headers['x-forwarded-host'] = originalHost;
+                headers['x-forwarded-proto'] = 'https';
+            }
+            delete headers.host; // Remove so WebSocket library doesn't send tunnel host to localhost
             const client = new ws_1.default(`ws://localhost:${this.port}${message.path}`, {
-                headers: message.headers
+                headers
             });
             this.webSocketClients.set(message.id, client);
             client.on('message', (data) => {
-                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') }));
-                }
+                sendWsEvent('message', data.toString('base64'));
             });
             client.on('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' }));
-                }
+                sendWsEvent('close');
                 this.webSocketClients.delete(message.id);
             });
             client.on('error', (error) => {
-                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 }));
-                }
+                sendWsEvent('error', error.message);
                 this.webSocketClients.delete(message.id);
             });
             this.emit("websocket_connection", { id: message.id, path: message.path });
         }
         catch (error) {
-            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 }));
-            }
+            sendWsEvent('error', error.message);
         }
     }
     handleWebSocketMessage(message) {
         const client = this.webSocketClients.get(message.id);
         if (!client)
             return;
-        if (message.event === 'message' && message.data) {
-            const data = Buffer.from(message.data, 'base64');
-            if (client.readyState === ws_1.default.OPEN) {
-                client.send(data);
-            }
-        }
-        else if (message.event === 'close') {
-            if (client.readyState === ws_1.default.OPEN) {
-                client.close();
-            }
-            this.webSocketClients.delete(message.id);
+        switch (message.event) {
+            case 'message':
+                if (message.data && client.readyState === ws_1.default.OPEN) {
+                    client.send(Buffer.from(message.data, 'base64'));
+                }
+                break;
+            case 'close':
+                if (client.readyState === ws_1.default.OPEN) {
+                    client.close();
+                }
+                this.webSocketClients.delete(message.id);
+                break;
         }
     }
     handleSSEConnection(message) {
-        var _a;
+        const sendSseEvent = (event, data = '') => {
+            this.safeSend({ type: 'sse', id: message.id, event, data });
+        };
         try {
+            const headers = { ...message.headers };
+            // Preserve original host for JWT audience validation
+            const originalHost = message.headers.host;
+            console.log(`[TunnelClient SSE] Original host from request: ${originalHost}`);
+            if (originalHost && !headers['x-forwarded-host']) {
+                headers['x-forwarded-host'] = originalHost;
+                headers['x-forwarded-proto'] = 'https';
+                console.log(`[TunnelClient SSE] Set x-forwarded-host: ${originalHost}`);
+            }
+            delete headers.host;
+            headers['accept-encoding'] = 'identity';
+            console.log(`[TunnelClient SSE] Forwarding to localhost:${this.port}${message.path} with x-forwarded-host: ${headers['x-forwarded-host']}`);
             const req = http_1.default.request({
                 hostname: 'localhost',
                 port: this.port,
                 path: message.path,
                 method: message.method || 'GET',
-                headers: message.headers,
+                headers,
                 agent: this.httpAgent,
             }, (res) => {
-                var _a;
-                // Non-200 response - forward error to tunnel server
                 if (res.statusCode !== 200) {
+                    console.log(`[TunnelClient SSE] Got non-200 status: ${res.statusCode}`);
                     let errorBody = '';
                     res.on('data', (chunk) => { errorBody += chunk.toString(); });
                     res.on('end', () => {
-                        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: `Status ${res.statusCode}: ${errorBody.substring(0, 200)}`
-                            }));
-                        }
+                        console.log(`[TunnelClient SSE] Error body: ${errorBody.substring(0, 500)}`);
+                        sendSseEvent('error', `Status ${res.statusCode}: ${errorBody.substring(0, 200)}`);
                     });
                     return;
                 }
-                // Optimize TCP for streaming
                 const socket = res.socket || res.connection;
                 if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
                     socket.setNoDelay(true);
-                // Notify tunnel server that local service accepted
-                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: 'connected', data: '' }));
-                }
-                // Stream SSE events to tunnel server
+                sendSseEvent('connected');
                 let buffer = '';
-                // 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 = '';
+                        let event = 'message';
+                        let data = '';
                         for (const line of msgData.split('\n')) {
-                            if (line.startsWith('event:'))
+                            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';
+                            }
                         }
                         if (data.endsWith('\n'))
                             data = data.slice(0, -1);
-                        // 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 }));
+                        if (data) {
+                            sendSseEvent(event, data);
                         }
                     }
                 };
@@ -399,34 +390,29 @@ class DainTunnel extends events_1.EventEmitter {
                     processBuffer();
                 });
                 res.on('end', () => {
-                    var _a;
-                    // Process any remaining data in buffer (might be missing final \n\n)
                     if (buffer.trim()) {
-                        // Add missing newlines to ensure processing
                         buffer += '\n\n';
                         processBuffer();
                     }
-                    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: '' }));
-                    }
+                    sendSseEvent('close');
                 });
             });
+            req.on('socket', (socket) => {
+                socket.setNoDelay(true);
+                socket.setTimeout(0);
+            });
             req.on('error', (error) => {
-                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 }));
-                }
+                sendSseEvent('error', error.message);
             });
-            if (message.body && message.method !== 'GET')
+            if (message.body && message.method !== 'GET') {
                 req.write(Buffer.from(message.body, 'base64'));
+            }
             req.end();
             this.sseClients.set(message.id, req);
             this.emit("sse_connection", { id: message.id, path: message.path });
         }
         catch (error) {
-            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 }));
-            }
+            sendSseEvent('error', error.message);
         }
     }
     handleSSEClose(message) {
@@ -440,146 +426,101 @@ class DainTunnel extends events_1.EventEmitter {
         return new Promise((resolve, reject) => {
             let resolved = false;
             let timeoutId = null;
-            const cleanup = () => {
+            const finish = (response, error) => {
+                if (resolved)
+                    return;
+                resolved = true;
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
                 }
-            };
-            const safeResolve = (response) => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
-                    resolve(response);
-                }
-            };
-            const safeReject = (error) => {
-                if (!resolved) {
-                    resolved = true;
-                    cleanup();
+                if (error) {
                     reject(error);
                 }
+                else {
+                    resolve(response);
+                }
             };
+            // Preserve original host for JWT audience validation
+            const headers = { ...request.headers };
+            const originalHost = request.headers.host;
+            console.log(`[TunnelClient] Original host from request: ${originalHost}`);
+            if (originalHost && !headers['x-forwarded-host']) {
+                headers['x-forwarded-host'] = originalHost;
+                headers['x-forwarded-proto'] = 'https';
+                console.log(`[TunnelClient] Set x-forwarded-host: ${originalHost}`);
+            }
+            delete headers.host; // Remove so Node.js doesn't send the tunnel host to localhost
+            console.log(`[TunnelClient] Forwarding to localhost:${this.port}${request.path} with x-forwarded-host: ${headers['x-forwarded-host']}`);
             const options = {
                 hostname: 'localhost',
                 port: this.port,
                 path: request.path,
                 method: request.method,
-                headers: request.headers,
-                agent: this.httpAgent, // Use connection pooling
-                timeout: this.REQUEST_TIMEOUT, // Socket timeout
+                headers,
+                agent: this.httpAgent,
+                timeout: TIMEOUTS.REQUEST,
             };
             const req = http_1.default.request(options, (res) => {
-                let body = Buffer.from([]);
-                res.on('data', (chunk) => {
-                    body = Buffer.concat([body, chunk]);
-                });
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
                 res.on('end', () => {
                     const headers = { ...res.headers };
                     delete headers['transfer-encoding'];
                     delete headers['content-length'];
-                    safeResolve({
+                    finish({
                         type: 'response',
                         requestId: request.id,
                         status: res.statusCode,
                         headers,
-                        body: body.toString('base64'),
+                        body: Buffer.concat(chunks).toString('base64'),
                     });
                 });
-                res.on('error', safeReject);
+                res.on('error', (err) => finish(undefined, err));
             });
-            // Handle request timeout
             req.on('timeout', () => {
                 req.destroy();
-                safeReject(new Error(`Request timeout after ${this.REQUEST_TIMEOUT}ms`));
+                finish(undefined, new Error(`Request timeout after ${TIMEOUTS.REQUEST}ms`));
             });
-            req.on('error', safeReject);
-            // Additional safety timeout
+            req.on('error', (err) => finish(undefined, err));
             timeoutId = setTimeout(() => {
-                if (!resolved) {
-                    req.destroy();
-                    safeReject(new Error(`Request timeout after ${this.REQUEST_TIMEOUT}ms`));
-                }
-            }, this.REQUEST_TIMEOUT);
+                req.destroy();
+                finish(undefined, new Error(`Request timeout after ${TIMEOUTS.REQUEST}ms`));
+            }, TIMEOUTS.REQUEST);
             if (request.body && request.method !== 'GET') {
                 req.write(Buffer.from(request.body, 'base64'));
             }
             req.end();
         });
     }
-    sendMessage(message) {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify(message));
-        }
-    }
     attemptReconnect() {
-        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+        if (this.reconnectAttempts < RECONNECT.MAX_ATTEMPTS) {
             this.reconnectAttempts++;
             setTimeout(async () => {
                 try {
                     await this.connect();
                 }
-                catch (error) { /* ignore */ }
-            }, this.reconnectDelay);
+                catch (_a) { }
+            }, TIMEOUTS.RECONNECT_DELAY);
         }
         else {
             this.emit("max_reconnect_attempts");
         }
     }
     async stop() {
-        return new Promise(async (resolve) => {
+        this.stopHeartbeat();
+        this.cleanupAllClients();
+        if (this.ws) {
             try {
-                // Stop heartbeat first
-                this.stopHeartbeat();
-                // Close all WebSocket clients
-                for (const [id, client] of this.webSocketClients.entries()) {
-                    try {
-                        if (client.readyState === ws_1.default.OPEN) {
-                            client.close();
-                        }
-                    }
-                    catch (error) {
-                        console.error(`Error closing WebSocket client ${id}:`, error);
-                    }
-                }
-                this.webSocketClients.clear();
-                // Close all SSE clients
-                for (const [id, client] of this.sseClients.entries()) {
-                    try {
-                        client.destroy();
-                    }
-                    catch (error) {
-                        console.error(`Error destroying SSE client ${id}:`, error);
-                    }
-                }
-                this.sseClients.clear();
-                // Close main WebSocket connection
-                if (this.ws) {
-                    try {
-                        if (this.ws.readyState === ws_1.default.OPEN) {
-                            this.ws.close();
-                        }
-                    }
-                    catch (error) {
-                        console.error('Error closing main WebSocket:', error);
-                    }
-                    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();
-                }
-                // Wait for all connections to close properly
-                await new Promise(resolve => setTimeout(resolve, 500));
-                resolve();
-            }
-            catch (error) {
-                console.error('Error in stop method:', error);
-                resolve(); // Resolve anyway to not block cleaning up
+                if (this.ws.readyState === ws_1.default.OPEN)
+                    this.ws.close();
             }
-        });
+            catch (_a) { }
+            this.ws = null;
+        }
+        this.tunnelUrl = null;
+        this.httpAgent.destroy();
+        await new Promise(resolve => setTimeout(resolve, TIMEOUTS.SHUTDOWN_GRACE));
     }
 }
 exports.DainTunnel = DainTunnel;