devportal-tunnel 1.0.1 → 1.0.2

package/dist/utils/logger.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLog = formatLog;
+exports.logRequest = logRequest;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+function formatLog(entry) {
+    const methodColor = entry.method === "GET"
+        ? chalk_1.default.green
+        : entry.method === "POST"
+            ? chalk_1.default.blue
+            : chalk_1.default.yellow;
+    const statusColor = entry.status >= 500
+        ? chalk_1.default.red
+        : entry.status >= 400
+            ? chalk_1.default.yellow
+            : chalk_1.default.green;
+    return [
+        chalk_1.default.gray(`[${entry.time}]`),
+        methodColor(entry.method.padEnd(6)),
+        chalk_1.default.white(entry.path.padEnd(20)),
+        statusColor(entry.status.toString().padEnd(4)),
+        chalk_1.default.gray(`${entry.duration}ms`),
+    ].join(" ");
+}
+/**
+ * Log a request to the terminal and optionally to a file.
+ * @param method HTTP method
+ * @param path Request path
+ * @param status HTTP status code
+ * @param duration Duration in ms
+ * @param logFile Optional log file path
+ */
+function logRequest(method, path, status, duration, logFile) {
+    const entry = {
+        time: new Date().toLocaleTimeString(),
+        method,
+        path,
+        status,
+        duration,
+    };
+    const line = formatLog(entry);
+    console.log(line);
+    if (logFile) {
+        try {
+            fs_1.default.appendFileSync(logFile, line + "\n");
+        }
+        catch (err) {
+            // Ignore file errors for now
+        }
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":";;;;;AAWA,8BAqBC;AAUD,gCAuBC;AAjED,kDAA0B;AAC1B,4CAAoB;AAUpB,SAAgB,SAAS,CAAC,KAAe;IACvC,MAAM,WAAW,GACf,KAAK,CAAC,MAAM,KAAK,KAAK;QACpB,CAAC,CAAC,eAAK,CAAC,KAAK;QACb,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,MAAM;YACvB,CAAC,CAAC,eAAK,CAAC,IAAI;YACZ,CAAC,CAAC,eAAK,CAAC,MAAM,CAAC;IACrB,MAAM,WAAW,GACf,KAAK,CAAC,MAAM,IAAI,GAAG;QACjB,CAAC,CAAC,eAAK,CAAC,GAAG;QACX,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG;YACnB,CAAC,CAAC,eAAK,CAAC,MAAM;YACd,CAAC,CAAC,eAAK,CAAC,KAAK,CAAC;IAEpB,OAAO;QACL,eAAK,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,GAAG,CAAC;QAC7B,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACnC,eAAK,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAClC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9C,eAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,QAAQ,IAAI,CAAC;KAClC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,UAAU,CACxB,MAAc,EACd,IAAY,EACZ,MAAc,EACd,QAAgB,EAChB,OAAgB;IAEhB,MAAM,KAAK,GAAa;QACtB,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE;QACrC,MAAM;QACN,IAAI;QACJ,MAAM;QACN,QAAQ;KACT,CAAC;IACF,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClB,IAAI,OAAO,EAAE,CAAC;QACZ,IAAI,CAAC;YACH,YAAE,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,6BAA6B;QAC/B,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/utils/tunnelClient.d.ts

@@ -1,9 +1,10 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 export interface TunnelConfig {
     serverUrl: string;
     wsUrl: string;
     deviceId: string;
     localPort: number;
+    remotePort?: number;
     subdomain?: string;
     password?: string;
     demo?: boolean;
@@ -17,19 +18,49 @@ export interface TunnelInfo {
 }
 export declare class TunnelClient extends EventEmitter {
     private ws;
+    /**
+     * Local application WebSocket connections.
+     *
+     * wsId = browser WebSocket ID generated by the server.
+     */
+    private localWebSockets;
     private config;
     private reconnectAttempts;
     private maxReconnectAttempts;
-    private reconnectDelay;
+    private baseReconnectDelay;
     private isConnected;
     private tunnelInfo;
+    private pingInterval;
+    private isReconnecting;
+    private shouldReconnect;
     constructor(config: TunnelConfig);
     connect(): Promise<TunnelInfo>;
+    private setupWebSocket;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
     private handleMessage;
+    /**
+     * Browser -> Server -> CLI
+     *
+     * Server tells CLI to create a local WebSocket.
+     */
+    private handleWebSocketOpen;
+    /**
+     * Browser -> Server -> CLI -> Local app
+     */
+    private handleWebSocketMessage;
+    /**
+     * Browser -> Server -> CLI
+     *
+     * Close local WebSocket.
+     */
+    private handleWebSocketClose;
+    private closeAllLocalWebSockets;
     private handleIncomingRequest;
     private makeLocalRequest;
     private send;
-    stop(): void;
+    stop(): Promise<void>;
     getTunnelInfo(): TunnelInfo | null;
 }
 //# sourceMappingURL=tunnelClient.d.ts.map

package/dist/utils/tunnelClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tunnelClient.d.ts","sourceRoot":"","sources":["../../src/utils/tunnelClient.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAA2B;gBAEjC,MAAM,EAAE,YAAY;IAK1B,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;YA8DtB,aAAa;YA+Bb,qBAAqB;IAgDnC,OAAO,CAAC,gBAAgB;IAwExB,OAAO,CAAC,IAAI;IAMZ,IAAI,IAAI,IAAI;IAOZ,aAAa,IAAI,UAAU,GAAG,IAAI;CAGnC"}
+{"version":3,"file":"tunnelClient.d.ts","sourceRoot":"","sources":["../../src/utils/tunnelClient.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,EAAE,CAA0B;IAEpC;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAAgC;IAEvD,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO,CAAC,iBAAiB,CAAK;IAE9B,OAAO,CAAC,oBAAoB,CAAM;IAElC,OAAO,CAAC,kBAAkB,CAAQ;IAElC,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO,CAAC,UAAU,CAA2B;IAE7C,OAAO,CAAC,YAAY,CAA+B;IAEnD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,eAAe,CAAQ;gBAEnB,MAAM,EAAE,YAAY;IAM1B,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IAMpC,OAAO,CAAC,cAAc;IA4FtB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,gBAAgB;YAQV,aAAa;IA8E3B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAwF3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAsB9B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,uBAAuB;YAajB,qBAAqB;IA+EnC,OAAO,CAAC,gBAAgB;IAiGxB,OAAO,CAAC,IAAI;IAMN,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B3B,aAAa,IAAI,UAAU,GAAG,IAAI;CAGnC"}

package/dist/utils/tunnelClient.js

@@ -12,113 +12,334 @@ class TunnelClient extends events_1.EventEmitter {
     constructor(config) {
         super();
         this.ws = null;
+        /**
+         * Local application WebSocket connections.
+         *
+         * wsId = browser WebSocket ID generated by the server.
+         */
+        this.localWebSockets = new Map();
         this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 5;
-        this.reconnectDelay = 1000;
+        this.maxReconnectAttempts = 10;
+        this.baseReconnectDelay = 1000;
         this.isConnected = false;
         this.tunnelInfo = null;
+        this.pingInterval = null;
+        this.isReconnecting = false;
+        this.shouldReconnect = true;
         this.config = config;
     }
     async connect() {
         return new Promise((resolve, reject) => {
-            try {
-                this.ws = new ws_1.default(this.config.wsUrl);
-                this.ws.on('open', () => {
-                    this.isConnected = true;
-                    this.reconnectAttempts = 0;
-                    // Register tunnel
-                    this.send({
-                        type: 'register',
-                        deviceId: this.config.deviceId,
-                        localPort: this.config.localPort,
-                        subdomain: this.config.subdomain,
-                        password: this.config.password,
-                        demo: this.config.demo,
-                    });
-                });
-                this.ws.on('message', async (data) => {
-                    try {
-                        const message = JSON.parse(data.toString());
-                        await this.handleMessage(message, resolve, reject);
-                    }
-                    catch (error) {
-                        console.error('Failed to parse message:', error);
-                    }
-                });
-                this.ws.on('close', () => {
-                    this.isConnected = false;
-                    this.emit('disconnected');
-                    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                        this.reconnectAttempts++;
-                        console.log(chalk_1.default.yellow(`Reconnecting... (attempt ${this.reconnectAttempts})`));
-                        setTimeout(() => this.connect(), this.reconnectDelay * this.reconnectAttempts);
-                    }
-                });
-                this.ws.on('error', (error) => {
-                    if (!this.isConnected) {
-                        reject(error);
-                    }
-                    this.emit('error', error);
-                });
-                // Ping to keep connection alive
-                const pingInterval = setInterval(() => {
-                    if (this.isConnected && this.ws?.readyState === ws_1.default.OPEN) {
-                        this.send({ type: 'ping' });
-                    }
-                }, 30000);
-                this.on('disconnected', () => clearInterval(pingInterval));
+            this.setupWebSocket(resolve, reject);
+        });
+    }
+    setupWebSocket(resolve, reject) {
+        try {
+            // Clean up existing control connection
+            if (this.ws) {
+                this.ws.removeAllListeners();
+                if (this.ws.readyState === ws_1.default.OPEN ||
+                    this.ws.readyState === ws_1.default.CONNECTING) {
+                    this.ws.close();
+                }
             }
-            catch (error) {
+            this.ws = new ws_1.default(this.config.wsUrl);
+            const ws = this.ws;
+            ws.on("open", () => {
+                this.isConnected = true;
+                this.isReconnecting = false;
+                this.reconnectAttempts = 0;
+                this.send({
+                    type: "register",
+                    deviceId: this.config.deviceId,
+                    localPort: this.config.localPort,
+                    remotePort: this.config.remotePort,
+                    subdomain: this.tunnelInfo?.name || this.config.subdomain,
+                    password: this.config.password,
+                    demo: this.config.demo,
+                });
+                this.startPingInterval();
+            });
+            ws.on("message", async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    await this.handleMessage(message, resolve, reject);
+                }
+                catch (error) {
+                    console.error("Failed to parse server message:", error);
+                }
+            });
+            ws.on("close", () => {
+                this.isConnected = false;
+                this.stopPingInterval();
+                this.closeAllLocalWebSockets();
+                if (!this.shouldReconnect) {
+                    this.emit("disconnected");
+                    return;
+                }
+                if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                    this.scheduleReconnect();
+                }
+                else {
+                    console.log(chalk_1.default.red("\nMax reconnection attempts reached. Tunnel stopped."));
+                    console.log(chalk_1.default.gray("Run the command again to start a new tunnel."));
+                    this.emit("disconnected");
+                    process.exit(1);
+                }
+            });
+            ws.on("error", (error) => {
+                if (!this.isConnected && !this.isReconnecting && reject) {
+                    reject(error);
+                }
+                this.emit("error", error);
+            });
+        }
+        catch (error) {
+            if (reject) {
                 reject(error);
             }
-        });
+        }
+    }
+    scheduleReconnect() {
+        if (this.isReconnecting) {
+            return;
+        }
+        this.isReconnecting = true;
+        this.reconnectAttempts++;
+        const delay = Math.min(this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) +
+            Math.random() * 1000, 30000);
+        console.log(chalk_1.default.yellow(`\nConnection lost. Reconnecting in ${Math.round(delay / 1000)}s... (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`));
+        setTimeout(() => {
+            this.emit("reconnecting", this.reconnectAttempts);
+            this.setupWebSocket();
+        }, delay);
+    }
+    startPingInterval() {
+        this.stopPingInterval();
+        this.pingInterval = setInterval(() => {
+            if (this.isConnected && this.ws?.readyState === ws_1.default.OPEN) {
+                this.send({
+                    type: "ping",
+                });
+            }
+        }, 15000);
+    }
+    stopPingInterval() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
     }
     async handleMessage(message, resolve, reject) {
         switch (message.type) {
-            case 'registered':
+            case "registered": {
+                const wasReconnect = this.tunnelInfo !== null;
                 this.tunnelInfo = message.tunnel;
-                this.emit('registered', message.tunnel);
-                resolve(message.tunnel);
+                this.emit("registered", message.tunnel);
+                if (wasReconnect) {
+                    console.log(chalk_1.default.green(`\nReconnected! Tunnel restored: ${message.tunnel.url}`));
+                    this.emit("reconnected", message.tunnel);
+                }
+                else if (resolve) {
+                    resolve(message.tunnel);
+                }
                 break;
-            case 'request':
+            }
+            case "request": {
                 await this.handleIncomingRequest(message);
                 break;
-            case 'error':
-                console.error(chalk_1.default.red('Server error:'), message.message);
-                reject(new Error(message.message));
+            }
+            case "ws-open": {
+                this.handleWebSocketOpen(message);
                 break;
-            case 'pong':
-                // Connection alive
+            }
+            case "ws-message": {
+                this.handleWebSocketMessage(message);
                 break;
-            case 'stopped':
-                this.emit('stopped', message.tunnelId);
+            }
+            case "ws-close": {
+                this.handleWebSocketClose(message);
                 break;
+            }
+            case "error": {
+                console.error(chalk_1.default.red("Server error:"), message.message);
+                if (reject) {
+                    reject(new Error(message.message));
+                }
+                break;
+            }
+            case "pong": {
+                break;
+            }
+            case "stopped": {
+                this.emit("stopped", message.tunnelId);
+                break;
+            }
+            default: {
+                console.warn("Unknown server message:", message.type);
+            }
         }
     }
