pinggy 0.3.8 → 0.3.10

package/dist/{chunk-65R2GMKQ.js → chunk-MBN3YBO4.js}

@@ -68,6 +68,9 @@ var _CLIPrinter = class _CLIPrinter {
     console.error(pico2.red(pico2.bold("\u2716 Error:")), pico2.red(msg));
     process.exit(1);
   }
+  static red(message) {
+    return pico2.red(message);
+  }
   static warn(message) {
     console.warn(pico2.yellow(pico2.bold("\u26A0 Warning:")), pico2.yellow(message));
   }
@@ -96,7 +99,7 @@ _CLIPrinter.errorDefinitions = [
     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.`;
+      return `Unknown option '${option}'. Please check your command or use pinggy -h for guidance.`;
     }
   },
   {
@@ -121,27 +124,36 @@ var CLIPrinter = _CLIPrinter;
 var printer_default = CLIPrinter;
 
 // src/utils/util.ts
-import { createRequire } from "module";
+import { readFileSync } from "fs";
 import { randomUUID } from "crypto";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 function getRandomId() {
   return randomUUID();
 }
 function isValidPort(p) {
   return Number.isInteger(p) && p > 0 && p < 65536;
 }
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
 function getVersion() {
-  return pkg.version ?? "";
+  try {
+    const packageJsonPath = join(__dirname2, "../package.json");
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return pkg.version ?? "";
+  } catch (error) {
+    printer_default.error("Error reading version info");
+    return "";
+  }
 }
 
 // src/tunnel_manager/TunnelManager.ts
 import { pinggy } from "@pinggy/pinggy";
 import path from "path";
 import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = path.dirname(__filename3);
 var TunnelManager = class _TunnelManager {
   constructor() {
     this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
@@ -149,6 +161,7 @@ var TunnelManager = class _TunnelManager {
     this.tunnelStats = /* @__PURE__ */ new Map();
     this.tunnelStatsListeners = /* @__PURE__ */ new Map();
     this.tunnelErrorListeners = /* @__PURE__ */ new Map();
+    this.tunnelPollingErrorListeners = /* @__PURE__ */ new Map();
     this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
     this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
     this.tunnelStartListeners = /* @__PURE__ */ new Map();
@@ -165,12 +178,9 @@ var TunnelManager = class _TunnelManager {
   }
   /**
    * Creates a new managed tunnel instance with the given configuration.
-   * Builds the config with forwarding rules and creates the tunnel instance.
+   * Optionally builds the config with forwarding rules based on buildConfig flag.
    * 
    * @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
@@ -179,24 +189,19 @@ var TunnelManager = class _TunnelManager {
    *                          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}"`);
+    const { configId, tunnelid: requestedTunnelId, tunnelName, name, serve } = config;
+    const tunnelid = requestedTunnelId || getRandomId();
+    const autoReconnect = config.autoReconnect || false;
+    if (!configId || typeof configId !== "string" || configId.trim() === "") {
+      throw new Error("configId is required and must be a non-empty string");
     }
-    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,
+      configId,
       tunnelid,
-      tunnelName,
+      tunnelName: tunnelName || name,
       originalConfig: config,
-      configWithForwarding,
-      additionalForwarding,
-      serve: config.serve,
-      autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
+      serve,
+      autoReconnect
     });
   }
   /**
@@ -210,7 +215,8 @@ var TunnelManager = class _TunnelManager {
   async _createTunnelWithProcessedConfig(params) {
     let instance;
     try {
-      instance = await pinggy.createTunnel(params.configWithForwarding);
+      logger.debug("Creating tunnel instance with processed config", params.originalConfig);
+      instance = await pinggy.createTunnel(params.originalConfig);
     } catch (e) {
       logger.error("Error creating tunnel instance:", e);
       throw e;
@@ -218,25 +224,25 @@ var TunnelManager = class _TunnelManager {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const managed = {
       tunnelid: params.tunnelid,
-      configid: params.configid,
+      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
+      autoReconnect: params.autoReconnect,
+      lastError: {}
     };
     instance.setTunnelEstablishedCallback(({}) => {
       managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
     });
     this.setupStatsCallback(params.tunnelid, managed);
     this.setupErrorCallback(params.tunnelid, managed);
+    this.setupTunnelPollingErrorCallback(params.tunnelid, managed);
     this.setupDisconnectCallback(params.tunnelid, managed);
     this.setupWillReconnectCallback(params.tunnelid, managed);
     this.setupReconnectingCallback(params.tunnelid, managed);
@@ -244,44 +250,10 @@ var TunnelManager = class _TunnelManager {
     this.setupReconnectionFailedCallback(params.tunnelid, managed);
     this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
     this.tunnelsByTunnelId.set(params.tunnelid, managed);
-    this.tunnelsByConfigId.set(params.configid, managed);
-    logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
+    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
    */
@@ -293,7 +265,14 @@ var TunnelManager = class _TunnelManager {
     try {
       urls = await managed.instance.start();
     } catch (error) {
-      logger.error("Failed to start tunnel", { tunnelId, error });
+      logger.warn("Failed to start tunnel", { tunnelId, error });
+      managed.isStopped = true;
+      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+      managed.lastError = {
+        message: "Failed to start tunnel",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isFatal: true
+      };
       throw error;
     }
     logger.info("Tunnel started", { tunnelId, urls });
@@ -329,7 +308,7 @@ var TunnelManager = class _TunnelManager {
   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 });
