pinggy 0.4.5 → 0.4.7

package/dist/index.cjs

@@ -116,6 +116,11 @@ var init_printer = __esm({
         const def = this.errorDefinitions.find((d) => d.match(err));
         const msg = def.message(err);
         console.error(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Error:")), import_picocolors2.default.red(msg));
+      }
+      static fatal(err) {
+        const def = this.errorDefinitions.find((d) => d.match(err));
+        const msg = def.message(err);
+        console.error(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Fatal Error:")), import_picocolors2.default.red(msg));
         process.exit(1);
       }
       static red(message) {
@@ -254,7 +259,9 @@ function enablePackageLogging(opts) {
   return applyLoggingConfig(opts ?? {});
 }
 function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
-  if (!loglevel) return;
+  if (!loglevel) {
+    return;
+  }
   const l = loglevel.toUpperCase();
   if (loglevel === "DEBUG") {
     import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.DEBUG, logFilePath);
@@ -430,7 +437,9 @@ var init_TunnelManager = __esm({
        */
       async startTunnel(tunnelId) {
         const managed = this.tunnelsByTunnelId.get(tunnelId);
-        if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
+        if (!managed) {
+          throw new Error(`Tunnel with id "${tunnelId}" not found`);
+        }
         logger.info("Starting tunnel", { tunnelId });
         let urls;
         try {
@@ -478,7 +487,9 @@ var init_TunnelManager = __esm({
        */
       stopTunnel(tunnelId) {
         const managed = this.tunnelsByTunnelId.get(tunnelId);
-        if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
         logger.info("Stopping tunnel", { tunnelId, configId: managed.configId });
         try {
           managed.instance.stop();
@@ -659,12 +670,16 @@ var init_TunnelManager = __esm({
       getTunnelInstance(configId, tunnelId) {
         if (configId) {
           const managed = this.tunnelsByConfigId.get(configId);
-          if (!managed) throw new Error(`Tunnel "${configId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${configId}" not found`);
+          }
           return managed.instance;
         }
         if (tunnelId) {
           const managed = this.tunnelsByTunnelId.get(tunnelId);
-          if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+          }
           return managed.instance;
         }
         throw new Error(`Either configId or tunnelId must be provided`);
@@ -843,12 +858,16 @@ var init_TunnelManager = __esm({
       getManagedTunnel(configId, tunnelId) {
         if (configId) {
           const managed = this.tunnelsByConfigId.get(configId);
-          if (!managed) throw new Error(`Tunnel "${configId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${configId}" not found`);
+          }
           return managed;
         }
         if (tunnelId) {
           const managed = this.tunnelsByTunnelId.get(tunnelId);
-          if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+          }
           return managed;
         }
         throw new Error(`Either configId or tunnelId must be provided`);
@@ -1237,7 +1256,9 @@ var init_TunnelManager = __esm({
       notifyPollingErrorListeners(tunnelId, errorMsg) {
         try {
           const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
-          if (!listeners) return;
+          if (!listeners) {
+            return;
+          }
           for (const [id, listener] of listeners) {
             try {
               listener(tunnelId, errorMsg);
@@ -1252,7 +1273,9 @@ var init_TunnelManager = __esm({
       notifyErrorListeners(tunnelId, errorMsg, isFatal) {
         try {
           const listeners = this.tunnelErrorListeners.get(tunnelId);
-          if (!listeners) return;
+          if (!listeners) {
+            return;
+          }
           for (const [id, listener] of listeners) {
             try {
               listener(tunnelId, errorMsg, isFatal);
@@ -1301,7 +1324,9 @@ var init_TunnelManager = __esm({
                 managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
               }
               const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error, messages);
@@ -1329,7 +1354,9 @@ var init_TunnelManager = __esm({
             try {
               logger.info("Tunnel will reconnect", { tunnelId, error, messages });
               const listeners = this.tunnelWillReconnectListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error, messages);
@@ -1357,7 +1384,9 @@ var init_TunnelManager = __esm({
             try {
               logger.info("Tunnel reconnecting", { tunnelId, retryCnt });
               const listeners = this.tunnelReconnectingListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, retryCnt);
@@ -1435,7 +1464,9 @@ var init_TunnelManager = __esm({
                 managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
               }
               const listeners = this.tunnelReconnectionFailedListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, retryCnt);
@@ -1459,7 +1490,9 @@ var init_TunnelManager = __esm({
             try {
               logger.debug("Error in Tunnel Worker", { tunnelId, errorMessage: error.message });
               const listeners = this.tunnelWorkerErrorListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error);
@@ -1945,6 +1978,7 @@ var init_handler = __esm({
     "use strict";
     init_cjs_shims();
     init_types();
+    init_logger();
     init_TunnelManager();
     init_remote_schema();
     TunnelOperations = class {
@@ -1967,6 +2001,26 @@ var init_handler = __esm({
         }
         return status;
       }
+      // --- Placeholder response ---
+      buildPendingTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
+        return {
+          tunnelid,
+          remoteurls: [],
+          tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, false, void 0, serve),
+          status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
+          stats: newStats()
+        };
+      }
+      buildPendingTunnelResponseV2(tunnelid, tunnelConfig, configFromCli, configid, tunnelName, serve) {
+        return {
+          tunnelid,
+          remoteurls: [],
+          tunnelconfig: pinggyOptionsToTunnelConfigV1(tunnelConfig, configFromCli),
+          status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
+          stats: newStats(),
+          greetmsg: ""
+        };
+      }
       // --- Helper to construct TunnelResponse ---
       async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
         const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
@@ -2007,10 +2061,10 @@ var init_handler = __esm({
         });
       }
       // --- Operations ---
-      async handleStart(config) {
+      async handleStart(config, noWait = false) {
         try {
           const opts = tunnelConfigToPinggyOptions(config);
-          const { tunnelid, instance, tunnelName, serve, tunnelConfig } = await this.tunnelManager.createTunnel({
+          const managed = await this.tunnelManager.createTunnel({
             ...opts,
             configId: config.configid,
             name: config.configname,
@@ -2018,36 +2072,52 @@ var init_handler = __esm({
               serve: config.serve
             }
           });
-          await this.tunnelManager.startTunnel(tunnelid);
+          const { tunnelid, tunnelName, serve, tunnelConfig } = managed;
+          const startPromise = this.tunnelManager.startTunnel(tunnelid);
+          if (noWait) {
+            startPromise.catch((err) => {
+              logger.error("No-wait startTunnel failed", { tunnelid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(tunnelid, tunnelConfig, config.configid, tunnelName, serve);
+          }
+          await startPromise;
           const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-          const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
-          return resp;
+          return this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
         } catch (err) {
           return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
         }
       }
-      async handleStartV2(config) {
+      async handleStartV2(config, noWait = false) {
         try {
-          const { tunnelid, instance, serve } = await this.tunnelManager.createTunnel(config);
+          const managed = await this.tunnelManager.createTunnel(config);
+          const { tunnelid, serve, tunnelConfig } = managed;
           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;
+          return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
         } catch (err) {
           return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
         }
       }
-      async handleUpdateConfig(config) {
+      async handleUpdateConfig(config, noWait = false) {
         try {
           const opts = tunnelConfigToPinggyOptions(config);
-          const tunnel = await this.tunnelManager.updateConfig({
+          const updateOpts = {
             ...opts,
             configId: config.configid,
             name: config.configname,
             optional: {
               serve: config.serve
             }
-          });
+          };
+          if (noWait) {
+            const existing = this.tunnelManager.getManagedTunnel(config.configid);
+            if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+            this.tunnelManager.updateConfig(updateOpts).catch((err) => {
+              logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(existing.tunnelid, existing.tunnelConfig, config.configid, existing.tunnelName, existing.serve);
+          }
+          const tunnel = await this.tunnelManager.updateConfig(updateOpts);
           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.serve);
@@ -2055,8 +2125,17 @@ var init_handler = __esm({
           return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
         }
       }
-      async handleUpdateConfigV2(config) {
+      async handleUpdateConfigV2(config, noWait = false) {
         try {
+          if (noWait) {
+            const existing = this.tunnelManager.getManagedTunnel(config.configId);
+            console.log(existing);
+            if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+            this.tunnelManager.updateConfig(config).catch((err) => {
+              logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
+            });
+            return this.buildPendingTunnelResponseV2(existing.tunnelid, existing.tunnelConfig, config, config.configId, existing.tunnelName, existing.serve);
+          }
           const tunnel = await this.tunnelManager.updateConfig(config);
           if (!tunnel.instance || !tunnel.tunnelConfig)
             throw new Error("Invalid tunnel state after configuration update");
@@ -2143,8 +2222,16 @@ var init_handler = __esm({
           return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
         }
       }
-      async handleRestart(tunnelid) {
+      async handleRestart(tunnelid, noWait = false) {
         try {
+          if (noWait) {
+            const managed2 = this.tunnelManager.getManagedTunnel("", tunnelid);
+            if (!managed2?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            this.tunnelManager.restartTunnel(tunnelid).catch((err) => {
+              logger.error("No-wait restartTunnel failed", { tunnelid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(tunnelid, managed2.tunnelConfig, managed2.configId, managed2.tunnelName, managed2.serve);
+          }
           await this.tunnelManager.restartTunnel(tunnelid);
           const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
           if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
@@ -2463,7 +2550,7 @@ var init_websocket_handlers = __esm({
           const dc = StartSchema.parse(raw);
           queuedConfig = dc.tunnelConfig;
           remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-          const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleStart(dc.tunnelConfig, true);
           remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2484,7 +2571,7 @@ var init_websocket_handlers = __esm({
           const dc = StartV2Schema.parse(raw);
           queuedConfig = dc.tunnelConfig;
           remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-          const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig, true);
           remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2533,7 +2620,7 @@ var init_websocket_handlers = __esm({
         try {
           const dc = RestartSchema.parse(raw);
           remoteManagementWebSocketPrinter.printRestartRequested(dc.tunnelID);
-          const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
+          const result = await this.tunnelHandler.handleRestart(dc.tunnelID, true);
           remoteManagementWebSocketPrinter.handleRestartResult(dc.tunnelID, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2548,7 +2635,7 @@ var init_websocket_handlers = __esm({
       async handleUpdateConfigReq(req, raw) {
         try {
           const dc = UpdateConfigSchema.parse(raw);
-          const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig, true);
           return this.wrapResponse(result, req);
         } catch (e) {
           if (e instanceof import_zod2.default.ZodError) {
@@ -2562,7 +2649,7 @@ var init_websocket_handlers = __esm({
       async handleUpdateConfigV2Req(req, raw) {
         try {
           const dc = UpdateConfigV2Schema.parse(raw);
-          const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig, true);
           return this.wrapResponse(result, req);
         } catch (e) {
           if (e instanceof import_zod2.default.ZodError) {
@@ -2758,9 +2845,14 @@ async function initiateRemoteManagement(remoteManagementConfig) {
     try {
       await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey);
     } catch (error) {
+      if (error instanceof RemoteManagementUnauthorizedError) {
+        throw error;
+      }
       logger.warn("Remote management connection error", { error: String(error) });
     }
-    if (_stopRequested) break;
+    if (_stopRequested) {
+      break;
+    }
     printer_default.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds...`);
     logger.info("Reconnecting to remote management after disconnect");
     await sleep(RECONNECT_SLEEP_MS);
@@ -2769,22 +2861,34 @@ async function initiateRemoteManagement(remoteManagementConfig) {
   logger.info("Remote management stopped.");
   return getRemoteManagementState();
 }
-async function handleWebSocketConnection(wsUrl, wsHost, token) {
-  return new Promise((resolve) => {
+async function handleWebSocketConnection(wsUrl, wsHost, token, onOpenCallback) {
+  return new Promise((resolve, reject) => {
     const ws = new import_ws.default(wsUrl, {
       headers: { Authorization: `Bearer ${token}` }
     });
     currentWs = ws;
     let heartbeat = null;
     let firstMessage = true;
-    const cleanup = () => {
-      if (heartbeat) clearInterval(heartbeat);
+    let settled = false;
+    const cleanup = (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (heartbeat) {
+        clearInterval(heartbeat);
+      }
       currentWs = null;
-      resolve();
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
     };
     ws.once("open", () => {
       printer_default.success(`Connected to ${wsHost}`);
       setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
+      onOpenCallback?.();
       heartbeat = setInterval(() => {
         if (ws.readyState === import_ws.default.OPEN) ws.ping();
       }, PING_INTERVAL_MS);
@@ -2812,13 +2916,14 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
     ws.on("unexpected-response", (_, res) => {
       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");
+        cleanup(new RemoteManagementUnauthorizedError());
         ws.close();
       } else {
         logger.warn("Unexpected HTTP response ", { statusCode: res.statusCode });
         printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
         cleanup();
+        ws.close();
       }
     });
     ws.on("close", (code, reason) => {
@@ -2830,7 +2935,7 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
     ws.on("error", (err) => {
       setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
       logger.warn("WebSocket error", { error: err.message });
-      printer_default.error(err);
+      printer_default.warn(err.message);
       cleanup();
     });
   });
@@ -2860,6 +2965,58 @@ async function closeRemoteManagement(timeoutMs = 1e4) {
     return getRemoteManagementState();
   }
 }
+function startRemoteManagement(remoteManagementConfig) {
+  if (!remoteManagementConfig.apiKey || remoteManagementConfig.apiKey.trim().length === 0) {
+    return Promise.reject(new Error("Remote management token is required"));
+  }
+  const wsUrl = remoteManagementConfig.serverUrl;
+  const wsHost = extractHostname(wsUrl);
+  logger.info("Remote management mode enabled.");
+  _stopRequested = false;
+  return new Promise((resolve, reject) => {
+    let firstSettled = false;
+    const settleOnce = (err) => {
+      if (firstSettled) {
+        return;
+      }
+      firstSettled = true;
+      if (err) {
+        reject(err);
+      } else {
+        resolve(getRemoteManagementState());
+      }
+    };
+    const runLoop = async () => {
+      const sigintHandler = () => {
+        _stopRequested = true;
+      };
+      process.once("SIGINT", sigintHandler);
+      while (!_stopRequested) {
+        logger.info("Connecting to remote management", { wsUrl });
+        setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
+        try {
+          await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey, () => settleOnce());
+        } catch (error) {
+          if (error instanceof RemoteManagementUnauthorizedError) {
+            settleOnce(error);
+            process.removeListener("SIGINT", sigintHandler);
+            return;
+          }
+          settleOnce();
+          logger.warn("Remote management connection error", { error: String(error) });
+        }
+        if (_stopRequested) {
+          break;
+        }
+        logger.info("Reconnecting to remote management after disconnect");
+        await sleep(RECONNECT_SLEEP_MS);
+      }
+      process.removeListener("SIGINT", sigintHandler);
+      logger.info("Remote management stopped.");
+    };
+    runLoop().catch((err) => settleOnce(err instanceof Error ? err : new Error(String(err))));
+  });
+}
 function getRemoteManagementState() {
   return _remoteManagementState;
 }
@@ -2869,7 +3026,7 @@ function setRemoteManagementState(state, errorMessage) {
     errorMessage: errorMessage || ""
   };
 }
-var import_ws, RECONNECT_SLEEP_MS, PING_INTERVAL_MS, _remoteManagementState, _stopRequested, currentWs;
+var import_ws, RECONNECT_SLEEP_MS, PING_INTERVAL_MS, RemoteManagementUnauthorizedError, _remoteManagementState, _stopRequested, currentWs;
 var init_remoteManagement = __esm({
   "src/remote_management/remoteManagement.ts"() {
     "use strict";
@@ -2881,6 +3038,12 @@ var init_remoteManagement = __esm({
     init_types();
     RECONNECT_SLEEP_MS = 5e3;
     PING_INTERVAL_MS = 3e4;
+    RemoteManagementUnauthorizedError = class extends Error {
+      constructor() {
+        super("Unauthorized. Please enter a valid token.");
+        this.name = "RemoteManagementUnauthorizedError";
+      }
+    };
     _remoteManagementState = {
       status: "NOT_RUNNING",
       errorMessage: ""
@@ -2922,9 +3085,13 @@ var init_options = __esm({
       vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
       vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
       autoreconnect: { type: "string", short: "a", description: "Automatically reconnect tunnel on failure (enabled by default). Use -a false to disable." },
-      // Save and load config
+      // Save and load config (legacy file-based)
       saveconf: { type: "string", description: "Create the configuration file based on the options provided here" },
       conf: { type: "string", description: "Use the configuration file as base. Other options will be used to override this file" },
+      // Used by `pinggy config save` and `buildAndStartTunnel` save flow
+      save: { type: "boolean", short: "s", description: "Save the tunnel config (use with config save or -l)", hidden: true },
+      name: { type: "string", description: "Name for the tunnel config", hidden: true },
+      auto: { type: "boolean", description: "Mark tunnel config for auto-start", hidden: true },
       // File server
       serve: { type: "string", description: "Start a webserver to serve files from the specified path. Eg --serve /path/to/files" },
       // Remote Control
@@ -2974,7 +3141,21 @@ function printHelpMessage() {
   console.log("  pinggy -R0:localhost:3000                        # Basic HTTP tunnel");
   console.log("  pinggy --type tcp -R0:localhost:22               # TCP tunnel for SSH");
   console.log("  pinggy -R0:localhost:8080 -L4300:localhost:4300  # HTTP tunnel with debugger");
-  console.log("  pinggy tcp@ap.example.com -R0:localhost:22       # TCP tunnel to region\n");
+  console.log("  pinggy tcp@ap.example.com -R0:localhost:22       # TCP tunnel to region");
+  console.log("\nConfig Management:");
+  console.log("  pinggy config list                                           # List saved configs");
+  console.log("  pinggy config show my-tunnel                                 # Show config details");
+  console.log("  pinggy config save my-tunnel -l 3000 token@pro.pinggy.io     # Save config");
+  console.log("  pinggy config save my-tunnel --auto -l 3000                  # Save with auto-start");
+  console.log("  pinggy config update my-tunnel -l 4000                       # Update saved config");
+  console.log("  pinggy config delete my-tunnel                               # Delete saved config");
+  console.log("  pinggy config auto my-tunnel                                 # Enable auto-start");
+  console.log("  pinggy config noauto my-tunnel                               # Disable auto-start");
+  console.log("\nStart Saved Tunnels:");
+  console.log("  pinggy start my-tunnel                                       # Start saved tunnel");
+  console.log("  pinggy start my-tunnel -l 4000                               # Start with runtime overrides");
+  console.log("  pinggy start tunnela tunnelb                                 # Start multiple tunnels");
+  console.log("  pinggy start --all                                           # Start all auto-start tunnels\n");
 }
 var init_help = __esm({
   "src/cli/help.ts"() {
@@ -2984,6 +3165,74 @@ var init_help = __esm({
   }
 });
 
+// src/utils/parseArgs.ts
+function isAttachedReverseOrLocalFlag(arg) {
+  return /^-[RL].+/.test(arg);
+}
+function shouldMergeReverseOrLocalFragment(current, next) {
+  if (next.startsWith("-")) {
+    return false;
+  }
+  if (next.startsWith(".")) {
+    return true;
+  }
+  const body = current.slice(2);
+  if (body.endsWith(":")) {
+    return true;
+  }
+  if (body.includes("//") && !body.includes(":")) {
+    return true;
+  }
+  return false;
+}
+function preprocessWindowsArgs(args) {
+  if (os2.platform() !== "win32") {
+    return args;
+  }
+  ;
+  const out = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (isAttachedReverseOrLocalFlag(arg)) {
+      let merged = arg;
+      while (i + 1 < args.length && shouldMergeReverseOrLocalFragment(merged, args[i + 1])) {
+        merged += args[i + 1];
+        i++;
+      }
+      out.push(merged);
+      i++;
+      continue;
+    }
+    out.push(arg);
+    i++;
+  }
+  return out;
+}
+function parseCliArgs(options, overrideArgs) {
+  const rawArgs = overrideArgs ?? process.argv.slice(2);
+  const processedArgs = preprocessWindowsArgs(rawArgs);
+  const parsed = (0, import_util5.parseArgs)({
+    args: processedArgs,
+    options,
+    allowPositionals: true
+  });
+  const hasAnyArgs = parsed.positionals.length > 0 || Object.values(parsed.values).some((v) => v !== void 0 && v !== false);
+  return {
+    ...parsed,
+    hasAnyArgs
+  };
+}
+var import_util5, os2;
+var init_parseArgs = __esm({
+  "src/utils/parseArgs.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_util5 = require("util");
+    os2 = __toESM(require("os"), 1);
+  }
+});
+
 // src/cli/defaults.ts
 var defaultOptions;
 var init_defaults = __esm({
@@ -2991,6 +3240,7 @@ var init_defaults = __esm({
     "use strict";
     init_cjs_shims();
     defaultOptions = {
+      version: "1.0",
       token: void 0,
       // No default token
       serverAddress: "a.pinggy.io",
@@ -3162,7 +3412,9 @@ function removeIPv6Brackets(ip) {
 }
 function isValidServerAddress(host) {
   const normalized = removeIPv6Brackets(host.trim());
-  if (!normalized) return false;
+  if (!normalized) {
+    return false;
+  }
   return domainRegex.test(normalized) || (0, import_net2.isIP)(normalized) !== 0;
 }
 function isKeyword(str) {
@@ -3174,7 +3426,9 @@ function parseUserAndDomain(str) {
   let server;
   let qrCode;
   let forceFlag;
-  if (!str) return { token, type, server, qrCode, forceFlag };
+  if (!str) {
+    return { token, type, server, qrCode, forceFlag };
+  }
   if (str.includes("@")) {
     const [user, domain] = str.split("@", 2);
     if (isValidServerAddress(domain)) {
@@ -3227,21 +3481,39 @@ function parseUsers(positionalArgs, explicitToken) {
   let remaining = [...positionalArgs];
   if (typeof explicitToken === "string") {
     const parsed = parseUserAndDomain(explicitToken);
-    if (parsed.server) server = parsed.server;
-    if (parsed.type) type = parsed.type;
-    if (parsed.token) token = parsed.token;
-    if (parsed.forceFlag) forceFlag = true;
-    if (parsed.qrCode) qrCode = true;
+    if (parsed.server) {
+      server = parsed.server;
+    }
+    if (parsed.type) {
+      type = parsed.type;
+    }
+    if (parsed.token) {
+      token = parsed.token;
+    }
+    if (parsed.forceFlag) {
+      forceFlag = true;
+    }
+    if (parsed.qrCode) {
+      qrCode = true;
+    }
   }
   if (remaining.length > 0) {
     const first = remaining[0];
     const parsed = parseUserAndDomain(first);
     if (parsed.server) {
       server = parsed.server;
-      if (parsed.type) type = parsed.type;
-      if (parsed.token) token = parsed.token;
-      if (parsed.forceFlag) forceFlag = true;
-      if (parsed.qrCode) qrCode = true;
+      if (parsed.type) {
+        type = parsed.type;
+      }
+      if (parsed.token) {
+        token = parsed.token;
+      }
+      if (parsed.forceFlag) {
+        forceFlag = true;
+      }
+      if (parsed.qrCode) {
+        qrCode = true;
+      }
       remaining = remaining.slice(1);
     }
   }
@@ -3254,7 +3526,9 @@ function parseType(finalConfig, values, inferredType) {
   }
 }
 function parseLocalPort(finalConfig, values) {
-  if (typeof values.localport !== "string") return null;
+  if (typeof values.localport !== "string") {
+    return null;
+  }
   let lp = values.localport.trim();
   let isHttps = false;
   if (lp.startsWith("https://")) {
@@ -3286,7 +3560,9 @@ function parseLocalPort(finalConfig, values) {
 }
 function isValidHostAddress(host) {
   const normalized = removeIPv6Brackets(host.trim());
-  if (normalized.length === 0) return false;
+  if (normalized.length === 0) {
+    return false;
+  }
   return normalized === "localhost" || (0, import_net2.isIP)(normalized) !== 0;
 }
 function ipv6SafeSplitColon(s) {
@@ -3329,7 +3605,9 @@ function parseDefaultForwarding(forwarding) {
 }
 function parseAdditionalForwarding(forwarding) {
   const toPort = (v) => {
-    if (!v) return null;
+    if (!v) {
+      return null;
+    }
     const n = parseInt(v, 10);
     return Number.isNaN(n) ? null : n;
   };
@@ -3408,7 +3686,9 @@ function parseReverseTunnelAddr(finalConfig, values, primaryType) {
       });
     } else if (slicedForwarding.length === 4) {
       const parsed = parseAdditionalForwarding(forwarding);
-      if (parsed instanceof Error) return parsed;
+      if (parsed instanceof Error) {
+        return parsed;
+      }
       forwardingData.push(parsed);
     } else {
       return new Error(
@@ -3420,7 +3700,9 @@ function parseReverseTunnelAddr(finalConfig, values, primaryType) {
   return null;
 }
 function parseLocalTunnelAddr(finalConfig, values) {
-  if (!Array.isArray(values.L) || values.L.length === 0) return null;
+  if (!Array.isArray(values.L) || values.L.length === 0) {
+    return null;
+  }
   const firstL = values.L[0];
   const parts = ipv6SafeSplitColon(firstL);
   let debuggerHost = "localhost";
@@ -3444,7 +3726,9 @@ function parseLocalTunnelAddr(finalConfig, values) {
 }
 function parseDebugger(finalConfig, values) {
   let dbg = values.debugger;
-  if (typeof dbg !== "string") return;
+  if (typeof dbg !== "string") {
+    return;
+  }
   dbg = dbg.startsWith(":") ? dbg.slice(1) : dbg;
   const d = parseInt(dbg, 10);
   if (!Number.isNaN(d) && isValidPort(d)) {
@@ -3459,7 +3743,7 @@ function parseToken(finalConfig, explicitToken) {
     finalConfig.token = explicitToken;
   }
 }
-function parseArgs(finalConfig, remainingPositionals) {
+function parseArgs2(finalConfig, remainingPositionals) {
   let localserverTls = "";
   localserverTls = parseExtendedOptions(remainingPositionals, finalConfig, localserverTls);
   if (localserverTls.length > 0 && finalConfig.forwarding) {
@@ -3470,10 +3754,10 @@ function parseArgs(finalConfig, remainingPositionals) {
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
-    const path5 = saveconf;
+    const path7 = saveconf;
     try {
-      import_fs4.default.writeFileSync(path5, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
-      logger.info(`Configuration saved to ${path5}`);
+      import_fs4.default.writeFileSync(path7, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
+      logger.info(`Configuration saved to ${path7}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       logger.error("Error loading configuration:", msg);
@@ -3503,7 +3787,9 @@ function isSaveConfOption(values) {
 }
 function parseServe(finalConfig, values) {
   const sv = values.serve;
-  if (typeof sv !== "string" || sv.trim().length === 0) return null;
+  if (typeof sv !== "string" || sv.trim().length === 0) {
+    return null;
+  }
   finalConfig.optional.serve = sv;
   return null;
 }
@@ -3521,7 +3807,7 @@ function parseAutoReconnect(finalConfig, values) {
   }
   return null;
 }
-async function buildFinalConfig(values, positionals) {
+async function buildFinalConfig(values, positionals, baseConfig) {
   let token;
   let server;
   let type;
@@ -3529,7 +3815,7 @@ async function buildFinalConfig(values, positionals) {
   let qrCode = false;
   let finalConfig = new Object();
   let saveconf = isSaveConfOption(values);
-  const configFromFile = loadJsonConfig(values);
+  const configFromFile = baseConfig || loadJsonConfig(values);
   const userParse = parseUsers(positionals, values.token);
   token = userParse.token;
   server = userParse.server;
@@ -3555,19 +3841,33 @@ async function buildFinalConfig(values, positionals) {
   type = parseType(finalConfig, values, type);
   parseToken(finalConfig, token || values.token);
   const dbgErr = parseDebugger(finalConfig, values);
-  if (dbgErr instanceof Error) throw dbgErr;
+  if (dbgErr instanceof Error) {
+    throw dbgErr;
+  }
   const lpErr = parseLocalPort(finalConfig, values);
-  if (lpErr instanceof Error) throw lpErr;
+  if (lpErr instanceof Error) {
+    throw lpErr;
+  }
   const rErr = parseReverseTunnelAddr(finalConfig, values, type);
-  if (rErr instanceof Error) throw rErr;
+  if (rErr instanceof Error) {
+    throw rErr;
+  }
   const lErr = parseLocalTunnelAddr(finalConfig, values);
-  if (lErr instanceof Error) throw lErr;
+  if (lErr instanceof Error) {
+    throw lErr;
+  }
   const serveErr = parseServe(finalConfig, values);
-  if (serveErr instanceof Error) throw serveErr;
+  if (serveErr instanceof Error) {
+    throw serveErr;
+  }
   const autoReconnectErr = parseAutoReconnect(finalConfig, values);
-  if (autoReconnectErr instanceof Error) throw autoReconnectErr;
-  if (forceFlag || values.force) finalConfig.force = true;
-  parseArgs(finalConfig, remainingPositionals);
+  if (autoReconnectErr instanceof Error) {
+    throw autoReconnectErr;
+  }
+  if (forceFlag || values.force) {
+    finalConfig.force = true;
+  }
+  parseArgs2(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
 }
@@ -3598,63 +3898,6 @@ var init_buildConfig = __esm({
   }
 });
 
-// src/utils/parseArgs.ts
-function isAttachedReverseOrLocalFlag(arg) {
-  return /^-[RL].+/.test(arg);
-}
-function shouldMergeReverseOrLocalFragment(current, next) {
-  if (next.startsWith("-")) return false;
-  if (next.startsWith(".")) return true;
-  const body = current.slice(2);
-  if (body.endsWith(":")) return true;
-  if (body.includes("//") && !body.includes(":")) return true;
-  return false;
-}
-function preprocessWindowsArgs(args) {
-  if (os2.platform() !== "win32") return args;
-  const out = [];
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (isAttachedReverseOrLocalFlag(arg)) {
-      let merged = arg;
-      while (i + 1 < args.length && shouldMergeReverseOrLocalFragment(merged, args[i + 1])) {
-        merged += args[i + 1];
-        i++;
-      }
-      out.push(merged);
-      i++;
-      continue;
-    }
-    out.push(arg);
-    i++;
-  }
-  return out;
-}
-function parseCliArgs(options) {
-  const rawArgs = process.argv.slice(2);
-  const processedArgs = preprocessWindowsArgs(rawArgs);
-  const parsed = (0, import_util6.parseArgs)({
-    args: processedArgs,
-    options,
-    allowPositionals: true
-  });
-  const hasAnyArgs = parsed.positionals.length > 0 || Object.values(parsed.values).some((v) => v !== void 0 && v !== false);
-  return {
-    ...parsed,
-    hasAnyArgs
-  };
-}
-var import_util6, os2;
-var init_parseArgs = __esm({
-  "src/utils/parseArgs.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_util6 = require("util");
-    os2 = __toESM(require("os"), 1);
-  }
-});
-
 // src/utils/getFreePort.ts
 function getFreePort(webDebugger) {
   return new Promise((resolve, reject) => {
@@ -3698,13 +3941,12 @@ var init_getFreePort = __esm({
 async function createQrCodes(urls) {
   const codes = [];
   for (const url of urls) {
-    const qr = await import_qrcode.default.toString(url, {
-      type: "terminal",
-      small: true,
-      margin: 0,
+    const raw = await import_qrcode.default.toString(url, {
+      type: "utf8",
+      margin: 2,
       errorCorrectionLevel: "L"
     });
-    codes.push(qr);
+    codes.push(raw);
   }
   return codes;
 }
@@ -3722,6 +3964,7 @@ function getTuiConfig() {
   return {
     maxRequestPairs: defaultTuiConfig.maxRequestPairs,
     visibleRequestCount: defaultTuiConfig.visibleRequestCount,
+    visibleUrlCount: defaultTuiConfig.visibleUrlCount,
     viewportScrollMargin: defaultTuiConfig.viewportScrollMargin,
     inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs
   };
@@ -3734,6 +3977,7 @@ var init_config = __esm({
     defaultTuiConfig = {
       maxRequestPairs: 100,
       visibleRequestCount: 10,
+      visibleUrlCount: 7,
       viewportScrollMargin: 2,
       inactivityHttpSelectorTimeoutMs: 1e4
     };
@@ -3974,7 +4218,7 @@ function createFullUI(screen, urls, greet, tunnelConfig) {
     width: "100%-2",
     height: `100%-${lowerSectionTop + 6}`
   });
-  const isQrCodeRequested = tunnelConfig?.qrCode || false;
+  const isQrCodeRequested = tunnelConfig?.isQRCode || false;
   const requestsBox = import_blessed.default.box({
     parent: lowerSection,
     top: 0,
@@ -4134,8 +4378,24 @@ var init_utils = __esm({
 // src/tui/blessed/components/DisplayUpdaters.ts
 function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
   if (!urlsBox) return;
-  let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}\n";
-  urls.forEach((url, index) => {
+  const config = getTuiConfig();
+  const { visibleUrlCount } = config;
+  let viewportStart = 0;
+  if (urls.length > visibleUrlCount) {
+    viewportStart = Math.max(0, Math.min(
+      currentQrIndex - Math.floor(visibleUrlCount / 2),
+      urls.length - visibleUrlCount
+    ));
+  }
+  const viewportEnd = Math.min(viewportStart + visibleUrlCount, urls.length);
+  const visibleUrls = urls.slice(viewportStart, viewportEnd);
+  let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}";
+  if (viewportStart > 0) {
+    content += ` {gray-fg}\u2191 ${viewportStart} more{/gray-fg}`;
+  }
+  content += "\n";
+  visibleUrls.forEach((url, i) => {
+    const index = viewportStart + i;
     const isSelected = index === currentQrIndex;
     const prefix = isSelected ? "\u2192 " : "\u2022 ";
     const color = isSelected ? "yellow" : "magenta";
@@ -4147,6 +4407,11 @@ function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
 `;
     }
   });
+  const itemsBelow = urls.length - viewportEnd;
+  if (itemsBelow > 0) {
+    content += `{gray-fg}\u2193 ${itemsBelow} more{/gray-fg}
+`;
+  }
   urlsBox.setContent(content);
   screen.render();
 }
@@ -4859,7 +5124,7 @@ var init_TunnelTui = __esm({
         }
       }
       async generateQrCodes() {
-        if (this.tunnelConfig?.qrCode && this.urls.length > 0) {
+        if (this.tunnelConfig?.isQRCode && this.urls.length > 0) {
           this.qrCodes = await createQrCodes(this.urls);
           this.updateQrCodeDisplay();
         }
@@ -5096,7 +5361,7 @@ async function startCli(finalConfig, manager) {
       });
     }
     manager2.registerWorkerErrorListner(tunnel.tunnelid, (_tunnelid, error) => {
-      printer_default.error(`${error.message}`);
+      printer_default.fatal(`${error.message}`);
     });
     await manager2.startTunnel(tunnel.tunnelid);
     printer_default.stopSpinnerSuccess(" Connected to Pinggy");
@@ -5221,7 +5486,7 @@ async function startCli(finalConfig, manager) {
     }
   } catch (err) {
     printer_default.stopSpinnerFail("Failed to connect");
-    printer_default.error(err.message || "Unknown error");
+    printer_default.fatal(err.message || "Unknown error");
     throw err;
   }
 }
@@ -5246,9 +5511,604 @@ var init_starCli = __esm({
   }
 });
 
+// src/utils/configDir.ts
+function getPinggyConfigDir() {
+  const platform2 = import_os2.default.platform();
+  let baseDir;
+  if (platform2 === "win32") {
+    baseDir = process.env.APPDATA || import_path5.default.join(import_os2.default.homedir(), "AppData", "Roaming");
+  } else {
+    baseDir = process.env.XDG_CONFIG_HOME || import_path5.default.join(import_os2.default.homedir(), ".config");
+  }
+  return import_path5.default.join(baseDir, "pinggy");
+}
+function getTunnelConfigDir() {
+  return import_path5.default.join(getPinggyConfigDir(), "tunnels");
+}
+function ensureTunnelConfigDir() {
+  const dir = getTunnelConfigDir();
+  import_fs5.default.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+var import_os2, import_path5, import_fs5;
+var init_configDir = __esm({
+  "src/utils/configDir.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_os2 = __toESM(require("os"), 1);
+    import_path5 = __toESM(require("path"), 1);
+    import_fs5 = __toESM(require("fs"), 1);
+  }
+});
+
+// src/cli/configStore.ts
+function buildFilename(name, configId) {
+  return `${name}_${configId}.json`;
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function validateName(name) {
+  if (!name || name.trim().length === 0) {
+    return new Error("Tunnel name cannot be empty.");
+  }
+  if (name.length > 128) {
+    return new Error("Tunnel name cannot exceed 128 characters.");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return new Error("Tunnel name can only contain alphanumeric characters, hyphens, and underscores.");
+  }
+  return null;
+}
+function readConfigFile(filePath) {
+  try {
+    const data = import_fs6.default.readFileSync(filePath, { encoding: "utf-8" });
+    return JSON.parse(data);
+  } catch (err) {
+    logger.warn(`Failed to read config file ${filePath}:`, err);
+    return null;
+  }
+}
+function writeConfigFile(filePath, config) {
+  import_fs6.default.writeFileSync(filePath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+}
+function listSavedConfigs() {
+  const dir = getTunnelConfigDir();
+  if (!import_fs6.default.existsSync(dir)) {
+    return [];
+  }
+  const files = import_fs6.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const configs = [];
+  for (const file of files) {
+    const config = readConfigFile(import_path6.default.join(dir, file));
+    if (config && config.name && config.configId) {
+      configs.push(config);
+    }
+  }
+  return configs;
+}
+function findConfigFile(nameOrId) {
+  const dir = getTunnelConfigDir();
+  if (!import_fs6.default.existsSync(dir)) return null;
+  const files = import_fs6.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const sanitized = sanitizeName(nameOrId);
+  const nameMatch = files.find((f) => f.startsWith(sanitized + "_"));
+  if (nameMatch) {
+    const filePath = import_path6.default.join(dir, nameMatch);
+    const config = readConfigFile(filePath);
+    if (config && config.name === nameOrId) return { filePath, config };
+  }
+  const idCandidates = files.filter((f) => {
+    const withoutExt = f.replace(/\.json$/, "");
+    const lastUnderscore = withoutExt.indexOf("_");
+    if (lastUnderscore === -1) return false;
+    const idPart = withoutExt.slice(lastUnderscore + 1);
+    return idPart.startsWith(nameOrId);
+  });
+  if (idCandidates.length === 1) {
+    const filePath = import_path6.default.join(dir, idCandidates[0]);
+    const config = readConfigFile(filePath);
+    if (config) return { filePath, config };
+  }
+  return null;
+}
+function findConfigByName(name) {
+  const resolved = findConfigFile(name);
+  return resolved?.config.name === name ? resolved.config : null;
+}
+function findConfig(nameOrId) {
+  return findConfigFile(nameOrId)?.config ?? null;
+}
+function saveConfig(name, configId, tunnelConfig, autoStart = false) {
+  const nameErr = validateName(name);
+  if (nameErr) {
+    throw nameErr;
+  }
+  const existing = findConfigByName(name);
+  if (existing) {
+    throw new Error(
+      `A tunnel config with the name "${name}" already exists (configId: ${existing.configId}). Please use a different name.`
+    );
+  }
+  const dir = ensureTunnelConfigDir();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const saved = {
+    name,
+    configId,
+    autoStart,
+    createdAt: now,
+    updatedAt: now,
+    tunnelConfig
+  };
+  const filename = buildFilename(sanitizeName(name), configId);
+  const filePath = import_path6.default.join(dir, filename);
+  import_fs6.default.writeFileSync(filePath, JSON.stringify(saved, null, 2), { encoding: "utf-8" });
+  logger.info(`Config "${name}" saved to ${filePath}`);
+  return saved;
+}
+function deleteConfig(nameOrId) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  import_fs6.default.unlinkSync(resolved.filePath);
+  logger.info(`Config "${resolved.config.name}" deleted.`);
+  return resolved.config.name;
+}
+function updateConfigAutoStart(nameOrId, autoStart) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  resolved.config.autoStart = autoStart;
+  resolved.config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeConfigFile(resolved.filePath, resolved.config);
+  logger.info(`Config "${resolved.config.name}" auto-start set to ${autoStart}`);
+  return resolved.config;
+}
+function updateTunnelConfig(nameOrId, tunnelConfig) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  resolved.config.tunnelConfig = tunnelConfig;
+  resolved.config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeConfigFile(resolved.filePath, resolved.config);
+  logger.info(`Config "${resolved.config.name}" tunnel configuration updated`);
+  return resolved.config;
+}
+function getAutoStartConfigs() {
+  return listSavedConfigs().filter((c) => c.autoStart);
+}
+function printConfigList() {
+  const configs = listSavedConfigs();
+  if (configs.length === 0) {
+    console.log(import_picocolors5.default.yellow("No saved tunnel configs found."));
+    console.log(import_picocolors5.default.gray(`Config directory: ${getTunnelConfigDir()}`));
+    return;
+  }
+  const nameW = 20;
+  const idW = 12;
+  const typeW = 8;
+  const fwdW = 25;
+  const serverW = 22;
+  const autoW = 10;
+  const header = import_picocolors5.default.bold("Name".padEnd(nameW)) + import_picocolors5.default.bold("Config ID".padEnd(idW)) + import_picocolors5.default.bold("Type".padEnd(typeW)) + import_picocolors5.default.bold("Forwarding".padEnd(fwdW)) + import_picocolors5.default.bold("Server".padEnd(serverW)) + import_picocolors5.default.bold("Auto-start".padEnd(autoW));
+  console.log("\n" + header);
+  console.log(import_picocolors5.default.gray("\u2500".repeat(nameW + idW + typeW + fwdW + serverW + autoW)));
+  for (const c of configs) {
+    const tc = c.tunnelConfig;
+    const forwarding = Array.isArray(tc.forwarding) ? tc.forwarding[0]?.address : String(tc.forwarding || "");
+    const type = (Array.isArray(tc.forwarding) ? tc.forwarding[0]?.type : void 0) || "http";
+    const server = tc.serverAddress || "a.pinggy.io";
+    const line = import_picocolors5.default.cyanBright(c.name.padEnd(nameW)) + import_picocolors5.default.gray(c.configId.slice(0, 8).padEnd(idW)) + type.padEnd(typeW) + forwarding.slice(0, fwdW - 2).padEnd(fwdW) + server.slice(0, serverW - 2).padEnd(serverW) + (c.autoStart ? import_picocolors5.default.green("yes") : import_picocolors5.default.gray("no")).padEnd(autoW);
+    console.log(line);
+  }
+  console.log();
+}
+function printConfigDetail(config) {
+  console.log(import_picocolors5.default.bold(`
+Tunnel Config: ${import_picocolors5.default.cyanBright(config.name)}`));
+  console.log(import_picocolors5.default.gray("\u2500".repeat(40)));
+  console.log(`  Config ID:   ${config.configId}`);
+  console.log(`  Auto-start:  ${config.autoStart ? import_picocolors5.default.green("yes") : import_picocolors5.default.gray("no")}`);
+  console.log(`  Created:     ${config.createdAt}`);
+  console.log(`  Updated:     ${config.updatedAt}`);
+  console.log(import_picocolors5.default.gray("\u2500".repeat(40)));
+  console.log(`  Server:      ${config.tunnelConfig.serverAddress || "a.pinggy.io"}`);
+  console.log(`  Token:       ${config.tunnelConfig.token ? "***" + config.tunnelConfig.token.slice(-4) : "(none)"}`);
+  const fwd = config.tunnelConfig.forwarding;
+  if (Array.isArray(fwd)) {
+    const defaultFwds = [];
+    const customFwds = [];
+    for (const f of fwd) {
+      if (typeof f === "string") {
+        defaultFwds.push(f);
+      } else if (f.listenAddress) {
+        customFwds.push(f);
+      } else {
+        defaultFwds.push(f);
+      }
+    }
+    for (const f of defaultFwds) {
+      const addr = typeof f === "string" ? f : `${f.address} (${f.type || "http"})`;
+      console.log(`  Forwarding:  ${addr}`);
+      if (config.tunnelConfig.webDebugger) {
+        console.log(`  Debugger:    ${config.tunnelConfig.webDebugger}`);
+      }
+    }
+    if (customFwds.length > 0) {
+      console.log(import_picocolors5.default.gray("\u2500".repeat(40)));
+      console.log(import_picocolors5.default.bold("  Domain Mappings:"));
+      for (const f of customFwds) {
+        if (typeof f === "string") continue;
+        const domain = f.listenAddress;
+        const target = f.address;
+        const type = f.type || "http";
+        console.log(`    ${import_picocolors5.default.cyanBright(domain)} \u2192 ${target} (${type})`);
+      }
+    }
+  } else if (fwd) {
+    console.log(`  Forwarding:  ${fwd}`);
+  }
+  console.log();
+}
+var import_fs6, import_path6, import_picocolors5;
+var init_configStore = __esm({
+  "src/cli/configStore.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs6 = __toESM(require("fs"), 1);
+    import_path6 = __toESM(require("path"), 1);
+    init_configDir();
+    init_logger();
+    import_picocolors5 = __toESM(require("picocolors"), 1);
+  }
+});
+
+// src/cli/buildAndStartTunnel.ts
+async function buildAndStartTunnel(values, positionals, manager) {
+  await initRemoteManagement(values);
+  logger.debug("Building final config from CLI values and positionals", { values, positionals });
+  const finalConfig = await buildFinalConfig(values, positionals);
+  logger.debug("Final configuration built", finalConfig);
+  if (values.save) {
+    const name = values.name;
+    if (!name) {
+      printer_default.error("--save requires --name to specify a name for the tunnel config.");
+      process.exit(1);
+    }
+    const nameErr = validateName(name);
+    if (nameErr) {
+      printer_default.error(nameErr.message);
+      process.exit(1);
+    }
+    const autoStart = !!values.auto;
+    saveConfig(name, finalConfig.configId, finalConfig, autoStart);
+    printer_default.success(`Config "${name}" saved.`);
+  }
+  await startCli(finalConfig, manager);
+}
+async function initRemoteManagement(values) {
+  const parseResult = await parseRemoteManagement(values);
+  if (parseResult?.ok === false) {
+    logger.error("Failed to initiate remote management:", parseResult.error);
+    printer_default.fatal(parseResult.error);
+  }
+}
+var init_buildAndStartTunnel = __esm({
+  "src/cli/buildAndStartTunnel.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_remoteManagement();
+    init_buildConfig();
+    init_starCli();
+    init_printer();
+    init_configStore();
+  }
+});
+
+// src/cli/subcommands.ts
+function isSubcommand(rawArgs) {
+  return rawArgs.length > 0 && SUBCOMMANDS.has(rawArgs[0]);
+}
+async function handleSubcommand(rawArgs, manager) {
+  const sub = rawArgs[0];
+  const rest = rawArgs.slice(1);
+  switch (sub) {
+    case "config":
+      await handleConfig(rest);
+      return;
+    case "start":
+      await handleStart(rest, manager);
+      return;
+  }
+}
+async function handleConfig(args) {
+  if (args.length === 0) {
+    printConfigHelp();
+    return;
+  }
+  const verb = args[0];
+  const rest = args.slice(1);
+  switch (verb) {
+    case "list":
+    case "ls":
+      printConfigList();
+      return;
+    case "show": {
+      const names = requireNames(rest, "config show");
+      for (const name of names) {
+        const saved2 = resolveConfig(name);
+        if (saved2) printConfigDetail(saved2);
+      }
+      return;
+    }
+    case "save": {
+      const name = requireName(rest, "config save");
+      await handleConfigSave(name, rest.slice(1));
+      return;
+    }
+    case "delete": {
+      const names = requireNames(rest, "config delete");
+      for (const name of names) {
+        const deletedName = deleteConfig(name);
+        if (deletedName) {
+          printer_default.success(`Config "${deletedName}" deleted.`);
+        } else {
+          printer_default.error(`No config found matching "${name}". Use: pinggy config list`);
+        }
+      }
+      return;
+    }
+    case "update": {
+      const name = requireName(rest, "config update");
+      await handleConfigUpdate(name, rest.slice(1));
+      return;
+    }
+    case "auto": {
+      const names = requireNames(rest, "config auto");
+      for (const name of names) {
+        const updated = updateConfigAutoStart(name, true);
+        if (updated) {
+          printer_default.success(`Config "${updated.name}" auto-start set to on.`);
+        } else {
+          printer_default.error(`No config found matching "${name}". Use: pinggy config list`);
+        }
+      }
+      return;
+    }
+    case "noauto": {
+      const names = requireNames(rest, "config noauto");
+      for (const name of names) {
+        const updated = updateConfigAutoStart(name, false);
+        if (updated) {
+          printer_default.success(`Config "${updated.name}" auto-start set to off.`);
+        } else {
+          printer_default.error(`No config found matching "${name}". Use: pinggy config list`);
+        }
+      }
+      return;
+    }
+    default:
+      const saved = resolveConfig(verb);
+      if (saved) printConfigDetail(saved);
+      return;
+  }
+}
+async function handleConfigSave(name, remainingArgs) {
+  const nameErr = validateName(name);
+  if (nameErr) {
+    printer_default.error(nameErr.message);
+    process.exit(1);
+  }
+  const { values, positionals } = parseCliArgs(cliOptions, remainingArgs);
+  const autoStart = !!values.auto;
+  logger.debug("Building config for save", { name, values, positionals });
+  const finalConfig = await buildFinalConfig(values, positionals);
+  saveConfig(name, finalConfig.configId, finalConfig, autoStart);
+  printer_default.success(`Config "${name}" saved.`);
+}
+async function handleConfigUpdate(nameOrId, remainingArgs) {
+  const saved = resolveConfig(nameOrId);
+  if (!saved) return;
+  const { values, positionals } = parseCliArgs(cliOptions, remainingArgs);
+  logger.debug("Building updated config", { nameOrId, values, positionals });
+  const updatedConfig = await buildFinalConfig(values, positionals, saved.tunnelConfig);
+  const result = updateTunnelConfig(nameOrId, updatedConfig);
+  if (result) {
+    printer_default.success(`Config "${result.name}" updated.`);
+    printConfigDetail(result);
+  } else {
+    printer_default.error(`Failed to update config "${nameOrId}".`);
+  }
+}
+async function handleStart(args, manager) {
+  const startAll = args.includes("--all");
+  const argsWithoutAll = args.filter((a) => a !== "--all");
+  const names = [];
+  let i = 0;
+  while (i < argsWithoutAll.length && !argsWithoutAll[i].startsWith("-")) {
+    names.push(argsWithoutAll[i]);
+    i++;
+  }
+  const flagArgs = argsWithoutAll.slice(i);
+  const { values, positionals } = parseCliArgs(cliOptions, flagArgs);
+  configureLogger(values);
+  if (startAll) {
+    await initRemoteManagementBackground(values);
+    await startAutoStartTunnels(manager);
+    return;
+  }
+  if (names.length === 0) {
+    printStartHelp();
+    return;
+  }
+  const resolved = [];
+  for (const name of names) {
+    const saved = resolveConfig(name);
+    if (!saved) return;
+    resolved.push(saved);
+  }
+  if (resolved.length > 1 && flagArgs.length > 0) {
+    printer_default.error("Runtime overrides (-l, --type, etc.) can only be used when starting a single tunnel.");
+    printer_default.print("  Start one tunnel:  pinggy start my-tunnel -l 4000");
+    printer_default.print("  Or update first:   pinggy config update my-tunnel -l 4000");
+    return;
+  }
+  await initRemoteManagementBackground(values);
+  if (resolved.length === 1) {
+    const saved = resolved[0];
+    logger.debug("Building config with overrides", { name: saved.name });
+    const finalConfig = await buildFinalConfig(values, positionals, saved.tunnelConfig);
+    finalConfig.configId = saved.configId;
+    await startCli(finalConfig, manager);
+  } else {
+    await startNamedTunnels(resolved, manager);
+  }
+}
+async function startAutoStartTunnels(manager) {
+  const configs = getAutoStartConfigs();
+  if (configs.length === 0) {
+    printer_default.warn("No configs marked for auto-start. Use: pinggy config auto <name>");
+    return;
+  }
+  printer_default.print(import_picocolors6.default.cyanBright(`Starting ${configs.length} auto-start tunnel(s)...`));
+  for (const saved of configs) {
+    await startSavedTunnel(saved, manager);
+  }
+  printer_default.print(import_picocolors6.default.gray("\nAll auto-start tunnels launched. Press Ctrl+C to stop.\n"));
+  await new Promise(() => {
+  });
+}
+async function startNamedTunnels(configs, manager) {
+  printer_default.print(import_picocolors6.default.cyanBright(`Starting ${configs.length} tunnel(s)...`));
+  for (const saved of configs) {
+    await startSavedTunnel(saved, manager);
+  }
+  printer_default.print(import_picocolors6.default.gray("\nAll tunnels launched. Press Ctrl+C to stop.\n"));
+  await new Promise(() => {
+  });
+}
+async function startSavedTunnel(saved, manager) {
+  const config = {
+    ...saved.tunnelConfig,
+    configId: saved.configId,
+    name: saved.name,
+    optional: {
+      ...saved.tunnelConfig.optional,
+      noTui: true
+    }
+  };
+  try {
+    const tunnel = await manager.createTunnel(config);
+    await manager.startTunnel(tunnel.tunnelid);
+    const urls = await manager.getTunnelUrls(tunnel.tunnelid);
+    printer_default.success(`"${saved.name}" started`);
+    (urls ?? []).forEach(
+      (url) => printer_default.print("  " + import_picocolors6.default.magentaBright(url))
+    );
+    manager.registerWorkerErrorListner(tunnel.tunnelid, (_id, error) => {
+      printer_default.error(`[${saved.name}] Fatal: ${error.message}`);
+    });
+    manager.registerDisconnectListener(tunnel.tunnelid, async (_id, error, messages) => {
+      if (error) printer_default.warn(`[${saved.name}] Disconnected: ${error}`);
+      messages?.forEach((m) => printer_default.warn(`[${saved.name}] ${m}`));
+    });
+    manager.registerReconnectingListener(tunnel.tunnelid, (_id, retryCnt) => {
+      printer_default.print(import_picocolors6.default.gray(`[${saved.name}] Reconnecting (attempt #${retryCnt})...`));
+    });
+    manager.registerReconnectionCompletedListener(tunnel.tunnelid, async (_id, urls2) => {
+      printer_default.success(`[${saved.name}] Reconnected`);
+      (urls2 ?? []).forEach(
+        (url) => printer_default.print("  " + import_picocolors6.default.magentaBright(url))
+      );
+    });
+    manager.registerReconnectionFailedListener(tunnel.tunnelid, (_id, retryCnt) => {
+      printer_default.error(`[${saved.name}] Reconnection failed after ${retryCnt} attempts`);
+    });
+  } catch (err) {
+    printer_default.error(`[${saved.name}] Failed to start: ${err.message || err}`);
+  }
+}
+function resolveConfig(nameOrId) {
+  const saved = findConfig(nameOrId);
+  if (!saved) {
+    printer_default.error(`No config found matching "${nameOrId}". Use: pinggy config list`);
+    return null;
+  }
+  return saved;
+}
+function requireName(args, command) {
+  if (args.length === 0 || args[0].startsWith("-")) {
+    printer_default.error(`Tunnel name is required. Usage: pinggy ${command} <name>`);
+    process.exit(1);
+  }
+  return args[0];
+}
+function requireNames(args, command) {
+  const names = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) break;
+    names.push(arg);
+  }
+  if (names.length === 0) {
+    printer_default.error(`At least one tunnel name is required. Usage: pinggy ${command} <name> [name2 ...]`);
+    process.exit(1);
+  }
+  return names;
+}
+async function initRemoteManagementBackground(values) {
+  const rmToken = values["remote-management"];
+  if (typeof rmToken === "string" && rmToken.trim().length > 0) {
+    const manageHost = values["manage"];
+    try {
+      await startRemoteManagement({
+        apiKey: rmToken,
+        serverUrl: buildRemoteManagementWsUrl(manageHost)
+      });
+    } catch (e) {
+      logger.error("Failed to initiate remote management:", e);
+      printer_default.fatal(e);
+    }
+  }
+}
+function printConfigHelp() {
+  console.log("\nUsage: pinggy config <command> [name] [options]\n");
+  console.log("Commands:");
+  console.log("  list                           List all saved configs");
+  console.log("  show <name>                    Show config details");
+  console.log("  save <name> [tunnel flags]     Save a tunnel config");
+  console.log("  update <name> [tunnel flags]   Update a saved config");
+  console.log("  delete <name>                  Delete a saved config");
+  console.log("  auto <name>                    Enable auto-start");
+  console.log("  noauto <name>                  Disable auto-start\n");
+}
+function printStartHelp() {
+  console.log("\nUsage: pinggy start <name> [options]\n");
+  console.log("Examples:");
+  console.log("  pinggy start my-tunnel                Start a saved tunnel");
+  console.log("  pinggy start my-tunnel -l 4000        Start with override");
+  console.log("  pinggy start tunnela tunnelb           Start multiple tunnels");
+  console.log("  pinggy start --all                     Start all auto-start tunnels\n");
+}
+var import_picocolors6, SUBCOMMANDS;
+var init_subcommands = __esm({
+  "src/cli/subcommands.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_options();
+    init_parseArgs();
+    init_buildConfig();
+    init_starCli();
+    init_printer();
+    init_logger();
+    import_picocolors6 = __toESM(require("picocolors"), 1);
+    init_configStore();
+    init_remoteManagement();
+    SUBCOMMANDS = /* @__PURE__ */ new Set(["config", "start"]);
+  }
+});
+
 // src/main.ts
 var main_exports = {};
 __export(main_exports, {
+  RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
   closeRemoteManagement: () => closeRemoteManagement,
@@ -5258,8 +6118,7 @@ __export(main_exports, {
 });
 async function main() {
   try {
-    const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
-    configureLogger(values);
+    const rawArgs = process.argv.slice(2);
     const manager = TunnelManager.getInstance();
     process.on("SIGINT", () => {
       logger.info("SIGINT received: stopping tunnels and exiting");
@@ -5268,6 +6127,12 @@ async function main() {
       console.log("Tunnels stopped. Exiting.");
       process.exit(0);
     });
+    if (isSubcommand(rawArgs)) {
+      await handleSubcommand(rawArgs, manager);
+      return;
+    }
+    const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
+    configureLogger(values);
     if (!hasAnyArgs || values.help) {
       printHelpMessage();
       return;
@@ -5276,22 +6141,13 @@ async function main() {
       printer_default.print(`Pinggy CLI version: ${getVersion()}`);
       return;
     }
-    const parseResult = await parseRemoteManagement(values);
-    if (parseResult?.ok === false) {
-      printer_default.error(parseResult.error);
-      logger.error("Failed to initiate remote management:", parseResult.error);
-      process.exit(1);
-    }
-    logger.debug("Building final config from CLI values and positionals", { values, positionals });
-    const finalConfig = await buildFinalConfig(values, positionals);
-    logger.debug("Final configuration built", finalConfig);
-    await startCli(finalConfig, manager);
+    await buildAndStartTunnel(values, positionals, manager);
   } catch (error) {
     logger.error("Unhandled error in CLI:", error);
-    printer_default.error(error);
+    printer_default.fatal(error);
   }
 }
-var import_url2, import_process, import_fs5, currentFile, entryFile;
+var import_url2, import_process, import_fs7, currentFile, entryFile;
 var init_main = __esm({
   "src/main.ts"() {
     "use strict";
@@ -5299,23 +6155,22 @@ var init_main = __esm({
     init_TunnelManager();
     init_help();
     init_options();
-    init_buildConfig();
     init_logger();
-    init_remoteManagement();
     init_parseArgs();
     init_printer();
-    init_starCli();
     init_util();
     init_handler();
     import_url2 = require("url");
     import_process = require("process");
-    import_fs5 = require("fs");
+    import_fs7 = require("fs");
     init_logger();
     init_remoteManagement();
+    init_buildAndStartTunnel();
+    init_subcommands();
     currentFile = (0, import_url2.fileURLToPath)(importMetaUrl);
     entryFile = null;
     try {
-      entryFile = import_process.argv[1] ? (0, import_fs5.realpathSync)(import_process.argv[1]) : null;
+      entryFile = import_process.argv[1] ? (0, import_fs7.realpathSync)(import_process.argv[1]) : null;
     } catch (e) {
       entryFile = null;
     }
@@ -5328,6 +6183,7 @@ var init_main = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
   TunnelErrorCodeType: () => TunnelErrorCodeType,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
@@ -5336,7 +6192,8 @@ __export(index_exports, {
   closeRemoteManagement: () => closeRemoteManagement,
   enablePackageLogging: () => enablePackageLogging,
   getRemoteManagementState: () => getRemoteManagementState,
-  initiateRemoteManagement: () => initiateRemoteManagement
+  initiateRemoteManagement: () => initiateRemoteManagement,
+  startRemoteManagement: () => startRemoteManagement
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -5442,11 +6299,11 @@ async function verifyAndLoad() {
   await Promise.resolve().then(() => (init_main(), main_exports));
 }
 verifyAndLoad().catch((err) => {
-  printer_default.error(`Failed to start CLI:, ${err}`);
-  process.exit(1);
+  printer_default.fatal(`Failed to start CLI:, ${err}`);
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RemoteManagementUnauthorizedError,
   TunnelErrorCodeType,
   TunnelManager,
   TunnelOperations,
@@ -5455,5 +6312,6 @@ verifyAndLoad().catch((err) => {
   closeRemoteManagement,
   enablePackageLogging,
   getRemoteManagementState,
-  initiateRemoteManagement
+  initiateRemoteManagement,
+  startRemoteManagement
 });