pinggy 0.4.6 → 0.4.8

package/dist/{main-XKFFUSKJ.js → main-4WTJG54V.js}

@@ -3,6 +3,7 @@ import {
   RemoteManagementUnauthorizedError,
   TunnelManager,
   TunnelOperations,
+  buildRemoteManagementWsUrl,
   closeRemoteManagement,
   getRandomId,
   getRemoteManagementState,
@@ -10,8 +11,9 @@ import {
   initiateRemoteManagement,
   isValidPort,
   parseRemoteManagement,
-  printer_default
-} from "./chunk-STEISST3.js";
+  printer_default,
+  startRemoteManagement
+} from "./chunk-YFTL44B3.js";
 import {
   configureLogger,
   enablePackageLogging,
@@ -44,10 +46,14 @@ var cliOptions = {
   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
@@ -95,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",
@@ -606,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) {
@@ -617,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);
@@ -657,20 +744,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;
@@ -678,7 +757,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;
@@ -730,72 +809,11 @@ async function buildFinalConfig(values, positionals) {
   if (forceFlag || values.force) {
     finalConfig.force = true;
   }
-  parseArgs(finalConfig, remainingPositionals);
+  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) {
@@ -2299,22 +2317,579 @@ async function startCli(finalConfig, manager) {
   }
 }
 
+// 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");
+    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;
@@ -2323,15 +2898,7 @@ 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);