+    logger.info("Stopping tunnel", { tunnelId, configId: managed.configId });
     try {
       managed.instance.stop();
       if (managed.serveWorker) {
@@ -341,6 +320,7 @@ var TunnelManager = class _TunnelManager {
       this.tunnelStats.delete(tunnelId);
       this.tunnelStatsListeners.delete(tunnelId);
       this.tunnelErrorListeners.delete(tunnelId);
+      this.tunnelPollingErrorListeners.delete(tunnelId);
       this.tunnelDisconnectListeners.delete(tunnelId);
       this.tunnelWorkerErrorListeners.delete(tunnelId);
       this.tunnelStartListeners.delete(tunnelId);
@@ -352,8 +332,8 @@ var TunnelManager = class _TunnelManager {
       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 };
+      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;
@@ -370,7 +350,6 @@ var TunnelManager = class _TunnelManager {
         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 });
@@ -386,11 +365,10 @@ var TunnelManager = class _TunnelManager {
       const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
         return {
           tunnelid: tunnel.tunnelid,
-          configid: tunnel.configid,
+          configId: tunnel.configId,
           tunnelName: tunnel.tunnelName,
           tunnelConfig: tunnel.tunnelConfig,
-          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
-          additionalForwarding: tunnel.additionalForwarding,
+          remoteurls: tunnel.isStopped || tunnel.lastError?.isFatal ? [] : await this.getTunnelUrls(tunnel.tunnelid),
           serve: tunnel.serve
         };
       }));
@@ -413,7 +391,6 @@ var TunnelManager = class _TunnelManager {
       return "exited";
     }
     const status = await managed.instance.getStatus();
