@dainprotocol/tunnel 1.1.31 → 1.1.35

package/dist/client/index.d.ts

@@ -9,9 +9,12 @@ declare class DainTunnel extends EventEmitter {
     private tunnelId;
     private secret;
     private webSocketClients;
+    private pendingWebSocketMessages;
     private sseClients;
     private httpAgent;
     private heartbeatInterval;
+    private reconnectTimer;
+    private isStopping;
     constructor(serverUrl: string, apiKey: string);
     private signChallenge;
     private safeSend;
@@ -25,10 +28,17 @@ 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>;
 }
 export { DainTunnel };

package/dist/client/index.js

@@ -14,12 +14,35 @@ const TIMEOUTS = {
     REQUEST: 25000,
     CONNECTION: 10000,
     CHALLENGE: 5000,
-    RECONNECT_DELAY: 5000,
     SHUTDOWN_GRACE: 500,
 };
 const RECONNECT = {
-    MAX_ATTEMPTS: 5,
+    MAX_ATTEMPTS: 10, // Increase from 5
+    BASE_DELAY: 1000, // Start at 1s
+    MAX_DELAY: 30000, // Cap at 30s
+    JITTER: 0.3, // 30% randomization
 };
+const LIMITS = {
+    MAX_PENDING_WS_MESSAGES_PER_CONNECTION: 256,
+};
+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 events_1.EventEmitter {
     constructor(serverUrl, apiKey) {
         super();
@@ -29,8 +52,11 @@ class DainTunnel extends events_1.EventEmitter {
         this.port = null;
         this.reconnectAttempts = 0;
         this.webSocketClients = new Map();
+        this.pendingWebSocketMessages = new Map();
         this.sseClients = new Map();
         this.heartbeatInterval = null;
+        this.reconnectTimer = null;
+        this.isStopping = false;
         const parsed = (0, auth_1.parseAPIKey)(apiKey);
         if (!parsed) {
             throw new Error('Invalid API key format. Expected: sk_agent_{agentId}_{orgId}_{secret}');
@@ -82,6 +108,7 @@ class DainTunnel extends events_1.EventEmitter {
         }
     }
     async start(port) {
+        this.isStopping = false;
         this.port = port;
         return this.connect();
     }
@@ -128,7 +155,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);
@@ -137,6 +164,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();
@@ -178,6 +208,7 @@ class DainTunnel extends events_1.EventEmitter {
             catch (_b) { }
         }
         this.webSocketClients.clear();
+        this.pendingWebSocketMessages.clear();
     }
     async requestChallenge() {
         return new Promise((resolve, reject) => {
@@ -206,7 +237,7 @@ 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);
                     }
@@ -281,17 +312,21 @@ class DainTunnel extends events_1.EventEmitter {
             const client = new ws_1.default(`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 });
         }
@@ -305,18 +340,57 @@ 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 === ws_1.default.OPEN) {
                     client.send(Buffer.from(message.data, 'base64'));
+                    return;
+                }
+                if (client.readyState !== ws_1.default.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 === ws_1.default.OPEN || client.readyState === ws_1.default.CONNECTING) {
                     client.close();
                 }
-                this.webSocketClients.delete(message.id);
+                this.cleanupWebSocketConnection(message.id);
+                break;
+            case 'error':
+                if (client.readyState === ws_1.default.OPEN || client.readyState === ws_1.default.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 === ws_1.default.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 });
@@ -339,12 +413,17 @@ class DainTunnel extends events_1.EventEmitter {
                 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);
                     return;
                 }
                 const socket = res.socket || res.connection;
@@ -390,6 +469,12 @@ class DainTunnel extends events_1.EventEmitter {
                         processBuffer();
                     }
                     sendSseEvent('close');
+                    cleanup();
+                });
+                res.on('close', cleanup);
+                res.on('error', (error) => {
+                    sendSseEvent('error', error.message);
+                    cleanup();
                 });
             });
             req.on('socket', (socket) => {
@@ -398,12 +483,16 @@ class DainTunnel extends events_1.EventEmitter {
             });
             req.on('error', (error) => {
                 sendSseEvent('error', error.message);
+                this.sseClients.delete(message.id);
+            });
+            req.on('close', () => {
+                this.sseClients.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.sseClients.set(message.id, req);
             this.emit("sse_connection", { id: message.id, path: message.path });
         }
         catch (error) {
@@ -486,22 +575,44 @@ class DainTunnel extends events_1.EventEmitter {
         });
     }
     attemptReconnect() {
-        if (this.reconnectAttempts < RECONNECT.MAX_ATTEMPTS) {
-            this.reconnectAttempts++;
-            setTimeout(async () => {
-                try {
-                    await this.connect();
-                }
-                catch (_a) { }
-            }, TIMEOUTS.RECONNECT_DELAY);
-        }
-        else {
+        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 });
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+                this.emit("reconnected");
+            }
+            catch (_a) {
+                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)

package/dist/server/index.d.ts

@@ -12,6 +12,8 @@ declare class DainTunnelServer {
     private tunnelRequestCount;
     private safeSend;
     private decrementRequestCount;
+    private buildForwardedHeaders;
+    private buildTunnelUrl;
     constructor(hostname: string, port: number);
     private setupExpressRoutes;
     private setupWebSocketServer;

package/dist/server/index.js

@@ -41,6 +41,27 @@ function extractPathParts(url) {
     const path = qIdx >= 0 ? url.slice(0, qIdx) : url;
     return path.split('/');
 }
+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 rawDataToBase64(data) {
+    if (typeof data === "string")
+        return Buffer.from(data, "utf8").toString("base64");
+    if (Buffer.isBuffer(data))
+        return data.toString("base64");
+    if (Array.isArray(data))
+        return Buffer.concat(data).toString("base64");
+    return Buffer.from(data).toString("base64");
+}
+function normalizeHostToBaseUrl(hostname) {
+    return /^https?:\/\//i.test(hostname) ? hostname : `http://${hostname}`;
+}
 class DainTunnelServer {
     safeSend(ws, data) {
         try {
@@ -55,8 +76,29 @@ class DainTunnelServer {
         return false;
     }
     decrementRequestCount(tunnelId) {
-        const currentCount = this.tunnelRequestCount.get(tunnelId) || 1;
-        this.tunnelRequestCount.set(tunnelId, Math.max(0, currentCount - 1));
+        const currentCount = this.tunnelRequestCount.get(tunnelId);
+        if (!currentCount)
+            return;
+        if (currentCount <= 1) {
+            this.tunnelRequestCount.delete(tunnelId);
+            return;
+        }
+        this.tunnelRequestCount.set(tunnelId, currentCount - 1);
+    }
+    buildForwardedHeaders(headers, tunnelId) {
+        const forwardedHeaders = { ...headers };
+        if (!forwardedHeaders["x-forwarded-prefix"]) {
+            forwardedHeaders["x-forwarded-prefix"] = `/${tunnelId}`;
+        }
+        return forwardedHeaders;
+    }
+    buildTunnelUrl(tunnelId) {
+        const baseUrl = normalizeHostToBaseUrl(this.hostname);
+        const url = new URL(baseUrl);
+        if (process.env.SKIP_PORT !== "true" && !url.port) {
+            url.port = String(this.port);
+        }
+        return `${url.toString().replace(/\/$/, "")}/${tunnelId}`;
     }
     constructor(hostname, port) {
         this.hostname = hostname;
@@ -149,7 +191,7 @@ class DainTunnelServer {
     handleTunnelClientConnection(ws, req) {
         ws.on("message", (message) => {
             try {
-                const data = JSON.parse(message);
+                const data = JSON.parse(rawDataToString(message));
                 switch (data.type) {
                     case "challenge_request":
                         this.handleChallengeRequest(ws);
@@ -190,18 +232,19 @@ class DainTunnelServer {
             return;
         }
         const wsConnectionId = fastId();
+        const forwardedHeaders = this.buildForwardedHeaders(req.headers, tunnelId);
         this.wsConnections.set(wsConnectionId, {
             clientSocket: ws,
             id: wsConnectionId,
             path: remainingPath,
-            headers: req.headers,
+            headers: forwardedHeaders,
             tunnelId
         });
         this.safeSend(tunnel.ws, {
             type: "websocket_connection",
             id: wsConnectionId,
             path: remainingPath,
-            headers: req.headers
+            headers: forwardedHeaders
         });
         const sendToTunnel = (event, data) => {
             const currentTunnel = this.tunnels.get(tunnelId);
@@ -209,7 +252,7 @@ class DainTunnelServer {
                 this.safeSend(currentTunnel.ws, { type: "websocket", id: wsConnectionId, event, data });
             }
         };
-        ws.on("message", (data) => sendToTunnel("message", data.toString('base64')));
+        ws.on("message", (data) => sendToTunnel("message", rawDataToBase64(data)));
         ws.on("close", () => { sendToTunnel("close"); this.wsConnections.delete(wsConnectionId); });
         ws.on("error", (error) => sendToTunnel("error", error.message));
     }
@@ -291,10 +334,7 @@ class DainTunnelServer {
             }, TIMEOUTS.PING_INTERVAL);
             ws.keepAliveInterval = intervalId;
             ws.on("close", () => clearInterval(intervalId));
-            let tunnelUrl = this.hostname;
-            if (process.env.SKIP_PORT !== "true")
-                tunnelUrl += `:${this.port}`;
-            tunnelUrl += `/${tunnelId}`;
+            const tunnelUrl = this.buildTunnelUrl(tunnelId);
             ws.send(JSON.stringify({ type: "tunnelUrl", url: tunnelUrl }));
             console.log(`[Tunnel] Created: ${tunnelUrl}`);
         }
@@ -389,6 +429,13 @@ class DainTunnelServer {
         const tunnelId = req.params.tunnelId;
         if (((_a = req.headers.upgrade) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'websocket')
             return;
+        if (!tunnelId || !tunnelId.includes("_")) {
+            res.status(404).json({
+                error: "Not Found",
+                message: `Tunnel "${tunnelId}" does not exist.`,
+            });
+            return;
+        }
         let tunnel;
         let retries = LIMITS.TUNNEL_RETRY_COUNT;
         while (retries > 0 && !tunnel) {
@@ -399,7 +446,6 @@ class DainTunnelServer {
             }
         }
         if (!tunnel) {
-            this.decrementRequestCount(tunnelId);
             res.status(502).json({
                 error: "Bad Gateway",
                 message: `Tunnel "${tunnelId}" not connected. The service may be offline or reconnecting.`,
@@ -441,7 +487,7 @@ class DainTunnelServer {
             id: requestId,
             method: req.method,
             path: req.url,
-            headers: req.headers,
+            headers: this.buildForwardedHeaders(req.headers, tunnelId),
             body: hasBody ? req.body.toString("base64") : undefined,
         });
         if (!sent) {
@@ -507,7 +553,7 @@ class DainTunnelServer {
             id: sseId,
             path: req.url,
             method: req.method,
-            headers: req.headers,
+            headers: this.buildForwardedHeaders(req.headers, tunnelId),
             body: hasBody ? req.body.toString("base64") : undefined
         });
         if (!sent) {
@@ -609,7 +655,6 @@ class DainTunnelServer {
         for (const [challenge, obj] of this.challenges.entries()) {
             if (obj.ws === ws) {
                 this.challenges.delete(challenge);
-                break;
             }
         }
     }
@@ -624,7 +669,33 @@ class DainTunnelServer {
     async stop() {
         return new Promise((resolve) => {
             try {
+                for (const tunnel of this.tunnels.values()) {
+                    if (tunnel.ws.keepAliveInterval)
+                        clearInterval(tunnel.ws.keepAliveInterval);
+                    try {
+                        tunnel.ws.terminate();
+                    }
+                    catch (error) {
+                        console.error(`Error closing tunnel ${tunnel.id}:`, error);
+                    }
+                }
+                this.tunnels.clear();
+                this.tunnelRequestCount.clear();
+                for (const [requestId, pending] of this.pendingRequests.entries()) {
+                    if (pending.timeoutId)
+                        clearTimeout(pending.timeoutId);
+                    if (!pending.res.headersSent) {
+                        try {
+                            pending.res.status(503).json({ error: "Service Unavailable", message: "Server shutting down" });
+                        }
+                        catch (_a) { }
+                    }
+                    this.pendingRequests.delete(requestId);
+                }
+                this.challenges.clear();
                 for (const [sseId, conn] of this.sseConnections.entries()) {
+                    if (conn.keepAliveInterval)
+                        clearInterval(conn.keepAliveInterval);
                     try {
                         conn.res.end();
                     }
@@ -642,7 +713,16 @@ class DainTunnelServer {
                     }
                     this.wsConnections.delete(wsId);
                 }
+                for (const socket of this.wss.clients) {
+                    try {
+                        socket.terminate();
+                    }
+                    catch (_b) { }
+                }
                 this.wss.close(() => {
+                    var _a, _b, _c, _d;
+                    (_b = (_a = this.server).closeIdleConnections) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    (_d = (_c = this.server).closeAllConnections) === null || _d === void 0 ? void 0 : _d.call(_c);
                     this.server.close(() => resolve());
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.1.31",
+  "version": "1.1.35",
   "description": "",
   "main": "dist/index.js",
   "private": false,
@@ -20,7 +20,7 @@
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "2.0.75",
+    "@dainprotocol/service-sdk": "2.0.82",
     "@types/body-parser": "^1.19.5",
     "@types/cors": "^2.8.17",
     "@types/eventsource": "^3.0.0",