pinggy 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -2255,7 +2255,7 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
     serve: serve || ""
   };
 }
-var import_pinggy3, import_zod, HeaderModificationSchema, AdditionalForwardingSchema, TunnelConfigSchema, StartSchema, StopSchema, GetSchema, RestartSchema, UpdateConfigSchema, ForwardingEntryV2Schema, TunnelConfigV1Schema, StartV2Schema, UpdateConfigV2Schema;
+var import_pinggy3, import_zod, HeaderModificationSchema, AdditionalForwardingSchema, TunnelConfigSchema, StartSchema, StopSchema, GetSchema, RestartSchema, UpdateConfigSchema, ForwardingEntryV2Schema, OptionalSchema, TunnelConfigV1Schema, TUNNEL_CONFIG_V1_KEYS, StartV2Schema, UpdateConfigV2Schema;
 var init_remote_schema = __esm({
   "src/remote_management/remote_schema.ts"() {
     "use strict";
@@ -2343,11 +2343,23 @@ var init_remote_schema = __esm({
       address: import_zod.z.string(),
       type: import_zod.z.enum([import_pinggy3.TunnelType.Http, import_pinggy3.TunnelType.Tcp, import_pinggy3.TunnelType.Udp, import_pinggy3.TunnelType.Tls, import_pinggy3.TunnelType.TlsTcp])
     });
+    OptionalSchema = import_zod.z.object({
+      sniServerName: import_zod.z.string().optional(),
+      ssl: import_zod.z.boolean().optional(),
+      additionalArguments: import_zod.z.string().optional(),
+      serve: import_zod.z.string().optional(),
+      manage: import_zod.z.string().optional(),
+      remoteManagement: import_zod.z.object({ serverUrl: import_zod.z.string(), apiKey: import_zod.z.string() }).optional(),
+      noTui: import_zod.z.boolean().optional()
+    }).catchall(import_zod.z.unknown());
     TunnelConfigV1Schema = import_zod.z.object({
       // Meta Info
       version: import_zod.z.string(),
       name: import_zod.z.string(),
       configId: import_zod.z.string(),
+      hostKeyCheck: import_zod.z.boolean().optional(),
+      platformValue: import_zod.z.string().optional(),
+      isQRCode: import_zod.z.boolean().optional(),
       // General tunnel configurations
       serverAddress: import_zod.z.string().optional(),
       token: import_zod.z.string().optional(),
@@ -2373,9 +2385,11 @@ var init_remote_schema = __esm({
       httpsOnly: import_zod.z.boolean().optional(),
       originalRequestUrl: import_zod.z.boolean().optional(),
       allowPreflight: import_zod.z.boolean().optional(),
-      serve: import_zod.z.string().optional(),
-      optional: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      optional: OptionalSchema.optional()
     });
+    TUNNEL_CONFIG_V1_KEYS = Object.keys(
+      TunnelConfigV1Schema.shape
+    );
     StartV2Schema = import_zod.z.object({
       tunnelID: import_zod.z.string().nullable().optional(),
       tunnelConfig: TunnelConfigV1Schema
@@ -2511,11 +2525,11 @@ var init_handler = __esm({
             startPromise.catch((err) => {
               logger.error("No-wait startTunnel failed", { tunnelid, err: String(err) });
             });
-            return this.buildPendingTunnelResponseV2(tunnelid, tunnelConfig, config, config.configId, config.name, config.serve);
+            return this.buildPendingTunnelResponseV2(tunnelid, tunnelConfig, config, config.configId, config.name, config.optional?.serve);
           }
           await startPromise;
           const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-          return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
+          return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.optional?.serve);
         } catch (err) {
           if (err instanceof TunnelAlreadyRunningError) {
             return this.error(ErrorCode.TunnelAlreadyRunningError, err, err.message);
@@ -3872,7 +3886,7 @@ var init_defaults = __esm({
 function parseExtendedOptions(options, config, localServerTls) {
   if (!options) return localServerTls;
   for (const opt of options) {
-    const [key, value] = opt.replace(/^"|"$/g, "").split(/:(.+)/).filter(Boolean);
+    const [key, value] = opt.replace(/^"|"$/g, "").split(/:(.*)/).filter(Boolean);
     switch (key) {
       case "x":
         switch (value) {
@@ -3933,7 +3947,7 @@ function parseExtendedOptions(options, config, localServerTls) {
         break;
       case "b":
         if (value && value.includes(":")) {
-          const [username, password] = value.split(/:(.+)/);
+          const [username, password] = value.split(/:(.*)/);
           if (!config.basicAuth) config.basicAuth = [];
           config.basicAuth.push({ username, password });
         } else {
@@ -3943,7 +3957,7 @@ function parseExtendedOptions(options, config, localServerTls) {
         break;
       case "a":
         if (value && value.includes(":")) {
-          const [key2, val] = value.split(/:(.+)/);
+          const [key2, val] = value.split(/:(.*)/);
           if (!config.headerModification) config.headerModification = [];
           config.headerModification.push({ type: "add", key: key2, value: [val] });
         } else {
@@ -3953,7 +3967,7 @@ function parseExtendedOptions(options, config, localServerTls) {
         break;
       case "u":
         if (value && value.includes(":")) {
-          const [key2, val] = value.split(/:(.+)/);
+          const [key2, val] = value.split(/:(.*)/);
           if (!config.headerModification) config.headerModification = [];
           config.headerModification.push({ type: "update", key: key2, value: [val] });
         } else {
@@ -4350,6 +4364,13 @@ function parseToken(finalConfig, explicitToken) {
     finalConfig.token = explicitToken;
   }
 }
+function normalizeForwardingToArray(finalConfig, type) {
+  const fwd = finalConfig.forwarding;
+  if (typeof fwd !== "string") {
+    return;
+  }
+  finalConfig.forwarding = fwd.trim() === "" ? [] : [{ type: type || import_pinggy4.TunnelType.Http, address: fwd.trim() }];
+}
 function parseArgs2(finalConfig, remainingPositionals) {
   let localserverTls = "";
   localserverTls = parseExtendedOptions(remainingPositionals, finalConfig, localserverTls);
@@ -4470,6 +4491,7 @@ function buildFinalConfig(values, positionals, baseConfig) {
   if (forceFlag || values.force) {
     finalConfig.force = true;
   }
+  normalizeForwardingToArray(finalConfig, type);
   parseArgs2(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
@@ -4509,6 +4531,8 @@ __export(configStore_exports, {
   RESERVED_NAMES: () => RESERVED_NAMES,
   SUBCOMMANDS: () => SUBCOMMANDS,
   Subcommand: () => Subcommand,
+  bulkReplace: () => bulkReplace,
+  configureStorageLogger: () => configureStorageLogger,
   deleteConfig: () => deleteConfig,
   findConfig: () => findConfig,
   findConfigByName: () => findConfigByName,
@@ -4521,15 +4545,21 @@ __export(configStore_exports, {
   saveConfig: () => saveConfig,
   updateConfigAutoStart: () => updateConfigAutoStart,
   updateTunnelConfig: () => updateTunnelConfig,
-  validateName: () => validateName
+  upsertConfig: () => upsertConfig,
+  validateName: () => validateName,
+  validateNameForStorage: () => validateNameForStorage,
+  validateNameStrict: () => validateNameStrict
 });
+function configureStorageLogger(l) {
+  storageLogger = l;
+}
 function buildFilename(name, configId) {
   return `${name}_${configId}.json`;
 }
 function sanitizeName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
-function validateName(name) {
+function validateNameStrict(name) {
   if (!name || name.trim().length === 0) {
     return new Error("Tunnel name cannot be empty.");
   }
@@ -4544,17 +4574,38 @@ function validateName(name) {
   }
   return null;
 }
+function validateNameForStorage(name) {
+  if (!name || name.trim().length === 0) {
+    return new Error("Tunnel name cannot be empty.");
+  }
+  if (/[\u0000-\u001F\/\\]/.test(name)) {
+    return new Error("Tunnel name cannot contain path separators or control characters.");
+  }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    return new Error(`"${name}" is a reserved subcommand name. Use a different name.`);
+  }
+  return null;
+}
 function readConfigFile(filePath) {
   try {
     const data = import_fs7.default.readFileSync(filePath, { encoding: "utf-8" });
     return JSON.parse(data);
   } catch (err) {
-    logger.warn(`Failed to read config file ${filePath}:`, err);
+    storageLogger.warn(`Failed to read config file ${filePath}: ${String(err)}`);
     return null;
   }
 }
 function writeConfigFile(filePath, config) {
-  import_fs7.default.writeFileSync(filePath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+  const tmp = `${filePath}.tmp.${process.pid}`;
+  import_fs7.default.writeFileSync(tmp, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+  import_fs7.default.renameSync(tmp, filePath);
+}
+function nextTimestamp(prev) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  if (prev && ts <= prev) {
+    return new Date(new Date(prev).getTime() + 1).toISOString();
+  }
+  return ts;
 }
 function listSavedConfigs() {
   const dir = getTunnelConfigDir();
@@ -4576,15 +4627,15 @@ function findConfigFile(nameOrId) {
   if (!import_fs7.default.existsSync(dir)) return null;
   const files = import_fs7.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_path7.default.join(dir, nameMatch);
+  const nameCandidates = files.filter((f) => f.startsWith(sanitized + "_"));
+  for (const f of nameCandidates) {
+    const filePath = import_path7.default.join(dir, f);
     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("_");
+    const lastUnderscore = withoutExt.lastIndexOf("_");
     if (lastUnderscore === -1) return false;
     const idPart = withoutExt.slice(lastUnderscore + 1);
     return idPart.startsWith(nameOrId);
@@ -4596,15 +4647,33 @@ function findConfigFile(nameOrId) {
   }
   return null;
 }
+function findConfigFileByConfigId(configId) {
+  const dir = getTunnelConfigDir();
+  if (!import_fs7.default.existsSync(dir)) return null;
+  const files = import_fs7.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    const filePath = import_path7.default.join(dir, file);
+    const config = readConfigFile(filePath);
+    if (config && config.configId === configId) {
+      return { filePath, config };
+    }
+  }
+  return null;
+}
 function findConfigByName(name) {
-  const resolved = findConfigFile(name);
-  return resolved?.config.name === name ? resolved.config : null;
+  const dir = getTunnelConfigDir();
+  if (!import_fs7.default.existsSync(dir)) return null;
+  const prefix = `${sanitizeName(name)}_`;
+  const matches = import_fs7.default.readdirSync(dir).filter((f) => f.endsWith(".json") && f.startsWith(prefix)).map((f) => readConfigFile(import_path7.default.join(dir, f))).filter((c) => c !== null && c.name === name);
+  if (matches.length === 0) return null;
+  return matches.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""))[0];
 }
 function findConfig(nameOrId) {
   return findConfigFile(nameOrId)?.config ?? null;
 }
-function saveConfig(name, configId, tunnelConfig, autoStart = false) {
-  const nameErr = validateName(name);
+function saveConfig(name, configId, tunnelConfig, autoStart = false, options = {}) {
+  const { strict = true } = options;
+  const nameErr = strict ? validateNameStrict(name) : validateNameForStorage(name);
   if (nameErr) {
     throw nameErr;
   }
@@ -4624,12 +4693,58 @@ function saveConfig(name, configId, tunnelConfig, autoStart = false) {
     updatedAt: now,
     tunnelConfig
   };
-  const filename = buildFilename(sanitizeName(name), configId);
-  const filePath = import_path7.default.join(dir, filename);
-  import_fs7.default.writeFileSync(filePath, JSON.stringify(saved, null, 2), { encoding: "utf-8" });
-  logger.info(`Config "${name}" saved to ${filePath}`);
+  const filePath = import_path7.default.join(dir, buildFilename(sanitizeName(name), configId));
+  writeConfigFile(filePath, saved);
+  storageLogger.info(`Config "${name}" saved to ${filePath}`);
   return saved;
 }
+function upsertConfig(saved, options = {}) {
+  const { strict = true } = options;
+  const dir = ensureTunnelConfigDir();
+  const targetPath = import_path7.default.join(dir, buildFilename(sanitizeName(saved.name), saved.configId));
+  const existing = findConfigFileByConfigId(saved.configId);
+  if (existing) {
+    if (import_path7.default.resolve(existing.filePath) !== import_path7.default.resolve(targetPath)) {
+      try {
+        import_fs7.default.unlinkSync(existing.filePath);
+      } catch (err) {
+        storageLogger.warn(`upsertConfig: failed to remove old file ${existing.filePath}: ${String(err)}`);
+      }
+    }
+    writeConfigFile(targetPath, saved);
+    storageLogger.info(`Config "${saved.name}" (${saved.configId}) updated at ${targetPath}`);
+    return saved;
+  }
+  const nameErr = strict ? validateNameStrict(saved.name) : validateNameForStorage(saved.name);
+  if (nameErr) {
+    throw nameErr;
+  }
+  writeConfigFile(targetPath, saved);
+  storageLogger.info(`Config "${saved.name}" (${saved.configId}) saved to ${targetPath}`);
+  return saved;
+}
+function bulkReplace(configs, knownConfigIds, options = {}) {
+  const written = [];
+  const deleted = [];
+  const incomingIds = /* @__PURE__ */ new Set();
+  for (const cfg of configs) {
+    upsertConfig(cfg, options);
+    written.push(cfg.configId);
+    incomingIds.add(cfg.configId);
+  }
+  for (const id of knownConfigIds) {
+    if (incomingIds.has(id)) continue;
+    const existing = findConfigFileByConfigId(id);
+    if (!existing) continue;
+    try {
+      import_fs7.default.unlinkSync(existing.filePath);
+      deleted.push(id);
+    } catch (err) {
+      storageLogger.warn(`bulkReplace: failed to delete ${existing.filePath}: ${String(err)}`);
+    }
+  }
+  return { written, deleted };
+}
 function loadConfigByName(name) {
   return findConfigByName(name);
 }
@@ -4637,25 +4752,25 @@ function deleteConfig(nameOrId) {
   const resolved = findConfigFile(nameOrId);
   if (!resolved) return null;
   import_fs7.default.unlinkSync(resolved.filePath);
-  logger.info(`Config "${resolved.config.name}" deleted.`);
+  storageLogger.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();
+  resolved.config.updatedAt = nextTimestamp(resolved.config.updatedAt);
   writeConfigFile(resolved.filePath, resolved.config);
-  logger.info(`Config "${resolved.config.name}" auto-start set to ${autoStart}`);
+  storageLogger.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();
+  resolved.config.updatedAt = nextTimestamp(resolved.config.updatedAt);
   writeConfigFile(resolved.filePath, resolved.config);
-  logger.info(`Config "${resolved.config.name}" tunnel configuration updated`);
+  storageLogger.info(`Config "${resolved.config.name}" tunnel configuration updated`);
   return resolved.config;
 }
 function getAutoStartConfigs() {
@@ -4734,7 +4849,7 @@ Tunnel Config: ${import_picocolors4.default.cyanBright(config.name)}`));
   }
   console.log();
 }
-var import_fs7, import_path7, import_picocolors4, Subcommand, ConfigVerb, SUBCOMMANDS, CONFIG_VERBS, RESERVED_NAMES;
+var import_fs7, import_path7, import_picocolors4, storageLogger, Subcommand, ConfigVerb, SUBCOMMANDS, CONFIG_VERBS, RESERVED_NAMES, validateName;
 var init_configStore = __esm({
   "src/cli/configStore.ts"() {
     "use strict";
@@ -4744,6 +4859,11 @@ var init_configStore = __esm({
     init_configDir();
     init_logger();
     import_picocolors4 = __toESM(require("picocolors"), 1);
+    storageLogger = {
+      info: (message, ...meta) => logger.info(message, ...meta),
+      warn: (message, ...meta) => logger.warn(message, ...meta),
+      error: (message, ...meta) => logger.error(message, ...meta)
+    };
     Subcommand = {
       Config: "config",
       Start: "start",
@@ -4769,6 +4889,7 @@ var init_configStore = __esm({
     SUBCOMMANDS = Object.values(Subcommand);
     CONFIG_VERBS = Object.values(ConfigVerb);
     RESERVED_NAMES = /* @__PURE__ */ new Set([...SUBCOMMANDS, ...CONFIG_VERBS]);
+    validateName = validateNameStrict;
   }
 });
 
@@ -7651,10 +7772,10 @@ function handleConfig(args) {
       printConfigList();
       return;
     case ConfigVerb.Show: {
-      const names = requireNames(rest, "config show");
+      const names = clubSpacedName(requireNames(rest, "config show"));
       for (const name of names) {
-        const saved2 = resolveConfig(name);
-        if (saved2) printConfigDetail(saved2);
+        const saved = resolveConfig(name, "config show");
+        if (saved) printConfigDetail(saved);
       }
       return;
     }
@@ -7664,7 +7785,7 @@ function handleConfig(args) {
       return;
     }
     case ConfigVerb.Delete: {
-      const names = requireNames(rest, "config delete");
+      const names = clubSpacedName(requireNames(rest, "config delete"));
       for (const name of names) {
         const deletedName = deleteConfig(name);
         if (deletedName) {
@@ -7681,7 +7802,7 @@ function handleConfig(args) {
       return;
     }
     case ConfigVerb.Auto: {
-      const names = requireNames(rest, "config auto");
+      const names = clubSpacedName(requireNames(rest, "config auto"));
       for (const name of names) {
         const updated = updateConfigAutoStart(name, true);
         if (updated) {
@@ -7693,7 +7814,7 @@ function handleConfig(args) {
       return;
     }
     case ConfigVerb.Noauto: {
-      const names = requireNames(rest, "config noauto");
+      const names = clubSpacedName(requireNames(rest, "config noauto"));
       for (const name of names) {
         const updated = updateConfigAutoStart(name, false);
         if (updated) {
@@ -7704,10 +7825,14 @@ function handleConfig(args) {
       }
       return;
     }
-    default:
-      const saved = resolveConfig(verb);
-      if (saved) printConfigDetail(saved);
+    default: {
+      const names = clubSpacedName([verb, ...rest]);
+      for (const name of names) {
+        const saved = resolveConfig(name, "config");
+        if (saved) printConfigDetail(saved);
+      }
       return;
+    }
   }
 }
 function handleConfigSave(name, remainingArgs) {
@@ -7725,7 +7850,7 @@ function handleConfigSave(name, remainingArgs) {
   printer_default.success(`Config "${name}" saved.`);
 }
 function handleConfigUpdate(nameOrId, remainingArgs) {
-  const saved = resolveConfig(nameOrId);
+  const saved = resolveConfig(nameOrId, "config update");
   if (!saved) return;
   const { values, positionals } = parseCliArgs(cliOptions, remainingArgs);
   logger.debug("Building updated config", { nameOrId, values, positionals });
@@ -7759,7 +7884,7 @@ async function handleStart(args) {
     return;
   }
   const resolved = [];
-  for (const name of names) {
+  for (const name of clubSpacedName(names)) {
     const saved = resolveConfig(name);
     if (!saved) return;
     resolved.push(saved);
@@ -7784,13 +7909,34 @@ async function handleStart(args) {
     await startMultipleForegroundViaDaemon(resolved, values, positionals);
   }
 }
-function resolveConfig(nameOrId) {
-  const saved = findConfig(nameOrId);
-  if (!saved) {
-    printer_default.error(`No config found matching "${nameOrId}". Use: pinggy config list`);
-    return null;
+function clubSpacedName(names) {
+  if (names.length > 1) {
+    const joined = names.join(" ");
+    if (findConfig(joined) ?? findConfigByName(joined)) {
+      return [joined];
+    }
   }
-  return saved;
+  return names;
+}
+function resolveConfig(nameOrId, command = "start") {
+  const saved = findConfig(nameOrId) ?? findConfigByName(nameOrId);
+  if (saved) return saved;
+  const sanitizedQuery = sanitizeName(nameOrId);
+  const suggestions = listSavedConfigs().filter(
+    (c) => c.name !== nameOrId && sanitizeName(c.name) === sanitizedQuery
+  );
+  printer_default.error(`No config found matching "${nameOrId}".`);
+  if (suggestions.length > 0) {
+    for (const c of suggestions.slice(0, 3)) {
+      printer_default.info(`  Did you mean "${c.name}"?  \u2192  pinggy ${command} "${c.name}"`);
+    }
+    if (suggestions.length > 3) {
+      printer_default.info(`  \u2026and ${suggestions.length - 3} more. Use: pinggy config list`);
+    }
+  } else {
+    printer_default.info("  Use: pinggy config list");
+  }
+  return null;
 }
 function requireName(args, command) {
   if (args.length === 0 || args[0].startsWith("-")) {
@@ -9751,17 +9897,39 @@ var init_tunnelClient = __esm({
 var index_exports = {};
 __export(index_exports, {
   RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
+  TUNNEL_CONFIG_V1_KEYS: () => TUNNEL_CONFIG_V1_KEYS,
   TunnelClient: () => TunnelClient,
+  TunnelConfigV1Schema: () => TunnelConfigV1Schema,
   TunnelErrorCodeType: () => TunnelErrorCodeType,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
   TunnelStateType: () => TunnelStateType,
   TunnelWarningCode: () => TunnelWarningCode,
+  bulkReplace: () => bulkReplace,
   closeRemoteManagement: () => closeRemoteManagement,
+  configureStorageLogger: () => configureStorageLogger,
+  deleteConfig: () => deleteConfig,
   enablePackageLogging: () => enablePackageLogging,
+  ensureTunnelConfigDir: () => ensureTunnelConfigDir,
+  findConfig: () => findConfig,
+  findConfigByName: () => findConfigByName,
+  getAutoStartConfigs: () => getAutoStartConfigs,
+  getDaemonInfoPath: () => getDaemonInfoPath,
+  getPinggyConfigDir: () => getPinggyConfigDir,
   getRemoteManagementState: () => getRemoteManagementState,
+  getTunnelConfigDir: () => getTunnelConfigDir,
   initiateRemoteManagement: () => initiateRemoteManagement,
-  startRemoteManagement: () => startRemoteManagement
+  listSavedConfigs: () => listSavedConfigs,
+  loadConfigByName: () => loadConfigByName,
+  sanitizeName: () => sanitizeName,
+  saveConfig: () => saveConfig,
+  startRemoteManagement: () => startRemoteManagement,
+  updateConfigAutoStart: () => updateConfigAutoStart,
+  updateTunnelConfig: () => updateTunnelConfig,
+  upsertConfig: () => upsertConfig,
+  validateName: () => validateName,
+  validateNameForStorage: () => validateNameForStorage,
+  validateNameStrict: () => validateNameStrict
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -9854,6 +10022,9 @@ init_tunnelClient();
 init_logger();
 init_remoteManagement();
 init_types();
+init_configStore();
+init_configDir();
+init_remote_schema();
 async function verifyAndLoad() {
   if (process.platform === "win32") {
     const vcRedist = checkVCRedist();
@@ -9873,15 +10044,37 @@ verifyAndLoad().catch((err) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RemoteManagementUnauthorizedError,
+  TUNNEL_CONFIG_V1_KEYS,
   TunnelClient,
+  TunnelConfigV1Schema,
   TunnelErrorCodeType,
   TunnelManager,
   TunnelOperations,
   TunnelStateType,
   TunnelWarningCode,
+  bulkReplace,
   closeRemoteManagement,
+  configureStorageLogger,
+  deleteConfig,
   enablePackageLogging,
+  ensureTunnelConfigDir,
+  findConfig,
+  findConfigByName,
+  getAutoStartConfigs,
+  getDaemonInfoPath,
+  getPinggyConfigDir,
   getRemoteManagementState,
+  getTunnelConfigDir,
   initiateRemoteManagement,
-  startRemoteManagement
+  listSavedConfigs,
+  loadConfigByName,
+  sanitizeName,
+  saveConfig,
+  startRemoteManagement,
+  updateConfigAutoStart,
+  updateTunnelConfig,
+  upsertConfig,
+  validateName,
+  validateNameForStorage,
+  validateNameStrict
 });