pinggy 0.1.8 → 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);
@@ -1040,11 +1059,11 @@ var TunnelManager = class _TunnelManager {
     if (Array.isArray(managed.additionalForwarding) && managed.additionalForwarding.length > 0) {
       for (const f of managed.additionalForwarding) {
         try {
-          if (!f || typeof f.remotePort !== "number" || !f.localDomain || typeof f.localPort !== "number") {
+          if (!f || typeof f.remoteDomain !== "string" || !f.localDomain || typeof f.localPort !== "number") {
             logger.warn(`Skipping invalid additional forwarding rule: ${JSON.stringify(f)}`);
             continue;
           }
-          const hostname = f.remoteDomain && f.remoteDomain.length > 0 ? `${f.remoteDomain}:${f.remotePort}` : `${f.remotePort}`;
+          const hostname = f.remoteDomain;
           const target = `${f.localDomain}:${f.localPort}`;
           await managed.instance.tunnelRequestAdditionalForwarding(hostname, target);
           logger.info("Applied additional forwarding", { tunnelId, hostname, target });
@@ -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) {
@@ -1125,7 +1160,9 @@ var TunnelManager = class _TunnelManager {
           configid: tunnel.configid,
           tunnelName: tunnel.tunnelName,
           tunnelConfig: tunnel.tunnelConfig,
-          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : []
+          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : [],
+          additionalForwarding: tunnel.additionalForwarding,
+          serve: tunnel.serve
         };
       }));
       return tunnelList;
@@ -1167,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
@@ -1241,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", {
@@ -1279,36 +1373,41 @@ var TunnelManager = class _TunnelManager {
     if (!existingTunnel) {
       throw new Error(`Tunnel with config id "${configid}" not found`);
     }
-    const wasRunning = await existingTunnel.instance.getStatus() === "live";
+    const isStopped = existingTunnel.isStopped;
     const currentTunnelConfig = existingTunnel.tunnelConfig;
     const currentTunnelId = existingTunnel.tunnelid;
     const currentTunnelConfigId = existingTunnel.configid;
     const currentAdditionalForwarding = existingTunnel.additionalForwarding;
     const currentTunnelName = existingTunnel.tunnelName;
+    const currentServe = existingTunnel.serve;
     try {
-      if (wasRunning) {
+      if (!isStopped) {
         existingTunnel.instance.stop();
       }
       this.tunnelsByTunnelId.delete(currentTunnelId);
       this.tunnelsByConfigId.delete(currentTunnelConfigId);
       const mergedConfig = {
-        ...currentTunnelConfig,
         ...newConfig,
         configid,
         tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
+        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
+        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
       };
       const newTunnel = await this.createTunnel(mergedConfig);
-      if (wasRunning) {
+      if (!isStopped) {
         this.startTunnel(newTunnel.tunnelid);
       }
       logger.info("Tunnel configuration updated", {
         tunnelId: newTunnel.tunnelid,
         configId: newTunnel.configid,
-        wasRunning
+        isStopped
       });
       return newTunnel;
     } catch (error) {
+      logger.error("Error updating tunnel configuration", {
+        configId: configid,
+        error: error instanceof Error ? error.message : String(error)
+      });
       try {
         const originalTunnel = await this.createTunnel({
           ...currentTunnelConfig,
@@ -1317,7 +1416,7 @@ var TunnelManager = class _TunnelManager {
           tunnelName: currentTunnelName,
           additionalForwarding: currentAdditionalForwarding
         });
-        if (wasRunning) {
+        if (!isStopped) {
           await this.startTunnel(originalTunnel.tunnelid);
         }
         logger.warn("Restored original tunnel configuration after update failure", {
@@ -1358,7 +1457,6 @@ var TunnelManager = class _TunnelManager {
     }
     try {
       if (managed.isStopped) {
-        logger.debug(`Tunnel "${tunnelId}" is stopped. No greet message available.`);
         return null;
       }
       const messages = await managed.instance.getGreetMessage();
@@ -1381,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);
@@ -1401,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);
@@ -1444,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.
    * 
@@ -1506,7 +1631,6 @@ var TunnelManager = class _TunnelManager {
     }
     try {
       if (managed.isStopped) {
-        logger.debug(`Tunnel "${tunnelId}" is stopped. Cannot fetch local server TLS info`);
         return false;
       }
       const tlsInfo = await managed.instance.getLocalServerTls();
@@ -1551,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);
@@ -1569,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) {
@@ -1628,7 +1768,7 @@ var TunnelManager = class _TunnelManager {
       if (tunnelListeners) {
         for (const [listenerId, listener] of tunnelListeners) {
           try {
-            listener(tunnelId, updatedStats);
+            listener(tunnelId, normalizedStats);
           } catch (error) {
             logger.warn("Error in stats listener callback", { listenerId, tunnelId, error });
           }
@@ -1667,7 +1807,9 @@ var TunnelManager = class _TunnelManager {
   }
   startStaticFileServer(managed) {
     try {
-      const fileServerWorkerPath = import_node_path.default.resolve(__dirname, "../workers/file_serve_worker.js");
+      const __filename3 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+      const __dirname2 = import_node_path.default.dirname(__filename3);
+      const fileServerWorkerPath = import_node_path.default.join(__dirname2, "workers", "file_serve_worker.js");
       const staticServerWorker = new import_node_worker_threads.Worker(fileServerWorkerPath, {
         workerData: {
           dir: managed.serve,
@@ -1731,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" },
@@ -1805,7 +1948,8 @@ var defaultOptions = {
   httpsOnly: false,
   originalRequestUrl: false,
   allowPreflight: false,
-  reverseProxy: false
+  reverseProxy: false,
+  autoReconnect: false
 };
 
 // src/cli/extendedOptions.ts
@@ -2228,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);
@@ -2312,17 +2457,18 @@ function newStatus(tunnelState, errorCode, errorMsg) {
   if (tunnelState === "live" /* Live */) {
     assignedState = "running" /* Running */;
   } else if (tunnelState === "idle" /* New */) {
-    assignedState = "starting" /* Starting */;
+    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: /* @__PURE__ */ new Date(),
-    starttimestamp: /* @__PURE__ */ new Date(),
-    endtimestamp: /* @__PURE__ */ new Date(),
+    createdtimestamp: now,
+    starttimestamp: now,
+    endtimestamp: now,
     warnings: []
   };
 }
@@ -2336,6 +2482,14 @@ function newStats() {
     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();
@@ -2349,8 +2503,16 @@ var HeaderModificationSchema = import_zod.z.object({
   value: import_zod.z.array(import_zod.z.string()).optional(),
   type: import_zod.z.enum(["add", "remove", "update"])
 });
+var AdditionalForwardingSchema = import_zod.z.object({
+  remoteDomain: import_zod.z.string().optional(),
+  localDomain: import_zod.z.string(),
+  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(),
@@ -2374,10 +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()
-});
+  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
@@ -2407,32 +2589,36 @@ function tunnelConfigToPinggyOptions(config) {
     allowPreflight: config.allowPreflight,
     reverseProxy: config.noReverseProxy,
     force: config.force,
+    autoReconnect: config.autoreconnect,
     optional: {
       sniServerName: config.localservertlssni || ""
     }
   };
 }
-function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg) {
+function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg, additionalForwarding, serve) {
   const forwarding = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
+  const parsedForwardedHost = forwarding.split(":").length == 3 ? forwarding.split(":")[1] : forwarding.split(":")[0];
+  const parsedLocalPort = forwarding.split(":").length == 3 ? parseInt(forwarding.split(":")[2], 10) : parseInt(forwarding.split(":")[1], 10);
   const tunnelType = Array.isArray(opts.tunnelType) ? opts.tunnelType[0] : opts.tunnelType ?? "http";
   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,
     configname: configName,
     greetmsg: greetMsg || "",
     force: opts.force ?? false,
-    forwardedhost: forwarding?.split(":")[1] || "localhost",
+    forwardedhost: parsedForwardedHost || "localhost",
     fullRequestUrl: opts.originalRequestUrl ?? false,
     headermodification: opts.headerModification || [],
     //structured list
     httpsOnly: opts.httpsOnly ?? false,
     internalwebdebuggerport: 0,
     ipwhitelist: opts.ipWhitelist ? Array.isArray(opts.ipWhitelist) ? opts.ipWhitelist : JSON.parse(opts.ipWhitelist) : null,
-    localport: parseInt(forwarding?.split(":")[2] || "0", 10),
+    localport: parsedLocalPort || 0,
     localservertlssni: null,
     regioncode: "",
     noReverseProxy: opts.reverseProxy ?? false,
@@ -2444,7 +2630,9 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
     type: tunnelType,
     webdebuggerport: Number(opts.webDebugger?.split(":")[0]) || 0,
     xff: opts.xForwardedFor ? "1" : "",
-    localsservertls: localserverTls || false
+    localsservertls: localserverTls || false,
+    additionalForwarding: additionalForwarding || [],
+    serve: serve || ""
   };
 }
 
@@ -2453,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) {
+  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)
@@ -2465,8 +2666,8 @@ var TunnelOperations = class {
     return {
       tunnelid,
       remoteurls,
-      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg),
-      status: newStatus(status, "" /* NoError */, ""),
+      tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg, additionalForwarding),
+      status: this.buildStatus(tunnelid, status, "" /* NoError */),
       stats
     };
   }
@@ -2480,14 +2681,17 @@ var TunnelOperations = class {
   async handleStart(config) {
     try {
       const opts = tunnelConfigToPinggyOptions(config);
-      const { tunnelid, instance, tunnelName } = await this.tunnelManager.createTunnel({
+      const additionalForwardingParsed = config.additionalForwarding || [];
+      const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
         ...opts,
         configid: config.configid,
-        tunnelName: config.configname
+        tunnelName: config.configname,
+        additionalForwarding: additionalForwardingParsed,
+        serve: config.serve
       });
       this.tunnelManager.startTunnel(tunnelid);
       const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName);
+      const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, additionalForwarding, serve);
       return resp;
     } catch (err) {
       return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
@@ -2499,11 +2703,13 @@ var TunnelOperations = class {
       const tunnel = await this.tunnelManager.updateConfig({
         ...opts,
         configid: config.configid,
-        tunnelName: config.configname
+        tunnelName: config.configname,
+        additionalForwarding: config.additionalForwarding || [],
+        serve: config.serve
       });
       if (!tunnel.instance || !tunnel.tunnelConfig)
         throw new Error("Invalid tunnel state after configuration update");
-      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName);
+      return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName, tunnel.additionalForwarding, tunnel.serve);
     } catch (err) {
       return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
     }
@@ -2516,19 +2722,19 @@ 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),
             this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
           ]);
-          const tunnelConfig = pinggyOptionsToTunnelConfig(t.tunnelConfig, t.configid, t.tunnelName, tlsInfo, greetMsg);
+          const pinggyOptions = status !== "closed" /* Closed */ && status !== "exited" /* Exited */ ? await this.tunnelManager.getTunnelConfig("", t.tunnelid) : t.tunnelConfig;
+          const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
           return {
             tunnelid: t.tunnelid,
             remoteurls: t.remoteurls,
-            status: newStatus(status, "" /* NoError */, ""),
-            stats,
+            status: this.buildStatus(t.tunnelid, status, "" /* NoError */),
+            stats: rawStats,
             tunnelconfig: tunnelConfig
           };
         })
@@ -2542,7 +2748,7 @@ var TunnelOperations = class {
       const { configid } = this.tunnelManager.stopTunnel(tunnelid);
       const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
       if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
     }
@@ -2551,7 +2757,7 @@ var TunnelOperations = class {
     try {
       const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
       if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
     }
@@ -2561,7 +2767,7 @@ var TunnelOperations = class {
       await this.tunnelManager.restartTunnel(tunnelid);
       const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
       if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName);
+      return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName, managed.additionalForwarding, managed.serve);
     } catch (err) {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
     }
@@ -2572,6 +2778,34 @@ var TunnelOperations = class {
   handleUnregisterStatsListener(tunnelid, listnerId) {
     this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
   }
+  handleGetTunnelStats(tunnelid) {
+    try {
+      const stats = this.tunnelManager.getTunnelStats(tunnelid);
+      if (!stats) {
+        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
@@ -2604,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);
   }
@@ -2638,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;
@@ -2711,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://"))) {
@@ -2744,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
@@ -2926,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();
@@ -2981,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");
@@ -3054,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();
@@ -3101,5 +3441,8 @@ if (entryFile && entryFile === currentFile) {
 0 && (module.exports = {
   TunnelManager,
   TunnelOperations,
-  enablePackageLogging
+  closeRemoteManagement,
+  enablePackageLogging,
+  getRemoteManagementState,
+  initiateRemoteManagement
 });