pinggy 0.6.0 → 0.6.3

package/dist/{chunk-J2U6P376.js → chunk-QNUVQ6KD.js}

@@ -4,10 +4,10 @@ import {
 import {
   getLogLevel,
   logger
-} from "./chunk-76SOSXXR.js";
+} from "./chunk-MV56U3E6.js";
 import {
   getTunnelLogPath
-} from "./chunk-GBYF2H4H.js";
+} from "./chunk-AFMTIELL.js";
 
 // src/tunnel_manager/TunnelManager.ts
 import { TunnelInstance, LogLevel as SdkLogLevel } from "@pinggy/pinggy";
@@ -94,6 +94,114 @@ function maybeRotate(file, maxBytes = DEFAULT_MAX_BYTES, maxArchives = DEFAULT_M
   }
 }
 
+// src/types.ts
+var TunnelStateType = /* @__PURE__ */ ((TunnelStateType2) => {
+  TunnelStateType2["New"] = "idle";
+  TunnelStateType2["Starting"] = "starting";
+  TunnelStateType2["Running"] = "running";
+  TunnelStateType2["Live"] = "live";
+  TunnelStateType2["Closed"] = "closed";
+  TunnelStateType2["Exited"] = "exited";
+  return TunnelStateType2;
+})(TunnelStateType || {});
+var TunnelErrorCodeType = /* @__PURE__ */ ((TunnelErrorCodeType2) => {
+  TunnelErrorCodeType2["NonResponsive"] = "non_responsive";
+  TunnelErrorCodeType2["FailedToConnect"] = "failed_to_connect";
+  TunnelErrorCodeType2["ErrorInAdditionalForwarding"] = "additional_forwarding_error";
+  TunnelErrorCodeType2["WebdebuggerError"] = "webdebugger_error";
+  TunnelErrorCodeType2["NoError"] = "";
+  return TunnelErrorCodeType2;
+})(TunnelErrorCodeType || {});
+var TunnelWarningCode = /* @__PURE__ */ ((TunnelWarningCode3) => {
+  TunnelWarningCode3["InvalidTunnelServePath"] = "INVALID_TUNNEL_SERVE_PATH";
+  TunnelWarningCode3["UnknownWarning"] = "UNKNOWN_WARNING";
+  return TunnelWarningCode3;
+})(TunnelWarningCode || {});
+var ErrorCode = {
+  InvalidRequestMethodError: "INVALID_REQUEST_METHOD",
+  InvalidRequestBodyError: "COULD_NOT_READ_BODY",
+  InternalServerError: "INTERNAL_SERVER_ERROR",
+  InvalidBodyFormatError: "INVALID_DATA_FORMAT",
+  ErrorStartingTunnel: "ERROR_STARTING_TUNNEL",
+  TunnelNotFound: "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND",
+  TunnelAlreadyRunningError: "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING",
+  WebsocketUpgradeFailError: "WEBSOCKET_UPGRADE_FAILED",
+  RemoteManagementAlreadyRunning: "REMOTE_MANAGEMENT_ALREADY_RUNNING",
+  RemoteManagementNotRunning: "REMOTE_MANAGEMENT_NOT_RUNNING",
+  RemoteManagementDeserializationFailed: "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED",
+  DeviceNotEnrolled: "DEVICE_NOT_ENROLLED"
+};
+function isErrorResponse(obj) {
+  return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj && typeof obj.message === "string" && Object.values(ErrorCode).includes(obj.code);
+}
+function newErrorResponse(codeOrError, message) {
+  if (typeof codeOrError === "object") {
+    return codeOrError;
+  }
+  return {
+    code: codeOrError,
+    message
+  };
+}
+function NewResponseObject(data) {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(JSON.stringify(data));
+  return {
+    response: bytes,
+    requestid: "",
+    command: "",
+    error: false,
+    errorresponse: {}
+  };
+}
+function NewErrorResponseObject(errorResponse) {
+  return {
+    response: new Uint8Array(),
+    requestid: "",
+    command: "",
+    error: true,
+    errorresponse: errorResponse
+  };
+}
+function newStatus(tunnelState, errorCode, errorMsg) {
+  let assignedState = tunnelState;
+  if (tunnelState === "live" /* Live */) {
+    assignedState = "running" /* Running */;
+  } else if (tunnelState === "idle" /* New */) {
+    assignedState = "idle" /* New */;
+  } else if (tunnelState === "closed" /* Closed */) {
+    assignedState = "exited" /* Exited */;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    state: assignedState,
+    errorcode: errorCode,
+    errormsg: errorMsg,
+    createdtimestamp: now,
+    starttimestamp: now,
+    endtimestamp: now,
+    warnings: []
+  };
+}
+function newStats() {
+  return {
+    numLiveConnections: 0,
+    numTotalConnections: 0,
+    numTotalReqBytes: 0,
+    numTotalResBytes: 0,
+    numTotalTxBytes: 0,
+    elapsedTime: 0
+  };
+}
+var RemoteManagementStatus = {
+  Connecting: "CONNECTING",
+  Disconnecting: "DISCONNECTING",
+  Reconnecting: "RECONNECTING",
+  Running: "RUNNING",
+  NotRunning: "NOT_RUNNING",
+  Error: "ERROR"
+};
+
 // src/tunnel_manager/TunnelManager.ts
 import path2 from "path";
 import { Worker } from "worker_threads";
