pinggy 0.4.5 → 0.4.7

package/dist/{main-2RDHMQT7.js → main-PUM4SD6B.js}

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import {
+  RemoteManagementUnauthorizedError,
   TunnelManager,
   TunnelOperations,
+  buildRemoteManagementWsUrl,
   closeRemoteManagement,
   getRandomId,
   getRemoteManagementState,
@@ -9,13 +11,14 @@ import {
   initiateRemoteManagement,
   isValidPort,
   parseRemoteManagement,
-  printer_default
-} from "./chunk-MBN3YBO4.js";
+  printer_default,
+  startRemoteManagement
+} from "./chunk-443UO6IY.js";
 import {
   configureLogger,
   enablePackageLogging,
   logger
-} from "./chunk-HUN2MRZO.js";
+} from "./chunk-3RTRUYNW.js";
 
 // src/cli/options.ts
 var cliOptions = {
@@ -44,9 +47,13 @@ var cliOptions = {
   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
@@ -94,11 +101,92 @@ 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");
 }
 
+// src/utils/parseArgs.ts
+import { parseArgs } from "util";
+import * as os from "os";
+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 (os.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 = 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
+  };
+}
+
+// src/main.ts
+import { fileURLToPath } from "url";
+import { argv } from "process";
+import { realpathSync } from "fs";
+
 // src/cli/defaults.ts
 var defaultOptions = {
+  version: "1.0",
   token: void 0,
   // No default token
   serverAddress: "a.pinggy.io",
@@ -264,7 +352,9 @@ function removeIPv6Brackets(ip) {
 }
 function isValidServerAddress(host) {
   const normalized = removeIPv6Brackets(host.trim());
-  if (!normalized) return false;
+  if (!normalized) {
+    return false;
+  }
   return domainRegex.test(normalized) || isIP2(normalized) !== 0;
 }
 var KEYWORDS = /* @__PURE__ */ new Set([
@@ -285,7 +375,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)) {
@@ -338,21 +430,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);
     }
   }
@@ -365,7 +475,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://")) {
@@ -397,7 +509,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" || isIP2(normalized) !== 0;
 }
 function ipv6SafeSplitColon(s) {
@@ -441,7 +555,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;
   };