+    /**
+     * Browser -> Server -> CLI
+     *
+     * Server tells CLI to create a local WebSocket.
+     */
+    handleWebSocketOpen(message) {
+        const { wsId, path, headers } = message;
+        if (!wsId) {
+            return;
+        }
+        const safePath = path && path !== "undefined" ? path : "/";
+        const localUrl = `ws://localhost:${this.config.localPort}${safePath}`;
+        console.log(chalk_1.default.gray(`WebSocket opening: ${localUrl}`));
+        const localHeaders = {
+            host: `localhost:${this.config.localPort}`,
+        };
+        // Forward useful headers but remove proxy-specific ones.
+        if (headers && typeof headers === "object") {
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof value === "string" &&
+                    ![
+                        "host",
+                        "connection",
+                        "upgrade",
+                        "sec-websocket-key",
+                        "sec-websocket-version",
+                        "sec-websocket-extensions",
+                        "content-length",
+                        "x-forwarded-host",
+                        "x-forwarded-proto",
+                        "x-forwarded-for",
+                    ].includes(key.toLowerCase())) {
+                    localHeaders[key] = value;
+                }
+            }
+        }
+        const localWs = new ws_1.default(localUrl, {
+            headers: localHeaders,
+        });
+        this.localWebSockets.set(wsId, localWs);
+        localWs.on("open", () => {
+            console.log(chalk_1.default.gray(`WebSocket connected locally: ${wsId}`));
+            this.send({
+                type: "ws-opened",
+                wsId,
+            });
+        });
+        localWs.on("message", (data, isBinary) => {
+            this.send({
+                type: "ws-message",
+                wsId,
+                data: Buffer.from(data).toString("base64"),
+                binary: isBinary,
+            });
+        });
+        localWs.on("close", () => {
+            this.localWebSockets.delete(wsId);
+            this.send({
+                type: "ws-close",
+                wsId,
+            });
+        });
+        localWs.on("error", (error) => {
+            console.error(chalk_1.default.red(`Local WebSocket error (${wsId}):`), error.message);
+            this.localWebSockets.delete(wsId);
+            this.send({
+                type: "ws-close",
+                wsId,
+            });
+        });
+    }
+    /**
+     * Browser -> Server -> CLI -> Local app
+     */
+    handleWebSocketMessage(message) {
+        const { wsId, data, binary } = message;
+        const localWs = this.localWebSockets.get(wsId);
+        if (!localWs || localWs.readyState !== ws_1.default.OPEN) {
+            return;
+        }
+        try {
+            const payload = Buffer.from(data, "base64");
+            if (binary) {
+                localWs.send(payload);
+            }
+            else {
+                localWs.send(payload.toString("utf8"));
+            }
+        }
+        catch (error) {
+            console.error("Failed to forward WebSocket message:", error);
+        }
+    }
+    /**
+     * Browser -> Server -> CLI
+     *
+     * Close local WebSocket.
+     */
+    handleWebSocketClose(message) {
+        const { wsId } = message;
+        const localWs = this.localWebSockets.get(wsId);
+        if (!localWs) {
+            return;
+        }
+        this.localWebSockets.delete(wsId);
+        if (localWs.readyState === ws_1.default.OPEN ||
+            localWs.readyState === ws_1.default.CONNECTING) {
+            localWs.close();
+        }
+    }
+    closeAllLocalWebSockets() {
+        for (const localWs of this.localWebSockets.values()) {
+            if (localWs.readyState === ws_1.default.OPEN ||
+                localWs.readyState === ws_1.default.CONNECTING) {
+                localWs.close();
+            }
+        }
+        this.localWebSockets.clear();
+    }
     async handleIncomingRequest(message) {
-        const { requestId, method, path, headers, query, body } = message;
-        // Log the request
-        this.emit('request', { method, path, requestId });
-        // Build URL with query params
-        let url = `http://localhost:${this.config.localPort}${path}`;
-        if (query && Object.keys(query).length > 0) {
-            const params = new URLSearchParams(query);
-            url += `?${params.toString()}`;
-        }
-        // Add auth header if configured
-        const requestHeaders = { ...headers };
+        const { requestId, method, path, headers, body } = message;
+        this.emit("request", {
+            method,
+            path,
+            requestId,
+        });
+        const safePath = path && path !== "undefined" ? path : "/";
+        const url = `http://localhost:${this.config.localPort}${safePath}`;
+        const requestHeaders = {
+            ...headers,
+            host: `localhost:${this.config.localPort}`,
+        };
+        delete requestHeaders["content-length"];
+        delete requestHeaders["transfer-encoding"];
+        delete requestHeaders["connection"];
+        delete requestHeaders["sec-fetch-site"];
+        delete requestHeaders["sec-fetch-mode"];
+        delete requestHeaders["sec-fetch-dest"];
+        delete requestHeaders["sec-fetch-user"];
+        delete requestHeaders["origin"];
+        delete requestHeaders["referer"];
+        delete requestHeaders["x-forwarded-host"];
+        delete requestHeaders["x-forwarded-proto"];
+        delete requestHeaders["x-forwarded-for"];
         if (this.config.authHeader) {
-            const [key, value] = this.config.authHeader.split(': ');
+            const [key, value] = this.config.authHeader.split(": ");
             if (key && value) {
                 requestHeaders[key] = value;
             }
         }
         try {
             const response = await this.makeLocalRequest(method, url, requestHeaders, body);
-            this.emit('response', { method, path, status: response.status, requestId });
-            // Send response back to server
+            this.emit("response", {
+                method,
+                path,
+                status: response.status,
+                requestId,
+            });
             this.send({
-                type: 'response',
+                type: "response",
                 requestId,
                 status: response.status,
                 headers: response.headers,
@@ -126,14 +347,18 @@ class TunnelClient extends events_1.EventEmitter {
             });
         }
         catch (error) {
-            this.emit('error', error);
-            // Send error response
+            this.emit("error", error);
             this.send({
-                type: 'response',
+                type: "response",
                 requestId,
                 status: 502,
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ error: 'Failed to connect to local server', message: error.message }),
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    error: "Failed to connect to local server",
+                    message: error.message,
+                }),
             });
         }
     }
