Merge pull request #57 from angiejones/feat/safari-support

feat: add Safari browser support

Author: angiejones

README.md

@@ -28,6 +28,12 @@ A Model Context Protocol (MCP) server implementation for Selenium WebDriver, ena
 - Chrome
 - Firefox
 - MS Edge
+- Safari (macOS only)
+
+> **Note:** Safari requires macOS with `safaridriver`, which is included with Safari.
+> Run `sudo safaridriver --enable` once, then enable "Allow Remote Automation"
+> in Safari → Settings → Developer. Safari does not support headless mode or
+> custom browser arguments.
 
 ## Use with Goose
 
@@ -117,7 +123,7 @@ Launches a browser session.
 **Parameters:**
 - `browser` (required): Browser to launch
   - Type: string
-  - Enum: ["chrome", "firefox"]
+  - Enum: ["chrome", "firefox", "edge", "safari"]
 - `options`: Browser configuration options
   - Type: object
   - Properties:

src/lib/server.js

@@ -8,6 +8,7 @@ const { Builder, By, Key, until, Actions } = pkg;
 import { Options as ChromeOptions } from 'selenium-webdriver/chrome.js';
 import { Options as FirefoxOptions } from 'selenium-webdriver/firefox.js';
 import { Options as EdgeOptions } from 'selenium-webdriver/edge.js';
+import { Options as SafariOptions } from 'selenium-webdriver/safari.js';
 
 
 // Create an MCP server
@@ -60,13 +61,14 @@ server.tool(
     "start_browser",
     "launches browser",
     {
-        browser: z.enum(["chrome", "firefox", "edge"]).describe("Browser to launch (chrome or firefox or microsoft edge)"),
+        browser: z.enum(["chrome", "firefox", "edge", "safari"]).describe("Browser to launch (chrome, firefox, edge, or safari)"),
         options: browserOptionsSchema
     },
     async ({ browser, options = {} }) => {
         try {
             let builder = new Builder();
             let driver;
+            let warnings = [];
             switch (browser) {
                 case 'chrome': {
                     const chromeOptions = new ChromeOptions();
@@ -110,6 +112,20 @@ server.tool(
                         .build();
                     break;
                 }
+                case 'safari': {
+                    const safariOptions = new SafariOptions();
+                    if (options.headless) {
+                        warnings.push('Safari does not support headless mode — launching with visible window.');
+                    }
+                    if (options.arguments?.length) {
+                        warnings.push('Safari does not support custom arguments — ignoring.');
+                    }
+                    driver = await builder
+                        .forBrowser('safari')
+                        .setSafariOptions(safariOptions)
+                        .build();
+                    break;
+                }
                 default: {
                     throw new Error(`Unsupported browser: ${browser}`);
                 }
@@ -118,8 +134,13 @@ server.tool(
             state.drivers.set(sessionId, driver);
             state.currentSession = sessionId;
 
+            let message = `Browser started with session_id: ${sessionId}`;
+            if (warnings.length > 0) {
+                message += `\nWarnings: ${warnings.join(' ')}`;
+            }
+
             return {
-                content: [{ type: 'text', text: `Browser started with session_id: ${sessionId}` }]
+                content: [{ type: 'text', text: message }]
             };
         } catch (e) {
             return {

test/safari.test.mjs

@@ -0,0 +1,51 @@
+/**
+ * Safari browser support tests.
+ *
+ * Integration tests require macOS with:
+ *   sudo safaridriver --enable
+ *   SAFARI_AVAILABLE=1 npm test
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { McpClient, getResponseText } from './mcp-client.mjs';
+
+const safariAvailable = process.platform === 'darwin' && process.env.SAFARI_AVAILABLE === '1';
+
+describe('Safari Browser Support', () => {
+    let client;
+    let tools;
+
+    before(async () => {
+        client = new McpClient();
+        await client.start();
+        tools = await client.listTools();
+    });
+
+    after(async () => {
+        try { await client.callTool('close_session'); } catch { /* ignore */ }
+        await client.stop();
+    });
+
+    it('should include "safari" in the start_browser browser enum', () => {
+        const startBrowser = tools.find(t => t.name === 'start_browser');
+        assert.ok(startBrowser, 'start_browser tool should exist');
+        const browserEnum = startBrowser.inputSchema.properties.browser.enum;
+        assert.ok(browserEnum.includes('safari'),
+            `Expected "safari" in enum, got: ${JSON.stringify(browserEnum)}`);
+    });
+
+    it('should surface warnings for unsupported options', { skip: !safariAvailable && 'safaridriver not available' }, async () => {
+        const result = await client.callTool('start_browser', {
+            browser: 'safari',
+            options: { headless: true, arguments: ['--some-flag'] },
+        });
+        const text = getResponseText(result);
+        assert.ok(!result.isError, `Expected success, got error: ${text}`);
+        assert.ok(text.includes('Browser started'), `Expected browser to start, got: ${text}`);
+        assert.ok(text.includes('does not support headless'),
+            `Expected headless warning in response, got: ${text}`);
+        assert.ok(text.includes('does not support custom arguments'),
+            `Expected arguments warning in response, got: ${text}`);
+    });
+});