-    logger.debug("Queried tunnel status", { tunnelId, status });
     return status;
   }
   /**
@@ -431,6 +408,15 @@ var TunnelManager = class _TunnelManager {
     this.tunnelsByConfigId.clear();
     this.tunnelStats.clear();
     this.tunnelStatsListeners.clear();
+    this.tunnelErrorListeners.clear();
+    this.tunnelPollingErrorListeners.clear();
+    this.tunnelDisconnectListeners.clear();
+    this.tunnelWorkerErrorListeners.clear();
+    this.tunnelStartListeners.clear();
+    this.tunnelWillReconnectListeners.clear();
+    this.tunnelReconnectingListeners.clear();
+    this.tunnelReconnectionCompletedListeners.clear();
+    this.tunnelReconnectionFailedListeners.clear();
     logger.info("All tunnels stopped and cleared");
   }
   /**
@@ -451,7 +437,7 @@ var TunnelManager = class _TunnelManager {
       return false;
     }
     this._cleanupTunnelRecords(managed);
-    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configid });
+    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configId });
     return true;
   }
   /**
@@ -478,6 +464,7 @@ var TunnelManager = class _TunnelManager {
       this.tunnelStats.delete(managed.tunnelid);
       this.tunnelStatsListeners.delete(managed.tunnelid);
       this.tunnelErrorListeners.delete(managed.tunnelid);
+      this.tunnelPollingErrorListeners.delete(managed.tunnelid);
       this.tunnelDisconnectListeners.delete(managed.tunnelid);
       this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
       this.tunnelStartListeners.delete(managed.tunnelid);
@@ -486,7 +473,7 @@ var TunnelManager = class _TunnelManager {
       this.tunnelReconnectionCompletedListeners.delete(managed.tunnelid);
       this.tunnelReconnectionFailedListeners.delete(managed.tunnelid);
       this.tunnelsByTunnelId.delete(managed.tunnelid);
-      this.tunnelsByConfigId.delete(managed.configid);
+      this.tunnelsByConfigId.delete(managed.configId);
     } catch (e) {
       logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
     }
@@ -547,21 +534,20 @@ var TunnelManager = class _TunnelManager {
     }
     logger.info("Initiating tunnel restart", {
       tunnelId: tunnelid,
-      configId: existingTunnel.configid
+      configId: existingTunnel.configId
     });
     try {
       const tunnelName = existingTunnel.tunnelName;
-      const currentConfigId = existingTunnel.configid;
+      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.tunnelsByConfigId.delete(existingTunnel.configId);
       this.tunnelStats.delete(tunnelid);
       this.tunnelStatsListeners.delete(tunnelid);
       this.tunnelErrorListeners.delete(tunnelid);
+      this.tunnelPollingErrorListeners.delete(tunnelid);
       this.tunnelDisconnectListeners.delete(tunnelid);
       this.tunnelWorkerErrorListeners.delete(tunnelid);
       this.tunnelStartListeners.delete(tunnelid);
@@ -570,12 +556,10 @@ var TunnelManager = class _TunnelManager {
       this.tunnelReconnectionCompletedListeners.delete(tunnelid);
       this.tunnelReconnectionFailedListeners.delete(tunnelid);
       const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid: currentConfigId,
+        configId: currentConfigId,
         tunnelid,
         tunnelName,
         originalConfig: currentConfig,
-        configWithForwarding,
-        additionalForwarding,
         serve: currentServe,
         autoReconnect
       });
@@ -604,20 +588,18 @@ var TunnelManager = class _TunnelManager {
    * @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 { configId, tunnelName: newTunnelName } = newConfig;
+    if (!configId || configId.trim().length === 0) {
+      throw new Error(`Invalid configId: "${configId}"`);
     }
-    const existingTunnel = this.tunnelsByConfigId.get(configid);
+    const existingTunnel = this.tunnelsByConfigId.get(configId);
     if (!existingTunnel) {
-      throw new Error(`Tunnel with config id "${configid}" not found`);
+      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 currentTunnelConfigId = existingTunnel.configId;
     const currentTunnelName = existingTunnel.tunnelName;
     const currentServe = existingTunnel.serve;
     const currentAutoReconnect = existingTunnel.autoReconnect || false;
@@ -629,22 +611,19 @@ var TunnelManager = class _TunnelManager {
       this.tunnelsByConfigId.delete(currentTunnelConfigId);
       const mergedBaseConfig = {
         ...newConfig,
-        configid,
+        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 effectiveServe = newConfig.serve !== void 0 ? newConfig.serve : currentServe;
+      const effectiveTunnelName = newTunnelName !== void 0 ? newTunnelName : currentTunnelName;
+      let configWithForwarding;
       const newTunnel = await this._createTunnelWithProcessedConfig({
-        configid,
+        configId,
         tunnelid: currentTunnelId,
-        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
+        tunnelName: effectiveTunnelName,
         originalConfig: mergedBaseConfig,
-        configWithForwarding: newConfigWithForwarding,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
-        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
+        serve: effectiveServe,
         autoReconnect: currentAutoReconnect
       });
       if (!isStopped) {
@@ -652,23 +631,21 @@ var TunnelManager = class _TunnelManager {
       }
       logger.info("Tunnel configuration updated", {
         tunnelId: newTunnel.tunnelid,
-        configId: newTunnel.configid,
+        configId: newTunnel.configId,
         isStopped
       });
       return newTunnel;
     } catch (error) {
       logger.error("Error updating tunnel configuration", {
-        configId: configid,
+        configId,
         error: error instanceof Error ? error.message : String(error)
       });
       try {
         const originalTunnel = await this._createTunnelWithProcessedConfig({
-          configid: currentTunnelConfigId,
+          configId: currentTunnelConfigId,
           tunnelid: currentTunnelId,
           tunnelName: currentTunnelName,
           originalConfig: currentTunnelConfig,
-          configWithForwarding: currentConfigWithForwarding,
-          additionalForwarding: currentAdditionalForwarding,
           serve: currentServe,
           autoReconnect: currentAutoReconnect
         });
@@ -784,6 +761,19 @@ var TunnelManager = class _TunnelManager {
     logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
     return listenerId;
   }
+  async registerPollingErrorListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelPollingErrorListeners.has(tunnelId)) {
+      this.tunnelPollingErrorListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = getRandomId();
+    this.tunnelPollingErrorListeners.get(tunnelId).set(listenerId, listener);
+    logger.info("Polling error listener registered for tunnel", { tunnelId, listenerId });
+    return listenerId;
+  }
   async registerDisconnectListener(tunnelId, listener) {
     const managed = this.tunnelsByTunnelId.get(tunnelId);
     if (!managed) {
@@ -915,6 +905,22 @@ var TunnelManager = class _TunnelManager {
       logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
     }
   }
+  deregisterPollingErrorListener(tunnelId, listenerId) {
+    const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
+    if (!listeners) {
+      logger.warn("No polling error listeners found for tunnel", { tunnelId });
+      return;
+    }
+    const removed = listeners.delete(listenerId);
+    if (removed) {
+      logger.info("Polling error listener deregistered", { tunnelId, listenerId });
+      if (listeners.size === 0) {
+        this.tunnelPollingErrorListeners.delete(tunnelId);
+      }
+    } else {
+      logger.warn("Attempted to deregister non-existent polling error listener", { tunnelId, listenerId });
+    }
+  }
   deregisterDisconnectListener(tunnelId, listenerId) {
     const listeners = this.tunnelDisconnectListeners.get(tunnelId);
     if (!listeners) {
@@ -1032,6 +1038,46 @@ var TunnelManager = class _TunnelManager {
       logger.warn("Failed to set up stats callback", { tunnelId, error });
     }
   }
+  setupTunnelPollingErrorCallback(tunnelId, managed) {
+    try {
+      const callback = ({ error }) => {
+        try {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger.info("Tunnel reported polling error", { tunnelId, errorMessage });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.lastError = {
+              message: errorMessage,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isFatal: true
+            };
+          }
+          this.notifyPollingErrorListeners(tunnelId, errorMessage);
+        } catch (e) {
+          logger.warn("Error handling tunnel polling error callback", { tunnelId, e });
+        }
+      };
+      managed.instance.setPollingErrorCallback(callback);
+      logger.debug("Tunnel polling error callback set up for tunnel", { tunnelId });
+    } catch (error) {
+      logger.warn("Failed to set up tunnel polling error callback", { tunnelId, error });
+    }
+  }
+  notifyPollingErrorListeners(tunnelId, errorMsg) {
+    try {
+      const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
+      if (!listeners) return;
+      for (const [id, listener] of listeners) {
+        try {
+          listener(tunnelId, errorMsg);
+        } catch (err) {
+          logger.debug("Error in polling-error-listener callback", { listenerId: id, tunnelId, err });
+        }
+      }
+    } catch (err) {
+      logger.debug("Failed to notify polling error listeners", { tunnelId, err });
+    }
+  }
   notifyErrorListeners(tunnelId, errorMsg, isFatal) {
     try {
       const listeners = this.tunnelErrorListeners.get(tunnelId);
@@ -1054,6 +1100,14 @@ var TunnelManager = class _TunnelManager {
           const msg = typeof error === "string" ? error : String(error);
           const isFatal = true;
           logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.lastError = {
+              message: msg,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isFatal: false
+            };
+          }
           this.notifyErrorListeners(tunnelId, msg, isFatal);
         } catch (e) {
           logger.warn("Error handling tunnel error callback", { tunnelId, e });
@@ -1304,9 +1358,9 @@ var TunnelManager = class _TunnelManager {
   }
   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 __filename4 = fileURLToPath2(import.meta.url);
+      const __dirname4 = path.dirname(__filename4);
+      const fileServerWorkerPath = path.join(__dirname4, "workers", "file_serve_worker.cjs");
       const staticServerWorker = new Worker(fileServerWorkerPath, {
         workerData: {
           dir: managed.serve,
@@ -1449,11 +1503,11 @@ var RemoteManagementStatus = {
 };
 
 // src/remote_management/remote_schema.ts
-import { TunnelType as TunnelType2 } from "@pinggy/pinggy";
+import { TunnelType } from "@pinggy/pinggy";
 import { z } from "zod";
 var HeaderModificationSchema = z.object({
   key: z.string(),
-  value: z.array(z.string()).optional(),
+  value: z.array(z.string()).nullable().optional(),
   type: z.enum(["add", "remove", "update"])
 });
 var AdditionalForwardingSchema = z.object({
@@ -1469,7 +1523,7 @@ var TunnelConfigSchema = z.object({
   // legacy key
   autoreconnect: z.boolean(),
   basicauth: z.array(z.object({ username: z.string(), password: z.string() })).nullable(),
-  bearerauth: z.string().nullable(),
+  bearerauth: z.array(z.string()).nullable(),
   configid: z.string(),
   configname: z.string(),
   greetmsg: z.string().optional(),
@@ -1491,11 +1545,11 @@ var TunnelConfigSchema = z.object({
   token: z.string(),
   tunnelTimeout: z.number(),
   type: z.enum([
-    TunnelType2.Http,
-    TunnelType2.Tcp,
-    TunnelType2.Udp,
-    TunnelType2.Tls,
-    TunnelType2.TlsTcp
+    TunnelType.Http,
+    TunnelType.Tcp,
+    TunnelType.Udp,
+    TunnelType.Tls,
+    TunnelType.TlsTcp
   ]),
   webdebuggerport: z.number(),
   xff: z.string(),
@@ -1526,15 +1580,102 @@ var RestartSchema = StopSchema;
 var UpdateConfigSchema = z.object({
   tunnelConfig: TunnelConfigSchema
 });
+var ForwardingEntryV2Schema = z.object({
+  listenAddress: z.string().optional(),
+  address: z.string(),
+  type: z.enum([TunnelType.Http, TunnelType.Tcp, TunnelType.Udp, TunnelType.Tls, TunnelType.TlsTcp]).optional()
+});
+var TunnelConfigV1Schema = z.object({
+  // Meta Info
+  version: z.string(),
+  name: z.string(),
+  configId: z.string(),
+  // General tunnel configurations
+  serverAddress: z.string().optional(),
+  token: z.string().optional(),
+  autoReconnect: z.boolean().optional(),
+  reconnectInterval: z.number().optional(),
+  maxReconnectAttempts: z.number().optional(),
+  force: z.boolean(),
+  keepAliveInterval: z.number().optional(),
+  webDebugger: z.string(),
+  //Forwarding
+  // Either a URL string (e.g. "https://localhost:5555") or an array of forwarding entries.
+  forwarding: z.union([
+    z.string(),
+    z.array(ForwardingEntryV2Schema)
+  ]),
+  // IP whitelist 
+  ipWhitelist: z.array(z.string()).optional(),
+  basicAuth: z.array(z.object({ username: z.string(), password: z.string() })).optional(),
+  bearerTokenAuth: z.array(z.string()).optional(),
+  headerModification: z.array(HeaderModificationSchema).optional(),
+  reverseProxy: z.boolean().optional(),
+  xForwardedFor: z.boolean().optional(),
+  httpsOnly: z.boolean().optional(),
+  originalRequestUrl: z.boolean().optional(),
+  allowPreflight: z.boolean().optional(),
+  serve: z.string().optional(),
+  optional: z.record(z.string(), z.unknown()).optional()
+});
+var StartV2Schema = z.object({
+  tunnelID: z.string().nullable().optional(),
+  tunnelConfig: TunnelConfigV1Schema
+});
+var UpdateConfigV2Schema = z.object({
+  tunnelConfig: TunnelConfigV1Schema
+});
+function pinggyOptionsToTunnelConfigV1(opts, configStoredInCli) {
+  const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
+  return {
+    version: configStoredInCli.version || "1.0",
+    name: configStoredInCli.name || "",
+    configId: configStoredInCli.configId || "",
+    serverAddress: opts.serverAddress || "a.pinggy.io:443",
+    token: opts.token || "",
+    autoReconnect: opts.autoReconnect ?? true,
+    force: opts.force ?? false,
+    webDebugger: opts.webDebugger || "",
+    forwarding: opts.forwarding ? opts.forwarding : "",
+    ipWhitelist: opts.ipWhitelist ? Array.isArray(opts.ipWhitelist) ? opts.ipWhitelist : JSON.parse(opts.ipWhitelist) : [],
+    basicAuth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : void 0,
+    bearerTokenAuth: parsedTokens.length ? parsedTokens : void 0,
+    headerModification: opts.headerModification || [],
+    reverseProxy: opts.reverseProxy ?? false,
+    xForwardedFor: !!opts.xForwardedFor,
+    httpsOnly: opts.httpsOnly ?? false,
+    originalRequestUrl: opts.originalRequestUrl ?? false,
+    allowPreflight: opts.allowPreflight ?? false,
+    optional: opts.optional || {}
+  };
+}
 function tunnelConfigToPinggyOptions(config) {
+  const forwardingData = [];
+  forwardingData.push({
+    address: `${config.forwardedhost}:${config.localport}`,
+    type: config.type || TunnelType.Http
+    // Default to HTTP for the primary forwarding entry
+  });
+  if (config.additionalForwarding && Array.isArray(config.additionalForwarding)) {
+    config.additionalForwarding.forEach((entry) => {
+      if (entry.localDomain && entry.localPort && entry.remoteDomain) {
+        const listenAddress = entry.remotePort && isValidPort(entry.remotePort) ? `${entry.remoteDomain}:${entry.remotePort}` : entry.remoteDomain;
+        forwardingData.push({
+          address: `${entry.localDomain}:${entry.localPort}`,
+          listenAddress,
+          type: TunnelType.Http
+        });
+      }
+    });
+  }
   return {
     token: config.token || "",
     serverAddress: config.serveraddress || "free.pinggy.io",
-    forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
+    forwarding: forwardingData,
     webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
     ipWhitelist: config.ipwhitelist || [],
     basicAuth: config.basicauth ? config.basicauth : [],
-    bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
+    bearerTokenAuth: config.bearerauth || [],
     headerModification: config.headermodification,
     xForwardedFor: !!config.xff,
     httpsOnly: config.httpsOnly,
@@ -1548,18 +1689,38 @@ function tunnelConfigToPinggyOptions(config) {
     }
   };
 }
-function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg, additionalForwarding, serve) {
-  const forwarding = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
-  const parsedForwardedHost = forwarding.split(":").length == 3 ? forwarding.split(":")[1] : forwarding.split(":")[0];
-  const parsedLocalPort = forwarding.split(":").length == 3 ? parseInt(forwarding.split(":")[2], 10) : parseInt(forwarding.split(":")[1], 10);
-  const tunnelType = (Array.isArray(opts.forwarding) ? opts.forwarding[0]?.type : void 0) ?? TunnelType2.Http;
+function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg, serve) {
+  let primaryEntry;
+  let additionalEntries = [];
+  if (Array.isArray(opts.forwarding)) {
+    primaryEntry = opts.forwarding.find((e) => !e.listenAddress) ?? opts.forwarding[0];
+    additionalEntries = opts.forwarding.filter(
+      (e) => e !== primaryEntry && Boolean(e.listenAddress)
+    );
+  }
+  const forwarding = primaryEntry ? String(primaryEntry.address) : String(opts.forwarding);
+  const [parsedForwardedHost, portStr] = forwarding.split(":");
+  const parsedLocalPort = parseInt(portStr, 10);
+  const tunnelType = primaryEntry?.type ?? TunnelType.Http;
+  const additionalForwarding = additionalEntries.map((e) => {
+    const [localDomain, localPortStr] = String(e.address).split(":");
+    const [remoteDomain, remotePortStr] = String(e.listenAddress).split(":");
+    const localPort = parseInt(localPortStr, 10);
+    const remotePort = parseInt(remotePortStr, 10);
+    return {
+      localDomain,
+      localPort: isNaN(localPort) ? 0 : localPort,
+      remoteDomain,
+      remotePort: isNaN(remotePort) ? 0 : remotePort
+    };
+  });
   const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
   return {
     allowPreflight: opts.allowPreflight ?? false,
     allowpreflight: opts.allowPreflight ?? false,
     autoreconnect: opts.autoReconnect ?? false,
     basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : null,
-    bearerauth: parsedTokens.length ? parsedTokens.join(",") : null,
+    bearerauth: parsedTokens.length ? [parsedTokens.join(",")] : null,
     configid,
     configname: configName,
     greetmsg: greetMsg || "",
@@ -1590,7 +1751,6 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
 }
 
 // src/remote_management/handler.ts
-import { TunnelType as TunnelType3 } from "@pinggy/pinggy";
 var TunnelOperations = class {
   constructor() {
     this.tunnelManager = TunnelManager.getInstance();
@@ -1604,12 +1764,15 @@ var TunnelOperations = class {
         status.starttimestamp = managed.startedAt || "";
         status.endtimestamp = managed.stoppedAt || "";
       }
+      if (managed?.lastError) {
+        status.lastError = managed.lastError;
+      }
     } catch (e) {
     }
     return status;
   }
   // --- Helper to construct TunnelResponse ---
-  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
+  async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
     const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
       this.tunnelManager.getTunnelStatus(tunnelid),
       this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
@@ -1620,11 +1783,27 @@ var TunnelOperations = class {
     return {
       tunnelid,
       remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
+      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg),
       status: this.buildStatus(tunnelid, status, "" /* NoError */),
       stats
     };
   }
