@dainprotocol/tunnel 1.1.25 → 1.1.29

package/dist/client/index.d.ts

@@ -5,22 +5,21 @@ declare class DainTunnel extends EventEmitter {
     private tunnelUrl;
     private port;
     private reconnectAttempts;
-    private maxReconnectAttempts;
-    private reconnectDelay;
     private apiKey;
     private tunnelId;
     private secret;
     private webSocketClients;
     private sseClients;
     private httpAgent;
+    private heartbeatInterval;
     constructor(serverUrl: string, apiKey: string);
-    /**
-     * Sign a challenge using HMAC-SHA256
-     * @private
-     */
     private signChallenge;
+    private safeSend;
+    private startHeartbeat;
+    private stopHeartbeat;
     start(port: number): Promise<string>;
     private connect;
+    private cleanupAllClients;
     private requestChallenge;
     private handleMessage;
     private handleRequest;
@@ -29,7 +28,6 @@ declare class DainTunnel extends EventEmitter {
     private handleSSEConnection;
     private handleSSEClose;
     private forwardRequest;
-    private sendMessage;
     private attemptReconnect;
     stop(): Promise<void>;
 }

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,34 +28,58 @@ 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();
-        // Parse API key to extract agentId and secret
+        this.heartbeatInterval = null;
         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
+        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: 50, // Allow up to 50 concurrent connections to local service
-            maxFreeSockets: 10, // Keep up to 10 idle connections
+            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;
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatInterval = setInterval(() => {
+            var _a;
+            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+                try {
+                    this.ws.ping();
+                }
+                catch (_b) {
+                    this.emit("error", new Error("Heartbeat ping failed"));
+                }
+            }
+        }, TIMEOUTS.HEARTBEAT);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
     }
     async start(port) {
         this.port = port;
@@ -52,6 +87,23 @@ class DainTunnel extends events_1.EventEmitter {
     }
     async connect() {
         return new Promise((resolve, reject) => {
+            let resolved = false;
+            let connectionTimeoutId = null;
+            const finish = (value, error) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (connectionTimeoutId) {
+                    clearTimeout(connectionTimeoutId);
+                    connectionTimeoutId = null;
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(value);
+                }
+            };
             try {
                 this.ws = new ws_1.default(this.serverUrl);
                 this.ws.on("open", async () => {
@@ -59,90 +111,113 @@ 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
                         });
+                        this.startHeartbeat();
                         this.emit("connected");
                     }
                     catch (err) {
-                        reject(err);
+                        finish(undefined, err);
                     }
                 });
                 this.ws.on("message", (data) => {
                     try {
-                        this.handleMessage(JSON.parse(data), resolve);
+                        this.handleMessage(JSON.parse(data), (url) => finish(url));
                     }
                     catch (err) {
-                        reject(err);
+                        finish(undefined, err);
                     }
                 });
                 this.ws.on("close", () => {
-                    // 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.stopHeartbeat();
+                    this.cleanupAllClients();
                     if (this.tunnelUrl) {
                         this.emit("disconnected");
                         this.attemptReconnect();
                     }
                     else {
-                        reject(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));
-                setTimeout(() => {
-                    if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-                        reject(new Error("Connection timeout"));
+                connectionTimeoutId = setTimeout(() => {
+                    var _a;
+                    if (!resolved && (!this.ws || this.ws.readyState !== ws_1.default.OPEN)) {
+                        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) {
-                reject(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) {
                 reject(new Error("WebSocket is not connected"));
                 return;
             }
-            this.ws.send(JSON.stringify({ type: "challenge_request" }));
+            let resolved = false;
+            let timeoutId = null;
+            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) => {
-                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") {
+                        finish(data.challenge);
                     }
-                    resolve(data.challenge);
                 }
+                catch (_a) { }
             };
             this.ws.on("message", challengeHandler);
-            // Add a timeout for the challenge request
-            setTimeout(() => {
-                if (this.ws) {
-                    this.ws.removeListener("message", challengeHandler);
-                }
-                reject(new Error("Challenge request timeout"));
-            }, 5000);
+            this.ws.send(JSON.stringify({ type: "challenge_request" }));
+            timeoutId = setTimeout(() => {
+                finish(undefined, new Error("Challenge request timeout"));
+            }, TIMEOUTS.CHALLENGE);
         });
     }
     handleMessage(message, resolve) {
@@ -172,120 +247,119 @@ 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) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            this.safeSend({
+                type: "response",
+                requestId: request.id,
+                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.emit("request_error", { request, error });
         }
     }
     handleWebSocketConnection(message) {
-        var _a;
+        const sendWsEvent = (event, data) => {
+            this.safeSend({ type: 'websocket', id: message.id, event, data });
+        };
         try {
             const client = new ws_1.default(`ws://localhost:${this.port}${message.path}`, {
                 headers: message.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 };
+            delete headers.host;
+            headers['accept-encoding'] = 'identity';
             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) {
                     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)}`
-                            }));
-                        }
+                        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;
+                    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);
-                        let event = 'message', data = '';
+                        if (!msgData.trim() || msgData.startsWith(':'))
+                            continue;
+                        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);
-                        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 }));
+                        if (data) {
+                            sendSseEvent(event, data);
                         }
                     }
                 };
@@ -294,34 +368,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) {
@@ -333,108 +402,92 @@ class DainTunnel extends events_1.EventEmitter {
     }
     forwardRequest(request) {
         return new Promise((resolve, reject) => {
+            let resolved = false;
+            let timeoutId = null;
+            const finish = (response, error) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(response);
+                }
+            };
             const options = {
                 hostname: 'localhost',
                 port: this.port,
                 path: request.path,
                 method: request.method,
                 headers: request.headers,
-                agent: this.httpAgent, // Use connection pooling
+                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'];
-                    resolve({
+                    finish({
                         type: 'response',
                         requestId: request.id,
                         status: res.statusCode,
                         headers,
-                        body: body.toString('base64'),
+                        body: Buffer.concat(chunks).toString('base64'),
                     });
                 });
+                res.on('error', (err) => finish(undefined, err));
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                finish(undefined, new Error(`Request timeout after ${TIMEOUTS.REQUEST}ms`));
             });
-            req.on('error', reject);
+            req.on('error', (err) => finish(undefined, err));
+            timeoutId = setTimeout(() => {
+                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 {
-                // 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;
-                }
-                // 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;