@@ -142,7 +367,7 @@ class TunnelClient extends events_1.EventEmitter {
             const urlObj = new URL(url);
             const options = {
                 hostname: urlObj.hostname,
-                port: urlObj.port || 80,
+                port: Number(urlObj.port) || this.config.localPort,
                 path: urlObj.pathname + urlObj.search,
                 method,
                 headers,
@@ -150,29 +375,34 @@ class TunnelClient extends events_1.EventEmitter {
             };
             const req = http_1.default.request(options, (res) => {
                 const chunks = [];
-                res.on('data', (chunk) => chunks.push(chunk));
-                res.on('end', () => {
+                res.on("data", (chunk) => {
+                    chunks.push(chunk);
+                });
+                res.on("end", () => {
                     const bodyBuffer = Buffer.concat(chunks);
                     const responseHeaders = {};
-                    // Convert headers
                     for (const [key, value] of Object.entries(res.headers)) {
                         if (value) {
-                            responseHeaders[key] = Array.isArray(value) ? value.join(', ') : value;
+                            responseHeaders[key] = Array.isArray(value)
+                                ? value.join(", ")
+                                : value;
                         }
                     }
-                    // Check if body is binary
-                    const contentType = responseHeaders['content-type'] || '';
-                    const isBinary = !contentType.includes('text') &&
-                        !contentType.includes('json') &&
-                        !contentType.includes('xml') &&
-                        !contentType.includes('javascript');
+                    delete responseHeaders["content-length"];
+                    delete responseHeaders["transfer-encoding"];
+                    delete responseHeaders["connection"];
+                    const contentType = responseHeaders["content-type"] || "";
+                    const isBinary = !contentType.includes("text") &&
+                        !contentType.includes("json") &&
+                        !contentType.includes("xml") &&
+                        !contentType.includes("javascript");
                     let bodyString;
                     if (isBinary) {
-                        bodyString = bodyBuffer.toString('base64');
-                        responseHeaders['x-body-encoding'] = 'base64';
+                        bodyString = bodyBuffer.toString("base64");
+                        responseHeaders["x-body-encoding"] = "base64";
                     }
                     else {
-                        bodyString = bodyBuffer.toString('utf-8');
+                        bodyString = bodyBuffer.toString("utf-8");
                     }
                     resolve({
                         status: res.statusCode || 500,
@@ -181,13 +411,16 @@ class TunnelClient extends events_1.EventEmitter {
                     });
                 });
             });
-            req.on('error', reject);
-            req.on('timeout', () => reject(new Error('Request timeout')));
+            req.on("error", reject);
+            req.on("timeout", () => {
+                req.destroy();
+                reject(new Error("Request timeout"));
+            });
             if (body) {
-                // Decode base64 body if it was encoded
-                const bodyBuffer = body.startsWith('ey') || body.includes('=')
-                    ? Buffer.from(body, 'base64')
-                    : Buffer.from(body);
+                const bodyEncoding = headers?.["x-body-encoding"];
+                const bodyBuffer = bodyEncoding === "base64"
+                    ? Buffer.from(body, "base64")
+                    : Buffer.from(body, "utf-8");
                 req.write(bodyBuffer);
             }
             req.end();
@@ -198,11 +431,29 @@ class TunnelClient extends events_1.EventEmitter {
             this.ws.send(JSON.stringify(data));
         }
     }
-    stop() {
+    async stop() {
+        this.shouldReconnect = false;
+        this.stopPingInterval();
+        this.closeAllLocalWebSockets();
         if (this.tunnelInfo) {
-            this.send({ type: 'stop', tunnelId: this.tunnelInfo.id });
+            this.send({
+                type: "stop",
+                tunnelId: this.tunnelInfo.id,
+            });
         }
-        this.ws?.close();
+        return new Promise((resolve) => {
+            if (this.ws?.readyState === ws_1.default.OPEN) {
+                const timeout = setTimeout(() => resolve(), 500);
+                this.ws.once("close", () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                this.ws.close();
+            }
+            else {
+                resolve();
+            }
+        });
     }
     getTunnelInfo() {
         return this.tunnelInfo;