Tracking pollInterval now in the class to clear it on stop.

Author: TheLarkInn

apps/playwright-browser-tunnel/src/PlaywrightBrowserTunnel.ts

@@ -88,15 +88,16 @@ export class PlaywrightTunnel {
   private readonly _onStatusChange: (status: TunnelStatus) => void;
   private readonly _onBeforeLaunch?: (handshake: IHandshake) => Promise<boolean> | boolean;
   private readonly _playwrightBrowsersInstalled: Set<string> = new Set();
-  private readonly _wsEndpoint?: string;
-  private readonly _listenPort?: number;
+  private readonly _wsEndpoint: string | undefined;
+  private readonly _listenPort: number | undefined;
   private readonly _playwrightInstallPath: string;
   private _status: TunnelStatus = 'stopped';
   private _initWsPromise?: Promise<WebSocket>;
   private _keepRunning: boolean = false;
   private _ws?: WebSocket;
   private _mode: TunnelMode;
   private _pendingConnectionAttempt?: Promise<WebSocket>;
+  private _pollInterval?: NodeJS.Timeout;
 
   public constructor(options: IPlaywrightTunnelOptions) {
     const { mode, terminal, onStatusChange, playwrightInstallPath, onBeforeLaunch } = options;
@@ -143,7 +144,7 @@ export class PlaywrightTunnel {
     if (initWsPromise) {
       const ws: WebSocket = await initWsPromise;
       await once(ws, 'close');
-      terminal.writeLine('WebSocket connection closed. resolving init promise.');
+      terminal.writeDebugLine('WebSocket connection closed. resolving init promise.');
       this._initWsPromise = undefined;
     }
   }
@@ -164,6 +165,10 @@ export class PlaywrightTunnel {
 
   public async stopAsync(): Promise<void> {
     this._keepRunning = false;
+    if (this._pollInterval) {
+      clearInterval(this._pollInterval);
+      this._pollInterval = undefined;
+    }
     await this._initWsPromise?.finally(() => {
       this._ws?.close();
     });
@@ -244,7 +249,7 @@ export class PlaywrightTunnel {
   private async _tryConnectAsync(): Promise<WebSocket> {
     const wsEndpoint: string | undefined = this._wsEndpoint;
     if (!wsEndpoint) {
-      return Promise.reject(new Error('WebSocket endpoint is not defined'));
+      throw new Error('WebSocket endpoint is not defined');
     }
     return await new Promise<WebSocket>((resolve, reject) => {
       const ws: WebSocket = new WebSocket(wsEndpoint);
@@ -262,16 +267,17 @@ export class PlaywrightTunnel {
   // Need to support multiple simultaneous connections for parallel tests.
   private async _pollConnectionAsync(): Promise<WebSocket> {
     this._terminal.writeLine(`Waiting for WebSocket connection`);
-    return new Promise((resolve, reject) => {
-      const interval: NodeJS.Timeout = setInterval(() => {
+    return await new Promise((resolve, reject) => {
+      this._pollInterval = setInterval(() => {
         if (this._pendingConnectionAttempt) {
           return; // Skip if a connection attempt is already in progress
         }
         const connectionPromise: Promise<WebSocket> = this._tryConnectAsync();
         this._pendingConnectionAttempt = connectionPromise;
         connectionPromise
           .then((ws: WebSocket) => {
-            clearInterval(interval);
+            clearInterval(this._pollInterval);
+            this._pollInterval = undefined;
             ws.removeAllListeners();
             this._pendingConnectionAttempt = undefined;
             resolve(ws);