@dainprotocol/tunnel 2.0.0 → 2.0.3

package/dist/client/index.js

@@ -18,6 +18,11 @@ const RECONNECT = {
 const LIMITS = {
     MAX_PENDING_WS_MESSAGES_PER_CONNECTION: 256,
 };
+function emitClientError(emitter, error) {
+    if (emitter.listenerCount("error") > 0) {
+        emitter.emit("error", error);
+    }
+}
 function rawDataToString(message) {
     if (typeof message === "string")
         return message;
@@ -81,7 +86,7 @@ class DainTunnel extends EventEmitter {
                     this.ws.ping();
                 }
                 catch {
-                    this.emit("error", new Error("Heartbeat ping failed"));
+                    emitClientError(this, new Error("Heartbeat ping failed"));
                 }
             }
         }, TIMEOUTS.HEARTBEAT);
@@ -160,7 +165,7 @@ class DainTunnel extends EventEmitter {
                         finish(undefined, new Error("Connection closed before tunnel established"));
                     }
                 });
-                this.ws.on("error", (error) => this.emit("error", error));
+                this.ws.on("error", (error) => emitClientError(this, error));
                 connectionTimeoutId = setTimeout(() => {
                     if (!resolved && (!this.ws || this.ws.readyState !== WebSocket.OPEN)) {
                         finish(undefined, new Error("Connection timeout"));
@@ -552,8 +557,12 @@ class DainTunnel extends EventEmitter {
         }
         if (this.ws) {
             try {
-                if (this.ws.readyState === WebSocket.OPEN)
-                    this.ws.close();
+                if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+                    this.ws.close(1000, "Client stopping");
+                }
+                else if (this.ws.readyState !== WebSocket.CLOSED) {
+                    this.ws.terminate();
+                }
             }
             catch { }
             this.ws = null;

package/dist/server/index.d.ts

@@ -9,7 +9,9 @@ declare class DainTunnelServer {
     private challenges;
     private sseConnections;
     private wsConnections;
+    private pendingProxiedWSEvents;
     private tunnelRequestCount;
+    private buildCorsHeaders;
     private safeSend;
     private decrementRequestCount;
     private buildForwardedHeaders;
@@ -26,6 +28,7 @@ declare class DainTunnelServer {
     private handleSSEMessage;
     private cleanupSSEConnection;
     private handleWebSocketMessage;
+    private flushPendingWebSocketEvents;
     private handleRequest;
     private handleSSERequest;
     private removeTunnel;

package/dist/server/index.js

@@ -15,10 +15,20 @@ const LIMITS = {
     MAX_MISSED_PONGS: 2,
     MAX_PAYLOAD_BYTES: 100 * 1024 * 1024,
     BACKPRESSURE_THRESHOLD: 1024 * 1024,
+    MAX_PENDING_WS_EVENTS_PER_CONNECTION: 256,
     SERVER_MAX_HEADERS: 100,
     WS_BACKLOG: 100,
     TUNNEL_RETRY_COUNT: 2,
 };
+const DEBUG_TUNNEL = process.env.DAIN_TUNNEL_DEBUG === "1";
+function debugLog(...args) {
+    if (DEBUG_TUNNEL)
+        console.log(...args);
+}
+function debugError(...args) {
+    if (DEBUG_TUNNEL)
+        console.error(...args);
+}
 let idCounter = 0;
 const ID_PREFIX = Date.now().toString(36);
 function fastId() {
@@ -52,6 +62,21 @@ function isCorsOriginAllowed(origin, allowedOrigins) {
 }
 const ALLOWED_CORS_ORIGINS = parseAllowedCorsOrigins(process.env.TUNNEL_ALLOWED_ORIGINS || process.env.CORS_ALLOWED_ORIGINS);
 class DainTunnelServer {
+    buildCorsHeaders(origin) {
+        const headers = {
+            "access-control-allow-methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+            "access-control-allow-headers": "X-DAIN-SIGNATURE, X-DAIN-SMART-ACCOUNT-PDA, X-DAIN-AGENT-ID, X-DAIN-ORG-ID, X-DAIN-ADDRESS, X-DAIN-TIMESTAMP, X-DAIN-WEBHOOK-URL, X-Service, X-Service-Token, Content-Type, Authorization, Accept, Origin, X-Requested-With",
+        };
+        if (origin && isCorsOriginAllowed(origin, this.allowedCorsOrigins)) {
+            headers["access-control-allow-origin"] = origin;
+            headers["access-control-allow-credentials"] = "true";
+            headers["vary"] = "Origin";
+        }
+        else if (!origin) {
+            headers["access-control-allow-origin"] = "*";
+        }
+        return headers;
+    }
     safeSend(ws, data) {
         try {
             if (ws.readyState === 1) { // WebSocket.OPEN
@@ -60,7 +85,7 @@ class DainTunnelServer {
             }
         }
         catch (error) {
-            console.error("[Tunnel] SafeSend error:", error);
+            debugError("[Tunnel] SafeSend error:", error);
         }
         return false;
     }
@@ -99,6 +124,7 @@ class DainTunnelServer {
         this.challenges = new Map();
         this.sseConnections = new Map();
         this.wsConnections = new Map();
+        this.pendingProxiedWSEvents = new Map();
         this.tunnelRequestCount = new Map();
         this.app = new Hono();
         this.setupRoutes();
@@ -183,7 +209,7 @@ class DainTunnelServer {
             }
         }
         catch (error) {
-            console.error("[Tunnel] Message error:", error);
+            debugError("[Tunnel] Message error:", error);
             ws.close(1008, "Invalid message");
         }
     }
@@ -279,7 +305,7 @@ class DainTunnelServer {
                 if (!isAlive) {
                     missedPongs++;
                     if (missedPongs >= LIMITS.MAX_MISSED_PONGS) {
-                        console.log(`[Tunnel] ${tunnelId} failed liveness check (${missedPongs} missed pongs), terminating`);
+                        debugLog(`[Tunnel] ${tunnelId} failed liveness check (${missedPongs} missed pongs), terminating`);
                         clearInterval(intervalId);
                         ws.close(1001, "Liveness check failed");
                         return;
@@ -300,13 +326,13 @@ class DainTunnelServer {
             // We track isAlive through the pong handler set up in Bun.serve websocket config
             const tunnelUrl = this.buildTunnelUrl(tunnelId);
             ws.send(JSON.stringify({ type: "tunnelUrl", url: tunnelUrl }));
-            console.log(`[Tunnel] Created: ${tunnelUrl}`);
+            debugLog(`[Tunnel] Created: ${tunnelUrl}`);
             // Store isAlive/missedPongs on ws.data for the pong handler
             ws.data._isAlive = true;
             ws.data._missedPongsReset = () => { isAlive = true; missedPongs = 0; };
         }
         catch (error) {
-            console.error(`Error in handleStartMessage for tunnel ${tunnelId}:`, error);
+            debugError(`Error in handleStartMessage for tunnel ${tunnelId}:`, error);
             ws.close(1011, "Internal server error");
         }
     }
@@ -314,7 +340,7 @@ class DainTunnelServer {
         const pendingRequest = this.pendingRequests.get(data.requestId);
         if (!pendingRequest)
             return;
-        const { resolve, tunnelId, timeoutId } = pendingRequest;
+        const { resolve, tunnelId, timeoutId, origin } = pendingRequest;
         this.pendingRequests.delete(data.requestId);
         if (timeoutId)
             clearTimeout(timeoutId);
@@ -322,6 +348,8 @@ class DainTunnelServer {
         const headers = data.headers;
         delete headers["transfer-encoding"];
         delete headers["content-length"];
+        // Inject CORS headers — Hono middleware doesn't apply to Promise-resolved responses
+        Object.assign(headers, this.buildCorsHeaders(origin));
         const bodyBuffer = Buffer.from(data.body, "base64");
         headers["content-length"] = bodyBuffer.length.toString();
         resolve(new Response(bodyBuffer, {
@@ -373,8 +401,28 @@ class DainTunnelServer {
     }
     handleWebSocketMessage(data) {
         const connection = this.wsConnections.get(data.id);
-        if (!connection)
+        if (!connection) {
+            const pendingEvents = this.pendingProxiedWSEvents.get(data.id);
+            if (!pendingEvents)
+                return;
+            if (data.event === "message" &&
+                pendingEvents.length >= LIMITS.MAX_PENDING_WS_EVENTS_PER_CONNECTION) {
+                pendingEvents.push({
+                    type: "websocket",
+                    id: data.id,
+                    event: "error",
+                    data: "WebSocket downstream overloaded",
+                });
+                pendingEvents.push({
+                    type: "websocket",
+                    id: data.id,
+                    event: "close",
+                });
+                return;
+            }
+            pendingEvents.push(data);
             return;
+        }
         const { clientSocket } = connection;
         const isOpen = clientSocket.readyState === 1;
         switch (data.event) {
@@ -394,6 +442,17 @@ class DainTunnelServer {
                 break;
         }
     }
+    flushPendingWebSocketEvents(id) {
+        const pendingEvents = this.pendingProxiedWSEvents.get(id);
+        if (!pendingEvents || pendingEvents.length === 0) {
+            this.pendingProxiedWSEvents.delete(id);
+            return;
+        }
+        this.pendingProxiedWSEvents.delete(id);
+        for (const event of pendingEvents) {
+            this.handleWebSocketMessage(event);
+        }
+    }
     async handleRequest(c) {
         const tunnelId = c.req.param("tunnelId");
         if (!tunnelId || !tunnelId.includes("_")) {
@@ -453,6 +512,8 @@ class DainTunnelServer {
             }
             catch { }
         }
+        const origin = c.req.header("origin");
+        const corsHeaders = this.buildCorsHeaders(origin);
         return new Promise((resolve) => {
             const timeoutId = setTimeout(() => {
                 const pendingRequest = this.pendingRequests.get(requestId);
@@ -461,11 +522,11 @@ class DainTunnelServer {
                     this.pendingRequests.delete(requestId);
                     resolve(new Response(JSON.stringify({ error: "Gateway Timeout", message: "Request timed out" }), {
                         status: 504,
-                        headers: { "content-type": "application/json" },
+                        headers: { "content-type": "application/json", ...corsHeaders },
                     }));
                 }
             }, TIMEOUTS.REQUEST_TIMEOUT);
-            this.pendingRequests.set(requestId, { resolve, startTime: Date.now(), tunnelId, timeoutId });
+            this.pendingRequests.set(requestId, { resolve, startTime: Date.now(), tunnelId, timeoutId, origin });
             const sent = this.safeSend(tunnel.ws, {
                 type: "request",
                 id: requestId,
@@ -480,19 +541,35 @@ class DainTunnelServer {
                 this.decrementRequestCount(tunnelId);
                 resolve(new Response(JSON.stringify({ error: "Bad Gateway", message: "Tunnel connection lost" }), {
                     status: 502,
-                    headers: { "content-type": "application/json" },
+                    headers: { "content-type": "application/json", ...corsHeaders },
                 }));
             }
         });
     }
-    handleSSERequest(c, tunnelId, tunnel) {
+    async handleSSERequest(c, tunnelId, tunnel) {
         const sseId = fastId();
+        const requestUrl = new URL(c.req.url);
+        let path = requestUrl.pathname.slice(`/${tunnelId}`.length) || "/";
+        if (requestUrl.search)
+            path += requestUrl.search;
         // Extract headers
         const reqHeaders = {};
         c.req.raw.headers.forEach((value, key) => {
             reqHeaders[key] = value;
         });
         const forwardedHeaders = this.buildForwardedHeaders(reqHeaders, tunnelId);
+        let bodyBase64;
+        if (c.req.method !== "GET" && c.req.method !== "HEAD") {
+            try {
+                const bodyBuffer = await c.req.arrayBuffer();
+                if (bodyBuffer.byteLength > 0) {
+                    bodyBase64 = Buffer.from(bodyBuffer).toString("base64");
+                }
+            }
+            catch {
+                // Best-effort body forwarding for streaming requests
+            }
+        }
         const origin = c.req.header("origin");
         const responseHeaders = {
             'Content-Type': 'text/event-stream',
@@ -540,9 +617,10 @@ class DainTunnelServer {
                 const sent = this.safeSend(tunnel.ws, {
                     type: "sse_connection",
                     id: sseId,
-                    path: new URL(c.req.url).pathname.slice(`/${tunnelId}`.length) || '/',
+                    path,
                     method: c.req.method,
                     headers: forwardedHeaders,
+                    body: bodyBase64,
                 });
                 if (!sent) {
                     this.cleanupSSEConnection(sseId, tunnelId);
@@ -577,7 +655,7 @@ class DainTunnelServer {
             this.cleanupChallengesForSocket(ws);
         }
         catch (error) {
-            console.error("[Tunnel] Remove error:", error);
+            debugError("[Tunnel] Remove error:", error);
         }
     }
     findAndRemoveTunnel(ws) {
@@ -604,7 +682,10 @@ class DainTunnelServer {
                     clearTimeout(pending.timeoutId);
                 pending.resolve(new Response(JSON.stringify({ error: "Bad Gateway", message: "Tunnel closed" }), {
                     status: 502,
-                    headers: { "content-type": "application/json" },
+                    headers: {
+                        "content-type": "application/json",
+                        ...this.buildCorsHeaders(pending.origin),
+                    },
                 }));
                 this.pendingRequests.delete(requestId);
             }
@@ -678,6 +759,13 @@ class DainTunnelServer {
                         reqHeaders[key] = value;
                     });
                     const forwardedHeaders = self.buildForwardedHeaders(reqHeaders, tunnelId);
+                    self._pendingProxiedWs = self._pendingProxiedWs || new Map();
+                    self._pendingProxiedWs.set(wsConnectionId, {
+                        tunnelId,
+                        path: remainingPath,
+                        headers: forwardedHeaders,
+                    });
+                    self.pendingProxiedWSEvents.set(wsConnectionId, []);
                     const success = server.upgrade(req, {
                         data: {
                             isProxiedWebSocket: true,
@@ -686,13 +774,6 @@ class DainTunnelServer {
                         },
                     });
                     if (success) {
-                        // Store setup info so open handler can register the connection
-                        self._pendingProxiedWs = self._pendingProxiedWs || new Map();
-                        self._pendingProxiedWs.set(wsConnectionId, {
-                            tunnelId,
-                            path: remainingPath,
-                            headers: forwardedHeaders,
-                        });
                         self.safeSend(tunnel.ws, {
                             type: "websocket_connection",
                             id: wsConnectionId,
@@ -701,6 +782,8 @@ class DainTunnelServer {
                         });
                         return undefined;
                     }
+                    self._pendingProxiedWs?.delete(wsConnectionId);
+                    self.pendingProxiedWSEvents.delete(wsConnectionId);
                     return new Response("WebSocket upgrade failed", { status: 400 });
                 }
                 // Regular HTTP request - pass to Hono
@@ -720,6 +803,7 @@ class DainTunnelServer {
                                 tunnelId: pending.tunnelId,
                             });
                             pendingMap.delete(ws.data.proxiedWsId);
+                            self.flushPendingWebSocketEvents(ws.data.proxiedWsId);
                         }
                     }
                     self.handleWsOpen(ws);
@@ -741,7 +825,7 @@ class DainTunnelServer {
                 backpressureLimit: LIMITS.BACKPRESSURE_THRESHOLD,
             },
         });
-        console.log(`DainTunnel Server is running on ${this.hostname}:${this.port}`);
+        debugLog(`DainTunnel Server is running on ${this.hostname}:${this.port}`);
     }
     async stop() {
         try {
@@ -752,7 +836,7 @@ class DainTunnelServer {
                     tunnel.ws.close(1001, "Server shutting down");
                 }
                 catch (error) {
-                    console.error(`Error closing tunnel ${tunnel.id}:`, error);
+                    debugError(`Error closing tunnel ${tunnel.id}:`, error);
                 }
             }
             this.tunnels.clear();
@@ -760,9 +844,15 @@ class DainTunnelServer {
             for (const [requestId, pending] of this.pendingRequests.entries()) {
                 if (pending.timeoutId)
                     clearTimeout(pending.timeoutId);
-                pending.resolve(new Response(JSON.stringify({ error: "Service Unavailable", message: "Server shutting down" }), {
+                pending.resolve(new Response(JSON.stringify({
+                    error: "Service Unavailable",
+                    message: "Server shutting down",
+                }), {
                     status: 503,
-                    headers: { "content-type": "application/json" },
+                    headers: {
+                        "content-type": "application/json",
+                        ...this.buildCorsHeaders(pending.origin),
+                    },
                 }));
                 this.pendingRequests.delete(requestId);
             }
@@ -774,7 +864,7 @@ class DainTunnelServer {
                     conn.controller.close();
                 }
                 catch (error) {
-                    console.error(`Error closing SSE ${sseId}:`, error);
+                    debugError(`Error closing SSE ${sseId}:`, error);
                 }
                 conn.closed = true;
                 this.sseConnections.delete(sseId);
@@ -784,7 +874,7 @@ class DainTunnelServer {
                     conn.clientSocket.close(1001, "Server shutting down");
                 }
                 catch (error) {
-                    console.error(`Error closing WS ${wsId}:`, error);
+                    debugError(`Error closing WS ${wsId}:`, error);
                 }
                 this.wsConnections.delete(wsId);
             }
@@ -794,7 +884,7 @@ class DainTunnelServer {
             }
         }
         catch (error) {
-            console.error('Error during server shutdown:', error);
+            debugError('Error during server shutdown:', error);
         }
     }
 }

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "",
   "main": "dist/index.js",
   "private": false,
+  "packageManager": "bun@1.3.13",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
-    "build:types": "tsc --emitDeclarationOnly",
-    "test": "bun test",
-    "prepublishOnly": "npm run build && npm run build:types",
+    "build": "bunx --bun tsc",
+    "build:production": "bun run build && bun build dist/server/start.js --outdir dist-prod --target bun --minify --sourcemap=external",
+    "build:types": "bunx --bun tsc --emitDeclarationOnly",
+    "test": "bun test --parallel=4",
+    "test:serial": "bun test --isolate",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage --isolate",
+    "prepublishOnly": "bun run build && bun run build:types",
     "start": "bun dist/server/start.js",
     "start-server": "bun src/server/start.ts"
   },
@@ -19,22 +24,23 @@
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
-    "@dainprotocol/service-sdk": "2.0.88",
-    "@types/node": "^22.5.4",
-    "@types/ws": "^8.5.12",
-    "hono": "^4.7.0",
-    "ws": "^8.18.0"
+    "@dainprotocol/service-sdk": "^2.0.95",
+    "hono": "^4.12.14",
+    "ws": "^8.20.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.0",
-    "typescript": "^5.0.0"
+    "@types/bun": "^1.3.12",
+    "@types/node": "^25.6.0",
+    "@types/ws": "^8.18.1",
+    "eventsource": "^4.1.0",
+    "typescript": "^6.0.3"
   },
   "files": [
     "dist",
     "README.md"
   ],
   "engines": {
-    "bun": ">=1.1.0"
+    "bun": ">=1.3.13"
   },
   "exports": {
     ".": "./dist/index.js",