pinggy 0.5.1 → 0.5.3

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);
@@ -2703,7 +2717,7 @@ var init_handler = __esm({
 });
 
 // src/daemon/ipc/ipcRoutes.ts
-var Route, SessionMode;
+var Route, DaemonHost, ShutdownStatus, SessionMode;
 var init_ipcRoutes = __esm({
   "src/daemon/ipc/ipcRoutes.ts"() {
     "use strict";
@@ -2727,6 +2741,14 @@ var init_ipcRoutes = __esm({
       SetTunnelLogging: "POST /config/tunnel-logging",
       GetLogPaths: "GET /logs/paths"
     };
+    DaemonHost = {
+      CLI: "cli",
+      APP: "app"
+    };
+    ShutdownStatus = {
+      ShuttingDown: "shutting_down",
+      RefusedInApp: "refused_in_app"
+    };
     SessionMode = {
       Foreground: "foreground",
       Detached: "detached"
@@ -4350,6 +4372,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 +4499,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 +4539,8 @@ __export(configStore_exports, {
   RESERVED_NAMES: () => RESERVED_NAMES,
   SUBCOMMANDS: () => SUBCOMMANDS,
   Subcommand: () => Subcommand,
+  bulkReplace: () => bulkReplace,
+  configureStorageLogger: () => configureStorageLogger,
   deleteConfig: () => deleteConfig,
   findConfig: () => findConfig,
   findConfigByName: () => findConfigByName,
@@ -4521,15 +4553,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 +4582,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 +4635,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 +4655,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 +4701,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 +4760,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 +4857,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 +4867,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 +4897,7 @@ var init_configStore = __esm({
     SUBCOMMANDS = Object.values(Subcommand);
     CONFIG_VERBS = Object.values(ConfigVerb);
     RESERVED_NAMES = /* @__PURE__ */ new Set([...SUBCOMMANDS, ...CONFIG_VERBS]);
+    validateName = validateNameStrict;
   }
 });
 
@@ -7122,6 +7251,8 @@ async function handleDaemonStop() {
   const result = await stopDaemon();
   if (result.ok) {
     printer_default.success("Daemon stopped.");
+  } else if (result.reason === DaemonHost.APP) {
+    printer_default.print(import_picocolors6.default.yellow("The Pinggy daemon is running inside the Pinggy desktop app. Please quit the Pinggy app to stop it."));
   } else {
     printer_default.error(result.error);
   }
@@ -7142,6 +7273,7 @@ function handleDaemonStatus() {
   printer_default.print(`  Port:      ${info.port}`);
   printer_default.print(`  Started:   ${info.startedAt}`);
   printer_default.print(`  Uptime:    ${uptimeStr}`);
+  printer_default.print(`  Host:      ${info.host === DaemonHost.APP ? "Pinggy app (in-process)" : "standalone (CLI)"}`);
 }
 var import_picocolors6;
 var init_daemonCommandsHandler = __esm({
@@ -7152,6 +7284,7 @@ var init_daemonCommandsHandler = __esm({
     import_picocolors6 = __toESM(require("picocolors"), 1);
     init_configStore();
     init_daemonManager();
+    init_ipcRoutes();
     init_serviceInstaller();
     init_helpMessages();
     init_util();
@@ -7651,10 +7784,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 +7797,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 +7814,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 +7826,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 +7837,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 +7862,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 +7896,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 +7921,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("-")) {
@@ -7861,6 +8019,7 @@ var init_subcommands = __esm({
 // src/main.ts
 var main_exports = {};
 __export(main_exports, {
+  DaemonHost: () => DaemonHost,
   RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
@@ -7923,6 +8082,7 @@ var init_main = __esm({
     init_buildAndStartTunnel();
     init_subcommands();
     init_daemonChild();
+    init_ipcRoutes();
     init_daemonManager();
     currentFile = (0, import_url2.fileURLToPath)(importMetaUrl);
     entryFile = null;
@@ -8229,6 +8389,10 @@ var init_ipcServer = __esm({
           },
           [Route.Shutdown]: () => {
             logger.info("Daemon shutdown requested via IPC");
+            if (getDaemonHost() === DaemonHost.APP) {
+              logger.info("Shutdown refused: daemon is hosted in-process by the Pinggy app");
+              return { status: ShutdownStatus.RefusedInApp, errors: [] };
+            }
             const errors = [];
             const step = (label, fn) => {
               try {
@@ -8243,7 +8407,7 @@ var init_ipcServer = __esm({
             step("clearDaemonState", clearDaemonState);
             step("stopAllTunnels", () => TunnelManager.getInstance().stopAllTunnels());
             setTimeout(() => process.exit(0), 200);
-            return { status: "shutting_down", errors };
+            return { status: ShutdownStatus.ShuttingDown, errors };
           }
         };
       }
@@ -8701,6 +8865,8 @@ var init_sessionTracker = __esm({
 // src/daemon/lifecycle/daemonChild.ts
 var daemonChild_exports = {};
 __export(daemonChild_exports, {
+  DaemonHost: () => DaemonHost,
+  getDaemonHost: () => getDaemonHost,
   removeDaemonInfo: () => removeDaemonInfo,
   runDaemonChild: () => runDaemonChild,
   setDaemonSessionTracker: () => setDaemonSessionTracker,
@@ -8708,6 +8874,9 @@ __export(daemonChild_exports, {
   trackTunnelStart: () => trackTunnelStart,
   trackTunnelStop: () => trackTunnelStop
 });
+function getDaemonHost() {
+  return daemonHost;
+}
 function setDaemonSessionTracker(st) {
   sessionTrackerRef = st;
 }
@@ -8836,6 +9005,7 @@ async function restoreCrashedTunnels(manager) {
 async function runDaemonChild(opts = {}) {
   const installSignalHandlers = opts.installSignalHandlers ?? true;
   const exitOnFailure = opts.exitOnFailure ?? true;
+  daemonHost = opts.host ?? DaemonHost.CLI;
   ensurePinggyConfigDir();
   const persistedLevel = readDaemonConfig()?.logLevel;
   const envLevel = process.env.PINGGY_LOG_LEVEL;
@@ -8911,7 +9081,8 @@ async function runDaemonChild(opts = {}) {
     const info = {
       pid: process.pid,
       port,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      host: daemonHost
     };
     writeDaemonInfo(info);
     logger.info("Daemon info written", info);
@@ -8944,7 +9115,7 @@ async function runDaemonChild(opts = {}) {
     throw err;
   }
 }
-var import_node_fs7, daemonState, sessionTrackerRef;
+var import_node_fs7, daemonState, daemonHost, sessionTrackerRef;
 var init_daemonChild = __esm({
   "src/daemon/lifecycle/daemonChild.ts"() {
     "use strict";
@@ -8962,6 +9133,7 @@ var init_daemonChild = __esm({
     init_util();
     init_ipcRoutes();
     daemonState = { tunnels: [], lastUpdated: "" };
+    daemonHost = DaemonHost.CLI;
     sessionTrackerRef = null;
   }
 });
@@ -9048,13 +9220,15 @@ async function ensureDaemonRunning() {
     const { runDaemonChild: runDaemonChild2 } = await Promise.resolve().then(() => (init_daemonChild(), daemonChild_exports));
     const handle = await runDaemonChild2({
       installSignalHandlers: false,
-      exitOnFailure: false
+      exitOnFailure: false,
+      host: DaemonHost.APP
     });
     inProcessHandle = handle;
     return getDaemonInfo() ?? {
       pid: handle.pid,
       port: handle.port,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      host: DaemonHost.APP
     };
   }
   return startDaemon();
@@ -9116,6 +9290,13 @@ async function stopDaemon() {
     const client = new IPCClient2(info.port);
     const result = await client.shutdown();
     logger.debug("Sent shutdown command to daemon", { result });
+    if (result?.status === ShutdownStatus.RefusedInApp) {
+      return {
+        ok: false,
+        reason: DaemonHost.APP,
+        error: "The daemon is running inside the Pinggy app."
+      };
+    }
     if (Array.isArray(result?.errors)) daemonErrors = result.errors;
   } catch (e) {
     return { ok: false, error: `Failed to reach daemon: ${errorMessage(e)}` };
@@ -9147,6 +9328,7 @@ var init_daemonManager = __esm({
     import_node_fs8 = __toESM(require("fs"), 1);
     import_node_child_process2 = require("child_process");
     init_configDir();
+    init_ipcRoutes();
     init_logger();
     init_types();
     init_util();
@@ -9437,6 +9619,13 @@ var init_daemonHealth = __esm({
       bindPid(pid) {
         this.originalPid = pid;
       }
+      /**
+       * Forget a previous loss verdict. Called when the client re-binds to a
+       * live daemon via ensureDaemon():
+       */
+      reset() {
+        this.lost = false;
+      }
       isLost() {
         return this.lost;
       }
@@ -9563,6 +9752,7 @@ var init_tunnelClient = __esm({
         const info = await ensureDaemonRunning();
         this.ipc = new IPCClient(info.port, this.origin);
         this.health.bindPid(info.pid);
+        this.health.reset();
       }
       static async forRemoteManagement() {
         const client = new _TunnelClient({ origin: "remote" });
@@ -9636,6 +9826,21 @@ var init_tunnelClient = __esm({
         await this.ipc.shutdown();
         this.close();
       }
+      /**
+       * Tear down the daemon hosted in THIS process, if any. Stops all tunnels
+       * and removes daemon.json + daemon-state.json so the next CLI run doesn't
+       * "crash-recover" tunnels that died with the host application. 
+       */
+      shutdownInProcessDaemon() {
+        const handle = getInProcessDaemonHandle();
+        if (!handle) return false;
+        try {
+          this.close();
+        } catch {
+        }
+        handle.shutdown();
+        return true;
+      }
       async getLogLevel() {
         this.assertClient();
         const res = await this.ipc.getLogLevel();
@@ -9751,17 +9956,41 @@ 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,
+  getDaemonInfo: () => getDaemonInfo,
+  getDaemonInfoPath: () => getDaemonInfoPath,
+  getPinggyConfigDir: () => getPinggyConfigDir,
   getRemoteManagementState: () => getRemoteManagementState,
+  getTunnelConfigDir: () => getTunnelConfigDir,
   initiateRemoteManagement: () => initiateRemoteManagement,
-  startRemoteManagement: () => startRemoteManagement
+  isDaemonRunning: () => isDaemonRunning,
+  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();
@@ -9851,9 +10080,13 @@ init_printer();
 init_TunnelManager();
 init_handler();
 init_tunnelClient();
+init_daemonManager();
 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 +10106,39 @@ 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,
+  getDaemonInfo,
+  getDaemonInfoPath,
+  getPinggyConfigDir,
   getRemoteManagementState,
+  getTunnelConfigDir,
   initiateRemoteManagement,
-  startRemoteManagement
+  isDaemonRunning,
+  listSavedConfigs,
+  loadConfigByName,
+  sanitizeName,
+  saveConfig,
+  startRemoteManagement,
+  updateConfigAutoStart,
+  updateTunnelConfig,
+  upsertConfig,
+  validateName,
+  validateNameForStorage,
+  validateNameStrict
 });