pinggy 0.3.4 → 0.3.6

package/dist/chunk-65R2GMKQ.js

@@ -0,0 +1,2101 @@
+import {
+  logger
+} from "./chunk-HUN2MRZO.js";
+
+// src/utils/printer.ts
+import pico2 from "picocolors";
+
+// src/tui/spinner/spinner.ts
+import pico from "picocolors";
+var spinners = {
+  dots: {
+    interval: 80,
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+  }
+};
+var currentTimer = null;
+var currentText = "";
+function startSpinner(name = "dots", text = "Loading") {
+  const spinner = spinners[name];
+  let i = 0;
+  currentText = text;
+  if (currentTimer) {
+    clearInterval(currentTimer);
+  }
+  currentTimer = setInterval(() => {
+    const frame = spinner.frames[i = ++i % spinner.frames.length];
+    process.stdout.write(`\r${pico.cyan(frame)} ${text}`);
+  }, spinner.interval);
+  return () => stopSpinner();
+}
+function stopSpinner() {
+  if (currentTimer) {
+    clearInterval(currentTimer);
+    currentTimer = null;
+    process.stdout.write("\r\x1B[K");
+  }
+}
+function stopSpinnerSuccess(message) {
+  if (currentTimer) {
+    clearInterval(currentTimer);
+    currentTimer = null;
+    const finalMessage = message || currentText;
+    process.stdout.write(`\r${pico.green("\u2714")} ${finalMessage}
+`);
+  }
+}
+function stopSpinnerFail(message) {
+  if (currentTimer) {
+    clearInterval(currentTimer);
+    currentTimer = null;
+    const finalMessage = message || currentText;
+    process.stdout.write(`\r${pico.red("\u2716")} ${finalMessage}
+`);
+  }
+}
+
+// src/utils/printer.ts
+var _CLIPrinter = class _CLIPrinter {
+  static isCLIError(err) {
+    return err instanceof Error;
+  }
+  static print(message, ...args) {
+    console.log(message, ...args);
+  }
+  static error(err) {
+    const def = this.errorDefinitions.find((d) => d.match(err));
+    const msg = def.message(err);
+    console.error(pico2.red(pico2.bold("\u2716 Error:")), pico2.red(msg));
+    process.exit(1);
+  }
+  static warn(message) {
+    console.warn(pico2.yellow(pico2.bold("\u26A0 Warning:")), pico2.yellow(message));
+  }
+  static warnTxt(message) {
+    console.warn(pico2.yellow(pico2.bold("\u26A0 Warning:")), pico2.yellow(message));
+  }
+  static success(message) {
+    console.log(pico2.green(pico2.bold(" \u2714 Success:")), pico2.green(message));
+  }
+  static async info(message) {
+    console.log(pico2.blue(message));
+  }
+  static startSpinner(message) {
+    startSpinner("dots", message);
+  }
+  static stopSpinnerSuccess(message) {
+    stopSpinnerSuccess(message);
+  }
+  static stopSpinnerFail(message) {
+    stopSpinnerFail(message);
+  }
+};
+_CLIPrinter.errorDefinitions = [
+  {
+    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION",
+    message: (err) => {
+      const match = /Unknown option '(.+?)'/.exec(err.message);
+      const option = match ? match[1] : "(unknown)";
+      return `Unknown option '${option}'. Please check your command or use pinggy --h for guidance.`;
+    }
+  },
+  {
+    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_MISSING_OPTION_VALUE",
+    message: (err) => `Missing required argument for option '${err.option}'.`
+  },
+  {
+    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE",
+    message: (err) => `Invalid argument'${err.message}'.`
+  },
+  {
+    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ENOENT",
+    message: (err) => `File or directory not found: ${err.message}`
+  },
+  {
+    match: () => true,
+    // fallback
+    message: (err) => _CLIPrinter.isCLIError(err) ? err.message : String(err)
+  }
+];
+var CLIPrinter = _CLIPrinter;
+var printer_default = CLIPrinter;
+
+// 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
+import { pinggy } from "@pinggy/pinggy";
+import path from "path";
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+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();
+    this.tunnelWillReconnectListeners = /* @__PURE__ */ new Map();
+    this.tunnelReconnectingListeners = /* @__PURE__ */ new Map();
+    this.tunnelReconnectionCompletedListeners = /* @__PURE__ */ new Map();
+    this.tunnelReconnectionFailedListeners = /* @__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.setupWillReconnectCallback(params.tunnelid, managed);
+    this.setupReconnectingCallback(params.tunnelid, managed);
+    this.setupReconnectionCompletedCallback(params.tunnelid, managed);
+    this.setupReconnectionFailedCallback(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);
+      this.tunnelWillReconnectListeners.delete(tunnelId);
+      this.tunnelReconnectingListeners.delete(tunnelId);
+      this.tunnelReconnectionCompletedListeners.delete(tunnelId);
+      this.tunnelReconnectionFailedListeners.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.tunnelWillReconnectListeners.delete(managed.tunnelid);
+      this.tunnelReconnectingListeners.delete(managed.tunnelid);
+      this.tunnelReconnectionCompletedListeners.delete(managed.tunnelid);
+      this.tunnelReconnectionFailedListeners.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);
+      this.tunnelWillReconnectListeners.delete(tunnelid);
+      this.tunnelReconnectingListeners.delete(tunnelid);
+      this.tunnelReconnectionCompletedListeners.delete(tunnelid);
+      this.tunnelReconnectionFailedListeners.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;
+  }
+  async registerWillReconnectListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelWillReconnectListeners.has(tunnelId)) {
+      this.tunnelWillReconnectListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelWillReconnectListeners.get(tunnelId).set(listenerId, listener);
+    logger.info("WillReconnect listener registered for tunnel", { tunnelId, listenerId });
+    return listenerId;
+  }
+  async registerReconnectingListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelReconnectingListeners.has(tunnelId)) {
+      this.tunnelReconnectingListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelReconnectingListeners.get(tunnelId).set(listenerId, listener);
+    logger.info("Reconnecting listener registered for tunnel", { tunnelId, listenerId });
+    return listenerId;
+  }
+  async registerReconnectionCompletedListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelReconnectionCompletedListeners.has(tunnelId)) {
+      this.tunnelReconnectionCompletedListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelReconnectionCompletedListeners.get(tunnelId).set(listenerId, listener);
+    logger.info("ReconnectionCompleted listener registered for tunnel", { tunnelId, listenerId });
+    return listenerId;
+  }
+  async registerReconnectionFailedListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelReconnectionFailedListeners.has(tunnelId)) {
+      this.tunnelReconnectionFailedListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelReconnectionFailedListeners.get(tunnelId).set(listenerId, listener);
+    logger.info("ReconnectionFailed 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 });
+    }
+  }
+  deregisterWillReconnectListener(tunnelId, listenerId) {
+    const listeners = this.tunnelWillReconnectListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No will-reconnect listeners found for tunnel", { tunnelId });
+      return;
+    }
+    ;
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("WillReconnect listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelWillReconnectListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent will-reconnect listener", { tunnelId, listenerId });
+    }
+  }
+  deregisterReconnectingListener(tunnelId, listenerId) {
+    const listeners = this.tunnelReconnectingListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No reconnecting listeners found for tunnel", { tunnelId });
+      return;
+    }
+    ;
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("Reconnecting listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelReconnectingListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent reconnecting listener", { tunnelId, listenerId });
+    }
+  }
+  deregisterReconnectionCompletedListener(tunnelId, listenerId) {
+    const listeners = this.tunnelReconnectionCompletedListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No reconnection completed listeners found for tunnel", { tunnelId });
+      return;
+    }
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("Reconnection completed listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelReconnectionCompletedListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent reconnection completed listener", { tunnelId, listenerId });
+    }
+  }
+  deregisterReconnectionFailedListener(tunnelId, listenerId) {
+    const listeners = this.tunnelReconnectionFailedListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No reconnection failed listeners found for tunnel", { tunnelId });
+      return;
+    }
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("Reconnection failed listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelReconnectionFailedListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent reconnection failed 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();
+          }
+          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 });
+    }
+  }
+  /**
+   * Called when the tunnel disconnects and the SDK is about to start reconnecting.
+   * Notifies registered will-reconnect listeners.
+   */
+  setupWillReconnectCallback(tunnelId, managed) {
+    try {
+      const callback = ({ error, messages }) => {
+        try {
+          logger.info("Tunnel will reconnect", { tunnelId, error, messages });
+          const listeners = this.tunnelWillReconnectListeners.get(tunnelId);
+          if (!listeners) return;
+          for (const [id, listener] of listeners) {
+            try {
+              listener(tunnelId, error, messages);
+            } catch (err) {
+              logger.debug("Error in will-reconnect-listener callback", { listenerId: id, tunnelId, err });
+            }
+          }
+        } catch (e) {
+          logger.warn("Error handling will-reconnect callback", { tunnelId, e });
+        }
+      };
+      managed.instance.setWillReconnectCallback(callback);
+      logger.debug("WillReconnect callback set up for tunnel", { tunnelId });
+    } catch (error) {
+      logger.warn("Failed to set up will-reconnect callback", { tunnelId, error });
+    }
+  }
+  /**
+   * Called for each reconnection attempt with the current retry count.
+   * Notifies registered reconnecting listeners.
+   */
+  setupReconnectingCallback(tunnelId, managed) {
+    try {
+      const callback = ({ retryCnt }) => {
+        try {
+          logger.info("Tunnel reconnecting", { tunnelId, retryCnt });
+          const listeners = this.tunnelReconnectingListeners.get(tunnelId);
+          if (!listeners) return;
+          for (const [id, listener] of listeners) {
+            try {
+              listener(tunnelId, retryCnt);
+            } catch (err) {
+              logger.debug("Error in reconnecting-listener callback", { listenerId: id, tunnelId, err });
+            }
+          }
+        } catch (e) {
+          logger.warn("Error handling reconnecting callback", { tunnelId, e });
+        }
+      };
+      managed.instance.setReconnectingCallback(callback);
+      logger.debug("Reconnecting callback set up for tunnel", { tunnelId });
+    } catch (error) {
+      logger.warn("Failed to set up reconnecting callback", { tunnelId, error });
+    }
+  }
+  /**
+   * Called when reconnection succeeds. Updates tunnel state back to active,
+   * and notifies registered reconnection-completed and start listeners with new URLs.
+   */
+  setupReconnectionCompletedCallback(tunnelId, managed) {
+    try {
+      const callback = ({ urls }) => {
+        try {
+          logger.info("Tunnel reconnection completed", { tunnelId, urls });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.isStopped = false;
+            managedTunnel.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            managedTunnel.stoppedAt = null;
+          }
+          const listeners = this.tunnelReconnectionCompletedListeners.get(tunnelId);
+          if (listeners) {
+            for (const [id, listener] of listeners) {
+              try {
+                listener(tunnelId, urls);
+              } catch (err) {
+                logger.debug("Error in reconnection-completed-listener callback", { listenerId: id, tunnelId, err });
+              }
+            }
+          }
+          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 on reconnection", { listenerId: id, tunnelId, err });
+              }
+            }
+          }
+        } catch (e) {
+          logger.warn("Error handling reconnection-completed callback", { tunnelId, e });
+        }
+      };
+      managed.instance.setReconnectionCompletedCallback(callback);
+      logger.debug("ReconnectionCompleted callback set up for tunnel", { tunnelId });
+    } catch (error) {
+      logger.warn("Failed to set up reconnection-completed callback", { tunnelId, error });
+    }
+  }
+  /**
+   * Called when all reconnection attempts are exhausted.
+   * Marks the tunnel as stopped and notifies registered reconnection-failed listeners.
+   */
+  setupReconnectionFailedCallback(tunnelId, managed) {
+    try {
+      const callback = ({ retryCnt }) => {
+        try {
+          logger.error("Tunnel reconnection failed", { tunnelId, retryCnt });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.isStopped = true;
+            managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          const listeners = this.tunnelReconnectionFailedListeners.get(tunnelId);
+          if (!listeners) return;
+          for (const [id, listener] of listeners) {
+            try {
+              listener(tunnelId, retryCnt);
+            } catch (err) {
+              logger.debug("Error in reconnection-failed-listener callback", { listenerId: id, tunnelId, err });
+            }
+          }
+        } catch (e) {
+          logger.warn("Error handling reconnection-failed callback", { tunnelId, e });
+        }
+      };
+      managed.instance.setReconnectionFailedCallback(callback);
+      logger.debug("ReconnectionFailed callback set up for tunnel", { tunnelId });
+    } catch (error) {
+      logger.warn("Failed to set up reconnection-failed 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/types.ts
+var TunnelStateType = /* @__PURE__ */ ((TunnelStateType2) => {
+  TunnelStateType2["New"] = "idle";
+  TunnelStateType2["Starting"] = "starting";
+  TunnelStateType2["Running"] = "running";
+  TunnelStateType2["Live"] = "live";
+  TunnelStateType2["Closed"] = "closed";
+  TunnelStateType2["Exited"] = "exited";
+  return TunnelStateType2;
+})(TunnelStateType || {});
+var TunnelErrorCodeType = /* @__PURE__ */ ((TunnelErrorCodeType2) => {
+  TunnelErrorCodeType2["NonResponsive"] = "non_responsive";
+  TunnelErrorCodeType2["FailedToConnect"] = "failed_to_connect";
+  TunnelErrorCodeType2["ErrorInAdditionalForwarding"] = "additional_forwarding_error";
+  TunnelErrorCodeType2["WebdebuggerError"] = "webdebugger_error";
+  TunnelErrorCodeType2["NoError"] = "";
+  return TunnelErrorCodeType2;
+})(TunnelErrorCodeType || {});
+var TunnelWarningCode = /* @__PURE__ */ ((TunnelWarningCode2) => {
+  TunnelWarningCode2["InvalidTunnelServePath"] = "INVALID_TUNNEL_SERVE_PATH";
+  TunnelWarningCode2["UnknownWarning"] = "UNKNOWN_WARNING";
+  return TunnelWarningCode2;
+})(TunnelWarningCode || {});
+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 TunnelType2 } 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([
+    TunnelType2.Http,
+    TunnelType2.Tcp,
+    TunnelType2.Udp,
+    TunnelType2.Tls,
+    TunnelType2.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) ?? TunnelType2.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 TunnelType3 } 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] : [TunnelType3.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] : [TunnelType3.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/remoteManagement.ts
+import WebSocket from "ws";
+
+// 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 || ""
+  };
+}
+
+export {
+  printer_default,
+  getRandomId,
+  isValidPort,
+  getVersion,
+  TunnelManager,
+  TunnelStateType,
+  TunnelErrorCodeType,
+  TunnelWarningCode,
+  TunnelOperations,
+  parseRemoteManagement,
+  initiateRemoteManagement,
+  closeRemoteManagement,
+  getRemoteManagementState
+};