lighthouse-mcp 0.1.15 → 0.1.16

package/README.md

@@ -101,7 +101,7 @@ Run a comprehensive Lighthouse audit on a URL.
 **Parameters:**
 - `url` (required): The URL to audit
 - `categories` (optional): Array of categories to audit (defaults to all)
-  - Options: "performance", "accessibility", "best-practices", "seo", "pwa"
+  - Options: "performance", "accessibility", "best-practices", "seo"
 - `device` (optional): Device to emulate (defaults to "mobile")
   - Options: "mobile", "desktop"
 - `throttling` (optional): Whether to apply network throttling (defaults to true)
@@ -145,10 +145,16 @@ Claude will use the `get_performance_score` tool to analyze the website and retu
 
 ## Requirements
 
-- Node.js 16+
+- Node.js 22.19+
 - Chrome/Chromium browser (for Lighthouse)
 
 ## Endorsements
 <a href="https://glama.ai/mcp/servers/@priyankark/lighthouse-mcp">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/@priyankark/lighthouse-mcp/badge" />
 </a>
+
+## Security
+
+Chrome runs with its sandbox enabled. Localhost, IPv4 loopback, and IPv6 loopback remain supported by default. Private, link-local, cloud metadata, and other non-public destinations are blocked, including requests made by redirects and page resources. Connections use validated IP addresses to prevent DNS rebinding. Because loopback access is intentional, audit only pages you trust to access services on your own machine. For hostile sites, use a separate environment with network isolation.
+
+Audits are limited to one at a time and time out after 120 seconds. Chrome and the audit proxy are cleaned up after success or failure.

package/build/index.js

@@ -7,123 +7,15 @@ import * as chromeLauncher from 'chrome-launcher';
 import os from 'os';
 import fs from 'fs';
 import path from 'path';
