@darbotlabs/darbot-browser-mcp 0.1.0

package/lib/tools/wait.js

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+const wait = captureSnapshot => defineTool({
+    capability: 'wait',
+    schema: {
+        name: 'browser_wait_for',
+        title: 'Wait for',
+        description: 'Wait for text to appear or disappear or a specified time to pass',
+        inputSchema: z.object({
+            time: z.number().optional().describe('The time to wait in seconds'),
+            text: z.string().optional().describe('The text to wait for'),
+            textGone: z.string().optional().describe('The text to wait for to disappear'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        if (!params.text && !params.textGone && !params.time)
+            throw new Error('Either time, text or textGone must be provided');
+        const code = [];
+        if (params.time) {
+            code.push(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
+            await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
+        }
+        const tab = context.currentTabOrDie();
+        const locator = params.text ? tab.page.getByText(params.text).first() : undefined;
+        const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : undefined;
+        if (goneLocator) {
+            code.push(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
+            await goneLocator.waitFor({ state: 'hidden' });
+        }
+        if (locator) {
+            code.push(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
+            await locator.waitFor({ state: 'visible' });
+        }
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+export default (captureSnapshot) => [
+    wait(captureSnapshot),
+];

package/lib/tools.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import common from './tools/common.js';
+import console from './tools/console.js';
+import dialogs from './tools/dialogs.js';
+import files from './tools/files.js';
+import install from './tools/install.js';
+import keyboard from './tools/keyboard.js';
+import navigate from './tools/navigate.js';
+import network from './tools/network.js';
+import pdf from './tools/pdf.js';
+import * as profiles from './tools/profiles.js';
+import snapshot from './tools/snapshot.js';
+import tabs from './tools/tabs.js';
+import screenshot from './tools/screenshot.js';
+import testing from './tools/testing.js';
+import vision from './tools/vision.js';
+import wait from './tools/wait.js';
+export const snapshotTools = [
+    ...common(true),
+    ...console,
+    ...dialogs(true),
+    ...files(true),
+    ...install,
+    ...keyboard(true),
+    ...navigate(true),
+    ...network,
+    ...pdf,
+    profiles.browserSaveProfile,
+    profiles.browserSwitchProfile,
+    profiles.browserListProfiles,
+    profiles.browserDeleteProfile,
+    ...screenshot,
+    ...snapshot,
+    ...tabs(true),
+    ...testing,
+    ...wait(true),
+];
+export const visionTools = [
+    ...common(false),
+    ...console,
+    ...dialogs(false),
+    ...files(false),
+    ...install,
+    ...keyboard(false),
+    ...navigate(false),
+    ...network,
+    ...pdf,
+    profiles.browserSaveProfile,
+    profiles.browserSwitchProfile,
+    profiles.browserListProfiles,
+    profiles.browserDeleteProfile,
+    ...tabs(false),
+    ...testing,
+    ...vision,
+    ...wait(false),
+];

package/lib/transport.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import http from 'node:http';
+import assert from 'node:assert';
+import crypto from 'node:crypto';
+import debug from 'debug';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+export async function startStdioTransport(server) {
+    await server.createConnection(new StdioServerTransport());
+}
+const testDebug = debug('pw:mcp:test');
+async function handleSSE(server, req, res, url, sessions) {
+    if (req.method === 'POST') {
+        const sessionId = url.searchParams.get('sessionId');
+        if (!sessionId) {
+            res.statusCode = 400;
+            return res.end('Missing sessionId');
+        }
+        const transport = sessions.get(sessionId);
+        if (!transport) {
+            res.statusCode = 404;
+            return res.end('Session not found');
+        }
+        return await transport.handlePostMessage(req, res);
+    }
+    else if (req.method === 'GET') {
+        const transport = new SSEServerTransport('/sse', res);
+        sessions.set(transport.sessionId, transport);
+        testDebug(`create SSE session: ${transport.sessionId}`);
+        const connection = await server.createConnection(transport);
+        res.on('close', () => {
+            testDebug(`delete SSE session: ${transport.sessionId}`);
+            sessions.delete(transport.sessionId);
+            // eslint-disable-next-line no-console
+            void connection.close().catch(e => console.error(e));
+        });
+        return;
+    }
+    res.statusCode = 405;
+    res.end('Method not allowed');
+}
+async function handleStreamable(server, req, res, sessions) {
+    const sessionId = req.headers['mcp-session-id'];
+    if (sessionId) {
+        const transport = sessions.get(sessionId);
+        if (!transport) {
+            res.statusCode = 404;
+            res.end('Session not found');
+            return;
+        }
+        return await transport.handleRequest(req, res);
+    }
+    if (req.method === 'POST') {
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => crypto.randomUUID(),
+            onsessioninitialized: sessionId => {
+                sessions.set(sessionId, transport);
+            }
+        });
+        transport.onclose = () => {
+            if (transport.sessionId)
+                sessions.delete(transport.sessionId);
+        };
+        await server.createConnection(transport);
+        await transport.handleRequest(req, res);
+        return;
+    }
+    res.statusCode = 400;
+    res.end('Invalid request');
+}
+export async function startHttpServer(config) {
+    const { host, port } = config;
+    const httpServer = http.createServer();
+    await new Promise((resolve, reject) => {
+        httpServer.on('error', reject);
+        httpServer.listen(port, host, () => {
+            resolve();
+            httpServer.removeListener('error', reject);
+        });
+    });
+    return httpServer;
+}
+export function startHttpTransport(httpServer, mcpServer) {
+    const sseSessions = new Map();
+    const streamableSessions = new Map();
+    httpServer.on('request', async (req, res) => {
+        const url = new URL(`http://localhost${req.url}`);
+        if (url.pathname.startsWith('/mcp'))
+            await handleStreamable(mcpServer, req, res, streamableSessions);
+        else
+            await handleSSE(mcpServer, req, res, url, sseSessions);
+    });
+    const url = httpAddressToString(httpServer.address());
+    const message = [
+        `Listening on ${url}`,
+        'Put this in your client config:',
+        JSON.stringify({
+            'mcpServers': {
+                'playwright': {
+                    'url': `${url}/sse`
+                }
+            }
+        }, undefined, 2),
+        'If your client supports streamable HTTP, you can use the /mcp endpoint instead.',
+    ].join('\n');
+    // eslint-disable-next-line no-console
+    console.error(message);
+}
+export function httpAddressToString(address) {
+    assert(address, 'Could not bind server socket');
+    if (typeof address === 'string')
+        return address;
+    const resolvedPort = address.port;
+    let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
+    if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')
+        resolvedHost = 'localhost';
+    return `http://${resolvedHost}:${resolvedPort}`;
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@darbotlabs/darbot-browser-mcp",
+  "version": "0.1.0",
+  "description": "🤖 Your Autonomous Browser Companion - 29 AI-driven browser tools with work profile support",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/darbotlabs/darbot-browser-mcp.git"
+  },
+  "homepage": "https://github.com/darbotlabs/darbot-browser-mcp",
+  "engines": {
+    "node": ">=18"
+  },
+  "author": {
+    "name": "Microsoft Corporation"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsc",
+    "lint": "npm run update-readme && eslint . && tsc --noEmit",
+    "update-readme": "node utils/update-readme.js",
+    "watch": "tsc --watch",
+    "test": "npx @playwright/test",
+    "test:msedge": "npx @playwright/test --project=msedge",
+    "run-server": "node cli.js",
+    "run-darbot": "node cli.js",
+    "clean": "rmdir /s /q lib 2>nul || echo Clean completed",
+    "npm-publish": "npm run clean && npm run build && npm run test && npm publish"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "commander": "^13.1.0",
+    "debug": "^4.4.1",
+    "mime": "^4.0.7",
+    "playwright": "1.55.0-alpha-1752540053000",
+    "playwright-core": "1.55.0-alpha-1752540053000",
+    "ws": "^8.18.1",
+    "zod-to-json-schema": "^3.24.4"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.19.0",
+    "@playwright/test": "1.55.0-alpha-1752540053000",
+    "@stylistic/eslint-plugin": "^3.0.1",
+    "@types/chrome": "^0.0.315",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^22.13.10",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
+    "@typescript-eslint/utils": "^8.26.1",
+    "eslint": "^9.19.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-notice": "^1.0.0",
+    "typescript": "^5.8.2"
+  },
+  "bin": {
+    "darbot-browser-mcp": "cli.js"
+  }
+}