@butlerbot/sdk 0.0.24 → 0.0.25

package/dist/link/link.d.ts

@@ -88,6 +88,8 @@ export declare class Link {
     private readonly pending;
     private readonly calls;
     private socket;
+    /** Every socket this link has opened and not yet closed, by generation. */
+    private readonly sockets;
     private frameCounter;
     private currentState;
     private identity?;
@@ -162,6 +164,15 @@ export declare class Link {
      * means the real event, whenever it turns up, is ignored.
      */
     private dropSocket;
+    /**
+     * Closes a socket this end has stopped using, whatever generation it belongs to.
+     *
+     * Every path that walks away from a socket goes through here. Forgetting one is not harmless:
+     * the server has no way to tell an abandoned connection from a live one — it has said hello,
+     * registered its tools and claimed its link id — so it keeps it, keeps serving from it, and
+     * hands the link id back and forth between it and its replacements.
+     */
+    private abandon;
     private onClose;
     /** Retries when it is allowed to, and tells everyone waiting when it is not. */
     private retryOrGiveUp;

package/dist/link/link.js

@@ -28,6 +28,8 @@ class Link {
         this.pending = new Map();
         this.calls = new Map();
         this.socket = null;
+        /** Every socket this link has opened and not yet closed, by generation. */
+        this.sockets = new Map();
         this.frameCounter = 0;
         this.currentState = "idle";
         /**
@@ -171,7 +173,10 @@ class Link {
         this.failPending(closed);
         this.settleWaiters(this.attemptWaiters, closed);
         this.settleWaiters(this.openWaiters, closed);
-        this.socket?.close(1000, reason);
+        // Every socket, not just the current one: a link that is being closed for good must not
+        // leave anything of itself attached to the server.
+        for (const generation of [...this.sockets.keys()])
+            this.abandon(generation, reason);
         this.socket = null;
     }
     /**
@@ -194,14 +199,23 @@ class Link {
         const { url, protocols } = (0, socket_1.buildHandshake)(this.options.serverUrl, "link", this.options.apiKey);
         this.debug(`connecting to ${url.replace(/api_key=[^&]+/, "api_key=***")}`);
         try {
-            this.socket = this.options.socketFactory(url, protocols, {
+            const socket = this.options.socketFactory(url, protocols, {
                 onOpen: () => this.onOpen(generation),
                 onMessage: (data) => { if (generation === this.generation)
                     this.onMessage(data); },
-                onClose: (code, reason) => this.onClose(generation, code, reason),
+                onClose: (code, reason) => {
+                    this.sockets.delete(generation);
+                    this.onClose(generation, code, reason);
+                },
                 onError: (error) => { if (generation === this.generation)
                     this.emitter.emit("error", asError(error)); },
             });
+            // Held by generation, not only as `this.socket`, so a socket that stops being the
+            // current one can still be closed. One that is merely forgotten stays open at the far
+            // end: it has already said hello and registered its tools, so the server goes on serving
+            // it, and it answers websocket pings forever because the network stack does that for it.
+            this.sockets.set(generation, socket);
+            this.socket = socket;
         }
         catch (error) {
             // A factory that throws never produces a close event, so this failure is
@@ -230,9 +244,11 @@ class Link {
             const identity = { connectionId: welcome.connectionId, scope: welcome.scope };
             this.identity = identity;
             await this.registerAll();
-            // Registration is several round trips; the socket may have gone during them.
+            // Registration is several round trips; the socket may have gone during them. It is fully
+            // registered at the server by now, so abandoning it quietly would leave it serving tools
+            // nothing here will ever answer.
             if (generation !== this.generation)
-                return;
+                return this.abandon(generation, "superseded during handshake");
             this.attempting = false;
             this.currentState = "open";
             this.reconnectAttempt = 0;
@@ -243,7 +259,7 @@ class Link {
             this.emitter.emit("connect", identity);
         }).catch((error) => {
             if (generation !== this.generation)
-                return;
+                return this.abandon(generation, "superseded during handshake");
             this.emitter.emit("error", error);
             this.settleWaiters(this.attemptWaiters, error);
             // Only the server saying "do not come back" stops us: a rejected claim or an
@@ -266,12 +282,28 @@ class Link {
     dropSocket(generation, code, reason) {
         if (generation !== this.generation)
             return;
-        const socket = this.socket;
         this.onClose(generation, code, reason);
+        // 1006 is reserved and rejected by browsers; anything else we raise is a valid
+        // application code.
+        this.abandon(generation, reason, code === 1006 ? 1000 : code);
+    }
+    /**
+     * Closes a socket this end has stopped using, whatever generation it belongs to.
+     *
+     * Every path that walks away from a socket goes through here. Forgetting one is not harmless:
+     * the server has no way to tell an abandoned connection from a live one — it has said hello,
+     * registered its tools and claimed its link id — so it keeps it, keeps serving from it, and
+     * hands the link id back and forth between it and its replacements.
+     */
+    abandon(generation, reason, code = 1000) {
+        const socket = this.sockets.get(generation);
+        if (!socket)
+            return;
+        this.sockets.delete(generation);
+        if (this.socket === socket)
+            this.socket = null;
         try {
-            // 1006 is reserved and rejected by browsers; anything else we raise is a valid
-            // application code.
-            socket?.close(code === 1006 ? 1000 : code, reason);
+            socket.close(code, reason);
         }
         catch {
             // Already gone, which is the outcome we wanted anyway.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@butlerbot/sdk",
-	"version": "0.0.24",
+	"version": "0.0.25",
 	"description": "The official ButlerBot SDK",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",