-import dns from 'dns/promises';
-import net from 'net';
-// Workaround for modelcontextprotocol/typescript-sdk#1380
-// In some Zod runtimes, the method literal is stored under `_def.values[0]`
-// instead of `_def.value` / `.value`, causing "Schema method literal must be a string"
-// during Server initialization. This patches setRequestHandler to handle both cases.
-const originalSetRequestHandler = Server.prototype.setRequestHandler;
-Server.prototype.setRequestHandler = function patchedSetRequestHandler(requestSchema, handler) {
-    try {
-        return originalSetRequestHandler.call(this, requestSchema, handler);
-    }
-    catch (err) {
-        if (err?.message !== 'Schema method literal must be a string')
-            throw err;
-        // Attempt to fix the schema by copying values[0] to value
-        try {
-            const shape = requestSchema?.shape ?? requestSchema?._def?.shape?.();
-            const methodSchema = shape?.method;
-            const def = methodSchema?._def;
-            const maybeValue = Array.isArray(def?.values) ? def.values[0] : undefined;
-            if (typeof maybeValue === 'string') {
-                if (def && def.value === undefined)
-                    def.value = maybeValue;
-                if (methodSchema && methodSchema.value === undefined)
-                    methodSchema.value = maybeValue;
-            }
-        }
-        catch {
-            // If patching fails, rethrow the original error
-        }
-        return originalSetRequestHandler.call(this, requestSchema, handler);
-    }
-};
-// ---------------------------------------------------------------------------
-// SSRF protection — validate URLs before passing to Lighthouse
-// Allows localhost/loopback (needed for local dev servers) but blocks
-// cloud metadata endpoints, RFC 1918 private ranges, and link-local IPs.
-// ---------------------------------------------------------------------------
-const BLOCKED_IP_RANGES = [
-    // RFC 1918 private networks
-    { prefix: '10.', mask: null },
-    { prefix: '172.', mask: (ip) => { const b = parseInt(ip.split('.')[1], 10); return b >= 16 && b <= 31; } },
-    { prefix: '192.168.', mask: null },
-    // Link-local (includes AWS metadata 169.254.169.254)
-    { prefix: '169.254.', mask: null },
-];
-const BLOCKED_HOSTNAMES = [
-    'metadata.google.internal',
-    'metadata.goog',
-];
-function isBlockedIP(ip) {
-    for (const range of BLOCKED_IP_RANGES) {
-        if (ip.startsWith(range.prefix)) {
-            if (range.mask === null || range.mask(ip))
-                return true;
-        }
-    }
-    return false;
-}
-function isLoopback(ip) {
-    if (ip === '::1')
-        return true;
-    if (ip.startsWith('127.'))
-        return true;
-    return false;
-}
-async function validateUrl(url) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        throw new McpError(ErrorCode.InvalidParams, `Invalid URL: ${url}`);
-    }
-    // Only allow http and https schemes
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new McpError(ErrorCode.InvalidParams, `Unsupported URL scheme "${parsed.protocol}" — only http: and https: are allowed`);
-    }
-    const hostname = parsed.hostname;
-    // Block known cloud metadata hostnames
-    if (BLOCKED_HOSTNAMES.includes(hostname.toLowerCase())) {
-        throw new McpError(ErrorCode.InvalidParams, `URL hostname "${hostname}" is blocked (cloud metadata endpoint)`);
-    }
-    // If the hostname is an IP literal, validate it directly
-    if (net.isIP(hostname)) {
-        if (isLoopback(hostname))
-            return; // allow localhost
-        if (isBlockedIP(hostname)) {
-            throw new McpError(ErrorCode.InvalidParams, `URL resolves to a blocked internal IP address (${hostname})`);
-        }
-        return;
-    }
-    // Resolve the hostname and check every returned address
-    let addresses;
-    try {
-        const results = await dns.resolve4(hostname);
-        addresses = results;
-    }
-    catch {
-        // If DNS resolution fails, let Lighthouse handle the error naturally
-        return;
-    }
-    for (const ip of addresses) {
-        if (isLoopback(ip))
-            continue; // allow localhost
-        if (isBlockedIP(ip)) {
-            throw new McpError(ErrorCode.InvalidParams, `URL hostname "${hostname}" resolves to blocked internal IP address (${ip})`);
-        }
-    }
-}
+import { createAuditProxy, parseUrl, resolveTarget } from './network.js';
 const isValidAuditArgs = (args) => {
     return (typeof args === 'object' &&
         args !== null &&
         typeof args.url === 'string' &&
         (args.categories === undefined ||
             (Array.isArray(args.categories) &&
-                args.categories.every((cat) => typeof cat === 'string'))) &&
+                args.categories.length > 0 && args.categories.length <= 4 &&
+                args.categories.every((cat) => ['performance', 'accessibility', 'best-practices', 'seo'].includes(cat)))) &&
         (args.device === undefined ||
             args.device === 'mobile' ||
             args.device === 'desktop') &&