+  async buildTunnelResponseV2(tunnelid, tunnelConfig, configFromCli, configid, tunnelName, serve) {
+    const [status, stats, greetMsg, remoteurls] = await Promise.all([
+      this.tunnelManager.getTunnelStatus(tunnelid),
+      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
+      this.tunnelManager.getTunnelGreetMessage(tunnelid),
+      this.tunnelManager.getTunnelUrls(tunnelid)
+    ]);
+    return {
+      tunnelid,
+      remoteurls,
+      tunnelconfig: pinggyOptionsToTunnelConfigV1(tunnelConfig, configFromCli),
+      status: this.buildStatus(tunnelid, status, "" /* NoError */),
+      stats,
+      greetmsg: greetMsg
+    };
+  }
   error(code, err, fallback) {
     return newErrorResponse({
       code,
@@ -1635,19 +1814,28 @@ var TunnelOperations = class {
   async handleStart(config) {
     try {
       const opts = tunnelConfigToPinggyOptions(config);
-      const additionalForwardingParsed = config.additionalForwarding || [];
-      const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
+      const { tunnelid, instance, tunnelName, serve, tunnelConfig } = await this.tunnelManager.createTunnel({
         ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType3.Http],
-        // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: additionalForwardingParsed,
-        serve: config.serve
+        configId: config.configid,
+        name: config.configname,
+        optional: {
+          serve: config.serve
+        }
       });
-      this.tunnelManager.startTunnel(tunnelid);
+      await this.tunnelManager.startTunnel(tunnelid);
       const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
+      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
+      return resp;
+    } catch (err) {
+      return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
+    }
+  }
+  async handleStartV2(config) {
+    try {
+      const { tunnelid, instance, serve } = await this.tunnelManager.createTunnel(config);
+      await this.tunnelManager.startTunnel(tunnelid);
+      const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
+      const resp = this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
       return resp;
     } catch (err) {
       return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
@@ -1658,20 +1846,59 @@ var TunnelOperations = class {
       const opts = tunnelConfigToPinggyOptions(config);
       const tunnel = await this.tunnelManager.updateConfig({
         ...opts,
-        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [TunnelType3.Http],
-        // // Temporary fix in future we will not use this field.
-        configid: config.configid,
-        tunnelName: config.configname,
-        additionalForwarding: config.additionalForwarding || [],
-        serve: config.serve
+        configId: config.configid,
+        name: config.configname,
+        optional: {
+          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);
+      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.serve);
     } catch (err) {
       return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
     }
   }
+  async handleUpdateConfigV2(config) {
+    try {
+      const tunnel = await this.tunnelManager.updateConfig(config);
+      if (!tunnel.instance || !tunnel.tunnelConfig)
+        throw new Error("Invalid tunnel state after configuration update");
+      return this.buildTunnelResponseV2(tunnel.tunnelid, tunnel.tunnelConfig, config, config.configId, tunnel.tunnelName, tunnel.serve);
+    } catch (err) {
+      return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
+    }
+  }
+  async handleListV2() {
+    try {
+      const tunnels = await this.tunnelManager.getAllTunnels();
+      if (tunnels.length === 0) {
+        return [];
+      }
+      return Promise.all(
+        tunnels.map(async (t) => {
+          const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
+          const [status, tlsInfo, greetMsg] = await Promise.all([
+            this.tunnelManager.getTunnelStatus(t.tunnelid),
+            this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
+            this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
+          ]);
+          const tunnelConfguration = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
+          const tunnelConfig = pinggyOptionsToTunnelConfigV1(tunnelConfguration, t.tunnelConfig);
+          return {
+            tunnelid: t.tunnelid,
+            remoteurls: t.remoteurls,
+            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
+            stats: rawStats,
+            tunnelconfig: tunnelConfig,
+            greetmsg: greetMsg
+          };
+        })
+      );
+    } catch (err) {
+      return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
+    }
+  }
   async handleList() {
     try {
       const tunnels = await this.tunnelManager.getAllTunnels();
@@ -1687,7 +1914,7 @@ var TunnelOperations = class {
             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);
+          const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configId, t.tunnelName, tlsInfo, greetMsg, t.serve);
           return {
             tunnelid: t.tunnelid,
             remoteurls: t.remoteurls,
@@ -1703,10 +1930,10 @@ var TunnelOperations = class {
   }
   async handleStop(tunnelid) {
     try {
-      const { configid } = this.tunnelManager.stopTunnel(tunnelid);
+      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);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configId, managed.tunnelName, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
     }
@@ -1715,7 +1942,7 @@ var TunnelOperations = class {
     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);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configId, managed.tunnelName, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
     }
@@ -1725,7 +1952,7 @@ var TunnelOperations = class {
       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);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configId, managed.tunnelName, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
     }
@@ -1769,11 +1996,198 @@ var TunnelOperations = class {
 // src/remote_management/remoteManagement.ts
 import WebSocket from "ws";
 
+// src/remote_management/websocket_printer.ts
+import pico3 from "picocolors";
+var PENDING_START_TIMEOUT_MS = 5 * 60 * 1e3;
+var RemoteManagementWebSocketPrinter = class {
+  constructor() {
+    this.tunnelManager = TunnelManager.getInstance();
+    this.pendingStarts = /* @__PURE__ */ new Map();
+  }
+  setTunnelHandler(tunnelHandler) {
+    this.tunnelHandler = tunnelHandler;
+  }
+  queueStart(config) {
+    this.cleanupExpiredPendingStarts();
+    const entry = {
+      configId: this.getConfigIdFromRequest(config),
+      configName: this.getConfigNameFromRequest(config),
+      queuedAt: Date.now()
+    };
+    this.latestPendingConfigId = entry.configId;
+    this.pendingStarts.set(entry.configId, entry);
+    printer_default.startSpinner("Starting tunnel with config name: " + entry.configName);
+  }
+  failQueuedStart(config, reason) {
+    const configId = this.getConfigIdFromRequest(config);
+    const pending = this.pendingStarts.get(configId);
+    const configName = pending?.configName || this.getConfigNameFromRequest(config);
+    this.pendingStarts.delete(configId);
+    if (this.latestPendingConfigId === configId) {
+      this.latestPendingConfigId = void 0;
+      printer_default.stopSpinnerFail(`Failed to start tunnel with config name: ${configName}. ${reason}`);
+    }
+  }
+  handleStartResult(config, result) {
+    this.cleanupExpiredPendingStarts();
+    const requestedConfigId = this.getConfigIdFromRequest(config);
+    if (this.latestPendingConfigId && requestedConfigId !== this.latestPendingConfigId) {
+      this.pendingStarts.delete(requestedConfigId);
+      return;
+    }
+    if (isErrorResponse(result)) {
+      this.failQueuedStart(config, result.message);
+      return;
+    }
+    const configId = this.getConfigIdFromTunnel(result);
+    const pending = this.pendingStarts.get(requestedConfigId) || {
+      configId: requestedConfigId,
+      configName: this.getConfigNameFromRequest(config),
+      queuedAt: Date.now()
+    };
+    pending.tunnelId = result.tunnelid;
+    this.pendingStarts.set(requestedConfigId, pending);
+    if (result.remoteurls.length > 0) {
+      this.completePendingStart(pending, result.remoteurls);
+    }
+  }
+  printStopRequested(tunnelId) {
+    const details = this.resolveTunnelDetails(tunnelId);
+    printer_default.startSpinner("Stopping tunnel with config name: " + details.configName);
+  }
+  handleStopResult(tunnelId, result) {
+    const details = this.resolveTunnelDetails(tunnelId, result);
+    if (isErrorResponse(result)) {
+      printer_default.stopSpinnerFail("Failed to stop tunnel with config name: " + details.configName);
+      return;
+    }
+    this.pendingStarts.delete(details.configId);
+    printer_default.stopSpinnerSuccess("Stopped tunnel with config name: " + details.configName);
+  }
+  printRestartRequested(tunnelId) {
+    const details = this.resolveTunnelDetails(tunnelId);
+    printer_default.startSpinner("Restarting tunnel with config name: " + details.configName);
+  }
+  handleRestartResult(tunnelId, result) {
+    const details = this.resolveTunnelDetails(tunnelId, result);
+    if (isErrorResponse(result)) {
+      printer_default.warn(`Failed to restart tunnel with config name: ${details.configName}. ${result.message}`);
+      printer_default.stopSpinnerFail("Failed to restart tunnel with config name: " + details.configName);
+      return;
+    }
+    printer_default.stopSpinnerSuccess("Restarted tunnel with config name: " + details.configName);
+    if (result.remoteurls?.length > 0) {
+      printer_default.info(pico3.cyanBright("Remote URLs:"));
+      (result.remoteurls ?? []).forEach(
+        (url) => printer_default.print("  " + pico3.magentaBright(url))
+      );
+    }
+  }
+  monitorList(result) {
+    this.cleanupExpiredPendingStarts();
+    if (!Array.isArray(result) || this.pendingStarts.size === 0 || !this.latestPendingConfigId) {
+      return;
+    }
+    for (const tunnel of result) {
+      const pending = this.findPendingStart(tunnel);
+      if (!pending) {
+        continue;
+      }
+      if (pending.configId !== this.latestPendingConfigId) {
+        continue;
+      }
+      pending.tunnelId = tunnel.tunnelid;
+      this.pendingStarts.set(pending.configId, pending);
+      if (tunnel.remoteurls.length > 0) {
+        this.completePendingStart(pending, tunnel.remoteurls);
+        continue;
+      }
+      if (tunnel.status.state === "exited" /* Exited */) {
+        const reason = tunnel.status.errormsg || "Tunnel exited before a public URL was assigned";
+        this.pendingStarts.delete(pending.configId);
+        this.latestPendingConfigId = void 0;
+        printer_default.stopSpinnerFail(`Tunnel start did not complete for config name: ${pending.configName}. ${reason}`);
+      }
+    }
+  }
+  completePendingStart(entry, urls) {
+    if (this.latestPendingConfigId && entry.configId !== this.latestPendingConfigId) {
+      this.pendingStarts.delete(entry.configId);
+      return;
+    }
+    this.pendingStarts.delete(entry.configId);
+    this.latestPendingConfigId = void 0;
+    printer_default.stopSpinnerSuccess(`Tunnel started with config name: ${entry.configName}.`);
+    printer_default.info(pico3.cyanBright("Remote URLs:"));
+    (urls ?? []).forEach(
+      (url) => printer_default.print("  " + pico3.magentaBright(url))
+    );
+  }
+  cleanupExpiredPendingStarts() {
+    const now = Date.now();
+    for (const [configId, entry] of this.pendingStarts.entries()) {
+      if (now - entry.queuedAt <= PENDING_START_TIMEOUT_MS) {
+        continue;
+      }
+      this.pendingStarts.delete(configId);
+      printer_default.warn(`Timed out while waiting for tunnel URL for config name: ${entry.configName}`);
+      logger.warn("Pending websocket start entry expired", { configId, tunnelId: entry.tunnelId });
+    }
+  }
+  findPendingStart(tunnel) {
+    const configId = this.getConfigIdFromTunnel(tunnel);
+    const byConfigId = this.pendingStarts.get(configId);
+    if (byConfigId) {
+      return byConfigId;
+    }
+    for (const entry of this.pendingStarts.values()) {
+      if (entry.tunnelId === tunnel.tunnelid) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  resolveTunnelDetails(tunnelId, result) {
+    try {
+      const managed = this.tunnelManager.getManagedTunnel(void 0, tunnelId);
+      return {
+        configId: managed.configId,
+        configName: managed.tunnelName || managed.configId || tunnelId
+      };
+    } catch {
+      if (result && !isErrorResponse(result)) {
+        return {
+          configId: this.getConfigIdFromTunnel(result),
+          configName: this.getConfigNameFromTunnel(result)
+        };
+      }
+      return {
+        configId: tunnelId,
+        configName: tunnelId
+      };
+    }
+  }
+  getConfigIdFromRequest(config) {
+    return "configid" in config ? config.configid : config.configId;
+  }
+  getConfigNameFromRequest(config) {
+    return "configname" in config ? config.configname : config.name;
+  }
+  getConfigIdFromTunnel(tunnel) {
+    return "configid" in tunnel.tunnelconfig ? tunnel.tunnelconfig.configid : tunnel.tunnelconfig.configId;
+  }
+  getConfigNameFromTunnel(tunnel) {
+    return "configname" in tunnel.tunnelconfig ? tunnel.tunnelconfig.configname : tunnel.tunnelconfig.name;
+  }
+};
+var remoteManagementWebSocketPrinter = new RemoteManagementWebSocketPrinter();
+
 // src/remote_management/websocket_handlers.ts
 import z2 from "zod";
 var WebSocketCommandHandler = class {
   constructor() {
     this.tunnelHandler = new TunnelOperations();
+    remoteManagementWebSocketPrinter.setTunnelHandler(this.tunnelHandler);
   }
   safeParse(text) {
     if (!text) return void 0;
@@ -1798,35 +2212,157 @@ var WebSocketCommandHandler = class {
     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);
+    let queuedConfig;
+    try {
+      const dc = StartSchema.parse(raw);
+      queuedConfig = dc.tunnelConfig;
+      remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
+      const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
+      remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (queuedConfig) {
+        remoteManagementWebSocketPrinter.failQueuedStart(queuedConfig, String(e));
+      }
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for start request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleStartReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
+  }
+  async handleStartV2Req(req, raw) {
+    let queuedConfig;
+    try {
+      const dc = StartV2Schema.parse(raw);
+      queuedConfig = dc.tunnelConfig;
+      remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
+      const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig);
+      remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (queuedConfig) {
+        remoteManagementWebSocketPrinter.failQueuedStart(queuedConfig, String(e));
+      }
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for start-v2 request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleStartV2Req error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
   }
   async handleStopReq(req, raw) {
-    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);
+    try {
+      const dc = StopSchema.parse(raw);
+      remoteManagementWebSocketPrinter.printStopRequested(dc.tunnelID);
+      const result = await this.tunnelHandler.handleStop(dc.tunnelID);
+      remoteManagementWebSocketPrinter.handleStopResult(dc.tunnelID, result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for stop request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleStopReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
   }
   async handleGetReq(req, raw) {
-    const dc = GetSchema.parse(raw);
-    const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-    return this.wrapResponse(result, req);
+    try {
+      const dc = GetSchema.parse(raw);
+      const result = await this.tunnelHandler.handleGet(dc.tunnelID);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for get request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleGetReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
   }
   async handleRestartReq(req, raw) {
-    const dc = RestartSchema.parse(raw);
-    const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
-    return this.wrapResponse(result, req);
+    try {
+      const dc = RestartSchema.parse(raw);
+      remoteManagementWebSocketPrinter.printRestartRequested(dc.tunnelID);
+      const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
+      remoteManagementWebSocketPrinter.handleRestartResult(dc.tunnelID, result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for restart request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleRestartReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
   }
   async handleUpdateConfigReq(req, raw) {
-    const dc = UpdateConfigSchema.parse(raw);
-    const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
+    try {
+      const dc = UpdateConfigSchema.parse(raw);
+      const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for updateconfig request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleUpdateConfigReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
+  }
+  async handleUpdateConfigV2Req(req, raw) {
+    try {
+      const dc = UpdateConfigV2Schema.parse(raw);
+      const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      if (e instanceof z2.ZodError) {
+        printer_default.warn("Validation failed for update-config-v2 request");
+        return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
+      }
+      printer_default.warn(`Error in handleUpdateConfigV2Req error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
   }
   async handleListReq(req) {
-    const result = await this.tunnelHandler.handleList();
-    return this.wrapResponse(result, req);
+    try {
+      const result = await this.tunnelHandler.handleList();
+      remoteManagementWebSocketPrinter.monitorList(result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      printer_default.warn(`Error in handleListReq error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
+  }
+  async handleListV2Req(req) {
+    try {
+      const result = await this.tunnelHandler.handleListV2();
+      remoteManagementWebSocketPrinter.monitorList(result);
+      return this.wrapResponse(result, req);
+    } catch (e) {
+      printer_default.warn(`Error in handleListV2Req error: ${String(e)}`);
+      return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
+    }
+  }
+  async handleGetVersionReq(ws, req) {
+    try {
+      const versionResponse = {
+        cli_version: getVersion()
+      };
+      const payload = {
+        command: req.command,
+        requestid: req.requestid,
+        response: JSON.stringify(versionResponse),
+        error: false
+      };
+      ws.send(JSON.stringify(payload));
+    } catch (e) {
+      printer_default.warn(`Error in handleGetVersionReq error: ${String(e)}`);
+      this.sendError(ws, req, String(e));
+    }
   }
   wrapResponse(result, req) {
     if (isErrorResponse(result)) {
@@ -1860,6 +2396,10 @@ var WebSocketCommandHandler = class {
           response = await this.handleStartReq(req, raw);
           break;
         }
+        case "start-v2": {
+          response = await this.handleStartV2Req(req, raw);
+          break;
+        }
         case "stop": {
           response = await this.handleStopReq(req, raw);
           break;
@@ -1876,10 +2416,22 @@ var WebSocketCommandHandler = class {
           response = await this.handleUpdateConfigReq(req, raw);
           break;
         }
+        case "update-config-v2": {
+          response = await this.handleUpdateConfigV2Req(req, raw);
+          break;
+        }
         case "list": {
           response = await this.handleListReq(req);
           break;
         }
+        case "list-v2": {
+          response = await this.handleListV2Req(req);
+          break;
+        }
+        case "get-version": {
+          await this.handleGetVersionReq(ws, req);
+          return;
+        }
         default:
           if (typeof req.command === "string") {
             logger.warn("Unknown command", { command: req.command });
@@ -1898,6 +2450,18 @@ var WebSocketCommandHandler = class {
     }
   }
 };
+function sendVersionResponse(ws) {
+  const versionResponse = {
+    cli_version: getVersion()
+  };
+  const payload = {
+    command: "get-version",
+    requestid: "0",
+    response: JSON.stringify(versionResponse),
+    error: false
+  };
+  ws.send(JSON.stringify(payload));
+}
 function handleConnectionStatusMessage(firstMessage) {
   try {
     const text = typeof firstMessage === "string" ? firstMessage : firstMessage.toString();
@@ -1948,7 +2512,11 @@ async function parseRemoteManagement(values) {
   if (typeof rmToken === "string" && rmToken.trim().length > 0) {
     const manageHost = values["manage"];
     try {
-      await initiateRemoteManagement(rmToken, manageHost);
+      const remoteManagementConfig = {
+        apiKey: rmToken,
+        serverUrl: buildRemoteManagementWsUrl(manageHost)
+      };
+      await initiateRemoteManagement(remoteManagementConfig);
       return { ok: true };
     } catch (e) {
       logger.error("Failed to initiate remote management:", e);
@@ -1956,11 +2524,11 @@ async function parseRemoteManagement(values) {
     }
   }
 }
-async function initiateRemoteManagement(token, manage) {
-  if (!token || token.trim().length === 0) {
+async function initiateRemoteManagement(remoteManagementConfig) {
+  if (!remoteManagementConfig.apiKey || remoteManagementConfig.apiKey.trim().length === 0) {
     throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
   }
-  const wsUrl = buildRemoteManagementWsUrl(manage);
+  const wsUrl = remoteManagementConfig.serverUrl;
   const wsHost = extractHostname(wsUrl);
   logger.info("Remote management mode enabled.");
   _stopRequested = false;
@@ -1976,7 +2544,7 @@ async function initiateRemoteManagement(token, manage) {
     logConnecting();
     setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
     try {
-      await handleWebSocketConnection(wsUrl, wsHost, token);
+      await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey);
     } catch (error) {
       logger.warn("Remote management connection error", { error: String(error) });
     }
@@ -2004,6 +2572,7 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
     };
     ws.once("open", () => {
       printer_default.success(`Connected to ${wsHost}`);
+      setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
       heartbeat = setInterval(() => {
         if (ws.readyState === WebSocket.OPEN) ws.ping();
       }, PING_INTERVAL_MS);
@@ -2014,7 +2583,11 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
         if (firstMessage) {
           firstMessage = false;
           const ok = handleConnectionStatusMessage(data);
-          if (!ok) ws.close();
+          if (!ok) {
+            ws.close();
+            return;
+          }
+          sendVersionResponse(ws);
           return;
         }
         setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
@@ -2025,20 +2598,21 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
       }
     });
     ws.on("unexpected-response", (_, res) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
       if (res.statusCode === 401) {
+        setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
         printer_default.error("Unauthorized. Please enter a valid token.");
         logger.error("Unauthorized (401) on remote management connect");
+        ws.close();
       } else {
+        logger.warn("Unexpected HTTP response ", { statusCode: res.statusCode });
         printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
-        logger.warn("Unexpected HTTP response", { statusCode: res.statusCode });
+        cleanup();
       }
-      ws.close();
     });
     ws.on("close", (code, reason) => {
       setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
       logger.info("WebSocket closed", { code, reason: reason.toString() });
-      printer_default.warn(`Disconnected (code: ${code}). Retrying...`);
+      printer_default.warn(`Disconnected (code: ${code}). Retrying in ${RECONNECT_SLEEP_MS / 1e3}s...`);
       cleanup();
     });
     ws.on("error", (err) => {