wispjs 3.0.0 → 3.1.0

package/dist/wisp_socket/index.js

@@ -220,8 +220,13 @@ export class WispSocket {
                 const logger = worker.logger;
                 logger.log("Running setupConsoleListener");
                 return new Promise((resolve) => {
-                    worker.socket.on("console output", (line) => {
+                    const cleanup = () => {
+                        worker.socket.off("console output", handleLine);
+                        worker.socket.off("disconnect", handleDisconnect);
+                    };
+                    const handleLine = (line) => {
                         if (this.consoleCallbacks.length == 0) {
+                            cleanup();
                             return resolve();
                         }
                         this.consoleCallbacks.forEach((callback) => {
@@ -232,7 +237,16 @@ export class WispSocket {
                                 logger.error("Failed to run console callback", e);
                             }
                         });
-                    });
+                    };
+                    const handleDisconnect = () => {
+                        cleanup();
+                        resolve();
+                        if (this.consoleCallbacks.length > 0) {
+                            this.setupConsoleListener();
+                        }
+                    };
+                    worker.socket.on("console output", handleLine);
+                    worker.socket.once("disconnect", handleDisconnect);
                 });
             });
         });

package/dist/wisp_socket/pool.d.ts

@@ -266,10 +266,13 @@ declare class PoolWorker {
     private intentionalDisconnect;
     private reconnectAttempts;
     private readonly maxReconnectAttempts;
+    private reauthTimer?;
     constructor(pool: WebsocketPool);
     private createSocket;
     private start;
     connect(): Promise<void>;
+    private scheduleReauth;
+    private reauth;
     private handleDisconnect;
     disconnect(): Promise<void>;
     private processWork;

package/dist/wisp_socket/pool.js

@@ -1,5 +1,10 @@
 import { WispWebSocket } from "./ws_adapter.js";
 const WISP_DEBUG = process.env.WISP_DEBUG === "true";
+const REAUTH_INTERVAL = (() => {
+    const parsed = process.env.WISP_REAUTH_INTERVAL ? parseInt(process.env.WISP_REAUTH_INTERVAL) : NaN;
+    return Number.isFinite(parsed) ? parsed : 9 * 60 * 1000;
+})();
+const REAUTH_TIMEOUT = 10000;
 /**
  * A single Worker within a {@link WebsocketPool}
  *
@@ -78,16 +83,59 @@ class PoolWorker {
                 this.reconnectAttempts = 0;
                 this.connected = true;
                 clearTimeout(timeout);
+                this.scheduleReauth();
                 resolve();
             });
             socket.connect();
         });
     }
+    // Resets the re-auth clock. Runs on every successful auth.
+    scheduleReauth() {
+        clearTimeout(this.reauthTimer);
+        this.reauthTimer = setTimeout(() => this.reauth(), REAUTH_INTERVAL);
+    }
+    // Re-auths the live socket with a fresh token. A failed re-auth is treated
+    // as a dead connection and handed to the reconnect path.
+    async reauth() {
+        if (!this.connected || this.intentionalDisconnect || this.done) {
+            return;
+        }
+        if (this.pool.refreshDetails) {
+            try {
+                const details = await this.pool.refreshDetails();
+                this.url = details.url;
+                this.token = details.token;
+            }
+            catch (e) {
+                this.logger.error("Re-auth: failed to refresh details", e);
+                return this.handleDisconnect("reauth refresh failure");
+            }
+        }
+        const socket = this.socket;
+        const ok = await new Promise((resolve) => {
+            const onSuccess = () => {
+                clearTimeout(timeout);
+                resolve(true);
+            };
+            const timeout = setTimeout(() => {
+                socket.off("auth success", onSuccess);
+                resolve(false);
+            }, REAUTH_TIMEOUT);
+            socket.once("auth success", onSuccess);
+            socket.emit("auth", this.token);
+        });
+        if (!ok) {
+            this.logger.error("Re-auth: no auth success in time");
+            return this.handleDisconnect("reauth failure");
+        }
+        this.scheduleReauth();
+    }
     // Recovers from an unexpected disconnect by reconnecting with a freshly
     // fetched token (the JWT is short-lived). After maxReconnectAttempts the
     // worker is marked dead so the pool stops handing it work.
     async handleDisconnect(reason) {
         this.connected = false;
+        clearTimeout(this.reauthTimer);
         if (this.intentionalDisconnect || this.done) {
             return;
         }
@@ -119,6 +167,7 @@ class PoolWorker {
     disconnect() {
         this.intentionalDisconnect = true;
         this.connected = false;
+        clearTimeout(this.reauthTimer);
         return new Promise((resolve) => {
             const timeout = setTimeout(() => {
                 this.logger.error("Socket didn't disconnect in time");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispjs",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "description": "A package for interacting with Wisp-based server panels",
   "main": "dist/wisp.js",