pinggy 0.3.3 → 0.3.4

package/dist/index.cjs

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,40 +29,155 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  TunnelManager: () => TunnelManager,
-  TunnelOperations: () => TunnelOperations,
-  closeRemoteManagement: () => closeRemoteManagement,
-  enablePackageLogging: () => enablePackageLogging,
-  getRemoteManagementState: () => getRemoteManagementState,
-  initiateRemoteManagement: () => initiateRemoteManagement
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
 });
-module.exports = __toCommonJS(index_exports);
 
-// node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+// src/tui/spinner/spinner.ts
+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${import_picocolors.default.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${import_picocolors.default.green("\u2714")} ${finalMessage}
+`);
+  }
+}
+function stopSpinnerFail(message) {
+  if (currentTimer) {
+    clearInterval(currentTimer);
+    currentTimer = null;
+    const finalMessage = message || currentText;
+    process.stdout.write(`\r${import_picocolors.default.red("\u2716")} ${finalMessage}
+`);
+  }
+}
+var import_picocolors, spinners, currentTimer, currentText;
+var init_spinner = __esm({
+  "src/tui/spinner/spinner.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_picocolors = __toESM(require("picocolors"), 1);
+    spinners = {
+      dots: {
+        interval: 80,
+        frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+      }
+    };
+    currentTimer = null;
+    currentText = "";
+  }
+});
 
-// src/tunnel_manager/TunnelManager.ts
-var import_pinggy2 = require("@pinggy/pinggy");
+// src/utils/printer.ts
+var import_picocolors2, _CLIPrinter, CLIPrinter, printer_default;
+var init_printer = __esm({
+  "src/utils/printer.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_picocolors2 = __toESM(require("picocolors"), 1);
+    init_spinner();
+    _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(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Error:")), import_picocolors2.default.red(msg));
+        process.exit(1);
+      }
+      static warn(message) {
+        console.warn(import_picocolors2.default.yellow(import_picocolors2.default.bold("\u26A0 Warning:")), import_picocolors2.default.yellow(message));
+      }
+      static warnTxt(message) {
+        console.warn(import_picocolors2.default.yellow(import_picocolors2.default.bold("\u26A0 Warning:")), import_picocolors2.default.yellow(message));
+      }
+      static success(message) {
+        console.log(import_picocolors2.default.green(import_picocolors2.default.bold(" \u2714 Success:")), import_picocolors2.default.green(message));
+      }
+      static async info(message) {
+        console.log(import_picocolors2.default.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)
+      }
+    ];
+    CLIPrinter = _CLIPrinter;
+    printer_default = CLIPrinter;
+  }
+});
 
 // src/logger.ts
-var import_winston = __toESM(require("winston"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_pinggy = require("@pinggy/pinggy");
-var _logger = null;
 function getLogger() {
   if (!_logger) {
     _logger = import_winston.default.createLogger({ level: "info", silent: true });
   }
   return _logger;
 }
-var logger = getLogger();
 function applyLoggingConfig(cfg) {
   const {
     level,
@@ -73,8 +191,8 @@ function applyLoggingConfig(cfg) {
     enableLoggingByLogLevelInSdk(level ?? "info", filePath);
   }
   if (filePath) {
-    const dir = import_path.default.dirname(filePath);
-    if (!import_fs.default.existsSync(dir)) import_fs.default.mkdirSync(dir, { recursive: true });
+    const dir = import_path2.default.dirname(filePath);
+    if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
   }
   const transports = [];
   if (stdout) {
@@ -142,1126 +260,1044 @@ function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
     import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.INFO, logFilePath);
   }
 }
-
-// src/tunnel_manager/TunnelManager.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_node_worker_threads = require("worker_threads");
-var import_node_url = require("url");
-
-// src/utils/printer.ts
-var import_picocolors2 = __toESM(require("picocolors"), 1);
-
-// src/tui/spinner/spinner.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
-var spinners = {
-  dots: {
-    interval: 80,
-    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+var import_winston, import_fs2, import_path2, import_pinggy, _logger, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_winston = __toESM(require("winston"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
+    import_pinggy = require("@pinggy/pinggy");
+    _logger = null;
+    logger = getLogger();
   }
-};
-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${import_picocolors.default.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${import_picocolors.default.green("\u2714")} ${finalMessage}
-`);
-  }
-}
-function stopSpinnerFail(message) {
-  if (currentTimer) {
-    clearInterval(currentTimer);
-    currentTimer = null;
-    const finalMessage = message || currentText;
-    process.stdout.write(`\r${import_picocolors.default.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(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Error:")), import_picocolors2.default.red(msg));
-    process.exit(1);
-  }
-  static warn(message) {
-    console.warn(import_picocolors2.default.yellow(import_picocolors2.default.bold("\u26A0 Warning:")), import_picocolors2.default.yellow(message));
-  }
-  static warnTxt(message) {
-    console.warn(import_picocolors2.default.yellow(import_picocolors2.default.bold("\u26A0 Warning:")), import_picocolors2.default.yellow(message));
-  }
-  static success(message) {
-    console.log(import_picocolors2.default.green(import_picocolors2.default.bold(" \u2714 Success:")), import_picocolors2.default.green(message));
-  }
-  static async info(message) {
-    console.log(import_picocolors2.default.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
-var import_module = require("module");
-var import_crypto = require("crypto");
 function getRandomId() {
   return (0, import_crypto.randomUUID)();
 }
 function isValidPort(p) {
   return Number.isInteger(p) && p > 0 && p < 65536;
 }
-var require2 = (0, import_module.createRequire)(importMetaUrl);
-var pkg = require2("../package.json");
 function getVersion() {
   return pkg.version ?? "";
 }
+var import_module, import_crypto, require2, pkg;
+var init_util = __esm({
+  "src/utils/util.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_module = require("module");
+    import_crypto = require("crypto");
+    require2 = (0, import_module.createRequire)(importMetaUrl);
+    pkg = require2("../package.json");
+  }
+});
 
 // src/tunnel_manager/TunnelManager.ts
-var __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
-var __dirname = import_node_path.default.dirname(__filename2);
-var TunnelManager = class _TunnelManager {
-  constructor() {
-    this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
-    this.tunnelsByConfigId = /* @__PURE__ */ new Map();
-    this.tunnelStats = /* @__PURE__ */ new Map();
-    this.tunnelStatsListeners = /* @__PURE__ */ new Map();
-    this.tunnelErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
-    this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelStartListeners = /* @__PURE__ */ new Map();
-  }
-  static getInstance() {
-    if (!_TunnelManager.instance) {
-      _TunnelManager.instance = new _TunnelManager();
-    }
-    return _TunnelManager.instance;
-  }
-  /**
-   * Creates a new managed tunnel instance with the given configuration.
-   * Builds the config with forwarding rules and creates the tunnel instance.
-   * 
-   * @param config - The tunnel configuration options
-   * @param config.configid - Unique identifier for the tunnel configuration
-   * @param config.tunnelid - Optional custom tunnel identifier. If not provided, a random UUID will be generated
-   * @param config.additionalForwarding - Optional array of additional forwarding configurations
-   * 
-   * @throws {Error} When configId is invalid or empty
-   * @throws {Error} When a tunnel with the given configId already exists
-   * 
-   * @returns {ManagedTunnel} A new managed tunnel instance containing the tunnel details,
-   *                          status information, and statistics
-   */
-  async createTunnel(config) {
-    const { configid, additionalForwarding, tunnelName } = config;
-    if (configid === void 0 || configid.trim().length === 0) {
-      throw new Error(`Invalid configId: "${configid}"`);
-    }
-    if (this.tunnelsByConfigId.has(configid)) {
-      throw new Error(`Tunnel with configId "${configid}" already exists`);
-    }
-    const tunnelid = config.tunnelid || getRandomId();
-    const configWithForwarding = this.buildPinggyConfig(config, additionalForwarding);
-    return this._createTunnelWithProcessedConfig({
-      configid,
-      tunnelid,
-      tunnelName,
-      originalConfig: config,
-      configWithForwarding,
-      additionalForwarding,
-      serve: config.serve,
-      autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
-    });
-  }
-  /**
-   * Internal method to create a tunnel with an already-processed configuration.
-   * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
-   * 
-   * @param params - Configuration parameters with already-processed forwarding rules
-   * @returns The created ManagedTunnel instance
-   * @private
-   */
-  async _createTunnelWithProcessedConfig(params) {
-    let instance;
-    try {
-      instance = await import_pinggy2.pinggy.createTunnel(params.configWithForwarding);
-    } catch (e) {
-      logger.error("Error creating tunnel instance:", e);
-      throw e;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const managed = {
-      tunnelid: params.tunnelid,
-      configid: params.configid,
-      tunnelName: params.tunnelName,
-      instance,
-      tunnelConfig: params.originalConfig,
-      configWithForwarding: params.configWithForwarding,
-      additionalForwarding: params.additionalForwarding,
-      serve: params.serve,
-      warnings: [],
-      isStopped: false,
-      createdAt: now,
-      startedAt: null,
-      stoppedAt: null,
-      autoReconnect: params.autoReconnect
-    };
-    instance.setTunnelEstablishedCallback(({}) => {
-      managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    });
-    this.setupStatsCallback(params.tunnelid, managed);
-    this.setupErrorCallback(params.tunnelid, managed);
-    this.setupDisconnectCallback(params.tunnelid, managed);
-    this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
-    this.tunnelsByTunnelId.set(params.tunnelid, managed);
-    this.tunnelsByConfigId.set(params.configid, managed);
-    logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
-    return managed;
-  }
-  /**
-   * Builds the Pinggy configuration by merging the default forwarding rule
-   * with additional forwarding rules from additionalForwarding array.
-   * 
-   * @param config - The base Pinggy configuration
-   * @param additionalForwarding - Optional array of additional forwarding rules
-   * @returns Modified PinggyOptions 
-   */
-  buildPinggyConfig(config, additionalForwarding) {
-    const forwardingRules = [];
-    if (config.forwarding) {
-      forwardingRules.push({
-        type: config.tunnelType && config.tunnelType[0] || "http",
-        address: config.forwarding
-      });
-    }
-    if (Array.isArray(additionalForwarding) && additionalForwarding.length > 0) {
-      for (const rule of additionalForwarding) {
-        if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
-          const forwardingRule = {
-            type: rule.protocol,
-            // In Future we can make this dynamic based on user input
-            address: `${rule.localDomain}:${rule.localPort}`,
-            listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain
-          };
-          forwardingRules.push(forwardingRule);
+var import_pinggy2, import_node_path, import_node_worker_threads, import_node_url, __filename2, __dirname, TunnelManager;
+var init_TunnelManager = __esm({
+  "src/tunnel_manager/TunnelManager.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_pinggy2 = require("@pinggy/pinggy");
+    init_logger();
+    import_node_path = __toESM(require("path"), 1);
+    import_node_worker_threads = require("worker_threads");
+    import_node_url = require("url");
+    init_printer();
+    init_util();
+    __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+    __dirname = import_node_path.default.dirname(__filename2);
+    TunnelManager = class _TunnelManager {
+      constructor() {
+        this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
+        this.tunnelsByConfigId = /* @__PURE__ */ new Map();
+        this.tunnelStats = /* @__PURE__ */ new Map();
+        this.tunnelStatsListeners = /* @__PURE__ */ new Map();
+        this.tunnelErrorListeners = /* @__PURE__ */ new Map();
+        this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
+        this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
+        this.tunnelStartListeners = /* @__PURE__ */ new Map();
+      }
+      static getInstance() {
+        if (!_TunnelManager.instance) {
+          _TunnelManager.instance = new _TunnelManager();
         }
+        return _TunnelManager.instance;
       }
-    }
-    return {
-      ...config,
-      forwarding: forwardingRules.length > 0 ? forwardingRules : config.forwarding
-    };
-  }
-  /**
-   * Start a tunnel that was created but not yet started
-   */
-  async startTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
-    logger.info("Starting tunnel", { tunnelId });
-    let urls;
-    try {
-      urls = await managed.instance.start();
-    } catch (error) {
-      logger.error("Failed to start tunnel", { tunnelId, error });
-      throw error;
-    }
-    logger.info("Tunnel started", { tunnelId, urls });
-    if (managed.serve) {
-      this.startStaticFileServer(managed);
-    }
-    try {
-      const startListeners = this.tunnelStartListeners.get(tunnelId);
-      if (startListeners) {
-        for (const [id, listener] of startListeners) {
-          try {
-            listener(tunnelId, urls);
-          } catch (err) {
-            logger.debug("Error in start-listener callback", { listenerId: id, tunnelId, err });
-          }
+      /**
+       * Creates a new managed tunnel instance with the given configuration.
+       * Builds the config with forwarding rules and creates the tunnel instance.
+       * 
+       * @param config - The tunnel configuration options
+       * @param config.configid - Unique identifier for the tunnel configuration
+       * @param config.tunnelid - Optional custom tunnel identifier. If not provided, a random UUID will be generated
+       * @param config.additionalForwarding - Optional array of additional forwarding configurations
+       * 
+       * @throws {Error} When configId is invalid or empty
+       * @throws {Error} When a tunnel with the given configId already exists
+       * 
+       * @returns {ManagedTunnel} A new managed tunnel instance containing the tunnel details,
+       *                          status information, and statistics
+       */
+      async createTunnel(config) {
+        const { configid, additionalForwarding, tunnelName } = config;
+        if (configid === void 0 || configid.trim().length === 0) {
+          throw new Error(`Invalid configId: "${configid}"`);
+        }
+        if (this.tunnelsByConfigId.has(configid)) {
+          throw new Error(`Tunnel with configId "${configid}" already exists`);
         }
+        const tunnelid = config.tunnelid || getRandomId();
+        const configWithForwarding = this.buildPinggyConfig(config, additionalForwarding);
+        return this._createTunnelWithProcessedConfig({
+          configid,
+          tunnelid,
+          tunnelName,
+          originalConfig: config,
+          configWithForwarding,
+          additionalForwarding,
+          serve: config.serve,
+          autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
+        });
       }
-    } catch (e) {
-      logger.warn("Failed to notify start listeners", { tunnelId, e });
-    }
-    return urls;
-  }
-  /**
-   * Stops a running tunnel and updates its status.
-   *
-   * @param tunnelId - The unique identifier of the tunnel to stop
-   * @throws {Error} If the tunnel with the given tunnelId is not found
-   * @remarks
-   * - Clears the tunnel's remote URLs
-   * - Updates the tunnel's state to Exited if stopped successfully
-   * - Logs the stop operation with tunnelId and configId
-   */
-  stopTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-    logger.info("Stopping tunnel", { tunnelId, configId: managed.configid });
-    try {
-      managed.instance.stop();
-      if (managed.serveWorker) {
-        logger.info("terminating serveWorker");
-        managed.serveWorker.terminate();
-      }
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelErrorListeners.delete(tunnelId);
-      this.tunnelDisconnectListeners.delete(tunnelId);
-      this.tunnelWorkerErrorListeners.delete(tunnelId);
-      this.tunnelStartListeners.delete(tunnelId);
-      managed.serveWorker = null;
-      managed.warnings = managed.warnings ?? [];
-      managed.isStopped = true;
-      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-      logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
-      return { configid: managed.configid, tunnelid: managed.tunnelid };
-    } catch (error) {
-      logger.error("Failed to stop tunnel", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all public URLs for a tunnel
-   */
-  async getTunnelUrls(tunnelId) {
-    try {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed || managed.isStopped) {
-        logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
-        return [];
-      }
-      const urls = await managed.instance.urls();
-      logger.debug("Queried tunnel URLs", { tunnelId, urls });
-      return urls;
-    } catch (error) {
-      logger.error("Error fetching tunnel URLs", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all TunnelStatus currently managed by this TunnelManager
-   * @returns An array of all TunnelStatus objects
-   */
-  async getAllTunnels() {
-    try {
-      const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
+      /**
+       * Internal method to create a tunnel with an already-processed configuration.
+       * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
+       * 
+       * @param params - Configuration parameters with already-processed forwarding rules
+       * @returns The created ManagedTunnel instance
+       * @private
+       */
+      async _createTunnelWithProcessedConfig(params) {
+        let instance;
+        try {
+          instance = await import_pinggy2.pinggy.createTunnel(params.configWithForwarding);
+        } catch (e) {
+          logger.error("Error creating tunnel instance:", e);
+          throw e;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const managed = {
+          tunnelid: params.tunnelid,
+          configid: params.configid,
+          tunnelName: params.tunnelName,
+          instance,
+          tunnelConfig: params.originalConfig,
+          configWithForwarding: params.configWithForwarding,
+          additionalForwarding: params.additionalForwarding,
+          serve: params.serve,
+          warnings: [],
+          isStopped: false,
+          createdAt: now,
+          startedAt: null,
+          stoppedAt: null,
+          autoReconnect: params.autoReconnect
+        };
+        instance.setTunnelEstablishedCallback(({}) => {
+          managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        });
+        this.setupStatsCallback(params.tunnelid, managed);
+        this.setupErrorCallback(params.tunnelid, managed);
+        this.setupDisconnectCallback(params.tunnelid, managed);
+        this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
+        this.tunnelsByTunnelId.set(params.tunnelid, managed);
+        this.tunnelsByConfigId.set(params.configid, managed);
+        logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
+        return managed;
+      }
+      /**
+       * Builds the Pinggy configuration by merging the default forwarding rule
+       * with additional forwarding rules from additionalForwarding array.
+       * 
+       * @param config - The base Pinggy configuration
+       * @param additionalForwarding - Optional array of additional forwarding rules
+       * @returns Modified PinggyOptions 
+       */
+      buildPinggyConfig(config, additionalForwarding) {
+        const forwardingRules = [];
+        if (config.forwarding) {
+          forwardingRules.push({
+            type: config.tunnelType && config.tunnelType[0] || "http",
+            address: config.forwarding
+          });
+        }
+        if (Array.isArray(additionalForwarding) && additionalForwarding.length > 0) {
+          for (const rule of additionalForwarding) {
+            if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
+              const forwardingRule = {
+                type: rule.protocol,
+                // In Future we can make this dynamic based on user input
+                address: `${rule.localDomain}:${rule.localPort}`,
+                listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain
+              };
+              forwardingRules.push(forwardingRule);
+            }
+          }
+        }
         return {
-          tunnelid: tunnel.tunnelid,
-          configid: tunnel.configid,
-          tunnelName: tunnel.tunnelName,
-          tunnelConfig: tunnel.tunnelConfig,
-          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
-          additionalForwarding: tunnel.additionalForwarding,
-          serve: tunnel.serve
+          ...config,
+          forwarding: forwardingRules.length > 0 ? forwardingRules : config.forwarding
         };
-      }));
-      return tunnelList;
-    } catch (err) {
-      logger.error("Error fetching tunnels", { error: err });
-      return [];
-    }
-  }
-  /**
-   * Get status of a tunnel
-   */
-  async getTunnelStatus(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (managed.isStopped) {
-      return "exited";
-    }
-    const status = await managed.instance.getStatus();
-    logger.debug("Queried tunnel status", { tunnelId, status });
-    return status;
-  }
-  /**
-   * Stop all tunnels
-   */
-  stopAllTunnels() {
-    for (const { instance } of this.tunnelsByTunnelId.values()) {
-      try {
-        instance.stop();
-      } catch (e) {
-        logger.warn("Error stopping tunnel instance", e);
       }
-    }
-    this.tunnelsByTunnelId.clear();
-    this.tunnelsByConfigId.clear();
-    this.tunnelStats.clear();
-    this.tunnelStatsListeners.clear();
-    logger.info("All tunnels stopped and cleared");
-  }
-  /**
-   * Remove a stopped tunnel's records so it will no longer be returned by list methods.
-   * 
-   *
-   * @param tunnelId - the tunnel id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByTunnelId(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel", { tunnelId });
-      return false;
-    }
-    if (!managed.isStopped) {
-      logger.warn("Attempted to remove tunnel that is not stopped", { tunnelId });
-      return false;
-    }
-    this._cleanupTunnelRecords(managed);
-    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configid });
-    return true;
-  }
-  /**
-   * Remove a stopped tunnel by its config id.
-   * @param configId - the config id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByConfigId(configId) {
-    const managed = this.tunnelsByConfigId.get(configId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel by configId", { configId });
-      return false;
-    }
-    return this.removeStoppedTunnelByTunnelId(managed.tunnelid);
-  }
-  _cleanupTunnelRecords(managed) {
-    if (!managed.isStopped) {
-      throw new Error(`Active tunnel "${managed.tunnelid}" cannot be removed`);
-    }
-    try {
-      if (managed.serveWorker) {
-        managed.serveWorker = null;
-      }
-      this.tunnelStats.delete(managed.tunnelid);
-      this.tunnelStatsListeners.delete(managed.tunnelid);
-      this.tunnelErrorListeners.delete(managed.tunnelid);
-      this.tunnelDisconnectListeners.delete(managed.tunnelid);
-      this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
-      this.tunnelStartListeners.delete(managed.tunnelid);
-      this.tunnelsByTunnelId.delete(managed.tunnelid);
-      this.tunnelsByConfigId.delete(managed.configid);
-    } catch (e) {
-      logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
-    }
-  }
-  /**
-   * Get tunnel instance by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel instance
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  getTunnelInstance(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) throw new Error(`Tunnel "${configId}" not found`);
-      return managed.instance;
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-      return managed.instance;
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Get tunnel config by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel config
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  async getTunnelConfig(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) {
-        throw new Error(`Tunnel with configId "${configId}" not found`);
-      }
-      return managed.instance.getConfig();
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) {
-        throw new Error(`Tunnel with tunnelId "${tunnelId}" not found`);
+      /**
+       * Start a tunnel that was created but not yet started
+       */
+      async startTunnel(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
+        logger.info("Starting tunnel", { tunnelId });
+        let urls;
+        try {
+          urls = await managed.instance.start();
+        } catch (error) {
+          logger.error("Failed to start tunnel", { tunnelId, error });
+          throw error;
+        }
+        logger.info("Tunnel started", { tunnelId, urls });
+        if (managed.serve) {
+          this.startStaticFileServer(managed);
+        }
+        try {
+          const startListeners = this.tunnelStartListeners.get(tunnelId);
+          if (startListeners) {
+            for (const [id, listener] of startListeners) {
+              try {
+                listener(tunnelId, urls);
+              } catch (err) {
+                logger.debug("Error in start-listener callback", { listenerId: id, tunnelId, err });
+              }
+            }
+          }
+        } catch (e) {
+          logger.warn("Failed to notify start listeners", { tunnelId, e });
+        }
+        return urls;
       }
-      return managed.instance.getConfig();
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Restarts a tunnel with its current configuration.
-   * This function will stop the tunnel if it's running and start it again.
-   * All configurations including additional forwarding rules are preserved.
-   */
-  async restartTunnel(tunnelid) {
-    const existingTunnel = this.tunnelsByTunnelId.get(tunnelid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel "${tunnelid}" not found`);
-    }
-    logger.info("Initiating tunnel restart", {
-      tunnelId: tunnelid,
-      configId: existingTunnel.configid
-    });
-    try {
-      const tunnelName = existingTunnel.tunnelName;
-      const currentConfigId = existingTunnel.configid;
-      const currentConfig = existingTunnel.tunnelConfig;
-      const configWithForwarding = existingTunnel.configWithForwarding;
-      const additionalForwarding = existingTunnel.additionalForwarding;
-      const currentServe = existingTunnel.serve;
-      const autoReconnect = existingTunnel.autoReconnect || false;
-      this.tunnelsByTunnelId.delete(tunnelid);
-      this.tunnelsByConfigId.delete(existingTunnel.configid);
-      this.tunnelStats.delete(tunnelid);
-      this.tunnelStatsListeners.delete(tunnelid);
-      this.tunnelErrorListeners.delete(tunnelid);
-      this.tunnelDisconnectListeners.delete(tunnelid);
-      this.tunnelWorkerErrorListeners.delete(tunnelid);
-      this.tunnelStartListeners.delete(tunnelid);
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid: currentConfigId,
-        tunnelid,
-        tunnelName,
-        originalConfig: currentConfig,
-        configWithForwarding,
-        additionalForwarding,
-        serve: currentServe,
-        autoReconnect
-      });
-      if (existingTunnel.createdAt) {
-        newTunnel.createdAt = existingTunnel.createdAt;
+      /**
+       * Stops a running tunnel and updates its status.
+       *
+       * @param tunnelId - The unique identifier of the tunnel to stop
+       * @throws {Error} If the tunnel with the given tunnelId is not found
+       * @remarks
+       * - Clears the tunnel's remote URLs
+       * - Updates the tunnel's state to Exited if stopped successfully
+       * - Logs the stop operation with tunnelId and configId
+       */
+      stopTunnel(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+        logger.info("Stopping tunnel", { tunnelId, configId: managed.configid });
+        try {
+          managed.instance.stop();
+          if (managed.serveWorker) {
+            logger.info("terminating serveWorker");
+            managed.serveWorker.terminate();
+          }
+          this.tunnelStats.delete(tunnelId);
+          this.tunnelStatsListeners.delete(tunnelId);
+          this.tunnelStats.delete(tunnelId);
+          this.tunnelStatsListeners.delete(tunnelId);
+          this.tunnelErrorListeners.delete(tunnelId);
+          this.tunnelDisconnectListeners.delete(tunnelId);
+          this.tunnelWorkerErrorListeners.delete(tunnelId);
+          this.tunnelStartListeners.delete(tunnelId);
+          managed.serveWorker = null;
+          managed.warnings = managed.warnings ?? [];
+          managed.isStopped = true;
+          managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
+          return { configid: managed.configid, tunnelid: managed.tunnelid };
+        } catch (error) {
+          logger.error("Failed to stop tunnel", { tunnelId, error });
+          throw error;
+        }
       }
-      await this.startTunnel(newTunnel.tunnelid);
-    } catch (error) {
-      logger.error("Failed to restart tunnel", {
-        tunnelid,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw new Error(`Failed to restart tunnel: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * Updates the configuration of an existing tunnel.
-   * 
-   * This method handles the process of updating a tunnel's configuration while preserving
-   * its state. If the tunnel is running, it will be stopped, updated, and restarted.
-   * In case of failure, it attempts to restore the original configuration.
-   * 
-   * @param newConfig - The new configuration to apply, including configid and optional additional forwarding
-   * 
-   * @returns Promise resolving to the updated ManagedTunnel
-   * @throws Error if the tunnel is not found or if the update process fails
-   */
-  async updateConfig(newConfig) {
-    const { configid, tunnelName: newTunnelName, additionalForwarding } = newConfig;
-    if (!configid || configid.trim().length === 0) {
-      throw new Error(`Invalid configid: "${configid}"`);
-    }
-    const existingTunnel = this.tunnelsByConfigId.get(configid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel with config id "${configid}" not found`);
-    }
-    const isStopped = existingTunnel.isStopped;
-    const currentTunnelConfig = existingTunnel.tunnelConfig;
-    const currentConfigWithForwarding = existingTunnel.configWithForwarding;
-    const currentTunnelId = existingTunnel.tunnelid;
-    const currentTunnelConfigId = existingTunnel.configid;
-    const currentAdditionalForwarding = existingTunnel.additionalForwarding;
-    const currentTunnelName = existingTunnel.tunnelName;
-    const currentServe = existingTunnel.serve;
-    const currentAutoReconnect = existingTunnel.autoReconnect || false;
-    try {
-      if (!isStopped) {
-        existingTunnel.instance.stop();
-      }
-      this.tunnelsByTunnelId.delete(currentTunnelId);
-      this.tunnelsByConfigId.delete(currentTunnelConfigId);
-      const mergedBaseConfig = {
-        ...newConfig,
-        configid,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
-      };
-      const newConfigWithForwarding = this.buildPinggyConfig(
-        mergedBaseConfig,
-        additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
-      );
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid,
-        tunnelid: currentTunnelId,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        originalConfig: mergedBaseConfig,
-        configWithForwarding: newConfigWithForwarding,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
-        autoReconnect: currentAutoReconnect
-      });
-      if (!isStopped) {
-        await this.startTunnel(newTunnel.tunnelid);
+      /**
+       * Get all public URLs for a tunnel
+       */
+      async getTunnelUrls(tunnelId) {
+        try {
+          const managed = this.tunnelsByTunnelId.get(tunnelId);
+          if (!managed || managed.isStopped) {
+            logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
+            return [];
+          }
+          const urls = await managed.instance.urls();
+          logger.debug("Queried tunnel URLs", { tunnelId, urls });
+          return urls;
+        } catch (error) {
+          logger.error("Error fetching tunnel URLs", { tunnelId, error });
+          throw error;
+        }
       }
-      logger.info("Tunnel configuration updated", {
-        tunnelId: newTunnel.tunnelid,
-        configId: newTunnel.configid,
-        isStopped
-      });
-      return newTunnel;
-    } catch (error) {
-      logger.error("Error updating tunnel configuration", {
-        configId: configid,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      try {
-        const originalTunnel = await this._createTunnelWithProcessedConfig({
-          configid: currentTunnelConfigId,
-          tunnelid: currentTunnelId,
-          tunnelName: currentTunnelName,
-          originalConfig: currentTunnelConfig,
-          configWithForwarding: currentConfigWithForwarding,
-          additionalForwarding: currentAdditionalForwarding,
-          serve: currentServe,
-          autoReconnect: currentAutoReconnect
-        });
-        if (!isStopped) {
-          await this.startTunnel(originalTunnel.tunnelid);
+      /**
+       * Get all TunnelStatus currently managed by this TunnelManager
+       * @returns An array of all TunnelStatus objects
+       */
+      async getAllTunnels() {
+        try {
+          const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
+            return {
+              tunnelid: tunnel.tunnelid,
+              configid: tunnel.configid,
+              tunnelName: tunnel.tunnelName,
+              tunnelConfig: tunnel.tunnelConfig,
+              remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
+              additionalForwarding: tunnel.additionalForwarding,
+              serve: tunnel.serve
+            };
+          }));
+          return tunnelList;
+        } catch (err) {
+          logger.error("Error fetching tunnels", { error: err });
+          return [];
         }
-        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;
+      /**
+       * Get status of a tunnel
+       */
+      async getTunnelStatus(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (managed.isStopped) {
+          return "exited";
+        }
+        const status = await managed.instance.getStatus();
+        logger.debug("Queried tunnel status", { tunnelId, status });
+        return status;
       }
-      const messages = await managed.instance.getGreetMessage();
-      if (Array.isArray(messages)) {
-        return messages.join(" ");
+      /**
+       * Stop all tunnels
+       */
+      stopAllTunnels() {
+        for (const { instance } of this.tunnelsByTunnelId.values()) {
+          try {
+            instance.stop();
+          } catch (e) {
+            logger.warn("Error stopping tunnel instance", e);
+          }
+        }
+        this.tunnelsByTunnelId.clear();
+        this.tunnelsByConfigId.clear();
+        this.tunnelStats.clear();
+        this.tunnelStatsListeners.clear();
+        logger.info("All tunnels stopped and cleared");
       }
-      return messages ?? null;
-    } catch (e) {
-      logger.error(
-        `Error fetching greet message for tunnel "${tunnelId}": ${e instanceof Error ? e.message : String(e)}`
-      );
-      return null;
-    }
-  }
-  getTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    return stats || null;
-  }
-  getLatestTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    if (stats && stats.length > 0) {
-      return stats[stats.length - 1];
-    }
-    return null;
-  }
-  /**
-   * Registers a listener function to receive tunnel statistics updates.
-   * The listener will be called whenever any tunnel's stats are updated.
-   * 
-   * @param tunnelId - The tunnel ID to listen to stats for
-   * @param listener - Function that receives tunnelId and stats when updates occur
-   * @returns A unique listener ID that can be used to deregister the listener and tunnelId
-   * 
-   * @throws {Error} When the specified tunnelId does not exist
-   */
-  async registerStatsListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStatsListeners.has(tunnelId)) {
-      this.tunnelStatsListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    tunnelListeners.set(listenerId, listener);
-    logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
-    return [listenerId, tunnelId];
-  }
-  async registerErrorListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelErrorListeners.has(tunnelId)) {
-      this.tunnelErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelErrorListeners = this.tunnelErrorListeners.get(tunnelId);
-    tunnelErrorListeners.set(listenerId, listener);
-    logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerDisconnectListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelDisconnectListeners.has(tunnelId)) {
-      this.tunnelDisconnectListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelDisconnectListeners = this.tunnelDisconnectListeners.get(tunnelId);
-    tunnelDisconnectListeners.set(listenerId, listener);
-    logger.info("Disconnect listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerWorkerErrorListner(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelWorkerErrorListeners.has(tunnelId)) {
-      this.tunnelWorkerErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelWorkerErrorListner = this.tunnelWorkerErrorListeners.get(tunnelId);
-    tunnelWorkerErrorListner?.set(listenerId, listener);
-    logger.info("TunnelWorker error listener registered for tunnel", { tunnelId, listenerId });
-  }
-  async registerStartListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStartListeners.has(tunnelId)) {
-      this.tunnelStartListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const listeners = this.tunnelStartListeners.get(tunnelId);
-    listeners.set(listenerId, listener);
-    logger.info("Start listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  /**
-   * Removes a previously registered stats listener.
-   * 
-  * @param tunnelId - The tunnel ID the listener was registered for
-  * @param listenerId - The unique ID returned when the listener was registered
-  */
-  deregisterStatsListener(tunnelId, listenerId) {
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    if (!tunnelListeners) {
-      logger.warn("No listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = tunnelListeners.delete(listenerId);
-    if (removed) {
-      logger.info("Stats listener deregistered", { tunnelId, listenerId });
-      if (tunnelListeners.size === 0) {
-        this.tunnelStatsListeners.delete(tunnelId);
+      /**
+       * 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;
       }
-    } 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);
+      /**
+       * 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);
       }
-    } else {
-      logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
-    }
-  }
-  deregisterDisconnectListener(tunnelId, listenerId) {
-    const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No disconnect listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Disconnect listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelDisconnectListeners.delete(tunnelId);
+      _cleanupTunnelRecords(managed) {
+        if (!managed.isStopped) {
+          throw new Error(`Active tunnel "${managed.tunnelid}" cannot be removed`);
+        }
+        try {
+          if (managed.serveWorker) {
+            managed.serveWorker = null;
+          }
+          this.tunnelStats.delete(managed.tunnelid);
+          this.tunnelStatsListeners.delete(managed.tunnelid);
+          this.tunnelErrorListeners.delete(managed.tunnelid);
+          this.tunnelDisconnectListeners.delete(managed.tunnelid);
+          this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
+          this.tunnelStartListeners.delete(managed.tunnelid);
+          this.tunnelsByTunnelId.delete(managed.tunnelid);
+          this.tunnelsByConfigId.delete(managed.configid);
+        } catch (e) {
+          logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
+        }
       }
-    } else {
-      logger.warn("Attempted to deregister non-existent disconnect listener", { tunnelId, listenerId });
-    }
-  }
-  async getLocalserverTlsInfo(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching local server TLS info`);
-      return false;
-    }
-    try {
-      if (managed.isStopped) {
-        return false;
+      /**
+       * 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`);
       }
-      const tlsInfo = await managed.instance.getLocalServerTls();
-      if (tlsInfo) {
-        return tlsInfo;
+      /**
+       * 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`);
       }
-      return false;
-    } catch (e) {
-      logger.error(`Error fetching TLS info for tunnel "${tunnelId}": ${e instanceof Error ? e.message : e}`);
-      return false;
-    }
-  }
-  /**
-   * Sets up the stats callback for a tunnel during creation.
-   * This callback will update stored stats and notify all registered listeners.
-   */
-  setupStatsCallback(tunnelId, managed) {
-    try {
-      const callback = (usage) => {
-        this.updateStats(tunnelId, usage);
-      };
-      managed.instance.setUsageUpdateCallback(callback);
-      logger.debug("Stats callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up stats callback", { tunnelId, error });
-    }
-  }
-  notifyErrorListeners(tunnelId, errorMsg, isFatal) {
-    try {
-      const listeners = this.tunnelErrorListeners.get(tunnelId);
-      if (!listeners) return;
-      for (const [id, listener] of listeners) {
+      /**
+       * 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 {
-          listener(tunnelId, errorMsg, isFatal);
-        } catch (err) {
-          logger.debug("Error in error-listener callback", { listenerId: id, tunnelId, err });
+          const tunnelName = existingTunnel.tunnelName;
+          const currentConfigId = existingTunnel.configid;
+          const currentConfig = existingTunnel.tunnelConfig;
+          const configWithForwarding = existingTunnel.configWithForwarding;
+          const additionalForwarding = existingTunnel.additionalForwarding;
+          const currentServe = existingTunnel.serve;
+          const autoReconnect = existingTunnel.autoReconnect || false;
+          this.tunnelsByTunnelId.delete(tunnelid);
+          this.tunnelsByConfigId.delete(existingTunnel.configid);
+          this.tunnelStats.delete(tunnelid);
+          this.tunnelStatsListeners.delete(tunnelid);
+          this.tunnelErrorListeners.delete(tunnelid);
+          this.tunnelDisconnectListeners.delete(tunnelid);
+          this.tunnelWorkerErrorListeners.delete(tunnelid);
+          this.tunnelStartListeners.delete(tunnelid);
+          const newTunnel = await this._createTunnelWithProcessedConfig({
+            configid: currentConfigId,
+            tunnelid,
+            tunnelName,
+            originalConfig: currentConfig,
+            configWithForwarding,
+            additionalForwarding,
+            serve: currentServe,
+            autoReconnect
+          });
+          if (existingTunnel.createdAt) {
+            newTunnel.createdAt = existingTunnel.createdAt;
+          }
+          await this.startTunnel(newTunnel.tunnelid);
+        } catch (error) {
+          logger.error("Failed to restart tunnel", {
+            tunnelid,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+          throw new Error(`Failed to restart tunnel: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
       }
-    } catch (err) {
-      logger.debug("Failed to notify error listeners", { tunnelId, err });
-    }
-  }
-  setupErrorCallback(tunnelId, managed) {
-    try {
-      const callback = ({ errorNo, error, recoverable }) => {
+      /**
+       * Updates the configuration of an existing tunnel.
+       * 
+       * This method handles the process of updating a tunnel's configuration while preserving
+       * its state. If the tunnel is running, it will be stopped, updated, and restarted.
+       * In case of failure, it attempts to restore the original configuration.
+       * 
+       * @param newConfig - The new configuration to apply, including configid and optional additional forwarding
+       * 
+       * @returns Promise resolving to the updated ManagedTunnel
+       * @throws Error if the tunnel is not found or if the update process fails
+       */
+      async updateConfig(newConfig) {
+        const { configid, tunnelName: newTunnelName, additionalForwarding } = newConfig;
+        if (!configid || configid.trim().length === 0) {
+          throw new Error(`Invalid configid: "${configid}"`);
+        }
+        const existingTunnel = this.tunnelsByConfigId.get(configid);
+        if (!existingTunnel) {
+          throw new Error(`Tunnel with config id "${configid}" not found`);
+        }
+        const isStopped = existingTunnel.isStopped;
+        const currentTunnelConfig = existingTunnel.tunnelConfig;
+        const currentConfigWithForwarding = existingTunnel.configWithForwarding;
+        const currentTunnelId = existingTunnel.tunnelid;
+        const currentTunnelConfigId = existingTunnel.configid;
+        const currentAdditionalForwarding = existingTunnel.additionalForwarding;
+        const currentTunnelName = existingTunnel.tunnelName;
+        const currentServe = existingTunnel.serve;
+        const currentAutoReconnect = existingTunnel.autoReconnect || false;
+        try {
+          if (!isStopped) {
+            existingTunnel.instance.stop();
+          }
+          this.tunnelsByTunnelId.delete(currentTunnelId);
+          this.tunnelsByConfigId.delete(currentTunnelConfigId);
+          const mergedBaseConfig = {
+            ...newConfig,
+            configid,
+            tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
+            serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
+          };
+          const newConfigWithForwarding = this.buildPinggyConfig(
+            mergedBaseConfig,
+            additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
+          );
+          const newTunnel = await this._createTunnelWithProcessedConfig({
+            configid,
+            tunnelid: currentTunnelId,
+            tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
+            originalConfig: mergedBaseConfig,
+            configWithForwarding: newConfigWithForwarding,
+            additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
+            serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
+            autoReconnect: currentAutoReconnect
+          });
+          if (!isStopped) {
+            await this.startTunnel(newTunnel.tunnelid);
+          }
+          logger.info("Tunnel configuration updated", {
+            tunnelId: newTunnel.tunnelid,
+            configId: newTunnel.configid,
+            isStopped
+          });
+          return newTunnel;
+        } catch (error) {
+          logger.error("Error updating tunnel configuration", {
+            configId: configid,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          try {
+            const originalTunnel = await this._createTunnelWithProcessedConfig({
+              configid: currentTunnelConfigId,
+              tunnelid: currentTunnelId,
+              tunnelName: currentTunnelName,
+              originalConfig: currentTunnelConfig,
+              configWithForwarding: currentConfigWithForwarding,
+              additionalForwarding: currentAdditionalForwarding,
+              serve: currentServe,
+              autoReconnect: currentAutoReconnect
+            });
+            if (!isStopped) {
+              await this.startTunnel(originalTunnel.tunnelid);
+            }
+            logger.warn("Restored original tunnel configuration after update failure", {
+              currentTunnelId,
+              error: error instanceof Error ? error.message : "Unknown error"
+            });
+          } catch (restoreError) {
+            logger.error("Failed to restore original tunnel configuration", {
+              currentTunnelId,
+              error: restoreError instanceof Error ? restoreError.message : "Unknown error"
+            });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Retrieve the ManagedTunnel object by either configId or tunnelId.
+       * Throws an error if neither id is provided or the tunnel is not found.
+       */
+      getManagedTunnel(configId, tunnelId) {
+        if (configId) {
+          const managed = this.tunnelsByConfigId.get(configId);
+          if (!managed) throw new Error(`Tunnel "${configId}" not found`);
+          return managed;
+        }
+        if (tunnelId) {
+          const managed = this.tunnelsByTunnelId.get(tunnelId);
+          if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+          return managed;
+        }
+        throw new Error(`Either configId or tunnelId must be provided`);
+      }
+      async getTunnelGreetMessage(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          logger.error(`Tunnel "${tunnelId}" not found when fetching greet message`);
+          return null;
+        }
         try {
-          const msg = typeof error === "string" ? error : String(error);
-          const isFatal = true;
-          logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
-          this.notifyErrorListeners(tunnelId, msg, isFatal);
+          if (managed.isStopped) {
+            return null;
+          }
+          const messages = await managed.instance.getGreetMessage();
+          if (Array.isArray(messages)) {
+            return messages.join(" ");
+          }
+          return messages ?? null;
         } catch (e) {
-          logger.warn("Error handling tunnel error callback", { tunnelId, e });
+          logger.error(
+            `Error fetching greet message for tunnel "${tunnelId}": ${e instanceof Error ? e.message : String(e)}`
+          );
+          return null;
+        }
+      }
+      getTunnelStats(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          return null;
+        }
+        const stats = this.tunnelStats.get(tunnelId);
+        return stats || null;
+      }
+      getLatestTunnelStats(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          return null;
+        }
+        const stats = this.tunnelStats.get(tunnelId);
+        if (stats && stats.length > 0) {
+          return stats[stats.length - 1];
+        }
+        return null;
+      }
+      /**
+       * Registers a listener function to receive tunnel statistics updates.
+       * The listener will be called whenever any tunnel's stats are updated.
+       * 
+       * @param tunnelId - The tunnel ID to listen to stats for
+       * @param listener - Function that receives tunnelId and stats when updates occur
+       * @returns A unique listener ID that can be used to deregister the listener and tunnelId
+       * 
+       * @throws {Error} When the specified tunnelId does not exist
+       */
+      async registerStatsListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelStatsListeners.has(tunnelId)) {
+          this.tunnelStatsListeners.set(tunnelId, /* @__PURE__ */ new Map());
+        }
+        const listenerId = getRandomId();
+        const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
+        tunnelListeners.set(listenerId, listener);
+        logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
+        return [listenerId, tunnelId];
+      }
+      async registerErrorListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelErrorListeners.has(tunnelId)) {
+          this.tunnelErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
+        }
+        const listenerId = getRandomId();
+        const tunnelErrorListeners = this.tunnelErrorListeners.get(tunnelId);
+        tunnelErrorListeners.set(listenerId, listener);
+        logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
+        return listenerId;
+      }
+      async registerDisconnectListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelDisconnectListeners.has(tunnelId)) {
+          this.tunnelDisconnectListeners.set(tunnelId, /* @__PURE__ */ new Map());
+        }
+        const listenerId = getRandomId();
+        const tunnelDisconnectListeners = this.tunnelDisconnectListeners.get(tunnelId);
+        tunnelDisconnectListeners.set(listenerId, listener);
+        logger.info("Disconnect listener registered for tunnel", { tunnelId, listenerId });
+        return listenerId;
+      }
+      async registerWorkerErrorListner(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelWorkerErrorListeners.has(tunnelId)) {
+          this.tunnelWorkerErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
+        }
+        const listenerId = getRandomId();
+        const tunnelWorkerErrorListner = this.tunnelWorkerErrorListeners.get(tunnelId);
+        tunnelWorkerErrorListner?.set(listenerId, listener);
+        logger.info("TunnelWorker error listener registered for tunnel", { tunnelId, listenerId });
+      }
+      async registerStartListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelStartListeners.has(tunnelId)) {
+          this.tunnelStartListeners.set(tunnelId, /* @__PURE__ */ new Map());
+        }
+        const listenerId = getRandomId();
+        const listeners = this.tunnelStartListeners.get(tunnelId);
+        listeners.set(listenerId, listener);
+        logger.info("Start listener registered for tunnel", { tunnelId, listenerId });
+        return listenerId;
+      }
+      /**
+       * Removes a previously registered stats listener.
+       * 
+      * @param tunnelId - The tunnel ID the listener was registered for
+      * @param listenerId - The unique ID returned when the listener was registered
+      */
+      deregisterStatsListener(tunnelId, listenerId) {
+        const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
+        if (!tunnelListeners) {
+          logger.warn("No listeners found for tunnel", { tunnelId });
+          return;
+        }
+        const removed = tunnelListeners.delete(listenerId);
+        if (removed) {
+          logger.info("Stats listener deregistered", { tunnelId, listenerId });
+          if (tunnelListeners.size === 0) {
+            this.tunnelStatsListeners.delete(tunnelId);
+          }
+        } else {
+          logger.warn("Attempted to deregister non-existent stats listener", { tunnelId, listenerId });
+        }
+      }
+      deregisterErrorListener(tunnelId, listenerId) {
+        const listeners = this.tunnelErrorListeners.get(tunnelId);
+        if (!listeners) {
+          logger.warn("No error listeners found for tunnel", { tunnelId });
+          return;
+        }
+        const removed = listeners.delete(listenerId);
+        if (removed) {
+          logger.info("Error listener deregistered", { tunnelId, listenerId });
+          if (listeners.size === 0) {
+            this.tunnelErrorListeners.delete(tunnelId);
+          }
+        } else {
+          logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
+        }
+      }
+      deregisterDisconnectListener(tunnelId, listenerId) {
+        const listeners = this.tunnelDisconnectListeners.get(tunnelId);
+        if (!listeners) {
+          logger.warn("No disconnect listeners found for tunnel", { tunnelId });
+          return;
+        }
+        const removed = listeners.delete(listenerId);
+        if (removed) {
+          logger.info("Disconnect listener deregistered", { tunnelId, listenerId });
+          if (listeners.size === 0) {
+            this.tunnelDisconnectListeners.delete(tunnelId);
+          }
+        } else {
+          logger.warn("Attempted to deregister non-existent disconnect listener", { tunnelId, listenerId });
+        }
+      }
+      async getLocalserverTlsInfo(tunnelId) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+          logger.error(`Tunnel "${tunnelId}" not found when fetching local server TLS info`);
+          return false;
         }
-      };
-      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 (managed.isStopped) {
+            return false;
           }
-          if (managedTunnel && managedTunnel.autoReconnect) {
-            logger.info("Auto-reconnecting tunnel", { tunnelId });
-            setTimeout(async () => {
-              try {
-                await this.restartTunnel(tunnelId);
-                logger.info("Tunnel auto-reconnected successfully", { tunnelId });
-              } catch (e) {
-                logger.error("Failed to auto-reconnect tunnel", { tunnelId, e });
-              }
-            }, 1e4);
+          const tlsInfo = await managed.instance.getLocalServerTls();
+          if (tlsInfo) {
+            return tlsInfo;
           }
-          const listeners = this.tunnelDisconnectListeners.get(tunnelId);
+          return false;
+        } catch (e) {
+          logger.error(`Error fetching TLS info for tunnel "${tunnelId}": ${e instanceof Error ? e.message : e}`);
+          return false;
+        }
+      }
+      /**
+       * Sets up the stats callback for a tunnel during creation.
+       * This callback will update stored stats and notify all registered listeners.
+       */
+      setupStatsCallback(tunnelId, managed) {
+        try {
+          const callback = (usage) => {
+            this.updateStats(tunnelId, usage);
+          };
+          managed.instance.setUsageUpdateCallback(callback);
+          logger.debug("Stats callback set up for tunnel", { tunnelId });
+        } catch (error) {
+          logger.warn("Failed to set up stats callback", { tunnelId, error });
+        }
+      }
+      notifyErrorListeners(tunnelId, errorMsg, isFatal) {
+        try {
+          const listeners = this.tunnelErrorListeners.get(tunnelId);
           if (!listeners) return;
           for (const [id, listener] of listeners) {
             try {
-              listener(tunnelId, error, messages);
+              listener(tunnelId, errorMsg, isFatal);
             } catch (err) {
-              logger.debug("Error in disconnect-listener callback", { listenerId: id, tunnelId, err });
+              logger.debug("Error in error-listener callback", { listenerId: id, tunnelId, err });
             }
           }
-        } catch (e) {
-          logger.warn("Error handling tunnel disconnect callback", { tunnelId, e });
+        } catch (err) {
+          logger.debug("Failed to notify error listeners", { tunnelId, err });
         }
-      };
-      managed.instance.setTunnelDisconnectedCallback(callback);
-      logger.debug("Disconnect callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up disconnect callback", { tunnelId, error });
-    }
-  }
-  setUpTunnelWorkerErrorCallback(tunnelId, managed) {
-    try {
-      const callback = (error) => {
+      }
+      setupErrorCallback(tunnelId, managed) {
         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) {
+          const callback = ({ errorNo, error, recoverable }) => {
             try {
-              listener(tunnelId, error);
-            } catch (err) {
-              logger.debug("Error in worker-error-listener callback", { listenerId: id, tunnelId, err });
+              const msg = typeof error === "string" ? error : String(error);
+              const isFatal = true;
+              logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
+              this.notifyErrorListeners(tunnelId, msg, isFatal);
+            } catch (e) {
+              logger.warn("Error handling tunnel error callback", { tunnelId, e });
             }
-          }
-        } catch (e) {
-          logger.warn("Error handling tunnel worker 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 });
         }
-      };
-      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 });
-          }
+      }
+      setupDisconnectCallback(tunnelId, managed) {
+        try {
+          const callback = ({ error, messages }) => {
+            try {
+              logger.debug("Tunnel disconnected", { tunnelId, error, messages });
+              const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+              if (managedTunnel) {
+                managedTunnel.isStopped = true;
+                managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+              }
+              if (managedTunnel && managedTunnel.autoReconnect) {
+                logger.info("Auto-reconnecting tunnel", { tunnelId });
+                setTimeout(async () => {
+                  try {
+                    await this.restartTunnel(tunnelId);
+                    logger.info("Tunnel auto-reconnected successfully", { tunnelId });
+                  } catch (e) {
+                    logger.error("Failed to auto-reconnect tunnel", { tunnelId, e });
+                  }
+                }, 1e4);
+              }
+              const listeners = this.tunnelDisconnectListeners.get(tunnelId);
+              if (!listeners) return;
+              for (const [id, listener] of listeners) {
+                try {
+                  listener(tunnelId, error, messages);
+                } catch (err) {
+                  logger.debug("Error in disconnect-listener callback", { listenerId: id, tunnelId, err });
+                }
+              }
+            } catch (e) {
+              logger.warn("Error handling tunnel disconnect callback", { tunnelId, e });
+            }
+          };
+          managed.instance.setTunnelDisconnectedCallback(callback);
+          logger.debug("Disconnect callback set up for tunnel", { tunnelId });
+        } catch (error) {
+          logger.warn("Failed to set up disconnect callback", { tunnelId, error });
         }
       }
