pinggy 0.4.9 → 0.5.0

package/dist/chunk-YFTL44B3.js

@@ -1,2857 +0,0 @@
-import {
-  logger
-} from "./chunk-3RTRUYNW.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));
-  }
-  static fatal(err) {
-    const def = this.errorDefinitions.find((d) => d.match(err));
-    const msg = def.message(err);
-    console.error(pico2.red(pico2.bold("\u2716 Fatal Error:")), pico2.red(msg));
-    process.exit(1);
-  }
-  static red(message) {
-    return pico2.red(message);
-  }
-  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 { readFileSync } from "fs";
-import { randomUUID } from "crypto";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-function getRandomId() {
-  return randomUUID();
-}
-function isValidPort(p) {
-  return Number.isInteger(p) && p > 0 && p < 65536;
-}
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
-function getVersion() {
-  try {
-    const packageJsonPath = join(__dirname2, "../package.json");
-    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    return pkg.version ?? "";
-  } catch (error) {
-    printer_default.error("Error reading version info");
-    return "";
-  }
-}
-
-// src/tunnel_manager/TunnelManager.ts
-import { pinggy } from "@pinggy/pinggy";
-import path from "path";
-import { Worker } from "worker_threads";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = path.dirname(__filename3);
-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.tunnelPollingErrorListeners = /* @__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.
-   * Optionally builds the config with forwarding rules based on buildConfig flag.
-   * 
-   * @param config - The tunnel configuration options
-   * 
-   * @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, tunnelid: requestedTunnelId, tunnelName, name } = config;
-    const tunnelid = requestedTunnelId || getRandomId();
-    const autoReconnect = config.autoReconnect || false;
-    const serve = this.resolveServePath(config);
-    if (!configId || typeof configId !== "string" || configId.trim() === "") {
-      throw new Error("configId is required and must be a non-empty string");
-    }
-    return this._createTunnelWithProcessedConfig({
-      configId,
-      tunnelid,
-      tunnelName: tunnelName || name,
-      originalConfig: config,
-      serve,
-      autoReconnect
-    });
-  }
-  /**
-   * 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 {
-      logger.debug("Creating tunnel instance with processed config", params.originalConfig);
-      instance = await pinggy.createTunnel(params.originalConfig);
-    } 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,
-      serve: params.serve,
-      warnings: [],
-      isStopped: false,
-      createdAt: now,
-      startedAt: null,
-      stoppedAt: null,
-      autoReconnect: params.autoReconnect,
-      lastError: {}
-    };
-    instance.setTunnelEstablishedCallback(({}) => {
-      managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    });
-    this.setupStatsCallback(params.tunnelid, managed);
-    this.setupErrorCallback(params.tunnelid, managed);
-    this.setupTunnelPollingErrorCallback(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;
-  }
-  /**
-   * 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.warn("Failed to start tunnel", { tunnelId, error });
-      managed.isStopped = true;
-      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-      managed.lastError = {
-        message: "Failed to start tunnel",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        isFatal: true
-      };
-      throw error;
-    }
-    logger.info("Tunnel started", { tunnelId, urls });
-    logger.info("Checking serve config for tunnel", { tunnelId, serve: managed.serve });
-    if (managed.serve) {
-      this.startStaticFileServer(managed);
-    } else {
-      logger.debug("No serve path configured, skipping static file server", { tunnelId });
-    }
-    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.tunnelPollingErrorListeners.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();
-      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 || tunnel.lastError?.isFatal ? [] : await this.getTunnelUrls(tunnel.tunnelid),
-          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();
-    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();
-    this.tunnelErrorListeners.clear();
-    this.tunnelPollingErrorListeners.clear();
-    this.tunnelDisconnectListeners.clear();
-    this.tunnelWorkerErrorListeners.clear();
-    this.tunnelStartListeners.clear();
-    this.tunnelWillReconnectListeners.clear();
-    this.tunnelReconnectingListeners.clear();
-    this.tunnelReconnectionCompletedListeners.clear();
-    this.tunnelReconnectionFailedListeners.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.tunnelPollingErrorListeners.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 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.tunnelPollingErrorListeners.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,
-        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 } = 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 currentTunnelId = existingTunnel.tunnelid;
-    const currentTunnelConfigId = existingTunnel.configId;
-    const currentTunnelName = existingTunnel.tunnelName;
-    const currentServe = existingTunnel.serve;
-    const currentAutoReconnect = existingTunnel.autoReconnect || false;
-    const requestedServe = this.resolveServePath(newConfig);
-    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: requestedServe !== void 0 ? requestedServe : currentServe
-      };
-      const effectiveServe = requestedServe !== void 0 ? requestedServe : currentServe;
-      const effectiveTunnelName = newTunnelName !== void 0 ? newTunnelName : currentTunnelName;
-      let configWithForwarding;
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configId,
-        tunnelid: currentTunnelId,
-        tunnelName: effectiveTunnelName,
-        originalConfig: mergedBaseConfig,
-        serve: effectiveServe,
-        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,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      try {
-        const originalTunnel = await this._createTunnelWithProcessedConfig({
-          configId: currentTunnelConfigId,
-          tunnelid: currentTunnelId,
-          tunnelName: currentTunnelName,
-          originalConfig: currentTunnelConfig,
-          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 registerPollingErrorListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelPollingErrorListeners.has(tunnelId)) {
-      this.tunnelPollingErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    this.tunnelPollingErrorListeners.get(tunnelId).set(listenerId, listener);
-    logger.info("Polling 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 });
-    }
-  }
-  deregisterPollingErrorListener(tunnelId, listenerId) {
-    const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No polling error listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Polling error listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelPollingErrorListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent polling 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 });
-    }
-  }
-  setupTunnelPollingErrorCallback(tunnelId, managed) {
-    try {
-      const callback = ({ error }) => {
-        try {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          logger.info("Tunnel reported polling error", { tunnelId, errorMessage });
-          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
-          if (managedTunnel) {
-            managedTunnel.lastError = {
-              message: errorMessage,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              isFatal: true
-            };
-          }
-          this.notifyPollingErrorListeners(tunnelId, errorMessage);
-        } catch (e) {
-          logger.warn("Error handling tunnel polling error callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setPollingErrorCallback(callback);
-      logger.debug("Tunnel polling error callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up tunnel polling error callback", { tunnelId, error });
-    }
-  }
-  notifyPollingErrorListeners(tunnelId, errorMsg) {
-    try {
-      const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
-      if (!listeners) {
-        return;
-      }
-      for (const [id, listener] of listeners) {
-        try {
-          listener(tunnelId, errorMsg);
-        } catch (err) {
-          logger.debug("Error in polling-error-listener callback", { listenerId: id, tunnelId, err });
-        }
-      }
-    } catch (err) {
-      logger.debug("Failed to notify polling error listeners", { tunnelId, err });
-    }
-  }
-  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 });
-          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
-          if (managedTunnel) {
-            managedTunnel.lastError = {
-              message: msg,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              isFatal: false
-            };
-          }
-          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;
-  }
-  /**
-   * Read serve path only from config.optional.serve.
-   */
-  resolveServePath(config) {
-    const optional = config.optional;
-    const servePath = optional?.serve;
-    logger.debug("resolveServePath", { servePath, hasOptional: !!optional, optionalKeys: optional ? Object.keys(optional) : [] });
-    return servePath;
-  }
-  startStaticFileServer(managed) {
-    try {
-      const __filename4 = fileURLToPath2(import.meta.url);
-      const __dirname4 = path.dirname(__filename4);
-      const fileServerWorkerPath = path.join(__dirname4, "workers", "file_serve_worker.cjs");
-      logger.info("Starting static file server worker", {
-        dir: managed.serve,
-        forwarding: JSON.stringify(managed.tunnelConfig?.forwarding),
-        workerPath: fileServerWorkerPath
-      });
-      const staticServerWorker = new Worker(fileServerWorkerPath, {
-        workerData: {
-          dir: managed.serve,
-          forwarding: managed.tunnelConfig?.forwarding
-        }
-      });
-      staticServerWorker.on("message", (msg) => {
-        switch (msg.type) {
-          case "started":
-            logger.info("Static file server started", { dir: managed.serve, port: msg.portNum });
-            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 } from "@pinggy/pinggy";
-import { z } from "zod";
-var HeaderModificationSchema = z.object({
-  key: z.string(),
-  value: z.array(z.string()).nullable().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.array(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([
-    TunnelType.Http,
-    TunnelType.Tcp,
-    TunnelType.Udp,
-    TunnelType.Tls,
-    TunnelType.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
-});
-var ForwardingEntryV2Schema = z.object({
-  listenAddress: z.string().optional(),
-  address: z.string(),
-  type: z.enum([TunnelType.Http, TunnelType.Tcp, TunnelType.Udp, TunnelType.Tls, TunnelType.TlsTcp]).optional()
-});
-var TunnelConfigV1Schema = z.object({
-  // Meta Info
-  version: z.string(),
-  name: z.string(),
-  configId: z.string(),
-  // General tunnel configurations
-  serverAddress: z.string().optional(),
-  token: z.string().optional(),
-  autoReconnect: z.boolean().optional(),
-  reconnectInterval: z.number().optional(),
-  maxReconnectAttempts: z.number().optional(),
-  force: z.boolean(),
-  keepAliveInterval: z.number().optional(),
-  webDebugger: z.string(),
-  //Forwarding
-  // Either a URL string (e.g. "https://localhost:5555") or an array of forwarding entries.
-  forwarding: z.union([
-    z.string(),
-    z.array(ForwardingEntryV2Schema)
-  ]),
-  // IP whitelist 
-  ipWhitelist: z.array(z.string()).optional(),
-  basicAuth: z.array(z.object({ username: z.string(), password: z.string() })).optional(),
-  bearerTokenAuth: z.array(z.string()).optional(),
-  headerModification: z.array(HeaderModificationSchema).optional(),
-  reverseProxy: z.boolean().optional(),
-  xForwardedFor: z.boolean().optional(),
-  httpsOnly: z.boolean().optional(),
-  originalRequestUrl: z.boolean().optional(),
-  allowPreflight: z.boolean().optional(),
-  serve: z.string().optional(),
-  optional: z.record(z.string(), z.unknown()).optional()
-});
-var StartV2Schema = z.object({
-  tunnelID: z.string().nullable().optional(),
-  tunnelConfig: TunnelConfigV1Schema
-});
-var UpdateConfigV2Schema = z.object({
-  tunnelConfig: TunnelConfigV1Schema
-});
-function pinggyOptionsToTunnelConfigV1(opts, configStoredInCli) {
-  const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
-  return {
-    version: configStoredInCli.version || "1.0",
-    name: configStoredInCli.name || "",
-    configId: configStoredInCli.configId || "",
-    serverAddress: opts.serverAddress || "a.pinggy.io:443",
-    token: opts.token || "",
-    autoReconnect: opts.autoReconnect ?? true,
-    force: opts.force ?? false,
-    webDebugger: opts.webDebugger || "",
-    forwarding: opts.forwarding ? opts.forwarding : "",
-    ipWhitelist: opts.ipWhitelist ? Array.isArray(opts.ipWhitelist) ? opts.ipWhitelist : JSON.parse(opts.ipWhitelist) : [],
-    basicAuth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : void 0,
-    bearerTokenAuth: parsedTokens.length ? parsedTokens : void 0,
-    headerModification: opts.headerModification || [],
-    reverseProxy: opts.reverseProxy ?? false,
-    xForwardedFor: !!opts.xForwardedFor,
-    httpsOnly: opts.httpsOnly ?? false,
-    originalRequestUrl: opts.originalRequestUrl ?? false,
-    allowPreflight: opts.allowPreflight ?? false,
-    optional: opts.optional || {}
-  };
-}
-function tunnelConfigToPinggyOptions(config) {
-  const forwardingData = [];
-  forwardingData.push({
-    address: `${config.forwardedhost}:${config.localport}`,
-    type: config.type || TunnelType.Http
-    // Default to HTTP for the primary forwarding entry
-  });
-  if (config.additionalForwarding && Array.isArray(config.additionalForwarding)) {
-    config.additionalForwarding.forEach((entry) => {
-      if (entry.localDomain && entry.localPort && entry.remoteDomain) {
-        const listenAddress = entry.remotePort && isValidPort(entry.remotePort) ? `${entry.remoteDomain}:${entry.remotePort}` : entry.remoteDomain;
-        forwardingData.push({
-          address: `${entry.localDomain}:${entry.localPort}`,
-          listenAddress,
-          type: TunnelType.Http
-        });
-      }
-    });
-  }
-  return {
-    token: config.token || "",
-    serverAddress: config.serveraddress || "free.pinggy.io",
-    forwarding: forwardingData,
-    webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
-    ipWhitelist: config.ipwhitelist || [],
-    basicAuth: config.basicauth ? config.basicauth : [],
-    bearerTokenAuth: 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, serve) {
-  let primaryEntry;
-  let additionalEntries = [];
-  if (Array.isArray(opts.forwarding)) {
-    primaryEntry = opts.forwarding.find((e) => !e.listenAddress) ?? opts.forwarding[0];
-    additionalEntries = opts.forwarding.filter(
-      (e) => e !== primaryEntry && Boolean(e.listenAddress)
-    );
-  }
-  const forwarding = primaryEntry ? String(primaryEntry.address) : String(opts.forwarding);
-  const [parsedForwardedHost, portStr] = forwarding.split(":");
-  const parsedLocalPort = parseInt(portStr, 10);
-  const tunnelType = primaryEntry?.type ?? TunnelType.Http;
-  const additionalForwarding = additionalEntries.map((e) => {
-    const [localDomain, localPortStr] = String(e.address).split(":");
-    const [remoteDomain, remotePortStr] = String(e.listenAddress).split(":");
-    const localPort = parseInt(localPortStr, 10);
-    const remotePort = parseInt(remotePortStr, 10);
-    return {
-      localDomain,
-      localPort: isNaN(localPort) ? 0 : localPort,
-      remoteDomain,
-      remotePort: isNaN(remotePort) ? 0 : remotePort
-    };
-  });
-  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
-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 || "";
-      }
-      if (managed?.lastError) {
-        status.lastError = managed.lastError;
-      }
-    } catch (e) {
-    }
-    return status;
-  }
-  // --- Placeholder response ---
-  buildPendingTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
-    return {
-      tunnelid,
-      remoteurls: [],
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, false, void 0, serve),
-      status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
-      stats: newStats()
-    };
-  }
-  buildPendingTunnelResponseV2(tunnelid, tunnelConfig, configFromCli, configid, tunnelName, serve) {
-    return {
-      tunnelid,
-      remoteurls: [],
-      tunnelconfig: pinggyOptionsToTunnelConfigV1(tunnelConfig, configFromCli),
-      status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
-      stats: newStats(),
-      greetmsg: ""
-    };
-  }
-  // --- Helper to construct TunnelResponse ---
-  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, 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),
-      status: this.buildStatus(tunnelid, status, "" /* NoError */),
-      stats
-    };
-  }
-  async buildTunnelResponseV2(tunnelid, tunnelConfig, configFromCli, configid, tunnelName, serve) {
-    const [status, stats, greetMsg, remoteurls] = await Promise.all([
-      this.tunnelManager.getTunnelStatus(tunnelid),
-      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
-      this.tunnelManager.getTunnelGreetMessage(tunnelid),
-      this.tunnelManager.getTunnelUrls(tunnelid)
-    ]);
-    return {
-      tunnelid,
-      remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfigV1(tunnelConfig, configFromCli),
-      status: this.buildStatus(tunnelid, status, "" /* NoError */),
-      stats,
-      greetmsg: greetMsg
-    };
-  }
-  error(code, err, fallback) {
-    return newErrorResponse({
-      code,
-      message: err instanceof Error ? err.message : fallback
-    });
-  }
-  // --- Operations ---
-  async handleStart(config, noWait = false) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const managed = await this.tunnelManager.createTunnel({
-        ...opts,
-        configId: config.configid,
-        name: config.configname,
-        optional: {
-          serve: config.serve
-        }
-      });
-      const { tunnelid, tunnelName, serve, tunnelConfig } = managed;
-      const startPromise = this.tunnelManager.startTunnel(tunnelid);
-      if (noWait) {
-        startPromise.catch((err) => {
-          logger.error("No-wait startTunnel failed", { tunnelid, err: String(err) });
-        });
-        return this.buildPendingTunnelResponse(tunnelid, tunnelConfig, config.configid, tunnelName, serve);
-      }
-      await startPromise;
-      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      return this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
-    } catch (err) {
-      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-    }
-  }
-  async handleStartV2(config, noWait = false) {
-    try {
-      const managed = await this.tunnelManager.createTunnel(config);
-      const { tunnelid, serve, tunnelConfig } = managed;
-      await this.tunnelManager.startTunnel(tunnelid);
-      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
-    } catch (err) {
-      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-    }
-  }
-  async handleUpdateConfig(config, noWait = false) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const updateOpts = {
-        ...opts,
-        configId: config.configid,
-        name: config.configname,
-        optional: {
-          serve: config.serve
-        }
-      };
-      if (noWait) {
-        const existing = this.tunnelManager.getManagedTunnel(config.configid);
-        if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
-        this.tunnelManager.updateConfig(updateOpts).catch((err) => {
-          logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
-        });
-        return this.buildPendingTunnelResponse(existing.tunnelid, existing.tunnelConfig, config.configid, existing.tunnelName, existing.serve);
-      }
-      const tunnel = await this.tunnelManager.updateConfig(updateOpts);
-      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.serve);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-    }
-  }
-  async handleUpdateConfigV2(config, noWait = false) {
-    try {
-      if (noWait) {
-        const existing = this.tunnelManager.getManagedTunnel(config.configId);
-        console.log(existing);
-        if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
-        this.tunnelManager.updateConfig(config).catch((err) => {
-          logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
-        });
-        return this.buildPendingTunnelResponseV2(existing.tunnelid, existing.tunnelConfig, config, config.configId, existing.tunnelName, existing.serve);
-      }
-      const tunnel = await this.tunnelManager.updateConfig(config);
-      if (!tunnel.instance || !tunnel.tunnelConfig)
-        throw new Error("Invalid tunnel state after configuration update");
-      return this.buildTunnelResponseV2(tunnel.tunnelid, tunnel.tunnelConfig, config, config.configId, tunnel.tunnelName, tunnel.serve);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-    }
-  }
-  async handleListV2() {
-    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 tunnelConfguration = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
-          const tunnelConfig = pinggyOptionsToTunnelConfigV1(tunnelConfguration, t.tunnelConfig);
-          return {
-            tunnelid: t.tunnelid,
-            remoteurls: t.remoteurls,
-            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
-            stats: rawStats,
-            tunnelconfig: tunnelConfig,
-            greetmsg: greetMsg
-          };
-        })
-      );
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
-    }
-  }
-  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.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.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.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
-    }
-  }
-  async handleRestart(tunnelid, noWait = false) {
-    try {
-      if (noWait) {
-        const managed2 = this.tunnelManager.getManagedTunnel("", tunnelid);
-        if (!managed2?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-        this.tunnelManager.restartTunnel(tunnelid).catch((err) => {
-          logger.error("No-wait restartTunnel failed", { tunnelid, err: String(err) });
-        });
-        return this.buildPendingTunnelResponse(tunnelid, managed2.tunnelConfig, managed2.configId, managed2.tunnelName, managed2.serve);
-      }
-      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.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_printer.ts
-import pico3 from "picocolors";
-var PENDING_START_TIMEOUT_MS = 5 * 60 * 1e3;
-var RemoteManagementWebSocketPrinter = class {
-  constructor() {
-    this.tunnelManager = TunnelManager.getInstance();
-    this.pendingStarts = /* @__PURE__ */ new Map();
-  }
-  setTunnelHandler(tunnelHandler) {
-    this.tunnelHandler = tunnelHandler;
-  }
-  queueStart(config) {
-    this.cleanupExpiredPendingStarts();
-    const entry = {
-      configId: this.getConfigIdFromRequest(config),
-      configName: this.getConfigNameFromRequest(config),
-      queuedAt: Date.now()
-    };
-    this.latestPendingConfigId = entry.configId;
-    this.pendingStarts.set(entry.configId, entry);
-    printer_default.startSpinner("Starting tunnel with config name: " + entry.configName);
-  }
-  failQueuedStart(config, reason) {
-    const configId = this.getConfigIdFromRequest(config);
-    const pending = this.pendingStarts.get(configId);
-    const configName = pending?.configName || this.getConfigNameFromRequest(config);
-    this.pendingStarts.delete(configId);
-    if (this.latestPendingConfigId === configId) {
-      this.latestPendingConfigId = void 0;
-      printer_default.stopSpinnerFail(`Failed to start tunnel with config name: ${configName}. ${reason}`);
-    }
-  }
-  handleStartResult(config, result) {
-    this.cleanupExpiredPendingStarts();
-    const requestedConfigId = this.getConfigIdFromRequest(config);
-    if (this.latestPendingConfigId && requestedConfigId !== this.latestPendingConfigId) {
-      this.pendingStarts.delete(requestedConfigId);
-      return;
-    }
-    if (isErrorResponse(result)) {
-      this.failQueuedStart(config, result.message);
-      return;
-    }
-    const configId = this.getConfigIdFromTunnel(result);
-    const pending = this.pendingStarts.get(requestedConfigId) || {
-      configId: requestedConfigId,
-      configName: this.getConfigNameFromRequest(config),
-      queuedAt: Date.now()
-    };
-    pending.tunnelId = result.tunnelid;
-    this.pendingStarts.set(requestedConfigId, pending);
-    if (result.remoteurls.length > 0) {
-      this.completePendingStart(pending, result.remoteurls);
-    }
-  }
-  printStopRequested(tunnelId) {
-    const details = this.resolveTunnelDetails(tunnelId);
-    printer_default.startSpinner("Stopping tunnel with config name: " + details.configName);
-  }
-  handleStopResult(tunnelId, result) {
-    const details = this.resolveTunnelDetails(tunnelId, result);
-    if (isErrorResponse(result)) {
-      printer_default.stopSpinnerFail("Failed to stop tunnel with config name: " + details.configName);
-      return;
-    }
-    this.pendingStarts.delete(details.configId);
-    printer_default.stopSpinnerSuccess("Stopped tunnel with config name: " + details.configName);
-  }
-  printRestartRequested(tunnelId) {
-    const details = this.resolveTunnelDetails(tunnelId);
-    printer_default.startSpinner("Restarting tunnel with config name: " + details.configName);
-  }
-  handleRestartResult(tunnelId, result) {
-    const details = this.resolveTunnelDetails(tunnelId, result);
-    if (isErrorResponse(result)) {
-      printer_default.warn(`Failed to restart tunnel with config name: ${details.configName}. ${result.message}`);
-      printer_default.stopSpinnerFail("Failed to restart tunnel with config name: " + details.configName);
-      return;
-    }
-    printer_default.stopSpinnerSuccess("Restarted tunnel with config name: " + details.configName);
-    if (result.remoteurls?.length > 0) {
-      printer_default.info(pico3.cyanBright("Remote URLs:"));
-      (result.remoteurls ?? []).forEach(
-        (url) => printer_default.print("  " + pico3.magentaBright(url))
-      );
-    }
-  }
-  monitorList(result) {
-    this.cleanupExpiredPendingStarts();
-    if (!Array.isArray(result) || this.pendingStarts.size === 0 || !this.latestPendingConfigId) {
-      return;
-    }
-    for (const tunnel of result) {
-      const pending = this.findPendingStart(tunnel);
-      if (!pending) {
-        continue;
-      }
-      if (pending.configId !== this.latestPendingConfigId) {
-        continue;
-      }
-      pending.tunnelId = tunnel.tunnelid;
-      this.pendingStarts.set(pending.configId, pending);
-      if (tunnel.remoteurls.length > 0) {
-        this.completePendingStart(pending, tunnel.remoteurls);
-        continue;
-      }
-      if (tunnel.status.state === "exited" /* Exited */) {
-        const reason = tunnel.status.errormsg || "Tunnel exited before a public URL was assigned";
-        this.pendingStarts.delete(pending.configId);
-        this.latestPendingConfigId = void 0;
-        printer_default.stopSpinnerFail(`Tunnel start did not complete for config name: ${pending.configName}. ${reason}`);
-      }
-    }
-  }
-  completePendingStart(entry, urls) {
-    if (this.latestPendingConfigId && entry.configId !== this.latestPendingConfigId) {
-      this.pendingStarts.delete(entry.configId);
-      return;
-    }
-    this.pendingStarts.delete(entry.configId);
-    this.latestPendingConfigId = void 0;
-    printer_default.stopSpinnerSuccess(`Tunnel started with config name: ${entry.configName}.`);
-    printer_default.info(pico3.cyanBright("Remote URLs:"));
-    (urls ?? []).forEach(
-      (url) => printer_default.print("  " + pico3.magentaBright(url))
-    );
-  }
-  cleanupExpiredPendingStarts() {
-    const now = Date.now();
-    for (const [configId, entry] of this.pendingStarts.entries()) {
-      if (now - entry.queuedAt <= PENDING_START_TIMEOUT_MS) {
-        continue;
-      }
-      this.pendingStarts.delete(configId);
-      printer_default.warn(`Timed out while waiting for tunnel URL for config name: ${entry.configName}`);
-      logger.warn("Pending websocket start entry expired", { configId, tunnelId: entry.tunnelId });
-    }
-  }
-  findPendingStart(tunnel) {
-    const configId = this.getConfigIdFromTunnel(tunnel);
-    const byConfigId = this.pendingStarts.get(configId);
-    if (byConfigId) {
-      return byConfigId;
-    }
-    for (const entry of this.pendingStarts.values()) {
-      if (entry.tunnelId === tunnel.tunnelid) {
-        return entry;
-      }
-    }
-    return void 0;
-  }
-  resolveTunnelDetails(tunnelId, result) {
-    try {
-      const managed = this.tunnelManager.getManagedTunnel(void 0, tunnelId);
-      return {
-        configId: managed.configId,
-        configName: managed.tunnelName || managed.configId || tunnelId
-      };
-    } catch {
-      if (result && !isErrorResponse(result)) {
-        return {
-          configId: this.getConfigIdFromTunnel(result),
-          configName: this.getConfigNameFromTunnel(result)
-        };
-      }
-      return {
-        configId: tunnelId,
-        configName: tunnelId
-      };
-    }
-  }
-  getConfigIdFromRequest(config) {
-    return "configid" in config ? config.configid : config.configId;
-  }
-  getConfigNameFromRequest(config) {
-    return "configname" in config ? config.configname : config.name;
-  }
-  getConfigIdFromTunnel(tunnel) {
-    return "configid" in tunnel.tunnelconfig ? tunnel.tunnelconfig.configid : tunnel.tunnelconfig.configId;
-  }
-  getConfigNameFromTunnel(tunnel) {
-    return "configname" in tunnel.tunnelconfig ? tunnel.tunnelconfig.configname : tunnel.tunnelconfig.name;
-  }
-};
-var remoteManagementWebSocketPrinter = new RemoteManagementWebSocketPrinter();
-
-// src/remote_management/websocket_handlers.ts
-import z2 from "zod";
-var WebSocketCommandHandler = class {
-  constructor() {
-    this.tunnelHandler = new TunnelOperations();
-    remoteManagementWebSocketPrinter.setTunnelHandler(this.tunnelHandler);
-  }
-  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) {
-    let queuedConfig;
-    try {
-      const dc = StartSchema.parse(raw);
-      queuedConfig = dc.tunnelConfig;
-      remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-      const result = await this.tunnelHandler.handleStart(dc.tunnelConfig, true);
-      remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (queuedConfig) {
-        remoteManagementWebSocketPrinter.failQueuedStart(queuedConfig, String(e));
-      }
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for start request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleStartReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleStartV2Req(req, raw) {
-    let queuedConfig;
-    try {
-      const dc = StartV2Schema.parse(raw);
-      queuedConfig = dc.tunnelConfig;
-      remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-      const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig, true);
-      remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (queuedConfig) {
-        remoteManagementWebSocketPrinter.failQueuedStart(queuedConfig, String(e));
-      }
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for start-v2 request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleStartV2Req error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleStopReq(req, raw) {
-    try {
-      const dc = StopSchema.parse(raw);
-      remoteManagementWebSocketPrinter.printStopRequested(dc.tunnelID);
-      const result = await this.tunnelHandler.handleStop(dc.tunnelID);
-      remoteManagementWebSocketPrinter.handleStopResult(dc.tunnelID, result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for stop request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleStopReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleGetReq(req, raw) {
-    try {
-      const dc = GetSchema.parse(raw);
-      const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for get request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleGetReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleRestartReq(req, raw) {
-    try {
-      const dc = RestartSchema.parse(raw);
-      remoteManagementWebSocketPrinter.printRestartRequested(dc.tunnelID);
-      const result = await this.tunnelHandler.handleRestart(dc.tunnelID, true);
-      remoteManagementWebSocketPrinter.handleRestartResult(dc.tunnelID, result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for restart request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleRestartReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleUpdateConfigReq(req, raw) {
-    try {
-      const dc = UpdateConfigSchema.parse(raw);
-      const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig, true);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for updateconfig request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleUpdateConfigReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleUpdateConfigV2Req(req, raw) {
-    try {
-      const dc = UpdateConfigV2Schema.parse(raw);
-      const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig, true);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        printer_default.warn("Validation failed for update-config-v2 request");
-        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
-      }
-      printer_default.warn(`Error in handleUpdateConfigV2Req error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleListReq(req) {
-    try {
-      const result = await this.tunnelHandler.handleList();
-      remoteManagementWebSocketPrinter.monitorList(result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      printer_default.warn(`Error in handleListReq error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleListV2Req(req) {
-    try {
-      const result = await this.tunnelHandler.handleListV2();
-      remoteManagementWebSocketPrinter.monitorList(result);
-      return this.wrapResponse(result, req);
-    } catch (e) {
-      printer_default.warn(`Error in handleListV2Req error: ${String(e)}`);
-      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
-    }
-  }
-  async handleGetVersionReq(ws, req) {
-    try {
-      const versionResponse = {
-        cli_version: getVersion()
-      };
-      const payload = {
-        command: req.command,
-        requestid: req.requestid,
-        response: JSON.stringify(versionResponse),
-        error: false
-      };
-      ws.send(JSON.stringify(payload));
-    } catch (e) {
-      printer_default.warn(`Error in handleGetVersionReq error: ${String(e)}`);
-      this.sendError(ws, req, String(e));
-    }
-  }
-  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 "start-v2": {
-          response = await this.handleStartV2Req(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 "update-config-v2": {
-          response = await this.handleUpdateConfigV2Req(req, raw);
-          break;
-        }
-        case "list": {
-          response = await this.handleListReq(req);
-          break;
-        }
-        case "list-v2": {
-          response = await this.handleListV2Req(req);
-          break;
-        }
-        case "get-version": {
-          await this.handleGetVersionReq(ws, req);
-          return;
-        }
-        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 sendVersionResponse(ws) {
-  const versionResponse = {
-    cli_version: getVersion()
-  };
-  const payload = {
-    command: "get-version",
-    requestid: "0",
-    response: JSON.stringify(versionResponse),
-    error: false
-  };
-  ws.send(JSON.stringify(payload));
-}
-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 RemoteManagementUnauthorizedError = class extends Error {
-  constructor() {
-    super("Unauthorized. Please enter a valid token.");
-    this.name = "RemoteManagementUnauthorizedError";
-  }
-};
-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 {
-      const remoteManagementConfig = {
-        apiKey: rmToken,
-        serverUrl: buildRemoteManagementWsUrl(manageHost)
-      };
-      await initiateRemoteManagement(remoteManagementConfig);
-      return { ok: true };
-    } catch (e) {
-      logger.error("Failed to initiate remote management:", e);
-      return { ok: false, error: e };
-    }
-  }
-}
-async function initiateRemoteManagement(remoteManagementConfig) {
-  if (!remoteManagementConfig.apiKey || remoteManagementConfig.apiKey.trim().length === 0) {
-    throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
-  }
-  const wsUrl = remoteManagementConfig.serverUrl;
-  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, remoteManagementConfig.apiKey);
-    } catch (error) {
-      if (error instanceof RemoteManagementUnauthorizedError) {
-        throw 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, onOpenCallback) {
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(wsUrl, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    currentWs = ws;
-    let heartbeat = null;
-    let firstMessage = true;
-    let settled = false;
-    const cleanup = (err) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (heartbeat) {
-        clearInterval(heartbeat);
-      }
-      currentWs = null;
-      if (err) {
-        reject(err);
-      } else {
-        resolve();
-      }
-    };
-    ws.once("open", () => {
-      printer_default.success(`Connected to ${wsHost}`);
-      setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
-      onOpenCallback?.();
-      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;
-          }
-          sendVersionResponse(ws);
-          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) => {
-      if (res.statusCode === 401) {
-        setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
-        logger.error("Unauthorized (401) on remote management connect");
-        cleanup(new RemoteManagementUnauthorizedError());
-        ws.close();
-      } else {
-        logger.warn("Unexpected HTTP response ", { statusCode: res.statusCode });
-        printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
-        cleanup();
-        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 in ${RECONNECT_SLEEP_MS / 1e3}s...`);
-      cleanup();
-    });
-    ws.on("error", (err) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
-      logger.warn("WebSocket error", { error: err.message });
-      printer_default.warn(err.message);
-      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 startRemoteManagement(remoteManagementConfig) {
-  if (!remoteManagementConfig.apiKey || remoteManagementConfig.apiKey.trim().length === 0) {
-    return Promise.reject(new Error("Remote management token is required"));
-  }
-  const wsUrl = remoteManagementConfig.serverUrl;
-  const wsHost = extractHostname(wsUrl);
-  logger.info("Remote management mode enabled.");
-  _stopRequested = false;
-  return new Promise((resolve, reject) => {
-    let firstSettled = false;
-    const settleOnce = (err) => {
-      if (firstSettled) {
-        return;
-      }
-      firstSettled = true;
-      if (err) {
-        reject(err);
-      } else {
-        resolve(getRemoteManagementState());
-      }
-    };
-    const runLoop = async () => {
-      const sigintHandler = () => {
-        _stopRequested = true;
-      };
-      process.once("SIGINT", sigintHandler);
-      while (!_stopRequested) {
-        logger.info("Connecting to remote management", { wsUrl });
-        setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
-        try {
-          await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey, () => settleOnce());
-        } catch (error) {
-          if (error instanceof RemoteManagementUnauthorizedError) {
-            settleOnce(error);
-            process.removeListener("SIGINT", sigintHandler);
-            return;
-          }
-          settleOnce();
-          logger.warn("Remote management connection error", { error: String(error) });
-        }
-        if (_stopRequested) {
-          break;
-        }
-        logger.info("Reconnecting to remote management after disconnect");
-        await sleep(RECONNECT_SLEEP_MS);
-      }
-      process.removeListener("SIGINT", sigintHandler);
-      logger.info("Remote management stopped.");
-    };
-    runLoop().catch((err) => settleOnce(err instanceof Error ? err : new Error(String(err))));
-  });
-}
-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,
-  RemoteManagementUnauthorizedError,
-  buildRemoteManagementWsUrl,
-  parseRemoteManagement,
-  initiateRemoteManagement,
-  closeRemoteManagement,
-  startRemoteManagement,
-  getRemoteManagementState
-};