@dainprotocol/tunnel 1.0.1 → 1.0.3

package/dist/client/index.d.ts

@@ -7,9 +7,12 @@ declare class DainTunnel extends EventEmitter {
     private reconnectAttempts;
     private maxReconnectAttempts;
     private reconnectDelay;
-    constructor(serverUrl: string);
+    private auth;
+    private tunnelId;
+    constructor(serverUrl: string, apiKey: string);
     start(port: number): Promise<string>;
     private connect;
+    private requestChallenge;
     private handleMessage;
     private handleRequest;
     private forwardRequest;
@@ -19,6 +22,6 @@ declare class DainTunnel extends EventEmitter {
 }
 export { DainTunnel };
 declare const _default: {
-    createTunnel: (serverUrl: string) => DainTunnel;
+    createTunnel: (serverUrl: string, apiKey: string) => DainTunnel;
 };
 export default _default;

package/dist/client/index.js

@@ -7,8 +7,10 @@ exports.DainTunnel = void 0;
 const ws_1 = __importDefault(require("ws"));
 const http_1 = __importDefault(require("http"));
 const events_1 = require("events");
+const bs58_1 = __importDefault(require("bs58"));
+const client_1 = require("@dainprotocol/service-sdk/client");
 class DainTunnel extends events_1.EventEmitter {
-    constructor(serverUrl) {
+    constructor(serverUrl, apiKey) {
         super();
         this.serverUrl = serverUrl;
         this.ws = null;
@@ -17,6 +19,8 @@ class DainTunnel extends events_1.EventEmitter {
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = 5;
         this.reconnectDelay = 5000;
+        this.auth = new client_1.DainClientAuth({ apiKey });
+        this.tunnelId = bs58_1.default.encode(this.auth.getPublicKey());
     }
     async start(port) {
         this.port = port;
@@ -25,9 +29,17 @@ class DainTunnel extends events_1.EventEmitter {
     async connect() {
         return new Promise((resolve, reject) => {
             this.ws = new ws_1.default(this.serverUrl);
-            this.ws.on("open", () => {
+            this.ws.on("open", async () => {
                 this.reconnectAttempts = 0;
-                this.sendMessage({ type: "start", port: this.port });
+                const challenge = await this.requestChallenge();
+                const signature = this.auth.signMessage(challenge);
+                this.sendMessage({
+                    type: "start",
+                    port: this.port,
+                    challenge,
+                    signature,
+                    tunnelId: this.tunnelId
+                });
                 this.emit("connected");
             });
             this.ws.on("message", (data) => {
@@ -51,6 +63,32 @@ class DainTunnel extends events_1.EventEmitter {
             }, 5000);
         });
     }
+    async requestChallenge() {
+        return new Promise((resolve, reject) => {
+            if (!this.ws) {
+                reject(new Error("WebSocket is not connected"));
+                return;
+            }
+            this.ws.send(JSON.stringify({ type: "challenge_request" }));
+            const challengeHandler = (message) => {
+                const data = JSON.parse(message);
+                if (data.type === "challenge") {
+                    if (this.ws) {
+                        this.ws.removeListener("message", challengeHandler);
+                    }
+                    resolve(data.challenge);
+                }
+            };
+            this.ws.on("message", challengeHandler);
+            // Add a timeout for the challenge request
+            setTimeout(() => {
+                if (this.ws) {
+                    this.ws.removeListener("message", challengeHandler);
+                }
+                reject(new Error("Challenge request timeout"));
+            }, 5000);
+        });
+    }
     handleMessage(message, resolve) {
         switch (message.type) {
             case "tunnelUrl":
@@ -75,10 +113,14 @@ class DainTunnel extends events_1.EventEmitter {
     }
     forwardRequest(request) {
         return new Promise((resolve, reject) => {
-            const req = http_1.default.request(`http://localhost:${this.port}${request.path}`, {
+            const options = {
+                hostname: 'localhost',
+                port: this.port,
+                path: request.path,
                 method: request.method,
                 headers: request.headers,
-            }, (res) => {
+            };
+            const req = http_1.default.request(options, (res) => {
                 let body = Buffer.from([]);
                 res.on('data', (chunk) => {
                     body = Buffer.concat([body, chunk]);
@@ -97,7 +139,7 @@ class DainTunnel extends events_1.EventEmitter {
                 });
             });
             req.on('error', reject);
-            if (request.body) {
+            if (request.body && request.method !== 'GET') {
                 req.write(Buffer.from(request.body, 'base64'));
             }
             req.end();
@@ -129,5 +171,5 @@ class DainTunnel extends events_1.EventEmitter {
 }
 exports.DainTunnel = DainTunnel;
 exports.default = {
-    createTunnel: (serverUrl) => new DainTunnel(serverUrl),
+    createTunnel: (serverUrl, apiKey) => new DainTunnel(serverUrl, apiKey),
 };

package/dist/server/index.d.ts

@@ -6,13 +6,14 @@ declare class DainTunnelServer {
     private wss;
     private tunnels;
     private pendingRequests;
+    private challenges;
     constructor(hostname: string, port: number);
     private setupExpressRoutes;
     private setupWebSocketServer;
+    private handleChallengeRequest;
     private handleStartMessage;
     private handleResponseMessage;
     private handleHttpRequest;
-    private getRequestBody;
     private removeTunnel;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/server/index.js

@@ -7,43 +7,112 @@ const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
 const ws_1 = __importDefault(require("ws"));
 const uuid_1 = require("uuid");
+const body_parser_1 = __importDefault(require("body-parser"));
+const cors_1 = __importDefault(require("cors")); // Add this import
+const client_1 = require("@dainprotocol/service-sdk/client");
+const bs58_1 = __importDefault(require("bs58"));
 class DainTunnelServer {
     constructor(hostname, port) {
         this.hostname = hostname;
         this.port = port;
         this.tunnels = new Map();
         this.pendingRequests = new Map();
+        this.challenges = new Map();
         this.app = (0, express_1.default)();
         this.server = http_1.default.createServer(this.app);
         this.wss = new ws_1.default.Server({ server: this.server });
+        // Use cors middleware
+        this.app.use((0, cors_1.default)());
+        // Update CORS middleware
+        this.app.use((req, res, next) => {
+            res.header("Access-Control-Allow-Origin", "*");
+            res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+            res.header("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, Content-Type, Authorization, Accept, Origin, X-Requested-With');
+            if (req.method === "OPTIONS") {
+                return res.sendStatus(200);
+            }
+            next();
+        });
+        // Add body-parser middleware
+        this.app.use(body_parser_1.default.raw({ type: "*/*", limit: "100mb" }));
         this.setupExpressRoutes();
         this.setupWebSocketServer();
     }
     setupExpressRoutes() {
-        this.app.use('/:tunnelId', this.handleHttpRequest.bind(this));
+        this.app.use("/:tunnelId", this.handleHttpRequest.bind(this));
     }
     setupWebSocketServer() {
-        this.wss.on('connection', (ws) => {
-            console.log('New WebSocket connection');
-            ws.on('message', (message) => {
-                const data = JSON.parse(message);
-                if (data.type === 'start') {
-                    this.handleStartMessage(ws, data);
+        this.wss.on("connection", (ws) => {
+            console.log("New WebSocket connection");
+            ws.on("message", (message) => {
+                try {
+                    const data = JSON.parse(message);
+                    console.log(`Received WebSocket message: ${data.type}`);
+                    if (data.type === "challenge_request") {
+                        this.handleChallengeRequest(ws);
+                    }
+                    else if (data.type === "start") {
+                        this.handleStartMessage(ws, data);
+                    }
+                    else if (data.type === "response") {
+                        this.handleResponseMessage(data);
+                    }
                 }
-                else if (data.type === 'response') {
-                    this.handleResponseMessage(data);
+                catch (error) {
+                    console.error("Error processing message:", error);
+                    ws.close(1008, "Invalid message");
                 }
             });
-            ws.on('close', () => {
+            ws.on("close", () => {
+                console.log("WebSocket connection closed");
                 this.removeTunnel(ws);
             });
+            ws.on("error", (error) => {
+                console.error("WebSocket error:", error);
+            });
         });
     }
+    handleChallengeRequest(ws) {
+        const challenge = (0, uuid_1.v4)();
+        const challengeObj = { ws, challenge };
+        this.challenges.set(challenge, challengeObj);
+        ws.send(JSON.stringify({ type: "challenge", challenge }));
+    }
     handleStartMessage(ws, data) {
-        const tunnelId = (0, uuid_1.v4)();
+        const { challenge, signature, tunnelId } = data;
+        const challengeObj = this.challenges.get(challenge);
+        if (!challengeObj || challengeObj.ws !== ws) {
+            ws.close(1008, "Invalid challenge");
+            return;
+        }
+        this.challenges.delete(challenge);
+        const publicKey = bs58_1.default.decode(tunnelId);
+        if (!client_1.DainClientAuth.verifyMessage(challenge, signature, publicKey)) {
+            ws.close(1008, "Invalid signature");
+            return;
+        }
         this.tunnels.set(tunnelId, { id: tunnelId, ws });
-        const tunnelUrl = `${this.hostname}:${this.port}/${tunnelId}`;
-        ws.send(JSON.stringify({ type: 'tunnelUrl', url: tunnelUrl }));
+        console.log(`Tunnel added: ${tunnelId}`);
+        console.log(`Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
+        // Add a periodic check to ensure the tunnel is still in the map
+        const intervalId = setInterval(() => {
+            if (this.tunnels.has(tunnelId)) {
+                console.log(`Tunnel ${tunnelId} still active`);
+            }
+            else {
+                console.log(`Tunnel ${tunnelId} not found in periodic check`);
+                clearInterval(intervalId);
+            }
+        }, 5000); // Check every 5 seconds
+        ws.on("close", () => {
+            clearInterval(intervalId);
+        });
+        let tunnelUrl = `${this.hostname}`;
+        if (process.env.SKIP_PORT !== "true") {
+            tunnelUrl += `:${this.port}`;
+        }
+        tunnelUrl += `/${tunnelId}`;
+        ws.send(JSON.stringify({ type: "tunnelUrl", url: tunnelUrl }));
         console.log(`New tunnel created: ${tunnelUrl}`);
     }
     handleResponseMessage(data) {
@@ -52,12 +121,13 @@ class DainTunnelServer {
             const { res, startTime } = pendingRequest;
             const endTime = Date.now();
             const headers = { ...data.headers };
-            delete headers['transfer-encoding'];
-            delete headers['content-length'];
-            const bodyBuffer = Buffer.from(data.body, 'base64');
-            res.status(data.status)
+            delete headers["transfer-encoding"];
+            delete headers["content-length"];
+            const bodyBuffer = Buffer.from(data.body, "base64");
+            res
+                .status(data.status)
                 .set(headers)
-                .set('Content-Length', bodyBuffer.length.toString())
+                .set("Content-Length", bodyBuffer.length.toString())
                 .send(bodyBuffer);
             console.log(`Request handled: ${data.requestId}, Duration: ${endTime - startTime}ms`);
             this.pendingRequests.delete(data.requestId);
@@ -65,43 +135,60 @@ class DainTunnelServer {
     }
     async handleHttpRequest(req, res) {
         const tunnelId = req.params.tunnelId;
-        const tunnel = this.tunnels.get(tunnelId);
+        let tunnel;
+        let retries = 3;
+        while (retries > 0 && !tunnel) {
+            tunnel = this.tunnels.get(tunnelId);
+            if (!tunnel) {
+                console.log(`Tunnel not found: ${tunnelId}, retrying... (${retries} attempts left)`);
+                console.log(`Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
+                await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms before retrying
+                retries--;
+            }
+        }
         if (!tunnel) {
-            return res.status(404).send('Tunnel not found');
+            console.log(`Tunnel not found after retries: ${tunnelId}`);
+            return res.status(404).send("Tunnel not found");
         }
         const requestId = (0, uuid_1.v4)();
         const startTime = Date.now();
         this.pendingRequests.set(requestId, { res, startTime });
         const requestMessage = {
-            type: 'request',
+            type: "request",
             id: requestId,
             method: req.method,
             path: req.url,
             headers: req.headers,
-            body: await this.getRequestBody(req)
+            body: req.method !== "GET" && req.body
+                ? req.body.toString("base64")
+                : undefined,
         };
         tunnel.ws.send(JSON.stringify(requestMessage));
         console.log(`Request forwarded: ${requestId}, Method: ${req.method}, Path: ${req.url}`);
     }
-    getRequestBody(req) {
-        return new Promise((resolve) => {
-            let body = '';
-            req.on('data', chunk => {
-                body += chunk.toString();
-            });
-            req.on('end', () => {
-                resolve(body);
-            });
-        });
-    }
     removeTunnel(ws) {
+        let removedTunnelId;
         for (const [id, tunnel] of this.tunnels.entries()) {
             if (tunnel.ws === ws) {
                 this.tunnels.delete(id);
+                removedTunnelId = id;
                 console.log(`Tunnel removed: ${id}`);
                 break;
             }
         }
+        if (removedTunnelId) {
+            console.log(`Tunnel ${removedTunnelId} removed. Current tunnels: ${Array.from(this.tunnels.keys()).join(', ')}`);
+        }
+        else {
+            console.log(`No tunnel found to remove for the closed WebSocket connection`);
+        }
+        // Also remove any pending challenges for this WebSocket
+        for (const [challenge, challengeObj] of this.challenges.entries()) {
+            if (challengeObj.ws === ws) {
+                this.challenges.delete(challenge);
+                break;
+            }
+        }
     }
     async start() {
         return new Promise((resolve) => {

package/dist/server/start.js

@@ -4,12 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = __importDefault(require("./index"));
+const dotenv_1 = __importDefault(require("dotenv"));
+// Load environment variables from .env file
+dotenv_1.default.config();
 const port = parseInt(process.env.PORT || '3000', 10);
-const hostname = process.env.HOSTNAME || 'http://localhost';
+const hostname = process.env.HOSTNAME || 'localhost';
 const server = new index_1.default(hostname, port);
 server.start()
     .then(() => {
-    console.log(`DainTunnel Server started on ${hostname}:${port}`);
+    console.log(`DainTunnel Server started on http://${hostname}:${port}`);
 })
     .catch((error) => {
     console.error('Failed to start DainTunnel Server:', error);

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@dainprotocol/tunnel",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "main": "dist/index.js",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+
   "scripts": {
     "build": "tsc",
     "build:types": "tsc --emitDeclarationOnly",
@@ -15,15 +20,23 @@
   "author": "Ryan",
   "license": "ISC",
   "dependencies": {
+    "@dainprotocol/service-sdk": "^1.0.11",
+    "@types/body-parser": "^1.19.5",
+    "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.5.4",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.5.12",
+    "body-parser": "^1.20.2",
+    "bs58": "^6.0.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
     "express": "^4.19.2",
     "fetch-mock": "^11.1.3",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
     "typescript": "^5.5.4",
     "uuid": "^10.0.0",
     "ws": "^8.18.0"