@@ -268,6 +376,7 @@ function getLocalAddress(config) {
 // src/tunnel_manager/TunnelManager.ts
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = path2.dirname(__filename3);
+var START_FAILED_MESSAGE = "Failed to start tunnel";
 function mapToSdkLogLevel(level) {
   if (level === "debug") return SdkLogLevel.DEBUG;
   if (level === "error") return SdkLogLevel.ERROR;
@@ -282,6 +391,13 @@ var TunnelAlreadyRunningError = class extends Error {
     this.name = "TunnelAlreadyRunningError";
   }
 };
+var TunnelRebuildInProgressError = class extends Error {
+  constructor(tunnelId) {
+    super(`Tunnel "${tunnelId}" is already restarting`);
+    this.tunnelId = tunnelId;
+    this.name = "TunnelRebuildInProgressError";
+  }
+};
 var TunnelManager = class _TunnelManager {
   constructor() {
     this.tunnelsByTunnelId = /* @__PURE__ */ new Map();
@@ -326,7 +442,7 @@ var TunnelManager = class _TunnelManager {
       throw new Error("configId is required and must be a non-empty string");
     }
     const existing = this.tunnelsByConfigId.get(configId);
-    if (existing && !existing.isStopped) {
+    if (existing && (!existing.isStopped || existing.rebuild)) {
       throw new TunnelAlreadyRunningError(configId, existing.tunnelid);
     }
     return this._createTunnelWithProcessedConfig({
@@ -348,14 +464,15 @@ var TunnelManager = class _TunnelManager {
    * @private
    */
   async _createTunnelWithProcessedConfig(params) {
-    const tunnelLogName = params.tunnelName || params.originalConfig?.name;
+    const tunnelConfig = { ...params.originalConfig, maxReconnectAttempts: 0 };
+    const tunnelLogName = params.tunnelName || tunnelConfig?.name;
     const tunnelLogPath = getTunnelLogPath(params.tunnelid, params.origin, tunnelLogName);
     maybeRotate(tunnelLogPath);
     attachTunnelLogger(params.tunnelid, params.origin, tunnelLogName);
     let instance;
     try {
-      logger.debug("Creating tunnel instance with processed config", params.originalConfig);
-      instance = await TunnelInstance.create(params.originalConfig, {
+      logger.debug("Creating tunnel instance with processed config", tunnelConfig);
+      instance = await TunnelInstance.create(tunnelConfig, {
         enabled: true,
         logLevel: mapToSdkLogLevel(getLogLevel()),
         logFilePath: tunnelLogPath,
@@ -373,7 +490,7 @@ var TunnelManager = class _TunnelManager {
       tunnelName: params.tunnelName,
       origin: params.origin,
       instance,
-      tunnelConfig: params.originalConfig,
+      tunnelConfig,
       serve: params.serve,
       warnings: [],
       isStopped: false,
@@ -413,11 +530,12 @@ var TunnelManager = class _TunnelManager {
     try {
       urls = await managed.instance.start();
     } catch (error) {
-      logger.warn("Failed to start tunnel", { tunnelId, error });
+      const reason = errorMessage(error) || START_FAILED_MESSAGE;
+      logger.warn("Failed to start tunnel", { tunnelId, error: reason });
       managed.isStopped = true;
       managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
       managed.lastError = {
-        message: "Failed to start tunnel",
+        message: reason,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         isFatal: true
       };
@@ -588,6 +706,9 @@ var TunnelManager = class _TunnelManager {
       logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
       throw new Error(`Tunnel "${tunnelId}" not found`);
     }
+    if (managed.rebuild?.startsAfter) {
+      return "starting" /* Starting */;
+    }
     if (managed.isStopped) {
       return "exited";
     }
@@ -638,6 +759,10 @@ var TunnelManager = class _TunnelManager {
       logger.warn("Attempted to remove tunnel that is not stopped", { tunnelId });
       return false;
     }
+    if (managed.rebuild) {
+      logger.warn("Attempted to remove tunnel that is restarting", { tunnelId });
+      return false;
+    }
     this._cleanupTunnelRecords(managed);
     logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configId });
     return true;
@@ -717,17 +842,27 @@ var TunnelManager = class _TunnelManager {
       if (!managed) {
         return Promise.reject(new Error(`Tunnel with configId "${configId}" not found`));
       }
-      return Promise.resolve(managed.instance.getConfig());
+      return this.currentConfig(managed);
     }
     if (tunnelId) {
       const managed = this.tunnelsByTunnelId.get(tunnelId);
       if (!managed) {
         return Promise.reject(new Error(`Tunnel with tunnelId "${tunnelId}" not found`));
       }
-      return Promise.resolve(managed.instance.getConfig());
+      return this.currentConfig(managed);
     }
     return Promise.reject(new Error(`Either configId or tunnelId must be provided`));
   }
+  /**
+   * The instance's config, asked of its worker. A stopped instance has let its worker go, so a stopped
+   * tunnel, including one a restart is replacing, answers with the config it was built from.
+   */
+  currentConfig(managed) {
+    if (managed.isStopped) {
+      return Promise.resolve(managed.tunnelConfig);
+    }
+    return Promise.resolve(managed.instance.getConfig());
+  }
   /**
    * Stop a tunnel instance and wait for the stop to settle, capped by a
    * timeout. Failure is logged, not thrown: the caller replaces the
@@ -751,6 +886,46 @@ var TunnelManager = class _TunnelManager {
       if (timer) clearTimeout(timer);
     }
   }
+  /**
+   * Marks the entry a restart or config update replaces. It stays in both maps until
+   * `_createTunnelWithProcessedConfig` sets the new entry under the same ids. When the new entry
+   * starts, the entry reports `starting`, and an error from an earlier run no longer describes it.
+   */
+  beginRebuild(managed, startsAfter) {
+    if (managed.rebuild) {
+      throw new TunnelRebuildInProgressError(managed.tunnelid);
+    }
+    managed.rebuild = { startsAfter };
+    if (startsAfter) {
+      managed.lastError = {};
+    }
+  }
+  /** Stops the instance being replaced, and marks it stopped so no reader calls it again. */
+  async stopForRebuild(managed) {
+    if (managed.isStopped) {
+      return;
+    }
+    await this.stopInstanceGuarded(managed);
+    managed.isStopped = true;
+    managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Ends a failed rebuild. When the old entry is still in the maps, it stays listed as stopped with
+   * the reason. A new entry that failed to start already holds its own error.
+   */
+  failRebuild(managed, error) {
+    managed.rebuild = void 0;
+    if (this.tunnelsByTunnelId.get(managed.tunnelid) !== managed) {
+      return;
+    }
+    managed.isStopped = true;
+    managed.stoppedAt = managed.stoppedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    managed.lastError = {
+      message: errorMessage(error) || START_FAILED_MESSAGE,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      isFatal: true
+    };
+  }
   /**
    * Restarts a tunnel with its current configuration.
    * This function will stop the tunnel if it's running and start it again.
@@ -761,6 +936,7 @@ var TunnelManager = class _TunnelManager {
     if (!existingTunnel) {
       throw new Error(`Tunnel "${tunnelid}" not found`);
     }
+    this.beginRebuild(existingTunnel, true);
     logger.info("Initiating tunnel restart", {
       tunnelId: tunnelid,
       configId: existingTunnel.configId
@@ -772,11 +948,7 @@ var TunnelManager = class _TunnelManager {
       const currentServe = existingTunnel.serve;
       const autoReconnect = existingTunnel.autoReconnect || false;
       const currentOrigin = existingTunnel.origin;
-      if (!existingTunnel.isStopped) {
-        await this.stopInstanceGuarded(existingTunnel);
-      }
-      this.tunnelsByTunnelId.delete(tunnelid);
-      this.tunnelsByConfigId.delete(existingTunnel.configId);
+      await this.stopForRebuild(existingTunnel);
       this.tunnelStats.delete(tunnelid);
       this.tunnelStatsListeners.delete(tunnelid);
       this.tunnelErrorListeners.delete(tunnelid);
@@ -802,6 +974,7 @@ var TunnelManager = class _TunnelManager {
       }
       await this.startTunnel(newTunnel.tunnelid);
     } catch (error) {
+      this.failRebuild(existingTunnel, error);
       logger.error("Failed to restart tunnel", {
         tunnelid,
         error: error instanceof Error ? error.message : "Unknown error"
@@ -859,12 +1032,9 @@ var TunnelManager = class _TunnelManager {
     const currentStartedAt = existingTunnel.startedAt;
     const currentStoppedAt = existingTunnel.stoppedAt;
     const requestedServe = this.resolveServePath(newConfig);
+    this.beginRebuild(existingTunnel, !isStopped);
     try {
-      if (!isStopped) {
-        await this.stopInstanceGuarded(existingTunnel);
-      }
-      this.tunnelsByTunnelId.delete(currentTunnelId);
-      this.tunnelsByConfigId.delete(currentTunnelConfigId);
+      await this.stopForRebuild(existingTunnel);
       const mergedBaseConfig = {
         ...newConfig,
         configId,
@@ -925,6 +1095,7 @@ var TunnelManager = class _TunnelManager {
           error: errorMessage(restoreError)
         });
       }
+      this.failRebuild(existingTunnel, error);
       throw error;
     }
   }
@@ -1738,11 +1909,23 @@ export {
   setTunnelLoggingEnabled,
   isTunnelLoggingEnabled,
   detachAllTunnelLoggers,
+  TunnelStateType,
+  TunnelErrorCodeType,
+  TunnelWarningCode,
+  ErrorCode,
+  isErrorResponse,
+  newErrorResponse,
+  NewResponseObject,
+  NewErrorResponseObject,
+  newStatus,
+  newStats,
+  RemoteManagementStatus,
   getRandomId,
   isValidPort,
   errorMessage,
   getVersion,
   getLocalAddress,
   TunnelAlreadyRunningError,
+  TunnelRebuildInProgressError,
   TunnelManager
 };