@dainprotocol/tunnel 1.1.35 → 2.0.0

package/dist/client/index.d.ts

@@ -10,8 +10,7 @@ declare class DainTunnel extends EventEmitter {
     private secret;
     private webSocketClients;
     private pendingWebSocketMessages;
-    private sseClients;
-    private httpAgent;
+    private sseAbortControllers;
     private heartbeatInterval;
     private reconnectTimer;
     private isStopping;
@@ -34,10 +33,6 @@ declare class DainTunnel extends EventEmitter {
     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,10 +10,10 @@ 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,
@@ -43,7 +36,7 @@ function rawDataToBuffer(data) {
         return Buffer.from(data, "utf8");
     return Buffer.from(data);
 }
-class DainTunnel extends events_1.EventEmitter {
+class DainTunnel extends EventEmitter {
     constructor(serverUrl, apiKey) {
         super();
         this.serverUrl = serverUrl;
@@ -53,36 +46,29 @@ class DainTunnel extends events_1.EventEmitter {
         this.reconnectAttempts = 0;
         this.webSocketClients = new Map();
         this.pendingWebSocketMessages = new Map();
-        this.sseClients = new Map();
+        this.sseAbortControllers = new Map();
         this.heartbeatInterval = null;
         this.reconnectTimer = null;
         this.isStopping = false;
-        const parsed = (0, auth_1.parseAPIKey)(apiKey);
+        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;
@@ -90,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"));
                 }
             }
@@ -132,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 {
@@ -177,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);
             }
@@ -193,19 +177,19 @@ 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();
@@ -219,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;
@@ -242,7 +225,7 @@ class DainTunnel extends events_1.EventEmitter {
                         finish(data.challenge);
                     }
                 }
-                catch (_a) { }
+                catch { }
             };
             this.ws.on("message", challengeHandler);
             this.ws.send(JSON.stringify({ type: "challenge_request" }));
@@ -301,15 +284,14 @@ 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, []);
@@ -342,11 +324,11 @@ class DainTunnel extends events_1.EventEmitter {
             case 'message':
                 if (!message.data)
                     return;
-                if (client.readyState === ws_1.default.OPEN) {
+                if (client.readyState === WebSocket.OPEN) {
                     client.send(Buffer.from(message.data, 'base64'));
                     return;
                 }
-                if (client.readyState !== ws_1.default.CONNECTING)
+                if (client.readyState !== WebSocket.CONNECTING)
                     return;
                 const pending = this.pendingWebSocketMessages.get(message.id);
                 if (!pending)
@@ -359,13 +341,13 @@ class DainTunnel extends events_1.EventEmitter {
                 pending.push(Buffer.from(message.data, 'base64'));
                 break;
             case 'close':
-                if (client.readyState === ws_1.default.OPEN || client.readyState === ws_1.default.CONNECTING) {
+                if (client.readyState === WebSocket.OPEN || client.readyState === WebSocket.CONNECTING) {
                     client.close();
                 }
                 this.cleanupWebSocketConnection(message.id);
                 break;
             case 'error':
-                if (client.readyState === ws_1.default.OPEN || client.readyState === ws_1.default.CONNECTING) {
+                if (client.readyState === WebSocket.OPEN || client.readyState === WebSocket.CONNECTING) {
                     client.close(1011, message.data);
                 }
                 this.cleanupWebSocketConnection(message.id);
@@ -378,7 +360,7 @@ class DainTunnel extends events_1.EventEmitter {
         if (!client || !pending || pending.length === 0)
             return;
         try {
-            while (pending.length > 0 && client.readyState === ws_1.default.OPEN) {
+            while (pending.length > 0 && client.readyState === WebSocket.OPEN) {
                 client.send(pending.shift());
             }
         }
@@ -397,7 +379,6 @@ class DainTunnel extends events_1.EventEmitter {
         };
         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;
@@ -405,34 +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) => {
-                const cleanup = () => {
-                    this.sseClients.delete(message.id);
-                };
-                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)}`);
-                        cleanup();
-                    });
-                    res.on('close', cleanup);
+                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');
                     }
@@ -440,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';
@@ -459,40 +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');
-                    cleanup();
-                });
-                res.on('close', cleanup);
-                res.on('error', (error) => {
+                }
+                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);
-                    cleanup();
-                });
-            });
-            req.on('socket', (socket) => {
-                socket.setNoDelay(true);
-                socket.setTimeout(0);
-            });
-            req.on('error', (error) => {
-                sendSseEvent('error', error.message);
-                this.sseClients.delete(message.id);
-            });
-            req.on('close', () => {
-                this.sseClients.delete(message.id);
+                }
+                this.sseAbortControllers.delete(message.id);
             });
-            this.sseClients.set(message.id, req);
-            if (message.body && message.method !== 'GET') {
-                req.write(Buffer.from(message.body, 'base64'));
-            }
-            req.end();
             this.emit("sse_connection", { id: message.id, path: message.path });
         }
         catch (error) {
@@ -500,79 +477,44 @@ 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)
@@ -582,7 +524,6 @@ class DainTunnel extends events_1.EventEmitter {
             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);
@@ -592,16 +533,12 @@ class DainTunnel extends events_1.EventEmitter {
                 await this.connect();
                 this.emit("reconnected");
             }
-            catch (_a) {
+            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;
     }
@@ -615,18 +552,17 @@ class DainTunnel extends events_1.EventEmitter {
         }
         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;
@@ -15,10 +15,11 @@ declare class DainTunnelServer {
     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;