Added reentrancy gates when websocket is created/dropped (#1431)

If the browser extension is not installed there's a potential timing
issue that causes the machine to go into a create/close WS loop
- now there's a singular Promise while waiting for port creation
- dropped connections are now throttled

Author: robgruen

ts/packages/shell/src/main/browserIpc.ts

@@ -15,6 +15,8 @@ export class BrowserAgentIpc {
     private static instance: BrowserAgentIpc;
     public onMessageReceived: ((message: WebSocketMessageV2) => void) | null;
     private webSocket: any;
+    private reconnectionPending: boolean = false;
+    private webSocketPromise: Promise<WebSocket | undefined> | null = null;
 
     private constructor() {
         this.webSocket = null;
@@ -30,65 +32,86 @@ export class BrowserAgentIpc {
     };
 
     public async ensureWebsocketConnected() {
-        return new Promise<WebSocket | undefined>(async (resolve) => {
-            if (this.webSocket) {
-                if (this.webSocket.readyState === WebSocket.OPEN) {
-                    resolve(this.webSocket);
+        // if there's a pending websocket promise, return it
+        if (this.webSocketPromise) {
+            return this.webSocketPromise;
+        }
+
+        //create a new promise to establish the websocket connection
+        this.webSocketPromise = new Promise<WebSocket | undefined>(
+            async (resolve) => {
+                if (this.webSocket) {
+                    if (this.webSocket.readyState === WebSocket.OPEN) {
+                        resolve(this.webSocket);
+                        return;
+                    }
+                    try {
+                        this.webSocket.close();
+                        this.webSocket = undefined;
+                    } catch {}
+                }
+
+                this.webSocket = await createWebSocket(
+                    "browser",
+                    "client",
+                    "inlineBrowser",
+                );
+                if (!this.webSocket) {
+                    resolve(undefined);
                     return;
                 }
-                try {
-                    this.webSocket.close();
-                    this.webSocket = undefined;
-                } catch {}
-            }
 
-            this.webSocket = await createWebSocket(
-                "browser",
-                "client",
-                "inlineBrowser",
-            );
-            if (!this.webSocket) {
-                resolve(undefined);
-                return;
-            }
+                this.webSocket.binaryType = "blob";
+                keepWebSocketAlive(this.webSocket, "browser");
+
+                this.webSocket.onmessage = async (event: any) => {
+                    const text =
+                        typeof event.data === "string"
+                            ? event.data
+                            : await (event.data as Blob).text();
+                    try {
+                        const data = JSON.parse(text) as WebSocketMessageV2;
+
+                        let schema = data.method?.split("/")[0];
+                        schema = schema || "browser";
+
+                        if (
+                            (schema == "browser" ||
+                                schema == "webAgent" ||
+                                schema.startsWith("browser.")) &&
+                            this.onMessageReceived
+                        ) {
+                            debugBrowserIPC("Browser -> Dispatcher", data);
+                            this.onMessageReceived(data);
+                        }
+                    } catch {}
+                };
+
+                this.webSocket.onclose = () => {
+                    console.log("websocket connection closed");
+                    this.webSocket = undefined;
+                    this.reconnectWebSocket();
+                };
 
-            this.webSocket.binaryType = "blob";
-            keepWebSocketAlive(this.webSocket, "browser");
-
-            this.webSocket.onmessage = async (event: any) => {
-                const text =
-                    typeof event.data === "string"
-                        ? event.data
-                        : await (event.data as Blob).text();
-                try {
-                    const data = JSON.parse(text) as WebSocketMessageV2;
-
-                    let schema = data.method?.split("/")[0];
-                    schema = schema || "browser";
-
-                    if (
-                        (schema == "browser" ||
-                            schema == "webAgent" ||
-                            schema.startsWith("browser.")) &&
-                        this.onMessageReceived
-                    ) {
-                        debugBrowserIPC("Browser -> Dispatcher", data);
-                        this.onMessageReceived(data);
-                    }
-                } catch {}
-            };
+                this.webSocketPromise = null;
 
-            this.webSocket.onclose = () => {
-                console.log("websocket connection closed");
-                this.webSocket = undefined;
-                this.reconnectWebSocket();
-            };
+                resolve(this.webSocket);
+            },
+        );
 
-            resolve(this.webSocket);
-        });
+        return this.webSocketPromise;
     }
 
     private reconnectWebSocket() {
+        // if there is a reconnection pending just return
+        if (this.reconnectionPending) {
+            return;
+        }
+
+        // indicate a reconnection attempt is pending
+        this.reconnectionPending = true;
+
+        // attempt reconnection every 5 seconds
         const connectionCheckIntervalId = setInterval(async () => {
             if (
                 this.webSocket &&
@@ -100,6 +123,9 @@ export class BrowserAgentIpc {
                 console.log("Retrying connection");
                 await this.ensureWebsocketConnected();
             }
+
+            // reconnection was either successful or attempted
+            this.reconnectionPending = false;
         }, 5 * 1000);
     }