-      logger.debug("Stats updated and listeners notified", {
-        tunnelId,
-        listenersCount: tunnelListeners?.size || 0
-      });
-    } catch (error) {
-      logger.warn("Error updating stats", { tunnelId, error });
-    }
-  }
-  /**
-   * Normalizes raw usage data from the SDK into a consistent TunnelStats format.
-   */
-  normalizeStats(rawStats) {
-    const elapsed = this.parseNumber(rawStats.elapsedTime ?? 0);
-    const liveConns = this.parseNumber(rawStats.numLiveConnections ?? 0);
-    const totalConns = this.parseNumber(rawStats.numTotalConnections ?? 0);
-    const reqBytes = this.parseNumber(rawStats.numTotalReqBytes ?? 0);
-    const resBytes = this.parseNumber(rawStats.numTotalResBytes ?? 0);
-    const txBytes = this.parseNumber(rawStats.numTotalTxBytes ?? 0);
-    return {
-      elapsedTime: elapsed,
-      numLiveConnections: liveConns,
-      numTotalConnections: totalConns,
-      numTotalReqBytes: reqBytes,
-      numTotalResBytes: resBytes,
-      numTotalTxBytes: txBytes
-    };
-  }
-  parseNumber(value) {
-    const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
-    return isNaN(parsed) ? 0 : parsed;
-  }
-  startStaticFileServer(managed) {
-    try {
-      const __filename3 = (0, import_node_url.fileURLToPath)(importMetaUrl);
-      const __dirname2 = import_node_path.default.dirname(__filename3);
-      const fileServerWorkerPath = import_node_path.default.join(__dirname2, "workers", "file_serve_worker.cjs");
-      const staticServerWorker = new import_node_worker_threads.Worker(fileServerWorkerPath, {
-        workerData: {
-          dir: managed.serve,
-          port: managed.tunnelConfig?.forwarding
+      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");
         }
-      });
-      staticServerWorker.on("message", (msg) => {
-        switch (msg.type) {
-          case "started":
-            logger.info("Static file server started", { dir: managed.serve });
-            break;
-          case "warning":
-            if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
-              managed.warnings = managed.warnings ?? [];
-              managed.warnings.push({ code: msg.code, message: msg.message });
+      }
+      /**
+       * 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 });
+              }
             }
-            printer_default.warn(msg.message);
-            break;
-          case "error":
-            managed.warnings = managed.warnings ?? [];
-            managed.warnings.push({
-              code: "UNKNOWN_WARNING",
-              message: msg.message
-            });
-            break;
+          }
+          logger.debug("Stats updated and listeners notified", {
+            tunnelId,
+            listenersCount: tunnelListeners?.size || 0
+          });
+        } catch (error) {
+          logger.warn("Error updating stats", { tunnelId, error });
         }
-      });
-      managed.serveWorker = staticServerWorker;
-    } catch (error) {
-      logger.error("Error starting static file server", error);
-    }
+      }
+      /**
+       * Normalizes raw usage data from the SDK into a consistent TunnelStats format.
+       */
+      normalizeStats(rawStats) {
+        const elapsed = this.parseNumber(rawStats.elapsedTime ?? 0);
+        const liveConns = this.parseNumber(rawStats.numLiveConnections ?? 0);
+        const totalConns = this.parseNumber(rawStats.numTotalConnections ?? 0);
+        const reqBytes = this.parseNumber(rawStats.numTotalReqBytes ?? 0);
+        const resBytes = this.parseNumber(rawStats.numTotalResBytes ?? 0);
+        const txBytes = this.parseNumber(rawStats.numTotalTxBytes ?? 0);
+        return {
+          elapsedTime: elapsed,
+          numLiveConnections: liveConns,
+          numTotalConnections: totalConns,
+          numTotalReqBytes: reqBytes,
+          numTotalResBytes: resBytes,
+          numTotalTxBytes: txBytes
+        };
+      }
+      parseNumber(value) {
+        const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
+        return isNaN(parsed) ? 0 : parsed;
+      }
+      startStaticFileServer(managed) {
+        try {
+          const __filename3 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+          const __dirname2 = import_node_path.default.dirname(__filename3);
+          const fileServerWorkerPath = import_node_path.default.join(__dirname2, "workers", "file_serve_worker.cjs");
+          const staticServerWorker = new import_node_worker_threads.Worker(fileServerWorkerPath, {
+            workerData: {
+              dir: managed.serve,
+              port: managed.tunnelConfig?.forwarding
+            }
+          });
+          staticServerWorker.on("message", (msg) => {
+            switch (msg.type) {
+              case "started":
+                logger.info("Static file server started", { dir: managed.serve });
+                break;
+              case "warning":
+                if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
+                  managed.warnings = managed.warnings ?? [];
+                  managed.warnings.push({ code: msg.code, message: msg.message });
+                }
+                printer_default.warn(msg.message);
+                break;
+              case "error":
+                managed.warnings = managed.warnings ?? [];
+                managed.warnings.push({
+                  code: "UNKNOWN_WARNING",
+                  message: msg.message
+                });
+                break;
+            }
+          });
+          managed.serveWorker = staticServerWorker;
+        } catch (error) {
+          logger.error("Error starting static file server", error);
+        }
+      }
+    };
   }
-};
+});
 
 // src/cli/options.ts
