pinggy 0.4.6 → 0.4.8

package/dist/index.cjs

@@ -367,9 +367,10 @@ var init_TunnelManager = __esm({
        *                          status information, and statistics
        */
       async createTunnel(config) {
-        const { configId, tunnelid: requestedTunnelId, tunnelName, name, serve } = config;
+        const { configId, tunnelid: requestedTunnelId, tunnelName, name } = config;
         const tunnelid = requestedTunnelId || getRandomId();
         const autoReconnect = config.autoReconnect || false;
+        const serve = this.resolveServePath(config);
         if (!configId || typeof configId !== "string" || configId.trim() === "") {
           throw new Error("configId is required and must be a non-empty string");
         }
@@ -456,8 +457,11 @@ var init_TunnelManager = __esm({
           throw error;
         }
         logger.info("Tunnel started", { tunnelId, urls });
+        logger.info("Checking serve config for tunnel", { tunnelId, serve: managed.serve });
         if (managed.serve) {
           this.startStaticFileServer(managed);
+        } else {
+          logger.debug("No serve path configured, skipping static file server", { tunnelId });
         }
         try {
           const startListeners = this.tunnelStartListeners.get(tunnelId);
@@ -789,6 +793,7 @@ var init_TunnelManager = __esm({
         const currentTunnelName = existingTunnel.tunnelName;
         const currentServe = existingTunnel.serve;
         const currentAutoReconnect = existingTunnel.autoReconnect || false;
+        const requestedServe = this.resolveServePath(newConfig);
         try {
           if (!isStopped) {
             existingTunnel.instance.stop();
@@ -799,9 +804,9 @@ var init_TunnelManager = __esm({
             ...newConfig,
             configId,
             tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-            serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
+            serve: requestedServe !== void 0 ? requestedServe : currentServe
           };
-          const effectiveServe = newConfig.serve !== void 0 ? newConfig.serve : currentServe;
+          const effectiveServe = requestedServe !== void 0 ? requestedServe : currentServe;
           const effectiveTunnelName = newTunnelName !== void 0 ? newTunnelName : currentTunnelName;
           let configWithForwarding;
           const newTunnel = await this._createTunnelWithProcessedConfig({
@@ -1560,21 +1565,35 @@ var init_TunnelManager = __esm({
         const parsed = typeof value === "number" ? value : parseInt(String(value), 10);
         return isNaN(parsed) ? 0 : parsed;
       }
+      /**
+       * Read serve path only from config.optional.serve.
+       */
+      resolveServePath(config) {
+        const optional = config.optional;
+        const servePath = optional?.serve;
+        logger.debug("resolveServePath", { servePath, hasOptional: !!optional, optionalKeys: optional ? Object.keys(optional) : [] });
+        return servePath;
+      }
       startStaticFileServer(managed) {
         try {
           const __filename4 = (0, import_node_url.fileURLToPath)(importMetaUrl);
           const __dirname3 = import_node_path.default.dirname(__filename4);
           const fileServerWorkerPath = import_node_path.default.join(__dirname3, "workers", "file_serve_worker.cjs");
+          logger.info("Starting static file server worker", {
+            dir: managed.serve,
+            forwarding: JSON.stringify(managed.tunnelConfig?.forwarding),
+            workerPath: fileServerWorkerPath
+          });
           const staticServerWorker = new import_node_worker_threads.Worker(fileServerWorkerPath, {
             workerData: {
               dir: managed.serve,
-              port: managed.tunnelConfig?.forwarding
+              forwarding: managed.tunnelConfig?.forwarding
             }
           });
           staticServerWorker.on("message", (msg) => {
             switch (msg.type) {
               case "started":
-                logger.info("Static file server started", { dir: managed.serve });
+                logger.info("Static file server started", { dir: managed.serve, port: msg.portNum });
                 break;
               case "warning":
                 if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
@@ -3084,10 +3103,14 @@ var init_options = __esm({
       v: { type: "boolean", description: "Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable" },
       vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
       vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
-      autoreconnect: { type: "string", short: "a", description: "Automatically reconnect tunnel on failure (enabled by default). Use -a false to disable." },
-      // Save and load config
+      "no-autoreconnect": { type: "boolean", short: "a", description: "Disable auto reconnection on failure (enabled by default)." },
+      // 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
@@ -3137,7 +3160,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"() {
@@ -3147,6 +3184,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({
@@ -3154,6 +3259,7 @@ var init_defaults = __esm({
     "use strict";
     init_cjs_shims();
     defaultOptions = {
+      version: "1.0",
       token: void 0,
       // No default token
       serverAddress: "a.pinggy.io",
@@ -3656,7 +3762,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) {
@@ -3667,10 +3773,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);
@@ -3707,20 +3813,12 @@ function parseServe(finalConfig, values) {
   return null;
 }
 function parseAutoReconnect(finalConfig, values) {
-  const autoReconnectValue = values.autoreconnect;
-  if (typeof autoReconnectValue === "string") {
-    const trimmed = autoReconnectValue.trim().toLowerCase();
-    if (trimmed === "true" || trimmed === "") {
-      finalConfig.autoReconnect = true;
-    } else if (trimmed === "false") {
-      finalConfig.autoReconnect = false;
-    } else {
-      return new Error(`Invalid autoreconnect value: ${autoReconnectValue}. Use true or false.`);
-    }
+  if (values["no-autoreconnect"]) {
+    finalConfig.autoReconnect = false;
   }
   return null;
 }
-async function buildFinalConfig(values, positionals) {
+async function buildFinalConfig(values, positionals, baseConfig) {
   let token;
   let server;
   let type;
@@ -3728,7 +3826,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;
@@ -3780,7 +3878,7 @@ async function buildFinalConfig(values, positionals) {
   if (forceFlag || values.force) {
     finalConfig.force = true;
   }
-  parseArgs(finalConfig, remainingPositionals);
+  parseArgs2(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
 }
@@ -3811,74 +3909,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) => {
@@ -5492,6 +5522,600 @@ 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, {
@@ -5505,16 +6129,23 @@ __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");
+    const gracefulShutdown = (signal) => {
+      logger.info(`${signal} received: stopping tunnels and exiting`);
       console.log("\nStopping all tunnels...");
       manager.stopAllTunnels();
       console.log("Tunnels stopped. Exiting.");
       process.exit(0);
-    });
+    };
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+    if (isSubcommand(rawArgs)) {
+      await handleSubcommand(rawArgs, manager);
+      return;
+    }
+    const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
+    configureLogger(values);
     if (!hasAnyArgs || values.help) {
       printHelpMessage();
       return;
@@ -5523,21 +6154,13 @@ async function main() {
       printer_default.print(`Pinggy CLI version: ${getVersion()}`);
       return;
     }
-    const parseResult = await parseRemoteManagement(values);
-    if (parseResult?.ok === false) {
-      logger.error("Failed to initiate remote management:", parseResult.error);
-      printer_default.fatal(parseResult.error);
-    }
-    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.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";
@@ -5545,23 +6168,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;
     }