@@ -520,7 +636,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(
@@ -532,7 +650,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";
@@ -556,7 +676,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)) {
@@ -571,7 +693,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) {
@@ -582,10 +704,10 @@ function parseArgs(finalConfig, remainingPositionals) {
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
-    const path2 = saveconf;
+    const path4 = saveconf;
     try {
-      fs.writeFileSync(path2, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
-      logger.info(`Configuration saved to ${path2}`);
+      fs.writeFileSync(path4, JSON.stringify(config, null, 2), { encoding: "utf-8", flag: "w" });
+      logger.info(`Configuration saved to ${path4}`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       logger.error("Error loading configuration:", msg);
@@ -615,7 +737,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;
 }
@@ -633,7 +757,7 @@ function parseAutoReconnect(finalConfig, values) {
   }
   return null;
 }
-async function buildFinalConfig(values, positionals) {
+async function buildFinalConfig(values, positionals, baseConfig) {
   let token;
   let server;
   let type;
@@ -641,7 +765,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;
@@ -667,73 +791,37 @@ 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;
 }
 
-// src/utils/parseArgs.ts
-import { parseArgs as parseArgs2 } from "util";
-import * as os from "os";
-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 (os.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 = parseArgs2({
-    args: processedArgs,
-    options,
-    allowPositionals: true
-  });
-  const hasAnyArgs = parsed.positionals.length > 0 || Object.values(parsed.values).some((v) => v !== void 0 && v !== false);
-  return {
-    ...parsed,
-    hasAnyArgs
-  };
-}
-
 // src/utils/getFreePort.ts
 import net from "net";
 function getFreePort(webDebugger) {
@@ -777,13 +865,12 @@ import QRCode from "qrcode";
 async function createQrCodes(urls) {
   const codes = [];
   for (const url of urls) {
-    const qr = await QRCode.toString(url, {
-      type: "terminal",
-      small: true,
-      margin: 0,
+    const raw = await QRCode.toString(url, {
+      type: "utf8",
+      margin: 2,
       errorCorrectionLevel: "L"
     });
-    codes.push(qr);
+    codes.push(raw);
   }
   return codes;
 }
@@ -795,6 +882,7 @@ import WebSocket from "ws";
 var defaultTuiConfig = {
   maxRequestPairs: 100,
   visibleRequestCount: 10,
+  visibleUrlCount: 7,
   viewportScrollMargin: 2,
   inactivityHttpSelectorTimeoutMs: 1e4
 };
@@ -802,6 +890,7 @@ function getTuiConfig() {
   return {
     maxRequestPairs: defaultTuiConfig.maxRequestPairs,
     visibleRequestCount: defaultTuiConfig.visibleRequestCount,
+    visibleUrlCount: defaultTuiConfig.visibleUrlCount,
     viewportScrollMargin: defaultTuiConfig.viewportScrollMargin,
     inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs
   };
@@ -1029,7 +1118,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 = blessed.box({
     parent: lowerSection,
     top: 0,
@@ -1172,8 +1261,24 @@ function getBytesInt(b) {
 // 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";
@@ -1185,6 +1290,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();
 }
@@ -1852,7 +1962,7 @@ var TunnelTui = class {
     }
   }
   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();
     }
@@ -2085,7 +2195,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");
@@ -2210,19 +2320,568 @@ 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;
   }
 }
 
+// src/cli/configStore.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/utils/configDir.ts
+import os2 from "os";
+import path2 from "path";
+import fs2 from "fs";
+function getPinggyConfigDir() {
+  const platform2 = os2.platform();
+  let baseDir;
+  if (platform2 === "win32") {
+    baseDir = process.env.APPDATA || path2.join(os2.homedir(), "AppData", "Roaming");
+  } else {
+    baseDir = process.env.XDG_CONFIG_HOME || path2.join(os2.homedir(), ".config");
+  }
+  return path2.join(baseDir, "pinggy");
+}
+function getTunnelConfigDir() {
+  return path2.join(getPinggyConfigDir(), "tunnels");
+}
+function ensureTunnelConfigDir() {
+  const dir = getTunnelConfigDir();
+  fs2.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/cli/configStore.ts
+import pico2 from "picocolors";
+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 = fs3.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) {
+  fs3.writeFileSync(filePath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+}
+function listSavedConfigs() {
+  const dir = getTunnelConfigDir();
+  if (!fs3.existsSync(dir)) {
+    return [];
+  }
+  const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const configs = [];
+  for (const file of files) {
+    const config = readConfigFile(path3.join(dir, file));
+    if (config && config.name && config.configId) {
+      configs.push(config);
+    }
+  }
+  return configs;
+}
+function findConfigFile(nameOrId) {
+  const dir = getTunnelConfigDir();
+  if (!fs3.existsSync(dir)) return null;
+  const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const sanitized = sanitizeName(nameOrId);
+  const nameMatch = files.find((f) => f.startsWith(sanitized + "_"));
+  if (nameMatch) {
+    const filePath = path3.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 = path3.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 = path3.join(dir, filename);
+  fs3.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;
+  fs3.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(pico2.yellow("No saved tunnel configs found."));
+    console.log(pico2.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 = pico2.bold("Name".padEnd(nameW)) + pico2.bold("Config ID".padEnd(idW)) + pico2.bold("Type".padEnd(typeW)) + pico2.bold("Forwarding".padEnd(fwdW)) + pico2.bold("Server".padEnd(serverW)) + pico2.bold("Auto-start".padEnd(autoW));
+  console.log("\n" + header);
+  console.log(pico2.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 = pico2.cyanBright(c.name.padEnd(nameW)) + pico2.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 ? pico2.green("yes") : pico2.gray("no")).padEnd(autoW);
+    console.log(line);
+  }
+  console.log();
+}
+function printConfigDetail(config) {
+  console.log(pico2.bold(`
+Tunnel Config: ${pico2.cyanBright(config.name)}`));
+  console.log(pico2.gray("\u2500".repeat(40)));
+  console.log(`  Config ID:   ${config.configId}`);
+  console.log(`  Auto-start:  ${config.autoStart ? pico2.green("yes") : pico2.gray("no")}`);
+  console.log(`  Created:     ${config.createdAt}`);
+  console.log(`  Updated:     ${config.updatedAt}`);
+  console.log(pico2.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(pico2.gray("\u2500".repeat(40)));
+      console.log(pico2.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(`    ${pico2.cyanBright(domain)} \u2192 ${target} (${type})`);
+      }
+    }
+  } else if (fwd) {
+    console.log(`  Forwarding:  ${fwd}`);
+  }
+  console.log();
+}
+
+// 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);
+  }
+}
+
+// src/cli/subcommands.ts
+import pico3 from "picocolors";
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["config", "start"]);
+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(pico3.cyanBright(`Starting ${configs.length} auto-start tunnel(s)...`));
+  for (const saved of configs) {
+    await startSavedTunnel(saved, manager);
+  }
+  printer_default.print(pico3.gray("\nAll auto-start tunnels launched. Press Ctrl+C to stop.\n"));
+  await new Promise(() => {
+  });
+}
+async function startNamedTunnels(configs, manager) {
+  printer_default.print(pico3.cyanBright(`Starting ${configs.length} tunnel(s)...`));
+  for (const saved of configs) {
+    await startSavedTunnel(saved, manager);
+  }
+  printer_default.print(pico3.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("  " + pico3.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(pico3.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("  " + pico3.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");
+}
+
 // src/main.ts
-import { fileURLToPath } from "url";
-import { argv } from "process";
-import { realpathSync } from "fs";
 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");
@@ -2231,6 +2890,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;
@@ -2239,19 +2904,10 @@ 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 currentFile = fileURLToPath(import.meta.url);
@@ -2265,6 +2921,7 @@ if (entryFile && entryFile === currentFile) {
   main();
 }
 export {
+  RemoteManagementUnauthorizedError,
   TunnelManager,
   TunnelOperations,
   closeRemoteManagement,