-var cliOptions = {
-  // SSH-like options
-  R: { type: "string", multiple: true, description: "Local port. Eg. -R0:localhost:3000 will forward tunnel connections to local port 3000." },
-  L: { type: "string", multiple: true, description: "Web Debugger address. Eg. -L4300:localhost:4300 will start web debugger on port 4300." },
-  o: { type: "string", multiple: true, description: "Options", hidden: true },
-  "server-port": { type: "string", short: "p", description: "Pinggy server port. Default: 443" },
-  v4: { type: "boolean", short: "4", description: "IPv4 only", hidden: true },
-  v6: { type: "boolean", short: "6", description: "IPv6 only", hidden: true },
-  // These options appear in the ssh command, but we ignore it in CLI
-  t: { type: "boolean", description: "hidden", hidden: true },
-  T: { type: "boolean", description: "hidden", hidden: true },
-  n: { type: "boolean", description: "hidden", hidden: true },
-  N: { type: "boolean", description: "hidden", hidden: true },
-  // Better options
-  type: { type: "string", description: "Type of the connection. Eg. --type tcp" },
-  localport: { type: "string", short: "l", description: "Takes input as [protocol:][host:]port. Eg. --localport https://localhost:8000 OR -l 3000" },
-  debugger: { type: "string", short: "d", description: "Port for web debugger. Eg. --debugger 4300 OR -d 4300" },
-  token: { type: "string", description: "Token for authentication. Eg. --token TOKEN_VALUE" },
-  // Logging options (CLI overrides env)
-  loglevel: { type: "string", description: "Logging level: ERROR, INFO, DEBUG. Overrides PINGGY_LOG_LEVEL environment variable" },
-  logfile: { type: "string", description: "Path to log file. Overrides PINGGY_LOG_FILE environment variable" },
-  v: { type: "boolean", description: "Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable" },
-  vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
-  vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
-  autoreconnect: { type: "boolean", short: "a", description: "Automatically reconnect tunnel on failure." },
-  // Save and load config
-  saveconf: { type: "string", description: "Create the configuration file based on the options provided here" },
-  conf: { type: "string", description: "Use the configuration file as base. Other options will be used to override this file" },
-  // File server
-  serve: { type: "string", description: "Start a webserver to serve files from the specified path. Eg --serve /path/to/files" },
-  // Remote Control
-  "remote-management": { type: "string", description: "Enable remote management of tunnels with token. Eg. --remote-management API_KEY" },
-  manage: { type: "string", description: "Provide a server address to manage tunnels. Eg --manage dashboard.pinggy.io" },
-  notui: { type: "boolean", description: "Disable TUI in remote management mode" },
-  // Misc
-  version: { type: "boolean", description: "Print version" },
-  // Help
-  help: { type: "boolean", short: "h", description: "Show this help message" }
-};
+var cliOptions;
+var init_options = __esm({
+  "src/cli/options.ts"() {
+    "use strict";
+    init_cjs_shims();
+    cliOptions = {
+      // SSH-like options
+      R: { type: "string", multiple: true, description: "Local port. Eg. -R0:localhost:3000 will forward tunnel connections to local port 3000." },
+      L: { type: "string", multiple: true, description: "Web Debugger address. Eg. -L4300:localhost:4300 will start web debugger on port 4300." },
+      o: { type: "string", multiple: true, description: "Options", hidden: true },
+      "server-port": { type: "string", short: "p", description: "Pinggy server port. Default: 443" },
+      v4: { type: "boolean", short: "4", description: "IPv4 only", hidden: true },
+      v6: { type: "boolean", short: "6", description: "IPv6 only", hidden: true },
+      // These options appear in the ssh command, but we ignore it in CLI
+      t: { type: "boolean", description: "hidden", hidden: true },
+      T: { type: "boolean", description: "hidden", hidden: true },
+      n: { type: "boolean", description: "hidden", hidden: true },
+      N: { type: "boolean", description: "hidden", hidden: true },
+      // Better options
+      type: { type: "string", description: "Type of the connection. Eg. --type tcp" },
+      localport: { type: "string", short: "l", description: "Takes input as [protocol:][host:]port. Eg. --localport https://localhost:8000 OR -l 3000" },
+      debugger: { type: "string", short: "d", description: "Port for web debugger. Eg. --debugger 4300 OR -d 4300" },
+      token: { type: "string", description: "Token for authentication. Eg. --token TOKEN_VALUE" },
+      // Logging options (CLI overrides env)
+      loglevel: { type: "string", description: "Logging level: ERROR, INFO, DEBUG. Overrides PINGGY_LOG_LEVEL environment variable" },
+      logfile: { type: "string", description: "Path to log file. Overrides PINGGY_LOG_FILE environment variable" },
+      v: { type: "boolean", description: "Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable" },
+      vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
+      vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
+      autoreconnect: { type: "boolean", short: "a", description: "Automatically reconnect tunnel on failure." },
+      // Save and load config
+      saveconf: { type: "string", description: "Create the configuration file based on the options provided here" },
+      conf: { type: "string", description: "Use the configuration file as base. Other options will be used to override this file" },
+      // File server
+      serve: { type: "string", description: "Start a webserver to serve files from the specified path. Eg --serve /path/to/files" },
+      // Remote Control
+      "remote-management": { type: "string", description: "Enable remote management of tunnels with token. Eg. --remote-management API_KEY" },
+      manage: { type: "string", description: "Provide a server address to manage tunnels. Eg --manage dashboard.pinggy.io" },
+      notui: { type: "boolean", description: "Disable TUI in remote management mode" },
+      // Misc
+      version: { type: "boolean", description: "Print version" },
+      // Help
+      help: { type: "boolean", short: "h", description: "Show this help message" }
+    };
+  }
+});
 
 // src/cli/help.ts
 function printHelpMessage() {
@@ -1299,29 +1335,42 @@ function printHelpMessage() {
   console.log("  pinggy -R0:localhost:8080 -L4300:localhost:4300  # HTTP tunnel with debugger");
   console.log("  pinggy tcp@ap.example.com -R0:localhost:22       # TCP tunnel to region\n");
 }
+var init_help = __esm({
+  "src/cli/help.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_options();
+  }
+});
 
 // src/cli/defaults.ts
