@dainprotocol/tunnel 1.1.33 → 2.0.0

package/dist/client/index.d.ts

@@ -9,9 +9,11 @@ declare class DainTunnel extends EventEmitter {
     private tunnelId;
     private secret;
     private webSocketClients;
-    private sseClients;
-    private httpAgent;
+    private pendingWebSocketMessages;
+    private sseAbortControllers;
     private heartbeatInterval;
+    private reconnectTimer;
+    private isStopping;
     constructor(serverUrl: string, apiKey: string);
     private signChallenge;
     private safeSend;
@@ -25,14 +27,12 @@ declare class DainTunnel extends EventEmitter {
     private handleRequest;
     private handleWebSocketConnection;
     private handleWebSocketMessage;
+    private flushPendingWebSocketMessages;
+    private cleanupWebSocketConnection;
     private handleSSEConnection;
     private handleSSEClose;
     private forwardRequest;
     private attemptReconnect;
-    /**
-     * Reset reconnection attempts counter.
-     * Call this to allow reconnection after max_reconnect_attempts was reached.
-     */
     resetReconnection(): void;
     stop(): Promise<void>;
 }

package/dist/client/index.js

@@ -1,14 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DainTunnel = void 0;
-const ws_1 = __importDefault(require("ws"));
-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");
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+import { createHmac } from "crypto";
+import { parseAPIKey } from "@dainprotocol/service-sdk/service/auth";
 const TIMEOUTS = {
     HEARTBEAT: 25000,
     REQUEST: 25000,
@@ -17,12 +10,33 @@ const TIMEOUTS = {
     SHUTDOWN_GRACE: 500,
 };
 const RECONNECT = {
-    MAX_ATTEMPTS: 10, // Increase from 5
-    BASE_DELAY: 1000, // Start at 1s
-    MAX_DELAY: 30000, // Cap at 30s
-    JITTER: 0.3, // 30% randomization
+    MAX_ATTEMPTS: 10,
+    BASE_DELAY: 1000,
+    MAX_DELAY: 30000,
+    JITTER: 0.3,
+};
+const LIMITS = {
+    MAX_PENDING_WS_MESSAGES_PER_CONNECTION: 256,
 };
-class DainTunnel extends events_1.EventEmitter {
+function rawDataToString(message) {
+    if (typeof message === "string")
+        return message;
+    if (Buffer.isBuffer(message))
+        return message.toString("utf8");
+    if (Array.isArray(message))
+        return Buffer.concat(message).toString("utf8");
+    return Buffer.from(message).toString("utf8");
+}
+function rawDataToBuffer(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    if (typeof data === "string")
+        return Buffer.from(data, "utf8");
+    return Buffer.from(data);
+}
+class DainTunnel extends EventEmitter {
     constructor(serverUrl, apiKey) {
         super();
         this.serverUrl = serverUrl;
@@ -31,34 +45,30 @@ class DainTunnel extends events_1.EventEmitter {
         this.port = null;
         this.reconnectAttempts = 0;
         this.webSocketClients = new Map();
-        this.sseClients = new Map();
+        this.pendingWebSocketMessages = new Map();
+        this.sseAbortControllers = new Map();
         this.heartbeatInterval = null;
-        const parsed = (0, auth_1.parseAPIKey)(apiKey);
+        this.reconnectTimer = null;
+        this.isStopping = false;
+        const parsed = 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}`;
         this.secret = parsed.secret;
-        this.httpAgent = new http_1.default.Agent({
-            keepAlive: true,
-            keepAliveMsecs: 30000,
-            maxSockets: 100,
-            maxFreeSockets: 20,
-        });
     }
     signChallenge(challenge) {
-        return (0, crypto_1.createHmac)('sha256', this.secret).update(challenge).digest('hex');
+        return 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) {
+            if (this.ws?.readyState === WebSocket.OPEN) {
                 this.ws.send(JSON.stringify(data));
                 return true;
             }
         }
-        catch (_b) {
+        catch {
             // Connection lost during send
         }
         return false;
@@ -66,12 +76,11 @@ class DainTunnel extends events_1.EventEmitter {
     startHeartbeat() {
         this.stopHeartbeat();
         this.heartbeatInterval = setInterval(() => {
-            var _a;
-            if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === ws_1.default.OPEN) {
+            if (this.ws?.readyState === WebSocket.OPEN) {
                 try {
                     this.ws.ping();
                 }
-                catch (_b) {
+                catch {
                     this.emit("error", new Error("Heartbeat ping failed"));
                 }
             }
@@ -84,6 +93,7 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     async start(port) {
+        this.isStopping = false;
         this.port = port;
         return this.connect();
     }
@@ -107,7 +117,7 @@ class DainTunnel extends events_1.EventEmitter {
                 }
             };
             try {
-                this.ws = new ws_1.default(this.serverUrl);
+                this.ws = new WebSocket(this.serverUrl);
                 this.ws.on("open", async () => {
                     this.reconnectAttempts = 0;
                     try {
@@ -130,7 +140,7 @@ class DainTunnel extends events_1.EventEmitter {
                 });
                 this.ws.on("message", (data) => {
                     try {
-                        this.handleMessage(JSON.parse(data), (url) => finish(url));
+                        this.handleMessage(JSON.parse(rawDataToString(data)), (url) => finish(url));
                     }
                     catch (err) {
                         finish(undefined, err);
@@ -139,6 +149,9 @@ class DainTunnel extends events_1.EventEmitter {
                 this.ws.on("close", () => {
                     this.stopHeartbeat();
                     this.cleanupAllClients();
+                    this.ws = null;
+                    if (this.isStopping)
+                        return;
                     if (this.tunnelUrl) {
                         this.emit("disconnected");
                         this.attemptReconnect();
@@ -149,13 +162,12 @@ class DainTunnel extends events_1.EventEmitter {
                 });
                 this.ws.on("error", (error) => this.emit("error", error));
                 connectionTimeoutId = setTimeout(() => {
-                    var _a;
-                    if (!resolved && (!this.ws || this.ws.readyState !== ws_1.default.OPEN)) {
+                    if (!resolved && (!this.ws || this.ws.readyState !== WebSocket.OPEN)) {
                         finish(undefined, new Error("Connection timeout"));
                         try {
-                            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.terminate();
+                            this.ws?.terminate();
                         }
-                        catch (_b) { }
+                        catch { }
                     }
                 }, TIMEOUTS.CONNECTION);
             }
@@ -165,21 +177,22 @@ class DainTunnel extends events_1.EventEmitter {
         });
     }
     cleanupAllClients() {
-        for (const client of this.sseClients.values()) {
+        for (const controller of this.sseAbortControllers.values()) {
             try {
-                client.destroy();
+                controller.abort();
             }
-            catch (_a) { }
+            catch { }
         }
-        this.sseClients.clear();
+        this.sseAbortControllers.clear();
         for (const client of this.webSocketClients.values()) {
             try {
-                if (client.readyState === ws_1.default.OPEN)
+                if (client.readyState === WebSocket.OPEN)
                     client.close(1001);
             }
-            catch (_b) { }
+            catch { }
         }
         this.webSocketClients.clear();
+        this.pendingWebSocketMessages.clear();
     }
     async requestChallenge() {
         return new Promise((resolve, reject) => {
@@ -190,11 +203,10 @@ class DainTunnel extends events_1.EventEmitter {
             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);
+                this.ws?.removeListener("message", challengeHandler);
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                     timeoutId = null;
@@ -208,12 +220,12 @@ class DainTunnel extends events_1.EventEmitter {
             };
             const challengeHandler = (message) => {
                 try {
-                    const data = JSON.parse(message);
+                    const data = JSON.parse(rawDataToString(message));
                     if (data.type === "challenge") {
                         finish(data.challenge);
                     }
                 }
-                catch (_a) { }
+                catch { }
             };
             this.ws.on("message", challengeHandler);
             this.ws.send(JSON.stringify({ type: "challenge_request" }));
@@ -272,28 +284,31 @@ class DainTunnel extends events_1.EventEmitter {
             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}`, {
+            delete headers.host;
+            const client = new WebSocket(`ws://localhost:${this.port}${message.path}`, {
                 headers
             });
+            this.pendingWebSocketMessages.set(message.id, []);
             this.webSocketClients.set(message.id, client);
+            client.on('open', () => {
+                this.flushPendingWebSocketMessages(message.id, sendWsEvent);
+            });
             client.on('message', (data) => {
-                sendWsEvent('message', data.toString('base64'));
+                sendWsEvent('message', rawDataToBuffer(data).toString('base64'));
             });
             client.on('close', () => {
                 sendWsEvent('close');
-                this.webSocketClients.delete(message.id);
+                this.cleanupWebSocketConnection(message.id);
             });
             client.on('error', (error) => {
                 sendWsEvent('error', error.message);
-                this.webSocketClients.delete(message.id);
+                this.cleanupWebSocketConnection(message.id);
             });
             this.emit("websocket_connection", { id: message.id, path: message.path });
         }
@@ -307,25 +322,63 @@ class DainTunnel extends events_1.EventEmitter {
             return;
         switch (message.event) {
             case 'message':
-                if (message.data && client.readyState === ws_1.default.OPEN) {
+                if (!message.data)
+                    return;
+                if (client.readyState === WebSocket.OPEN) {
                     client.send(Buffer.from(message.data, 'base64'));
+                    return;
+                }
+                if (client.readyState !== WebSocket.CONNECTING)
+                    return;
+                const pending = this.pendingWebSocketMessages.get(message.id);
+                if (!pending)
+                    return;
+                if (pending.length >= LIMITS.MAX_PENDING_WS_MESSAGES_PER_CONNECTION) {
+                    client.close(1013, "WebSocket upstream overloaded");
+                    this.cleanupWebSocketConnection(message.id);
+                    return;
                 }
+                pending.push(Buffer.from(message.data, 'base64'));
                 break;
             case 'close':
-                if (client.readyState === ws_1.default.OPEN) {
+                if (client.readyState === WebSocket.OPEN || client.readyState === WebSocket.CONNECTING) {
                     client.close();
                 }
-                this.webSocketClients.delete(message.id);
+                this.cleanupWebSocketConnection(message.id);
+                break;
+            case 'error':
+                if (client.readyState === WebSocket.OPEN || client.readyState === WebSocket.CONNECTING) {
+                    client.close(1011, message.data);
+                }
+                this.cleanupWebSocketConnection(message.id);
                 break;
         }
     }
+    flushPendingWebSocketMessages(id, sendWsEvent) {
+        const client = this.webSocketClients.get(id);
+        const pending = this.pendingWebSocketMessages.get(id);
+        if (!client || !pending || pending.length === 0)
+            return;
+        try {
+            while (pending.length > 0 && client.readyState === WebSocket.OPEN) {
+                client.send(pending.shift());
+            }
+        }
+        catch (error) {
+            sendWsEvent("error", error.message);
+            this.cleanupWebSocketConnection(id);
+        }
+    }
+    cleanupWebSocketConnection(id) {
+        this.pendingWebSocketMessages.delete(id);
+        this.webSocketClients.delete(id);
+    }
     handleSSEConnection(message) {
         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;
             if (originalHost && !headers['x-forwarded-host']) {
                 headers['x-forwarded-host'] = originalHost;
@@ -333,29 +386,35 @@ class DainTunnel extends events_1.EventEmitter {
             }
             delete headers.host;
             headers['accept-encoding'] = 'identity';
-            const req = http_1.default.request({
-                hostname: 'localhost',
-                port: this.port,
-                path: message.path,
+            const abortController = new AbortController();
+            this.sseAbortControllers.set(message.id, abortController);
+            const url = `http://localhost:${this.port}${message.path}`;
+            const fetchOptions = {
                 method: message.method || 'GET',
                 headers,
-                agent: this.httpAgent,
-            }, (res) => {
-                if (res.statusCode !== 200) {
-                    let errorBody = '';
-                    res.on('data', (chunk) => { errorBody += chunk.toString(); });
-                    res.on('end', () => {
-                        sendSseEvent('error', `Status ${res.statusCode}: ${errorBody.substring(0, 200)}`);
-                    });
+                signal: abortController.signal,
+            };
+            if (message.body && message.method !== 'GET') {
+                fetchOptions.body = Buffer.from(message.body, 'base64');
+            }
+            fetch(url, fetchOptions)
+                .then(async (res) => {
+                if (res.status !== 200) {
+                    const errorBody = await res.text();
+                    sendSseEvent('error', `Status ${res.status}: ${errorBody.substring(0, 200)}`);
+                    this.sseAbortControllers.delete(message.id);
                     return;
                 }
-                const socket = res.socket || res.connection;
-                if (socket === null || socket === void 0 ? void 0 : socket.setNoDelay)
-                    socket.setNoDelay(true);
                 sendSseEvent('connected');
+                if (!res.body) {
+                    sendSseEvent('close');
+                    this.sseAbortControllers.delete(message.id);
+                    return;
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
                 let buffer = '';
                 const processBuffer = () => {
-                    // Normalize line endings once
                     if (buffer.indexOf('\r') >= 0) {
                         buffer = buffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
                     }
@@ -363,7 +422,6 @@ class DainTunnel extends events_1.EventEmitter {
                     while ((idx = buffer.indexOf('\n\n')) >= 0) {
                         const msgData = buffer.slice(0, idx);
                         buffer = buffer.slice(idx + 2);
-                        // Skip empty messages and comments
                         if (!msgData || msgData[0] === ':')
                             continue;
                         let event = 'message';
@@ -382,30 +440,36 @@ class DainTunnel extends events_1.EventEmitter {
                             sendSseEvent(event, data);
                     }
                 };
-                res.on('data', (chunk) => {
-                    buffer += chunk.toString();
-                    processBuffer();
-                });
-                res.on('end', () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        processBuffer();
+                    }
+                    // Process remaining buffer
                     if (buffer.trim()) {
                         buffer += '\n\n';
                         processBuffer();
                     }
                     sendSseEvent('close');
-                });
-            });
-            req.on('socket', (socket) => {
-                socket.setNoDelay(true);
-                socket.setTimeout(0);
-            });
-            req.on('error', (error) => {
-                sendSseEvent('error', error.message);
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        sendSseEvent('error', err.message);
+                    }
+                }
+                finally {
+                    this.sseAbortControllers.delete(message.id);
+                }
+            })
+                .catch((error) => {
+                if (error.name !== 'AbortError') {
+                    sendSseEvent('error', error.message);
+                }
+                this.sseAbortControllers.delete(message.id);
             });
-            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) {
@@ -413,125 +477,92 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     handleSSEClose(message) {
-        const client = this.sseClients.get(message.id);
-        if (client) {
-            client.destroy();
-            this.sseClients.delete(message.id);
+        const controller = this.sseAbortControllers.get(message.id);
+        if (controller) {
+            controller.abort();
+            this.sseAbortControllers.delete(message.id);
         }
     }
-    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);
-                }
-            };
-            // Preserve original host for JWT audience validation
-            const headers = { ...request.headers };
-            const originalHost = request.headers.host;
-            if (originalHost && !headers['x-forwarded-host']) {
-                headers['x-forwarded-host'] = originalHost;
-                headers['x-forwarded-proto'] = 'https';
-            }
-            delete headers.host;
-            const options = {
-                hostname: 'localhost',
-                port: this.port,
-                path: request.path,
-                method: request.method,
-                headers,
-                agent: this.httpAgent,
-                timeout: TIMEOUTS.REQUEST,
-            };
-            const req = http_1.default.request(options, (res) => {
-                const chunks = [];
-                res.on('data', (chunk) => chunks.push(chunk));
-                res.on('end', () => {
-                    const headers = { ...res.headers };
-                    delete headers['transfer-encoding'];
-                    delete headers['content-length'];
-                    finish({
-                        type: 'response',
-                        requestId: request.id,
-                        status: res.statusCode,
-                        headers,
-                        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', (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();
+    async forwardRequest(request) {
+        const headers = { ...request.headers };
+        const originalHost = request.headers.host;
+        if (originalHost && !headers['x-forwarded-host']) {
+            headers['x-forwarded-host'] = originalHost;
+            headers['x-forwarded-proto'] = 'https';
+        }
+        delete headers.host;
+        const url = `http://localhost:${this.port}${request.path}`;
+        const fetchOptions = {
+            method: request.method,
+            headers,
+            signal: AbortSignal.timeout(TIMEOUTS.REQUEST),
+        };
+        if (request.body && request.method !== 'GET') {
+            fetchOptions.body = Buffer.from(request.body, 'base64');
+        }
+        const res = await fetch(url, fetchOptions);
+        const responseBody = await res.arrayBuffer();
+        const responseHeaders = {};
+        res.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
         });
+        delete responseHeaders['transfer-encoding'];
+        delete responseHeaders['content-length'];
+        return {
+            type: 'response',
+            requestId: request.id,
+            status: res.status,
+            headers: responseHeaders,
+            body: Buffer.from(responseBody).toString('base64'),
+        };
     }
     attemptReconnect() {
+        if (this.isStopping)
+            return;
         if (this.reconnectAttempts >= RECONNECT.MAX_ATTEMPTS) {
             this.emit("max_reconnect_attempts");
             return;
         }
         this.reconnectAttempts++;
-        // Exponential backoff with jitter
         const baseDelay = Math.min(RECONNECT.BASE_DELAY * Math.pow(2, this.reconnectAttempts - 1), RECONNECT.MAX_DELAY);
         const jitter = baseDelay * RECONNECT.JITTER * (Math.random() - 0.5);
         const delay = Math.round(baseDelay + jitter);
         this.emit("reconnecting", { attempt: this.reconnectAttempts, delay });
-        setTimeout(async () => {
+        this.reconnectTimer = setTimeout(async () => {
             try {
                 await this.connect();
                 this.emit("reconnected");
             }
-            catch (_a) {
-                // connect() will call attemptReconnect again on close
+            catch {
+                if (!this.isStopping)
+                    this.attemptReconnect();
             }
         }, delay);
     }
-    /**
-     * Reset reconnection attempts counter.
-     * Call this to allow reconnection after max_reconnect_attempts was reached.
-     */
     resetReconnection() {
         this.reconnectAttempts = 0;
     }
     async stop() {
+        this.isStopping = true;
         this.stopHeartbeat();
         this.cleanupAllClients();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         if (this.ws) {
             try {
-                if (this.ws.readyState === ws_1.default.OPEN)
+                if (this.ws.readyState === WebSocket.OPEN)
                     this.ws.close();
             }
-            catch (_a) { }
+            catch { }
             this.ws = null;
         }
         this.tunnelUrl = null;
-        this.httpAgent.destroy();
         await new Promise(resolve => setTimeout(resolve, TIMEOUTS.SHUTDOWN_GRACE));
     }
 }
-exports.DainTunnel = DainTunnel;
-exports.default = {
+export { DainTunnel };
+export default {
     createTunnel: (serverUrl, apiKey) => new DainTunnel(serverUrl, apiKey),
 };

package/dist/server/index.d.ts

@@ -3,7 +3,7 @@ declare class DainTunnelServer {
     private port;
     private app;
     private server;
-    private wss;
+    private allowedCorsOrigins;
     private tunnels;
     private pendingRequests;
     private challenges;
@@ -12,11 +12,14 @@ declare class DainTunnelServer {
     private tunnelRequestCount;
     private safeSend;
     private decrementRequestCount;
+    private buildForwardedHeaders;
+    private buildTunnelUrl;
     constructor(hostname: string, port: number);
-    private setupExpressRoutes;
-    private setupWebSocketServer;
-    private handleTunnelClientConnection;
-    private handleProxiedWebSocketConnection;
+    private setupRoutes;
+    private handleWsOpen;
+    private handleWsMessage;
+    private handleWsClose;
+    private handleProxiedWebSocketClientMessage;
     private handleChallengeRequest;
     private handleStartMessage;
     private handleResponseMessage;