mcpbrowser 0.2.19 → 0.2.22

package/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: MCP Server Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    
+    - name: Install dependencies
+      run: npm ci
+    
+    - name: Run MCP server tests
+      run: npm run test:mcp
+    
+    - name: Run all tests
+      run: npm test

package/README.md

@@ -38,7 +38,7 @@ Add to your `mcp.json`:
   "type": "stdio",
   "command": "npx",
   "args": ["-y", "mcpbrowser@latest"],
-  "description": "Fetches authenticated web pages using your Chrome session"
+  "description": "Use AUTOMATICALLY on 401/403 errors, login pages, SSO prompts, anti-bot blocks, OR when you think loading via real browser would be beneficial (JavaScript-heavy sites, dynamic content, SPAs). First domain request: ask user confirmation (browser opens for auth). Subsequent same-domain: use automatically (session preserved). Returns HTML from authenticated Chrome session. Handles Microsoft, GitHub, AWS, Google, corporate sites."
 }
 ```
 
@@ -102,7 +102,7 @@ Add this entry to your `mcp.json` file under the `"servers"` section:
 	"type": "stdio",
 	"command": "node",
 	"args": ["<PATH_TO_MCPBROWSER>/src/mcp-browser.js"],
-	"description": "**USE THIS AUTOMATICALLY** when you encounter ANY authentication/authorization barrier: 401/403 errors, login redirects, 'fetch denied', SSO prompts, or web pages requiring sign-in. Fetches web content using the user's authenticated Chrome session (works for ANY site: Microsoft, GitHub, AWS, Google, corporate intranets, etc.). IMPORTANT: Tool waits automatically for web pages to fetch (up to 60s default, handles auth redirects, waits for network idle). Do NOT retry or give up if you think web page is loading - trust the tool's timeout. Do NOT ask permission - use immediately when auth is required."
+	"description": "Use AUTOMATICALLY on 401/403 errors, login pages, SSO prompts, anti-bot blocks, OR when you think loading via real browser would be beneficial (JavaScript-heavy sites, dynamic content, SPAs). First domain request: ask user confirmation (browser opens for auth). Subsequent same-domain: use automatically (session preserved). Returns HTML from authenticated Chrome session. Handles Microsoft, GitHub, AWS, Google, corporate sites."
 }
 ```
 

package/extension/package.json

@@ -2,7 +2,7 @@
   "name": "mcpbrowser",
   "displayName": "MCP Browser",
   "description": "Lightweight MCP server-extension that allows Copilot to fetch protected web pages you can authenticate to via browser - handles login, SSO, and anti-crawler restrictions. Should be used when standard fetch_webpage fails",
