@dainprotocol/tunnel 1.0.0

package/dist/client/index.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from "events";
+declare class DainTunnel extends EventEmitter {
+    private serverUrl;
+    private ws;
+    private tunnelUrl;
+    private port;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(serverUrl: string);
+    start(port: number): Promise<string>;
+    private connect;
+    private handleMessage;
+    private handleRequest;
+    private forwardRequest;
+    private sendMessage;
+    private attemptReconnect;
+    stop(): Promise<void>;
+}
+export { DainTunnel };
+declare const _default: {
+    createTunnel: (serverUrl: string) => DainTunnel;
+};
+export default _default;

package/dist/client/index.js

@@ -0,0 +1,133 @@
+"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");
+class DainTunnel extends events_1.EventEmitter {
+    constructor(serverUrl) {
+        super();
+        this.serverUrl = serverUrl;
+        this.ws = null;
+        this.tunnelUrl = null;
+        this.port = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 5000;
+    }
+    async start(port) {
+        this.port = port;
+        return this.connect();
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(this.serverUrl);
+            this.ws.on("open", () => {
+                this.reconnectAttempts = 0;
+                this.sendMessage({ type: "start", port: this.port });
+                this.emit("connected");
+            });
+            this.ws.on("message", (data) => {
+                const message = JSON.parse(data);
+                this.handleMessage(message, resolve);
+            });
+            this.ws.on("close", () => {
+                this.emit("disconnected");
+                this.attemptReconnect();
+            });
+            this.ws.on("error", (error) => {
+                this.emit("error", error);
+                reject(error);
+            });
+            // Add a timeout to reject the promise if connection takes too long
+            setTimeout(() => {
+                var _a;
+                if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) !== ws_1.default.OPEN) {
+                    reject(new Error("Connection timeout"));
+                }
+            }, 5000);
+        });
+    }
+    handleMessage(message, resolve) {
+        switch (message.type) {
+            case "tunnelUrl":
+                this.tunnelUrl = message.url;
+                resolve(this.tunnelUrl);
+                this.emit("tunnel_created", this.tunnelUrl);
+                break;
+            case "request":
+                this.handleRequest(message);
+                break;
+        }
+    }
+    async handleRequest(request) {
+        try {
+            const response = await this.forwardRequest(request);
+            this.sendMessage(response);
+            this.emit("request_handled", { request, response });
+        }
+        catch (error) {
+            this.emit("request_error", { request, error });
+        }
+    }
+    forwardRequest(request) {
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.request(`http://localhost:${this.port}${request.path}`, {
+                method: request.method,
+                headers: request.headers,
+            }, (res) => {
+                let body = Buffer.from([]);
+                res.on('data', (chunk) => {
+                    body = Buffer.concat([body, chunk]);
+                });
+                res.on('end', () => {
+                    const headers = { ...res.headers };
+                    delete headers['transfer-encoding'];
+                    delete headers['content-length'];
+                    resolve({
+                        type: 'response',
+                        requestId: request.id,
+                        status: res.statusCode,
+                        headers,
+                        body: body.toString('base64'),
+                    });
+                });
+            });
+            req.on('error', reject);
+            if (request.body) {
+                req.write(Buffer.from(request.body, 'base64'));
+            }
+            req.end();
+        });
+    }
+    sendMessage(message) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            setTimeout(() => this.connect(), this.reconnectDelay);
+        }
+        else {
+            this.emit("max_reconnect_attempts");
+        }
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.ws) {
+                this.ws.close();
+                this.ws = null;
+            }
+            resolve();
+        });
+    }
+}
+exports.DainTunnel = DainTunnel;
+exports.default = {
+    createTunnel: (serverUrl) => new DainTunnel(serverUrl),
+};

package/dist/server/index.d.ts

@@ -0,0 +1,20 @@
+declare class DainTunnelServer {
+    private hostname;
+    private port;
+    private app;
+    private server;
+    private wss;
+    private tunnels;
+    private pendingRequests;
+    constructor(hostname: string, port: number);
+    private setupExpressRoutes;
+    private setupWebSocketServer;
+    private handleStartMessage;
+    private handleResponseMessage;
+    private handleHttpRequest;
+    private getRequestBody;
+    private removeTunnel;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export default DainTunnelServer;

package/dist/server/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+class DainTunnelServer {
+    constructor(hostname, port) {
+        this.hostname = hostname;
+        this.port = port;
+        this.tunnels = new Map();
+        this.pendingRequests = 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 });
+        this.setupExpressRoutes();
+        this.setupWebSocketServer();
+    }
+    setupExpressRoutes() {
+        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);
+                }
+                else if (data.type === 'response') {
+                    this.handleResponseMessage(data);
+                }
+            });
+            ws.on('close', () => {
+                this.removeTunnel(ws);
+            });
+        });
+    }
+    handleStartMessage(ws, data) {
+        const tunnelId = (0, uuid_1.v4)();
+        this.tunnels.set(tunnelId, { id: tunnelId, ws });
+        const tunnelUrl = `${this.hostname}:${this.port}/${tunnelId}`;
+        ws.send(JSON.stringify({ type: 'tunnelUrl', url: tunnelUrl }));
+        console.log(`New tunnel created: ${tunnelUrl}`);
+    }
+    handleResponseMessage(data) {
+        const pendingRequest = this.pendingRequests.get(data.requestId);
+        if (pendingRequest) {
+            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)
+                .set(headers)
+                .set('Content-Length', bodyBuffer.length.toString())
+                .send(bodyBuffer);
+            console.log(`Request handled: ${data.requestId}, Duration: ${endTime - startTime}ms`);
+            this.pendingRequests.delete(data.requestId);
+        }
+    }
+    async handleHttpRequest(req, res) {
+        const tunnelId = req.params.tunnelId;
+        const tunnel = this.tunnels.get(tunnelId);
+        if (!tunnel) {
+            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',
+            id: requestId,
+            method: req.method,
+            path: req.url,
+            headers: req.headers,
+            body: await this.getRequestBody(req)
+        };
+        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) {
+        for (const [id, tunnel] of this.tunnels.entries()) {
+            if (tunnel.ws === ws) {
+                this.tunnels.delete(id);
+                console.log(`Tunnel removed: ${id}`);
+                break;
+            }
+        }
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server.listen(this.port, () => {
+                console.log(`DainTunnel Server is running on ${this.hostname}:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.wss.close(() => {
+                this.server.close(() => {
+                    resolve();
+                });
+            });
+        });
+    }
+}
+exports.default = DainTunnelServer;

package/dist/server/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/start.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const port = parseInt(process.env.PORT || '3000', 10);
+const hostname = process.env.HOSTNAME || 'http://localhost';
+const server = new index_1.default(hostname, port);
+server.start()
+    .then(() => {
+    console.log(`DainTunnel Server started on ${hostname}:${port}`);
+})
+    .catch((error) => {
+    console.error('Failed to start DainTunnel Server:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@dainprotocol/tunnel",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "build:types": "tsc --emitDeclarationOnly",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run build && npm run build:types",
+    "start-server": "ts-node src/server/start.ts"
+  },
+  "keywords": [],
+  "author": "Ryan",
+  "license": "ISC",
+  "dependencies": {
+    "@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",
+    "express": "^4.19.2",
+    "fetch-mock": "^11.1.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.5.4",
+    "uuid": "^10.0.0",
+    "ws": "^8.18.0"
+  },  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": "20.7.0"
+  }
+}