pinggy 0.3.3 → 0.3.4

package/dist/index.js

@@ -1,3853 +1,140 @@
 #!/usr/bin/env node
 import {
-  configureLogger,
-  enablePackageLogging,
-  logger
-} from "./chunk-HUN2MRZO.js";
+  printer_default
+} from "./chunk-T5ESYDJY.js";
 
-// src/tunnel_manager/TunnelManager.ts
-import { pinggy } from "@pinggy/pinggy";
+// src/utils/detect_vc_redist_on_windows.ts
+import fs from "fs";
 import path from "path";
-import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-
-// src/utils/printer.ts
-import pico2 from "picocolors";
-
-// src/tui/spinner/spinner.ts
-import pico from "picocolors";
-var spinners = {
-  dots: {
-    interval: 80,
-    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
-  }
-};
-var currentTimer = null;
-var currentText = "";
-function startSpinner(name = "dots", text = "Loading") {
-  const spinner = spinners[name];
-  let i = 0;
-  currentText = text;
-  if (currentTimer) {
-    clearInterval(currentTimer);
-  }
-  currentTimer = setInterval(() => {
-    const frame = spinner.frames[i = ++i % spinner.frames.length];
-    process.stdout.write(`\r${pico.cyan(frame)} ${text}`);
-  }, spinner.interval);
-  return () => stopSpinner();
-}
-function stopSpinner() {
-  if (currentTimer) {
-    clearInterval(currentTimer);
-    currentTimer = null;
-    process.stdout.write("\r\x1B[K");
-  }
-}
-function stopSpinnerSuccess(message) {
-  if (currentTimer) {
-    clearInterval(currentTimer);
-    currentTimer = null;
-    const finalMessage = message || currentText;
-    process.stdout.write(`\r${pico.green("\u2714")} ${finalMessage}
-`);
-  }
-}
-function stopSpinnerFail(message) {
-  if (currentTimer) {
-    clearInterval(currentTimer);
-    currentTimer = null;
-    const finalMessage = message || currentText;
-    process.stdout.write(`\r${pico.red("\u2716")} ${finalMessage}
-`);
-  }
-}
-
-// src/utils/printer.ts
-var _CLIPrinter = class _CLIPrinter {
-  static isCLIError(err) {
-    return err instanceof Error;
-  }
-  static print(message, ...args) {
-    console.log(message, ...args);
-  }
-  static error(err) {
-    const def = this.errorDefinitions.find((d) => d.match(err));
-    const msg = def.message(err);
-    console.error(pico2.red(pico2.bold("\u2716 Error:")), pico2.red(msg));
-    process.exit(1);
-  }
-  static warn(message) {
-    console.warn(pico2.yellow(pico2.bold("\u26A0 Warning:")), pico2.yellow(message));
-  }
-  static warnTxt(message) {
-    console.warn(pico2.yellow(pico2.bold("\u26A0 Warning:")), pico2.yellow(message));
-  }
-  static success(message) {
-    console.log(pico2.green(pico2.bold(" \u2714 Success:")), pico2.green(message));
-  }
-  static async info(message) {
-    console.log(pico2.blue(message));
-  }
-  static startSpinner(message) {
-    startSpinner("dots", message);
-  }
-  static stopSpinnerSuccess(message) {
-    stopSpinnerSuccess(message);
-  }
-  static stopSpinnerFail(message) {
-    stopSpinnerFail(message);
-  }
-};
-_CLIPrinter.errorDefinitions = [
-  {
-    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION",
-    message: (err) => {
-      const match = /Unknown option '(.+?)'/.exec(err.message);
-      const option = match ? match[1] : "(unknown)";
-      return `Unknown option '${option}'. Please check your command or use pinggy --h for guidance.`;
-    }
-  },
-  {
-    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_MISSING_OPTION_VALUE",
-    message: (err) => `Missing required argument for option '${err.option}'.`
-  },
-  {
-    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE",
-    message: (err) => `Invalid argument'${err.message}'.`
-  },
-  {
-    match: (err) => _CLIPrinter.isCLIError(err) && err.code === "ENOENT",
-    message: (err) => `File or directory not found: ${err.message}`
-  },
-  {
-    match: () => true,
-    // fallback
-    message: (err) => _CLIPrinter.isCLIError(err) ? err.message : String(err)
-  }
+import { exec, execSync } from "child_process";
+import os from "os";
+import { promisify } from "util";
+var execAsync = promisify(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"
 ];
-var CLIPrinter = _CLIPrinter;
-var printer_default = CLIPrinter;
-
-// src/utils/util.ts
-import { createRequire } from "module";
-import { randomUUID } from "crypto";
-function getRandomId() {
-  return randomUUID();
-}
-function isValidPort(p) {
-  return Number.isInteger(p) && p > 0 && p < 65536;
-}
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-function getVersion() {
-  return pkg.version ?? "";
-}
-
-// src/tunnel_manager/TunnelManager.ts
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var TunnelManager = class _TunnelManager {
-  constructor() {
-    this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
-    this.tunnelsByConfigId = /* @__PURE__ */ new Map();
-    this.tunnelStats = /* @__PURE__ */ new Map();
-    this.tunnelStatsListeners = /* @__PURE__ */ new Map();
-    this.tunnelErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
-    this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
-    this.tunnelStartListeners = /* @__PURE__ */ new Map();
-  }
-  static getInstance() {
-    if (!_TunnelManager.instance) {
-      _TunnelManager.instance = new _TunnelManager();
-    }
-    return _TunnelManager.instance;
-  }
-  /**
-   * Creates a new managed tunnel instance with the given configuration.
-   * Builds the config with forwarding rules and creates the tunnel instance.
-   * 
-   * @param config - The tunnel configuration options
-   * @param config.configid - Unique identifier for the tunnel configuration
-   * @param config.tunnelid - Optional custom tunnel identifier. If not provided, a random UUID will be generated
-   * @param config.additionalForwarding - Optional array of additional forwarding configurations
-   * 
-   * @throws {Error} When configId is invalid or empty
-   * @throws {Error} When a tunnel with the given configId already exists
-   * 
-   * @returns {ManagedTunnel} A new managed tunnel instance containing the tunnel details,
-   *                          status information, and statistics
-   */
-  async createTunnel(config) {
-    const { configid, additionalForwarding, tunnelName } = config;
-    if (configid === void 0 || configid.trim().length === 0) {
-      throw new Error(`Invalid configId: "${configid}"`);
-    }
-    if (this.tunnelsByConfigId.has(configid)) {
-      throw new Error(`Tunnel with configId "${configid}" already exists`);
-    }
-    const tunnelid = config.tunnelid || getRandomId();
-    const configWithForwarding = this.buildPinggyConfig(config, additionalForwarding);
-    return this._createTunnelWithProcessedConfig({
-      configid,
-      tunnelid,
-      tunnelName,
-      originalConfig: config,
-      configWithForwarding,
-      additionalForwarding,
-      serve: config.serve,
-      autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
-    });
-  }
-  /**
-   * Internal method to create a tunnel with an already-processed configuration.
-   * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
-   * 
-   * @param params - Configuration parameters with already-processed forwarding rules
-   * @returns The created ManagedTunnel instance
-   * @private
-   */
-  async _createTunnelWithProcessedConfig(params) {
-    let instance;
-    try {
-      instance = await pinggy.createTunnel(params.configWithForwarding);
-    } catch (e) {
-      logger.error("Error creating tunnel instance:", e);
-      throw e;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const managed = {
-      tunnelid: params.tunnelid,
-      configid: params.configid,
-      tunnelName: params.tunnelName,
-      instance,
-      tunnelConfig: params.originalConfig,
-      configWithForwarding: params.configWithForwarding,
-      additionalForwarding: params.additionalForwarding,
-      serve: params.serve,
-      warnings: [],
-      isStopped: false,
-      createdAt: now,
-      startedAt: null,
-      stoppedAt: null,
-      autoReconnect: params.autoReconnect
-    };
-    instance.setTunnelEstablishedCallback(({}) => {
-      managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    });
-    this.setupStatsCallback(params.tunnelid, managed);
-    this.setupErrorCallback(params.tunnelid, managed);
-    this.setupDisconnectCallback(params.tunnelid, managed);
-    this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
-    this.tunnelsByTunnelId.set(params.tunnelid, managed);
-    this.tunnelsByConfigId.set(params.configid, managed);
-    logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
-    return managed;
-  }
-  /**
-   * Builds the Pinggy configuration by merging the default forwarding rule
-   * with additional forwarding rules from additionalForwarding array.
-   * 
-   * @param config - The base Pinggy configuration
-   * @param additionalForwarding - Optional array of additional forwarding rules
-   * @returns Modified PinggyOptions 
-   */
-  buildPinggyConfig(config, additionalForwarding) {
-    const forwardingRules = [];
-    if (config.forwarding) {
-      forwardingRules.push({
-        type: config.tunnelType && config.tunnelType[0] || "http",
-        address: config.forwarding
-      });
-    }
-    if (Array.isArray(additionalForwarding) && additionalForwarding.length > 0) {
-      for (const rule of additionalForwarding) {
-        if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
-          const forwardingRule = {
-            type: rule.protocol,
-            // In Future we can make this dynamic based on user input
-            address: `${rule.localDomain}:${rule.localPort}`,
-            listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain
-          };
-          forwardingRules.push(forwardingRule);
-        }
-      }
-    }
-    return {
-      ...config,
-      forwarding: forwardingRules.length > 0 ? forwardingRules : config.forwarding
-    };
-  }
-  /**
-   * Start a tunnel that was created but not yet started
-   */
-  async startTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
-    logger.info("Starting tunnel", { tunnelId });
-    let urls;
-    try {
-      urls = await managed.instance.start();
-    } catch (error) {
-      logger.error("Failed to start tunnel", { tunnelId, error });
-      throw error;
-    }
-    logger.info("Tunnel started", { tunnelId, urls });
-    if (managed.serve) {
-      this.startStaticFileServer(managed);
-    }
-    try {
-      const startListeners = this.tunnelStartListeners.get(tunnelId);
-      if (startListeners) {
-        for (const [id, listener] of startListeners) {
-          try {
-            listener(tunnelId, urls);
-          } catch (err) {
-            logger.debug("Error in start-listener callback", { listenerId: id, tunnelId, err });
-          }
-        }
-      }
-    } catch (e) {
-      logger.warn("Failed to notify start listeners", { tunnelId, e });
-    }
-    return urls;
-  }
-  /**
-   * Stops a running tunnel and updates its status.
-   *
-   * @param tunnelId - The unique identifier of the tunnel to stop
-   * @throws {Error} If the tunnel with the given tunnelId is not found
-   * @remarks
-   * - Clears the tunnel's remote URLs
-   * - Updates the tunnel's state to Exited if stopped successfully
-   * - Logs the stop operation with tunnelId and configId
-   */
-  stopTunnel(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-    logger.info("Stopping tunnel", { tunnelId, configId: managed.configid });
-    try {
-      managed.instance.stop();
-      if (managed.serveWorker) {
-        logger.info("terminating serveWorker");
-        managed.serveWorker.terminate();
-      }
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelStats.delete(tunnelId);
-      this.tunnelStatsListeners.delete(tunnelId);
-      this.tunnelErrorListeners.delete(tunnelId);
-      this.tunnelDisconnectListeners.delete(tunnelId);
-      this.tunnelWorkerErrorListeners.delete(tunnelId);
-      this.tunnelStartListeners.delete(tunnelId);
-      managed.serveWorker = null;
-      managed.warnings = managed.warnings ?? [];
-      managed.isStopped = true;
-      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-      logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
-      return { configid: managed.configid, tunnelid: managed.tunnelid };
-    } catch (error) {
-      logger.error("Failed to stop tunnel", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all public URLs for a tunnel
-   */
-  async getTunnelUrls(tunnelId) {
-    try {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed || managed.isStopped) {
-        logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
-        return [];
-      }
-      const urls = await managed.instance.urls();
-      logger.debug("Queried tunnel URLs", { tunnelId, urls });
-      return urls;
-    } catch (error) {
-      logger.error("Error fetching tunnel URLs", { tunnelId, error });
-      throw error;
-    }
-  }
-  /**
-   * Get all TunnelStatus currently managed by this TunnelManager
-   * @returns An array of all TunnelStatus objects
-   */
-  async getAllTunnels() {
-    try {
-      const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
-        return {
-          tunnelid: tunnel.tunnelid,
-          configid: tunnel.configid,
-          tunnelName: tunnel.tunnelName,
-          tunnelConfig: tunnel.tunnelConfig,
-          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
-          additionalForwarding: tunnel.additionalForwarding,
-          serve: tunnel.serve
-        };
-      }));
-      return tunnelList;
-    } catch (err) {
-      logger.error("Error fetching tunnels", { error: err });
-      return [];
-    }
-  }
-  /**
-   * Get status of a tunnel
-   */
-  async getTunnelStatus(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (managed.isStopped) {
-      return "exited";
-    }
-    const status = await managed.instance.getStatus();
-    logger.debug("Queried tunnel status", { tunnelId, status });
-    return status;
-  }
-  /**
-   * Stop all tunnels
-   */
-  stopAllTunnels() {
-    for (const { instance } of this.tunnelsByTunnelId.values()) {
-      try {
-        instance.stop();
-      } catch (e) {
-        logger.warn("Error stopping tunnel instance", e);
-      }
-    }
-    this.tunnelsByTunnelId.clear();
-    this.tunnelsByConfigId.clear();
-    this.tunnelStats.clear();
-    this.tunnelStatsListeners.clear();
-    logger.info("All tunnels stopped and cleared");
-  }
-  /**
-   * Remove a stopped tunnel's records so it will no longer be returned by list methods.
-   * 
-   *
-   * @param tunnelId - the tunnel id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByTunnelId(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel", { tunnelId });
-      return false;
-    }
-    if (!managed.isStopped) {
-      logger.warn("Attempted to remove tunnel that is not stopped", { tunnelId });
-      return false;
-    }
-    this._cleanupTunnelRecords(managed);
-    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configid });
-    return true;
-  }
-  /**
-   * Remove a stopped tunnel by its config id.
-   * @param configId - the config id to remove
-   * @returns true if the record was removed, false otherwise
-   */
-  removeStoppedTunnelByConfigId(configId) {
-    const managed = this.tunnelsByConfigId.get(configId);
-    if (!managed) {
-      logger.debug("Attempted to remove non-existent tunnel by configId", { configId });
-      return false;
-    }
-    return this.removeStoppedTunnelByTunnelId(managed.tunnelid);
-  }
-  _cleanupTunnelRecords(managed) {
-    if (!managed.isStopped) {
-      throw new Error(`Active tunnel "${managed.tunnelid}" cannot be removed`);
-    }
-    try {
-      if (managed.serveWorker) {
-        managed.serveWorker = null;
-      }
-      this.tunnelStats.delete(managed.tunnelid);
-      this.tunnelStatsListeners.delete(managed.tunnelid);
-      this.tunnelErrorListeners.delete(managed.tunnelid);
-      this.tunnelDisconnectListeners.delete(managed.tunnelid);
-      this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
-      this.tunnelStartListeners.delete(managed.tunnelid);
-      this.tunnelsByTunnelId.delete(managed.tunnelid);
-      this.tunnelsByConfigId.delete(managed.configid);
-    } catch (e) {
-      logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
-    }
-  }
-  /**
-   * Get tunnel instance by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel instance
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  getTunnelInstance(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) throw new Error(`Tunnel "${configId}" not found`);
-      return managed.instance;
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-      return managed.instance;
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Get tunnel config by either configId or tunnelId
-   * @param configId - The configuration ID of the tunnel
-   * @param tunnelId - The tunnel ID
-   * @returns The tunnel config
-   * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
-   */
-  async getTunnelConfig(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) {
-        throw new Error(`Tunnel with configId "${configId}" not found`);
-      }
-      return managed.instance.getConfig();
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) {
-        throw new Error(`Tunnel with tunnelId "${tunnelId}" not found`);
-      }
-      return managed.instance.getConfig();
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  /**
-   * Restarts a tunnel with its current configuration.
-   * This function will stop the tunnel if it's running and start it again.
-   * All configurations including additional forwarding rules are preserved.
-   */
-  async restartTunnel(tunnelid) {
-    const existingTunnel = this.tunnelsByTunnelId.get(tunnelid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel "${tunnelid}" not found`);
-    }
-    logger.info("Initiating tunnel restart", {
-      tunnelId: tunnelid,
-      configId: existingTunnel.configid
-    });
-    try {
-      const tunnelName = existingTunnel.tunnelName;
-      const currentConfigId = existingTunnel.configid;
-      const currentConfig = existingTunnel.tunnelConfig;
-      const configWithForwarding = existingTunnel.configWithForwarding;
-      const additionalForwarding = existingTunnel.additionalForwarding;
-      const currentServe = existingTunnel.serve;
-      const autoReconnect = existingTunnel.autoReconnect || false;
-      this.tunnelsByTunnelId.delete(tunnelid);
-      this.tunnelsByConfigId.delete(existingTunnel.configid);
-      this.tunnelStats.delete(tunnelid);
-      this.tunnelStatsListeners.delete(tunnelid);
-      this.tunnelErrorListeners.delete(tunnelid);
-      this.tunnelDisconnectListeners.delete(tunnelid);
-      this.tunnelWorkerErrorListeners.delete(tunnelid);
-      this.tunnelStartListeners.delete(tunnelid);
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid: currentConfigId,
-        tunnelid,
-        tunnelName,
-        originalConfig: currentConfig,
-        configWithForwarding,
-        additionalForwarding,
-        serve: currentServe,
-        autoReconnect
-      });
-      if (existingTunnel.createdAt) {
-        newTunnel.createdAt = existingTunnel.createdAt;
-      }
-      await this.startTunnel(newTunnel.tunnelid);
-    } catch (error) {
-      logger.error("Failed to restart tunnel", {
-        tunnelid,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw new Error(`Failed to restart tunnel: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * Updates the configuration of an existing tunnel.
-   * 
-   * This method handles the process of updating a tunnel's configuration while preserving
-   * its state. If the tunnel is running, it will be stopped, updated, and restarted.
-   * In case of failure, it attempts to restore the original configuration.
-   * 
-   * @param newConfig - The new configuration to apply, including configid and optional additional forwarding
-   * 
-   * @returns Promise resolving to the updated ManagedTunnel
-   * @throws Error if the tunnel is not found or if the update process fails
-   */
-  async updateConfig(newConfig) {
-    const { configid, tunnelName: newTunnelName, additionalForwarding } = newConfig;
-    if (!configid || configid.trim().length === 0) {
-      throw new Error(`Invalid configid: "${configid}"`);
-    }
-    const existingTunnel = this.tunnelsByConfigId.get(configid);
-    if (!existingTunnel) {
-      throw new Error(`Tunnel with config id "${configid}" not found`);
-    }
-    const isStopped = existingTunnel.isStopped;
-    const currentTunnelConfig = existingTunnel.tunnelConfig;
-    const currentConfigWithForwarding = existingTunnel.configWithForwarding;
-    const currentTunnelId = existingTunnel.tunnelid;
-    const currentTunnelConfigId = existingTunnel.configid;
-    const currentAdditionalForwarding = existingTunnel.additionalForwarding;
-    const currentTunnelName = existingTunnel.tunnelName;
-    const currentServe = existingTunnel.serve;
-    const currentAutoReconnect = existingTunnel.autoReconnect || false;
-    try {
-      if (!isStopped) {
-        existingTunnel.instance.stop();
-      }
-      this.tunnelsByTunnelId.delete(currentTunnelId);
-      this.tunnelsByConfigId.delete(currentTunnelConfigId);
-      const mergedBaseConfig = {
-        ...newConfig,
-        configid,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
-      };
-      const newConfigWithForwarding = this.buildPinggyConfig(
-        mergedBaseConfig,
-        additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
-      );
-      const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid,
-        tunnelid: currentTunnelId,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        originalConfig: mergedBaseConfig,
-        configWithForwarding: newConfigWithForwarding,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
-        autoReconnect: currentAutoReconnect
-      });
-      if (!isStopped) {
-        await this.startTunnel(newTunnel.tunnelid);
-      }
-      logger.info("Tunnel configuration updated", {
-        tunnelId: newTunnel.tunnelid,
-        configId: newTunnel.configid,
-        isStopped
-      });
-      return newTunnel;
-    } catch (error) {
-      logger.error("Error updating tunnel configuration", {
-        configId: configid,
-        error: error instanceof Error ? error.message : String(error)
-      });
+function checkDLLs() {
+  return DLLS.every(
+    (dll) => PATHS.some((p) => {
       try {
-        const originalTunnel = await this._createTunnelWithProcessedConfig({
-          configid: currentTunnelConfigId,
-          tunnelid: currentTunnelId,
-          tunnelName: currentTunnelName,
-          originalConfig: currentTunnelConfig,
-          configWithForwarding: currentConfigWithForwarding,
-          additionalForwarding: currentAdditionalForwarding,
-          serve: currentServe,
-          autoReconnect: currentAutoReconnect
-        });
-        if (!isStopped) {
-          await this.startTunnel(originalTunnel.tunnelid);
-        }
-        logger.warn("Restored original tunnel configuration after update failure", {
-          currentTunnelId,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      } catch (restoreError) {
-        logger.error("Failed to restore original tunnel configuration", {
-          currentTunnelId,
-          error: restoreError instanceof Error ? restoreError.message : "Unknown error"
-        });
-      }
-      throw error;
-    }
-  }
-  /**
-   * Retrieve the ManagedTunnel object by either configId or tunnelId.
-   * Throws an error if neither id is provided or the tunnel is not found.
-   */
-  getManagedTunnel(configId, tunnelId) {
-    if (configId) {
-      const managed = this.tunnelsByConfigId.get(configId);
-      if (!managed) throw new Error(`Tunnel "${configId}" not found`);
-      return managed;
-    }
-    if (tunnelId) {
-      const managed = this.tunnelsByTunnelId.get(tunnelId);
-      if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
-      return managed;
-    }
-    throw new Error(`Either configId or tunnelId must be provided`);
-  }
-  async getTunnelGreetMessage(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching greet message`);
-      return null;
-    }
-    try {
-      if (managed.isStopped) {
-        return null;
-      }
-      const messages = await managed.instance.getGreetMessage();
-      if (Array.isArray(messages)) {
-        return messages.join(" ");
-      }
-      return messages ?? null;
-    } catch (e) {
-      logger.error(
-        `Error fetching greet message for tunnel "${tunnelId}": ${e instanceof Error ? e.message : String(e)}`
-      );
-      return null;
-    }
-  }
-  getTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    return stats || null;
-  }
-  getLatestTunnelStats(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      return null;
-    }
-    const stats = this.tunnelStats.get(tunnelId);
-    if (stats && stats.length > 0) {
-      return stats[stats.length - 1];
-    }
-    return null;
-  }
-  /**
-   * Registers a listener function to receive tunnel statistics updates.
-   * The listener will be called whenever any tunnel's stats are updated.
-   * 
-   * @param tunnelId - The tunnel ID to listen to stats for
-   * @param listener - Function that receives tunnelId and stats when updates occur
-   * @returns A unique listener ID that can be used to deregister the listener and tunnelId
-   * 
-   * @throws {Error} When the specified tunnelId does not exist
-   */
-  async registerStatsListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStatsListeners.has(tunnelId)) {
-      this.tunnelStatsListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    tunnelListeners.set(listenerId, listener);
-    logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
-    return [listenerId, tunnelId];
-  }
-  async registerErrorListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelErrorListeners.has(tunnelId)) {
-      this.tunnelErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelErrorListeners = this.tunnelErrorListeners.get(tunnelId);
-    tunnelErrorListeners.set(listenerId, listener);
-    logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerDisconnectListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelDisconnectListeners.has(tunnelId)) {
-      this.tunnelDisconnectListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelDisconnectListeners = this.tunnelDisconnectListeners.get(tunnelId);
-    tunnelDisconnectListeners.set(listenerId, listener);
-    logger.info("Disconnect listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  async registerWorkerErrorListner(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelWorkerErrorListeners.has(tunnelId)) {
-      this.tunnelWorkerErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const tunnelWorkerErrorListner = this.tunnelWorkerErrorListeners.get(tunnelId);
-    tunnelWorkerErrorListner?.set(listenerId, listener);
-    logger.info("TunnelWorker error listener registered for tunnel", { tunnelId, listenerId });
-  }
-  async registerStartListener(tunnelId, listener) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      throw new Error(`Tunnel "${tunnelId}" not found`);
-    }
-    if (!this.tunnelStartListeners.has(tunnelId)) {
-      this.tunnelStartListeners.set(tunnelId, /* @__PURE__ */ new Map());
-    }
-    const listenerId = getRandomId();
-    const listeners = this.tunnelStartListeners.get(tunnelId);
-    listeners.set(listenerId, listener);
-    logger.info("Start listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
-  }
-  /**
-   * Removes a previously registered stats listener.
-   * 
-  * @param tunnelId - The tunnel ID the listener was registered for
-  * @param listenerId - The unique ID returned when the listener was registered
-  */
-  deregisterStatsListener(tunnelId, listenerId) {
-    const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-    if (!tunnelListeners) {
-      logger.warn("No listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = tunnelListeners.delete(listenerId);
-    if (removed) {
-      logger.info("Stats listener deregistered", { tunnelId, listenerId });
-      if (tunnelListeners.size === 0) {
-        this.tunnelStatsListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent stats listener", { tunnelId, listenerId });
-    }
-  }
-  deregisterErrorListener(tunnelId, listenerId) {
-    const listeners = this.tunnelErrorListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No error listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Error listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelErrorListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
-    }
-  }
-  deregisterDisconnectListener(tunnelId, listenerId) {
-    const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-    if (!listeners) {
-      logger.warn("No disconnect listeners found for tunnel", { tunnelId });
-      return;
-    }
-    const removed = listeners.delete(listenerId);
-    if (removed) {
-      logger.info("Disconnect listener deregistered", { tunnelId, listenerId });
-      if (listeners.size === 0) {
-        this.tunnelDisconnectListeners.delete(tunnelId);
-      }
-    } else {
-      logger.warn("Attempted to deregister non-existent disconnect listener", { tunnelId, listenerId });
-    }
-  }
-  async getLocalserverTlsInfo(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching local server TLS info`);
-      return false;
-    }
-    try {
-      if (managed.isStopped) {
+        return fs.existsSync(path.join(p, dll));
+      } catch {
         return false;
       }
-      const tlsInfo = await managed.instance.getLocalServerTls();
-      if (tlsInfo) {
-        return tlsInfo;
-      }
-      return false;
-    } catch (e) {
-      logger.error(`Error fetching TLS info for tunnel "${tunnelId}": ${e instanceof Error ? e.message : e}`);
-      return false;
-    }
-  }
-  /**
-   * Sets up the stats callback for a tunnel during creation.
-   * This callback will update stored stats and notify all registered listeners.
-   */
-  setupStatsCallback(tunnelId, managed) {
-    try {
-      const callback = (usage) => {
-        this.updateStats(tunnelId, usage);
-      };
-      managed.instance.setUsageUpdateCallback(callback);
-      logger.debug("Stats callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up stats callback", { tunnelId, error });
-    }
-  }
-  notifyErrorListeners(tunnelId, errorMsg, isFatal) {
-    try {
-      const listeners = this.tunnelErrorListeners.get(tunnelId);
-      if (!listeners) return;
-      for (const [id, listener] of listeners) {
-        try {
-          listener(tunnelId, errorMsg, isFatal);
-        } catch (err) {
-          logger.debug("Error in error-listener callback", { listenerId: id, tunnelId, err });
-        }
-      }
-    } catch (err) {
-      logger.debug("Failed to notify error listeners", { tunnelId, err });
-    }
-  }
-  setupErrorCallback(tunnelId, managed) {
-    try {
-      const callback = ({ errorNo, error, recoverable }) => {
-        try {
-          const msg = typeof error === "string" ? error : String(error);
-          const isFatal = true;
-          logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
-          this.notifyErrorListeners(tunnelId, msg, isFatal);
-        } catch (e) {
-          logger.warn("Error handling tunnel error callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setTunnelErrorCallback(callback);
-      logger.debug("Error callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up error callback", { tunnelId, error });
-    }
-  }
-  setupDisconnectCallback(tunnelId, managed) {
-    try {
-      const callback = ({ error, messages }) => {
-        try {
-          logger.debug("Tunnel disconnected", { tunnelId, error, messages });
-          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
-          if (managedTunnel) {
-            managedTunnel.isStopped = true;
-            managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
-          }
-          if (managedTunnel && managedTunnel.autoReconnect) {
-            logger.info("Auto-reconnecting tunnel", { tunnelId });
-            setTimeout(async () => {
-              try {
-                await this.restartTunnel(tunnelId);
-                logger.info("Tunnel auto-reconnected successfully", { tunnelId });
-              } catch (e) {
-                logger.error("Failed to auto-reconnect tunnel", { tunnelId, e });
-              }
-            }, 1e4);
-          }
-          const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-          if (!listeners) return;
-          for (const [id, listener] of listeners) {
-            try {
-              listener(tunnelId, error, messages);
-            } catch (err) {
-              logger.debug("Error in disconnect-listener callback", { listenerId: id, tunnelId, err });
-            }
-          }
-        } catch (e) {
-          logger.warn("Error handling tunnel disconnect callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setTunnelDisconnectedCallback(callback);
-      logger.debug("Disconnect callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to set up disconnect callback", { tunnelId, error });
-    }
-  }
-  setUpTunnelWorkerErrorCallback(tunnelId, managed) {
-    try {
-      const callback = (error) => {
-        try {
-          logger.debug("Error in Tunnel Worker", { tunnelId, errorMessage: error.message });
-          const listeners = this.tunnelWorkerErrorListeners.get(tunnelId);
-          if (!listeners) return;
-          for (const [id, listener] of listeners) {
-            try {
-              listener(tunnelId, error);
-            } catch (err) {
-              logger.debug("Error in worker-error-listener callback", { listenerId: id, tunnelId, err });
-            }
-          }
-        } catch (e) {
-          logger.warn("Error handling tunnel worker error callback", { tunnelId, e });
-        }
-      };
-      managed.instance.setWorkerErrorCallback(callback);
-      logger.debug("Disconnect callback set up for tunnel", { tunnelId });
-    } catch (error) {
-      logger.warn("Failed to setup tunnel worker error callback");
-    }
-  }
-  /**
-   * Updates the stored stats for a tunnel and notifies all registered listeners.
-   */
-  updateStats(tunnelId, rawUsage) {
-    try {
-      const normalizedStats = this.normalizeStats(rawUsage);
-      const existingStats = this.tunnelStats.get(tunnelId) || [];
-      const updatedStats = [...existingStats, normalizedStats];
-      this.tunnelStats.set(tunnelId, updatedStats);
-      const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
-      if (tunnelListeners) {
-        for (const [listenerId, listener] of tunnelListeners) {
-          try {
-            listener(tunnelId, normalizedStats);
-          } catch (error) {
-            logger.warn("Error in stats listener callback", { listenerId, tunnelId, error });
-          }
-        }
-      }
-      logger.debug("Stats updated and listeners notified", {
-        tunnelId,
-        listenersCount: tunnelListeners?.size || 0
-      });
-    } catch (error) {
-      logger.warn("Error updating stats", { tunnelId, error });
-    }
-  }
-  /**
-   * Normalizes raw usage data from the SDK into a consistent TunnelStats format.
-   */
-  normalizeStats(rawStats) {
-    const elapsed = this.parseNumber(rawStats.elapsedTime ?? 0);
-    const liveConns = this.parseNumber(rawStats.numLiveConnections ?? 0);
-    const totalConns = this.parseNumber(rawStats.numTotalConnections ?? 0);
-    const reqBytes = this.parseNumber(rawStats.numTotalReqBytes ?? 0);
-    const resBytes = this.parseNumber(rawStats.numTotalResBytes ?? 0);
-    const txBytes = this.parseNumber(rawStats.numTotalTxBytes ?? 0);
-    return {
-      elapsedTime: elapsed,
-      numLiveConnections: liveConns,
-      numTotalConnections: totalConns,
-      numTotalReqBytes: reqBytes,
-      numTotalResBytes: resBytes,
-      numTotalTxBytes: txBytes
-    };
-  }
-  parseNumber(value) {
-    const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
-    return isNaN(parsed) ? 0 : parsed;
-  }
-  startStaticFileServer(managed) {
-    try {
-      const __filename3 = fileURLToPath(import.meta.url);
-      const __dirname3 = path.dirname(__filename3);
-      const fileServerWorkerPath = path.join(__dirname3, "workers", "file_serve_worker.cjs");
-      const staticServerWorker = new Worker(fileServerWorkerPath, {
-        workerData: {
-          dir: managed.serve,
-          port: managed.tunnelConfig?.forwarding
-        }
-      });
-      staticServerWorker.on("message", (msg) => {
-        switch (msg.type) {
-          case "started":
-            logger.info("Static file server started", { dir: managed.serve });
-            break;
-          case "warning":
-            if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
-              managed.warnings = managed.warnings ?? [];
-              managed.warnings.push({ code: msg.code, message: msg.message });
-            }
-            printer_default.warn(msg.message);
-            break;
-          case "error":
-            managed.warnings = managed.warnings ?? [];
-            managed.warnings.push({
-              code: "UNKNOWN_WARNING",
-              message: msg.message
-            });
-            break;
-        }
-      });
-      managed.serveWorker = staticServerWorker;
-    } catch (error) {
-      logger.error("Error starting static file server", error);
-    }
-  }
-};
-
-// src/cli/options.ts
-var cliOptions = {
-  // SSH-like options
-  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() {
-  console.log("\nPinggy CLI Tool - Create secure tunnels to your localhost.");
-  console.log("\nUsage:");
-  console.log("   pinggy [options] -l <port>\n");
-  console.log("Options:");
-  for (const [key, value] of Object.entries(cliOptions)) {
-    if (value.hidden) continue;
-    const short = "short" in value && value.short ? `-${value.short}, ` : "    ";
-    const optType = value.type === "boolean" ? "" : "<value>";
-    console.log(`  ${short}--${key.padEnd(17)} ${optType.padEnd(8)} ${value.description}`);
-  }
-  console.log("\nExtended options :");
-  console.log("  x:https                 Enforce HTTPS only (redirect HTTP to HTTPS)");
-  console.log("  x:noreverseproxy        Disable built-in reverse-proxy header injection");
-  console.log("  x:localservertls:host   Connect to local HTTPS server with SNI");
-  console.log("  x:passpreflight         Pass CORS preflight requests unchanged");
-  console.log("  a:Key:Val               Add header");
-  console.log("  u:Key:Val               Update header");
-  console.log("  r:Key                   Remove header");
-  console.log("  b:user:pass             Basic auth");
-  console.log("  k:BEARER                Bearer token");
-  console.log("  w:192.168.1.0/24        IP whitelist (CIDR)");
-  console.log("\nExamples (User-friendly):");
-  console.log("  pinggy -l 3000                           # HTTP(S) tunnel to localhost port 3000");
-  console.log("  pinggy --type tcp -l 22                  # TCP tunnel for SSH (port 22)");
-  console.log("  pinggy -l 8080 -d 4300                   # HTTP tunnel to port 8080 with debugger running at localhost:4300");
-  console.log("  pinggy --token mytoken -l 3000           # Authenticated tunnel");
-  console.log("  pinggy x:https x:xff -l https://localhost:8443  # HTTPS-only + XFF");
-  console.log("  pinggy w:192.168.1.0/24 -l 8080          # IP whitelist restriction");
-  console.log("\nExamples (SSH-style):");
-  console.log("  pinggy -R0:localhost:3000                        # Basic HTTP tunnel");
-  console.log("  pinggy --type tcp -R0:localhost:22               # TCP tunnel for SSH");
-  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");
-}
-
-// 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
-};
-
-// src/cli/extendedOptions.ts
-import { isIP } from "net";
-function parseExtendedOptions(options, config) {
-  if (!options) return;
-  for (const opt of options) {
-    const [key, value] = opt.replace(/^"|"$/g, "").split(/:(.+)/).filter(Boolean);
-    switch (key) {
-      case "x":
-        switch (value) {
-          case "https":
-          case "httpsonly":
-            config.httpsOnly = true;
-            break;
-          case "passpreflight":
-          case "allowpreflight":
-            config.allowPreflight = true;
-            break;
-          case "reverseproxy":
-            config.reverseProxy = false;
-            break;
-          case "xff":
-            config.xForwardedFor = true;
-            break;
-          case "fullurl":
-          case "fullrequesturl":
-            config.originalRequestUrl = true;
-            break;
-          default:
-            printer_default.warn(`Unknown extended option "${key}"`);
-            logger.warn(`Warning: Unknown extended option "${key}"`);
-            break;
-        }
-        break;
-      case "w":
-        if (value) {
-          const ips = value.split(",").map((ip) => ip.trim()).filter(Boolean);
-          const invalidIps = ips.filter((ip) => !(isValidIpV4Cidr(ip) || isValidIpV6Cidr(ip)));
-          if (invalidIps.length > 0) {
-            printer_default.warn(`Invalid IP/CIDR(s) in whitelist: ${invalidIps.join(", ")}`);
-            logger.warn(`Warning: Invalid IP/CIDR(s) in whitelist: ${invalidIps.join(", ")}`);
-          }
-          if (!(invalidIps.length > 0)) {
-            config.ipWhitelist = ips;
-          }
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'w' requires IP(s)`);
-          logger.warn(`Warning: Extended option "${opt}" for 'w' requires IP(s)`);
-        }
-        break;
-      case "k":
-        if (!config.bearerTokenAuth) config.bearerTokenAuth = [];
-        if (value) {
-          config.bearerTokenAuth.push(value);
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'k' requires a value`);
-          logger.warn(`Warning: Extended option "${opt}" for 'k' requires a value`);
-        }
-        break;
-      case "b":
-        if (value && value.includes(":")) {
-          const [username, password] = value.split(/:(.+)/);
-          if (!config.basicAuth) config.basicAuth = [];
-          config.basicAuth.push({ username, password });
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'b' requires value in format username:password`);
-          logger.warn(`Warning: Extended option "${opt}" for 'b' requires value in format username:password`);
-        }
-        break;
-      case "a":
-        if (value && value.includes(":")) {
-          const [key2, val] = value.split(/:(.+)/);
-          if (!config.headerModification) config.headerModification = [];
-          config.headerModification.push({ type: "add", key: key2, value: [val] });
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'a' requires key:value`);
-          logger.warn(`Warning: Extended option "${opt}" for 'a' requires key:value`);
-        }
-        break;
-      case "u":
-        if (value && value.includes(":")) {
-          const [key2, val] = value.split(/:(.+)/);
-          if (!config.headerModification) config.headerModification = [];
-          config.headerModification.push({ type: "update", key: key2, value: [val] });
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'u' requires key:value`);
-          logger.warn(`Warning: Extended option "${opt}" for 'u' requires key:value`);
-        }
-        break;
-      case "r":
-        if (value) {
-          if (!config.headerModification) config.headerModification = [];
-          config.headerModification.push({ type: "remove", key: value });
-        } else {
-          printer_default.warn(`Extended option "${opt}" for 'r' requires a key`);
-        }
-        break;
-      default:
-        printer_default.warn(`Unknown extended option "${key}"`);
-        break;
-    }
-  }
+    })
+  );
 }
-function isValidIpV4Cidr(input) {
-  if (input.includes("/")) {
-    const [ip, mask] = input.split("/");
-    if (!ip || !mask) return false;
-    const isIp4 = isIP(ip) === 4;
-    const maskNum = parseInt(mask, 10);
-    const isMaskValid = !isNaN(maskNum) && maskNum >= 0 && maskNum <= 32;
-    return isIp4 && isMaskValid;
-  }
-  return false;
-}
-function isValidIpV6Cidr(input) {
-  if (input.includes("/")) {
-    const [rawIp, mask] = input.split("/");
-    if (!rawIp || !mask) return false;
-    const ip = rawIp.split("%")[0].replace(/^\[|\]$/g, "");
-    const isIp6 = isIP(ip) === 6;
-    const maskNum = parseInt(mask, 10);
-    const isMaskValid = !isNaN(maskNum) && maskNum >= 0 && maskNum <= 128;
-    return isIp6 && isMaskValid;
-  }
-  return false;
-}
-
-// src/cli/buildConfig.ts
-import { TunnelType as TunnelType2 } from "@pinggy/pinggy";
-import fs from "fs";
-import path2 from "path";
-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;
-  let server;
-  let qrCode;
-  if (!str) return { token, type, server, qrCode };
-  if (str.includes("@")) {
-    const [user, domain] = str.split("@", 2);
-    if (domainRegex.test(domain)) {
-      server = domain;
-      const parts = user.split("+");
-      for (const part of parts) {
-        if ([TunnelType2.Http, TunnelType2.Tcp, TunnelType2.Tls, TunnelType2.Udp, TunnelType2.TlsTcp].includes(part.toLowerCase())) {
-          type = part;
-        } else if (part === "force") {
-          token = (token ? token + "+" : "") + part;
-        } else if (part === "qr") {
-          qrCode = true;
-        } else {
-          token = (token ? token + "+" : "") + part;
-        }
+function checkRegistry() {
+  if (os.platform() !== "win32") return false;
+  try {
+    for (const key of REGISTRY_KEYS) {
+      const cmd = `reg query "${key}" /v Installed 2>nul`;
+      const result = execSync(cmd, { encoding: "utf8" });
+      if (result.includes("0x1")) {
+        return true;
       }
     }
-  } else if (domainRegex.test(str)) {
-    server = str;
+  } catch {
   }
-  return { token, type, server, qrCode };
+  return false;
 }
-function parseUsers(positionalArgs, explicitToken) {
-  let token;
-  let server;
-  let type;
-  let forceFlag = false;
-  let qrCode = false;
-  let remaining = [...positionalArgs];
-  if (typeof explicitToken === "string") {
-    const parsed = parseUserAndDomain(explicitToken);
-    if (parsed.server) server = parsed.server;
-    if (parsed.type) type = parsed.type;
-    if (parsed.token) token = parsed.token;
-  }
-  if (remaining.length > 0) {
-    const first = remaining[0];
-    const parsed = parseUserAndDomain(first);
-    if (parsed.server) {
-      server = parsed.server;
-      if (parsed.type) type = parsed.type;
-      if (parsed.token) {
-        if (parsed.token.includes("+")) {
-          const parts = parsed.token.split("+");
-          const tOnly = parts.filter((p) => p !== "force").join("+");
-          if (tOnly) token = tOnly;
-          if (parts.includes("force")) forceFlag = true;
-        } else {
-          token = parsed.token;
-        }
-      }
-      if (parsed.qrCode) {
-        qrCode = true;
+function getVCRedistVersion() {
+  if (os.platform() !== "win32") return null;
+  try {
+    for (const key of REGISTRY_KEYS) {
+      const cmd = `reg query "${key}" /v Version 2>nul`;
+      const result = execSync(cmd, { encoding: "utf8" });
+      const match = result.match(/Version\s+REG_SZ\s+(\S+)/);
+      if (match) {
+        return match[1];
       }
-      remaining = remaining.slice(1);
-    }
-  }
-  return { token, server, type, forceFlag, qrCode, remaining };
-}
-function parseType(finalConfig, values, inferredType) {
-  const t = inferredType || values.type || finalConfig.tunnelType;
-  if (t === TunnelType2.Http || t === TunnelType2.Tcp || t === TunnelType2.Tls || t === TunnelType2.Udp || t === TunnelType2.TlsTcp) {
-    finalConfig.tunnelType = [t];
-  }
-}
-function parseLocalPort(finalConfig, values) {
-  if (typeof values.localport !== "string") return null;
-  let lp = values.localport.trim();
-  let isHttps = false;
-  if (lp.startsWith("https://")) {
-    isHttps = true;
-    lp = lp.replace(/^https:\/\//, "");
-  } else if (lp.startsWith("http://")) {
-    lp = lp.replace(/^http:\/\//, "");
-  }
-  const parts = lp.split(":");
-  if (parts.length === 1) {
-    const port = parseInt(parts[0], 10);
-    if (!Number.isNaN(port) && isValidPort(port)) {
-      finalConfig.forwarding = `localhost:${port}`;
-    } else {
-      return new Error("Invalid local port");
     }
-  } else if (parts.length === 2) {
-    const host = parts[0] || "localhost";
-    const port = parseInt(parts[1], 10);
-    if (!Number.isNaN(port) && isValidPort(port)) {
-      finalConfig.forwarding = `${host}:${port}`;
-    } else {
-      return new Error("Invalid local port. Please use -h option for help.");
-    }
-  } else {
-    return new Error("Invalid --localport format. Please use -h option for help.");
+  } catch {
   }
   return null;
 }
-function removeIPv6Brackets(ip) {
-  if (ip.startsWith("[") && ip.endsWith("]")) {
-    return ip.slice(1, -1);
-  }
-  return ip;
-}
-function ipv6SafeSplitColon(s) {
-  const result = [];
-  let buf = "";
-  const stack = [];
-  for (let i = 0; i < s.length; i++) {
-    const c = s[i];
-    if (c === "[") {
-      stack.push(c);
-    } else if (c === "]" && stack.length > 0) {
-      stack.pop();
-    }
-    if (c === ":" && stack.length === 0) {
-      result.push(buf);
-      buf = "";
-    } else {
-      buf += c;
-    }
+function hasVCRedist() {
+  if (os.platform() !== "win32") {
+    return true;
   }
-  result.push(buf);
-  return result;
-}
-var VALID_PROTOCOLS = ["http", "tcp", "udp", "tls"];
-function parseDefaultForwarding(forwarding) {
-  const parts = ipv6SafeSplitColon(forwarding);
-  if (parts.length === 3) {
-    const remotePort = parseInt(parts[0], 10);
-    const localDomain = removeIPv6Brackets(parts[1] || "localhost");
-    const localPort = parseInt(parts[2], 10);
-    return { remotePort, localDomain, localPort };
+  if (checkRegistry()) {
+    return true;
   }
-  if (parts.length === 4) {
-    const remoteDomain = removeIPv6Brackets(parts[0]);
-    const remotePort = parseInt(parts[1], 10);
-    const localDomain = removeIPv6Brackets(parts[2] || "localhost");
-    const localPort = parseInt(parts[3], 10);
-    return { remoteDomain, remotePort, localDomain, localPort };
+  if (checkDLLs()) {
+    return true;
   }
-  return new Error("forwarding address incorrect");
+  return false;
 }
-function parseAdditionalForwarding(forwarding) {
-  const toPort = (v) => {
-    const n = parseInt(v, 10);
-    return Number.isNaN(n) ? null : n;
-  };
-  const validateDomain = (d) => d && domainRegex.test(d) ? d : null;
-  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");
-    }
-    if (localPort2 === null || !isValidPort(localPort2)) {
-      return new Error("forwarding address incorrect: invalid local port");
-    }
+function getVCRedistStatus() {
+  if (os.platform() !== "win32") {
     return {
-      protocol: "http",
-      remoteDomain,
-      remotePort: 0,
-      localDomain: localDomain2,
-      localPort: localPort2
+      required: false,
+      installed: true,
+      version: null,
+      method: "non-windows"
     };
   }
-  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`);
-  }
-  const localDomain = removeIPv6Brackets(parts[1] || "localhost");
-  const localPort = toPort(parts[2]);
-  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`);
-    }
-  }
+  const registryInstalled = checkRegistry();
+  const dllsPresent = checkDLLs();
+  const version = getVCRedistVersion();
   return {
-    protocol,
-    remoteDomain: remoteDomainRaw,
-    remotePort: remotePortNum,
-    localDomain,
-    localPort
+    required: true,
+    installed: registryInstalled || dllsPresent,
+    version,
+    registryCheck: registryInstalled,
+    dllCheck: dllsPresent,
+    method: registryInstalled ? "registry" : dllsPresent ? "dll" : "none"
   };
 }
-function parseReverseTunnelAddr(finalConfig, values) {
-  const reverseTunnel = values.R;
-  if ((!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) && !values.localport && !finalConfig.forwarding) {
-    return new Error("local port not specified. Please use '-h' option for help.");
-  }
-  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);
-    }
-  }
-  return null;
-}
-function parseLocalTunnelAddr(finalConfig, values) {
-  if (!Array.isArray(values.L) || values.L.length === 0) return null;
-  const firstL = values.L[0];
-  const parts = firstL.split(":");
-  if (parts.length === 3) {
-    const lp = parseInt(parts[2], 10);
-    if (!Number.isNaN(lp) && isValidPort(lp)) {
-      finalConfig.webDebugger = `localhost:${lp}`;
-    } else {
-      return new Error(`Invalid debugger port ${lp}`);
-    }
-  } else {
-    return new Error("Incorrect command line arguments: web debugger address incorrect. Please use '-h' option for help.");
-  }
-}
-function parseDebugger(finalConfig, values) {
-  let dbg = values.debugger;
-  if (typeof dbg !== "string") return;
-  dbg = dbg.startsWith(":") ? dbg.slice(1) : dbg;
-  const d = parseInt(dbg, 10);
-  if (!Number.isNaN(d) && isValidPort(d)) {
-    finalConfig.webDebugger = `localhost:${d}`;
-  } else {
-    logger.error("Invalid debugger port:", dbg);
-    return new Error(`Invalid debugger port ${dbg}. Please use '-h' option for help.`);
+async function openDownloadPage() {
+  if (process.platform !== "win32") {
+    return;
   }
-}
-function parseToken(finalConfig, explicitToken) {
-  if (typeof explicitToken === "string" && explicitToken) {
-    finalConfig.token = explicitToken;
-  }
-}
-function parseArgs(finalConfig, remainingPositionals) {
-  parseExtendedOptions(remainingPositionals, finalConfig);
-}
-function storeJson(config, saveconf) {
-  if (saveconf) {
-    const path3 = saveconf;
-    try {
-      fs.writeFileSync(path3, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
-      logger.info(`Configuration saved to ${path3}`);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger.error("Error loading configuration:", msg);
-    }
-  }
-}
-function loadJsonConfig(config) {
-  const configpath = config["conf"];
-  if (typeof configpath === "string" && configpath.trim().length > 0) {
-    const filepath = path2.resolve(configpath);
-    try {
-      const data = fs.readFileSync(filepath, { encoding: "utf-8" });
-      const json = JSON.parse(data);
-      return json;
-    } catch (err) {
-      logger.error("Error loading configuration:", err);
-    }
+  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");
   }
-  return null;
 }
-function isSaveConfOption(values) {
-  const saveconf = values["saveconf"];
-  if (typeof saveconf === "string" && saveconf.trim().length > 0) {
-    return saveconf;
+function getVCRedistMessage() {
+  const status = getVCRedistStatus();
+  if (!status.required || status.installed) {
+    return null;
   }
-  return null;
-}
-function parseServe(finalConfig, values) {
-  const sv = values.serve;
-  if (typeof sv !== "string" || sv.trim().length === 0) return null;
-  finalConfig.serve = sv;
-  return null;
-}
-async function buildFinalConfig(values, positionals) {
-  let token;
-  let server;
-  let type;
-  let forceFlag = false;
-  let qrCode = false;
-  let finalConfig = new Object();
-  let saveconf = isSaveConfOption(values);
-  const configFromFile = loadJsonConfig(values);
-  const userParse = parseUsers(positionals, values.token);
-  token = userParse.token;
-  server = userParse.server;
-  type = userParse.type;
-  forceFlag = userParse.forceFlag;
-  qrCode = userParse.qrCode;
-  const remainingPositionals = userParse.remaining;
-  const initialTunnel = type || values.type;
-  finalConfig = {
-    ...defaultOptions,
-    ...configFromFile || {},
-    // Apply loaded config on top of defaults
-    configid: getRandomId(),
-    token: token || (configFromFile?.token || (typeof values.token === "string" ? values.token : "")),
-    serverAddress: server || (configFromFile?.serverAddress || defaultOptions.serverAddress),
-    tunnelType: initialTunnel ? [initialTunnel] : configFromFile?.tunnelType || [TunnelType2.Http],
-    NoTUI: values.notui || (configFromFile?.NoTUI || false),
-    qrCode: qrCode || (configFromFile?.qrCode || false),
-    autoReconnect: values.autoreconnect || (configFromFile?.autoReconnect || false)
+  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"
   };
-  parseType(finalConfig, values, type);
-  parseToken(finalConfig, token || values.token);
-  const dbgErr = parseDebugger(finalConfig, values);
-  if (dbgErr instanceof Error) throw dbgErr;
-  const lpErr = parseLocalPort(finalConfig, values);
-  if (lpErr instanceof Error) throw lpErr;
-  const rErr = parseReverseTunnelAddr(finalConfig, values);
-  if (rErr instanceof Error) throw rErr;
-  const lErr = parseLocalTunnelAddr(finalConfig, values);
-  if (lErr instanceof Error) throw lErr;
-  const serveErr = parseServe(finalConfig, values);
-  if (serveErr instanceof Error) throw serveErr;
-  if (forceFlag) finalConfig.force = true;
-  parseArgs(finalConfig, remainingPositionals);
-  storeJson(finalConfig, saveconf);
-  return finalConfig;
 }
 
-// src/remote_management/remoteManagement.ts
-import WebSocket from "ws";
-
-// src/types.ts
-var ErrorCode = {
-  InvalidRequestMethodError: "INVALID_REQUEST_METHOD",
-  InvalidRequestBodyError: "COULD_NOT_READ_BODY",
-  InternalServerError: "INTERNAL_SERVER_ERROR",
-  InvalidBodyFormatError: "INVALID_DATA_FORMAT",
-  ErrorStartingTunnel: "ERROR_STARTING_TUNNEL",
-  TunnelNotFound: "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND",
-  TunnelAlreadyRunningError: "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING",
-  WebsocketUpgradeFailError: "WEBSOCKET_UPGRADE_FAILED",
-  RemoteManagementAlreadyRunning: "REMOTE_MANAGEMENT_ALREADY_RUNNING",
-  RemoteManagementNotRunning: "REMOTE_MANAGEMENT_NOT_RUNNING",
-  RemoteManagementDeserializationFailed: "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED"
-};
-function isErrorResponse(obj) {
-  return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj && typeof obj.message === "string" && Object.values(ErrorCode).includes(obj.code);
-}
-function newErrorResponse(codeOrError, message) {
-  if (typeof codeOrError === "object") {
-    return codeOrError;
+// src/index.ts
+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);
   }
-  return {
-    code: codeOrError,
-    message
-  };
-}
-function NewResponseObject(data) {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(JSON.stringify(data));
-  return {
-    response: bytes,
-    requestid: "",
-    command: "",
-    error: false,
-    errorresponse: {}
-  };
+  await import("./main-CZY6GID4.js");
 }
-function NewErrorResponseObject(errorResponse) {
-  return {
-    response: new Uint8Array(),
-    requestid: "",
-    command: "",
-    error: true,
-    errorresponse: errorResponse
-  };
-}
-function newStatus(tunnelState, errorCode, errorMsg) {
-  let assignedState = tunnelState;
-  if (tunnelState === "live" /* Live */) {
-    assignedState = "running" /* Running */;
-  } else if (tunnelState === "idle" /* New */) {
-    assignedState = "idle" /* New */;
-  } else if (tunnelState === "closed" /* Closed */) {
-    assignedState = "exited" /* Exited */;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    state: assignedState,
-    errorcode: errorCode,
-    errormsg: errorMsg,
-    createdtimestamp: now,
-    starttimestamp: now,
-    endtimestamp: now,
-    warnings: []
-  };
-}
-function newStats() {
-  return {
-    numLiveConnections: 0,
-    numTotalConnections: 0,
-    numTotalReqBytes: 0,
-    numTotalResBytes: 0,
-    numTotalTxBytes: 0,
-    elapsedTime: 0
-  };
-}
-var RemoteManagementStatus = {
-  Connecting: "CONNECTING",
-  Disconnecting: "DISCONNECTING",
-  Reconnecting: "RECONNECTING",
-  Running: "RUNNING",
-  NotRunning: "NOT_RUNNING",
-  Error: "ERROR"
-};
-
-// src/remote_management/remote_schema.ts
-import { TunnelType as TunnelType3 } from "@pinggy/pinggy";
-import { z } from "zod";
-var HeaderModificationSchema = z.object({
-  key: z.string(),
-  value: z.array(z.string()).optional(),
-  type: z.enum(["add", "remove", "update"])
-});
-var AdditionalForwardingSchema = z.object({
-  remoteDomain: z.string().optional(),
-  remotePort: z.number().optional(),
-  localDomain: z.string(),
-  localPort: z.number()
+verifyAndLoad().catch((err) => {
+  printer_default.error(`Failed to start CLI:, ${err}`);
+  process.exit(1);
 });
-var TunnelConfigSchema = z.object({
-  allowPreflight: z.boolean().optional(),
-  // primary key
-  allowpreflight: z.boolean().optional(),
-  // legacy key
-  autoreconnect: z.boolean(),
-  basicauth: z.array(z.object({ username: z.string(), password: z.string() })).nullable(),
-  bearerauth: z.string().nullable(),
-  configid: z.string(),
-  configname: z.string(),
-  greetmsg: z.string().optional(),
-  force: z.boolean(),
-  forwardedhost: z.string(),
-  fullRequestUrl: z.boolean(),
-  headermodification: z.array(HeaderModificationSchema),
-  httpsOnly: z.boolean(),
-  internalwebdebuggerport: z.number(),
-  ipwhitelist: z.array(z.string()).nullable(),
-  localport: z.number(),
-  localsservertls: z.union([z.boolean(), z.string()]),
-  localservertlssni: z.string().nullable(),
-  regioncode: z.string(),
-  noReverseProxy: z.boolean(),
-  serveraddress: z.string(),
-  serverport: z.number(),
-  statusCheckInterval: z.number(),
-  token: z.string(),
-  tunnelTimeout: z.number(),
-  type: z.enum([
-    TunnelType3.Http,
-    TunnelType3.Tcp,
-    TunnelType3.Udp,
-    TunnelType3.Tls,
-    TunnelType3.TlsTcp
-  ]),
-  webdebuggerport: z.number(),
-  xff: z.string(),
-  additionalForwarding: z.array(AdditionalForwardingSchema).optional(),
-  serve: z.string().optional()
-}).superRefine((data, ctx) => {
-  if (data.allowPreflight === void 0 && data.allowpreflight === void 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Either allowPreflight or allowpreflight is required",
-      path: ["allowPreflight"]
-    });
-  }
-}).transform((data) => ({
-  ...data,
-  allowPreflight: data.allowPreflight ?? data.allowpreflight,
-  allowpreflight: data.allowPreflight ?? data.allowpreflight
-}));
-var StartSchema = z.object({
-  tunnelID: z.string().nullable().optional(),
-  tunnelConfig: TunnelConfigSchema
-});
-var StopSchema = z.object({
-  tunnelID: z.string().min(1)
-});
-var GetSchema = StopSchema;
-var RestartSchema = StopSchema;
-var UpdateConfigSchema = z.object({
-  tunnelConfig: TunnelConfigSchema
-});
-function tunnelConfigToPinggyOptions(config) {
-  return {
-    token: config.token || "",
-    serverAddress: config.serveraddress || "free.pinggy.io",
-    forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
-    webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
-    ipWhitelist: config.ipwhitelist || [],
-    basicAuth: config.basicauth ? config.basicauth : [],
-    bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
-    headerModification: config.headermodification,
-    xForwardedFor: !!config.xff,
-    httpsOnly: config.httpsOnly,
-    originalRequestUrl: config.fullRequestUrl,
-    allowPreflight: config.allowPreflight,
-    reverseProxy: config.noReverseProxy,
-    force: config.force,
-    autoReconnect: config.autoreconnect,
-    optional: {
-      sniServerName: config.localservertlssni || ""
-    }
-  };
-}
-function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg, additionalForwarding, serve) {
-  const forwarding = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
-  const parsedForwardedHost = forwarding.split(":").length == 3 ? forwarding.split(":")[1] : forwarding.split(":")[0];
-  const parsedLocalPort = forwarding.split(":").length == 3 ? parseInt(forwarding.split(":")[2], 10) : parseInt(forwarding.split(":")[1], 10);
-  const tunnelType = (Array.isArray(opts.forwarding) ? opts.forwarding[0]?.type : void 0) ?? TunnelType3.Http;
-  const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
-  return {
-    allowPreflight: opts.allowPreflight ?? false,
-    allowpreflight: opts.allowPreflight ?? false,
-    autoreconnect: opts.autoReconnect ?? false,
-    basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : null,
-    bearerauth: parsedTokens.length ? parsedTokens.join(",") : null,
-    configid,
-    configname: configName,
-    greetmsg: greetMsg || "",
-    force: opts.force ?? false,
-    forwardedhost: parsedForwardedHost || "localhost",
-    fullRequestUrl: opts.originalRequestUrl ?? false,
-    headermodification: opts.headerModification || [],
-    //structured list
-    httpsOnly: opts.httpsOnly ?? false,
-    internalwebdebuggerport: 0,
-    ipwhitelist: opts.ipWhitelist ? Array.isArray(opts.ipWhitelist) ? opts.ipWhitelist : JSON.parse(opts.ipWhitelist) : null,
-    localport: parsedLocalPort || 0,
-    localservertlssni: null,
-    regioncode: "",
-    noReverseProxy: opts.reverseProxy ?? false,
-    serveraddress: opts.serverAddress || "free.pinggy.io",
-    serverport: 0,
-    statusCheckInterval: 0,
-    token: opts.token || "",
-    tunnelTimeout: 0,
-    type: tunnelType,
-    webdebuggerport: Number(opts.webDebugger?.split(":")[0]) || 0,
-    xff: opts.xForwardedFor ? "1" : "",
-    localsservertls: localserverTls || false,
-    additionalForwarding: additionalForwarding || [],
-    serve: serve || ""
-  };
-}
-
-// src/remote_management/handler.ts
-import { TunnelType as TunnelType4 } from "@pinggy/pinggy";
-var TunnelOperations = class {
-  constructor() {
-    this.tunnelManager = TunnelManager.getInstance();
-  }
-  buildStatus(tunnelId, state, errorCode) {
-    const status = newStatus(state, errorCode, "");
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
-      if (managed) {
-        status.createdtimestamp = managed.createdAt || "";
-        status.starttimestamp = managed.startedAt || "";
-        status.endtimestamp = managed.stoppedAt || "";
-      }
-    } catch (e) {
-    }
-    return status;
-  }
-  // --- Helper to construct TunnelResponse ---
-  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
-    const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
-      this.tunnelManager.getTunnelStatus(tunnelid),
-      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
-      this.tunnelManager.getLocalserverTlsInfo(tunnelid),
-      this.tunnelManager.getTunnelGreetMessage(tunnelid),
-      this.tunnelManager.getTunnelUrls(tunnelid)
-    ]);
-    return {
-      tunnelid,
-      remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
-      status: this.buildStatus(tunnelid, status, "" /* NoError */),
-      stats
-    };
-  }
-  error(code, err, fallback) {
-    return newErrorResponse({
-      code,
-      message: err instanceof Error ? err.message : fallback
-    });
-  }
-  // --- Operations ---
-  async handleStart(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const additionalForwardingParsed = config.additionalForwarding || [];
-      const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType4.Http],
-        // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: additionalForwardingParsed,
-        serve: config.serve
-      });
-      this.tunnelManager.startTunnel(tunnelid);
-      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
-      return resp;
-    } catch (err) {
-      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-    }
-  }
-  async handleUpdateConfig(config) {
-    try {
-      const opts = tunnelConfigToPinggyOptions(config);
-      const tunnel = await this.tunnelManager.updateConfig({
-        ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType4.Http],
-        // // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: config.additionalForwarding || [],
-        serve: config.serve
-      });
-      if (!tunnel.instance || !tunnel.tunnelConfig)
-        throw new Error("Invalid tunnel state after configuration update");
-      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.additionalForwarding, tunnel.serve);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-    }
-  }
-  async handleList() {
-    try {
-      const tunnels = await this.tunnelManager.getAllTunnels();
-      if (tunnels.length === 0) {
-        return [];
-      }
-      return Promise.all(
-        tunnels.map(async (t) => {
-          const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
-          const [status, tlsInfo, greetMsg] = await Promise.all([
-            this.tunnelManager.getTunnelStatus(t.tunnelid),
-            this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
-            this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
-          ]);
-          const pinggyOptions = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
-          const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
-          return {
-            tunnelid: t.tunnelid,
-            remoteurls: t.remoteurls,
-            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
-            stats: rawStats,
-            tunnelconfig: tunnelConfig
-          };
-        })
-      );
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
-    }
-  }
-  async handleStop(tunnelid) {
-    try {
-      const { configid } = this.tunnelManager.stopTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
-    }
-  }
-  async handleGet(tunnelid) {
-    try {
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
-    }
-  }
-  async handleRestart(tunnelid) {
-    try {
-      await this.tunnelManager.restartTunnel(tunnelid);
-      const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-      if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
-    }
-  }
-  handleRegisterStatsListener(tunnelid, listener) {
-    this.tunnelManager.registerStatsListener(tunnelid, listener);
-  }
-  handleUnregisterStatsListener(tunnelid, listnerId) {
-    this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
-  }
-  handleGetTunnelStats(tunnelid) {
-    try {
-      const stats = this.tunnelManager.getTunnelStats(tunnelid);
-      if (!stats) {
-        return [newStats()];
-      }
-      return stats;
-    } catch (err) {
-      return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel stats");
-    }
-  }
-  handleRegisterDisconnectListener(tunnelid, listener) {
-    this.tunnelManager.registerDisconnectListener(tunnelid, listener);
-  }
-  handleRemoveStoppedTunnelByConfigId(configId) {
-    try {
-      return this.tunnelManager.removeStoppedTunnelByConfigId(configId);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by configId");
-    }
-  }
-  handleRemoveStoppedTunnelByTunnelId(tunnelId) {
-    try {
-      return this.tunnelManager.removeStoppedTunnelByTunnelId(tunnelId);
-    } catch (err) {
-      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by tunnelId");
-    }
-  }
-};
-
-// src/remote_management/websocket_handlers.ts
-import z2 from "zod";
-var WebSocketCommandHandler = class {
-  constructor() {
-    this.tunnelHandler = new TunnelOperations();
-  }
-  safeParse(text) {
-    if (!text) return void 0;
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      logger.warn("Invalid JSON payload", { error: String(e), text });
-      return void 0;
-    }
-  }
-  sendResponse(ws, resp) {
-    const payload = {
-      ...resp,
-      response: Buffer.from(resp.response || []).toString("base64")
-    };
-    ws.send(JSON.stringify(payload));
-  }
-  sendError(ws, req, message, code = ErrorCode.InternalServerError) {
-    const resp = NewErrorResponseObject({ code, message });
-    resp.command = req.command || "";
-    resp.requestid = req.requestid || "";
-    this.sendResponse(ws, resp);
-  }
-  async handleStartReq(req, raw) {
-    const dc = StartSchema.parse(raw);
-    printer_default.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
-    const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleStopReq(req, raw) {
-    const dc = StopSchema.parse(raw);
-    printer_default.info("Stopping tunnel with ID: " + dc.tunnelID);
-    const result = await this.tunnelHandler.handleStop(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleGetReq(req, raw) {
-    const dc = GetSchema.parse(raw);
-    const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleRestartReq(req, raw) {
-    const dc = RestartSchema.parse(raw);
-    const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-  async handleUpdateConfigReq(req, raw) {
-    const dc = UpdateConfigSchema.parse(raw);
-    const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-  async handleListReq(req) {
-    const result = await this.tunnelHandler.handleList();
-    return this.wrapResponse(result, req);
-  }
-  wrapResponse(result, req) {
-    if (isErrorResponse(result)) {
-      const errResp = NewErrorResponseObject(result);
-      errResp.command = req.command;
-      errResp.requestid = req.requestid;
-      return errResp;
-    }
-    const finalResult = JSON.parse(JSON.stringify(result));
-    if (Array.isArray(finalResult)) {
-      finalResult.forEach((item) => {
-        if (item?.tunnelconfig) {
-          delete item.tunnelconfig.allowPreflight;
-        }
-      });
-    } else if (finalResult?.tunnelconfig) {
-      delete finalResult.tunnelconfig.allowPreflight;
-    }
-    const respObj = NewResponseObject(finalResult);
-    respObj.command = req.command;
-    respObj.requestid = req.requestid;
-    return respObj;
-  }
-  async handle(ws, req) {
-    const cmd = (req.command || "").toLowerCase();
-    const raw = this.safeParse(req.data);
-    try {
-      let response;
-      switch (cmd) {
-        case "start": {
-          response = await this.handleStartReq(req, raw);
-          break;
-        }
-        case "stop": {
-          response = await this.handleStopReq(req, raw);
-          break;
-        }
-        case "get": {
-          response = await this.handleGetReq(req, raw);
-          break;
-        }
-        case "restart": {
-          response = await this.handleRestartReq(req, raw);
-          break;
-        }
-        case "updateconfig": {
-          response = await this.handleUpdateConfigReq(req, raw);
-          break;
-        }
-        case "list": {
-          response = await this.handleListReq(req);
-          break;
-        }
-        default:
-          if (typeof req.command === "string") {
-            logger.warn("Unknown command", { command: req.command });
-          }
-          return this.sendError(ws, req, "Invalid command");
-      }
-      logger.debug("Sending response", { command: response.command, requestid: response.requestid });
-      this.sendResponse(ws, response);
-    } catch (e) {
-      if (e instanceof z2.ZodError) {
-        logger.warn("Validation failed", { cmd, issues: e.issues });
-        return this.sendError(ws, req, "Invalid request data", ErrorCode.InvalidBodyFormatError);
-      }
-      logger.error("Error handling command", { cmd, error: String(e) });
-      return this.sendError(ws, req, e?.message || "Internal error");
-    }
-  }
-};
-function handleConnectionStatusMessage(firstMessage) {
-  try {
-    const text = typeof firstMessage === "string" ? firstMessage : firstMessage.toString();
-    const cs = JSON.parse(text);
-    if (!cs.success) {
-      const msg = cs.error_msg || "Connection failed";
-      printer_default.warn(`Connection failed: ${msg}`);
-      logger.warn("Remote management connection failed", { error_code: cs.error_code, error_msg: msg });
-      return false;
-    }
-    return true;
-  } catch (e) {
-    logger.warn("Failed to parse connection status message", { error: String(e) });
-    return true;
-  }
-}
-
-// src/remote_management/remoteManagement.ts
-var RECONNECT_SLEEP_MS = 5e3;
-var PING_INTERVAL_MS = 3e4;
-var _remoteManagementState = {
-  status: "NOT_RUNNING",
-  errorMessage: ""
-};
-var _stopRequested = false;
-var currentWs = null;
-function buildRemoteManagementWsUrl(manage) {
-  let baseUrl = (manage || "dashboard.pinggy.io").trim();
-  if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
-    baseUrl = "wss://" + baseUrl;
-  }
-  const trimmed = baseUrl.replace(/\/$/, "");
-  return `${trimmed}/backend/api/v1/remote-management/connect`;
-}
-function extractHostname(u) {
-  try {
-    const url = new URL(u);
-    return url.host;
-  } catch {
-    return u;
-  }
-}
-function sleep(ms) {
-  return new Promise((res) => setTimeout(res, ms));
-}
-async function parseRemoteManagement(values) {
-  const rmToken = values["remote-management"];
-  if (typeof rmToken === "string" && rmToken.trim().length > 0) {
-    const manageHost = values["manage"];
-    try {
-      await initiateRemoteManagement(rmToken, manageHost);
-      return { ok: true };
-    } catch (e) {
-      logger.error("Failed to initiate remote management:", e);
-      return { ok: false, error: e };
-    }
-  }
-}
-async function initiateRemoteManagement(token, manage) {
-  if (!token || token.trim().length === 0) {
-    throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
-  }
-  const wsUrl = buildRemoteManagementWsUrl(manage);
-  const wsHost = extractHostname(wsUrl);
-  logger.info("Remote management mode enabled.");
-  _stopRequested = false;
-  const sigintHandler = () => {
-    _stopRequested = true;
-  };
-  process.once("SIGINT", sigintHandler);
-  const logConnecting = () => {
-    printer_default.print(`Connecting to ${wsHost}`);
-    logger.info("Connecting to remote management", { wsUrl });
-  };
-  while (!_stopRequested) {
-    logConnecting();
-    setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
-    try {
-      await handleWebSocketConnection(wsUrl, wsHost, token);
-    } catch (error) {
-      logger.warn("Remote management connection error", { error: String(error) });
-    }
-    if (_stopRequested) break;
-    printer_default.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds...`);
-    logger.info("Reconnecting to remote management after disconnect");
-    await sleep(RECONNECT_SLEEP_MS);
-  }
-  process.removeListener("SIGINT", sigintHandler);
-  logger.info("Remote management stopped.");
-  return getRemoteManagementState();
-}
-async function handleWebSocketConnection(wsUrl, wsHost, token) {
-  return new Promise((resolve) => {
-    const ws = new WebSocket(wsUrl, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-    currentWs = ws;
-    let heartbeat = null;
-    let firstMessage = true;
-    const cleanup = () => {
-      if (heartbeat) clearInterval(heartbeat);
-      currentWs = null;
-      resolve();
-    };
-    ws.once("open", () => {
-      printer_default.success(`Connected to ${wsHost}`);
-      heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) ws.ping();
-      }, PING_INTERVAL_MS);
-    });
-    ws.on("ping", () => ws.pong());
-    ws.on("message", async (data) => {
-      try {
-        if (firstMessage) {
-          firstMessage = false;
-          const ok = handleConnectionStatusMessage(data);
-          if (!ok) ws.close();
-          return;
-        }
-        setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
-        const req = JSON.parse(data.toString("utf8"));
-        await new WebSocketCommandHandler().handle(ws, req);
-      } catch (e) {
-        logger.warn("Failed handling websocket message", { error: String(e) });
-      }
-    });
-    ws.on("unexpected-response", (_, res) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
-      if (res.statusCode === 401) {
-        printer_default.error("Unauthorized. Please enter a valid token.");
-        logger.error("Unauthorized (401) on remote management connect");
-      } else {
-        printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
-        logger.warn("Unexpected HTTP response", { statusCode: res.statusCode });
-      }
-      ws.close();
-    });
-    ws.on("close", (code, reason) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-      logger.info("WebSocket closed", { code, reason: reason.toString() });
-      printer_default.warn(`Disconnected (code: ${code}). Retrying...`);
-      cleanup();
-    });
-    ws.on("error", (err) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
-      logger.warn("WebSocket error", { error: err.message });
-      printer_default.error(err);
-      cleanup();
-    });
-  });
-}
-async function closeRemoteManagement(timeoutMs = 1e4) {
-  _stopRequested = true;
-  try {
-    if (currentWs) {
-      try {
-        setRemoteManagementState({ status: RemoteManagementStatus.Disconnecting, errorMessage: "" });
-        currentWs.close();
-      } catch (e) {
-        logger.warn("Error while closing current remote management websocket", { error: String(e) });
-      }
-    }
-    const start = Date.now();
-    while (_remoteManagementState.status === "RUNNING") {
-      if (Date.now() - start > timeoutMs) {
-        logger.warn("Timed out waiting for remote management to stop");
-        break;
-      }
-      await sleep(200);
-    }
-  } finally {
-    currentWs = null;
-    setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-    return getRemoteManagementState();
-  }
-}
-function getRemoteManagementState() {
-  return _remoteManagementState;
-}
-function setRemoteManagementState(state, errorMessage) {
-  _remoteManagementState = {
-    status: state.status,
-    errorMessage: errorMessage || ""
-  };
-}
-
-// src/utils/parseArgs.ts
-import { parseArgs as parseArgs2 } from "util";
-import * as os from "os";
-function isInlineColonFlag(arg) {
-  return /^-([RL])[A-Za-z0-9._-]*:?$/.test(arg);
-}
-function preprocessWindowsArgs(args) {
-  if (os.platform() !== "win32") return args;
-  const out = [];
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (isInlineColonFlag(arg)) {
-      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-        let merged = arg + args[i + 1];
-        i += 2;
-        out.push(merged);
-        continue;
-      }
-      out.push(arg);
-      i++;
-      continue;
-    }
-    out.push(arg);
-    i++;
-  }
-  return out;
-}
-function parseCliArgs(options) {
-  const rawArgs = process.argv.slice(2);
-  const processedArgs = preprocessWindowsArgs(rawArgs);
-  const parsed = parseArgs2({
-    args: processedArgs,
-    options,
-    allowPositionals: true
-  });
-  const hasAnyArgs = parsed.positionals.length > 0 || Object.values(parsed.values).some((v) => v !== void 0 && v !== false);
-  return {
-    ...parsed,
-    hasAnyArgs
-  };
-}
-
-// src/utils/getFreePort.ts
-import net from "net";
-function getFreePort(webDebugger) {
-  return new Promise((resolve, reject) => {
-    const tryPort = (portToTry) => {
-      const server = net.createServer();
-      server.unref();
-      server.on("error", (err) => {
-        if (portToTry !== 0) {
-          tryPort(0);
-        } else {
-          reject(err);
-        }
-      });
-      server.listen(portToTry, () => {
-        const address = server.address();
-        const port = address ? address.port : 0;
-        server.close(() => resolve(port));
-      });
-    };
-    let providedPort = 0;
-    if (webDebugger && webDebugger.includes(":")) {
-      const portPart = webDebugger.split(":")[1];
-      const parsed = parseInt(portPart, 10);
-      if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
-        providedPort = parsed;
-      }
-    }
-    tryPort(providedPort);
-  });
-}
-
-// src/cli/starCli.ts
-import pico3 from "picocolors";
-
-// src/tui/blessed/TunnelTui.ts
-import blessed3 from "blessed";
-
-// src/tui/blessed/qrCodeGenerator.ts
-import QRCode from "qrcode";
-async function createQrCodes(urls) {
-  const codes = [];
-  for (const url of urls) {
-    const qr = await QRCode.toString(url, {
-      type: "terminal",
-      small: true,
-      margin: 0,
-      errorCorrectionLevel: "L"
-    });
-    codes.push(qr);
-  }
-  return codes;
-}
-
-// src/tui/blessed/webDebuggerConnection.ts
-import WebSocket2 from "ws";
-
-// src/tui/blessed/config.ts
-var defaultTuiConfig = {
-  maxRequestPairs: 100,
-  visibleRequestCount: 10,
-  viewportScrollMargin: 2,
-  inactivityHttpSelectorTimeoutMs: 1e4
-};
-function getTuiConfig() {
-  return {
-    maxRequestPairs: defaultTuiConfig.maxRequestPairs,
-    visibleRequestCount: defaultTuiConfig.visibleRequestCount,
-    viewportScrollMargin: defaultTuiConfig.viewportScrollMargin,
-    inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs
-  };
-}
-
-// src/tui/blessed/webDebuggerConnection.ts
-function createWebDebuggerConnection(webDebuggerUrl, onUpdate) {
-  const pairs = /* @__PURE__ */ new Map();
-  const pairKeys = [];
-  let socket = null;
-  let reconnectTimeout = null;
-  let isStopped = false;
-  const config = getTuiConfig();
-  const maxPairs = config.maxRequestPairs;
-  const trimPairs = () => {
-    while (pairKeys.length > maxPairs) {
-      const oldestKey = pairKeys.shift();
-      if (oldestKey !== void 0) {
-        pairs.delete(oldestKey);
-      }
-    }
-  };
-  const upsertPair = (key, pair) => {
-    if (!pairs.has(key)) {
-      pairKeys.push(key);
-    }
-    pairs.set(key, pair);
-    trimPairs();
-  };
-  const connect = () => {
-    const ws = new WebSocket2(`ws://${webDebuggerUrl}/introspec/websocket`);
-    socket = ws;
-    ws.on("open", () => {
-      logger.info("Web debugger connected.");
-    });
-    ws.on("message", (data) => {
-      try {
-        const raw = data.toString();
-        const parsed = JSON.parse(raw);
-        const msg = {
-          Req: parsed.req,
-          Res: parsed.res
-        };
-        if (msg.Req) {
-          const { key } = msg.Req;
-          const existing = pairs.get(key);
-          const merged = {
-            request: msg.Req,
-            response: existing?.response
-          };
-          upsertPair(key, merged);
-        }
-        if (msg.Res) {
-          const { key } = msg.Res;
-          const existing = pairs.get(key);
-          const merged = {
-            request: existing?.request ?? {},
-            response: msg.Res
-          };
-          upsertPair(key, merged);
-        }
-        const reversedPairs = [];
-        for (let i = pairKeys.length - 1; i >= 0; i--) {
-          const key = pairKeys[i];
-          const pair = pairs.get(key);
-          if (pair) {
-            reversedPairs.push(pair);
-          }
-        }
-        onUpdate(reversedPairs);
-      } catch (err) {
-        logger.error("Error parsing WebSocket message:", err.message || err);
-      }
-    });
-    ws.on("close", () => {
-      logger.warn("Web debugger disconnected. Reconnecting in 5s...");
-      if (!isStopped) {
-        reconnectTimeout = setTimeout(connect, 5e3);
-      }
-    });
-    ws.on("error", (err) => {
-      logger.error(`WebSocket error: ${err.message}`);
-    });
-  };
-  connect();
-  return {
-    close: () => {
-      isStopped = true;
-      if (socket) {
-        socket.close();
-      }
-      if (reconnectTimeout) {
-        clearTimeout(reconnectTimeout);
-      }
-    }
-  };
-}
-
-// src/tui/blessed/components/UIComponents.ts
-import blessed from "blessed";
-
-// src/tui/ink/asciArt.ts
-var 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");
-  return lines.map((line, i) => {
-    const color = colors[i % colors.length];
-    return `{${color}-fg}${line}{/${color}-fg}`;
-  }).join("\n");
-}
-function createWarningUI(screen) {
-  return blessed.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "80%",
-    height: 5,
-    content: `{red-fg}{bold}Terminal is too narrow to show TUI (${screen.width} cols).{/bold}{/red-fg}
-{yellow-fg}Please resize your terminal to at least ${MIN_WIDTH_WARNING} columns for proper display.{/yellow-fg}`,
-    tags: true,
-    align: "center",
-    valign: "middle",
-    style: {
-      fg: "red"
-    }
-  });
-}
-function createFullUI(screen, urls, greet, tunnelConfig) {
-  const mainContainer = blessed.box({
-    parent: screen,
-    top: 0,
-    left: 0,
-    width: "100%",
-    height: "100%",
-    padding: 1
-  });
-  const logoBox = blessed.box({
-    parent: mainContainer,
-    top: 0,
-    left: 0,
-    width: "100%",
-    height: 7,
-    content: colorizeGradient(asciiArtPinggyLogo),
-    tags: true
-  });
-  const contentBox = blessed.box({
-    parent: mainContainer,
-    top: 8,
-    left: 0,
-    width: "100%-2",
-    height: "100%-10",
-    padding: 0,
-    border: {
-      type: "line"
-    },
-    style: {
-      border: {
-        fg: "green"
-      }
-    }
-  });
-  let greetHeight = 0;
-  if (greet) {
-    const greetBox = blessed.box({
-      parent: contentBox,
-      top: 0,
-      left: "center",
-      width: "60%",
-      height: 4,
-      content: `{bold}${greet}{/bold}`,
-      tags: true,
-      align: "center",
-      style: {
-        fg: "green"
-      }
-    });
-    greetHeight = 4;
-  }
-  const upperSectionTop = greetHeight > 0 ? greetHeight : 0;
-  const upperSection = blessed.box({
-    parent: contentBox,
-    top: upperSectionTop,
-    left: 0,
-    width: "100%-2",
-    height: 10
-  });
-  const urlsBox = blessed.box({
-    parent: upperSection,
-    top: 0,
-    left: 0,
-    width: "48%",
-    height: "100%",
-    padding: { left: 1, right: 1 },
-    tags: true
-  });
-  const statsBox = blessed.box({
-    parent: upperSection,
-    top: 0,
-    right: 0,
-    left: "65%",
-    width: "35%",
-    height: "100%",
-    padding: { left: 1, right: 1 },
-    tags: true,
-    align: "left"
-  });
-  const lowerSectionTop = greetHeight + 11;
-  const lowerSection = blessed.box({
-    parent: contentBox,
-    top: lowerSectionTop,
-    left: 0,
-    right: 0,
-    bottom: 2,
-    width: "100%-2",
-    height: `100%-${lowerSectionTop + 6}`
-  });
-  const isQrCodeRequested = tunnelConfig?.qrCode || false;
-  const requestsBox = blessed.box({
-    parent: lowerSection,
-    top: 0,
-    left: 0,
-    width: isQrCodeRequested ? "60%" : "80%",
-    height: "80%",
-    padding: { left: 1, right: 1 },
-    tags: true,
-    scrollable: true
-  });
-  let qrCodeBox;
-  if (isQrCodeRequested) {
-    qrCodeBox = blessed.box({
-      parent: lowerSection,
-      top: 0,
-      right: 0,
-      width: "40%",
-      height: "100%",
-      tags: true,
-      padding: { left: 1, right: 1 }
-    });
-  }
-  const footerBox = blessed.box({
-    parent: contentBox,
-    bottom: 0,
-    left: "center",
-    width: "shrink",
-    height: 1,
-    content: "Press Ctrl+C to stop the tunnel. Or press h for key bindings.",
-    tags: true
-  });
-  return {
-    mainContainer,
-    logoBox,
-    contentBox,
-    urlsBox,
-    statsBox,
-    requestsBox,
-    qrCodeBox,
-    footerBox
-  };
-}
-function createSimpleUI(screen, urls, greet) {
-  const mainContainer = blessed.box({
-    parent: screen,
-    top: 0,
-    left: 0,
-    width: "100%",
-    height: "100%",
-    padding: { left: 1, right: 1 }
-  });
-  let currentTop = 0;
-  if (greet) {
-    blessed.box({
-      parent: mainContainer,
-      top: currentTop,
-      left: "center",
-      width: "90%",
-      height: "shrink",
-      content: `{bold}${greet}{/bold}`,
-      tags: true,
-      align: "center",
-      style: {
-        fg: "green"
-      }
-    });
-    const lines = Math.ceil(greet.length / (screen.width * 0.9));
-    currentTop += Math.max(lines, 1) + 1;
-  }
-  const urlsBox = blessed.box({
-    parent: mainContainer,
-    top: currentTop,
-    left: 0,
-    width: "100%",
-    height: urls.length + 2,
-    tags: true
-  });
-  currentTop += urls.length + 3;
-  const statsBox = blessed.box({
-    parent: mainContainer,
-    top: currentTop,
-    left: 0,
-    width: "100%",
-    height: 8,
-    tags: true
-  });
-  currentTop += 9;
-  const footerBox = blessed.box({
-    parent: mainContainer,
-    bottom: 0,
-    left: "center",
-    width: "shrink",
-    height: 1,
-    content: "Press Ctrl+C to stop the tunnel.",
-    tags: true,
-    style: {
-      fg: "white"
-    }
-  });
-  return {
-    mainContainer,
-    urlsBox,
-    statsBox,
-    footerBox
-  };
-}
-
-// src/tui/ink/utils/utils.ts
-function getStatusColor(status) {
-  const match = status.match(/\b(\d{3})\b/);
-  const statusCode = match ? parseInt(match[1], 10) : 0;
-  switch (true) {
-    case (statusCode >= 100 && statusCode < 200):
-      return "yellow";
-    case (statusCode >= 200 && statusCode < 300):
-      return "green";
-    case (statusCode >= 300 && statusCode < 400):
-      return "yellow";
-    case (statusCode >= 400 && statusCode < 500):
-      return "red";
-    case statusCode >= 500:
-      return "pink";
-    default:
-      return "yellow";
-  }
-}
-function getBytesInt(b) {
-  if (b >= 1024 * 1024 * 1024) {
-    return `${(b / (1024 * 1024 * 1024)).toFixed(2)} G`;
-  }
-  if (b >= 1024 * 1024) {
-    return `${(b / (1024 * 1024)).toFixed(2)} M`;
-  }
-  if (b >= 1024) {
-    return `${(b / 1024).toFixed(2)} K`;
-  }
-  return `${b.toFixed(2)}  `;
-}
-
-// src/tui/blessed/components/DisplayUpdaters.ts
-function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
-  if (!urlsBox) return;
-  let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}\n";
-  urls.forEach((url, index) => {
-    const isSelected = index === currentQrIndex;
-    const prefix = isSelected ? "\u2192 " : "\u2022 ";
-    const color = isSelected ? "yellow" : "magenta";
-    if (isSelected) {
-      content += `{bold}{${color}-fg}${prefix}${url}{/${color}-fg}{/bold}
-`;
-    } else {
-      content += `{${color}-fg}${prefix}${url}{/${color}-fg}
-`;
-    }
-  });
-  urlsBox.setContent(content);
-  screen.render();
-}
-function updateStatsDisplay(statsBox, screen, stats) {
-  if (!statsBox) return;
-  const content = `{green-fg}{bold}Live Stats{/bold}{/green-fg}
-Elapsed: ${stats.elapsedTime}s
-Live Connections: ${stats.numLiveConnections}
-Total Connections: ${stats.numTotalConnections}
-Request: ${getBytesInt(stats.numTotalReqBytes)}
-Response: ${getBytesInt(stats.numTotalResBytes)}
-Total Transfer: ${getBytesInt(stats.numTotalTxBytes)}`;
-  statsBox.setContent(content);
-  statsBox.style = { ...statsBox.style };
-  statsBox.parseContent();
-  screen.render();
-}
-function updateRequestsDisplay(requestsBox, screen, pairs, selectedIndex) {
-  const config = getTuiConfig();
-  const { maxRequestPairs, visibleRequestCount, viewportScrollMargin } = config;
-  if (!requestsBox) {
-    return { adjustedSelectedIndex: selectedIndex, trimmedPairs: pairs };
-  }
-  let allPairs = pairs;
-  let trimmedPairs = pairs;
-  if (allPairs.length > maxRequestPairs) {
-    allPairs = allPairs.slice(0, maxRequestPairs);
-    trimmedPairs = allPairs;
-  }
-  const totalPairs = allPairs.length;
-  let adjustedSelectedIndex = selectedIndex;
-  if (adjustedSelectedIndex >= totalPairs) {
-    adjustedSelectedIndex = -1;
-  }
-  let viewportStart;
-  if (totalPairs <= visibleRequestCount) {
-    viewportStart = 0;
-  } else if (adjustedSelectedIndex === -1) {
-    viewportStart = 0;
-  } else {
-    viewportStart = 0;
-    if (adjustedSelectedIndex >= visibleRequestCount - viewportScrollMargin) {
-      viewportStart = Math.min(
-        totalPairs - visibleRequestCount,
-        adjustedSelectedIndex - viewportScrollMargin
-      );
-    }
-    if (adjustedSelectedIndex < viewportStart + viewportScrollMargin) {
-      viewportStart = Math.max(0, adjustedSelectedIndex - viewportScrollMargin);
-    }
-  }
-  const viewportEnd = Math.min(viewportStart + visibleRequestCount, totalPairs);
-  const visiblePairs = allPairs.slice(viewportStart, viewportEnd);
-  let content = "{yellow-fg}HTTP Requests:{/yellow-fg}";
-  if (viewportStart > 0) {
-    content += ` {gray-fg}\u2191 ${viewportStart} more{/gray-fg}`;
-  }
-  content += "\n";
-  visiblePairs.forEach((pair, i) => {
-    const globalIndex = viewportStart + i;
-    const isSelected = adjustedSelectedIndex !== -1 && adjustedSelectedIndex === globalIndex;
-    const prefix = isSelected ? "> " : "  ";
-    const method = pair.request?.method || "";
-    const uri = pair.request?.uri || "";
-    const status = pair.response?.status || "";
-    const statusColor = getStatusColor(String(status));
-    if (isSelected) {
-      content += `{cyan-fg}${prefix}${method} ${status} ${uri}{/cyan-fg}
-`;
-    } else if (pair.response) {
-      content += `{${statusColor}-fg}${prefix}${method} ${status} ${uri}{/${statusColor}-fg}
-`;
-    } else {
-      content += `${prefix}${method} ...${uri}
-`;
-    }
-  });
-  const itemsBelow = totalPairs - viewportEnd;
-  if (itemsBelow > 0) {
-    content += `{gray-fg}  \u2193 ${itemsBelow} more{/gray-fg}
-`;
-  }
-  requestsBox.setContent(content);
-  screen.render();
-  return { adjustedSelectedIndex, trimmedPairs };
-}
-function updateQrCodeDisplay(qrCodeBox, screen, qrCodes, urls, currentQrIndex) {
-  if (!qrCodeBox || qrCodes.length === 0) return;
-  let content = `{green-fg}{bold}QR Code ${currentQrIndex + 1}/${urls.length}{/bold}{/green-fg}
-`;
-  if (urls.length > 1) {
-    content += "\n{yellow-fg}\u2190 \u2192 to switch QR codes{/yellow-fg}\n";
-  }
-  content += qrCodes[currentQrIndex] || "";
-  qrCodeBox.setContent(content);
-  qrCodeBox.style = { ...qrCodeBox.style };
-  qrCodeBox.parseContent();
-  screen.render();
-}
-
-// src/tui/blessed/components/Modals.ts
-import blessed2 from "blessed";
-function showDetailModal(screen, manager, requestText, responseText) {
-  manager.inDetailView = true;
-  manager.detailModal = blessed2.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "90%",
-    height: "90%",
-    border: {
-      type: "line"
-    },
-    style: {
-      border: {
-        fg: "green"
-      }
-    },
-    padding: { left: 2, right: 2, top: 1, bottom: 1 },
-    tags: true,
-    scrollable: true,
-    keys: true,
-    vi: true,
-    alwaysScroll: true,
-    scrollbar: {
-      ch: " ",
-      track: {
-        bg: "cyan"
-      },
-      style: {
-        inverse: true
-      }
-    }
-  });
-  const content = `{cyan-fg}{bold}Request{/bold}{/cyan-fg}
-${requestText || "(no request data)"}
-
-{magenta-fg}{bold}Response{/bold}{/magenta-fg}
-${responseText || "(no response data)"}
-
-{white-bg}{black-fg}Press ESC to close{/black-fg}{/white-bg}`;
-  manager.detailModal.setContent(content);
-  manager.detailModal.focus();
-  screen.render();
-}
-function closeDetailModal(screen, manager) {
-  if (manager.detailModal) {
-    manager.detailModal.destroy();
-    manager.detailModal = null;
-  }
-  manager.inDetailView = false;
-  screen.render();
-}
-function showKeyBindingsModal(screen, manager) {
-  manager.keyBindingView = true;
-  manager.keyBindingsModal = blessed2.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "60%",
-    height: "80%",
-    border: {
-      type: "line"
-    },
-    style: {
-      border: {
-        fg: "green"
-      }
-    },
-    padding: { left: 2, right: 2, top: 1, bottom: 1 },
-    tags: true
-  });
-  const content = `{cyan-fg}{bold}Key Bindings{/bold}{/cyan-fg}
-
-{bold}h{/bold}         This page
-{bold}c{/bold}         Copy the selected URL to clipboard
-{bold}Ctrl+c{/bold}    Exit
-
-Enter/Return    Open selected request
-Esc             Return to main page (or close modals)
-UP (\u2191)          Scroll up the requests
-Down (\u2193)        Scroll down the requests
-Left (\u2190)        Show qr code for previous url
-Right (\u2192)       Show qr code for next url
-Home           Jump to top of requests
-End            Jump to bottom of requests
-Ctrl+c          Force Exit
-
-{white-bg}{black-fg}Press ESC to close{/black-fg}{/white-bg}`;
-  manager.keyBindingsModal.setContent(content);
-  manager.keyBindingsModal.focus();
-  screen.render();
-}
-function closeKeyBindingsModal(screen, manager) {
-  if (manager.keyBindingsModal) {
-    manager.keyBindingsModal.destroy();
-    manager.keyBindingsModal = null;
-  }
-  manager.keyBindingView = false;
-  screen.render();
-}
-function showDisconnectModal(screen, manager, message, onClose) {
-  manager.inDisconnectView = true;
-  manager.disconnectModal = blessed2.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "50%",
-    height: "20%",
-    border: {
-      type: "line"
-    },
-    style: {
-      border: {
-        fg: "red"
-      }
-    },
-    padding: { left: 2, right: 2, top: 1, bottom: 1 },
-    tags: true,
-    align: "center",
-    valign: "middle"
-  });
-  const content = `{red-fg}{bold}Tunnel Disconnected{/bold}{/red-fg}
-
-${message || "Disconnect request received. Tunnel will be closed."}
-
-{white-bg}{black-fg}Closing in 3 seconds... {/black-fg}{/white-bg}`;
-  manager.disconnectModal.setContent(content);
-  manager.disconnectModal.focus();
-  screen.render();
-  const timeout = setTimeout(() => {
-    closeDisconnectModal(screen, manager);
-    if (onClose) onClose();
-  }, 5e3);
-  const keyHandler = () => {
-    clearTimeout(timeout);
-    closeDisconnectModal(screen, manager);
-    if (onClose) onClose();
-  };
-  manager.disconnectModal.key(["escape", "enter", "space"], keyHandler);
-  screen.key(["escape", "enter", "space"], keyHandler);
-}
-function closeDisconnectModal(screen, manager) {
-  if (manager.disconnectModal) {
-    manager.disconnectModal.destroy();
-    manager.disconnectModal = null;
-  }
-  manager.inDisconnectView = false;
-  screen.render();
-}
-function showLoadingModal(screen, modalManager, message = "Loading...") {
-  if (modalManager.loadingView) return;
-  modalManager.loadingBox = blessed2.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "60%",
-    height: 8,
-    border: { type: "line" },
-    style: {
-      border: { fg: "yellow" }
-    },
-    tags: true,
-    content: `{center}{yellow-fg}{bold}${message}{/bold}{/yellow-fg}
-
-{gray-fg}Press ESC to cancel{/gray-fg}{/center}`,
-    valign: "middle"
-  });
-  modalManager.loadingView = true;
-  screen.render();
-}
-function closeLoadingModal(screen, modalManager) {
-  if (!modalManager.loadingView || !modalManager.loadingBox) return;
-  modalManager.loadingBox.destroy();
-  modalManager.loadingBox = null;
-  modalManager.loadingView = false;
-  screen.render();
-}
-function showErrorModal(screen, modalManager, title = "Error", message) {
-  if (modalManager.loadingBox) {
-    modalManager.loadingBox.destroy();
-    modalManager.loadingBox = null;
-  }
-  modalManager.loadingBox = blessed2.box({
-    parent: screen,
-    top: "center",
-    left: "center",
-    width: "60%",
-    height: 9,
-    border: { type: "line" },
-    style: {
-      border: { fg: "red" }
-    },
-    tags: true,
-    content: `{center}{red-fg}{bold}${title}{/bold}{/red-fg}
-
-{white-fg}${message}{/white-fg}
-
-{gray-fg}Press ESC to close{/gray-fg}{/center}`,
-    valign: "middle"
-  });
-  modalManager.loadingView = true;
-  screen.render();
-}
-
-// src/tui/blessed/headerFetcher.ts
-async function fetchReqResHeaders(baseUrl, key, signal) {
-  if (!baseUrl) {
-    return { req: "", res: "" };
-  }
-  try {
-    const [reqRes, resRes] = await Promise.all([
-      fetch(`http://${baseUrl}/introspec/getrawrequestheader`, {
-        headers: { "X-Introspec-Key": key.toString() },
-        signal
-      }),
-      fetch(`http://${baseUrl}/introspec/getrawresponseheader`, {
-        headers: { "X-Introspec-Key": key.toString() },
-        signal
-      })
-    ]);
-    const [req, res] = await Promise.all([reqRes.text(), resRes.text()]);
-    return { req, res };
-  } catch (err) {
-    if (err?.name === "AbortError") {
-      throw err;
-    }
-    logger.error("Error fetching headers:", err.message || err);
-    throw err;
-  }
-}
-
-// src/tui/blessed/components/KeyBindings.ts
-function setupKeyBindings(screen, modalManager, state, callbacks, tunnelConfig) {
-  let inactivityTimeout = null;
-  const { inactivityHttpSelectorTimeoutMs } = getTuiConfig();
-  const INACTIVITY_TIMEOUT_MS = inactivityHttpSelectorTimeoutMs;
-  const resetInactivityTimer = () => {
-    if (inactivityTimeout) {
-      clearTimeout(inactivityTimeout);
-    }
-    if (state.selectedIndex !== -1) {
-      inactivityTimeout = setTimeout(() => {
-        callbacks.onSelectedIndexChange(-1, null);
-        callbacks.updateRequestsDisplay();
-      }, INACTIVITY_TIMEOUT_MS);
-    }
-  };
-  screen.key(["C-c"], () => {
-    callbacks.onDestroy();
-    process.exit(0);
-  });
-  screen.key(["escape"], () => {
-    if (modalManager.loadingView) {
-      if (modalManager.fetchAbortController) {
-        modalManager.fetchAbortController.abort();
-        modalManager.fetchAbortController = null;
-      }
-      closeLoadingModal(screen, modalManager);
-      return;
-    }
-    if (modalManager.inDetailView) {
-      closeDetailModal(screen, modalManager);
-      return;
-    }
-    if (modalManager.keyBindingView) {
-      closeKeyBindingsModal(screen, modalManager);
-      return;
-    }
-    if (state.selectedIndex !== -1) {
-      if (inactivityTimeout) {
-        clearTimeout(inactivityTimeout);
-        inactivityTimeout = null;
-      }
-      callbacks.onSelectedIndexChange(-1, null);
-      callbacks.updateRequestsDisplay();
-    }
-  });
-  screen.key(["up"], () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    resetInactivityTimer();
-    if (state.selectedIndex === -1) {
-      const requestKey = state.pairs[0]?.request?.key ?? null;
-      callbacks.onSelectedIndexChange(0, requestKey);
-      callbacks.updateRequestsDisplay();
-      resetInactivityTimer();
-    } else if (state.selectedIndex > 0) {
-      const newIndex = state.selectedIndex - 1;
-      const requestKey = state.pairs[newIndex]?.request?.key ?? null;
-      callbacks.onSelectedIndexChange(newIndex, requestKey);
-      callbacks.updateRequestsDisplay();
-    }
-  });
-  screen.key(["down"], () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    resetInactivityTimer();
-    const config = getTuiConfig();
-    const limitedLength = Math.min(state.pairs.length, config.maxRequestPairs);
-    if (state.selectedIndex === -1) {
-      if (limitedLength > 0) {
-        const requestKey = state.pairs[0]?.request?.key ?? null;
-        callbacks.onSelectedIndexChange(0, requestKey);
-        callbacks.updateRequestsDisplay();
-        resetInactivityTimer();
-      }
-    } else if (state.selectedIndex < limitedLength - 1) {
-      const newIndex = state.selectedIndex + 1;
-      const requestKey = state.pairs[newIndex]?.request?.key ?? null;
-      callbacks.onSelectedIndexChange(newIndex, requestKey);
-      callbacks.updateRequestsDisplay();
-    }
-  });
-  screen.key(["end"], () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    resetInactivityTimer();
-    const config = getTuiConfig();
-    const limitedLength = Math.min(state.pairs.length, config.maxRequestPairs);
-    const lastIndex = Math.max(0, limitedLength - 1);
-    if (state.selectedIndex !== lastIndex) {
-      const requestKey = state.pairs[lastIndex]?.request?.key ?? null;
-      callbacks.onSelectedIndexChange(lastIndex, requestKey);
-      callbacks.updateRequestsDisplay();
-    }
-  });
-  screen.key(["enter"], async () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    if (state.selectedIndex === -1) return;
-    resetInactivityTimer();
-    const pair = state.pairs[state.selectedIndex];
-    if (pair?.request?.key !== void 0 && pair?.request?.key !== null) {
-      const abortController = new AbortController();
-      modalManager.fetchAbortController = abortController;
-      showLoadingModal(screen, modalManager, "Fetching request details...");
-      try {
-        const headers = await fetchReqResHeaders(
-          tunnelConfig?.webDebugger || "",
-          pair.request.key,
-          abortController.signal
-        );
-        if (abortController.signal.aborted) {
-          return;
-        }
-        closeLoadingModal(screen, modalManager);
-        modalManager.fetchAbortController = null;
-        showDetailModal(screen, modalManager, headers.req, headers.res);
-      } catch (err) {
-        if (err?.name === "AbortError" || abortController.signal.aborted) {
-          logger.info("Fetch request cancelled by user");
-          return;
-        }
-        closeLoadingModal(screen, modalManager);
-        modalManager.fetchAbortController = null;
-        const errorMessage = err?.message || String(err) || "Unknown error occurred";
-        logger.error("Fetch error:", err);
-        showErrorModal(screen, modalManager, "Failed to fetch request details", errorMessage);
-      }
-    }
-  });
-  screen.key(["h"], () => {
-    if (modalManager.inDetailView || modalManager.loadingView) return;
-    if (modalManager.keyBindingView) {
-      closeKeyBindingsModal(screen, modalManager);
-    } else {
-      showKeyBindingsModal(screen, modalManager);
-    }
-  });
-  screen.key(["c"], async () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    if (state.urls.length > 0) {
-      try {
-        const clipboardy = await import("clipboardy");
-        clipboardy.default.writeSync(state.urls[state.currentQrIndex]);
-      } catch (err) {
-        logger.error("Failed to copy to clipboard:", err);
-      }
-    }
-  });
-  screen.key(["left"], () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    if (state.currentQrIndex > 0) {
-      callbacks.onQrIndexChange(state.currentQrIndex - 1);
-      callbacks.updateUrlsDisplay();
-      callbacks.updateQrCodeDisplay();
-    }
-  });
-  screen.key(["right"], () => {
-    if (modalManager.inDetailView || modalManager.keyBindingView || modalManager.loadingView) return;
-    if (state.currentQrIndex < state.urls.length - 1) {
-      callbacks.onQrIndexChange(state.currentQrIndex + 1);
-      callbacks.updateUrlsDisplay();
-      callbacks.updateQrCodeDisplay();
-    }
-  });
-}
-
-// 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 = blessed3.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;
-      }
-    }
-    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;
-      }
-    };
-    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;
-  }
-  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/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;
-    if (!isTTYEnabled) {
-      printer_default.warn("Unable to initiate the TUI: your terminal does not support the required input mode.");
-      return;
-    }
-    const tui = new TunnelTui({
-      urls: urls ?? [],
-      greet: greet ?? "",
-      tunnelConfig: finalConfig,
-      disconnectInfo: null,
-      tunnelInstance: tunnel
-    });
-    activeTui = tui;
-    try {
-      tui.start();
-      await tui.waitUntilExit();
-    } catch (e) {
-      logger.warn("TUI error", e);
-    } finally {
-      activeTui = null;
-    }
-  } catch (e) {
-    logger.warn("Failed to (re-)initiate TUI", e);
-  }
-}
-async function startCli(finalConfig, manager) {
-  if (!finalConfig.NoTUI && finalConfig.webDebugger === "") {
-    const freePort = await getFreePort(finalConfig.webDebugger || "");
-    finalConfig.webDebugger = `localhost:${freePort}`;
-  }
-  try {
-    const manager2 = TunnelManager.getInstance();
-    const tunnel = await manager2.createTunnel(finalConfig);
-    printer_default.startSpinner("Connecting to Pinggy...");
-    if (!finalConfig.NoTUI) {
-      manager2.registerStatsListener(tunnel.tunnelid, (tunnelId, stats) => {
-        globalThis.__PINGGY_TUNNEL_STATS__?.(stats);
-      });
-    }
-    manager2.registerWorkerErrorListner(tunnel.tunnelid, (_tunnelid, error) => {
-      printer_default.error(`${error.message}`);
-    });
-    await manager2.startTunnel(tunnel.tunnelid);
-    printer_default.stopSpinnerSuccess(" Connected to Pinggy");
-    printer_default.success(pico3.bold("Tunnel established!"));
-    printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    TunnelData.urls = await manager2.getTunnelUrls(tunnel.tunnelid);
-    TunnelData.greet = await manager2.getTunnelGreetMessage(tunnel.tunnelid);
-    printer_default.info(pico3.cyanBright("Remote URLs:"));
-    (TunnelData.urls ?? []).forEach(
-      (url) => printer_default.print("  " + pico3.magentaBright(url))
-    );
-    printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    if (TunnelData.greet?.includes("not authenticated")) {
-      printer_default.warn(pico3.yellowBright(TunnelData.greet));
-    } else if (TunnelData.greet?.includes("authenticated as")) {
-      const emailMatch = /authenticated as (.+)/.exec(TunnelData.greet);
-      if (emailMatch) {
-        const email = emailMatch[1];
-        printer_default.info(pico3.cyanBright("Authenticated as: " + email));
-      }
-    }
-    printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    printer_default.print(pico3.gray("\nPress Ctrl+C to stop the tunnel.\n"));
-    manager2.registerDisconnectListener(tunnel.tunnelid, async (tunnelId, error, messages) => {
-      if (activeTui) {
-        disconnectState = {
-          disconnected: true,
-          error,
-          messages
-        };
-        activeTui.updateDisconnectInfo(disconnectState);
-        try {
-          await activeTui.waitUntilExit();
-        } catch (e) {
-          logger.warn("Failed to wait for TUI exit", e);
-        } finally {
-          activeTui = null;
-          printer_default.warn(`Error in tunnel:`);
-          messages?.forEach(function(m) {
-            printer_default.warnTxt(m);
-          });
-          if (!finalConfig.autoReconnect) {
-            process.exit(0);
-          }
-        }
-      } else {
-        messages?.forEach(function(m) {
-          printer_default.warn(m);
-        });
-        if (!finalConfig.autoReconnect) {
-          process.exit(0);
-        }
-      }
-      if (finalConfig.autoReconnect) {
-        printer_default.startSpinner("Reconnecting to Pinggy");
-      }
-    });
-    try {
-      await manager2.registerStartListener(tunnel.tunnelid, async (tunnelId, urls) => {
-        try {
-          printer_default.stopSpinnerSuccess("Reconnected to Pinggy");
-        } catch (e) {
-        }
-        printer_default.success(pico3.bold("Tunnel re-established!"));
-        printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-        TunnelData.urls = urls;
-        TunnelData.greet = await manager2.getTunnelGreetMessage(tunnel.tunnelid);
-        printer_default.info(pico3.cyanBright("Remote URLs:"));
-        (TunnelData.urls ?? []).forEach(
-          (url) => printer_default.print("  " + pico3.magentaBright(url))
-        );
-        printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-        if (TunnelData.greet?.includes("not authenticated")) {
-          printer_default.warn(pico3.yellowBright(TunnelData.greet));
-        } else if (TunnelData.greet?.includes("authenticated as")) {
-          const emailMatch = /authenticated as (.+)/.exec(TunnelData.greet);
-          if (emailMatch) {
-            const email = emailMatch[1];
-            printer_default.info(pico3.cyanBright("Authenticated as: " + email));
-          }
-        }
-        printer_default.print(pico3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-        printer_default.print(pico3.gray("\nPress Ctrl+C to stop the tunnel.\n"));
-        if (!finalConfig.NoTUI) {
-          await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
-        }
-      });
-    } catch (e) {
-      logger.debug("Failed to register start listener", e);
-    }
-    if (!finalConfig.NoTUI) {
-      await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
-    }
-  } catch (err) {
-    printer_default.stopSpinnerFail("Failed to connect");
-    printer_default.error(err.message || "Unknown error");
-    throw err;
-  }
-}
-
-// src/index.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { argv } from "process";
-import { realpathSync } from "fs";
-async function main() {
-  try {
-    const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
-    configureLogger(values);
-    const manager = TunnelManager.getInstance();
-    process.on("SIGINT", () => {
-      logger.info("SIGINT received: stopping tunnels and exiting");
-      console.log("\nStopping all tunnels...");
-      manager.stopAllTunnels();
-      console.log("Tunnels stopped. Exiting.");
-      process.exit(0);
-    });
-    if (!hasAnyArgs || values.help) {
-      printHelpMessage();
-      return;
-    }
-    if (values.version) {
-      printer_default.print(`Pinggy CLI version: ${getVersion()}`);
-      return;
-    }
-    const parseResult = await parseRemoteManagement(values);
-    if (parseResult?.ok === false) {
-      printer_default.error(parseResult.error);
-      logger.error("Failed to initiate remote management:", parseResult.error);
-      process.exit(1);
-    }
-    logger.debug("Building final config from CLI values and positionals", { values, positionals });
-    const finalConfig = await buildFinalConfig(values, positionals);
-    logger.debug("Final configuration built", finalConfig);
-    await startCli(finalConfig, manager);
-  } catch (error) {
-    logger.error("Unhandled error in CLI:", error);
-    printer_default.error(error);
-  }
-}
-var currentFile = fileURLToPath2(import.meta.url);
-var entryFile = null;
-try {
-  entryFile = argv[1] ? realpathSync(argv[1]) : null;
-} catch (e) {
-  entryFile = null;
-}
-if (entryFile && entryFile === currentFile) {
-  main();
-}
-export {
-  TunnelManager,
-  TunnelOperations,
-  closeRemoteManagement,
-  enablePackageLogging,
-  getRemoteManagementState,
-  initiateRemoteManagement
-};