@quenty/studio-bridge 0.7.0 → 0.8.0

package/src/server/studio-bridge-server.ts

@@ -10,7 +10,10 @@
  */
 
 import { randomUUID } from 'crypto';
+import * as fs from 'fs';
+import * as http from 'http';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 import { WebSocketServer, type WebSocket } from 'ws';
 import { OutputHelper } from '@quenty/cli-output-helpers';
 import {
@@ -20,13 +23,22 @@ import {
 } from '@quenty/nevermore-template-helpers';
 import {
   type OutputLevel,
+  type Capability,
+  type PluginMessage,
+  type ServerMessage,
   encodeMessage,
   decodePluginMessage,
 } from './web-socket-protocol.js';
+import { ActionDispatcher } from './action-dispatcher.js';
+import {
+  loadActionSourcesAsync,
+  type ActionSource,
+} from '../commands/framework/action-loader.js';
 import {
   injectPluginAsync,
   type InjectedPlugin,
 } from '../plugin/plugin-injector.js';
+import { isPersistentPluginInstalled } from '../plugin/plugin-discovery.js';
 import {
   launchStudioAsync,
   type StudioProcess,
@@ -43,9 +55,20 @@ const sessionAttributeTransformScript = resolvePackagePath(
   'transform-add-session-attribute.luau'
 );
 
-// ---------------------------------------------------------------------------
-// Public API types
-// ---------------------------------------------------------------------------
+function readServerVersion(): string {
+  try {
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    // Walk up from src/server/ to package root
+    const pkgPath = path.resolve(thisDir, '..', '..', 'package.json');
+    const raw = fs.readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(raw) as { version?: string };
+    return pkg.version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+const SERVER_VERSION = readServerVersion();
 
 export type StudioBridgePhase =
   | 'building'
@@ -64,6 +87,11 @@ export interface StudioBridgeServerOptions {
   onPhase?: (phase: StudioBridgePhase) => void;
   /** Session ID for concurrent session isolation. Auto-generated if omitted. */
   sessionId?: string;
+  /** Whether to prefer the persistent plugin over temp injection (default: true).
+   *  When true and the persistent plugin is installed, the server waits for
+   *  the plugin to discover it via the health endpoint before falling back
+   *  to temporary injection. Set to false in CI environments. */
+  preferPersistentPlugin?: boolean;
 }
 
 export interface ExecuteOptions {
@@ -80,10 +108,6 @@ export interface StudioBridgeResult {
   logs: string;
 }
 
-// ---------------------------------------------------------------------------
-// State machine
-// ---------------------------------------------------------------------------
-
 type BridgeState =
   | 'idle'
   | 'starting'
@@ -92,52 +116,156 @@ type BridgeState =
   | 'stopping'
   | 'stopped';
 
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
+/** Returns the assigned port once listening. WSS uses noServer mode (manual upgrade). */
+function startHttpAndWsServerAsync(
+  httpServer: http.Server,
+  wss: WebSocketServer,
+  sessionId: string
+): Promise<number> {
+  httpServer.on(
+    'request',
+    (req: http.IncomingMessage, res: http.ServerResponse) => {
+      if (req.method === 'GET' && req.url === '/health') {
+        const addr = httpServer.address();
+        const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+        const body = JSON.stringify({
+          status: 'ok',
+          sessionId,
+          port,
+          serverVersion: SERVER_VERSION,
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(body);
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    }
+  );
+
+  // Handle WebSocket upgrades — only allow /${sessionId}
+  httpServer.on(
+    'upgrade',
+    (
+      req: http.IncomingMessage,
+      socket: import('stream').Duplex,
+      head: Buffer
+    ) => {
+      const expectedPath = `/${sessionId}`;
+      if (req.url !== expectedPath) {
+        socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
+      });
+    }
+  );
 
-/**
- * Start a WebSocket server on a random available port and return the assigned
- * port number once listening.
- */
-function startWsServerAsync(wss: WebSocketServer): Promise<number> {
   return new Promise((resolve, reject) => {
-    wss.on('error', reject);
-    wss.on('listening', () => {
-      const addr = wss.address();
+    httpServer.on('error', reject);
+    httpServer.listen(0, () => {
+      const addr = httpServer.address();
       if (typeof addr === 'object' && addr !== null) {
         resolve(addr.port);
       } else {
-        reject(new Error('WebSocket server address is not available'));
+        reject(new Error('HTTP server address is not available'));
       }
     });
   });
 }
 
+/** Capability required for each action type. */
+const ACTION_CAPABILITIES: Record<string, Capability> = {
+  queryState: 'queryState',
+  captureScreenshot: 'captureScreenshot',
+  queryDataModel: 'queryDataModel',
+  queryLogs: 'queryLogs',
+  execute: 'execute',
+};
+
 export class StudioBridgeServer {
   private _state: BridgeState = 'idle';
 
+  private readonly _options: StudioBridgeServerOptions;
   private readonly _sessionId: string;
   private readonly _defaultTimeoutMs: number;
   private readonly _onPhase: ((phase: StudioBridgePhase) => void) | undefined;
   private readonly _placePath: string | undefined;
 
+  private _httpServer: http.Server | undefined;
   private _wss: WebSocketServer | undefined;
+  private _port: number = 0;
   private _pluginHandle: InjectedPlugin | undefined;
   private _studioProc: StudioProcess | undefined;
   private _placeBuildContext: BuildContext | undefined;
   private _connectedClient: WebSocket | undefined;
 
+  private _negotiatedCapabilities: Capability[] = ['execute'];
+  private _lastHeartbeatTimestamp: number | undefined;
+  private _actionDispatcher = new ActionDispatcher();
+  private _actionsReady = false;
+  private _actionSources: ActionSource[] | undefined;
+
   constructor(options: StudioBridgeServerOptions = {}) {
+    this._options = options;
     this._sessionId = options.sessionId ?? randomUUID();
     this._defaultTimeoutMs = options.timeoutMs ?? 120_000;
     this._onPhase = options.onPhase;
     this._placePath = options.placePath;
   }
 
-  // -----------------------------------------------------------------------
-  // Lifecycle: startAsync
-  // -----------------------------------------------------------------------
+  /** The negotiated set of capabilities shared between plugin and server. */
+  get capabilities(): readonly Capability[] {
+    return this._negotiatedCapabilities;
+  }
+
+  /** Timestamp of the last heartbeat received from the plugin, or undefined. */
+  get lastHeartbeatTimestamp(): number | undefined {
+    return this._lastHeartbeatTimestamp;
+  }
+
+  /** Requires the plugin to advertise the relevant capability. */
+  async performActionAsync<T extends PluginMessage>(
+    message: Omit<ServerMessage, 'requestId' | 'sessionId'>,
+    timeoutMs?: number
+  ): Promise<T> {
+    if (this._state !== 'ready') {
+      throw new Error(
+        `Cannot perform action: expected state 'ready', got '${this._state}'`
+      );
+    }
+    if (!this._connectedClient) {
+      throw new Error('Cannot perform action: no connected client');
+    }
+
+    const actionType = message.type;
+    const requiredCapability = ACTION_CAPABILITIES[actionType];
+    if (
+      requiredCapability &&
+      !this._negotiatedCapabilities.includes(requiredCapability)
+    ) {
+      throw new Error(
+        `Plugin does not support capability: ${requiredCapability}`
+      );
+    }
+
+    const { requestId, responsePromise } =
+      this._actionDispatcher.createRequestAsync(actionType, timeoutMs);
+
+    const fullMessage: ServerMessage = {
+      ...message,
+      requestId,
+      sessionId: this._sessionId,
+    } as ServerMessage;
+
+    this._connectedClient.send(encodeMessage(fullMessage));
+
+    return responsePromise as Promise<T>;
+  }
 
   /**
    * Build place (if needed) → start WS server → inject plugin → launch
@@ -181,21 +309,45 @@ export class StudioBridgeServer {
       );
       placePath = transformedPlacePath;
 
-      // 1. Start WebSocket server (unique path rejects wrong connections at HTTP upgrade level)
-      this._wss = new WebSocketServer({ port: 0, path: `/${this._sessionId}` });
-      const port = await startWsServerAsync(this._wss);
+      // 1. Start HTTP + WebSocket server (unique path rejects wrong connections at upgrade level)
+      this._httpServer = http.createServer();
+      this._wss = new WebSocketServer({ noServer: true });
+      const port = await startHttpAndWsServerAsync(
+        this._httpServer,
+        this._wss,
+        this._sessionId
+      );
+      this._port = port;
       OutputHelper.verbose(
         `[StudioBridge] WebSocket server listening on port ${port}`
       );
 
-      // 2. Inject plugin (no scriptContent — scripts are sent via execute messages)
-      this._pluginHandle = await injectPluginAsync({
-        port,
-        sessionId: this._sessionId,
-      });
-      OutputHelper.verbose(
-        `[StudioBridge] Plugin injected: ${this._pluginHandle.pluginPath}`
-      );
+      // 2. Decide between persistent plugin and temp injection
+      const preferPersistent = this._options.preferPersistentPlugin ?? true;
+
+      if (preferPersistent && isPersistentPluginInstalled()) {
+        // Persistent plugin is installed. Skip injection and wait for the
+        // plugin to discover us via the health endpoint.
+        // Start a grace period timer: if the plugin does not connect within
+        // the grace period, fall back to temporary injection.
+        OutputHelper.verbose(
+          '[StudioBridge] Persistent plugin detected, waiting for connection'
+        );
+        const graceMs = 3_000;
+        const connected = await this._waitForPluginConnectionAsync(graceMs);
+        if (!connected) {
+          // Grace period expired. Plugin may not be running in Studio.
+          // Fall back to temporary injection.
+          OutputHelper.verbose(
+            '[StudioBridge] Grace period expired, falling back to temp injection'
+          );
+          await this._injectPluginAsync();
+        }
+      } else {
+        // No persistent plugin or preference disabled (CI mode).
+        // Use temporary injection (legacy launch-and-execute flow).
+        await this._injectPluginAsync();
+      }
 
       // 3. Launch Studio
       this._onPhase?.('launching');
@@ -204,9 +356,11 @@ export class StudioBridgeServer {
         `[StudioBridge] Studio launched (PID: ${this._studioProc.process.pid})`
       );
 
-      // 4. Wait for handshake
+      // 4. Wait for handshake (only if not already connected via persistent plugin)
       this._onPhase?.('connecting');
-      await this._waitForHandshakeAsync();
+      if (!this._connectedClient) {
+        await this._waitForHandshakeAsync();
+      }
 
       this._state = 'ready';
     } catch (error) {
@@ -216,14 +370,7 @@ export class StudioBridgeServer {
     }
   }
 
-  // -----------------------------------------------------------------------
-  // Lifecycle: executeAsync
-  // -----------------------------------------------------------------------
-
-  /**
-   * Send a Luau script to the connected Studio instance and wait for it to
-   * finish executing. Can be called multiple times while the bridge is ready.
-   */
+  /** Can be called multiple times while the bridge is ready. */
   async executeAsync(options: ExecuteOptions): Promise<StudioBridgeResult> {
     if (this._state !== 'ready') {
       throw new Error(
@@ -234,11 +381,14 @@ export class StudioBridgeServer {
       throw new Error('Cannot execute: no connected client');
     }
 
+    // Sync action modules before first execute (state must still be 'ready'
+    // because performActionAsync checks for it).
+    await this._ensureActionsAsync();
+
     this._state = 'executing';
     this._onPhase?.('executing');
 
     try {
-      // Send execute message
       this._connectedClient.send(
         encodeMessage({
           type: 'execute',
@@ -247,7 +397,6 @@ export class StudioBridgeServer {
         })
       );
 
-      // Wait for result
       const result = await this._waitForScriptCompleteAsync(options);
 
       this._onPhase?.('done');
@@ -263,14 +412,7 @@ export class StudioBridgeServer {
     }
   }
 
-  // -----------------------------------------------------------------------
-  // Lifecycle: stopAsync
-  // -----------------------------------------------------------------------
-
-  /**
-   * Shut down the bridge — send shutdown to client, kill Studio, clean up
-   * all resources. Idempotent on 'stopped'.
-   */
+  /** Idempotent on 'stopped'. */
   async stopAsync(): Promise<void> {
     if (this._state === 'stopped') {
       return;
@@ -278,7 +420,6 @@ export class StudioBridgeServer {
 
     this._state = 'stopping';
 
-    // Send shutdown to connected client
     if (this._connectedClient) {
       try {
         this._connectedClient.send(
@@ -297,11 +438,195 @@ export class StudioBridgeServer {
     this._state = 'stopped';
   }
 
-  // -----------------------------------------------------------------------
-  // Private: _waitForHandshakeAsync
-  // -----------------------------------------------------------------------
+  /**
+   * Ensure action modules (like `execute.luau`) are synced to the plugin
+   * before first use. Uses `syncActions` to check which actions the plugin
+   * is missing, then registers them via `registerAction`.
+   *
+   * Loads action sources and registers them with the connected plugin.
+   */
+  private async _ensureActionsAsync(): Promise<void> {
+    if (this._actionsReady) return;
+
+    if (!this._actionSources) {
+      this._actionSources = await loadActionSourcesAsync();
+      OutputHelper.verbose(
+        `[StudioBridge] Loaded ${
+          this._actionSources.length
+        } action source(s): ${
+          this._actionSources.map((a) => a.name).join(', ') || '(none)'
+        }`
+      );
+    }
+
+    if (this._actionSources.length === 0) {
+      this._actionsReady = true;
+      return;
+    }
+
+    const actions: Record<string, string> = {};
+    for (const action of this._actionSources) {
+      actions[action.name] = action.hash;
+    }
+
+    OutputHelper.verbose('[StudioBridge] Syncing actions with plugin');
+    const syncResult = await this.performActionAsync<PluginMessage>(
+      {
+        type: 'syncActions',
+        payload: { actions },
+      },
+      10_000
+    );
+
+    if (syncResult.type === 'syncActionsResult') {
+      const needed = (syncResult.payload as Record<string, unknown>)
+        .needed as string[];
+      OutputHelper.verbose(
+        `[StudioBridge] ${needed.length} action(s) need registering${
+          needed.length > 0 ? ': ' + needed.join(', ') : ''
+        }`
+      );
+
+      for (const actionName of needed) {
+        const action = this._actionSources.find((a) => a.name === actionName);
+        if (!action) continue;
+
+        OutputHelper.verbose(
+          `[StudioBridge] Registering action: ${actionName}`
+        );
+        await this.performActionAsync<PluginMessage>(
+          {
+            type: 'registerAction',
+            payload: {
+              name: action.name,
+              source: action.source,
+              hash: action.hash,
+            },
+          },
+          10_000
+        );
+      }
+    }
+
+    this._actionsReady = true;
+    OutputHelper.verbose('[StudioBridge] Action sync complete');
+  }
+
+  /**
+   * Inject the temporary plugin via rojo build into Studio's plugins folder.
+   */
+  private async _injectPluginAsync(): Promise<void> {
+    this._pluginHandle = await injectPluginAsync({
+      port: this._port,
+      sessionId: this._sessionId,
+    });
+    OutputHelper.verbose(
+      `[StudioBridge] Plugin injected: ${this._pluginHandle.pluginPath}`
+    );
+  }
+
+  /**
+   * Wait for a persistent plugin to connect via WebSocket within the grace
+   * period. Returns true if a plugin connected (sent hello or register),
+   * false if the grace period expired.
+   */
+  private _waitForPluginConnectionAsync(graceMs: number): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      let settled = false;
+
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          resolve(false);
+        }
+      }, graceMs);
+
+      this._wss!.on('connection', (ws: WebSocket) => {
+        if (settled) return;
+
+        const onMessage = (raw: Buffer | string) => {
+          if (settled) return;
+          const data = typeof raw === 'string' ? raw : raw.toString('utf-8');
+          const msg = decodePluginMessage(data);
+          if (!msg) return;
+
+          if (msg.type === 'register') {
+            settled = true;
+            clearTimeout(timer);
+            ws.off('message', onMessage);
+
+            this._handlePluginHandshakeMessage(ws, msg);
+            resolve(true);
+          }
+        };
+
+        ws.on('message', onMessage);
+
+        ws.on('error', (err) => {
+          OutputHelper.verbose(
+            `[StudioBridge] WebSocket error during grace period: ${err.message}`
+          );
+        });
+      });
+    });
+  }
+
+  private _handlePluginHandshakeMessage(
+    ws: WebSocket,
+    msg: PluginMessage
+  ): void {
+    if (msg.type !== 'register') return;
+
+    const serverSupportedCapabilities: Capability[] = [
+      'execute',
+      'queryState',
+      'captureScreenshot',
+      'queryDataModel',
+      'queryLogs',
+    ];
+
+    this._negotiatedCapabilities = msg.payload.capabilities.filter((cap) =>
+      serverSupportedCapabilities.includes(cap)
+    );
+
+    OutputHelper.verbose(
+      '[StudioBridge] Plugin register handshake accepted (grace period)'
+    );
+
+    this._connectedClient = ws;
+
+    ws.on('message', (raw: Buffer | string) => {
+      const data = typeof raw === 'string' ? raw : raw.toString('utf-8');
+      const innerMsg = decodePluginMessage(data);
+      if (!innerMsg) return;
+
+      if (this._actionDispatcher.handleResponse(innerMsg)) {
+        return;
+      }
+
+      if (innerMsg.type === 'heartbeat') {
+        this._lastHeartbeatTimestamp = Date.now();
+      }
+    });
+
+    ws.on('close', () => {
+      OutputHelper.verbose('[StudioBridge] Plugin disconnected');
+      this._connectedClient = undefined;
+      if (this._state !== 'stopping' && this._state !== 'stopped') {
+        this._state = 'stopped';
+      }
+    });
+  }
 
   private _waitForHandshakeAsync(): Promise<void> {
+    const serverSupportedCapabilities: Capability[] = [
+      'execute',
+      'queryState',
+      'captureScreenshot',
+      'queryDataModel',
+      'queryLogs',
+    ];
+
     return new Promise<void>((resolve, reject) => {
       let settled = false;
 
@@ -322,47 +647,23 @@ export class StudioBridgeServer {
         const onMessage = (raw: Buffer | string) => {
           const data = typeof raw === 'string' ? raw : raw.toString('utf-8');
           const msg = decodePluginMessage(data);
-          if (!msg || msg.type !== 'hello') {
+          if (!msg) {
             return;
           }
 
-          if (
-            msg.sessionId !== this._sessionId ||
-            msg.payload.sessionId !== this._sessionId
-          ) {
-            OutputHelper.verbose(
-              `[StudioBridge] Rejecting hello with wrong session ID`
+          if (msg.type === 'register') {
+            this._negotiatedCapabilities = msg.payload.capabilities.filter(
+              (cap) => serverSupportedCapabilities.includes(cap)
             );
-            ws.close();
-            return;
-          }
 
-          // Handshake accepted
-          OutputHelper.verbose('[StudioBridge] Handshake accepted');
-          ws.send(
-            encodeMessage({
-              type: 'welcome',
-              sessionId: this._sessionId,
-              payload: { sessionId: this._sessionId },
-            })
-          );
-
-          ws.off('message', onMessage);
-          this._connectedClient = ws;
-
-          // Listen for unexpected disconnect
-          ws.on('close', () => {
-            OutputHelper.verbose('[StudioBridge] Plugin disconnected');
-            this._connectedClient = undefined;
-            if (this._state !== 'stopping' && this._state !== 'stopped') {
-              this._state = 'stopped';
-            }
-          });
+            OutputHelper.verbose(
+              '[StudioBridge] Plugin register handshake accepted'
+            );
 
-          if (!settled) {
+            ws.off('message', onMessage);
+            this._finishHandshake(ws, settled, timer, resolve);
             settled = true;
-            clearTimeout(timer);
-            resolve();
+            return;
           }
         };
 
@@ -385,9 +686,46 @@ export class StudioBridgeServer {
     });
   }
 
-  // -----------------------------------------------------------------------
-  // Private: _waitForScriptCompleteAsync
-  // -----------------------------------------------------------------------
+  /**
+   * Common handshake completion: store the connected client, listen for
+   * heartbeats and disconnect events.
+   */
+  private _finishHandshake(
+    ws: WebSocket,
+    alreadySettled: boolean,
+    timer: ReturnType<typeof setTimeout>,
+    resolve: () => void
+  ): void {
+    this._connectedClient = ws;
+
+    ws.on('message', (raw: Buffer | string) => {
+      const data = typeof raw === 'string' ? raw : raw.toString('utf-8');
+      const msg = decodePluginMessage(data);
+      if (!msg) return;
+
+      // Action dispatcher first — request/response correlation
+      if (this._actionDispatcher.handleResponse(msg)) {
+        return;
+      }
+
+      if (msg.type === 'heartbeat') {
+        this._lastHeartbeatTimestamp = Date.now();
+      }
+    });
+
+    ws.on('close', () => {
+      OutputHelper.verbose('[StudioBridge] Plugin disconnected');
+      this._connectedClient = undefined;
+      if (this._state !== 'stopping' && this._state !== 'stopped') {
+        this._state = 'stopped';
+      }
+    });
+
+    if (!alreadySettled) {
+      clearTimeout(timer);
+      resolve();
+    }
+  }
 
   private _waitForScriptCompleteAsync(
     options: ExecuteOptions
@@ -439,20 +777,19 @@ export class StudioBridgeServer {
         }
 
         switch (msg.type) {
-          case 'output': {
-            for (const entry of msg.payload.messages) {
-              logLines.push(entry.body);
-              options.onOutput?.(entry.level, entry.body);
-            }
-            break;
-          }
-
           case 'scriptComplete': {
             OutputHelper.verbose(
               `[StudioBridge] Script complete: success=${msg.payload.success}` +
                 (msg.payload.error ? ` error=${msg.payload.error}` : '')
             );
 
+            if (msg.payload.output) {
+              for (const entry of msg.payload.output) {
+                logLines.push(entry.body);
+                options.onOutput?.(entry.level as OutputLevel, entry.body);
+              }
+            }
+
             if (msg.payload.error) {
               logLines.push(msg.payload.error);
             }
@@ -463,6 +800,24 @@ export class StudioBridgeServer {
             });
             break;
           }
+
+          case 'error': {
+            const errorPayload = msg.payload as {
+              code: string;
+              message: string;
+            };
+            OutputHelper.verbose(
+              `[StudioBridge] Plugin error: ${errorPayload.code} — ${errorPayload.message}`
+            );
+            logLines.push(
+              `[StudioBridge] Plugin error: ${errorPayload.code} — ${errorPayload.message}`
+            );
+            finish({
+              success: false,
+              logs: logLines.join('\n'),
+            });
+            break;
+          }
         }
       };
 
@@ -494,31 +849,27 @@ export class StudioBridgeServer {
     });
   }
 
-  // -----------------------------------------------------------------------
-  // Private: _cleanupResourcesAsync
-  // -----------------------------------------------------------------------
-
   private async _cleanupResourcesAsync(): Promise<void> {
-    // Kill Studio
+    this._actionDispatcher.cancelAll('Server shutting down');
+
     if (this._studioProc) {
       await this._studioProc.killAsync();
       this._studioProc = undefined;
     }
 
-    // Remove injected plugin
     if (this._pluginHandle) {
       await this._pluginHandle.cleanupAsync();
       this._pluginHandle = undefined;
     }
 
-    // Remove auto-built place
     if (this._placeBuildContext) {
       await this._placeBuildContext.cleanupAsync();
       this._placeBuildContext = undefined;
     }
 
-    // Close WebSocket server — terminate lingering connections first so
-    // the 'close' callback fires promptly.
+    // Terminate lingering WebSocket connections first so close callbacks
+    // fire promptly, then close the HTTP server (which owns the listening
+    // socket) and finally close the WSS.
     if (this._wss) {
       for (const wsClient of this._wss.clients) {
         wsClient.terminate();
@@ -529,6 +880,13 @@ export class StudioBridgeServer {
       this._wss = undefined;
     }
 
+    if (this._httpServer) {
+      await new Promise<void>((resolve) => {
+        this._httpServer!.close(() => resolve());
+      });
+      this._httpServer = undefined;
+    }
+
     this._connectedClient = undefined;
   }
 }