pinggy 0.3.7 → 0.3.9

package/dist/index.cjs

@@ -118,6 +118,9 @@ var init_printer = __esm({
         console.error(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Error:")), import_picocolors2.default.red(msg));
         process.exit(1);
       }
+      static red(message) {
+        return import_picocolors2.default.red(message);
+      }
       static warn(message) {
         console.warn(import_picocolors2.default.yellow(import_picocolors2.default.bold("\u26A0 Warning:")), import_picocolors2.default.yellow(message));
       }
@@ -283,22 +286,32 @@ function isValidPort(p) {
   return Number.isInteger(p) && p > 0 && p < 65536;
 }
 function getVersion() {
-  return pkg.version ?? "";
+  try {
+    const packageJsonPath = (0, import_path3.join)(__dirname, "../package.json");
+    const pkg = JSON.parse((0, import_fs3.readFileSync)(packageJsonPath, "utf-8"));
+    return pkg.version ?? "";
+  } catch (error) {
+    printer_default.error("Error reading version info");
+    return "";
+  }
 }
-var import_module, import_crypto, require2, pkg;
+var import_fs3, import_crypto, import_url, import_path3, __filename2, __dirname;
 var init_util = __esm({
   "src/utils/util.ts"() {
     "use strict";
     init_cjs_shims();
-    import_module = require("module");
+    import_fs3 = require("fs");
     import_crypto = require("crypto");
-    require2 = (0, import_module.createRequire)(importMetaUrl);
-    pkg = require2("../package.json");
+    import_url = require("url");
+    import_path3 = require("path");
+    init_printer();
+    __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
+    __dirname = (0, import_path3.dirname)(__filename2);
   }
 });
 
 // src/tunnel_manager/TunnelManager.ts
-var import_pinggy2, import_node_path, import_node_worker_threads, import_node_url, __filename2, __dirname, TunnelManager;
+var import_pinggy2, import_node_path, import_node_worker_threads, import_node_url, __filename3, __dirname2, TunnelManager;
 var init_TunnelManager = __esm({
   "src/tunnel_manager/TunnelManager.ts"() {
     "use strict";
@@ -310,8 +323,8 @@ var init_TunnelManager = __esm({
     import_node_url = require("url");
     init_printer();
     init_util();
-    __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
-    __dirname = import_node_path.default.dirname(__filename2);
+    __filename3 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+    __dirname2 = import_node_path.default.dirname(__filename3);
     TunnelManager = class _TunnelManager {
       constructor() {
         this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
@@ -319,6 +332,7 @@ var init_TunnelManager = __esm({
         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();
@@ -335,12 +349,9 @@ var init_TunnelManager = __esm({
       }
       /**
        * 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
@@ -349,24 +360,19 @@ var init_TunnelManager = __esm({
        *                          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 { 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");
         }
-        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
         });
       }
       /**
@@ -380,7 +386,8 @@ var init_TunnelManager = __esm({
       async _createTunnelWithProcessedConfig(params) {
         let instance;
         try {
-          instance = await import_pinggy2.pinggy.createTunnel(params.configWithForwarding);
+          logger.debug("Creating tunnel instance with processed config", params.originalConfig);
+          instance = await import_pinggy2.pinggy.createTunnel(params.originalConfig);
         } catch (e) {
           logger.error("Error creating tunnel instance:", e);
           throw e;
@@ -388,12 +395,10 @@ var init_TunnelManager = __esm({
         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,
@@ -407,6 +412,7 @@ var init_TunnelManager = __esm({
         });
         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);
@@ -414,44 +420,10 @@ var init_TunnelManager = __esm({
         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
        */
@@ -463,7 +435,7 @@ var init_TunnelManager = __esm({
         try {
           urls = await managed.instance.start();
         } catch (error) {
-          logger.error("Failed to start tunnel", { tunnelId, error });
+          logger.warn("Failed to start tunnel", { tunnelId, error });
           throw error;
         }
         logger.info("Tunnel started", { tunnelId, urls });
@@ -499,7 +471,7 @@ var init_TunnelManager = __esm({
       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) {
@@ -511,6 +483,7 @@ var init_TunnelManager = __esm({
           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);
@@ -522,8 +495,8 @@ var init_TunnelManager = __esm({
           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;
@@ -556,11 +529,10 @@ var init_TunnelManager = __esm({
           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,
               serve: tunnel.serve
             };
           }));
@@ -601,6 +573,15 @@ var init_TunnelManager = __esm({
         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");
       }
       /**
@@ -621,7 +602,7 @@ var init_TunnelManager = __esm({
           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;
       }
       /**
@@ -648,6 +629,7 @@ var init_TunnelManager = __esm({
           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);
@@ -656,7 +638,7 @@ var init_TunnelManager = __esm({
           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 });
         }
@@ -717,21 +699,20 @@ var init_TunnelManager = __esm({
         }
         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);
@@ -740,12 +721,10 @@ var init_TunnelManager = __esm({
           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
           });
@@ -774,20 +753,18 @@ var init_TunnelManager = __esm({
        * @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;
@@ -799,22 +776,19 @@ var init_TunnelManager = __esm({
           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) {
@@ -822,23 +796,21 @@ var init_TunnelManager = __esm({
           }
           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
             });
@@ -954,6 +926,19 @@ var init_TunnelManager = __esm({
         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) {
@@ -1085,6 +1070,22 @@ var init_TunnelManager = __esm({
           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) {
@@ -1202,6 +1203,38 @@ var init_TunnelManager = __esm({
           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 });
+              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);
@@ -1474,9 +1507,9 @@ var init_TunnelManager = __esm({
       }
       startStaticFileServer(managed) {
         try {
-          const __filename3 = (0, import_node_url.fileURLToPath)(importMetaUrl);
-          const __dirname2 = import_node_path.default.dirname(__filename3);
-          const fileServerWorkerPath = import_node_path.default.join(__dirname2, "workers", "file_serve_worker.cjs");
+          const __filename4 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+          const __dirname3 = import_node_path.default.dirname(__filename4);
+          const fileServerWorkerPath = import_node_path.default.join(__dirname3, "workers", "file_serve_worker.cjs");
           const staticServerWorker = new import_node_worker_threads.Worker(fileServerWorkerPath, {
             workerData: {
               dir: managed.serve,
@@ -1628,15 +1661,57 @@ var init_types = __esm({
 });
 
 // src/remote_management/remote_schema.ts
+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 || import_pinggy3.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: import_pinggy3.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,
@@ -1650,18 +1725,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) ?? import_pinggy3.TunnelType.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 ?? import_pinggy3.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 || "",
@@ -1690,16 +1785,17 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
     serve: serve || ""
   };
 }
-var import_pinggy3, import_zod, HeaderModificationSchema, AdditionalForwardingSchema, TunnelConfigSchema, StartSchema, StopSchema, GetSchema, RestartSchema, UpdateConfigSchema;
+var import_pinggy3, import_zod, HeaderModificationSchema, AdditionalForwardingSchema, TunnelConfigSchema, StartSchema, StopSchema, GetSchema, RestartSchema, UpdateConfigSchema, ForwardingEntryV2Schema, TunnelConfigV1Schema, StartV2Schema, UpdateConfigV2Schema;
 var init_remote_schema = __esm({
   "src/remote_management/remote_schema.ts"() {
     "use strict";
     init_cjs_shims();
     import_pinggy3 = require("@pinggy/pinggy");
     import_zod = require("zod");
+    init_util();
     HeaderModificationSchema = import_zod.z.object({
       key: import_zod.z.string(),
-      value: import_zod.z.array(import_zod.z.string()).optional(),
+      value: import_zod.z.array(import_zod.z.string()).nullable().optional(),
       type: import_zod.z.enum(["add", "remove", "update"])
     });
     AdditionalForwardingSchema = import_zod.z.object({
@@ -1715,7 +1811,7 @@ var init_remote_schema = __esm({
       // legacy key
       autoreconnect: import_zod.z.boolean(),
       basicauth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).nullable(),
-      bearerauth: import_zod.z.string().nullable(),
+      bearerauth: import_zod.z.array(import_zod.z.string()).nullable(),
       configid: import_zod.z.string(),
       configname: import_zod.z.string(),
       greetmsg: import_zod.z.string().optional(),
@@ -1772,11 +1868,56 @@ var init_remote_schema = __esm({
     UpdateConfigSchema = import_zod.z.object({
       tunnelConfig: TunnelConfigSchema
     });
+    ForwardingEntryV2Schema = import_zod.z.object({
+      listenAddress: import_zod.z.string().optional(),
+      address: import_zod.z.string(),
+      type: import_zod.z.enum([import_pinggy3.TunnelType.Http, import_pinggy3.TunnelType.Tcp, import_pinggy3.TunnelType.Udp, import_pinggy3.TunnelType.Tls, import_pinggy3.TunnelType.TlsTcp]).optional()
+    });
+    TunnelConfigV1Schema = import_zod.z.object({
+      // Meta Info
+      version: import_zod.z.string(),
+      name: import_zod.z.string(),
+      configId: import_zod.z.string(),
+      // General tunnel configurations
+      serverAddress: import_zod.z.string().optional(),
+      token: import_zod.z.string().optional(),
+      autoReconnect: import_zod.z.boolean().optional(),
+      reconnectInterval: import_zod.z.number().optional(),
+      maxReconnectAttempts: import_zod.z.number().optional(),
+      force: import_zod.z.boolean(),
+      keepAliveInterval: import_zod.z.number().optional(),
+      webDebugger: import_zod.z.string(),
+      //Forwarding
+      // Either a URL string (e.g. "https://localhost:5555") or an array of forwarding entries.
+      forwarding: import_zod.z.union([
+        import_zod.z.string(),
+        import_zod.z.array(ForwardingEntryV2Schema)
+      ]),
+      // IP whitelist 
+      ipWhitelist: import_zod.z.array(import_zod.z.string()).optional(),
+      basicAuth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).optional(),
+      bearerTokenAuth: import_zod.z.array(import_zod.z.string()).optional(),
+      headerModification: import_zod.z.array(HeaderModificationSchema).optional(),
+      reverseProxy: import_zod.z.boolean().optional(),
+      xForwardedFor: import_zod.z.boolean().optional(),
+      httpsOnly: import_zod.z.boolean().optional(),
+      originalRequestUrl: import_zod.z.boolean().optional(),
+      allowPreflight: import_zod.z.boolean().optional(),
+      serve: import_zod.z.string().optional(),
+      optional: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+    });
+    StartV2Schema = import_zod.z.object({
+      tunnelID: import_zod.z.string().nullable().optional(),
+      tunnelConfig: TunnelConfigV1Schema
+    });
+    UpdateConfigV2Schema = import_zod.z.object({
+      tunnelConfig: TunnelConfigV1Schema
+    });
   }
 });
 
 // src/remote_management/handler.ts
-var import_pinggy4, TunnelOperations;
+var TunnelOperations;
 var init_handler = __esm({
   "src/remote_management/handler.ts"() {
     "use strict";
@@ -1784,7 +1925,6 @@ var init_handler = __esm({
     init_types();
     init_TunnelManager();
     init_remote_schema();
-    import_pinggy4 = require("@pinggy/pinggy");
     TunnelOperations = class {
       constructor() {
         this.tunnelManager = TunnelManager.getInstance();
@@ -1803,7 +1943,7 @@ var init_handler = __esm({
         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(),
@@ -1814,11 +1954,27 @@ var init_handler = __esm({
         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,
@@ -1829,19 +1985,28 @@ var init_handler = __esm({
       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] : [import_pinggy4.TunnelType.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, 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.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
+          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");
@@ -1852,20 +2017,59 @@ var init_handler = __esm({
           const opts = tunnelConfigToPinggyOptions(config);
           const tunnel = await this.tunnelManager.updateConfig({
             ...opts,
-            tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy4.TunnelType.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();
@@ -1881,7 +2085,7 @@ var init_handler = __esm({
                 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,
@@ -1897,10 +2101,10 @@ var init_handler = __esm({
       }
       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");
         }
@@ -1909,7 +2113,7 @@ var init_handler = __esm({
         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");
         }
@@ -1919,7 +2123,7 @@ var init_handler = __esm({
           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");
         }
@@ -1962,7 +2166,216 @@ var init_handler = __esm({
   }
 });
 
+// src/remote_management/websocket_printer.ts
+var import_picocolors3, PENDING_START_TIMEOUT_MS, RemoteManagementWebSocketPrinter, remoteManagementWebSocketPrinter;
+var init_websocket_printer = __esm({
+  "src/remote_management/websocket_printer.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_TunnelManager();
+    init_types();
+    init_printer();
+    import_picocolors3 = __toESM(require("picocolors"), 1);
+    PENDING_START_TIMEOUT_MS = 5 * 60 * 1e3;
+    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(import_picocolors3.default.cyanBright("Remote URLs:"));
+          (result.remoteurls ?? []).forEach(
+            (url) => printer_default.print("  " + import_picocolors3.default.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(import_picocolors3.default.cyanBright("Remote URLs:"));
+        (urls ?? []).forEach(
+          (url) => printer_default.print("  " + import_picocolors3.default.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;
+      }
+    };
+    remoteManagementWebSocketPrinter = new RemoteManagementWebSocketPrinter();
+  }
+});
+
 // src/remote_management/websocket_handlers.ts
+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();
@@ -1988,11 +2401,14 @@ var init_websocket_handlers = __esm({
     init_types();
     init_handler();
     init_remote_schema();
+    init_websocket_printer();
     import_zod2 = __toESM(require("zod"), 1);
     init_printer();
+    init_util();
     WebSocketCommandHandler = class {
       constructor() {
         this.tunnelHandler = new TunnelOperations();
+        remoteManagementWebSocketPrinter.setTunnelHandler(this.tunnelHandler);
       }
       safeParse(text) {
         if (!text) return void 0;
@@ -2017,35 +2433,157 @@ var init_websocket_handlers = __esm({
         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 import_zod2.default.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 import_zod2.default.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 import_zod2.default.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 import_zod2.default.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 import_zod2.default.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 import_zod2.default.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 import_zod2.default.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)) {
@@ -2079,6 +2617,10 @@ var init_websocket_handlers = __esm({
               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;
@@ -2095,10 +2637,22 @@ var init_websocket_handlers = __esm({
               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 });
@@ -2145,7 +2699,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);
@@ -2153,11 +2711,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;
@@ -2173,7 +2731,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) });
     }
@@ -2201,6 +2759,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 === import_ws.default.OPEN) ws.ping();
       }, PING_INTERVAL_MS);
@@ -2211,7 +2770,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: "" });
@@ -2222,20 +2785,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) => {
@@ -2325,6 +2889,7 @@ var init_options = __esm({
       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" },
+      force: { type: "boolean", short: "f", description: "Forcefully close existing tunnels and establish a new tunnel" },
       // 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" },
@@ -2340,7 +2905,8 @@ var init_options = __esm({
       // 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" },
+      noTui: { type: "boolean", description: "Disable TUI in remote management mode" },
+      notui: { type: "boolean", description: "hidden", hidden: true },
       // Misc
       version: { type: "boolean", description: "Print version" },
       // Help
@@ -2421,8 +2987,8 @@ var init_defaults = __esm({
 });
 
 // src/cli/extendedOptions.ts
-function parseExtendedOptions(options, config) {
-  if (!options) return;
+function parseExtendedOptions(options, config, localServerTls) {
+  if (!options) return localServerTls;
   for (const opt of options) {
     const [key, value] = opt.replace(/^"|"$/g, "").split(/:(.+)/).filter(Boolean);
     switch (key) {
@@ -2446,10 +3012,16 @@ function parseExtendedOptions(options, config) {
           case "fullrequesturl":
             config.originalRequestUrl = true;
             break;
-          default:
-            printer_default.warn(`Unknown extended option "${key}"`);
-            logger.warn(`Warning: Unknown extended option "${key}"`);
+          default: {
+            if (value && (value.startsWith("localServerTls") || value.startsWith("localservertls"))) {
+              const parts = value.split(/:(.+)/);
+              localServerTls = parts[1] ? parts[1] : "";
+            } else {
+              printer_default.warn(`Unknown extended option "${value}"`);
+              logger.warn(`Warning: Unknown extended option "${value}"`);
+            }
             break;
+          }
         }
         break;
       case "w":
@@ -2520,6 +3092,7 @@ function parseExtendedOptions(options, config) {
         break;
     }
   }
+  return localServerTls;
 }
 function isValidIpV4Cidr(input) {
   if (input.includes("/")) {
@@ -2570,7 +3143,7 @@ function parseUserAndDomain(str) {
     const [user, domain] = str.split("@", 2);
     if (domainRegex.test(domain)) {
       let processKeyword2 = function(keyword) {
-        if ([import_pinggy5.TunnelType.Http, import_pinggy5.TunnelType.Tcp, import_pinggy5.TunnelType.Tls, import_pinggy5.TunnelType.Udp, import_pinggy5.TunnelType.TlsTcp].includes(keyword)) {
+        if ([import_pinggy4.TunnelType.Http, import_pinggy4.TunnelType.Tcp, import_pinggy4.TunnelType.Tls, import_pinggy4.TunnelType.Udp, import_pinggy4.TunnelType.TlsTcp].includes(keyword)) {
           type = keyword;
         } else if (keyword === "force") {
           forceFlag = true;
@@ -2639,9 +3212,9 @@ function parseUsers(positionalArgs, explicitToken) {
   return { token, server, type, forceFlag, qrCode, remaining };
 }
 function parseType(finalConfig, values, inferredType) {
-  const t = inferredType || values.type || finalConfig.tunnelType;
-  if (t === import_pinggy5.TunnelType.Http || t === import_pinggy5.TunnelType.Tcp || t === import_pinggy5.TunnelType.Tls || t === import_pinggy5.TunnelType.Udp || t === import_pinggy5.TunnelType.TlsTcp) {
-    finalConfig.tunnelType = [t];
+  const t = inferredType || values.type;
+  if (t === import_pinggy4.TunnelType.Http || t === import_pinggy4.TunnelType.Tcp || t === import_pinggy4.TunnelType.Tls || t === import_pinggy4.TunnelType.Udp || t === import_pinggy4.TunnelType.TlsTcp) {
+    return t;
   }
 }
 function parseLocalPort(finalConfig, values) {
@@ -2775,15 +3348,14 @@ function parseAdditionalForwarding(forwarding) {
     return new Error("forwarding address incorrect: invalid local port");
   }
   return {
-    protocol,
-    remoteDomain: remoteDomainRaw,
-    remotePort,
-    localDomain,
-    localPort
+    type: protocol,
+    listenAddress: `${remoteDomainRaw}:${remotePort}`,
+    address: `${localDomain}:${localPort}`
   };
 }
-function parseReverseTunnelAddr(finalConfig, values) {
+function parseReverseTunnelAddr(finalConfig, values, primaryType) {
   const reverseTunnel = values.R;
+  let forwardingData = [];
   if ((!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) && !values.localport && !finalConfig.forwarding) {
     return new Error("local port not specified. Please use '-h' option for help.");
   }
@@ -2795,18 +3367,21 @@ function parseReverseTunnelAddr(finalConfig, values) {
     if (slicedForwarding.length === 3) {
       const parsed = parseDefaultForwarding(forwarding);
       if (parsed instanceof Error) return parsed;
-      finalConfig.forwarding = `${parsed.localDomain}:${parsed.localPort}`;
+      forwardingData.push({
+        address: `${parsed.localDomain}:${parsed.localPort}`,
+        type: primaryType || import_pinggy4.TunnelType.Http
+      });
     } else if (slicedForwarding.length === 4) {
-      finalConfig.additionalForwarding ?? (finalConfig.additionalForwarding = []);
       const parsed = parseAdditionalForwarding(forwarding);
       if (parsed instanceof Error) return parsed;
-      finalConfig.additionalForwarding.push(parsed);
+      forwardingData.push(parsed);
     } else {
       return new Error(
         "Incorrect command line arguments: reverse tunnel address incorrect. Please use '-h' option for help."
       );
     }
   }
+  finalConfig.forwarding = forwardingData;
   return null;
 }
 function parseLocalTunnelAddr(finalConfig, values) {
@@ -2842,13 +3417,19 @@ function parseToken(finalConfig, explicitToken) {
   }
 }
 function parseArgs(finalConfig, remainingPositionals) {
-  parseExtendedOptions(remainingPositionals, finalConfig);
+  let localserverTls = "";
+  localserverTls = parseExtendedOptions(remainingPositionals, finalConfig, localserverTls);
+  if (localserverTls.length > 0 && finalConfig.forwarding) {
+    if (typeof finalConfig.forwarding[0] === "object" && "address" in finalConfig.forwarding[0]) {
+      finalConfig.forwarding[0].address = `https://${finalConfig.forwarding[0].address}`;
+    }
+  }
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
     const path5 = saveconf;
     try {
-      import_fs3.default.writeFileSync(path5, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
+      import_fs4.default.writeFileSync(path5, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
       logger.info(`Configuration saved to ${path5}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -2859,9 +3440,9 @@ function storeJson(config, saveconf) {
 function loadJsonConfig(config) {
   const configpath = config["conf"];
   if (typeof configpath === "string" && configpath.trim().length > 0) {
-    const filepath = import_path3.default.resolve(configpath);
+    const filepath = import_path4.default.resolve(configpath);
     try {
-      const data = import_fs3.default.readFileSync(filepath, { encoding: "utf-8" });
+      const data = import_fs4.default.readFileSync(filepath, { encoding: "utf-8" });
       const json = JSON.parse(data);
       return json;
     } catch (err) {
@@ -2880,7 +3461,7 @@ function isSaveConfOption(values) {
 function parseServe(finalConfig, values) {
   const sv = values.serve;
   if (typeof sv !== "string" || sv.trim().length === 0) return null;
-  finalConfig.serve = sv;
+  finalConfig.optional.serve = sv;
   return null;
 }
 function parseAutoReconnect(finalConfig, values) {
@@ -2918,21 +3499,23 @@ async function buildFinalConfig(values, positionals) {
     ...defaultOptions,
     ...configFromFile || {},
     // Apply loaded config on top of defaults
-    configid: getRandomId(),
+    configId: getRandomId(),
     token: token || (configFromFile?.token || (typeof values.token === "string" ? values.token : "")),
     serverAddress: server || (configFromFile?.serverAddress || defaultOptions.serverAddress),
-    tunnelType: initialTunnel ? [initialTunnel] : configFromFile?.tunnelType || [import_pinggy5.TunnelType.Http],
-    NoTUI: values.notui || (configFromFile?.NoTUI || false),
-    qrCode: qrCode || (configFromFile?.qrCode || false),
-    autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect
+    isQRCode: qrCode || (configFromFile?.isQRCode || false),
+    autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect,
+    optional: {
+      serve: configFromFile?.optional?.serve || void 0,
+      noTui: values.noTui || values.notui || (configFromFile?.optional?.noTui || false)
+    }
   };
-  parseType(finalConfig, values, type);
+  type = 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);
+  const rErr = parseReverseTunnelAddr(finalConfig, values, type);
   if (rErr instanceof Error) throw rErr;
   const lErr = parseLocalTunnelAddr(finalConfig, values);
   if (lErr instanceof Error) throw lErr;
@@ -2940,12 +3523,12 @@ async function buildFinalConfig(values, positionals) {
   if (serveErr instanceof Error) throw serveErr;
   const autoReconnectErr = parseAutoReconnect(finalConfig, values);
   if (autoReconnectErr instanceof Error) throw autoReconnectErr;
-  if (forceFlag) finalConfig.force = true;
+  if (forceFlag || values.force) finalConfig.force = true;
   parseArgs(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
 }
-var import_pinggy5, import_fs3, import_path3, domainRegex, KEYWORDS, VALID_PROTOCOLS;
+var import_pinggy4, import_fs4, import_path4, domainRegex, KEYWORDS, VALID_PROTOCOLS;
 var init_buildConfig = __esm({
   "src/cli/buildConfig.ts"() {
     "use strict";
@@ -2954,16 +3537,16 @@ var init_buildConfig = __esm({
     init_extendedOptions();
     init_logger();
     init_util();
-    import_pinggy5 = require("@pinggy/pinggy");
-    import_fs3 = __toESM(require("fs"), 1);
-    import_path3 = __toESM(require("path"), 1);
+    import_pinggy4 = require("@pinggy/pinggy");
+    import_fs4 = __toESM(require("fs"), 1);
+    import_path4 = __toESM(require("path"), 1);
     domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
     KEYWORDS = /* @__PURE__ */ new Set([
-      import_pinggy5.TunnelType.Http,
-      import_pinggy5.TunnelType.Tcp,
-      import_pinggy5.TunnelType.Tls,
-      import_pinggy5.TunnelType.Udp,
-      import_pinggy5.TunnelType.TlsTcp,
+      import_pinggy4.TunnelType.Http,
+      import_pinggy4.TunnelType.Tcp,
+      import_pinggy4.TunnelType.Tls,
+      import_pinggy4.TunnelType.Udp,
+      import_pinggy4.TunnelType.TlsTcp,
       "force",
       "qr"
     ]);
@@ -3000,7 +3583,7 @@ function preprocessWindowsArgs(args) {
 function parseCliArgs(options) {
   const rawArgs = process.argv.slice(2);
   const processedArgs = preprocessWindowsArgs(rawArgs);
-  const parsed = (0, import_util4.parseArgs)({
+  const parsed = (0, import_util6.parseArgs)({
     args: processedArgs,
     options,
     allowPositionals: true
@@ -3011,12 +3594,12 @@ function parseCliArgs(options) {
     hasAnyArgs
   };
 }
-var import_util4, os2;
+var import_util6, os2;
 var init_parseArgs = __esm({
   "src/utils/parseArgs.ts"() {
     "use strict";
     init_cjs_shims();
-    import_util4 = require("util");
+    import_util6 = require("util");
     os2 = __toESM(require("os"), 1);
   }
 });
@@ -4448,7 +5031,7 @@ async function launchTui(finalConfig, urls, greet, tunnel) {
   }
 }
 async function startCli(finalConfig, manager) {
-  if (!finalConfig.NoTUI && finalConfig.webDebugger === "") {
+  if (!finalConfig.optional?.noTui && finalConfig.webDebugger === "") {
     const freePort = await getFreePort(finalConfig.webDebugger || "");
     finalConfig.webDebugger = `localhost:${freePort}`;
   }
@@ -4456,7 +5039,7 @@ async function startCli(finalConfig, manager) {
     const manager2 = TunnelManager.getInstance();
     const tunnel = await manager2.createTunnel(finalConfig);
     printer_default.startSpinner("Connecting to Pinggy...");
-    if (!finalConfig.NoTUI) {
+    if (!finalConfig.optional?.noTui) {
       manager2.registerStatsListener(tunnel.tunnelid, (tunnelId, stats) => {
         globalThis.__PINGGY_TUNNEL_STATS__?.(stats);
       });
@@ -4466,26 +5049,26 @@ async function startCli(finalConfig, manager) {
     });
     await manager2.startTunnel(tunnel.tunnelid);
     printer_default.stopSpinnerSuccess(" Connected to Pinggy");
-    printer_default.success(import_picocolors3.default.bold("Tunnel established!"));
-    printer_default.print(import_picocolors3.default.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.success(import_picocolors4.default.bold("Tunnel established!"));
+    printer_default.print(import_picocolors4.default.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(import_picocolors3.default.cyanBright("Remote URLs:"));
+    printer_default.info(import_picocolors4.default.cyanBright("Remote URLs:"));
     (TunnelData.urls ?? []).forEach(
-      (url) => printer_default.print("  " + import_picocolors3.default.magentaBright(url))
+      (url) => printer_default.print("  " + import_picocolors4.default.magentaBright(url))
     );
-    printer_default.print(import_picocolors3.default.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(import_picocolors4.default.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(import_picocolors3.default.yellowBright(TunnelData.greet));
+      printer_default.warn(import_picocolors4.default.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(import_picocolors3.default.cyanBright("Authenticated as: " + email));
+        printer_default.info(import_picocolors4.default.cyanBright("Authenticated as: " + email));
       }
     }
-    printer_default.print(import_picocolors3.default.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(import_picocolors3.default.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+    printer_default.print(import_picocolors4.default.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(import_picocolors4.default.gray("\nPress Ctrl+C to stop the tunnel.\n"));
     manager2.registerWillReconnectListener(tunnel.tunnelid, (tunnelId, error, messages) => {
       if (activeTui) {
         const msg = messages?.join("\n") || error || "Tunnel disconnected, reconnecting...";
@@ -4555,34 +5138,34 @@ async function startCli(finalConfig, manager) {
           printer_default.stopSpinnerSuccess("Reconnected to Pinggy");
         } catch (e) {
         }
-        printer_default.success(import_picocolors3.default.bold("Tunnel re-established!"));
-        printer_default.print(import_picocolors3.default.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.success(import_picocolors4.default.bold("Tunnel re-established!"));
+        printer_default.print(import_picocolors4.default.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(import_picocolors3.default.cyanBright("Remote URLs:"));
+        printer_default.info(import_picocolors4.default.cyanBright("Remote URLs:"));
         (TunnelData.urls ?? []).forEach(
-          (url) => printer_default.print("  " + import_picocolors3.default.magentaBright(url))
+          (url) => printer_default.print("  " + import_picocolors4.default.magentaBright(url))
         );
-        printer_default.print(import_picocolors3.default.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(import_picocolors4.default.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(import_picocolors3.default.yellowBright(TunnelData.greet));
+          printer_default.warn(import_picocolors4.default.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(import_picocolors3.default.cyanBright("Authenticated as: " + email));
+            printer_default.info(import_picocolors4.default.cyanBright("Authenticated as: " + email));
           }
         }
-        printer_default.print(import_picocolors3.default.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(import_picocolors3.default.gray("\nPress Ctrl+C to stop the tunnel.\n"));
-        if (!finalConfig.NoTUI) {
+        printer_default.print(import_picocolors4.default.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(import_picocolors4.default.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+        if (!finalConfig.optional?.noTui) {
           await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
         }
       });
     } catch (e) {
       logger.debug("Failed to register start listener", e);
     }
-    if (!finalConfig.NoTUI) {
+    if (!finalConfig.optional?.noTui) {
       await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
     }
   } catch (err) {
@@ -4591,7 +5174,7 @@ async function startCli(finalConfig, manager) {
     throw err;
   }
 }
-var import_picocolors3, TunnelData, activeTui, disconnectState;
+var import_picocolors4, TunnelData, activeTui, disconnectState;
 var init_starCli = __esm({
   "src/cli/starCli.ts"() {
     "use strict";
@@ -4600,7 +5183,7 @@ var init_starCli = __esm({
     init_TunnelManager();
     init_getFreePort();
     init_logger();
-    import_picocolors3 = __toESM(require("picocolors"), 1);
+    import_picocolors4 = __toESM(require("picocolors"), 1);
     init_blessed();
     TunnelData = {
       urls: null,
@@ -4657,7 +5240,7 @@ async function main() {
     printer_default.error(error);
   }
 }
-var import_url, import_process, import_fs4, currentFile, entryFile;
+var import_url2, import_process, import_fs5, currentFile, entryFile;
 var init_main = __esm({
   "src/main.ts"() {
     "use strict";
@@ -4673,15 +5256,15 @@ var init_main = __esm({
     init_starCli();
     init_util();
     init_handler();
-    import_url = require("url");
+    import_url2 = require("url");
     import_process = require("process");
-    import_fs4 = require("fs");
+    import_fs5 = require("fs");
     init_logger();
     init_remoteManagement();
-    currentFile = (0, import_url.fileURLToPath)(importMetaUrl);
+    currentFile = (0, import_url2.fileURLToPath)(importMetaUrl);
     entryFile = null;
     try {
-      entryFile = import_process.argv[1] ? (0, import_fs4.realpathSync)(import_process.argv[1]) : null;
+      entryFile = import_process.argv[1] ? (0, import_fs5.realpathSync)(import_process.argv[1]) : null;
     } catch (e) {
       entryFile = null;
     }