pinggy 0.3.5 → 0.3.6

package/dist/{main-K44C44NW.js → main-2QDG7PWL.js}

@@ -1,975 +1,22 @@
 #!/usr/bin/env node
 import {
+  TunnelManager,
+  TunnelOperations,
+  closeRemoteManagement,
+  getRandomId,
+  getRemoteManagementState,
+  getVersion,
+  initiateRemoteManagement,
+  isValidPort,
+  parseRemoteManagement,
   printer_default
-} from "./chunk-T5ESYDJY.js";
+} from "./chunk-65R2GMKQ.js";
 import {
   configureLogger,
   enablePackageLogging,
   logger
 } from "./chunk-HUN2MRZO.js";
 
-// src/tunnel_manager/TunnelManager.ts
-import { pinggy } from "@pinggy/pinggy";
-import path from "path";
-import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-
-// src/utils/util.ts
-import { createRequire } from "module";
-import { randomUUID } from "crypto";
-function getRandomId() {
-  return randomUUID();
-}
-function isValidPort(p) {
-  return Number.isInteger(p) && p > 0 && p < 65536;
-}
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-function getVersion() {
-  return pkg.version ?? "";
-}
-
-// src/tunnel_manager/TunnelManager.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var TunnelManager = class _TunnelManager {
-  constructor() {
-    this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
-    this.tunnelsByConfigId = /* @__PURE__ */ new Map();
-    this.tunnelStats = /* @__PURE__ */ new Map();
-    this.tunnelStatsListeners = /* @__PURE__ */ new Map();
-    this.tunnelErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
-    this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelStartListeners = /* @__PURE__ */ new Map();
-  }
-  static getInstance() {
-    if (!_TunnelManager.instance) {
-      _TunnelManager.instance = new _TunnelManager();
-    }
-    return _TunnelManager.instance;
-  }
-  /**
-   * Creates a new managed tunnel instance with the given configuration.
-   * Builds the config with forwarding rules and creates the tunnel instance.
-   * 
-   * @param config - The tunnel configuration options
-   * @param config.configid - Unique identifier for the tunnel configuration
-   * @param config.tunnelid - Optional custom tunnel identifier. If not provided, a random UUID will be generated
-   * @param config.additionalForwarding - Optional array of additional forwarding configurations
-   * 
-   * @throws {Error} When configId is invalid or empty
-   * @throws {Error} When a tunnel with the given configId already exists
-   * 
-   * @returns {ManagedTunnel} A new managed tunnel instance containing the tunnel details,
-   *                          status information, and statistics
-   */
-  async createTunnel(config) {
-    const { configid, additionalForwarding, tunnelName } = config;
-    if (configid === void 0 || configid.trim().length === 0) {
-      throw new Error(`Invalid configId: "${configid}"`);
-    }
-    if (this.tunnelsByConfigId.has(configid)) {
-      throw new Error(`Tunnel with configId "${configid}" already exists`);
-    }
-    const tunnelid = config.tunnelid || getRandomId();
-    const configWithForwarding = this.buildPinggyConfig(config, additionalForwarding);
-    return this._createTunnelWithProcessedConfig({
-      configid,
-      tunnelid,
-      tunnelName,
-      originalConfig: config,
-      configWithForwarding,
-      additionalForwarding,
-      serve: config.serve,
-      autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
-    });
-  }
-  /**
-   * Internal method to create a tunnel with an already-processed configuration.
-   * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
-   * 
-   * @param params - Configuration parameters with already-processed forwarding rules
-   * @returns The created ManagedTunnel instance
-   * @private
-   */
-  async _createTunnelWithProcessedConfig(params) {
-    let instance;
-    try {
-      instance = await pinggy.createTunnel(params.configWithForwarding);
-    } catch (e) {
-      logger.error("Error creating tunnel instance:", e);
-      throw e;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const managed = {
-      tunnelid: params.tunnelid,
-      configid: params.configid,
-      tunnelName: params.tunnelName,
-      instance,
-      tunnelConfig: params.originalConfig,
-      configWithForwarding: params.configWithForwarding,
-      additionalForwarding: params.additionalForwarding,
-      serve: params.serve,
-      warnings: [],
-      isStopped: false,
-      createdAt: now,
-      startedAt: null,
-      stoppedAt: null,
-      autoReconnect: params.autoReconnect
-    };
-    instance.setTunnelEstablishedCallback(({}) => {
-      managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    });
-    this.setupStatsCallback(params.tunnelid, managed);
-    this.setupErrorCallback(params.tunnelid, managed);
-    this.setupDisconnectCallback(params.tunnelid, managed);
-    this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
-    this.tunnelsByTunnelId.set(params.tunnelid, managed);
-    this.tunnelsByConfigId.set(params.configid, managed);
-    logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
-    return managed;
-  }
-  /**
-   * Builds the Pinggy configuration by merging the default forwarding rule
-   * with additional forwarding rules from additionalForwarding array.
-   * 
-   * @param config - The base Pinggy configuration
-   * @param additionalForwarding - Optional array of additional forwarding rules
-   * @returns Modified PinggyOptions 
-   */
-  buildPinggyConfig(config, additionalForwarding) {
-    const forwardingRules = [];
-    if (config.forwarding) {
-      forwardingRules.push({
-        type: config.tunnelType && config.tunnelType[0] || "http",
-        address: config.forwarding
-      });
-    }
-    if (Array.isArray(additionalForwarding) && additionalForwarding.length > 0) {
-      for (const rule of additionalForwarding) {
-        if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
-          const forwardingRule = {
-            type: rule.protocol,
-            // In Future we can make this dynamic based on user input
-            address: `${rule.localDomain}:${rule.localPort}`,
-            listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain
-          };
-          forwardingRules.push(forwardingRule);
-        }
-      }
-    }
-    return {
-      ...config,
-      forwarding: forwardingRules.length > 0 ? forwardingRules : config.forwarding
-    };
-  }
-  /**
-   * Start a tunnel that was created but not yet started
-   */
-  async startTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
-    logger.info("Starting tunnel", { tunnelId });
-    let urls;
-    try {
-      urls = await managed.instance.start();
-    } catch (error) {
-      logger.error("Failed to start tunnel", { tunnelId, error });
-      throw error;
-    }
-    logger.info("Tunnel started", { tunnelId, urls });
-    if (managed.serve) {
-      this.startStaticFileServer(managed);
-    }
-    try {
-      const startListeners = this.tunnelStartListeners.get(tunnelId);
-      if (startListeners) {
-        for (const [id, listener] of startListeners) {
-          try {
-            listener(tunnelId, urls);
-          } catch (err) {
-            logger.debug("Error in start-listener callback", { listenerId: id, tunnelId, err });
-          }
-        }
-      }
-    } catch (e) {
-      logger.warn("Failed to notify start listeners", { tunnelId, e });
-    }
-    return urls;
-  }
-  /**
-   * Stops a running tunnel and updates its status.
-   *
-   * @param tunnelId - The unique identifier of the tunnel to stop
-   * @throws {Error} If the tunnel with the given tunnelId is not found
-   * @remarks
-   * - Clears the tunnel's remote URLs
-   * - Updates the tunnel's state to Exited if stopped successfully
-   * - Logs the stop operation with tunnelId and configId
-   */
-  stopTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-    logger.info("Stopping tunnel", { tunnelId, configId: managed.configid });
-    try {
-      managed.instance.stop();
-      if (managed.serveWorker) {
-        logger.info("terminating serveWorker");
-        managed.serveWorker.terminate();
-      }
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelErrorListeners.delete(tunnelId);
-      this.tunnelDisconnectListeners.delete(tunnelId);
-      this.tunnelWorkerErrorListeners.delete(tunnelId);
-      this.tunnelStartListeners.delete(tunnelId);
-      managed.serveWorker = null;
-      managed.warnings = managed.warnings ?? [];
-      managed.isStopped = true;
-      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-      logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
-      return { configid: managed.configid, tunnelid: managed.tunnelid };
-    } catch (error) {
-      logger.error("Failed to stop tunnel", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all public URLs for a tunnel
-   */
-  async getTunnelUrls(tunnelId) {
-    try {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed || managed.isStopped) {
-        logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
-        return [];
-      }
-      const urls = await managed.instance.urls();
-      logger.debug("Queried tunnel URLs", { tunnelId, urls });
-      return urls;
-    } catch (error) {
-      logger.error("Error fetching tunnel URLs", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all TunnelStatus currently managed by this TunnelManager
-   * @returns An array of all TunnelStatus objects
-   */
-  async getAllTunnels() {
-    try {
-      const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
-        return {
-          tunnelid: tunnel.tunnelid,
-          configid: tunnel.configid,
-          tunnelName: tunnel.tunnelName,
-          tunnelConfig: tunnel.tunnelConfig,
-          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
-          additionalForwarding: tunnel.additionalForwarding,
-          serve: tunnel.serve
-        };
-      }));
-      return tunnelList;
-    } catch (err) {
-      logger.error("Error fetching tunnels", { error: err });
-      return [];
-    }
-  }
-  /**
-   * Get status of a tunnel
-   */
-  async getTunnelStatus(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (managed.isStopped) {
-      return "exited";
-    }
-    const status = await managed.instance.getStatus();
-    logger.debug("Queried tunnel status", { tunnelId, status });
-    return status;
-  }
-  /**
-   * Stop all tunnels
-   */
-  stopAllTunnels() {
-    for (const { instance } of this.tunnelsByTunnelId.values()) {
-      try {
-        instance.stop();
-      } catch (e) {
-        logger.warn("Error stopping tunnel instance", e);
-      }
-    }
-    this.tunnelsByTunnelId.clear();
-    this.tunnelsByConfigId.clear();
-    this.tunnelStats.clear();
-    this.tunnelStatsListeners.clear();
-    logger.info("All tunnels stopped and cleared");
-  }
-  /**
-   * Remove a stopped tunnel's records so it will no longer be returned by list methods.
-   * 
-   *
-   * @param tunnelId - the tunnel id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByTunnelId(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel", { tunnelId });
-      return false;
-    }
-    if (!managed.isStopped) {
-      logger.warn("Attempted to remove tunnel that is not stopped", { tunnelId });
-      return false;
-    }
-    this._cleanupTunnelRecords(managed);
-    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configid });
-    return true;
-  }
-  /**
-   * Remove a stopped tunnel by its config id.
-   * @param configId - the config id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByConfigId(configId) {
-    const managed = this.tunnelsByConfigId.get(configId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel by configId", { configId });
-      return false;
-    }
-    return this.removeStoppedTunnelByTunnelId(managed.tunnelid);
-  }
-  _cleanupTunnelRecords(managed) {
-    if (!managed.isStopped) {
-      throw new Error(`Active tunnel "${managed.tunnelid}" cannot be removed`);
-    }
-    try {
-      if (managed.serveWorker) {
-        managed.serveWorker = null;
-      }
-      this.tunnelStats.delete(managed.tunnelid);
-      this.tunnelStatsListeners.delete(managed.tunnelid);
-      this.tunnelErrorListeners.delete(managed.tunnelid);
-      this.tunnelDisconnectListeners.delete(managed.tunnelid);
-      this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
-      this.tunnelStartListeners.delete(managed.tunnelid);
-      this.tunnelsByTunnelId.delete(managed.tunnelid);
-      this.tunnelsByConfigId.delete(managed.configid);
-    } catch (e) {
-      logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
-    }
-  }
-  /**
-   * Get tunnel instance by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel instance
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  getTunnelInstance(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) throw new Error(`Tunnel "${configId}" not found`);
-      return managed.instance;
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-      return managed.instance;
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Get tunnel config by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel config
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  async getTunnelConfig(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) {
-        throw new Error(`Tunnel with configId "${configId}" not found`);
-      }
-      return managed.instance.getConfig();
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) {
-        throw new Error(`Tunnel with tunnelId "${tunnelId}" not found`);
-      }
-      return managed.instance.getConfig();
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Restarts a tunnel with its current configuration.
-   * This function will stop the tunnel if it's running and start it again.
-   * All configurations including additional forwarding rules are preserved.
-   */
-  async restartTunnel(tunnelid) {
-    const existingTunnel = this.tunnelsByTunnelId.get(tunnelid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel "${tunnelid}" not found`);
-    }
-    logger.info("Initiating tunnel restart", {
-      tunnelId: tunnelid,
-      configId: existingTunnel.configid
-    });
-    try {
-      const tunnelName = existingTunnel.tunnelName;
-      const currentConfigId = existingTunnel.configid;
-      const currentConfig = existingTunnel.tunnelConfig;
-      const configWithForwarding = existingTunnel.configWithForwarding;
-      const additionalForwarding = existingTunnel.additionalForwarding;
-      const currentServe = existingTunnel.serve;
-      const autoReconnect = existingTunnel.autoReconnect || false;
-      this.tunnelsByTunnelId.delete(tunnelid);
-      this.tunnelsByConfigId.delete(existingTunnel.configid);
-      this.tunnelStats.delete(tunnelid);
-      this.tunnelStatsListeners.delete(tunnelid);
-      this.tunnelErrorListeners.delete(tunnelid);
-      this.tunnelDisconnectListeners.delete(tunnelid);
-      this.tunnelWorkerErrorListeners.delete(tunnelid);
-      this.tunnelStartListeners.delete(tunnelid);
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid: currentConfigId,
-        tunnelid,
-        tunnelName,
-        originalConfig: currentConfig,
-        configWithForwarding,
-        additionalForwarding,
-        serve: currentServe,
-        autoReconnect
-      });
-      if (existingTunnel.createdAt) {
-        newTunnel.createdAt = existingTunnel.createdAt;
-      }
-      await this.startTunnel(newTunnel.tunnelid);
-    } catch (error) {
-      logger.error("Failed to restart tunnel", {
-        tunnelid,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw new Error(`Failed to restart tunnel: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * Updates the configuration of an existing tunnel.
-   * 
-   * This method handles the process of updating a tunnel's configuration while preserving
-   * its state. If the tunnel is running, it will be stopped, updated, and restarted.
-   * In case of failure, it attempts to restore the original configuration.
-   * 
-   * @param newConfig - The new configuration to apply, including configid and optional additional forwarding
-   * 
-   * @returns Promise resolving to the updated ManagedTunnel
-   * @throws Error if the tunnel is not found or if the update process fails
-   */
-  async updateConfig(newConfig) {
-    const { configid, tunnelName: newTunnelName, additionalForwarding } = newConfig;
-    if (!configid || configid.trim().length === 0) {
-      throw new Error(`Invalid configid: "${configid}"`);
-    }
-    const existingTunnel = this.tunnelsByConfigId.get(configid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel with config id "${configid}" not found`);
-    }
-    const isStopped = existingTunnel.isStopped;
-    const currentTunnelConfig = existingTunnel.tunnelConfig;
-    const currentConfigWithForwarding = existingTunnel.configWithForwarding;
-    const currentTunnelId = existingTunnel.tunnelid;
-    const currentTunnelConfigId = existingTunnel.configid;
-    const currentAdditionalForwarding = existingTunnel.additionalForwarding;
-    const currentTunnelName = existingTunnel.tunnelName;
-    const currentServe = existingTunnel.serve;
-    const currentAutoReconnect = existingTunnel.autoReconnect || false;
-    try {
-      if (!isStopped) {
-        existingTunnel.instance.stop();
-      }
-      this.tunnelsByTunnelId.delete(currentTunnelId);
-      this.tunnelsByConfigId.delete(currentTunnelConfigId);
-      const mergedBaseConfig = {
-        ...newConfig,
-        configid,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
-      };
-      const newConfigWithForwarding = this.buildPinggyConfig(
-        mergedBaseConfig,
-        additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
-      );
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid,
-        tunnelid: currentTunnelId,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        originalConfig: mergedBaseConfig,
-        configWithForwarding: newConfigWithForwarding,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
-        autoReconnect: currentAutoReconnect
-      });
-      if (!isStopped) {
-        await this.startTunnel(newTunnel.tunnelid);
-      }
-      logger.info("Tunnel configuration updated", {
-        tunnelId: newTunnel.tunnelid,
-        configId: newTunnel.configid,
-        isStopped
-      });
-      return newTunnel;
-    } catch (error) {
-      logger.error("Error updating tunnel configuration", {
-        configId: configid,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      try {
-        const originalTunnel = await this._createTunnelWithProcessedConfig({
-          configid: currentTunnelConfigId,
-          tunnelid: currentTunnelId,
-          tunnelName: currentTunnelName,
-          originalConfig: currentTunnelConfig,
-          configWithForwarding: currentConfigWithForwarding,
-          additionalForwarding: currentAdditionalForwarding,
-          serve: currentServe,
-          autoReconnect: currentAutoReconnect
-        });
-        if (!isStopped) {
-          await this.startTunnel(originalTunnel.tunnelid);
-        }
-        logger.warn("Restored original tunnel configuration after update failure", {
-          currentTunnelId,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      } catch (restoreError) {
-        logger.error("Failed to restore original tunnel configuration", {
-          currentTunnelId,
-          error: restoreError instanceof Error ? restoreError.message : "Unknown error"
-        });
-      }
-      throw error;
-    }
-  }
-  /**
-   * Retrieve the ManagedTunnel object by either configId or tunnelId.
-   * Throws an error if neither id is provided or the tunnel is not found.
-   */
-  getManagedTunnel(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) throw new Error(`Tunnel "${configId}" not found`);
-      return managed;
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-      return managed;
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  async getTunnelGreetMessage(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching greet message`);
-      return null;
-    }
-    try {
-      if (managed.isStopped) {
-        return null;
-      }
-      const messages = await managed.instance.getGreetMessage();
-      if (Array.isArray(messages)) {
-        return messages.join(" ");
-      }
-      return messages ?? null;
-    } catch (e) {
-      logger.error(
-        `Error fetching greet message for tunnel "${tunnelId}": ${e instanceof Error ? e.message : String(e)}`
-      );
-      return null;
-    }
-  }
-  getTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    return stats || null;
-  }
-  getLatestTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    if (stats && stats.length > 0) {
-      return stats[stats.length - 1];
-    }
-    return null;
-  }
-  /**
-   * Registers a listener function to receive tunnel statistics updates.
-   * The listener will be called whenever any tunnel's stats are updated.
-   * 
-   * @param tunnelId - The tunnel ID to listen to stats for
-   * @param listener - Function that receives tunnelId and stats when updates occur
-   * @returns A unique listener ID that can be used to deregister the listener and tunnelId
-   * 
-   * @throws {Error} When the specified tunnelId does not exist
-   */
-  async registerStatsListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStatsListeners.has(tunnelId)) {
-      this.tunnelStatsListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    tunnelListeners.set(listenerId, listener);
-    logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
-    return [listenerId, tunnelId];
-  }
-  async registerErrorListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelErrorListeners.has(tunnelId)) {
-      this.tunnelErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelErrorListeners = this.tunnelErrorListeners.get(tunnelId);
-    tunnelErrorListeners.set(listenerId, listener);
-    logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerDisconnectListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelDisconnectListeners.has(tunnelId)) {
-      this.tunnelDisconnectListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelDisconnectListeners = this.tunnelDisconnectListeners.get(tunnelId);
-    tunnelDisconnectListeners.set(listenerId, listener);
-    logger.info("Disconnect listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerWorkerErrorListner(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelWorkerErrorListeners.has(tunnelId)) {
-      this.tunnelWorkerErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelWorkerErrorListner = this.tunnelWorkerErrorListeners.get(tunnelId);
-    tunnelWorkerErrorListner?.set(listenerId, listener);
-    logger.info("TunnelWorker error listener registered for tunnel", { tunnelId, listenerId });
-  }
-  async registerStartListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStartListeners.has(tunnelId)) {
-      this.tunnelStartListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const listeners = this.tunnelStartListeners.get(tunnelId);
-    listeners.set(listenerId, listener);
-    logger.info("Start listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  /**
-   * Removes a previously registered stats listener.
-   * 
-  * @param tunnelId - The tunnel ID the listener was registered for
-  * @param listenerId - The unique ID returned when the listener was registered
-  */
-  deregisterStatsListener(tunnelId, listenerId) {
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    if (!tunnelListeners) {
-      logger.warn("No listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = tunnelListeners.delete(listenerId);
-    if (removed) {
-      logger.info("Stats listener deregistered", { tunnelId, listenerId });
-      if (tunnelListeners.size === 0) {
-        this.tunnelStatsListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent stats listener", { tunnelId, listenerId });
-    }
-  }
-  deregisterErrorListener(tunnelId, listenerId) {
-    const listeners = this.tunnelErrorListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No error listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Error listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelErrorListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
-    }
-  }
-  deregisterDisconnectListener(tunnelId, listenerId) {
-    const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No disconnect listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Disconnect listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelDisconnectListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent disconnect listener", { tunnelId, listenerId });
-    }
-  }
-  async getLocalserverTlsInfo(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching local server TLS info`);
-      return false;
-    }
-    try {
-      if (managed.isStopped) {
-        return false;
-      }
-      const tlsInfo = await managed.instance.getLocalServerTls();
-      if (tlsInfo) {
-        return tlsInfo;
-      }
-      return false;
-    } catch (e) {
-      logger.error(`Error fetching TLS info for tunnel "${tunnelId}": ${e instanceof Error ? e.message : e}`);
-      return false;
-    }
-  }
-  /**
-   * Sets up the stats callback for a tunnel during creation.
-   * This callback will update stored stats and notify all registered listeners.
-   */
-  setupStatsCallback(tunnelId, managed) {
-    try {
-      const callback = (usage) => {
-        this.updateStats(tunnelId, usage);
-      };
-      managed.instance.setUsageUpdateCallback(callback);
-      logger.debug("Stats callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up stats callback", { tunnelId, error });
-    }
-  }
-  notifyErrorListeners(tunnelId, errorMsg, isFatal) {
-    try {
-      const listeners = this.tunnelErrorListeners.get(tunnelId);
-      if (!listeners) return;
-      for (const [id, listener] of listeners) {
-        try {
-          listener(tunnelId, errorMsg, isFatal);
-        } catch (err) {
-          logger.debug("Error in error-listener callback", { listenerId: id, tunnelId, err });
-        }
-      }
-    } catch (err) {
-      logger.debug("Failed to notify error listeners", { tunnelId, err });
-    }
-  }
-  setupErrorCallback(tunnelId, managed) {
-    try {
-      const callback = ({ errorNo, error, recoverable }) => {
-        try {
-          const msg = typeof error === "string" ? error : String(error);
-          const isFatal = true;
-          logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
-          this.notifyErrorListeners(tunnelId, msg, isFatal);
-        } catch (e) {
-          logger.warn("Error handling tunnel error callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setTunnelErrorCallback(callback);
-      logger.debug("Error callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up error callback", { tunnelId, error });
-    }
-  }
-  setupDisconnectCallback(tunnelId, managed) {
-    try {
-      const callback = ({ error, messages }) => {
-        try {
-          logger.debug("Tunnel disconnected", { tunnelId, error, messages });
-          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
-          if (managedTunnel) {
-            managedTunnel.isStopped = true;
-            managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-          }
-          if (managedTunnel && managedTunnel.autoReconnect) {
-            logger.info("Auto-reconnecting tunnel", { tunnelId });
-            setTimeout(async () => {
-              try {
-                await this.restartTunnel(tunnelId);
-                logger.info("Tunnel auto-reconnected successfully", { tunnelId });
-              } catch (e) {
-                logger.error("Failed to auto-reconnect tunnel", { tunnelId, e });
-              }
-            }, 1e4);
-          }
-          const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-          if (!listeners) return;
-          for (const [id, listener] of listeners) {
-            try {
-              listener(tunnelId, error, messages);
-            } catch (err) {
-              logger.debug("Error in disconnect-listener callback", { listenerId: id, tunnelId, err });
-            }
-          }
-        } catch (e) {
-          logger.warn("Error handling tunnel disconnect callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setTunnelDisconnectedCallback(callback);
-      logger.debug("Disconnect callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up disconnect callback", { tunnelId, error });
-    }
-  }
-  setUpTunnelWorkerErrorCallback(tunnelId, managed) {
-    try {
-      const callback = (error) => {
-        try {
-          logger.debug("Error in Tunnel Worker", { tunnelId, errorMessage: error.message });
-          const listeners = this.tunnelWorkerErrorListeners.get(tunnelId);
-          if (!listeners) return;
-          for (const [id, listener] of listeners) {
-            try {
-              listener(tunnelId, error);
-            } catch (err) {
-              logger.debug("Error in worker-error-listener callback", { listenerId: id, tunnelId, err });
-            }
-          }
-        } catch (e) {
-          logger.warn("Error handling tunnel worker error callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setWorkerErrorCallback(callback);
-      logger.debug("Disconnect callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to setup tunnel worker error callback");
-    }
-  }
-  /**
-   * Updates the stored stats for a tunnel and notifies all registered listeners.
-   */
-  updateStats(tunnelId, rawUsage) {
-    try {
-      const normalizedStats = this.normalizeStats(rawUsage);
-      const existingStats = this.tunnelStats.get(tunnelId) || [];
-      const updatedStats = [...existingStats, normalizedStats];
-      this.tunnelStats.set(tunnelId, updatedStats);
-      const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-      if (tunnelListeners) {
-        for (const [listenerId, listener] of tunnelListeners) {
-          try {
-            listener(tunnelId, normalizedStats);
-          } catch (error) {
-            logger.warn("Error in stats listener callback", { listenerId, tunnelId, error });
-          }
-        }
-      }
-      logger.debug("Stats updated and listeners notified", {
-        tunnelId,
-        listenersCount: tunnelListeners?.size || 0
-      });
-    } catch (error) {
-      logger.warn("Error updating stats", { tunnelId, error });
-    }
-  }
-  /**
-   * Normalizes raw usage data from the SDK into a consistent TunnelStats format.
-   */
-  normalizeStats(rawStats) {
-    const elapsed = this.parseNumber(rawStats.elapsedTime ?? 0);
-    const liveConns = this.parseNumber(rawStats.numLiveConnections ?? 0);
-    const totalConns = this.parseNumber(rawStats.numTotalConnections ?? 0);
-    const reqBytes = this.parseNumber(rawStats.numTotalReqBytes ?? 0);
-    const resBytes = this.parseNumber(rawStats.numTotalResBytes ?? 0);
-    const txBytes = this.parseNumber(rawStats.numTotalTxBytes ?? 0);
-    return {
-      elapsedTime: elapsed,
-      numLiveConnections: liveConns,
-      numTotalConnections: totalConns,
-      numTotalReqBytes: reqBytes,
-      numTotalResBytes: resBytes,
-      numTotalTxBytes: txBytes
-    };
-  }
-  parseNumber(value) {
-    const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
-    return isNaN(parsed) ? 0 : parsed;
-  }
-  startStaticFileServer(managed) {
-    try {
-      const __filename3 = fileURLToPath(import.meta.url);
-      const __dirname3 = path.dirname(__filename3);
-      const fileServerWorkerPath = path.join(__dirname3, "workers", "file_serve_worker.cjs");
-      const staticServerWorker = new Worker(fileServerWorkerPath, {
-        workerData: {
-          dir: managed.serve,
-          port: managed.tunnelConfig?.forwarding
-        }
-      });
-      staticServerWorker.on("message", (msg) => {
-        switch (msg.type) {
-          case "started":
-            logger.info("Static file server started", { dir: managed.serve });
-            break;
-          case "warning":
-            if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
-              managed.warnings = managed.warnings ?? [];
-              managed.warnings.push({ code: msg.code, message: msg.message });
-            }
-            printer_default.warn(msg.message);
-            break;
-          case "error":
-            managed.warnings = managed.warnings ?? [];
-            managed.warnings.push({
-              code: "UNKNOWN_WARNING",
-              message: msg.message
-            });
-            break;
-        }
-      });
-      managed.serveWorker = staticServerWorker;
-    } catch (error) {
-      logger.error("Error starting static file server", error);
-    }
-  }
-};
-
 // src/cli/options.ts
 var cliOptions = {
   // SSH-like options
@@ -995,7 +42,7 @@ var cliOptions = {
   v: { type: "boolean", description: "Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable" },
   vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
   vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
-  autoreconnect: { type: "string", short: "a", description: "Automatically reconnect tunnel on failure. Use -a (defaults to true), -a true, or -a false." },
+  autoreconnect: { type: "string", short: "a", description: "Automatically reconnect tunnel on failure (enabled by default). Use -a false to disable." },
   // Save and load config
   saveconf: { type: "string", description: "Create the configuration file based on the options provided here" },
   conf: { type: "string", description: "Use the configuration file as base. Other options will be used to override this file" },
@@ -1195,16 +242,16 @@ function isValidIpV6Cidr(input) {
 }
 
 // src/cli/buildConfig.ts
-import { TunnelType as TunnelType2 } from "@pinggy/pinggy";
+import { TunnelType } from "@pinggy/pinggy";
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 var domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var KEYWORDS = /* @__PURE__ */ new Set([
-  TunnelType2.Http,
-  TunnelType2.Tcp,
-  TunnelType2.Tls,
-  TunnelType2.Udp,
-  TunnelType2.TlsTcp,
+  TunnelType.Http,
+  TunnelType.Tcp,
+  TunnelType.Tls,
+  TunnelType.Udp,
+  TunnelType.TlsTcp,
   "force",
   "qr"
 ]);
@@ -1222,7 +269,7 @@ function parseUserAndDomain(str) {
     const [user, domain] = str.split("@", 2);
     if (domainRegex.test(domain)) {
       let processKeyword2 = function(keyword) {
-        if ([TunnelType2.Http, TunnelType2.Tcp, TunnelType2.Tls, TunnelType2.Udp, TunnelType2.TlsTcp].includes(keyword)) {
+        if ([TunnelType.Http, TunnelType.Tcp, TunnelType.Tls, TunnelType.Udp, TunnelType.TlsTcp].includes(keyword)) {
           type = keyword;
         } else if (keyword === "force") {
           forceFlag = true;
@@ -1292,7 +339,7 @@ function parseUsers(positionalArgs, explicitToken) {
 }
 function parseType(finalConfig, values, inferredType) {
   const t = inferredType || values.type || finalConfig.tunnelType;
-  if (t === TunnelType2.Http || t === TunnelType2.Tcp || t === TunnelType2.Tls || t === TunnelType2.Udp || t === TunnelType2.TlsTcp) {
+  if (t === TunnelType.Http || t === TunnelType.Tcp || t === TunnelType.Tls || t === TunnelType.Udp || t === TunnelType.TlsTcp) {
     finalConfig.tunnelType = [t];
   }
 }
@@ -1499,10 +546,10 @@ function parseArgs(finalConfig, remainingPositionals) {
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
-    const path3 = saveconf;
+    const path2 = saveconf;
     try {
-      fs.writeFileSync(path3, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
-      logger.info(`Configuration saved to ${path3}`);
+      fs.writeFileSync(path2, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
+      logger.info(`Configuration saved to ${path2}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       logger.error("Error loading configuration:", msg);
@@ -1512,7 +559,7 @@ function storeJson(config, saveconf) {
 function loadJsonConfig(config) {
   const configpath = config["conf"];
   if (typeof configpath === "string" && configpath.trim().length > 0) {
-    const filepath = path2.resolve(configpath);
+    const filepath = path.resolve(configpath);
     try {
       const data = fs.readFileSync(filepath, { encoding: "utf-8" });
       const json = JSON.parse(data);
@@ -1574,7 +621,7 @@ async function buildFinalConfig(values, positionals) {
     configid: getRandomId(),
     token: token || (configFromFile?.token || (typeof values.token === "string" ? values.token : "")),
     serverAddress: server || (configFromFile?.serverAddress || defaultOptions.serverAddress),
-    tunnelType: initialTunnel ? [initialTunnel] : configFromFile?.tunnelType || [TunnelType2.Http],
+    tunnelType: initialTunnel ? [initialTunnel] : configFromFile?.tunnelType || [TunnelType.Http],
     NoTUI: values.notui || (configFromFile?.NoTUI || false),
     qrCode: qrCode || (configFromFile?.qrCode || false),
     autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect
@@ -1599,727 +646,6 @@ async function buildFinalConfig(values, positionals) {
   return finalConfig;
 }
 
-// src/remote_management/remoteManagement.ts
-import WebSocket from "ws";
-
-// src/types.ts
-var ErrorCode = {
-  InvalidRequestMethodError: "INVALID_REQUEST_METHOD",
-  InvalidRequestBodyError: "COULD_NOT_READ_BODY",
-  InternalServerError: "INTERNAL_SERVER_ERROR",
-  InvalidBodyFormatError: "INVALID_DATA_FORMAT",
-  ErrorStartingTunnel: "ERROR_STARTING_TUNNEL",
-  TunnelNotFound: "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND",
-  TunnelAlreadyRunningError: "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING",
-  WebsocketUpgradeFailError: "WEBSOCKET_UPGRADE_FAILED",
-  RemoteManagementAlreadyRunning: "REMOTE_MANAGEMENT_ALREADY_RUNNING",
-  RemoteManagementNotRunning: "REMOTE_MANAGEMENT_NOT_RUNNING",
-  RemoteManagementDeserializationFailed: "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED"
-};
-function isErrorResponse(obj) {
-  return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj && typeof obj.message === "string" && Object.values(ErrorCode).includes(obj.code);
-}
-function newErrorResponse(codeOrError, message) {
-  if (typeof codeOrError === "object") {
-    return codeOrError;
-  }
-  return {
-    code: codeOrError,
-    message
-  };
-}
-function NewResponseObject(data) {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(JSON.stringify(data));
-  return {
-    response: bytes,
-    requestid: "",
-    command: "",
-    error: false,
-    errorresponse: {}
-  };
-}
-function NewErrorResponseObject(errorResponse) {
-  return {
-    response: new Uint8Array(),
-    requestid: "",
-    command: "",
-    error: true,
-    errorresponse: errorResponse
-  };
-}
-function newStatus(tunnelState, errorCode, errorMsg) {
-  let assignedState = tunnelState;
-  if (tunnelState === "live" /* Live */) {
-    assignedState = "running" /* Running */;
-  } else if (tunnelState === "idle" /* New */) {
-    assignedState = "idle" /* New */;
-  } else if (tunnelState === "closed" /* Closed */) {
-    assignedState = "exited" /* Exited */;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    state: assignedState,
-    errorcode: errorCode,
-    errormsg: errorMsg,
-    createdtimestamp: now,
-    starttimestamp: now,
-    endtimestamp: now,
-    warnings: []
-  };
-}
-function newStats() {
-  return {
-    numLiveConnections: 0,
-    numTotalConnections: 0,
-    numTotalReqBytes: 0,
-    numTotalResBytes: 0,
-    numTotalTxBytes: 0,
-    elapsedTime: 0
-  };
-}
-var RemoteManagementStatus = {
-  Connecting: "CONNECTING",
-  Disconnecting: "DISCONNECTING",
-  Reconnecting: "RECONNECTING",
-  Running: "RUNNING",
-  NotRunning: "NOT_RUNNING",
-  Error: "ERROR"
-};
-
-// src/remote_management/remote_schema.ts
-import { TunnelType as TunnelType3 } from "@pinggy/pinggy";
-import { z } from "zod";
-var HeaderModificationSchema = z.object({
-  key: z.string(),
-  value: z.array(z.string()).optional(),
-  type: z.enum(["add", "remove", "update"])
-});
-var AdditionalForwardingSchema = z.object({
-  remoteDomain: z.string().optional(),
-  remotePort: z.number().optional(),
-  localDomain: z.string(),
-  localPort: z.number()
-});
-var TunnelConfigSchema = z.object({
-  allowPreflight: z.boolean().optional(),
-  // primary key
-  allowpreflight: z.boolean().optional(),
-  // legacy key
-  autoreconnect: z.boolean(),
-  basicauth: z.array(z.object({ username: z.string(), password: z.string() })).nullable(),
-  bearerauth: z.string().nullable(),
-  configid: z.string(),
-  configname: z.string(),
-  greetmsg: z.string().optional(),
-  force: z.boolean(),
-  forwardedhost: z.string(),
-  fullRequestUrl: z.boolean(),
-  headermodification: z.array(HeaderModificationSchema),
-  httpsOnly: z.boolean(),
-  internalwebdebuggerport: z.number(),
-  ipwhitelist: z.array(z.string()).nullable(),
-  localport: z.number(),
-  localsservertls: z.union([z.boolean(), z.string()]),
-  localservertlssni: z.string().nullable(),
-  regioncode: z.string(),
-  noReverseProxy: z.boolean(),
-  serveraddress: z.string(),
-  serverport: z.number(),
-  statusCheckInterval: z.number(),
-  token: z.string(),
-  tunnelTimeout: z.number(),
-  type: z.enum([
-    TunnelType3.Http,
-    TunnelType3.Tcp,
-    TunnelType3.Udp,
-    TunnelType3.Tls,
-    TunnelType3.TlsTcp
-  ]),
-  webdebuggerport: z.number(),
-  xff: z.string(),
-  additionalForwarding: z.array(AdditionalForwardingSchema).optional(),
-  serve: z.string().optional()
-}).superRefine((data, ctx) => {
-  if (data.allowPreflight === void 0 && data.allowpreflight === void 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Either allowPreflight or allowpreflight is required",
-      path: ["allowPreflight"]
-    });
-  }
-}).transform((data) => ({
-  ...data,
-  allowPreflight: data.allowPreflight ?? data.allowpreflight,
-  allowpreflight: data.allowPreflight ?? data.allowpreflight
-}));
-var StartSchema = z.object({
-  tunnelID: z.string().nullable().optional(),
-  tunnelConfig: TunnelConfigSchema
-});
-var StopSchema = z.object({
-  tunnelID: z.string().min(1)
-});
-var GetSchema = StopSchema;
-var RestartSchema = StopSchema;
-var UpdateConfigSchema = z.object({
-  tunnelConfig: TunnelConfigSchema
-});
-function tunnelConfigToPinggyOptions(config) {
-  return {
-    token: config.token || "",
-    serverAddress: config.serveraddress || "free.pinggy.io",
-    forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
-    webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
-    ipWhitelist: config.ipwhitelist || [],
-    basicAuth: config.basicauth ? config.basicauth : [],
-    bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
-    headerModification: config.headermodification,
-    xForwardedFor: !!config.xff,
-    httpsOnly: config.httpsOnly,
-    originalRequestUrl: config.fullRequestUrl,
-    allowPreflight: config.allowPreflight,
-    reverseProxy: config.noReverseProxy,
-    force: config.force,
-    autoReconnect: config.autoreconnect,
-    optional: {
-      sniServerName: config.localservertlssni || ""
-    }
-  };
-}
-function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg, additionalForwarding, serve) {
-  const forwarding = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
-  const parsedForwardedHost = forwarding.split(":").length == 3 ? forwarding.split(":")[1] : forwarding.split(":")[0];
-  const parsedLocalPort = forwarding.split(":").length == 3 ? parseInt(forwarding.split(":")[2], 10) : parseInt(forwarding.split(":")[1], 10);
-  const tunnelType = (Array.isArray(opts.forwarding) ? opts.forwarding[0]?.type : void 0) ?? TunnelType3.Http;
-  const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
-  return {
-    allowPreflight: opts.allowPreflight ?? false,
-    allowpreflight: opts.allowPreflight ?? false,
-    autoreconnect: opts.autoReconnect ?? false,
-    basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : null,
-    bearerauth: parsedTokens.length ? parsedTokens.join(",") : null,
-    configid,
-    configname: configName,
-    greetmsg: greetMsg || "",
-    force: opts.force ?? false,
-    forwardedhost: parsedForwardedHost || "localhost",
-    fullRequestUrl: opts.originalRequestUrl ?? false,
-    headermodification: opts.headerModification || [],
-    //structured list
-    httpsOnly: opts.httpsOnly ?? false,
-    internalwebdebuggerport: 0,
-    ipwhitelist: opts.ipWhitelist ? Array.isArray(opts.ipWhitelist) ? opts.ipWhitelist : JSON.parse(opts.ipWhitelist) : null,
-    localport: parsedLocalPort || 0,
-    localservertlssni: null,
-    regioncode: "",
-    noReverseProxy: opts.reverseProxy ?? false,
-    serveraddress: opts.serverAddress || "free.pinggy.io",
-    serverport: 0,
-    statusCheckInterval: 0,
-    token: opts.token || "",
-    tunnelTimeout: 0,
-    type: tunnelType,
-    webdebuggerport: Number(opts.webDebugger?.split(":")[0]) || 0,
-    xff: opts.xForwardedFor ? "1" : "",
-    localsservertls: localserverTls || false,
-    additionalForwarding: additionalForwarding || [],
-    serve: serve || ""
-  };
-}
-
-// src/remote_management/handler.ts
-import { TunnelType as TunnelType4 } from "@pinggy/pinggy";
-var TunnelOperations = class {
-  constructor() {
-    this.tunnelManager = TunnelManager.getInstance();
-  }
-  buildStatus(tunnelId, state, errorCode) {
-    const status = newStatus(state, errorCode, "");
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
-      if (managed) {
-        status.createdtimestamp = managed.createdAt || "";
-        status.starttimestamp = managed.startedAt || "";
-        status.endtimestamp = managed.stoppedAt || "";
-      }
-    } catch (e) {
-    }
-    return status;
-  }
-  // --- Helper to construct TunnelResponse ---
-  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
-    const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
-      this.tunnelManager.getTunnelStatus(tunnelid),
-      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
-      this.tunnelManager.getLocalserverTlsInfo(tunnelid),
-      this.tunnelManager.getTunnelGreetMessage(tunnelid),
-      this.tunnelManager.getTunnelUrls(tunnelid)
-    ]);
-    return {
-      tunnelid,
-      remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
-      status: this.buildStatus(tunnelid, status, "" /* NoError */),
-      stats
-    };
-  }
-  error(code, err, fallback) {
-    return newErrorResponse({
-      code,
-      message: err instanceof Error ? err.message : fallback
-    });
-  }
-  // --- Operations ---
-  async handleStart(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const additionalForwardingParsed = config.additionalForwarding || [];
-      const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType4.Http],
-        // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: additionalForwardingParsed,
-        serve: config.serve
-      });
-      this.tunnelManager.startTunnel(tunnelid);
-      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
-      return resp;
-    } catch (err) {
-      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-    }
-  }
-  async handleUpdateConfig(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const tunnel = await this.tunnelManager.updateConfig({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType4.Http],
-        // // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: config.additionalForwarding || [],
-        serve: config.serve
-      });
-      if (!tunnel.instance || !tunnel.tunnelConfig)
-        throw new Error("Invalid tunnel state after configuration update");
-      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.additionalForwarding, tunnel.serve);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-    }
-  }
-  async handleList() {
-    try {
-      const tunnels = await this.tunnelManager.getAllTunnels();
-      if (tunnels.length === 0) {
-        return [];
-      }
-      return Promise.all(
-        tunnels.map(async (t) => {
-          const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
-          const [status, tlsInfo, greetMsg] = await Promise.all([
-            this.tunnelManager.getTunnelStatus(t.tunnelid),
-            this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
-            this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
-          ]);
-          const pinggyOptions = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
-          const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
-          return {
-            tunnelid: t.tunnelid,
-            remoteurls: t.remoteurls,
-            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
-            stats: rawStats,
-            tunnelconfig: tunnelConfig
-          };
-        })
-      );
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
-    }
-  }
-  async handleStop(tunnelid) {
-    try {
-      const { configid } = this.tunnelManager.stopTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
-    }
-  }
-  async handleGet(tunnelid) {
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
-    }
-  }
-  async handleRestart(tunnelid) {
-    try {
-      await this.tunnelManager.restartTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
-    }
-  }
-  handleRegisterStatsListener(tunnelid, listener) {
-    this.tunnelManager.registerStatsListener(tunnelid, listener);
-  }
-  handleUnregisterStatsListener(tunnelid, listnerId) {
-    this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
-  }
-  handleGetTunnelStats(tunnelid) {
-    try {
-      const stats = this.tunnelManager.getTunnelStats(tunnelid);
-      if (!stats) {
-        return [newStats()];
-      }
-      return stats;
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel stats");
-    }
-  }
-  handleRegisterDisconnectListener(tunnelid, listener) {
-    this.tunnelManager.registerDisconnectListener(tunnelid, listener);
-  }
-  handleRemoveStoppedTunnelByConfigId(configId) {
-    try {
-      return this.tunnelManager.removeStoppedTunnelByConfigId(configId);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by configId");
-    }
-  }
-  handleRemoveStoppedTunnelByTunnelId(tunnelId) {
-    try {
-      return this.tunnelManager.removeStoppedTunnelByTunnelId(tunnelId);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by tunnelId");
-    }
-  }
-};
-
-// src/remote_management/websocket_handlers.ts
-import z2 from "zod";
-var WebSocketCommandHandler = class {
-  constructor() {
-    this.tunnelHandler = new TunnelOperations();
-  }
-  safeParse(text) {
-    if (!text) return void 0;
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      logger.warn("Invalid JSON payload", { error: String(e), text });
-      return void 0;
-    }
-  }
-  sendResponse(ws, resp) {
-    const payload = {
-      ...resp,
-      response: Buffer.from(resp.response || []).toString("base64")
-    };
-    ws.send(JSON.stringify(payload));
-  }
-  sendError(ws, req, message, code = ErrorCode.InternalServerError) {
-    const resp = NewErrorResponseObject({ code, message });
-    resp.command = req.command || "";
-    resp.requestid = req.requestid || "";
-    this.sendResponse(ws, resp);
-  }
-  async handleStartReq(req, raw) {
-    const dc = StartSchema.parse(raw);
-    printer_default.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
-    const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleStopReq(req, raw) {
-    const dc = StopSchema.parse(raw);
-    printer_default.info("Stopping tunnel with ID: " + dc.tunnelID);
-    const result = await this.tunnelHandler.handleStop(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleGetReq(req, raw) {
-    const dc = GetSchema.parse(raw);
-    const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleRestartReq(req, raw) {
-    const dc = RestartSchema.parse(raw);
-    const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleUpdateConfigReq(req, raw) {
-    const dc = UpdateConfigSchema.parse(raw);
-    const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleListReq(req) {
-    const result = await this.tunnelHandler.handleList();
-    return this.wrapResponse(result, req);
-  }
-  wrapResponse(result, req) {
-    if (isErrorResponse(result)) {
-      const errResp = NewErrorResponseObject(result);
-      errResp.command = req.command;
-      errResp.requestid = req.requestid;
-      return errResp;
-    }
-    const finalResult = JSON.parse(JSON.stringify(result));
-    if (Array.isArray(finalResult)) {
-      finalResult.forEach((item) => {
-        if (item?.tunnelconfig) {
-          delete item.tunnelconfig.allowPreflight;
-        }
-      });
-    } else if (finalResult?.tunnelconfig) {
-      delete finalResult.tunnelconfig.allowPreflight;
-    }
-    const respObj = NewResponseObject(finalResult);
-    respObj.command = req.command;
-    respObj.requestid = req.requestid;
-    return respObj;
-  }
-  async handle(ws, req) {
-    const cmd = (req.command || "").toLowerCase();
-    const raw = this.safeParse(req.data);
-    try {
-      let response;
-      switch (cmd) {
-        case "start": {
-          response = await this.handleStartReq(req, raw);
-          break;
-        }
-        case "stop": {
-          response = await this.handleStopReq(req, raw);
-          break;
-        }
-        case "get": {
-          response = await this.handleGetReq(req, raw);
-          break;
-        }
-        case "restart": {
-          response = await this.handleRestartReq(req, raw);
-          break;
-        }
-        case "updateconfig": {
-          response = await this.handleUpdateConfigReq(req, raw);
-          break;
-        }
-        case "list": {
-          response = await this.handleListReq(req);
-          break;
-        }
-        default:
-          if (typeof req.command === "string") {
-            logger.warn("Unknown command", { command: req.command });
-          }
-          return this.sendError(ws, req, "Invalid command");
-      }
-      logger.debug("Sending response", { command: response.command, requestid: response.requestid });
-      this.sendResponse(ws, response);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        logger.warn("Validation failed", { cmd, issues: e.issues });
-        return this.sendError(ws, req, "Invalid request data", ErrorCode.InvalidBodyFormatError);
-      }
-      logger.error("Error handling command", { cmd, error: String(e) });
-      return this.sendError(ws, req, e?.message || "Internal error");
-    }
-  }
-};
-function handleConnectionStatusMessage(firstMessage) {
-  try {
-    const text = typeof firstMessage === "string" ? firstMessage : firstMessage.toString();
-    const cs = JSON.parse(text);
-    if (!cs.success) {
-      const msg = cs.error_msg || "Connection failed";
-      printer_default.warn(`Connection failed: ${msg}`);
-      logger.warn("Remote management connection failed", { error_code: cs.error_code, error_msg: msg });
-      return false;
-    }
-    return true;
-  } catch (e) {
-    logger.warn("Failed to parse connection status message", { error: String(e) });
-    return true;
-  }
-}
-
-// src/remote_management/remoteManagement.ts
-var RECONNECT_SLEEP_MS = 5e3;
-var PING_INTERVAL_MS = 3e4;
-var _remoteManagementState = {
-  status: "NOT_RUNNING",
-  errorMessage: ""
-};
-var _stopRequested = false;
-var currentWs = null;
-function buildRemoteManagementWsUrl(manage) {
-  let baseUrl = (manage || "dashboard.pinggy.io").trim();
-  if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
-    baseUrl = "wss://" + baseUrl;
-  }
-  const trimmed = baseUrl.replace(/\/$/, "");
-  return `${trimmed}/backend/api/v1/remote-management/connect`;
-}
-function extractHostname(u) {
-  try {
-    const url = new URL(u);
-    return url.host;
-  } catch {
-    return u;
-  }
-}
-function sleep(ms) {
-  return new Promise((res) => setTimeout(res, ms));
-}
-async function parseRemoteManagement(values) {
-  const rmToken = values["remote-management"];
-  if (typeof rmToken === "string" && rmToken.trim().length > 0) {
-    const manageHost = values["manage"];
-    try {
-      await initiateRemoteManagement(rmToken, manageHost);
-      return { ok: true };
-    } catch (e) {
-      logger.error("Failed to initiate remote management:", e);
-      return { ok: false, error: e };
-    }
-  }
-}
-async function initiateRemoteManagement(token, manage) {
-  if (!token || token.trim().length === 0) {
-    throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
-  }
-  const wsUrl = buildRemoteManagementWsUrl(manage);
-  const wsHost = extractHostname(wsUrl);
-  logger.info("Remote management mode enabled.");
-  _stopRequested = false;
-  const sigintHandler = () => {
-    _stopRequested = true;
-  };
-  process.once("SIGINT", sigintHandler);
-  const logConnecting = () => {
-    printer_default.print(`Connecting to ${wsHost}`);
-    logger.info("Connecting to remote management", { wsUrl });
-  };
-  while (!_stopRequested) {
-    logConnecting();
-    setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
-    try {
-      await handleWebSocketConnection(wsUrl, wsHost, token);
-    } catch (error) {
-      logger.warn("Remote management connection error", { error: String(error) });
-    }
-    if (_stopRequested) break;
-    printer_default.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds...`);
-    logger.info("Reconnecting to remote management after disconnect");
-    await sleep(RECONNECT_SLEEP_MS);
-  }
-  process.removeListener("SIGINT", sigintHandler);
-  logger.info("Remote management stopped.");
-  return getRemoteManagementState();
-}
-async function handleWebSocketConnection(wsUrl, wsHost, token) {
-  return new Promise((resolve) => {
-    const ws = new WebSocket(wsUrl, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    currentWs = ws;
-    let heartbeat = null;
-    let firstMessage = true;
-    const cleanup = () => {
-      if (heartbeat) clearInterval(heartbeat);
-      currentWs = null;
-      resolve();
-    };
-    ws.once("open", () => {
-      printer_default.success(`Connected to ${wsHost}`);
-      heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) ws.ping();
-      }, PING_INTERVAL_MS);
-    });
-    ws.on("ping", () => ws.pong());
-    ws.on("message", async (data) => {
-      try {
-        if (firstMessage) {
-          firstMessage = false;
-          const ok = handleConnectionStatusMessage(data);
-          if (!ok) ws.close();
-          return;
-        }
-        setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
-        const req = JSON.parse(data.toString("utf8"));
-        await new WebSocketCommandHandler().handle(ws, req);
-      } catch (e) {
-        logger.warn("Failed handling websocket message", { error: String(e) });
-      }
-    });
-    ws.on("unexpected-response", (_, res) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
-      if (res.statusCode === 401) {
-        printer_default.error("Unauthorized. Please enter a valid token.");
-        logger.error("Unauthorized (401) on remote management connect");
-      } else {
-        printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
-        logger.warn("Unexpected HTTP response", { statusCode: res.statusCode });
-      }
-      ws.close();
-    });
-    ws.on("close", (code, reason) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-      logger.info("WebSocket closed", { code, reason: reason.toString() });
-      printer_default.warn(`Disconnected (code: ${code}). Retrying...`);
-      cleanup();
-    });
-    ws.on("error", (err) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
-      logger.warn("WebSocket error", { error: err.message });
-      printer_default.error(err);
-      cleanup();
-    });
-  });
-}
-async function closeRemoteManagement(timeoutMs = 1e4) {
-  _stopRequested = true;
-  try {
-    if (currentWs) {
-      try {
-        setRemoteManagementState({ status: RemoteManagementStatus.Disconnecting, errorMessage: "" });
-        currentWs.close();
-      } catch (e) {
-        logger.warn("Error while closing current remote management websocket", { error: String(e) });
-      }
-    }
-    const start = Date.now();
-    while (_remoteManagementState.status === "RUNNING") {
-      if (Date.now() - start > timeoutMs) {
-        logger.warn("Timed out waiting for remote management to stop");
-        break;
-      }
-      await sleep(200);
-    }
-  } finally {
-    currentWs = null;
-    setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-    return getRemoteManagementState();
-  }
-}
-function getRemoteManagementState() {
-  return _remoteManagementState;
-}
-function setRemoteManagementState(state, errorMessage) {
-  _remoteManagementState = {
-    status: state.status,
-    errorMessage: errorMessage || ""
-  };
-}
-
 // src/utils/parseArgs.ts
 import { parseArgs as parseArgs2 } from "util";
 import * as os from "os";
@@ -2418,7 +744,7 @@ async function createQrCodes(urls) {
 }
 
 // src/tui/blessed/webDebuggerConnection.ts
-import WebSocket2 from "ws";
+import WebSocket from "ws";
 
 // src/tui/blessed/config.ts
 var defaultTuiConfig = {
@@ -2461,7 +787,7 @@ function createWebDebuggerConnection(webDebuggerUrl, onUpdate) {
     trimPairs();
   };
   const connect = () => {
-    const ws = new WebSocket2(`ws://${webDebuggerUrl}/introspec/websocket`);
+    const ws = new WebSocket(`ws://${webDebuggerUrl}/introspec/websocket`);
     socket = ws;
     ws.on("open", () => {
       logger.info("Web debugger connected.");
@@ -3064,6 +1390,91 @@ function closeDisconnectModal(screen, manager) {
   manager.inDisconnectView = false;
   screen.render();
 }
+function showReconnectingModal(screen, manager, retryCnt, message) {
+  if (manager.reconnectModal) {
+    manager.reconnectModal.destroy();
+    manager.reconnectModal = null;
+  }
+  manager.inReconnectView = true;
+  manager.reconnectModal = blessed2.box({
+    parent: screen,
+    top: "center",
+    left: "center",
+    width: "50%",
+    height: "20%",
+    border: {
+      type: "line"
+    },
+    style: {
+      border: {
+        fg: "yellow"
+      }
+    },
+    padding: { left: 2, right: 2, top: 1, bottom: 1 },
+    tags: true,
+    align: "center",
+    valign: "middle"
+  });
+  const content = `{yellow-fg}{bold}Reconnecting...{/bold}{/yellow-fg}
+
+${message || `Attempt #${retryCnt} \u2014 trying to re-establish tunnel...`}
+
+{gray-fg}Please wait{/gray-fg}`;
+  manager.reconnectModal.setContent(content);
+  manager.reconnectModal.focus();
+  screen.render();
+}
+function closeReconnectingModal(screen, manager) {
+  if (manager.reconnectModal) {
+    manager.reconnectModal.destroy();
+    manager.reconnectModal = null;
+  }
+  manager.inReconnectView = false;
+  screen.render();
+}
+function showReconnectionFailedModal(screen, manager, retryCnt, onClose) {
+  closeReconnectingModal(screen, manager);
+  manager.inReconnectView = true;
+  manager.reconnectModal = blessed2.box({
+    parent: screen,
+    top: "center",
+    left: "center",
+    width: "50%",
+    height: "20%",
+    border: {
+      type: "line"
+    },
+    style: {
+      border: {
+        fg: "red"
+      }
+    },
+    padding: { left: 2, right: 2, top: 1, bottom: 1 },
+    tags: true,
+    align: "center",
+    valign: "middle"
+  });
+  const content = `{red-fg}{bold}Reconnection Failed{/bold}{/red-fg}
+
+Failed to reconnect after ${retryCnt} attempts.
+Tunnel will be closed.
+
+{white-bg}{black-fg}Closing in 5 seconds...{/black-fg}{/white-bg}`;
+  manager.reconnectModal.setContent(content);
+  manager.reconnectModal.focus();
+  screen.render();
+  const timeout = setTimeout(() => {
+    closeReconnectingModal(screen, manager);
+    if (onClose) onClose();
+  }, 5e3);
+  const keyHandler = () => {
+    clearTimeout(timeout);
+    closeReconnectingModal(screen, manager);
+    if (onClose) onClose();
+  };
+  manager.reconnectModal.key(["escape", "enter", "space"], keyHandler);
+  screen.key(["escape", "enter", "space"], keyHandler);
+}
 function showLoadingModal(screen, modalManager, message = "Loading...") {
   if (modalManager.loadingView) return;
   modalManager.loadingBox = blessed2.box({
@@ -3333,9 +1744,11 @@ var TunnelTui = class {
       detailModal: null,
       keyBindingsModal: null,
       disconnectModal: null,
+      reconnectModal: null,
       inDetailView: false,
       keyBindingView: false,
       inDisconnectView: false,
+      inReconnectView: false,
       loadingBox: null,
       loadingView: false,
       fetchAbortController: null
@@ -3363,8 +1776,8 @@ var TunnelTui = class {
     this.setupKeyBindings();
   }
   setupStatsListener() {
-    globalThis.__PINGGY_TUNNEL_STATS__ = (newStats2) => {
-      this.stats = { ...newStats2 };
+    globalThis.__PINGGY_TUNNEL_STATS__ = (newStats) => {
+      this.stats = { ...newStats };
       this.updateStatsDisplay();
     };
   }
@@ -3536,6 +1949,25 @@ Tunnel will be closed.` : info.messages?.join("\n") || "Disconnect request recei
       );
     }
   }
+  updateReconnectingInfo(retryCnt, message) {
+    showReconnectingModal(
+      this.screen,
+      this.modalManager,
+      retryCnt,
+      message
+    );
+  }
+  closeReconnectingInfo() {
+    closeReconnectingModal(this.screen, this.modalManager);
+  }
+  updateReconnectionFailed(retryCnt) {
+    showReconnectionFailedModal(
+      this.screen,
+      this.modalManager,
+      retryCnt,
+      () => this.destroy()
+    );
+  }
   start() {
     this.screen.render();
   }
@@ -3632,6 +2064,35 @@ async function startCli(finalConfig, manager) {
     }
     printer_default.print(pico.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     printer_default.print(pico.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+    manager2.registerWillReconnectListener(tunnel.tunnelid, (tunnelId, error, messages) => {
+      if (activeTui) {
+        const msg = messages?.join("\n") || error || "Tunnel disconnected, reconnecting...";
+        activeTui.updateReconnectingInfo(0, msg);
+      } else if (finalConfig.autoReconnect) {
+        printer_default.warn(error || "Tunnel connection reset");
+        printer_default.startSpinner(messages?.join("\n"));
+      }
+    });
+    manager2.registerReconnectingListener(tunnel.tunnelid, (tunnelId, retryCnt) => {
+      if (activeTui) {
+        activeTui.updateReconnectingInfo(retryCnt);
+      } else if (finalConfig.autoReconnect) {
+        printer_default.startSpinner(`Reconnecting to Pinggy (attempt #${retryCnt})`);
+      }
+    });
+    manager2.registerReconnectionCompletedListener(tunnel.tunnelid, (tunnelId, urls) => {
+      if (activeTui) {
+        activeTui.closeReconnectingInfo();
+      }
+    });
+    manager2.registerReconnectionFailedListener(tunnel.tunnelid, (tunnelId, retryCnt) => {
+      if (activeTui) {
+        activeTui.updateReconnectionFailed(retryCnt);
+      } else {
+        printer_default.stopSpinnerFail(`Reconnection failed after ${retryCnt} attempts`);
+        process.exit(1);
+      }
+    });
     manager2.registerDisconnectListener(tunnel.tunnelid, async (tunnelId, error, messages) => {
       if (activeTui) {
         disconnectState = {
@@ -3710,7 +2171,7 @@ async function startCli(finalConfig, manager) {
 }
 
 // src/main.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { argv } from "process";
 import { realpathSync } from "fs";
 async function main() {
@@ -3748,7 +2209,7 @@ async function main() {
     printer_default.error(error);
   }
 }
-var currentFile = fileURLToPath2(import.meta.url);
+var currentFile = fileURLToPath(import.meta.url);
 var entryFile = null;
 try {
   entryFile = argv[1] ? realpathSync(argv[1]) : null;