chore: isolate SSE client browsers (#76)

src/program.ts

@@ -25,8 +25,8 @@ import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 
 
 import { createServer } from './index';
+import { ServerList } from './server';
 
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { LaunchOptions } from 'playwright';
 import assert from 'assert';
 
@@ -44,14 +44,48 @@ program
         headless: !!options.headless,
         channel: 'chrome',
       };
-      const server = createServer({
+      const userDataDir = options.userDataDir ?? await createUserDataDir();
-        userDataDir: options.userDataDir ?? await userDataDir(),
+      const serverList = new ServerList(() => createServer({
+        userDataDir,
         launchOptions,
         vision: !!options.vision,
-      });
+      }));
-      setupExitWatchdog(server);
+      setupExitWatchdog(serverList);
 
       if (options.port) {
+        startSSEServer(+options.port, serverList);
+      } else {
+        const server = await serverList.create();
+        await server.connect(new StdioServerTransport());
+      }
+    });
+
+function setupExitWatchdog(serverList: ServerList) {
+  process.stdin.on('close', async () => {
+    setTimeout(() => process.exit(0), 15000);
+    await serverList.closeAll();
+    process.exit(0);
+  });
+}
+
+program.parse(process.argv);
+
+async function createUserDataDir() {
+  let cacheDirectory: string;
+  if (process.platform === 'linux')
+    cacheDirectory = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+  else if (process.platform === 'darwin')
+    cacheDirectory = path.join(os.homedir(), 'Library', 'Caches');
+  else if (process.platform === 'win32')
+    cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+  else
+    throw new Error('Unsupported platform: ' + process.platform);
+  const result = path.join(cacheDirectory, 'ms-playwright', 'mcp-chrome-profile');
+  await fs.promises.mkdir(result, { recursive: true });
+  return result;
+}
+
+async function startSSEServer(port: number, serverList: ServerList) {
   const sessions = new Map<string, SSEServerTransport>();
   const httpServer = http.createServer(async (req, res) => {
     if (req.method === 'POST') {
@@ -74,8 +108,10 @@ program
     } else if (req.method === 'GET') {
       const transport = new SSEServerTransport('/sse', res);
       sessions.set(transport.sessionId, transport);
+      const server = await serverList.create();
       res.on('close', () => {
         sessions.delete(transport.sessionId);
+        serverList.close(server).catch(e => console.error(e));
       });
       await server.connect(transport);
       return;
@@ -84,56 +120,28 @@ program
       res.end('Method not allowed');
     }
   });
-        httpServer.listen(+options.port, () => {
+
+  httpServer.listen(port, () => {
     const address = httpServer.address();
     assert(address, 'Could not bind server socket');
-          let urlPrefixHumanReadable: string;
+    let url: string;
     if (typeof address === 'string') {
-            urlPrefixHumanReadable = address;
+      url = address;
     } else {
-            const port = address.port;
+      const resolvedPort = address.port;
       let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
       if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')
         resolvedHost = 'localhost';
-            urlPrefixHumanReadable = `http://${resolvedHost}:${port}`;
+      url = `http://${resolvedHost}:${resolvedPort}`;
     }
-          console.log(`Listening on ${urlPrefixHumanReadable}`);
+    console.log(`Listening on ${url}`);
     console.log('Put this in your client config:');
     console.log(JSON.stringify({
       'mcpServers': {
         'playwright': {
-                'url': `${urlPrefixHumanReadable}/sse`
+          'url': `${url}/sse`
         }
       }
     }, undefined, 2));
   });
-      } else {
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-      }
-    });
-
-function setupExitWatchdog(server: Server) {
-  process.stdin.on('close', async () => {
-    setTimeout(() => process.exit(0), 15000);
-    await server.close();
-    process.exit(0);
-  });
-}
-
-program.parse(process.argv);
-
-async function userDataDir() {
-  let cacheDirectory: string;
-  if (process.platform === 'linux')
-    cacheDirectory = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
-  else if (process.platform === 'darwin')
-    cacheDirectory = path.join(os.homedir(), 'Library', 'Caches');
-  else if (process.platform === 'win32')
-    cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-  else
-    throw new Error('Unsupported platform: ' + process.platform);
-  const result = path.join(cacheDirectory, 'ms-playwright', 'mcp-chrome-profile');
-  await fs.promises.mkdir(result, { recursive: true });
-  return result;
 }

src/server.ts

@@ -88,3 +88,29 @@ export function createServerWithTools(options: Options): Server {
 
   return server;
 }
+
+export class ServerList {
+  private _servers: Server[] = [];
+  private _serverFactory: () => Server;
+
+  constructor(serverFactory: () => Server) {
+    this._serverFactory = serverFactory;
+  }
+
+  async create() {
+    const server = this._serverFactory();
+    this._servers.push(server);
+    return server;
+  }
+
+  async close(server: Server) {
+    const index = this._servers.indexOf(server);
+    if (index !== -1)
+      this._servers.splice(index, 1);
+    await server.close();
+  }
+
+  async closeAll() {
+    await Promise.all(this._servers.map(server => server.close()));
+  }
+}