-  "version": "0.2.19",
+  "version": "0.2.22",
   "publisher": "cherchyk",
   "icon": "icon.png",
   "engines": {

package/extension/src/extension.js

@@ -92,7 +92,7 @@ async function configureMcpBrowser() {
             type: "stdio",
             command: "npx",
             args: ["-y", "mcpbrowser@latest"],
-            description: "Use AUTOMATICALLY on 401/403 errors, login pages, SSO prompts, or anti-bot blocks. First domain request: ask user confirmation (browser opens for auth). Subsequent same-domain: use automatically (session preserved). Returns HTML from authenticated Chrome session. Handles Microsoft, GitHub, AWS, Google, corporate sites."
+            description: "Use AUTOMATICALLY on 401/403 errors, login pages, SSO prompts, anti-bot blocks, OR when you think loading via real browser would be beneficial (JavaScript-heavy sites, dynamic content, SPAs). First domain request: ask user confirmation (browser opens for auth). Subsequent same-domain: use automatically (session preserved). Returns HTML from authenticated Chrome session. Handles Microsoft, GitHub, AWS, Google, corporate sites."
         };
 
         // Write back to file with pretty formatting

package/package.json

@@ -1,5 +1,5 @@
 {  "name": "mcpbrowser",
-  "version": "0.2.19",
+  "version": "0.2.22",
   "mcpName": "io.github.cherchyk/browser",
   "type": "module",
   "description": "MCP server that fetches protected web pages using Chrome DevTools Protocol",
@@ -8,7 +8,9 @@
     "mcpbrowser": "src/mcp-browser.js"
   },
   "scripts": {
-    "mcp": "node src/mcp-browser.js"
+    "mcp": "node src/mcp-browser.js",
+    "test": "node --test tests/*.test.js",
+    "test:mcp": "node --test tests/mcp-server.test.js"
   },
   "keywords": [
     "mcp",

package/server.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/cherchyk/MCPBrowser",
     "source": "github"
   },
-  "version": "0.2.19",
+  "version": "0.2.22",
   "packages": [
     {
       "registryType": "npm",

package/src/mcp-browser.js

@@ -393,7 +393,7 @@ function prepareHtml(html, baseUrl) {
 }
 
 async function main() {
-  const server = new Server({ name: "MCPBrowser", version: "0.2.19" }, { capabilities: { tools: {} } });
+  const server = new Server({ name: "MCPBrowser", version: "0.2.22" }, { capabilities: { tools: {} } });
 
   const tools = [
     {
@@ -455,10 +455,8 @@ async function main() {
 // Export for testing
 export { fetchPage, getBrowser, prepareHtml };
 
-// Only run main if this is the entry point
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main().catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });
-}
+// Run the MCP server
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/test-mcp.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+
+const mcpProcess = spawn('node', ['src/mcp-browser.js'], {
+  cwd: process.cwd(),
+  stdio: ['pipe', 'pipe', 'inherit']
+});
+
+// Send initialize request
+const initRequest = {
+  jsonrpc: '2.0',
+  id: 1,
+  method: 'initialize',
+  params: {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'test', version: '1.0' }
+  }
+};
+
+console.log('Sending initialize request...');
+mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
+
+// Send list tools request
+const listToolsRequest = {
+  jsonrpc: '2.0',
+  id: 2,
+  method: 'tools/list',
+  params: {}
+};
+
+setTimeout(() => {
+  console.log('Sending tools/list request...');
+  mcpProcess.stdin.write(JSON.stringify(listToolsRequest) + '\n');
+}, 1000);
+
+let responseBuffer = '';
+mcpProcess.stdout.on('data', (data) => {
+  responseBuffer += data.toString();
+  const lines = responseBuffer.split('\n');
+  responseBuffer = lines.pop() || '';
+  
+  lines.forEach(line => {
+    if (line.trim()) {
+      try {
+        const response = JSON.parse(line);
+        console.log('Response:', JSON.stringify(response, null, 2));
+      } catch (e) {
+        console.log('Raw output:', line);
+      }
+    }
+  });
+});
+
+mcpProcess.on('error', (err) => {
+  console.error('Error:', err);
+});
+
+setTimeout(() => {
+  console.log('Closing...');
+  mcpProcess.kill();
+  process.exit(0);
+}, 3000);

package/tests/mcp-server.test.js

@@ -0,0 +1,154 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('MCP Server', () => {
+  it('should start and respond to initialize request', async () => {
+    const mcpProcess = spawn('node', [join(__dirname, '..', 'src', 'mcp-browser.js')], {
+      stdio: ['pipe', 'pipe', 'inherit']
+    });
+
+    try {
+      const initRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' }
+        }
+      };
+
+      const response = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Server did not respond to initialize request within 5 seconds'));
+        }, 5000);
+
+        let buffer = '';
+        mcpProcess.stdout.on('data', (data) => {
+          buffer += data.toString();
+          const lines = buffer.split('\n');
+          
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const parsed = JSON.parse(line);
+                if (parsed.id === 1) {
+                  clearTimeout(timeout);
+                  resolve(parsed);
+                  return;
+                }
+              } catch (e) {
+                // Not JSON, continue
+              }
+            }
+          }
+        });
+
+        mcpProcess.on('error', (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+
+        mcpProcess.on('exit', (code) => {
+          clearTimeout(timeout);
+          reject(new Error(`Server exited with code ${code} before responding`));
+        });
+
+        mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
+      });
+
+      assert.ok(response.result, 'Initialize response should have result');
+      assert.equal(response.result.protocolVersion, '2024-11-05', 'Protocol version should match');
+      assert.ok(response.result.serverInfo, 'Server info should be present');
+      assert.equal(response.result.serverInfo.name, 'MCPBrowser', 'Server name should be MCPBrowser');
+    } finally {
+      mcpProcess.kill();
+    }
+  });
+
+  it('should respond to tools/list request', async () => {
+    const mcpProcess = spawn('node', [join(__dirname, '..', 'src', 'mcp-browser.js')], {
+      stdio: ['pipe', 'pipe', 'inherit']
+    });
+
+    try {
+      // First initialize
+      const initRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' }
+        }
+      };
+
+      mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
+
+      // Wait a bit for initialization
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Then request tools list
+      const toolsRequest = {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/list',
+        params: {}
+      };
+
+      const response = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Server did not respond to tools/list request within 5 seconds'));
+        }, 5000);
+
+        let buffer = '';
+        mcpProcess.stdout.on('data', (data) => {
+          buffer += data.toString();
+          const lines = buffer.split('\n');
+          
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const parsed = JSON.parse(line);
+                if (parsed.id === 2) {
+                  clearTimeout(timeout);
+                  resolve(parsed);
+                  return;
+                }
+              } catch (e) {
+                // Not JSON, continue
+              }
+            }
+          }
+        });
+
+        mcpProcess.on('error', (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+
+        mcpProcess.stdin.write(JSON.stringify(toolsRequest) + '\n');
+      });
+
+      assert.ok(response.result, 'Tools/list response should have result');
+      assert.ok(response.result.tools, 'Result should have tools array');
+      assert.ok(Array.isArray(response.result.tools), 'Tools should be an array');
+      assert.ok(response.result.tools.length > 0, 'Should have at least one tool');
+      
+      const fetchTool = response.result.tools.find(t => t.name === 'fetch_webpage_protected');
+      assert.ok(fetchTool, 'Should have fetch_webpage_protected tool');
+      assert.ok(fetchTool.description, 'Tool should have description');
+      assert.ok(fetchTool.inputSchema, 'Tool should have input schema');
+    } finally {
+      mcpProcess.kill();
+    }
+  });
+});