pinggy 0.4.8 → 0.5.0

package/dist/chunk-DLNUDW6G.js

@@ -0,0 +1,1690 @@
+import {
+  FileServerMessage
+} from "./chunk-UB26QJ4T.js";
+import {
+  getLogLevel,
+  logger
+} from "./chunk-7G6SJEEA.js";
+import {
+  getTunnelLogPath
+} from "./chunk-GBYF2H4H.js";
+
+// src/tunnel_manager/TunnelManager.ts
+import { TunnelInstance, LogLevel as SdkLogLevel } from "@pinggy/pinggy";
+
+// src/logger/tunnelLogger.ts
+import winston from "winston";
+import fs from "fs";
+import path from "path";
+var tunnelTransports = /* @__PURE__ */ new Map();
+var tunnelLoggingEnabled = true;
+function setTunnelLoggingEnabled(enabled) {
+  if (tunnelLoggingEnabled === enabled) return;
+  tunnelLoggingEnabled = enabled;
+  if (!enabled) {
+    detachAllTunnelLoggers();
+  }
+}
+function isTunnelLoggingEnabled() {
+  return tunnelLoggingEnabled;
+}
+function attachTunnelLogger(tunnelId, origin, name) {
+  if (!tunnelLoggingEnabled) {
+    return logger.child({ tunnelId, source: "daemon" });
+  }
+  const logPath = getTunnelLogPath(tunnelId, origin, name);
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  const tunnelFilter = winston.format((info) => {
+    return info.tunnelId === tunnelId ? info : false;
+  });
+  const transport = new winston.transports.File({
+    filename: logPath,
+    format: winston.format.combine(
+      tunnelFilter(),
+      winston.format.timestamp(),
+      winston.format.printf(({ level, message, timestamp, source, ...meta }) => {
+        const srcLabel = source ? `[${source}] ` : "";
+        const { tunnelId: _tid, ...rest } = meta;
+        return `${timestamp} [${level}] ${srcLabel}${message}${Object.keys(rest).length ? " " + JSON.stringify(rest) : ""}`;
+      })
+    )
+  });
+  logger.add(transport);
+  tunnelTransports.set(tunnelId, transport);
+  return logger.child({ tunnelId, source: "daemon" });
+}
+function detachTunnelLogger(tunnelId) {
+  const transport = tunnelTransports.get(tunnelId);
+  if (!transport) return;
+  logger.remove(transport);
+  tunnelTransports.delete(tunnelId);
+  transport.close?.();
+}
+function detachAllTunnelLoggers() {
+  for (const tunnelId of tunnelTransports.keys()) {
+    detachTunnelLogger(tunnelId);
+  }
+}
+
+// src/logger/rotateLog.ts
+import fs2 from "fs";
+var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+var DEFAULT_MAX_ARCHIVES = 3;
+var ROTATE_TRIGGER_RATIO = 0.8;
+function maybeRotate(file, maxBytes = DEFAULT_MAX_BYTES, maxArchives = DEFAULT_MAX_ARCHIVES) {
+  let size;
+  try {
+    size = fs2.statSync(file).size;
+  } catch {
+    return;
+  }
+  if (size < maxBytes * ROTATE_TRIGGER_RATIO) return;
+  const archive = (n) => `${file}.${n}`;
+  try {
+    if (fs2.existsSync(archive(maxArchives))) {
+      fs2.unlinkSync(archive(maxArchives));
+    }
+    for (let n = maxArchives - 1; n >= 1; n--) {
+      if (fs2.existsSync(archive(n))) {
+        fs2.renameSync(archive(n), archive(n + 1));
+      }
+    }
+    fs2.renameSync(file, archive(1));
+  } catch {
+  }
+}
+
+// src/tunnel_manager/TunnelManager.ts
+import path2 from "path";
+import { Worker } from "worker_threads";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// 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 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;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+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 "";
+  }
+}
+function getLocalAddress(config) {
+  if (!config) return "-";
+  if (config.forwarding) {
+    if (typeof config.forwarding === "string") return config.forwarding;
+    if (Array.isArray(config.forwarding) && config.forwarding.length > 0) {
+      const f = config.forwarding[0];
+      if (f.address) return f.address;
+      if (f.localDomain && f.localPort) return `${f.localDomain}:${f.localPort}`;
+    }
+  }
+  if (config.localAddress) return config.localAddress;
+  return "-";
+}
+
+// src/tunnel_manager/TunnelManager.ts
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = path2.dirname(__filename3);
+function mapToSdkLogLevel(level) {
+  if (level === "debug") return SdkLogLevel.DEBUG;
+  if (level === "error") return SdkLogLevel.ERROR;
+  return SdkLogLevel.INFO;
+}
+var STATS_HISTORY_LIMIT = 100;
+var TunnelAlreadyRunningError = class extends Error {
+  constructor(configId, existingTunnelId) {
+    super(`Tunnel with configId "${configId}" is already running (tunnelid: ${existingTunnelId})`);
+    this.configId = configId;
+    this.existingTunnelId = existingTunnelId;
+    this.name = "TunnelAlreadyRunningError";
+  }
+};
+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.tunnelStoppedListeners = /* @__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, origin = "cli") {
+    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");
+    }
+    const existing = this.tunnelsByConfigId.get(configId);
+    if (existing && !existing.isStopped) {
+      throw new TunnelAlreadyRunningError(configId, existing.tunnelid);
+    }
+    return this._createTunnelWithProcessedConfig({
+      configId,
+      tunnelid,
+      tunnelName: tunnelName || name,
+      origin,
+      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) {
+    const tunnelLogName = params.tunnelName || params.originalConfig?.name;
+    const tunnelLogPath = getTunnelLogPath(params.tunnelid, params.origin, tunnelLogName);
+    maybeRotate(tunnelLogPath);
+    attachTunnelLogger(params.tunnelid, params.origin, tunnelLogName);
+    let instance;
+    try {
+      logger.debug("Creating tunnel instance with processed config", params.originalConfig);
+      instance = await TunnelInstance.create(params.originalConfig, {
+        enabled: true,
+        logLevel: mapToSdkLogLevel(getLogLevel()),
+        logFilePath: tunnelLogPath,
+        libpinggyLogPath: tunnelLogPath
+      });
+    } catch (e) {
+      logger.error("Error creating tunnel instance:", e);
+      detachTunnelLogger(params.tunnelid);
+      throw e;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const managed = {
+      tunnelid: params.tunnelid,
+      configId: params.configId,
+      tunnelName: params.tunnelName,
+      origin: params.origin,
+      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 });
+    managed.isStopping = true;
+    try {
+      void managed.instance.stop();
+      if (managed.serveWorker) {
+        logger.info("terminating serveWorker");
+        void 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();
+      detachTunnelLogger(tunnelId);
+      this.notifyStoppedListeners(tunnelId);
+      logger.info("Tunnel stopped", { tunnelId, configId: managed.configId });
+      return { configId: managed.configId, tunnelid: managed.tunnelid };
+    } catch (error) {
+      managed.isStopping = false;
+      logger.error("Failed to stop tunnel", { tunnelId, error });
+      throw error;
+    }
+  }
+  notifyStoppedListeners(tunnelId) {
+    const listeners = this.tunnelStoppedListeners.get(tunnelId);
+    if (!listeners) return;
+    for (const [id, listener] of listeners) {
+      try {
+        listener(tunnelId);
+      } catch (err) {
+        logger.debug("Error in stopped-listener callback", { listenerId: id, tunnelId, err });
+      }
+    }
+    this.tunnelStoppedListeners.delete(tunnelId);
+  }
+  /**
+   * Get all public URLs for a tunnel
+   */
+  async getTunnelUrls(tunnelId) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
+      return [];
+    }
+    if (managed.isStopped) {
+      logger.debug(`Skipping URL fetch for stopped tunnel`, { tunnelId });
+      return [];
+    }
+    const urls = await managed.instance.urls();
+    return urls;
+  }
+  /**
+   * 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 [];
+    }
+  }
+  /**
+   * Re-apply the given log level to every live tunnel's worker JS logger.
+   * Native libpinggy level is fixed at worker init and cannot be re-pathed
+   * or re-levelled at runtime without restarting the tunnel.
+   */
+  applyLogLevelToActiveTunnels(level) {
+    const sdkLevel = mapToSdkLogLevel(level);
+    for (const tunnel of this.tunnelsByTunnelId.values()) {
+      if (tunnel.isStopped) continue;
+      if (tunnel.lastError?.isFatal) continue;
+      const logPath = getTunnelLogPath(tunnel.tunnelid, tunnel.origin, tunnel.tunnelName || tunnel.tunnelConfig?.name);
+      tunnel.instance.setDebugLogging(true, sdkLevel, logPath).catch((err) => {
+        logger.error("Failed to apply log level to tunnel", { tunnelId: tunnel.tunnelid, error: err?.message ?? err });
+      });
+    }
+  }
+  /**
+   * Tunnel IDs whose ManagedTunnel is currently alive (not stopped, no fatal error).
+   * Cheap, synchronous, suitable for hot paths like /logs/paths.
+   */
+  getActiveTunnelIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const tunnel of this.tunnelsByTunnelId.values()) {
+      if (tunnel.isStopped) continue;
+      if (tunnel.lastError?.isFatal) continue;
+      ids.add(tunnel.tunnelid);
+    }
+    return ids;
+  }
+  /**
+   * 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 managed of this.tunnelsByTunnelId.values()) {
+      if (managed.isStopped) continue;
+      try {
+        void managed.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
+   */
+  getTunnelConfig(configId, tunnelId) {
+    if (configId) {
+      const managed = this.tunnelsByConfigId.get(configId);
+      if (!managed) {
+        return Promise.reject(new Error(`Tunnel with configId "${configId}" not found`));
+      }
+      return Promise.resolve(managed.instance.getConfig());
+    }
+    if (tunnelId) {
+      const managed = this.tunnelsByTunnelId.get(tunnelId);
+      if (!managed) {
+        return Promise.reject(new Error(`Tunnel with tunnelId "${tunnelId}" not found`));
+      }
+      return Promise.resolve(managed.instance.getConfig());
+    }
+    return Promise.reject(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;
+      const currentOrigin = existingTunnel.origin;
+      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,
+        origin: currentOrigin,
+        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 currentOrigin = existingTunnel.origin;
+    const requestedServe = this.resolveServePath(newConfig);
+    try {
+      if (!isStopped) {
+        void 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,
+        origin: currentOrigin,
+        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: errorMessage(error)
+      });
+      try {
+        const originalTunnel = await this._createTunnelWithProcessedConfig({
+          configId: currentTunnelConfigId,
+          tunnelid: currentTunnelId,
+          tunnelName: currentTunnelName,
+          origin: currentOrigin,
+          originalConfig: currentTunnelConfig,
+          serve: currentServe,
+          autoReconnect: currentAutoReconnect
+        });
+        if (!isStopped) {
+          await this.startTunnel(originalTunnel.tunnelid);
+        }
+        logger.warn("Restored original tunnel configuration after update failure", {
+          currentTunnelId,
+          error: errorMessage(error)
+        });
+      } catch (restoreError) {
+        logger.error("Failed to restore original tunnel configuration", {
+          currentTunnelId,
+          error: errorMessage(restoreError)
+        });
+      }
+      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
+   */
+  registerStatsListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve([listenerId, tunnelId]);
+  }
+  registerErrorListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerPollingErrorListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerDisconnectListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerWorkerErrorListner(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 });
+    return Promise.resolve(listenerId);
+  }
+  deregisterWorkerErrorListener(tunnelId, listenerId) {
+    const listeners = this.tunnelWorkerErrorListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No worker error listeners found for tunnel", { tunnelId });
+      return;
+    }
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("Worker error listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelWorkerErrorListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent worker error listener", { tunnelId, listenerId });
+    }
+  }
+  registerStartListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerWillReconnectListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerReconnectingListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerReconnectionCompletedListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(listenerId);
+  }
+  registerReconnectionFailedListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(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 Promise.resolve(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 });
+    }
+  }
+  registerStoppedListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return Promise.reject(new Error(`Tunnel "${tunnelId}" not found`));
+    }
+    if (!this.tunnelStoppedListeners.has(tunnelId)) {
+      this.tunnelStoppedListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelStoppedListeners.get(tunnelId).set(listenerId, listener);
+    return Promise.resolve(listenerId);
+  }
+  deregisterStoppedListener(tunnelId, listenerId) {
+    const listeners = this.tunnelStoppedListeners.get(tunnelId);
+    if (!listeners) return;
+    listeners.delete(listenerId);
+    if (listeners.size === 0) {
+      this.tunnelStoppedListeners.delete(tunnelId);
+    }
+  }
+  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 errorMessage2 = error instanceof Error ? error.message : String(error);
+          logger.info("Tunnel reported polling error", { tunnelId, errorMessage: errorMessage2 });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.lastError = {
+              message: errorMessage2,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isFatal: true
+            };
+          }
+          this.notifyPollingErrorListeners(tunnelId, errorMessage2);
+        } 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();
+          }
+          if (managedTunnel?.isStopping) {
+            return;
+          }
+          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.length >= STATS_HISTORY_LIMIT ? [...existingStats.slice(existingStats.length - STATS_HISTORY_LIMIT + 1), normalizedStats] : [...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 = path2.dirname(__filename4);
+      const fileServerWorkerPath = path2.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 FileServerMessage.Started:
+            logger.info("Static file server started", { dir: managed.serve, port: msg.portNum });
+            break;
+          case FileServerMessage.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 FileServerMessage.Error:
+            managed.warnings = managed.warnings ?? [];
+            managed.warnings.push({
+              code: "UNKNOWN_WARNING",
+              message: msg.error
+            });
+            break;
+        }
+      });
+      managed.serveWorker = staticServerWorker;
+    } catch (error) {
+      logger.error("Error starting static file server", error);
+    }
+  }
+};
+
+export {
+  printer_default,
+  setTunnelLoggingEnabled,
+  isTunnelLoggingEnabled,
+  detachAllTunnelLoggers,
+  getRandomId,
+  isValidPort,
+  errorMessage,
+  getVersion,
+  getLocalAddress,
+  TunnelAlreadyRunningError,
+  TunnelManager
+};