-var defaultOptions = {
-  token: void 0,
-  // No default token
-  serverAddress: "a.pinggy.io",
-  forwarding: "localhost:8000",
-  webDebugger: "",
-  ipWhitelist: [],
-  basicAuth: [],
-  bearerTokenAuth: [],
-  headerModification: [],
-  force: false,
-  xForwardedFor: false,
-  httpsOnly: false,
-  originalRequestUrl: false,
-  allowPreflight: false,
-  reverseProxy: false,
-  autoReconnect: false
-};
+var defaultOptions;
+var init_defaults = __esm({
+  "src/cli/defaults.ts"() {
+    "use strict";
+    init_cjs_shims();
+    defaultOptions = {
+      token: void 0,
+      // No default token
+      serverAddress: "a.pinggy.io",
+      forwarding: "localhost:8000",
+      webDebugger: "",
+      ipWhitelist: [],
+      basicAuth: [],
+      bearerTokenAuth: [],
+      headerModification: [],
+      force: false,
+      xForwardedFor: false,
+      httpsOnly: false,
+      originalRequestUrl: false,
+      allowPreflight: false,
+      reverseProxy: false,
+      autoReconnect: false
+    };
+  }
+});
 
 // src/cli/extendedOptions.ts
-var import_net = require("net");
 function parseExtendedOptions(options, config) {
   if (!options) return;
   for (const opt of options) {
@@ -1445,12 +1494,18 @@ function isValidIpV6Cidr(input) {
   }
   return false;
 }
+var import_net;
+var init_extendedOptions = __esm({
+  "src/cli/extendedOptions.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_net = require("net");
+    init_logger();
+    init_printer();
+  }
+});
 
 // src/cli/buildConfig.ts