@@ -131,9 +23,10 @@ const isValidAuditArgs = (args) => {
 };
 class LighthouseServer {
     constructor() {
+        this.auditRunning = false;
         this.server = new Server({
             name: 'lighthouse-mcp',
-            version: '0.1.0',
+            version: '0.1.16',
         }, {
             capabilities: {
                 tools: {},
@@ -169,7 +62,6 @@ class LighthouseServer {
                                         'accessibility',
                                         'best-practices',
                                         'seo',
-                                        'pwa',
                                     ],
                                 },
                                 description: 'Categories to audit (defaults to all)',
@@ -223,9 +115,17 @@ class LighthouseServer {
         if (!isValidAuditArgs(args)) {
             throw new McpError(ErrorCode.InvalidParams, 'Invalid audit arguments');
         }
-        // SSRF protection: validate the URL before launching Chrome
-        await validateUrl(args.url);
+        if (this.auditRunning)
+            throw new McpError(ErrorCode.InvalidRequest, 'An audit is already running');
+        this.auditRunning = true;
+        let chrome;
+        let proxy;
+        let timer;
         try {
+            const allowLoopback = true;
+            const url = parseUrl(args.url);
+            await resolveTarget(url.hostname, allowLoopback);
+            proxy = await createAuditProxy(allowLoopback);
             // Ensure temp directory exists and is writable (fixes #19 - Windows EPERM)
             // On Windows, os.tmpdir() reads TEMP -> TMP -> USERPROFILE, so we verify
             // the resolved path is usable before launching Chrome.
@@ -237,7 +137,7 @@ class LighthouseServer {
                 // If the default temp dir isn't writable, create a fallback in the user's home
                 const fallbackTmp = path.join(os.homedir(), '.lighthouse-tmp');
                 if (!fs.existsSync(fallbackTmp)) {
-                    fs.mkdirSync(fallbackTmp, { recursive: true });
+                    fs.mkdirSync(fallbackTmp, { recursive: true, mode: 0o700 });
                 }
                 process.env.TEMP = fallbackTmp;
                 process.env.TMP = fallbackTmp;
@@ -245,12 +145,14 @@ class LighthouseServer {
             }
             // Explicitly pass process.env so MCP-configured env vars (TEMP, TMP, TMPDIR)
             // propagate to the Chrome child process on all platforms.
-            const chrome = await chromeLauncher.launch({
-                chromeFlags: ['--headless', '--no-sandbox'],
+            chrome = await chromeLauncher.launch({
+                chromeFlags: ['--headless', `--proxy-server=http://127.0.0.1:${proxy.port}`,
+                    '--proxy-bypass-list=<-loopback>', '--disable-quic',
+                    '--force-webrtc-ip-handling-policy=disable_non_proxied_udp'],
                 envVars: process.env,
             });
             const options = {
-                logLevel: 'info',
+                logLevel: 'error',
                 output: 'json',
                 onlyCategories: args.categories,
                 port: chrome.port,
@@ -272,8 +174,12 @@ class LighthouseServer {
                     cpuSlowdownMultiplier: 1,
                 },
             };
-            const runnerResult = await lighthouse(args.url, options);
-            await chrome.kill();
+            const runnerResult = await Promise.race([
+                lighthouse(args.url, options),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('Audit timed out after 120 seconds')), 120000);
+                }),
+            ]);
             if (!runnerResult) {
                 throw new McpError(ErrorCode.InternalError, 'Failed to run Lighthouse audit');
             }
@@ -342,6 +248,21 @@ class LighthouseServer {
                 isError: true,
             };
         }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            try {
+                await chrome?.kill();
+            }
+            finally {
+                try {
+                    await proxy?.close();
+                }
+                finally {
+                    this.auditRunning = false;
+                }
+            }
+        }
     }
     async handleGetPerformanceScore(args) {
         if (!isValidAuditArgs(args)) {
@@ -356,6 +277,8 @@ class LighthouseServer {
                 throttling: true,
             };
             const result = await this.handleRunAudit(auditArgs);
+            if (result.isError)
+                return result;
             // Extract just the performance data
             const resultData = JSON.parse(result.content[0].text);
             const performanceData = {

package/build/network.d.ts

@@ -0,0 +1,11 @@
+import dns from 'node:dns/promises';
+export declare function isAllowedAddress(address: string, allowLoopback?: boolean): boolean;
+export declare function parseUrl(input: string): URL;
+export declare function resolveTarget(host: string, allowLoopback?: boolean, lookup?: typeof dns.lookup): Promise<{
+    address: string;
+    family: number;
+}>;
+export declare function createAuditProxy(allowLoopback?: boolean): Promise<{
+    port: number;
+    close: () => Promise<void>;
+}>;

package/build/network.js

@@ -0,0 +1,107 @@
+import dns from 'node:dns/promises';
+import http from 'node:http';
+import net from 'node:net';
+import ipaddr from 'ipaddr.js';
+export function isAllowedAddress(address, allowLoopback = true) {
+    try {
+        const parsed = ipaddr.process(address);
+        return parsed.range() === 'unicast' || (allowLoopback && parsed.range() === 'loopback');
+    }
+    catch {
+        return false;
+    }
+}
+export function parseUrl(input) {
+    const url = new URL(input);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+        throw new Error('Only HTTP(S) URLs without embedded credentials are allowed');
+    }
+    return url;
+}
+export async function resolveTarget(host, allowLoopback = true, lookup = dns.lookup) {
+    const hostname = host.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
+    if (['metadata.google.internal', 'metadata.goog'].includes(hostname)) {
+        throw new Error('Cloud metadata endpoints are blocked');
+    }
+    const addresses = net.isIP(hostname)
+        ? [{ address: hostname, family: net.isIP(hostname) }]
+        : await lookup(hostname, { all: true, verbatim: true });
+    if (!addresses.length || addresses.some(a => !isAllowedAddress(a.address, allowLoopback))) {
+        throw new Error('Non-public network addresses are blocked');
+    }
+    return addresses[0];
+}
+// Resolve and validate each connection, then connect to that exact IP. Chrome
+// must use this proxy for redirects and subresources too (no loopback bypass).
+export async function createAuditProxy(allowLoopback = true) {
+    const sockets = new Set();
+    const track = (socket) => {
+        sockets.add(socket);
+        socket.setTimeout(120000, () => socket.destroy());
+        socket.once('close', () => sockets.delete(socket));
+        return socket;
+    };
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = parseUrl(req.url || '');
+            if (url.protocol !== 'http:')
+                throw new Error('Use CONNECT for HTTPS');
+            const target = await resolveTarget(url.hostname, allowLoopback);
+            if (res.destroyed)
+                return;
+            const headers = { ...req.headers, host: url.host };
+            delete headers['proxy-authorization'];
+            delete headers['proxy-connection'];
+            const upstream = http.request({
+                hostname: target.address, family: target.family,
+                port: url.port || 80, path: url.pathname + url.search,
+                method: req.method, headers, agent: false,
+            }, response => { res.writeHead(response.statusCode || 502, response.headers); response.pipe(res); });
+            upstream.on('socket', track);
+            upstream.on('error', () => { if (!res.headersSent)
+                res.writeHead(502); res.end(); });
+            res.on('close', () => upstream.destroy());
+            req.pipe(upstream);
+        }
+        catch {
+            res.writeHead(403);
+            res.end('Destination blocked');
+        }
+    });
+    server.on('connection', track);
+    server.on('connect', async (req, client, head) => {
+        try {
+            const url = parseUrl(`https://${req.url}`);
+            const target = await resolveTarget(url.hostname, allowLoopback);
+            if (client.destroyed)
+                return;
+            const upstream = track(net.connect({ host: target.address, family: target.family, port: Number(url.port || 443) }));
+            upstream.on('error', () => client.destroy());
+            client.on('error', () => upstream.destroy());
+            client.on('close', () => upstream.destroy());
+            upstream.once('connect', () => {
+                client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+                upstream.write(head);
+                client.pipe(upstream);
+                upstream.pipe(client);
+            });
+        }
+        catch {
+            client.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+        }
+    });
+    server.on('clientError', (_error, socket) => socket.destroy());
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    return {
+        port: address.port,
+        close: async () => {
+            for (const socket of sockets)
+                socket.destroy();
+            await new Promise(resolve => server.close(() => resolve()));
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse-mcp",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "MCP server for Google Lighthouse performance metrics",
   "type": "module",
   "main": "build/index.js",
@@ -15,8 +15,9 @@
     "build": "tsc && chmod +x build/index.js",
     "start": "node build/index.js",
     "dev": "tsc -w",
-    "prepublishOnly": "npm run build",
-    "update-server-json": "node -e \"const fs=require('fs');const pkg=JSON.parse(fs.readFileSync('package.json'));const server=JSON.parse(fs.readFileSync('server.json'));server.version=pkg.version;server.packages[0].version=pkg.version;fs.writeFileSync('server.json',JSON.stringify(server,null,2));\""
+    "prepublishOnly": "npm test",
+    "update-server-json": "node -e \"const fs=require('fs');const pkg=JSON.parse(fs.readFileSync('package.json'));const server=JSON.parse(fs.readFileSync('server.json'));server.version=pkg.version;server.packages[0].version=pkg.version;fs.writeFileSync('server.json',JSON.stringify(server,null,2));\"",
+    "test": "npm run build && node --test test/*.test.mjs"
   },
   "keywords": [
     "lighthouse",
@@ -32,23 +33,19 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "https://github.com/priyankark/lighthouse-mcp.git"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "chrome-launcher": "^0.15.2",
-    "lighthouse": "^12.5.1"
-  },
-  "overrides": {
-    "basic-ftp": ">=5.3.0",
-    "lodash-es": ">=4.18.1",
-    "path-to-regexp": ">=8.4.0",
-    "brace-expansion": ">=5.0.5",
-    "hono": ">=4.12.14",
-    "@hono/node-server": ">=1.19.13"
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "chrome-launcher": "^1.2.1",
+    "ipaddr.js": "^2.5.0",
+    "lighthouse": "^13.4.1"
   },
   "devDependencies": {
     "@types/node": "^20.4.5",
     "typescript": "^5.1.6"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   }
 }