pinggy 0.5.2 → 0.5.5

package/dist/{chunk-C3ZMLIC4.js → chunk-UX64XCC2.js}

@@ -1,7 +1,9 @@
 import {
+  DaemonHost,
   IPCClient,
-  SessionMode
-} from "./chunk-BFARGPGP.js";
+  SessionMode,
+  ShutdownStatus
+} from "./chunk-YTJEV27N.js";
 import {
   TunnelAlreadyRunningError,
   TunnelManager,
@@ -10,10 +12,10 @@ import {
   getVersion,
   isValidPort,
   printer_default
-} from "./chunk-DLNUDW6G.js";
+} from "./chunk-PQSLSIDA.js";
 import {
   logger
-} from "./chunk-7G6SJEEA.js";
+} from "./chunk-P7WNBN7F.js";
 import {
   getDaemonInfoPath,
   getDaemonLogPath
@@ -127,7 +129,7 @@ var RemoteManagementStatus = {
 };
 
 // src/remote_management/remote_schema.ts
-import { TunnelType } from "@pinggy/pinggy";
+import { HaProxyVersion, TunnelType } from "@pinggy/pinggy";
 import { z } from "zod";
 var HeaderModificationSchema = z.object({
   key: z.string(),
@@ -207,7 +209,7 @@ var UpdateConfigSchema = z.object({
 var ForwardingEntryV2Schema = z.object({
   listenAddress: z.string().optional(),
   address: z.string(),
-  type: z.enum([TunnelType.Http, TunnelType.Tcp, TunnelType.Udp, TunnelType.Tls, TunnelType.TlsTcp])
+  type: z.enum([TunnelType.Http, TunnelType.Tcp, TunnelType.Udp, TunnelType.Tls, TunnelType.TlsTcp]).default(TunnelType.Http)
 });
 var OptionalSchema = z.object({
   sniServerName: z.string().optional(),
@@ -251,7 +253,9 @@ var TunnelConfigV1Schema = z.object({
   httpsOnly: z.boolean().optional(),
   originalRequestUrl: z.boolean().optional(),
   allowPreflight: z.boolean().optional(),
-  optional: OptionalSchema.optional()
+  haProxy: z.enum([HaProxyVersion.V1, HaProxyVersion.V2]).optional(),
+  serve: z.string().optional(),
+  optional: z.record(z.string(), z.unknown()).optional()
 });
 var TUNNEL_CONFIG_V1_KEYS = Object.keys(
   TunnelConfigV1Schema.shape
@@ -284,6 +288,7 @@ function pinggyOptionsToTunnelConfigV1(opts, configStoredInCli) {
     httpsOnly: opts.httpsOnly ?? false,
     originalRequestUrl: opts.originalRequestUrl ?? false,
     allowPreflight: opts.allowPreflight ?? false,
+    haProxy: opts.haProxy,
     optional: opts.optional || {}
   };
 }
@@ -504,11 +509,11 @@ var TunnelOperations = class {
         startPromise.catch((err) => {
           logger.error("No-wait startTunnel failed", { tunnelid, err: String(err) });
         });
-        return this.buildPendingTunnelResponseV2(tunnelid, tunnelConfig, config, config.configId, config.name, config.optional?.serve);
+        return this.buildPendingTunnelResponseV2(tunnelid, tunnelConfig, config, config.configId, config.name, config.serve);
       }
       await startPromise;
       const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.optional?.serve);
+      return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
     } catch (err) {
       if (err instanceof TunnelAlreadyRunningError) {
         return this.error(ErrorCode.TunnelAlreadyRunningError, err, err.message);
@@ -530,10 +535,12 @@ var TunnelOperations = class {
       if (noWait) {
         const existing = this.tunnelManager.getManagedTunnel(config.configid);
         if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
-        this.tunnelManager.updateConfig(updateOpts).catch((err) => {
-          logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
-        });
-        return this.buildPendingTunnelResponse(existing.tunnelid, existing.tunnelConfig, config.configid, existing.tunnelName, existing.serve);
+        if (!existing.isStopped) {
+          this.tunnelManager.updateConfig(updateOpts).catch((err) => {
+            logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
+          });
+          return this.buildPendingTunnelResponse(existing.tunnelid, existing.tunnelConfig, config.configid, existing.tunnelName, existing.serve);
+        }
       }
       const tunnel = await this.tunnelManager.updateConfig(updateOpts);
       if (!tunnel.instance || !tunnel.tunnelConfig)
@@ -548,10 +555,12 @@ var TunnelOperations = class {
       if (noWait) {
         const existing = this.tunnelManager.getManagedTunnel(config.configId);
         if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
-        this.tunnelManager.updateConfig(config).catch((err) => {
-          logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
-        });
-        return this.buildPendingTunnelResponseV2(existing.tunnelid, existing.tunnelConfig, config, config.configId, existing.tunnelName, existing.serve);
+        if (!existing.isStopped) {
+          this.tunnelManager.updateConfig(config).catch((err) => {
+            logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
+          });
+          return this.buildPendingTunnelResponseV2(existing.tunnelid, existing.tunnelConfig, config, config.configId, existing.tunnelName, existing.serve);
+        }
       }
       const tunnel = await this.tunnelManager.updateConfig(config);
       if (!tunnel.instance || !tunnel.tunnelConfig)
@@ -698,13 +707,71 @@ import WebSocket from "ws";
 
 // src/remote_management/websocket_printer.ts
 import pico from "picocolors";
-var PENDING_START_TIMEOUT_MS = 5 * 60 * 1e3;
-var RemoteManagementWebSocketPrinter = class {
+var PENDING_TIMEOUT_MS = 5 * 60 * 1e3;
+var PendingTracker = class {
   constructor() {
-    this.pendingStarts = /* @__PURE__ */ new Map();
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  queue(entry) {
+    this.latestConfigId = entry.configId;
+    this.entries.set(entry.configId, entry);
+  }
+  /** Store an entry without claiming the latest cursor. */
+  upsert(entry) {
+    this.entries.set(entry.configId, entry);
+  }
+  get(configId) {
+    return this.entries.get(configId);
+  }
+  find(configId, tunnelId) {
+    const byConfigId = this.entries.get(configId);
+    if (byConfigId) {
+      return byConfigId;
+    }
+    if (!tunnelId) {
+      return void 0;
+    }
+    for (const entry of this.entries.values()) {
+      if (entry.tunnelId === tunnelId) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  delete(configId) {
+    this.entries.delete(configId);
+    if (this.latestConfigId === configId) {
+      this.latestConfigId = void 0;
+    }
+  }
+  get latest() {
+    return this.latestConfigId;
   }
-  setTunnelHandler(tunnelHandler) {
-    this.tunnelHandler = tunnelHandler;
+  get hasLatest() {
+    return this.entries.size > 0 && this.latestConfigId !== void 0;
+  }
+  isLatest(configId) {
+    return configId === this.latestConfigId;
+  }
+  cleanupExpired(onTimeout) {
+    const now = Date.now();
+    for (const [configId, entry] of this.entries) {
+      if (now - entry.queuedAt <= PENDING_TIMEOUT_MS) {
+        continue;
+      }
+      const wasLatest = this.isLatest(configId);
+      this.delete(configId);
+      onTimeout(entry, wasLatest);
+    }
+  }
+};
+var RemoteManagementWebSocketPrinter = class {
+  constructor() {
+    this.pendingStarts = new PendingTracker();
+    this.pendingActions = new PendingTracker();
+    // tunnelId -> details, fed by monitorList. Stop/restart requests only carry
+    // a tunnelId; without this the spinner shows the raw id.
+    this.tunnelDetailsCache = /* @__PURE__ */ new Map();
   }
   queueStart(config) {
     this.cleanupExpiredPendingStarts();
@@ -713,24 +780,23 @@ var RemoteManagementWebSocketPrinter = class {
       configName: this.getConfigNameFromRequest(config),
       queuedAt: Date.now()
     };
-    this.latestPendingConfigId = entry.configId;
-    this.pendingStarts.set(entry.configId, entry);
+    this.pendingStarts.queue(entry);
     printer_default.startSpinner("Starting tunnel with config name: " + entry.configName);
   }
   failQueuedStart(config, reason) {
     const configId = this.getConfigIdFromRequest(config);
     const pending = this.pendingStarts.get(configId);
     const configName = pending?.configName || this.getConfigNameFromRequest(config);
+    const wasLatest = this.pendingStarts.isLatest(configId);
     this.pendingStarts.delete(configId);
-    if (this.latestPendingConfigId === configId) {
-      this.latestPendingConfigId = void 0;
+    if (wasLatest) {
       printer_default.stopSpinnerFail(`Failed to start tunnel with config name: ${configName}. ${reason}`);
     }
   }
   handleStartResult(config, result) {
     this.cleanupExpiredPendingStarts();
     const requestedConfigId = this.getConfigIdFromRequest(config);
-    if (this.latestPendingConfigId && requestedConfigId !== this.latestPendingConfigId) {
+    if (this.pendingStarts.latest && !this.pendingStarts.isLatest(requestedConfigId)) {
       this.pendingStarts.delete(requestedConfigId);
       return;
     }
@@ -738,20 +804,20 @@ var RemoteManagementWebSocketPrinter = class {
       this.failQueuedStart(config, result.message);
       return;
     }
-    const configId = this.getConfigIdFromTunnel(result);
     const pending = this.pendingStarts.get(requestedConfigId) || {
       configId: requestedConfigId,
       configName: this.getConfigNameFromRequest(config),
       queuedAt: Date.now()
     };
     pending.tunnelId = result.tunnelid;
-    this.pendingStarts.set(requestedConfigId, pending);
+    this.pendingStarts.upsert(pending);
     if (result.remoteurls.length > 0) {
       this.completePendingStart(pending, result.remoteurls);
     }
   }
   printStopRequested(tunnelId) {
     const details = this.resolveTunnelDetails(tunnelId);
+    this.clearPendingAction(details.configId, tunnelId);
     printer_default.startSpinner("Stopping tunnel with config name: " + details.configName);
   }
   handleStopResult(tunnelId, result) {
@@ -765,6 +831,7 @@ var RemoteManagementWebSocketPrinter = class {
   }
   printRestartRequested(tunnelId) {
     const details = this.resolveTunnelDetails(tunnelId);
+    this.clearPendingAction(details.configId, tunnelId);
     printer_default.startSpinner("Restarting tunnel with config name: " + details.configName);
   }
   handleRestartResult(tunnelId, result) {
@@ -774,48 +841,101 @@ var RemoteManagementWebSocketPrinter = class {
       printer_default.stopSpinnerFail("Failed to restart tunnel with config name: " + details.configName);
       return;
     }
-    printer_default.stopSpinnerSuccess("Restarted tunnel with config name: " + details.configName);
-    if (result.remoteurls?.length > 0) {
-      printer_default.info(pico.cyanBright("Remote URLs:"));
-      (result.remoteurls ?? []).forEach(
-        (url) => printer_default.print("  " + pico.magentaBright(url))
-      );
+    this.queuePendingAction("restart", details.configId, details.configName, result.tunnelid);
+  }
+  printUpdateConfigRequested(config) {
+    const configName = this.getConfigNameFromRequest(config);
+    this.clearPendingAction(this.getConfigIdFromRequest(config));
+    printer_default.startSpinner("Updating tunnel configuration for: " + configName);
+  }
+  handleUpdateConfigResult(config, result) {
+    const configId = this.getConfigIdFromRequest(config);
+    const configName = this.getConfigNameFromRequest(config);
+    if (isErrorResponse(result)) {
+      printer_default.stopSpinnerFail(`Failed to update tunnel configuration for: ${configName}. ${result.message}`);
+      return;
+    }
+    if (result.status.state === "exited" /* Exited */) {
+      printer_default.stopSpinnerSuccess(`Tunnel configuration updated: ${configName}.`);
+      return;
+    }
+    this.queuePendingAction("update", configId, configName, result.tunnelid);
+  }
+  clearPendingAction(configId, tunnelId) {
+    const entry = this.pendingActions.find(configId, tunnelId);
+    if (!entry) {
+      return;
     }
+    this.pendingActions.delete(entry.configId);
+  }
+  queuePendingAction(action, configId, configName, tunnelId) {
+    this.cleanupExpiredPendingActions();
+    this.pendingActions.queue({ action, configId, configName, queuedAt: Date.now(), tunnelId });
+  }
+  printActionComplete(action, configName, urls) {
+    const message = action === "restart" ? `Restarted tunnel with config name: ${configName}` : `Tunnel configuration updated and restarted: ${configName}`;
+    printer_default.stopSpinnerSuccess(message);
+    printer_default.info(pico.cyanBright("Remote URLs:"));
+    urls.forEach((url) => printer_default.print("  " + pico.magentaBright(url)));
   }
   monitorList(result) {
     this.cleanupExpiredPendingStarts();
-    if (!Array.isArray(result) || this.pendingStarts.size === 0 || !this.latestPendingConfigId) {
+    this.cleanupExpiredPendingActions();
+    if (!Array.isArray(result)) {
       return;
     }
     for (const tunnel of result) {
-      const pending = this.findPendingStart(tunnel);
-      if (!pending) {
-        continue;
+      this.tunnelDetailsCache.set(tunnel.tunnelid, {
+        configId: this.getConfigIdFromTunnel(tunnel),
+        configName: this.getConfigNameFromTunnel(tunnel)
+      });
+    }
+    this.resolvePendingFromList(
+      result,
+      this.pendingStarts,
+      (entry, urls) => this.completePendingStart(entry, urls),
+      (entry, reason) => printer_default.stopSpinnerFail(`Tunnel start did not complete for config name: ${entry.configName}. ${reason}`)
+    );
+    this.resolvePendingFromList(
+      result,
+      this.pendingActions,
+      (entry, urls) => {
+        this.pendingActions.delete(entry.configId);
+        this.printActionComplete(entry.action, entry.configName, urls);
+      },
+      (entry, reason) => {
+        const verb = entry.action === "restart" ? "Restart" : "Configuration update";
+        printer_default.stopSpinnerFail(`${verb} did not complete for config name: ${entry.configName}. ${reason}`);
       }
-      if (pending.configId !== this.latestPendingConfigId) {
+    );
+  }
+  resolvePendingFromList(tunnels, tracker, onComplete, onExited) {
+    if (!tracker.hasLatest) {
+      return;
+    }
+    for (const tunnel of tunnels) {
+      const entry = tracker.find(this.getConfigIdFromTunnel(tunnel), tunnel.tunnelid);
+      if (!entry || !tracker.isLatest(entry.configId)) {
         continue;
       }
-      pending.tunnelId = tunnel.tunnelid;
-      this.pendingStarts.set(pending.configId, pending);
+      entry.tunnelId = tunnel.tunnelid;
+      tracker.upsert(entry);
       if (tunnel.remoteurls.length > 0) {
-        this.completePendingStart(pending, tunnel.remoteurls);
+        onComplete(entry, tunnel.remoteurls);
         continue;
       }
       if (tunnel.status.state === "exited" /* Exited */) {
-        const reason = tunnel.status.errormsg || "Tunnel exited before a public URL was assigned";
-        this.pendingStarts.delete(pending.configId);
-        this.latestPendingConfigId = void 0;
-        printer_default.stopSpinnerFail(`Tunnel start did not complete for config name: ${pending.configName}. ${reason}`);
+        tracker.delete(entry.configId);
+        onExited(entry, tunnel.status.errormsg || "Tunnel exited before a public URL was assigned");
       }
     }
   }
   completePendingStart(entry, urls) {
-    if (this.latestPendingConfigId && entry.configId !== this.latestPendingConfigId) {
+    if (this.pendingStarts.latest && !this.pendingStarts.isLatest(entry.configId)) {
       this.pendingStarts.delete(entry.configId);
       return;
     }
     this.pendingStarts.delete(entry.configId);
-    this.latestPendingConfigId = void 0;
     printer_default.stopSpinnerSuccess(`Tunnel started with config name: ${entry.configName}.`);
     printer_default.info(pico.cyanBright("Remote URLs:"));
     (urls ?? []).forEach(
@@ -823,28 +943,27 @@ var RemoteManagementWebSocketPrinter = class {
     );
   }
   cleanupExpiredPendingStarts() {
-    const now = Date.now();
-    for (const [configId, entry] of this.pendingStarts.entries()) {
-      if (now - entry.queuedAt <= PENDING_START_TIMEOUT_MS) {
-        continue;
+    this.pendingStarts.cleanupExpired((entry, wasLatest) => {
+      const message = `Timed out while waiting for tunnel URL for config name: ${entry.configName}`;
+      if (wasLatest) {
+        printer_default.stopSpinnerFail(message);
+      } else {
+        printer_default.warn(message);
       }
-      this.pendingStarts.delete(configId);
-      printer_default.warn(`Timed out while waiting for tunnel URL for config name: ${entry.configName}`);
-      logger.warn("Pending websocket start entry expired", { configId, tunnelId: entry.tunnelId });
-    }
+      logger.warn("Pending websocket start entry expired", { configId: entry.configId, tunnelId: entry.tunnelId });
+    });
   }
-  findPendingStart(tunnel) {
-    const configId = this.getConfigIdFromTunnel(tunnel);
-    const byConfigId = this.pendingStarts.get(configId);
-    if (byConfigId) {
-      return byConfigId;
-    }
-    for (const entry of this.pendingStarts.values()) {
-      if (entry.tunnelId === tunnel.tunnelid) {
-        return entry;
+  cleanupExpiredPendingActions() {
+    this.pendingActions.cleanupExpired((entry, wasLatest) => {
+      const verb = entry.action === "restart" ? "restart" : "configuration update";
+      const message = `Timed out while waiting for tunnel URL after ${verb} for config name: ${entry.configName}`;
+      if (wasLatest) {
+        printer_default.stopSpinnerFail(message);
+      } else {
+        printer_default.warn(message);
       }
-    }
-    return void 0;
+      logger.warn("Pending websocket action entry expired", { configId: entry.configId, tunnelId: entry.tunnelId, action: entry.action });
+    });
   }
   resolveTunnelDetails(tunnelId, result) {
     if (result && !isErrorResponse(result)) {
@@ -853,7 +972,7 @@ var RemoteManagementWebSocketPrinter = class {
         configName: this.getConfigNameFromTunnel(result)
       };
     }
-    return {
+    return this.tunnelDetailsCache.get(tunnelId) ?? {
       configId: tunnelId,
       configName: tunnelId
     };
@@ -890,7 +1009,6 @@ var WsCommand = {
 var WebSocketCommandHandler = class {
   constructor(handler) {
     this.tunnelHandler = handler ?? new TunnelOperations();
-    remoteManagementWebSocketPrinter.setTunnelHandler(this.tunnelHandler);
   }
   safeParse(text) {
     if (!text) return void 0;
@@ -957,8 +1075,10 @@ var WebSocketCommandHandler = class {
     }
   }
   async handleStopReq(req, raw) {
+    let tunnelID;
     try {
       const dc = StopSchema.parse(raw);
+      tunnelID = dc.tunnelID;
       remoteManagementWebSocketPrinter.printStopRequested(dc.tunnelID);
       const result = await this.tunnelHandler.handleStop(dc.tunnelID);
       remoteManagementWebSocketPrinter.handleStopResult(dc.tunnelID, result);
@@ -968,6 +1088,9 @@ var WebSocketCommandHandler = class {
         printer_default.warn("Validation failed for stop request");
         return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
       }
+      if (tunnelID) {
+        remoteManagementWebSocketPrinter.handleStopResult(tunnelID, newErrorResponse({ code: ErrorCode.InternalServerError, message: errorMessage(e) }));
+      }
       printer_default.warn(`Error in handleStopReq error: ${String(e)}`);
       return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
     }
@@ -987,8 +1110,10 @@ var WebSocketCommandHandler = class {
     }
   }
   async handleRestartReq(req, raw) {
+    let tunnelID;
     try {
       const dc = RestartSchema.parse(raw);
+      tunnelID = dc.tunnelID;
       remoteManagementWebSocketPrinter.printRestartRequested(dc.tunnelID);
       const result = await this.tunnelHandler.handleRestart(dc.tunnelID, true);
       remoteManagementWebSocketPrinter.handleRestartResult(dc.tunnelID, result);
@@ -998,34 +1123,51 @@ var WebSocketCommandHandler = class {
         printer_default.warn("Validation failed for restart request");
         return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
       }
+      if (tunnelID) {
+        remoteManagementWebSocketPrinter.handleRestartResult(tunnelID, newErrorResponse({ code: ErrorCode.InternalServerError, message: errorMessage(e) }));
+      }
       printer_default.warn(`Error in handleRestartReq error: ${String(e)}`);
       return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
     }
   }
   async handleUpdateConfigReq(req, raw) {
+    let parsedConfig;
     try {
       const dc = UpdateConfigSchema.parse(raw);
+      parsedConfig = dc.tunnelConfig;
+      remoteManagementWebSocketPrinter.printUpdateConfigRequested(dc.tunnelConfig);
       const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig, true);
+      remoteManagementWebSocketPrinter.handleUpdateConfigResult(dc.tunnelConfig, result);
       return this.wrapResponse(result, req);
     } catch (e) {
       if (e instanceof z2.ZodError) {
         printer_default.warn("Validation failed for updateconfig request");
         return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
       }
+      if (parsedConfig) {
+        remoteManagementWebSocketPrinter.handleUpdateConfigResult(parsedConfig, newErrorResponse({ code: ErrorCode.InternalServerError, message: errorMessage(e) }));
+      }
       printer_default.warn(`Error in handleUpdateConfigReq error: ${String(e)}`);
       return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
     }
   }
   async handleUpdateConfigV2Req(req, raw) {
+    let parsedConfig;
     try {
       const dc = UpdateConfigV2Schema.parse(raw);
+      parsedConfig = dc.tunnelConfig;
+      remoteManagementWebSocketPrinter.printUpdateConfigRequested(dc.tunnelConfig);
       const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig, true);
+      remoteManagementWebSocketPrinter.handleUpdateConfigResult(dc.tunnelConfig, result);
       return this.wrapResponse(result, req);
     } catch (e) {
       if (e instanceof z2.ZodError) {
         printer_default.warn("Validation failed for update-config-v2 request");
         return NewErrorResponseObject({ code: ErrorCode.InvalidBodyFormatError, message: "Validation failed" });
       }
+      if (parsedConfig) {
+        remoteManagementWebSocketPrinter.handleUpdateConfigResult(parsedConfig, newErrorResponse({ code: ErrorCode.InternalServerError, message: errorMessage(e) }));
+      }
       printer_default.warn(`Error in handleUpdateConfigV2Req error: ${String(e)}`);
       return NewErrorResponseObject({ code: ErrorCode.InternalServerError, message: String(e) });
     }
@@ -1505,16 +1647,18 @@ async function ensureDaemonRunning() {
   const existing = getDaemonInfo();
   if (existing) return existing;
   if (process.versions.electron) {
-    const { runDaemonChild } = await import("./daemonChild-6QA4AVAN.js");
+    const { runDaemonChild } = await import("./daemonChild-ZACX7V6J.js");
     const handle = await runDaemonChild({
       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();
@@ -1525,7 +1669,7 @@ function getInProcessDaemonHandle() {
 async function getActiveTunnelSummaries(origin = "app") {
   const info = getDaemonInfo();
   if (!info) return [];
-  const { IPCClient: IPCClient2 } = await import("./ipcClient-LZQCCNMR.js");
+  const { IPCClient: IPCClient2 } = await import("./ipcClient-XRL2WUUM.js");
   const client = new IPCClient2(info.port, origin);
   let tunnels;
   try {
@@ -1572,10 +1716,17 @@ async function stopDaemon() {
   if (!info) return { ok: false, error: "No daemon is running." };
   let daemonErrors = [];
   try {
-    const { IPCClient: IPCClient2 } = await import("./ipcClient-LZQCCNMR.js");
+    const { IPCClient: IPCClient2 } = await import("./ipcClient-XRL2WUUM.js");
     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)}` };
@@ -1861,6 +2012,13 @@ var DaemonHealth = class {
   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;
   }
@@ -1965,6 +2123,7 @@ var TunnelClient = class _TunnelClient {
     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" });
@@ -2029,15 +2188,30 @@ var TunnelClient = class _TunnelClient {
     this.assertClient();
     return this.ipc.getTunnel(tunnelId);
   }
-  async handleRestart(tunnelId) {
+  async handleRestart(tunnelId, noWait) {
     this.assertClient();
-    return this.ipc.restartTunnel(tunnelId);
+    return this.ipc.restartTunnel(tunnelId, noWait);
   }
   async shutdown() {
     this.assertClient();
     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();

package/dist/{chunk-BFARGPGP.js → chunk-YTJEV27N.js}

@@ -21,6 +21,14 @@ var Route = {
   SetTunnelLogging: "POST /config/tunnel-logging",
   GetLogPaths: "GET /logs/paths"
 };
+var DaemonHost = {
+  CLI: "cli",
+  APP: "app"
+};
+var ShutdownStatus = {
+  ShuttingDown: "shutting_down",
+  RefusedInApp: "refused_in_app"
+};
 var SessionMode = {
   Foreground: "foreground",
   Detached: "detached"
@@ -54,8 +62,8 @@ var IPCClient = class {
   async stopTunnel(tunnelid) {
     return this.call(Route.StopTunnel, { tunnelid });
   }
-  async restartTunnel(tunnelid) {
-    return this.call(Route.RestartTunnel, { tunnelid });
+  async restartTunnel(tunnelid, noWait) {
+    return this.call(Route.RestartTunnel, { tunnelid, noWait });
   }
   // v1 operations (used by remote management via daemon)
   async startTunnelV1(config, mode, noWait) {
@@ -159,6 +167,8 @@ var IPCClient = class {
 
 export {
   Route,
+  DaemonHost,
+  ShutdownStatus,
   SessionMode,
   IPCClient
 };

package/dist/{chunk-WM7I57AA.js → chunk-YWXADADB.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-7G6SJEEA.js";
+} from "./chunk-P7WNBN7F.js";
 import {
   ensureTunnelConfigDir,
   getTunnelConfigDir

package/dist/{configStore-HP3NXPH4.js → configStore-2AZRILVC.js}

@@ -22,8 +22,8 @@ import {
   validateName,
   validateNameForStorage,
   validateNameStrict
-} from "./chunk-WM7I57AA.js";
-import "./chunk-7G6SJEEA.js";
+} from "./chunk-YWXADADB.js";
+import "./chunk-P7WNBN7F.js";
 import "./chunk-GBYF2H4H.js";
 export {
   CONFIG_VERBS,