pinggy 0.1.9 → 0.1.10

package/dist/index.cjs

@@ -847,7 +847,10 @@ var index_exports = {};
 __export(index_exports, {
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
-  enablePackageLogging: () => enablePackageLogging
+  closeRemoteManagement: () => closeRemoteManagement,
+  enablePackageLogging: () => enablePackageLogging,
+  getRemoteManagementState: () => getRemoteManagementState,
+  initiateRemoteManagement: () => initiateRemoteManagement
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -971,6 +974,7 @@ var TunnelManager = class _TunnelManager {
     this.tunnelErrorListeners = /* @__PURE__ */ new Map();
     this.tunnelDisconnectListeners = /* @__PURE__ */ new Map();
     this.tunnelWorkerErrorListeners = /* @__PURE__ */ new Map();
+    this.tunnelStartListeners = /* @__PURE__ */ new Map();
   }
   static getInstance() {
     if (!_TunnelManager.instance) {
@@ -1001,7 +1005,15 @@ var TunnelManager = class _TunnelManager {
       throw new Error(`Tunnel with configId "${configid}" already exists`);
     }
     const tunnelid = config.tunnelid || await getUuid();
-    const instance = import_pinggy2.pinggy.createTunnel(config);
+    let instance;
+    try {
+      instance = await import_pinggy2.pinggy.createTunnel(config);
+    } catch (e) {
+      logger.error("Error creating tunnel instance:", e);
+      throw e;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let autoReconnect = config.autoReconnect !== void 0 ? config.autoReconnect : false;
     const managed = {
       tunnelid,
       configid,
@@ -1011,8 +1023,15 @@ var TunnelManager = class _TunnelManager {
       additionalForwarding,
       serve: config.serve,
       warnings: [],
-      isStopped: false
+      isStopped: false,
+      createdAt: now,
+      startedAt: null,
+      stoppedAt: null,
+      autoReconnect
     };
+    instance.setPrimaryForwardingCallback(({}) => {
+      managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
     this.setupStatsCallback(tunnelid, managed);
     this.setupErrorCallback(tunnelid, managed);
     this.setupDisconnectCallback(tunnelid, managed);
@@ -1056,6 +1075,20 @@ var TunnelManager = class _TunnelManager {
     if (managed.serve) {
       this.startStaticFileServer(managed);
     }
+    try {
+      const startListeners = this.tunnelStartListeners.get(tunnelId);
+      if (startListeners) {
+        for (const [id, listener] of startListeners) {
+          try {
+            listener(tunnelId, urls);
+          } catch (err) {
+            logger.debug("Error in start-listener callback", { listenerId: id, tunnelId, err });
+          }
+        }
+      }
+    } catch (e) {
+      logger.warn("Failed to notify start listeners", { tunnelId, e });
+    }
     return urls;
   }
   /**
@@ -1085,9 +1118,11 @@ var TunnelManager = class _TunnelManager {
       this.tunnelErrorListeners.delete(tunnelId);
       this.tunnelDisconnectListeners.delete(tunnelId);
       this.tunnelWorkerErrorListeners.delete(tunnelId);
+      this.tunnelStartListeners.delete(tunnelId);
       managed.serveWorker = null;
       managed.warnings = managed.warnings ?? [];
       managed.isStopped = true;
+      managed.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
       logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
       return { configid: managed.configid, tunnelid: managed.tunnelid };
     } catch (error) {
@@ -1169,6 +1204,60 @@ var TunnelManager = class _TunnelManager {
     this.tunnelStatsListeners.clear();
     logger.info("All tunnels stopped and cleared");
   }
+  /**
+   * Remove a stopped tunnel's records so it will no longer be returned by list methods.
+   * 
+   *
+   * @param tunnelId - the tunnel id to remove
+   * @returns true if the record was removed, false otherwise
+   */
+  removeStoppedTunnelByTunnelId(tunnelId) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      logger.debug("Attempted to remove non-existent tunnel", { tunnelId });
+      return false;
+    }
+    if (!managed.isStopped) {
+      logger.warn("Attempted to remove tunnel that is not stopped", { tunnelId });
+      return false;
+    }
+    this._cleanupTunnelRecords(managed);
+    logger.info("Removed stopped tunnel records", { tunnelId, configId: managed.configid });
+    return true;
+  }
+  /**
+   * Remove a stopped tunnel by its config id.
+   * @param configId - the config id to remove
+   * @returns true if the record was removed, false otherwise
+   */
+  removeStoppedTunnelByConfigId(configId) {
+    const managed = this.tunnelsByConfigId.get(configId);
+    if (!managed) {
+      logger.debug("Attempted to remove non-existent tunnel by configId", { configId });
+      return false;
+    }
+    return this.removeStoppedTunnelByTunnelId(managed.tunnelid);
+  }
+  _cleanupTunnelRecords(managed) {
+    if (!managed.isStopped) {
+      throw new Error(`Active tunnel "${managed.tunnelid}" cannot be removed`);
+    }
+    try {
+      if (managed.serveWorker) {
+        managed.serveWorker = null;
+      }
+      this.tunnelStats.delete(managed.tunnelid);
+      this.tunnelStatsListeners.delete(managed.tunnelid);
+      this.tunnelErrorListeners.delete(managed.tunnelid);
+      this.tunnelDisconnectListeners.delete(managed.tunnelid);
+      this.tunnelWorkerErrorListeners.delete(managed.tunnelid);
+      this.tunnelStartListeners.delete(managed.tunnelid);
+      this.tunnelsByTunnelId.delete(managed.tunnelid);
+      this.tunnelsByConfigId.delete(managed.configid);
+    } catch (e) {
+      logger.warn("Failed cleaning up tunnel records", { tunnelId: managed.tunnelid, error: e });
+    }
+  }
   /**
    * Get tunnel instance by either configId or tunnelId
    * @param configId - The configuration ID of the tunnel
@@ -1243,6 +1332,9 @@ var TunnelManager = class _TunnelManager {
         additionalForwarding,
         tunnelName
       });
+      if (existingTunnel.createdAt) {
+        newTunnel.createdAt = existingTunnel.createdAt;
+      }
       this.startTunnel(newTunnel.tunnelid);
     } catch (error) {
       logger.error("Failed to restart tunnel", {
@@ -1387,13 +1479,26 @@ var TunnelManager = class _TunnelManager {
     const stats = this.tunnelStats.get(tunnelId);
     return stats || null;
   }
+  getLatestTunnelStats(tunnelId) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      return null;
+    }
+    const stats = this.tunnelStats.get(tunnelId);
+    if (stats && stats.length > 0) {
+      return stats[stats.length - 1];
+    }
+    return null;
+  }
   /**
    * Registers a listener function to receive tunnel statistics updates.
    * The listener will be called whenever any tunnel's stats are updated.
    * 
    * @param tunnelId - The tunnel ID to listen to stats for
    * @param listener - Function that receives tunnelId and stats when updates occur
-   * @returns A unique listener ID that can be used to deregister the listener
+   * @returns A unique listener ID that can be used to deregister the listener and tunnelId
+   * 
+   * @throws {Error} When the specified tunnelId does not exist
    */
   async registerStatsListener(tunnelId, listener) {
     const managed = this.tunnelsByTunnelId.get(tunnelId);
@@ -1407,7 +1512,7 @@ var TunnelManager = class _TunnelManager {
     const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
     tunnelListeners.set(listenerId, listener);
     logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
-    return listenerId;
+    return [listenerId, tunnelId];
   }
   async registerErrorListener(tunnelId, listener) {
     const managed = this.tunnelsByTunnelId.get(tunnelId);
@@ -1450,6 +1555,20 @@ var TunnelManager = class _TunnelManager {
     tunnelWorkerErrorListner?.set(listenerId, listener);
     logger.info("TunnelWorker error listener registered for tunnel", { tunnelId, listenerId });
   }
+  async registerStartListener(tunnelId, listener) {
+    const managed = this.tunnelsByTunnelId.get(tunnelId);
+    if (!managed) {
+      throw new Error(`Tunnel "${tunnelId}" not found`);
+    }
+    if (!this.tunnelStartListeners.has(tunnelId)) {
+      this.tunnelStartListeners.set(tunnelId, /* @__PURE__ */ new Map());
+    }
+    const listenerId = await getUuid();
+    const listeners = this.tunnelStartListeners.get(tunnelId);
+    listeners.set(listenerId, listener);
+    logger.info("Start listener registered for tunnel", { tunnelId, listenerId });
+    return listenerId;
+  }
   /**
    * Removes a previously registered stats listener.
    * 
@@ -1556,9 +1675,9 @@ var TunnelManager = class _TunnelManager {
   }
   setupErrorCallback(tunnelId, managed) {
     try {
-      const callback = (errorNo, errorMsg, recoverable) => {
+      const callback = ({ errorNo, error, recoverable }) => {
         try {
-          const msg = typeof errorMsg === "string" ? errorMsg : String(errorMsg);
+          const msg = typeof error === "string" ? error : String(error);
           const isFatal = true;
           logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
           this.notifyErrorListeners(tunnelId, msg, isFatal);
@@ -1574,9 +1693,25 @@ var TunnelManager = class _TunnelManager {
   }
   setupDisconnectCallback(tunnelId, managed) {
     try {
-      const callback = (error, messages) => {
+      const callback = ({ error, messages }) => {
         try {
           logger.debug("Tunnel disconnected", { tunnelId, error, messages });
+          const managedTunnel = this.tunnelsByTunnelId.get(tunnelId);
+          if (managedTunnel) {
+            managedTunnel.isStopped = true;
+            managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          if (managedTunnel && managedTunnel.autoReconnect) {
+            logger.info("Auto-reconnecting tunnel", { tunnelId });
+            setTimeout(async () => {
+              try {
+                await this.restartTunnel(tunnelId);
+                logger.info("Tunnel auto-reconnected successfully", { tunnelId });
+              } catch (e) {
+                logger.error("Failed to auto-reconnect tunnel", { tunnelId, e });
+              }
+            }, 1e4);
+          }
           const listeners = this.tunnelDisconnectListeners.get(tunnelId);
           if (!listeners) return;
           for (const [id, listener] of listeners) {
@@ -1738,6 +1873,7 @@ var cliOptions = {
   v: { type: "boolean", description: "Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable" },
   vv: { type: "boolean", description: "Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs." },
   vvv: { type: "boolean", description: "Enable all logs from Cli, SDK and internal components." },
+  autoreconnect: { type: "boolean", short: "a", description: "Automatically reconnect tunnel on failure." },
   // Save and load config
   saveconf: { type: "string", description: "Create the configuration file based on the options provided here" },
   conf: { type: "string", description: "Use the configuration file as base. Other options will be used to override this file" },
@@ -1812,7 +1948,8 @@ var defaultOptions = {
   httpsOnly: false,
   originalRequestUrl: false,
   allowPreflight: false,
-  reverseProxy: false
+  reverseProxy: false,
+  autoReconnect: false
 };
 
 // src/cli/extendedOptions.ts
@@ -2235,7 +2372,8 @@ async function buildFinalConfig(values, positionals) {
     serverAddress: server || defaultOptions.serverAddress,
     tunnelType: initialTunnel ? [initialTunnel] : defaultOptions.tunnelType,
     NoTUI: values.notui || false,
-    qrCode: qrCode || false
+    qrCode: qrCode || false,
+    autoReconnect: values.autoreconnect || false
   };
   parseType(finalConfig, values, type);
   parseToken(finalConfig, token || values.token);
@@ -2335,15 +2473,23 @@ function newStatus(tunnelState, errorCode, errorMsg) {
   };
 }
 function newStats() {
-  return [{
+  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/remote_management/handler.ts
 init_cjs_shims();
@@ -2363,7 +2509,10 @@ var AdditionalForwardingSchema = import_zod.z.object({
   localPort: import_zod.z.number()
 });
 var TunnelConfigSchema = import_zod.z.object({
-  allowPreflight: import_zod.z.boolean(),
+  allowPreflight: import_zod.z.boolean().optional(),
+  // primary key
+  allowpreflight: import_zod.z.boolean().optional(),
+  // legacy key
   autoreconnect: import_zod.z.boolean(),
   basicauth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).nullable(),
   bearerauth: import_zod.z.string().nullable(),
@@ -2387,12 +2536,30 @@ var TunnelConfigSchema = import_zod.z.object({
   statusCheckInterval: import_zod.z.number(),
   token: import_zod.z.string(),
   tunnelTimeout: import_zod.z.number(),
-  type: import_zod.z.enum([import_pinggy5.TunnelType.Http, import_pinggy5.TunnelType.Tcp, import_pinggy5.TunnelType.Udp, import_pinggy5.TunnelType.Tls, import_pinggy5.TunnelType.TlsTcp]),
+  type: import_zod.z.enum([
+    import_pinggy5.TunnelType.Http,
+    import_pinggy5.TunnelType.Tcp,
+    import_pinggy5.TunnelType.Udp,
+    import_pinggy5.TunnelType.Tls,
+    import_pinggy5.TunnelType.TlsTcp
+  ]),
   webdebuggerport: import_zod.z.number(),
   xff: import_zod.z.string(),
   additionalForwarding: import_zod.z.array(AdditionalForwardingSchema).optional(),
   serve: import_zod.z.string().optional()
-});
+}).superRefine((data, ctx) => {
+  if (data.allowPreflight === void 0 && data.allowpreflight === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Either allowPreflight or allowpreflight is required",
+      path: ["allowPreflight"]
+    });
+  }
+}).transform((data) => ({
+  ...data,
+  allowPreflight: data.allowPreflight ?? data.allowpreflight,
+  allowpreflight: data.allowPreflight ?? data.allowpreflight
+}));
 var StartSchema = import_zod.z.object({
   tunnelID: import_zod.z.string().uuid().nullable().optional(),
   tunnelConfig: TunnelConfigSchema
@@ -2422,6 +2589,7 @@ function tunnelConfigToPinggyOptions(config) {
     allowPreflight: config.allowPreflight,
     reverseProxy: config.noReverseProxy,
     force: config.force,
+    autoReconnect: config.autoreconnect,
     optional: {
       sniServerName: config.localservertlssni || ""
     }
@@ -2435,7 +2603,8 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
   const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
   return {
     allowPreflight: opts.allowPreflight ?? false,
-    autoreconnect: true,
+    allowpreflight: opts.allowPreflight ?? false,
+    autoreconnect: opts.autoReconnect ?? false,
     basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : null,
     bearerauth: parsedTokens.length ? parsedTokens.join(",") : null,
     configid,
@@ -2472,11 +2641,24 @@ var TunnelOperations = class {
   constructor() {
     this.tunnelManager = TunnelManager.getInstance();
   }
+  buildStatus(tunnelId, state, errorCode) {
+    const status = newStatus(state, errorCode, "");
+    try {
+      const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
+      if (managed) {
+        status.createdtimestamp = managed.createdAt || "";
+        status.starttimestamp = managed.startedAt || "";
+        status.endtimestamp = managed.stoppedAt || "";
+      }
+    } catch (e) {
+    }
+    return status;
+  }
   // --- Helper to construct TunnelResponse ---
   async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, additionalForwarding, serve) {
     const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
       this.tunnelManager.getTunnelStatus(tunnelid),
-      this.tunnelManager.getTunnelStats(tunnelid),
+      this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
       this.tunnelManager.getLocalserverTlsInfo(tunnelid),
       this.tunnelManager.getTunnelGreetMessage(tunnelid),
       this.tunnelManager.getTunnelUrls(tunnelid)
@@ -2485,7 +2667,7 @@ var TunnelOperations = class {
       tunnelid,
       remoteurls,
       tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
-      status: newStatus(status, "" /* NoError */, ""),
+      status: this.buildStatus(tunnelid, status, "" /* NoError */),
       stats
     };
   }
@@ -2540,8 +2722,7 @@ var TunnelOperations = class {
       }
       return Promise.all(
         tunnels.map(async (t) => {
-          const rawStats = this.tunnelManager.getTunnelStats(t.tunnelid);
-          const stats = rawStats ?? newStats();
+          const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
           const [status, tlsInfo, greetMsg] = await Promise.all([
             this.tunnelManager.getTunnelStatus(t.tunnelid),
             this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
@@ -2552,8 +2733,8 @@ var TunnelOperations = class {
           return {
             tunnelid: t.tunnelid,
             remoteurls: t.remoteurls,
-            status: newStatus(status, "" /* NoError */, ""),
-            stats,
+            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
+            stats: rawStats,
             tunnelconfig: tunnelConfig
           };
         })
@@ -2601,13 +2782,30 @@ var TunnelOperations = class {
     try {
       const stats = this.tunnelManager.getTunnelStats(tunnelid);
       if (!stats) {
-        return newStats();
+        return [newStats()];
       }
       return stats;
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel stats");
     }
   }
+  handleRegisterDisconnectListener(tunnelid, listener) {
+    this.tunnelManager.registerDisconnectListener(tunnelid, listener);
+  }
+  handleRemoveStoppedTunnelByConfigId(configId) {
+    try {
+      return this.tunnelManager.removeStoppedTunnelByConfigId(configId);
+    } catch (err) {
+      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by configId");
+    }
+  }
+  handleRemoveStoppedTunnelByTunnelId(tunnelId) {
+    try {
+      return this.tunnelManager.removeStoppedTunnelByTunnelId(tunnelId);
+    } catch (err) {
+      return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by tunnelId");
+    }
+  }
 };
 
 // src/remote_management/websocket_handlers.ts
@@ -2640,11 +2838,13 @@ var WebSocketCommandHandler = class {
   }
   async handleStartReq(req, raw) {
     const dc = StartSchema.parse(raw);
+    printer_default.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
     const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
     return this.wrapResponse(result, req);
   }
   async handleStopReq(req, raw) {
     const dc = StopSchema.parse(raw);
+    printer_default.info("Stopping tunnel with ID: " + dc.tunnelID);
     const result = await this.tunnelHandler.handleStop(dc.tunnelID);
     return this.wrapResponse(result, req);
   }
@@ -2674,7 +2874,17 @@ var WebSocketCommandHandler = class {
       errResp.requestid = req.requestid;
       return errResp;
     }
-    const respObj = NewResponseObject(result);
+    const finalResult = JSON.parse(JSON.stringify(result));
+    if (Array.isArray(finalResult)) {
+      finalResult.forEach((item) => {
+        if (item?.tunnelconfig) {
+          delete item.tunnelconfig.allowPreflight;
+        }
+      });
+    } else if (finalResult?.tunnelconfig) {
+      delete finalResult.tunnelconfig.allowPreflight;
+    }
+    const respObj = NewResponseObject(finalResult);
     respObj.command = req.command;
     respObj.requestid = req.requestid;
     return respObj;
@@ -2747,6 +2957,12 @@ function handleConnectionStatusMessage(firstMessage) {
 // src/remote_management/remoteManagement.ts
 var RECONNECT_SLEEP_MS = 5e3;
 var PING_INTERVAL_MS = 3e4;
+var _remoteManagementState = {
+  status: "NOT_RUNNING",
+  errorMessage: ""
+};
+var _stopRequested = false;
+var currentWs = null;
 function buildRemoteManagementWsUrl(manage) {
   let baseUrl = (manage || "dashboard.pinggy.io").trim();
   if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
@@ -2780,95 +2996,133 @@ async function parseRemoteManagement(values) {
   }
 }
 async function initiateRemoteManagement(token, manage) {
+  await printer_default.ensureDeps();
+  await loadChalk();
   if (!token || token.trim().length === 0) {
     throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
   }
   const wsUrl = buildRemoteManagementWsUrl(manage);
   const wsHost = extractHostname(wsUrl);
   logger.info("Remote management mode enabled.");
-  let stopRequested = false;
+  _stopRequested = false;
   const sigintHandler = () => {
-    stopRequested = true;
+    _stopRequested = true;
   };
   process.once("SIGINT", sigintHandler);
-  let firstTry = true;
-  while (!stopRequested) {
-    if (firstTry) {
-      firstTry = false;
-      printer_default.print(`Connecting to ${wsHost}`);
-      logger.info("Connecting to remote management", { wsUrl });
-    } else {
-      printer_default.warn(`Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds.`);
-      logger.info("Reconnecting after sleep", { seconds: RECONNECT_SLEEP_MS / 1e3 });
-      await sleep(RECONNECT_SLEEP_MS);
-      if (stopRequested) break;
-      printer_default.print(`Connecting to ${wsHost}`);
-      logger.info("Connecting to remote management", { wsUrl });
+  const logConnecting = () => {
+    printer_default.print(`Connecting to ${wsHost}`);
+    logger.info("Connecting to remote management", { wsUrl });
+  };
+  while (!_stopRequested) {
+    logConnecting();
+    setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
+    try {
+      await handleWebSocketConnection(wsUrl, wsHost, token);
+    } catch (error) {
+      logger.warn("Remote management connection error", { error: String(error) });
     }
+    if (_stopRequested) break;
+    printer_default.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds...`);
+    logger.info("Reconnecting to remote management after disconnect");
+    await sleep(RECONNECT_SLEEP_MS);
+  }
+  process.removeListener("SIGINT", sigintHandler);
+  logger.info("Remote management stopped.");
+  return getRemoteManagementState();
+}
+async function handleWebSocketConnection(wsUrl, wsHost, token) {
+  return new Promise((resolve) => {
     const ws = new import_ws.default(wsUrl, {
       headers: { Authorization: `Bearer ${token}` }
     });
-    await new Promise((resolve) => {
-      let heartbeat;
-      const startHeartbeat = () => {
-        heartbeat = setInterval(() => {
-          if (ws.readyState !== import_ws.default.OPEN) return;
-          ws.ping();
-        }, PING_INTERVAL_MS);
-      };
-      ws.on("open", () => {
-        printer_default.success(`Connected to ${wsHost}`);
-        startHeartbeat();
-      });
-      ws.on("ping", () => ws.pong());
-      let firstMessage = true;
-      ws.on("message", async (data) => {
-        try {
-          if (firstMessage) {
-            firstMessage = false;
-            const ok = handleConnectionStatusMessage(data);
-            if (!ok) {
-              ws.close();
-            }
-            return;
-          }
-          const text = data.toString("utf8");
-          const req = JSON.parse(text);
-          const webSocketHandler = new WebSocketCommandHandler();
-          await webSocketHandler.handle(ws, req);
-        } catch (e) {
-          logger.warn("Failed handling websocket message", { error: String(e) });
-        }
-      });
-      ws.on("unexpected-response", (_req, res) => {
-        if (res.statusCode === 401) {
-          printer_default.error("Unauthorized. Please enter a valid token.");
-          logger.error("Unauthorized (401) on remote management connect");
-          stopRequested = true;
-          ws.close();
-        } else {
-          printer_default.warn(`Unexpected HTTP response ${res.statusCode} from server. Retrying...`);
-          logger.warn("Unexpected HTTP response on WebSocket connect", { statusCode: res.statusCode });
-          ws.close();
+    currentWs = ws;
+    let heartbeat = null;
+    let firstMessage = true;
+    const cleanup = () => {
+      if (heartbeat) clearInterval(heartbeat);
+      currentWs = null;
+      resolve();
+    };
+    ws.once("open", () => {
+      printer_default.success(`Connected to ${wsHost}`);
+      heartbeat = setInterval(() => {
+        if (ws.readyState === import_ws.default.OPEN) ws.ping();
+      }, PING_INTERVAL_MS);
+    });
+    ws.on("ping", () => ws.pong());
+    ws.on("message", async (data) => {
+      try {
+        if (firstMessage) {
+          firstMessage = false;
+          const ok = handleConnectionStatusMessage(data);
+          if (!ok) ws.close();
+          return;
         }
-      });
-      ws.on("close", (code, reason) => {
-        logger.info("WebSocket closed", { code, reason: reason.toString() });
-        printer_default.warn(`Disconnected from remote management (code: ${code}).Retrying...`);
-        clearInterval(heartbeat);
-        resolve();
-      });
-      ws.on("error", (err) => {
-        printer_default.error(err);
-        logger.warn("WebSocket error", { error: err.message });
-        clearInterval(heartbeat);
-        resolve();
-      });
+        setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
+        const req = JSON.parse(data.toString("utf8"));
+        await new WebSocketCommandHandler().handle(ws, req);
+      } catch (e) {
+        logger.warn("Failed handling websocket message", { error: String(e) });
+      }
+    });
+    ws.on("unexpected-response", (_, res) => {
+      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
+      if (res.statusCode === 401) {
+        printer_default.error("Unauthorized. Please enter a valid token.");
+        logger.error("Unauthorized (401) on remote management connect");
+      } else {
+        printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
+        logger.warn("Unexpected HTTP response", { statusCode: res.statusCode });
+      }
+      ws.close();
+    });
+    ws.on("close", (code, reason) => {
+      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
+      logger.info("WebSocket closed", { code, reason: reason.toString() });
+      printer_default.warn(`Disconnected (code: ${code}). Retrying...`);
+      cleanup();
+    });
+    ws.on("error", (err) => {
+      setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
+      logger.warn("WebSocket error", { error: err.message });
+      printer_default.error(err);
+      cleanup();
     });
-    if (stopRequested) break;
+  });
+}
+async function closeRemoteManagement(timeoutMs = 1e4) {
+  _stopRequested = true;
+  try {
+    if (currentWs) {
+      try {
+        setRemoteManagementState({ status: RemoteManagementStatus.Disconnecting, errorMessage: "" });
+        currentWs.close();
+      } catch (e) {
+        logger.warn("Error while closing current remote management websocket", { error: String(e) });
+      }
+    }
+    const start = Date.now();
+    while (_remoteManagementState.status === "RUNNING") {
+      if (Date.now() - start > timeoutMs) {
+        logger.warn("Timed out waiting for remote management to stop");
+        break;
+      }
+      await sleep(200);
+    }
+  } finally {
+    currentWs = null;
+    setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
+    return getRemoteManagementState();
   }
-  process.removeListener("SIGINT", sigintHandler);
-  logger.info("Remote management stopped.");
+}
+function getRemoteManagementState() {
+  return _remoteManagementState;
+}
+function setRemoteManagementState(state, errorMessage) {
+  _remoteManagementState = {
+    status: state.status,
+    errorMessage: errorMessage || ""
+  };
 }
 
 // src/utils/parseArgs.ts
@@ -2962,6 +3216,57 @@ var TunnelData = {
 var activeTui = null;
 var disconnectState = null;
 var updateDisconnectState = null;
+async function launchTui(finalConfig, urls, greet) {
+  try {
+    const { withFullScreen } = await import("fullscreen-ink");
+    const { default: TunnelTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+    const React3 = await import("react");
+    const isTTYEnabled = process.stdin.isTTY;
+    const TunnelTuiWrapper = ({ finalConfig: finalConfig2, urls: urls2, greet: greet2 }) => {
+      const [disconnectInfo, setDisconnectInfo] = React3.useState(null);
+      React3.useEffect(() => {
+        updateDisconnectState = setDisconnectInfo;
+        return () => {
+          updateDisconnectState = null;
+        };
+      }, []);
+      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        TunnelTui2,
+        {
+          urls: urls2 ?? [],
+          greet: greet2 ?? "",
+          tunnelConfig: finalConfig2,
+          disconnectInfo
+        }
+      );
+    };
+    const tui = withFullScreen(
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+        TunnelTuiWrapper,
+        {
+          finalConfig,
+          urls,
+          greet
+        }
+      )
+    );
+    activeTui = tui;
+    if (isTTYEnabled) {
+      try {
+        await tui.start();
+        await tui.waitUntilExit();
+      } catch (e) {
+        logger.warn("TUI error", e);
+      } finally {
+        activeTui = null;
+      }
+    } else {
+      printer_default.warn("Unable to initiate the TUI: your terminal does not support the required input mode.");
+    }
+  } catch (e) {
+    logger.warn("Failed to (re-)initiate TUI", e);
+  }
+}
 async function startCli(finalConfig, manager) {
   await printer_default.ensureDeps();
   const chalk = await loadChalk();
@@ -3017,64 +3322,61 @@ async function startCli(finalConfig, manager) {
           logger.warn("Failed to wait for TUI exit", e);
         } finally {
           activeTui = null;
-          messages.forEach(function(m) {
+          printer_default.warn(`Error in tunnel:`);
+          messages?.forEach(function(m) {
             printer_default.warn(m);
           });
-          process.exit(0);
+          if (!finalConfig.autoReconnect) {
+            process.exit(0);
+          }
         }
       } else {
-        messages.forEach(function(m) {
+        messages?.forEach(function(m) {
           printer_default.warn(m);
         });
-        process.exit(0);
+        if (!finalConfig.autoReconnect) {
+          process.exit(0);
+        }
+      }
+      if (finalConfig.autoReconnect) {
+        printer_default.startSpinner("Reconnecting to Pinggy");
       }
     });
-    if (!finalConfig.NoTUI) {
-      const { withFullScreen } = await import("fullscreen-ink");
-      const { default: TunnelTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
-      const React3 = await import("react");
-      const isTTYEnabled = process.stdin.isTTY;
-      const TunnelTuiWrapper = ({ finalConfig: finalConfig2, urls, greet }) => {
-        const [disconnectInfo, setDisconnectInfo] = React3.useState(null);
-        React3.useEffect(() => {
-          updateDisconnectState = setDisconnectInfo;
-          return () => {
-            updateDisconnectState = null;
-          };
-        }, []);
-        return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
-          TunnelTui2,
-          {
-            urls: urls ?? [],
-            greet: greet ?? "",
-            tunnelConfig: finalConfig2,
-            disconnectInfo
-          }
-        );
-      };
-      const tui = withFullScreen(
-        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
-          TunnelTuiWrapper,
-          {
-            finalConfig,
-            urls: TunnelData.urls,
-            greet: TunnelData.greet
-          }
-        )
-      );
-      activeTui = tui;
-      if (isTTYEnabled) {
+    try {
+      await manager2.registerStartListener(tunnel.tunnelid, async (tunnelId, urls) => {
         try {
-          await tui.start();
-          await tui.waitUntilExit();
+          printer_default.stopSpinnerSuccess("Reconnected to Pinggy");
         } catch (e) {
-          logger.warn("TUI error", e);
-        } finally {
-          activeTui = null;
         }
-      } else {
-        printer_default.warn("Unable to initiate the TUI: your terminal does not support the required input mode.");
-      }
+        printer_default.success(chalk.bold("Tunnel re-established!"));
+        printer_default.print(chalk.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        TunnelData.urls = urls;
+        TunnelData.greet = await manager2.getTunnelGreetMessage(tunnel.tunnelid);
+        printer_default.info(chalk.cyanBright("Remote URLs:"));
+        (TunnelData.urls ?? []).forEach(
+          (url) => printer_default.print("  " + chalk.magentaBright(url))
+        );
+        printer_default.print(chalk.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        if (TunnelData.greet?.includes("not authenticated")) {
+          printer_default.warn(chalk.yellowBright(TunnelData.greet));
+        } else if (TunnelData.greet?.includes("authenticated as")) {
+          const emailMatch = /authenticated as (.+)/.exec(TunnelData.greet);
+          if (emailMatch) {
+            const email = emailMatch[1];
+            printer_default.info(chalk.cyanBright("Authenticated as: " + email));
+          }
+        }
+        printer_default.print(chalk.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        printer_default.print(chalk.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+        if (!finalConfig.NoTUI) {
+          await launchTui(finalConfig, TunnelData.urls, TunnelData.greet);
+        }
+      });
+    } catch (e) {
+      logger.debug("Failed to register start listener", e);
+    }
+    if (!finalConfig.NoTUI) {
+      await launchTui(finalConfig, TunnelData.urls, TunnelData.greet);
     }
   } catch (err) {
     printer_default.stopSpinnerFail("Failed to connect");
@@ -3090,6 +3392,8 @@ var import_fs3 = require("fs");
 init_logger();
 async function main() {
   try {
+    await printer_default.ensureDeps();
+    await loadChalk();
     const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
     configureLogger(values);
     const manager = TunnelManager.getInstance();
@@ -3137,5 +3441,8 @@ if (entryFile && entryFile === currentFile) {
 0 && (module.exports = {
   TunnelManager,
   TunnelOperations,
-  enablePackageLogging
+  closeRemoteManagement,
+  enablePackageLogging,
+  getRemoteManagementState,
+  initiateRemoteManagement
 });