-var import_pinggy3 = require("@pinggy/pinggy");
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-var domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 function parseUserAndDomain(str) {
   let token;
   let type;
@@ -1580,7 +1635,6 @@ function ipv6SafeSplitColon(s) {
   result.push(buf);
   return result;
 }
-var VALID_PROTOCOLS = ["http", "tcp", "udp", "tls"];
 function parseDefaultForwarding(forwarding) {
   const parts = ipv6SafeSplitColon(forwarding);
   if (parts.length === 3) {
@@ -1600,77 +1654,63 @@ function parseDefaultForwarding(forwarding) {
 }
 function parseAdditionalForwarding(forwarding) {
   const toPort = (v) => {
+    if (!v) return null;
     const n = parseInt(v, 10);
     return Number.isNaN(n) ? null : n;
   };
-  const validateDomain = (d) => d && domainRegex.test(d) ? d : null;
+  const parsed = ipv6SafeSplitColon(forwarding);
+  if (parsed.length !== 4) {
+    return new Error(
+      "forwarding must be in format: [schema//]hostname[/port][@forwardingId]:<placeholder>:<forwardingAddress>:<forwardingPort>"
+    );
+  }
+  const firstPart = parsed[0];
+  const [hostPart] = firstPart.split("@");
   let protocol = "http";
   let remoteDomainRaw;
-  const protocolsRequiringDomainPort = ["tcp", "udp"];
-  const lowForwarding = forwarding.toLowerCase();
-  let remaining = forwarding;
-  for (const p of VALID_PROTOCOLS) {
-    if (lowForwarding.startsWith(p + "//")) {
-      protocol = p;
-      remaining = forwarding.slice(p.length + 2);
-      break;
-    }
-  }
-  if (protocol === "http" && remaining === forwarding) {
-    const parts2 = ipv6SafeSplitColon(remaining);
-    if (parts2.length !== 4) {
-      return new Error(
-        "forwarding must be in format: domain:remotePort:localDomain:localPort"
-      );
-    }
-    const remoteDomain = validateDomain(removeIPv6Brackets(parts2[0]));
-    const localDomain2 = removeIPv6Brackets(parts2[2] || "localhost");
-    const localPort2 = toPort(parts2[3]);
-    if (!remoteDomain) {
-      return new Error("forwarding address incorrect: invalid domain");
+  let remotePort = 0;
+  if (hostPart.includes("//")) {
+    const [schema, rest] = hostPart.split("//");
+    if (!schema || !VALID_PROTOCOLS.includes(schema)) {
+      return new Error(`invalid protocol: ${schema}`);
+    }
+    protocol = schema;
+    const domainAndPort = rest.split("/");
+    if (domainAndPort.length > 2) {
+      return new Error("invalid forwarding address format");
+    }
+    remoteDomainRaw = domainAndPort[0];
+    if (!remoteDomainRaw || !domainRegex.test(remoteDomainRaw)) {
+      return new Error("invalid remote domain");
+    }
+    const parsedRemotePort = toPort(domainAndPort[1]);
+    if (protocol === "http") {
+      remotePort = 0;
+    } else {
+      if (parsedRemotePort === null || !isValidPort(parsedRemotePort)) {
+        return new Error(
+          `${protocol} forwarding requires port in format ${protocol}//domain/remotePort`
+        );
+      }
+      remotePort = parsedRemotePort;
     }
-    if (localPort2 === null || !isValidPort(localPort2)) {
-      return new Error("forwarding address incorrect: invalid local port");
+  } else {
+    remoteDomainRaw = hostPart;
+    if (!domainRegex.test(remoteDomainRaw)) {
+      return new Error("invalid remote domain");
     }
-    return {
-      protocol: "http",
-      remoteDomain,
-      remotePort: 0,
-      localDomain: localDomain2,
-      localPort: localPort2
-    };
-  }
-  const domainPortMatch = remaining.match(/^([^:]+)\/(\d+):(.+)$/);
-  if (!domainPortMatch) {
-    return new Error(`forwarding must be in format: ${protocol}//domain/remotePort:localDomain:localPort`);
-  }
-  remoteDomainRaw = removeIPv6Brackets(domainPortMatch[1]);
-  const remotePortNum = toPort(domainPortMatch[2]);
-  const restParts = domainPortMatch[3];
-  if (!remoteDomainRaw || !domainRegex.test(remoteDomainRaw)) {
-    return new Error("forwarding address incorrect: invalid domain or remote port");
-  }
-  if (!remoteDomainRaw || remotePortNum === null || !isValidPort(remotePortNum)) {
-    return new Error(`${protocol} forwarding: invalid domain or port in format ${protocol}//domain/remotePort`);
-  }
-  const parts = ipv6SafeSplitColon(restParts);
-  if (parts.length !== 3) {
-    return new Error(`forwarding format incorrect: expected ${protocol}//domain/remotePort:placeholder:localDomain:localPort`);
+    protocol = "http";
+    remotePort = 0;
   }
-  const localDomain = removeIPv6Brackets(parts[1] || "localhost");
-  const localPort = toPort(parts[2]);
+  const localDomain = removeIPv6Brackets(parsed[2] || "localhost");
+  const localPort = toPort(parsed[3]);
   if (localPort === null || !isValidPort(localPort)) {
     return new Error("forwarding address incorrect: invalid local port");
   }
-  if (protocolsRequiringDomainPort.includes(protocol)) {
-    if (!remoteDomainRaw || !remotePortNum) {
-      return new Error(`${protocol} forwarding requires domain and port in format: ${protocol}//domain/remotePort:localDomain:localPort`);
-    }
-  }
   return {
     protocol,
     remoteDomain: remoteDomainRaw,
-    remotePort: remotePortNum,
+    remotePort,
     localDomain,
     localPort
   };
@@ -1683,19 +1723,21 @@ function parseReverseTunnelAddr(finalConfig, values) {
   if (!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) {
     return null;
   }
-  const forwarding = parseDefaultForwarding(reverseTunnel[0]);
-  if (forwarding instanceof Error) {
-    return forwarding;
-  }
-  finalConfig.forwarding = `${forwarding.localDomain}:${forwarding.localPort}`;
-  if (reverseTunnel.length > 1) {
-    finalConfig.additionalForwarding = [];
-    for (const t of reverseTunnel.slice(1)) {
-      const f = parseAdditionalForwarding(t);
-      if (f instanceof Error) {
-        return f;
-      }
-      finalConfig.additionalForwarding.push(f);
+  for (const forwarding of reverseTunnel) {
+    const slicedForwarding = ipv6SafeSplitColon(forwarding);
+    if (slicedForwarding.length === 3) {
+      const parsed = parseDefaultForwarding(forwarding);
+      if (parsed instanceof Error) return parsed;
+      finalConfig.forwarding = `${parsed.localDomain}:${parsed.localPort}`;
+    } else if (slicedForwarding.length === 4) {
+      finalConfig.additionalForwarding ?? (finalConfig.additionalForwarding = []);
+      const parsed = parseAdditionalForwarding(forwarding);
+      if (parsed instanceof Error) return parsed;
+      finalConfig.additionalForwarding.push(parsed);
+    } else {
+      return new Error(
+        "Incorrect command line arguments: reverse tunnel address incorrect. Please use '-h' option for help."
+      );
     }
   }
   return null;
@@ -1737,10 +1779,10 @@ function parseArgs(finalConfig, remainingPositionals) {
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
-    const path4 = saveconf;
+    const path5 = saveconf;
     try {
-      import_fs2.default.writeFileSync(path4, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
-      logger.info(`Configuration saved to ${path4}`);
+      import_fs3.default.writeFileSync(path5, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
+      logger.info(`Configuration saved to ${path5}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       logger.error("Error loading configuration:", msg);
@@ -1750,9 +1792,9 @@ function storeJson(config, saveconf) {
 function loadJsonConfig(config) {
   const configpath = config["conf"];
   if (typeof configpath === "string" && configpath.trim().length > 0) {
-    const filepath = import_path2.default.resolve(configpath);
+    const filepath = import_path3.default.resolve(configpath);
     try {
-      const data = import_fs2.default.readFileSync(filepath, { encoding: "utf-8" });
+      const data = import_fs3.default.readFileSync(filepath, { encoding: "utf-8" });
       const json = JSON.parse(data);
       return json;
     } catch (err) {
@@ -1820,24 +1862,24 @@ async function buildFinalConfig(values, positionals) {
   storeJson(finalConfig, saveconf);
   return finalConfig;
 }
-
-// src/remote_management/remoteManagement.ts
-var import_ws = __toESM(require("ws"), 1);
+var import_pinggy3, import_fs3, import_path3, domainRegex, VALID_PROTOCOLS;
+var init_buildConfig = __esm({
+  "src/cli/buildConfig.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_defaults();
+    init_extendedOptions();
+    init_logger();
+    init_util();
+    import_pinggy3 = require("@pinggy/pinggy");
+    import_fs3 = __toESM(require("fs"), 1);
+    import_path3 = __toESM(require("path"), 1);
+    domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+    VALID_PROTOCOLS = ["http", "tcp", "udp", "tls"];
+  }
+});
 
 // src/types.ts
-var ErrorCode = {
-  InvalidRequestMethodError: "INVALID_REQUEST_METHOD",
-  InvalidRequestBodyError: "COULD_NOT_READ_BODY",
-  InternalServerError: "INTERNAL_SERVER_ERROR",
-  InvalidBodyFormatError: "INVALID_DATA_FORMAT",
-  ErrorStartingTunnel: "ERROR_STARTING_TUNNEL",
-  TunnelNotFound: "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND",
-  TunnelAlreadyRunningError: "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING",
-  WebsocketUpgradeFailError: "WEBSOCKET_UPGRADE_FAILED",
-  RemoteManagementAlreadyRunning: "REMOTE_MANAGEMENT_ALREADY_RUNNING",
-  RemoteManagementNotRunning: "REMOTE_MANAGEMENT_NOT_RUNNING",
-  RemoteManagementDeserializationFailed: "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED"
-};
 function isErrorResponse(obj) {
   return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj && typeof obj.message === "string" && Object.values(ErrorCode).includes(obj.code);
 }
@@ -1900,93 +1942,36 @@ function newStats() {
     elapsedTime: 0
   };
 }
-var RemoteManagementStatus = {
-  Connecting: "CONNECTING",
-  Disconnecting: "DISCONNECTING",
-  Reconnecting: "RECONNECTING",
-  Running: "RUNNING",
-  NotRunning: "NOT_RUNNING",
-  Error: "ERROR"
-};
-
-// src/remote_management/remote_schema.ts
-var import_pinggy4 = require("@pinggy/pinggy");
-var import_zod = require("zod");
-var HeaderModificationSchema = import_zod.z.object({
-  key: import_zod.z.string(),
-  value: import_zod.z.array(import_zod.z.string()).optional(),
-  type: import_zod.z.enum(["add", "remove", "update"])
-});
-var AdditionalForwardingSchema = import_zod.z.object({
-  remoteDomain: import_zod.z.string().optional(),
-  remotePort: import_zod.z.number().optional(),
-  localDomain: import_zod.z.string(),
-  localPort: import_zod.z.number()
-});
-var TunnelConfigSchema = import_zod.z.object({
-  allowPreflight: import_zod.z.boolean().optional(),
-  // primary key
-  allowpreflight: import_zod.z.boolean().optional(),
-  // legacy key
-  autoreconnect: import_zod.z.boolean(),
-  basicauth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).nullable(),
-  bearerauth: import_zod.z.string().nullable(),
-  configid: import_zod.z.string(),
-  configname: import_zod.z.string(),
-  greetmsg: import_zod.z.string().optional(),
-  force: import_zod.z.boolean(),
-  forwardedhost: import_zod.z.string(),
-  fullRequestUrl: import_zod.z.boolean(),
-  headermodification: import_zod.z.array(HeaderModificationSchema),
-  httpsOnly: import_zod.z.boolean(),
-  internalwebdebuggerport: import_zod.z.number(),
-  ipwhitelist: import_zod.z.array(import_zod.z.string()).nullable(),
-  localport: import_zod.z.number(),
-  localsservertls: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]),
-  localservertlssni: import_zod.z.string().nullable(),
-  regioncode: import_zod.z.string(),
-  noReverseProxy: import_zod.z.boolean(),
-  serveraddress: import_zod.z.string(),
-  serverport: import_zod.z.number(),
-  statusCheckInterval: import_zod.z.number(),
-  token: import_zod.z.string(),
-  tunnelTimeout: import_zod.z.number(),
-  type: import_zod.z.enum([
-    import_pinggy4.TunnelType.Http,
-    import_pinggy4.TunnelType.Tcp,
-    import_pinggy4.TunnelType.Udp,
-    import_pinggy4.TunnelType.Tls,
-    import_pinggy4.TunnelType.TlsTcp
-  ]),
-  webdebuggerport: import_zod.z.number(),
-  xff: import_zod.z.string(),
-  additionalForwarding: import_zod.z.array(AdditionalForwardingSchema).optional(),
-  serve: import_zod.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"]
-    });
+var ErrorCode, RemoteManagementStatus;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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"
+    };
+    RemoteManagementStatus = {
+      Connecting: "CONNECTING",
+      Disconnecting: "DISCONNECTING",
+      Reconnecting: "RECONNECTING",
+      Running: "RUNNING",
+      NotRunning: "NOT_RUNNING",
+      Error: "ERROR"
+    };
   }
-}).transform((data) => ({
-  ...data,
-  allowPreflight: data.allowPreflight ?? data.allowpreflight,
-  allowpreflight: data.allowPreflight ?? data.allowpreflight
-}));
-var StartSchema = import_zod.z.object({
-  tunnelID: import_zod.z.string().nullable().optional(),
-  tunnelConfig: TunnelConfigSchema
-});
-var StopSchema = import_zod.z.object({
-  tunnelID: import_zod.z.string().min(1)
-});
-var GetSchema = StopSchema;
-var RestartSchema = StopSchema;
-var UpdateConfigSchema = import_zod.z.object({
-  tunnelConfig: TunnelConfigSchema
 });
+
+// src/remote_management/remote_schema.ts
 function tunnelConfigToPinggyOptions(config) {
   return {
     token: config.token || "",
@@ -2049,313 +2034,279 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
     serve: serve || ""
   };
 }
-
-// src/remote_management/handler.ts
-var import_pinggy5 = require("@pinggy/pinggy");
-var TunnelOperations = class {
-  constructor() {
-    this.tunnelManager = TunnelManager.getInstance();
-  }
-  buildStatus(tunnelId, state, errorCode) {
-    const status = newStatus(state, errorCode, "");
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
-      if (managed) {
-        status.createdtimestamp = managed.createdAt || "";
-        status.starttimestamp = managed.startedAt || "";
-        status.endtimestamp = managed.stoppedAt || "";
-      }
-    } catch (e) {
-    }
-    return status;
-  }
-  // --- Helper to construct TunnelResponse ---
-  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
-    const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
-      this.tunnelManager.getTunnelStatus(tunnelid),
-      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
-      this.tunnelManager.getLocalserverTlsInfo(tunnelid),
-      this.tunnelManager.getTunnelGreetMessage(tunnelid),
-      this.tunnelManager.getTunnelUrls(tunnelid)
-    ]);
-    return {
-      tunnelid,
-      remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
-      status: this.buildStatus(tunnelid, status, "" /* NoError */),
-      stats
-    };
-  }
-  error(code, err, fallback) {
-    return newErrorResponse({
-      code,
-      message: err instanceof Error ? err.message : fallback
+var import_pinggy4, import_zod, HeaderModificationSchema, AdditionalForwardingSchema, TunnelConfigSchema, StartSchema, StopSchema, GetSchema, RestartSchema, UpdateConfigSchema;
+var init_remote_schema = __esm({
+  "src/remote_management/remote_schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_pinggy4 = require("@pinggy/pinggy");
+    import_zod = require("zod");
+    HeaderModificationSchema = import_zod.z.object({
+      key: import_zod.z.string(),
+      value: import_zod.z.array(import_zod.z.string()).optional(),
+      type: import_zod.z.enum(["add", "remove", "update"])
     });
-  }
-  // --- Operations ---
-  async handleStart(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const additionalForwardingParsed = config.additionalForwarding || [];
-      const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy5.TunnelType.Http],
-        // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: additionalForwardingParsed,
-        serve: config.serve
-      });
-      this.tunnelManager.startTunnel(tunnelid);
-      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
-      return resp;
-    } catch (err) {
-      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-    }
-  }
-  async handleUpdateConfig(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const tunnel = await this.tunnelManager.updateConfig({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy5.TunnelType.Http],
-        // // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: config.additionalForwarding || [],
-        serve: config.serve
-      });
-      if (!tunnel.instance || !tunnel.tunnelConfig)
-        throw new Error("Invalid tunnel state after configuration update");
-      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.additionalForwarding, tunnel.serve);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-    }
-  }
-  async handleList() {
-    try {
-      const tunnels = await this.tunnelManager.getAllTunnels();
-      if (tunnels.length === 0) {
-        return [];
-      }
-      return Promise.all(
-        tunnels.map(async (t) => {
-          const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
-          const [status, tlsInfo, greetMsg] = await Promise.all([
-            this.tunnelManager.getTunnelStatus(t.tunnelid),
-            this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
-            this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
-          ]);
-          const pinggyOptions = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
-          const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
-          return {
-            tunnelid: t.tunnelid,
-            remoteurls: t.remoteurls,
-            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
-            stats: rawStats,
-            tunnelconfig: tunnelConfig
-          };
-        })
-      );
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
-    }
-  }
-  async handleStop(tunnelid) {
-    try {
-      const { configid } = this.tunnelManager.stopTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
-    }
-  }
-  async handleGet(tunnelid) {
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
-    }
-  }
-  async handleRestart(tunnelid) {
-    try {
-      await this.tunnelManager.restartTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
-    }
-  }
-  handleRegisterStatsListener(tunnelid, listener) {
-    this.tunnelManager.registerStatsListener(tunnelid, listener);
-  }
-  handleUnregisterStatsListener(tunnelid, listnerId) {
-    this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
-  }
-  handleGetTunnelStats(tunnelid) {
-    try {
-      const stats = this.tunnelManager.getTunnelStats(tunnelid);
-      if (!stats) {
-        return [newStats()];
+    AdditionalForwardingSchema = import_zod.z.object({
+      remoteDomain: import_zod.z.string().optional(),
+      remotePort: import_zod.z.number().optional(),
+      localDomain: import_zod.z.string(),
+      localPort: import_zod.z.number()
+    });
+    TunnelConfigSchema = import_zod.z.object({
+      allowPreflight: import_zod.z.boolean().optional(),
+      // primary key
+      allowpreflight: import_zod.z.boolean().optional(),
+      // legacy key
+      autoreconnect: import_zod.z.boolean(),
+      basicauth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).nullable(),
+      bearerauth: import_zod.z.string().nullable(),
+      configid: import_zod.z.string(),
+      configname: import_zod.z.string(),
+      greetmsg: import_zod.z.string().optional(),
+      force: import_zod.z.boolean(),
+      forwardedhost: import_zod.z.string(),
+      fullRequestUrl: import_zod.z.boolean(),
+      headermodification: import_zod.z.array(HeaderModificationSchema),
+      httpsOnly: import_zod.z.boolean(),
+      internalwebdebuggerport: import_zod.z.number(),
+      ipwhitelist: import_zod.z.array(import_zod.z.string()).nullable(),
+      localport: import_zod.z.number(),
+      localsservertls: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]),
+      localservertlssni: import_zod.z.string().nullable(),
+      regioncode: import_zod.z.string(),
+      noReverseProxy: import_zod.z.boolean(),
+      serveraddress: import_zod.z.string(),
+      serverport: import_zod.z.number(),
+      statusCheckInterval: import_zod.z.number(),
+      token: import_zod.z.string(),
+      tunnelTimeout: import_zod.z.number(),
+      type: import_zod.z.enum([
+        import_pinggy4.TunnelType.Http,
+        import_pinggy4.TunnelType.Tcp,
+        import_pinggy4.TunnelType.Udp,
+        import_pinggy4.TunnelType.Tls,
+        import_pinggy4.TunnelType.TlsTcp
+      ]),
+      webdebuggerport: import_zod.z.number(),
+      xff: import_zod.z.string(),
+      additionalForwarding: import_zod.z.array(AdditionalForwardingSchema).optional(),
+      serve: import_zod.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"]
+        });
       }
-      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");
-    }
+    }).transform((data) => ({
+      ...data,
+      allowPreflight: data.allowPreflight ?? data.allowpreflight,
+      allowpreflight: data.allowPreflight ?? data.allowpreflight
+    }));
+    StartSchema = import_zod.z.object({
+      tunnelID: import_zod.z.string().nullable().optional(),
+      tunnelConfig: TunnelConfigSchema
+    });
+    StopSchema = import_zod.z.object({
+      tunnelID: import_zod.z.string().min(1)
+    });
+    GetSchema = StopSchema;
+    RestartSchema = StopSchema;
+    UpdateConfigSchema = import_zod.z.object({
+      tunnelConfig: TunnelConfigSchema
+    });
   }
-};
+});
 
-// src/remote_management/websocket_handlers.ts
-var import_zod2 = __toESM(require("zod"), 1);
-var WebSocketCommandHandler = class {
-  constructor() {
-    this.tunnelHandler = new TunnelOperations();
-  }
-  safeParse(text) {
-    if (!text) return void 0;
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      logger.warn("Invalid JSON payload", { error: String(e), text });
-      return void 0;
-    }
-  }
-  sendResponse(ws, resp) {
-    const payload = {
-      ...resp,
-      response: Buffer.from(resp.response || []).toString("base64")
-    };
-    ws.send(JSON.stringify(payload));
-  }
-  sendError(ws, req, message, code = ErrorCode.InternalServerError) {
-    const resp = NewErrorResponseObject({ code, message });
-    resp.command = req.command || "";
-    resp.requestid = req.requestid || "";
-    this.sendResponse(ws, resp);
-  }
-  async handleStartReq(req, raw) {
-    const dc = StartSchema.parse(raw);
-    printer_default.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
-    const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleStopReq(req, raw) {
-    const dc = StopSchema.parse(raw);
-    printer_default.info("Stopping tunnel with ID: " + dc.tunnelID);
-    const result = await this.tunnelHandler.handleStop(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleGetReq(req, raw) {
-    const dc = GetSchema.parse(raw);
-    const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleRestartReq(req, raw) {
-    const dc = RestartSchema.parse(raw);
-    const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleUpdateConfigReq(req, raw) {
-    const dc = UpdateConfigSchema.parse(raw);
-    const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleListReq(req) {
-    const result = await this.tunnelHandler.handleList();
-    return this.wrapResponse(result, req);
-  }
-  wrapResponse(result, req) {
-    if (isErrorResponse(result)) {
-      const errResp = NewErrorResponseObject(result);
-      errResp.command = req.command;
-      errResp.requestid = req.requestid;
-      return errResp;
-    }
-    const finalResult = JSON.parse(JSON.stringify(result));
-    if (Array.isArray(finalResult)) {
-      finalResult.forEach((item) => {
-        if (item?.tunnelconfig) {
-          delete item.tunnelconfig.allowPreflight;
+// src/remote_management/handler.ts
+var import_pinggy5, TunnelOperations;
+var init_handler = __esm({
+  "src/remote_management/handler.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_types();
+    init_TunnelManager();
+    init_remote_schema();
+    import_pinggy5 = require("@pinggy/pinggy");
+    TunnelOperations = class {
+      constructor() {
+        this.tunnelManager = TunnelManager.getInstance();
+      }
+      buildStatus(tunnelId, state, errorCode) {
+        const status = newStatus(state, errorCode, "");
+        try {
+          const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
+          if (managed) {
+            status.createdtimestamp = managed.createdAt || "";
+            status.starttimestamp = managed.startedAt || "";
+            status.endtimestamp = managed.stoppedAt || "";
+          }
+        } catch (e) {
         }
-      });
-    } else if (finalResult?.tunnelconfig) {
-      delete finalResult.tunnelconfig.allowPreflight;
-    }
-    const respObj = NewResponseObject(finalResult);
-    respObj.command = req.command;
-    respObj.requestid = req.requestid;
-    return respObj;
-  }
-  async handle(ws, req) {
-    const cmd = (req.command || "").toLowerCase();
-    const raw = this.safeParse(req.data);
-    try {
-      let response;
-      switch (cmd) {
-        case "start": {
-          response = await this.handleStartReq(req, raw);
-          break;
-        }
-        case "stop": {
-          response = await this.handleStopReq(req, raw);
-          break;
-        }
-        case "get": {
-          response = await this.handleGetReq(req, raw);
-          break;
-        }
-        case "restart": {
-          response = await this.handleRestartReq(req, raw);
-          break;
-        }
-        case "updateconfig": {
-          response = await this.handleUpdateConfigReq(req, raw);
-          break;
-        }
-        case "list": {
-          response = await this.handleListReq(req);
-          break;
-        }
-        default:
-          if (typeof req.command === "string") {
-            logger.warn("Unknown command", { command: req.command });
+        return status;
+      }
+      // --- Helper to construct TunnelResponse ---
+      async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
+        const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
+          this.tunnelManager.getTunnelStatus(tunnelid),
+          this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
+          this.tunnelManager.getLocalserverTlsInfo(tunnelid),
+          this.tunnelManager.getTunnelGreetMessage(tunnelid),
+          this.tunnelManager.getTunnelUrls(tunnelid)
+        ]);
+        return {
+          tunnelid,
+          remoteurls,
+          tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
+          status: this.buildStatus(tunnelid, status, "" /* NoError */),
+          stats
+        };
+      }
+      error(code, err, fallback) {
+        return newErrorResponse({
+          code,
+          message: err instanceof Error ? err.message : fallback
+        });
+      }
+      // --- Operations ---
+      async handleStart(config) {
+        try {
+          const opts = tunnelConfigToPinggyOptions(config);
+          const additionalForwardingParsed = config.additionalForwarding || [];
+          const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
+            ...opts,
+            tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy5.TunnelType.Http],
+            // Temporary fix in future we will not use this field.
+            configid: config.configid,
+            tunnelName: config.configname,
+            additionalForwarding: additionalForwardingParsed,
+            serve: config.serve
+          });
+          this.tunnelManager.startTunnel(tunnelid);
+          const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
+          const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
+          return resp;
+        } catch (err) {
+          return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
+        }
+      }
+      async handleUpdateConfig(config) {
+        try {
+          const opts = tunnelConfigToPinggyOptions(config);
+          const tunnel = await this.tunnelManager.updateConfig({
+            ...opts,
+            tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy5.TunnelType.Http],
+            // // Temporary fix in future we will not use this field.
+            configid: config.configid,
+            tunnelName: config.configname,
+            additionalForwarding: config.additionalForwarding || [],
+            serve: config.serve
+          });
+          if (!tunnel.instance || !tunnel.tunnelConfig)
+            throw new Error("Invalid tunnel state after configuration update");
+          return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.additionalForwarding, tunnel.serve);
+        } catch (err) {
+          return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
+        }
+      }
+      async handleList() {
+        try {
+          const tunnels = await this.tunnelManager.getAllTunnels();
+          if (tunnels.length === 0) {
+            return [];
+          }
+          return Promise.all(
+            tunnels.map(async (t) => {
+              const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
+              const [status, tlsInfo, greetMsg] = await Promise.all([
+                this.tunnelManager.getTunnelStatus(t.tunnelid),
+                this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
+                this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
+              ]);
+              const pinggyOptions = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
+              const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
+              return {
+                tunnelid: t.tunnelid,
+                remoteurls: t.remoteurls,
+                status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
+                stats: rawStats,
+                tunnelconfig: tunnelConfig
+              };
+            })
+          );
+        } catch (err) {
+          return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
+        }
+      }
+      async handleStop(tunnelid) {
+        try {
+          const { configid } = this.tunnelManager.stopTunnel(tunnelid);
+          const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+          if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+          return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
+        } catch (err) {
+          return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
+        }
+      }
+      async handleGet(tunnelid) {
+        try {
+          const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+          if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+          return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
+        } catch (err) {
+          return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
+        }
+      }
+      async handleRestart(tunnelid) {
+        try {
+          await this.tunnelManager.restartTunnel(tunnelid);
+          const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+          if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+          return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
+        } catch (err) {
+          return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
+        }
+      }
+      handleRegisterStatsListener(tunnelid, listener) {
+        this.tunnelManager.registerStatsListener(tunnelid, listener);
+      }
+      handleUnregisterStatsListener(tunnelid, listnerId) {
+        this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
+      }
+      handleGetTunnelStats(tunnelid) {
+        try {
+          const stats = this.tunnelManager.getTunnelStats(tunnelid);
+          if (!stats) {
+            return [newStats()];
           }
-          return this.sendError(ws, req, "Invalid command");
+          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");
+        }
       }
-      logger.debug("Sending response", { command: response.command, requestid: response.requestid });
-      this.sendResponse(ws, response);
-    } catch (e) {
-      if (e instanceof import_zod2.default.ZodError) {
-        logger.warn("Validation failed", { cmd, issues: e.issues });
-        return this.sendError(ws, req, "Invalid request data", ErrorCode.InvalidBodyFormatError);
+      handleRemoveStoppedTunnelByTunnelId(tunnelId) {
+        try {
+          return this.tunnelManager.removeStoppedTunnelByTunnelId(tunnelId);
+        } catch (err) {
+          return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by tunnelId");
+        }
       }
-      logger.error("Error handling command", { cmd, error: String(e) });
-      return this.sendError(ws, req, e?.message || "Internal error");
-    }
+    };
   }
-};
+});
+
+// src/remote_management/websocket_handlers.ts
 function handleConnectionStatusMessage(firstMessage) {
   try {
     const text = typeof firstMessage === "string" ? firstMessage : firstMessage.toString();
@@ -2372,16 +2323,148 @@ function handleConnectionStatusMessage(firstMessage) {
     return true;
   }
 }
+var import_zod2, WebSocketCommandHandler;
+var init_websocket_handlers = __esm({
+  "src/remote_management/websocket_handlers.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_types();
+    init_handler();
+    init_remote_schema();
+    import_zod2 = __toESM(require("zod"), 1);
+    init_printer();
+    WebSocketCommandHandler = class {
+      constructor() {
+        this.tunnelHandler = new TunnelOperations();
+      }
+      safeParse(text) {
+        if (!text) return void 0;
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          logger.warn("Invalid JSON payload", { error: String(e), text });
+          return void 0;
+        }
+      }
+      sendResponse(ws, resp) {
+        const payload = {
+          ...resp,
+          response: Buffer.from(resp.response || []).toString("base64")
+        };
+        ws.send(JSON.stringify(payload));
+      }
+      sendError(ws, req, message, code = ErrorCode.InternalServerError) {
+        const resp = NewErrorResponseObject({ code, message });
+        resp.command = req.command || "";
+        resp.requestid = req.requestid || "";
+        this.sendResponse(ws, resp);
+      }
+      async handleStartReq(req, raw) {
+        const dc = StartSchema.parse(raw);
+        printer_default.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
+        const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
+        return this.wrapResponse(result, req);
+      }
+      async handleStopReq(req, raw) {
+        const dc = StopSchema.parse(raw);
+        printer_default.info("Stopping tunnel with ID: " + dc.tunnelID);
+        const result = await this.tunnelHandler.handleStop(dc.tunnelID);
+        return this.wrapResponse(result, req);
+      }
+      async handleGetReq(req, raw) {
+        const dc = GetSchema.parse(raw);
+        const result = await this.tunnelHandler.handleGet(dc.tunnelID);
+        return this.wrapResponse(result, req);
+      }
+      async handleRestartReq(req, raw) {
+        const dc = RestartSchema.parse(raw);
+        const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
+        return this.wrapResponse(result, req);
+      }
+      async handleUpdateConfigReq(req, raw) {
+        const dc = UpdateConfigSchema.parse(raw);
+        const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+        return this.wrapResponse(result, req);
+      }
+      async handleListReq(req) {
+        const result = await this.tunnelHandler.handleList();
+        return this.wrapResponse(result, req);
+      }
+      wrapResponse(result, req) {
+        if (isErrorResponse(result)) {
+          const errResp = NewErrorResponseObject(result);
+          errResp.command = req.command;
+          errResp.requestid = req.requestid;
+          return errResp;
+        }
+        const finalResult = JSON.parse(JSON.stringify(result));
+        if (Array.isArray(finalResult)) {
+          finalResult.forEach((item) => {
+            if (item?.tunnelconfig) {
+              delete item.tunnelconfig.allowPreflight;
+            }
+          });
+        } else if (finalResult?.tunnelconfig) {
+          delete finalResult.tunnelconfig.allowPreflight;
+        }
+        const respObj = NewResponseObject(finalResult);
+        respObj.command = req.command;
+        respObj.requestid = req.requestid;
+        return respObj;
+      }
+      async handle(ws, req) {
+        const cmd = (req.command || "").toLowerCase();
+        const raw = this.safeParse(req.data);
+        try {
+          let response;
+          switch (cmd) {
+            case "start": {
+              response = await this.handleStartReq(req, raw);
+              break;
+            }
+            case "stop": {
+              response = await this.handleStopReq(req, raw);
+              break;
+            }
+            case "get": {
+              response = await this.handleGetReq(req, raw);
+              break;
+            }
+            case "restart": {
+              response = await this.handleRestartReq(req, raw);
+              break;
+            }
+            case "updateconfig": {
+              response = await this.handleUpdateConfigReq(req, raw);
+              break;
+            }
+            case "list": {
+              response = await this.handleListReq(req);
+              break;
+            }
+            default:
+              if (typeof req.command === "string") {
+                logger.warn("Unknown command", { command: req.command });
+              }
+              return this.sendError(ws, req, "Invalid command");
+          }
+          logger.debug("Sending response", { command: response.command, requestid: response.requestid });
+          this.sendResponse(ws, response);
+        } catch (e) {
+          if (e instanceof import_zod2.default.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");
+        }
+      }
+    };
+  }
+});
 
 // src/remote_management/remoteManagement.ts
-var RECONNECT_SLEEP_MS = 5e3;
-var PING_INTERVAL_MS = 3e4;
-var _remoteManagementState = {
-  status: "NOT_RUNNING",
-  errorMessage: ""
-};
-var _stopRequested = false;
-var currentWs = null;
 function buildRemoteManagementWsUrl(manage) {
   let baseUrl = (manage || "dashboard.pinggy.io").trim();
   if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
@@ -2541,15 +2624,33 @@ function setRemoteManagementState(state, errorMessage) {
     errorMessage: errorMessage || ""
   };
 }
+var import_ws, RECONNECT_SLEEP_MS, PING_INTERVAL_MS, _remoteManagementState, _stopRequested, currentWs;
+var init_remoteManagement = __esm({
+  "src/remote_management/remoteManagement.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ws = __toESM(require("ws"), 1);
+    init_logger();
+    init_websocket_handlers();
+    init_printer();
+    init_types();
+    RECONNECT_SLEEP_MS = 5e3;
+    PING_INTERVAL_MS = 3e4;
+    _remoteManagementState = {
+      status: "NOT_RUNNING",
+      errorMessage: ""
+    };
+    _stopRequested = false;
+    currentWs = null;
+  }
+});
 
 // src/utils/parseArgs.ts
-var import_util3 = require("util");
-var os = __toESM(require("os"), 1);
 function isInlineColonFlag(arg) {
   return /^-([RL])[A-Za-z0-9._-]*:?$/.test(arg);
 }
 function preprocessWindowsArgs(args) {
-  if (os.platform() !== "win32") return args;
+  if (os2.platform() !== "win32") return args;
   const out = [];
   let i = 0;
   while (i < args.length) {
@@ -2573,7 +2674,7 @@ function preprocessWindowsArgs(args) {
 function parseCliArgs(options) {
   const rawArgs = process.argv.slice(2);
   const processedArgs = preprocessWindowsArgs(rawArgs);
-  const parsed = (0, import_util3.parseArgs)({
+  const parsed = (0, import_util4.parseArgs)({
     args: processedArgs,
     options,
     allowPositionals: true
@@ -2584,9 +2685,17 @@ function parseCliArgs(options) {
     hasAnyArgs
   };
 }
+var import_util4, os2;
+var init_parseArgs = __esm({
+  "src/utils/parseArgs.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_util4 = require("util");
+    os2 = __toESM(require("os"), 1);
+  }
+});
 
 // src/utils/getFreePort.ts
-var import_net2 = __toESM(require("net"), 1);
 function getFreePort(webDebugger) {
   return new Promise((resolve, reject) => {
     const tryPort = (portToTry) => {
@@ -2616,15 +2725,16 @@ function getFreePort(webDebugger) {
     tryPort(providedPort);
   });
 }
-
-// src/cli/starCli.ts
-var import_picocolors3 = __toESM(require("picocolors"), 1);
-
-// src/tui/blessed/TunnelTui.ts
-var import_blessed3 = __toESM(require("blessed"), 1);
+var import_net2;
+var init_getFreePort = __esm({
+  "src/utils/getFreePort.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_net2 = __toESM(require("net"), 1);
+  }
+});
 
 // src/tui/blessed/qrCodeGenerator.ts
-var import_qrcode = __toESM(require("qrcode"), 1);
 async function createQrCodes(urls) {
   const codes = [];
   for (const url of urls) {
@@ -2638,17 +2748,16 @@ async function createQrCodes(urls) {
   }
   return codes;
 }
-
-// src/tui/blessed/webDebuggerConnection.ts
-var import_ws2 = __toESM(require("ws"), 1);
+var import_qrcode;
+var init_qrCodeGenerator = __esm({
+  "src/tui/blessed/qrCodeGenerator.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_qrcode = __toESM(require("qrcode"), 1);
+  }
+});
 
 // src/tui/blessed/config.ts
-var defaultTuiConfig = {
-  maxRequestPairs: 100,
-  visibleRequestCount: 10,
-  viewportScrollMargin: 2,
-  inactivityHttpSelectorTimeoutMs: 1e4
-};
 function getTuiConfig() {
   return {
     maxRequestPairs: defaultTuiConfig.maxRequestPairs,
@@ -2657,6 +2766,19 @@ function getTuiConfig() {
     inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs
   };
 }
+var defaultTuiConfig;
+var init_config = __esm({
+  "src/tui/blessed/config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    defaultTuiConfig = {
+      maxRequestPairs: 100,
+      visibleRequestCount: 10,
+      viewportScrollMargin: 2,
+      inactivityHttpSelectorTimeoutMs: 1e4
+    };
+  }
+});
 
 // src/tui/blessed/webDebuggerConnection.ts
 function createWebDebuggerConnection(webDebuggerUrl, onUpdate) {
@@ -2750,22 +2872,34 @@ function createWebDebuggerConnection(webDebuggerUrl, onUpdate) {
     }
   };
 }
-
-// src/tui/blessed/components/UIComponents.ts
-var import_blessed = __toESM(require("blessed"), 1);
+var import_ws2;
+var init_webDebuggerConnection = __esm({
+  "src/tui/blessed/webDebuggerConnection.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ws2 = __toESM(require("ws"), 1);
+    init_logger();
+    init_config();
+  }
+});
 
 // src/tui/ink/asciArt.ts
-var asciiArtPinggyLogo = `
+var asciiArtPinggyLogo;
+var init_asciArt = __esm({
+  "src/tui/ink/asciArt.ts"() {
+    "use strict";
+    init_cjs_shims();
+    asciiArtPinggyLogo = `
 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557
 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D
 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2554\u255D 
 \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2588\u2588\u2554\u255D  
 \u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2551   
 \u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   `;
+  }
+});
 
 // src/tui/blessed/components/UIComponents.ts
-var MIN_WIDTH_WARNING = 60;
-var SIMPLE_LAYOUT_THRESHOLD = 80;
 function colorizeGradient(text) {
   const colors = ["red", "yellow", "green", "cyan", "blue", "magenta"];
   const lines = text.split("\n");
@@ -2987,6 +3121,17 @@ function createSimpleUI(screen, urls, greet) {
     footerBox
   };
 }
+var import_blessed, MIN_WIDTH_WARNING, SIMPLE_LAYOUT_THRESHOLD;
+var init_UIComponents = __esm({
+  "src/tui/blessed/components/UIComponents.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_blessed = __toESM(require("blessed"), 1);
+    init_asciArt();
+    MIN_WIDTH_WARNING = 60;
+    SIMPLE_LAYOUT_THRESHOLD = 80;
+  }
+});
 
 // src/tui/ink/utils/utils.ts
 function getStatusColor(status) {
@@ -3019,6 +3164,12 @@ function getBytesInt(b) {
   }
   return `${b.toFixed(2)}  `;
 }
+var init_utils = __esm({
+  "src/tui/ink/utils/utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/tui/blessed/components/DisplayUpdaters.ts
 function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
@@ -3135,9 +3286,16 @@ function updateQrCodeDisplay(qrCodeBox, screen, qrCodes, urls, currentQrIndex) {
   qrCodeBox.parseContent();
   screen.render();
 }
+var init_DisplayUpdaters = __esm({
+  "src/tui/blessed/components/DisplayUpdaters.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_utils();
+    init_config();
+  }
+});
 
 // src/tui/blessed/components/Modals.ts
-var import_blessed2 = __toESM(require("blessed"), 1);
 function showDetailModal(screen, manager, requestText, responseText) {
   manager.inDetailView = true;
   manager.detailModal = import_blessed2.default.box({
@@ -3340,6 +3498,14 @@ function showErrorModal(screen, modalManager, title = "Error", message) {
   modalManager.loadingView = true;
   screen.render();
 }
+var import_blessed2;
+var init_Modals = __esm({
+  "src/tui/blessed/components/Modals.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_blessed2 = __toESM(require("blessed"), 1);
+  }
+});
 
 // src/tui/blessed/headerFetcher.ts
 async function fetchReqResHeaders(baseUrl, key, signal) {
@@ -3367,6 +3533,13 @@ async function fetchReqResHeaders(baseUrl, key, signal) {
     throw err;
   }
 }
+var init_headerFetcher = __esm({
+  "src/tui/blessed/headerFetcher.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+  }
+});
 
 // src/tui/blessed/components/KeyBindings.ts
 function setupKeyBindings(screen, modalManager, state, callbacks, tunnelConfig) {
@@ -3530,264 +3703,291 @@ function setupKeyBindings(screen, modalManager, state, callbacks, tunnelConfig)
     }
   });
 }
+var init_KeyBindings = __esm({
+  "src/tui/blessed/components/KeyBindings.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_headerFetcher();
+    init_logger();
+    init_Modals();
+    init_config();
+  }
+});
 
 // src/tui/blessed/TunnelTui.ts
-var TunnelTui = class {
-  constructor(props) {
-    // State
-    this.currentQrIndex = 0;
-    this.selectedIndex = -1;
-    // -1 means no selection
-    this.selectedRequestKey = null;
-    // Track selected request by key
-    this.qrCodes = [];
-    this.stats = {
-      elapsedTime: 0,
-      numLiveConnections: 0,
-      numTotalConnections: 0,
-      numTotalReqBytes: 0,
-      numTotalResBytes: 0,
-      numTotalTxBytes: 0
-    };
-    this.pairs = [];
-    this.webDebuggerConnection = null;
-    this.modalManager = {
-      detailModal: null,
-      keyBindingsModal: null,
-      disconnectModal: null,
-      inDetailView: false,
-      keyBindingView: false,
-      inDisconnectView: false,
-      loadingBox: null,
-      loadingView: false,
-      fetchAbortController: null
-    };
-    this.exitPromiseResolve = null;
-    this.urls = props.urls;
-    this.greet = props.greet || "";
-    this.tunnelConfig = props.tunnelConfig;
-    this.disconnectInfo = props.disconnectInfo;
-    if (props.tunnelInstance) {
-      this.tunnelInstance = props.tunnelInstance;
-    }
-    this.exitPromise = new Promise((resolve) => {
-      this.exitPromiseResolve = resolve;
-    });
-    this.screen = import_blessed3.default.screen({
-      smartCSR: true,
-      title: "Pinggy Tunnel",
-      fullUnicode: true
-    });
-    this.setupStatsListener();
-    this.setupWebDebugger();
-    this.generateQrCodes();
-    this.createUI();
-    this.setupKeyBindings();
-  }
-  setupStatsListener() {
-    globalThis.__PINGGY_TUNNEL_STATS__ = (newStats2) => {
-      this.stats = { ...newStats2 };
-      this.updateStatsDisplay();
-    };
-  }
-  clearSelection() {
-    this.selectedIndex = -1;
-    this.selectedRequestKey = null;
-  }
-  setupWebDebugger() {
-    if (this.tunnelConfig?.webDebugger) {
-      this.webDebuggerConnection = createWebDebuggerConnection(
-        this.tunnelConfig.webDebugger,
-        (pairs) => {
-          this.pairs = pairs;
-          if (this.selectedRequestKey !== null) {
-            const newIndex = pairs.findIndex(
-              (pair) => pair.request?.key === this.selectedRequestKey
-            );
-            if (newIndex !== -1) {
-              this.selectedIndex = newIndex;
-            } else {
-              this.clearSelection();
+var import_blessed3, TunnelTui;
+var init_TunnelTui = __esm({
+  "src/tui/blessed/TunnelTui.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_blessed3 = __toESM(require("blessed"), 1);
+    init_qrCodeGenerator();
+    init_webDebuggerConnection();
+    init_TunnelManager();
+    init_UIComponents();
+    init_DisplayUpdaters();
+    init_Modals();
+    init_KeyBindings();
+    TunnelTui = class {
+      constructor(props) {
+        // State
+        this.currentQrIndex = 0;
+        this.selectedIndex = -1;
+        // -1 means no selection
+        this.selectedRequestKey = null;
+        // Track selected request by key
+        this.qrCodes = [];
+        this.stats = {
+          elapsedTime: 0,
+          numLiveConnections: 0,
+          numTotalConnections: 0,
+          numTotalReqBytes: 0,
+          numTotalResBytes: 0,
+          numTotalTxBytes: 0
+        };
+        this.pairs = [];
+        this.webDebuggerConnection = null;
+        this.modalManager = {
+          detailModal: null,
+          keyBindingsModal: null,
+          disconnectModal: null,
+          inDetailView: false,
+          keyBindingView: false,
+          inDisconnectView: false,
+          loadingBox: null,
+          loadingView: false,
+          fetchAbortController: null
+        };
+        this.exitPromiseResolve = null;
+        this.urls = props.urls;
+        this.greet = props.greet || "";
+        this.tunnelConfig = props.tunnelConfig;
+        this.disconnectInfo = props.disconnectInfo;
+        if (props.tunnelInstance) {
+          this.tunnelInstance = props.tunnelInstance;
+        }
+        this.exitPromise = new Promise((resolve) => {
+          this.exitPromiseResolve = resolve;
+        });
+        this.screen = import_blessed3.default.screen({
+          smartCSR: true,
+          title: "Pinggy Tunnel",
+          fullUnicode: true
+        });
+        this.setupStatsListener();
+        this.setupWebDebugger();
+        this.generateQrCodes();
+        this.createUI();
+        this.setupKeyBindings();
+      }
+      setupStatsListener() {
+        globalThis.__PINGGY_TUNNEL_STATS__ = (newStats2) => {
+          this.stats = { ...newStats2 };
+          this.updateStatsDisplay();
+        };
+      }
+      clearSelection() {
+        this.selectedIndex = -1;
+        this.selectedRequestKey = null;
+      }
+      setupWebDebugger() {
+        if (this.tunnelConfig?.webDebugger) {
+          this.webDebuggerConnection = createWebDebuggerConnection(
+            this.tunnelConfig.webDebugger,
+            (pairs) => {
+              this.pairs = pairs;
+              if (this.selectedRequestKey !== null) {
+                const newIndex = pairs.findIndex(
+                  (pair) => pair.request?.key === this.selectedRequestKey
+                );
+                if (newIndex !== -1) {
+                  this.selectedIndex = newIndex;
+                } else {
+                  this.clearSelection();
+                }
+              }
+              this.updateRequestsDisplay();
             }
+          );
+        }
+      }
+      async generateQrCodes() {
+        if (this.tunnelConfig?.qrCode && this.urls.length > 0) {
+          this.qrCodes = await createQrCodes(this.urls);
+          this.updateQrCodeDisplay();
+        }
+      }
+      // Create the UI based on terminal size
+      createUI() {
+        this.buildUI();
+        this.screen.on("resize", () => {
+          this.handleResize();
+        });
+      }
+      buildUI() {
+        const width = this.screen.width;
+        if (width < MIN_WIDTH_WARNING) {
+          this.uiElements = {
+            mainContainer: createWarningUI(this.screen),
+            urlsBox: null,
+            statsBox: null,
+            requestsBox: null,
+            footerBox: null,
+            warningBox: createWarningUI(this.screen)
+          };
+          this.screen.render();
+          return;
+        }
+        if (width < SIMPLE_LAYOUT_THRESHOLD) {
+          this.uiElements = createSimpleUI(this.screen, this.urls, this.greet);
+        } else {
+          this.uiElements = createFullUI(this.screen, this.urls, this.greet, this.tunnelConfig);
+        }
+        this.refreshDisplays();
+        this.screen.render();
+      }
+      refreshDisplays() {
+        this.updateUrlsDisplay();
+        this.updateStatsDisplay();
+        this.updateRequestsDisplay();
+        this.updateQrCodeDisplay();
+      }
+      updateUrlsDisplay() {
+        updateUrlsDisplay(
+          this.uiElements?.urlsBox,
+          this.screen,
+          this.urls,
+          this.currentQrIndex
+        );
+      }
+      updateStatsDisplay() {
+        updateStatsDisplay(
+          this.uiElements?.statsBox,
+          this.screen,
+          this.stats
+        );
+      }
+      updateRequestsDisplay() {
+        const result = updateRequestsDisplay(
+          this.uiElements?.requestsBox,
+          this.screen,
+          this.pairs,
+          this.selectedIndex
+        );
+        if (result.adjustedSelectedIndex !== this.selectedIndex) {
+          if (result.adjustedSelectedIndex === -1) {
+            this.clearSelection();
+          } else {
+            this.selectedIndex = result.adjustedSelectedIndex;
           }
-          this.updateRequestsDisplay();
         }
-      );
-    }
-  }
-  async generateQrCodes() {
-    if (this.tunnelConfig?.qrCode && this.urls.length > 0) {
-      this.qrCodes = await createQrCodes(this.urls);
-      this.updateQrCodeDisplay();
-    }
-  }
-  // Create the UI based on terminal size
-  createUI() {
-    this.buildUI();
-    this.screen.on("resize", () => {
-      this.handleResize();
-    });
-  }
-  buildUI() {
-    const width = this.screen.width;
-    if (width < MIN_WIDTH_WARNING) {
-      this.uiElements = {
-        mainContainer: createWarningUI(this.screen),
-        urlsBox: null,
-        statsBox: null,
-        requestsBox: null,
-        footerBox: null,
-        warningBox: createWarningUI(this.screen)
-      };
-      this.screen.render();
-      return;
-    }
-    if (width < SIMPLE_LAYOUT_THRESHOLD) {
-      this.uiElements = createSimpleUI(this.screen, this.urls, this.greet);
-    } else {
-      this.uiElements = createFullUI(this.screen, this.urls, this.greet, this.tunnelConfig);
-    }
-    this.refreshDisplays();
-    this.screen.render();
-  }
-  refreshDisplays() {
-    this.updateUrlsDisplay();
-    this.updateStatsDisplay();
-    this.updateRequestsDisplay();
-    this.updateQrCodeDisplay();
-  }
-  updateUrlsDisplay() {
-    updateUrlsDisplay(
-      this.uiElements?.urlsBox,
-      this.screen,
-      this.urls,
-      this.currentQrIndex
-    );
-  }
-  updateStatsDisplay() {
-    updateStatsDisplay(
-      this.uiElements?.statsBox,
-      this.screen,
-      this.stats
-    );
-  }
-  updateRequestsDisplay() {
-    const result = updateRequestsDisplay(
-      this.uiElements?.requestsBox,
-      this.screen,
-      this.pairs,
-      this.selectedIndex
-    );
-    if (result.adjustedSelectedIndex !== this.selectedIndex) {
-      if (result.adjustedSelectedIndex === -1) {
-        this.clearSelection();
-      } else {
-        this.selectedIndex = result.adjustedSelectedIndex;
+        if (result.trimmedPairs !== this.pairs) {
+          this.pairs = result.trimmedPairs;
+        }
       }
-    }
-    if (result.trimmedPairs !== this.pairs) {
-      this.pairs = result.trimmedPairs;
-    }
-  }
-  updateQrCodeDisplay() {
-    updateQrCodeDisplay(
-      this.uiElements?.qrCodeBox,
-      this.screen,
-      this.qrCodes,
-      this.urls,
-      this.currentQrIndex
-    );
-  }
-  setupKeyBindings() {
-    const self = this;
-    const state = {
-      get currentQrIndex() {
-        return self.currentQrIndex;
-      },
-      set currentQrIndex(value) {
-        self.currentQrIndex = value;
-      },
-      get selectedIndex() {
-        return self.selectedIndex;
-      },
-      set selectedIndex(value) {
-        self.selectedIndex = value;
-      },
-      get pairs() {
-        return self.pairs;
-      },
-      get urls() {
-        return self.urls;
+      updateQrCodeDisplay() {
+        updateQrCodeDisplay(
+          this.uiElements?.qrCodeBox,
+          this.screen,
+          this.qrCodes,
+          this.urls,
+          this.currentQrIndex
+        );
       }
-    };
-    const callbacks = {
-      onQrIndexChange: (index) => {
-        self.currentQrIndex = index;
-      },
-      onSelectedIndexChange: (index, requestKey) => {
-        self.selectedIndex = index;
-        self.selectedRequestKey = requestKey;
-      },
-      onDestroy: () => self.destroy(),
-      updateUrlsDisplay: () => self.updateUrlsDisplay(),
-      updateQrCodeDisplay: () => self.updateQrCodeDisplay(),
-      updateRequestsDisplay: () => self.updateRequestsDisplay()
-    };
-    setupKeyBindings(
-      this.screen,
-      this.modalManager,
-      state,
-      callbacks,
-      this.tunnelConfig
-    );
-  }
-  handleResize() {
-    this.screen.children.forEach((child) => child.destroy());
-    this.buildUI();
-  }
-  updateDisconnectInfo(info) {
-    this.disconnectInfo = info;
-    if (info?.disconnected) {
-      const message = info.error ? `Error: ${info.error}
+      setupKeyBindings() {
+        const self = this;
+        const state = {
+          get currentQrIndex() {
+            return self.currentQrIndex;
+          },
+          set currentQrIndex(value) {
+            self.currentQrIndex = value;
+          },
+          get selectedIndex() {
+            return self.selectedIndex;
+          },
+          set selectedIndex(value) {
+            self.selectedIndex = value;
+          },
+          get pairs() {
+            return self.pairs;
+          },
+          get urls() {
+            return self.urls;
+          }
+        };
+        const callbacks = {
+          onQrIndexChange: (index) => {
+            self.currentQrIndex = index;
+          },
+          onSelectedIndexChange: (index, requestKey) => {
+            self.selectedIndex = index;
+            self.selectedRequestKey = requestKey;
+          },
+          onDestroy: () => self.destroy(),
+          updateUrlsDisplay: () => self.updateUrlsDisplay(),
+          updateQrCodeDisplay: () => self.updateQrCodeDisplay(),
+          updateRequestsDisplay: () => self.updateRequestsDisplay()
+        };
+        setupKeyBindings(
+          this.screen,
+          this.modalManager,
+          state,
+          callbacks,
+          this.tunnelConfig
+        );
+      }
+      handleResize() {
+        this.screen.children.forEach((child) => child.destroy());
+        this.buildUI();
+      }
+      updateDisconnectInfo(info) {
+        this.disconnectInfo = info;
+        if (info?.disconnected) {
+          const message = info.error ? `Error: ${info.error}
 Tunnel will be closed.` : info.messages?.join("\n") || "Disconnect request received. Tunnel will be closed.";
-      showDisconnectModal(
-        this.screen,
-        this.modalManager,
-        message,
-        () => this.destroy()
-      );
-    }
-  }
-  start() {
-    this.screen.render();
-  }
-  waitUntilExit() {
-    return this.exitPromise;
+          showDisconnectModal(
+            this.screen,
+            this.modalManager,
+            message,
+            () => this.destroy()
+          );
+        }
+      }
+      start() {
+        this.screen.render();
+      }
+      waitUntilExit() {
+        return this.exitPromise;
+      }
+      destroy() {
+        if (this.tunnelInstance?.tunnelid) {
+          const manager = TunnelManager.getInstance();
+          manager.stopTunnel(this.tunnelInstance.tunnelid);
+        }
+        delete globalThis.__PINGGY_TUNNEL_STATS__;
+        if (this.webDebuggerConnection) {
+          this.webDebuggerConnection.close();
+        }
+        this.screen.destroy();
+        if (this.exitPromiseResolve) {
+          this.exitPromiseResolve();
+        }
+      }
+    };
   }
-  destroy() {
-    if (this.tunnelInstance?.tunnelid) {
-      const manager = TunnelManager.getInstance();
-      manager.stopTunnel(this.tunnelInstance.tunnelid);
-    }
-    delete globalThis.__PINGGY_TUNNEL_STATS__;
-    if (this.webDebuggerConnection) {
-      this.webDebuggerConnection.close();
-    }
-    this.screen.destroy();
-    if (this.exitPromiseResolve) {
-      this.exitPromiseResolve();
-    }
+});
+
+// src/tui/blessed/index.ts
+var init_blessed = __esm({
+  "src/tui/blessed/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_TunnelTui();
   }
-};
+});
 
 // src/cli/starCli.ts
-var TunnelData = {
-  urls: null,
-  greet: null,
-  usage: null
-};
-var activeTui = null;
-var disconnectState = null;
 async function launchTui(finalConfig, urls, greet, tunnel) {
   try {
     const isTTYEnabled = process.stdin.isTTY;
@@ -3930,11 +4130,37 @@ async function startCli(finalConfig, manager) {
     throw err;
   }
 }
+var import_picocolors3, TunnelData, activeTui, disconnectState;
+var init_starCli = __esm({
+  "src/cli/starCli.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_printer();
+    init_TunnelManager();
+    init_getFreePort();
+    init_logger();
+    import_picocolors3 = __toESM(require("picocolors"), 1);
+    init_blessed();
+    TunnelData = {
+      urls: null,
+      greet: null,
+      usage: null
+    };
+    activeTui = null;
+    disconnectState = null;
+  }
+});
 
-// src/index.ts
-var import_url = require("url");
-var import_process = require("process");
-var import_fs3 = require("fs");
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  TunnelManager: () => TunnelManager,
+  TunnelOperations: () => TunnelOperations,
+  closeRemoteManagement: () => closeRemoteManagement,
+  enablePackageLogging: () => enablePackageLogging,
+  getRemoteManagementState: () => getRemoteManagementState,
+  initiateRemoteManagement: () => initiateRemoteManagement
+});
 async function main() {
   try {
     const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
@@ -3970,22 +4196,178 @@ async function main() {
     printer_default.error(error);
   }
 }
-var currentFile = (0, import_url.fileURLToPath)(importMetaUrl);
-var entryFile = null;
-try {
-  entryFile = import_process.argv[1] ? (0, import_fs3.realpathSync)(import_process.argv[1]) : null;
-} catch (e) {
-  entryFile = null;
-}
-if (entryFile && entryFile === currentFile) {
-  main();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TunnelManager,
-  TunnelOperations,
-  closeRemoteManagement,
-  enablePackageLogging,
-  getRemoteManagementState,
-  initiateRemoteManagement
+var import_url, import_process, import_fs4, currentFile, entryFile;
+var init_main = __esm({
+  "src/main.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_TunnelManager();
+    init_help();
+    init_options();
+    init_buildConfig();
+    init_logger();
+    init_remoteManagement();
+    init_parseArgs();
+    init_printer();
+    init_starCli();
+    init_util();
+    init_handler();
+    import_url = require("url");
+    import_process = require("process");
+    import_fs4 = require("fs");
+    init_logger();
+    init_remoteManagement();
+    currentFile = (0, import_url.fileURLToPath)(importMetaUrl);
+    entryFile = null;
+    try {
+      entryFile = import_process.argv[1] ? (0, import_fs4.realpathSync)(import_process.argv[1]) : null;
+    } catch (e) {
+      entryFile = null;
+    }
+    if (entryFile && entryFile === currentFile) {
+      main();
+    }
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+
+// src/utils/detect_vc_redist_on_windows.ts
+init_cjs_shims();
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+var import_os = __toESM(require("os"), 1);
+init_printer();
+var import_util = require("util");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var DLLS = ["vcruntime140.dll", "vcruntime140_1.dll", "msvcp140.dll"];
+var PATHS = ["C:\\Windows\\System32", "C:\\Windows\\SysWOW64"];
+var REGISTRY_KEYS = [
+  "HKLM\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\X64",
+  "HKLM\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\X86",
+  "HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\X64",
+  "HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\X86"
+];
+function checkDLLs() {
+  return DLLS.every(
+    (dll) => PATHS.some((p) => {
+      try {
+        return import_fs.default.existsSync(import_path.default.join(p, dll));
+      } catch {
+        return false;
+      }
+    })
+  );
+}
+function checkRegistry() {
+  if (import_os.default.platform() !== "win32") return false;
+  try {
+    for (const key of REGISTRY_KEYS) {
+      const cmd = `reg query "${key}" /v Installed 2>nul`;
+      const result = (0, import_child_process.execSync)(cmd, { encoding: "utf8" });
+      if (result.includes("0x1")) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function getVCRedistVersion() {
+  if (import_os.default.platform() !== "win32") return null;
+  try {
+    for (const key of REGISTRY_KEYS) {
+      const cmd = `reg query "${key}" /v Version 2>nul`;
+      const result = (0, import_child_process.execSync)(cmd, { encoding: "utf8" });
+      const match = result.match(/Version\s+REG_SZ\s+(\S+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function hasVCRedist() {
+  if (import_os.default.platform() !== "win32") {
+    return true;
+  }
+  if (checkRegistry()) {
+    return true;
+  }
+  if (checkDLLs()) {
+    return true;
+  }
+  return false;
+}
+function getVCRedistStatus() {
+  if (import_os.default.platform() !== "win32") {
+    return {
+      required: false,
+      installed: true,
+      version: null,
+      method: "non-windows"
+    };
+  }
+  const registryInstalled = checkRegistry();
+  const dllsPresent = checkDLLs();
+  const version = getVCRedistVersion();
+  return {
+    required: true,
+    installed: registryInstalled || dllsPresent,
+    version,
+    registryCheck: registryInstalled,
+    dllCheck: dllsPresent,
+    method: registryInstalled ? "registry" : dllsPresent ? "dll" : "none"
+  };
+}
+async function openDownloadPage() {
+  if (process.platform !== "win32") {
+    return;
+  }
+  const url = "https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170";
+  const command = `cmd.exe /c start "" "${url}"`;
+  try {
+    await execAsync(command);
+    printer_default.info("\nOpening Microsoft download page in your browser...");
+    printer_default.info(
+      "Please install the Visual C++ Runtime and restart this application.\n"
+    );
+  } catch (err) {
+    printer_default.info("\nUnable to open your browser automatically.");
+    printer_default.info(
+      "Please visit the following page to download the runtime:\n"
+    );
+    printer_default.info(url + "\n");
+  }
+}
+function getVCRedistMessage() {
+  const status = getVCRedistStatus();
+  if (!status.required || status.installed) {
+    return null;
+  }
+  return {
+    error: true,
+    message: "Missing Microsoft Visual C++ Runtime. This application requires the Microsoft Visual C++ Runtime to run on Windows.\nPlease download and install it using the link below, then restart this application.\n"
+  };
+}
+
+// src/index.ts
+init_printer();
+async function verifyAndLoad() {
+  if (process.platform === "win32" && !hasVCRedist()) {
+    const msg = getVCRedistMessage();
+    printer_default.warn(
+      msg?.message ?? "This application requires the Microsoft Visual C++ Runtime on Windows."
+    );
+    await openDownloadPage();
+    process.exit(1);
+  }
+  await Promise.resolve().then(() => (init_main(), main_exports));
+}
+verifyAndLoad().catch((err) => {
+  printer_default.error(`Failed to start CLI:, ${err}`);
+  process.exit(1);
 });