mcpbrowser 0.2.19 → 0.2.21

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/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.21",
   "publisher": "cherchyk",
   "icon": "icon.png",
   "engines": {

package/package.json

@@ -1,5 +1,5 @@
 {  "name": "mcpbrowser",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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.21",
   "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.21" }, { 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();
+    }
+  });
+});