mcp-optimizer 0.0.1-alpha.1

package/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish package
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch: {}
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          if [ -z "$NPM_TOKEN" ]; then echo "NPM_TOKEN is not set"; exit 1; fi
+          echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+          npm publish --access public --tag beta

package/README.md

@@ -0,0 +1,31 @@
+# MCP Optimizer
+
+A minimal scaffold that runs Lighthouse to produce performance reports. The project includes a placeholder fixer that can be extended to integrate an LLM for automatic code fixes.
+
+Quick start
+
+1. Install runtime dependencies:
+
+```bash
+npm install lighthouse chrome-launcher
+```
+
+2. Start the server (after building or in dev):
+
+```bash
+npm run build
+npm start
+# or for development:
+npm run dev
+```
+
+3. Run an audit:
+
+```bash
+curl -X POST http://localhost:3000/audit -H "Content-Type: application/json" -d '{"url":"https://example.com"}'
+```
+
+Notes
+- `src/runner/lighthouseRunner.ts` — runs Lighthouse via `chrome-launcher` and returns the LHR.
+- `src/fix/fixer.ts` — placeholder to convert LHR into actionable fixes; integrate LLM (e.g., via `@modelcontextprotocol/sdk`) here.
+

package/bin/mcp-optimizer.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// Lightweight CLI wrapper for the MCP Optimizer package.
+// This file is intentionally small so `npx mcp-optimizer` can run it.
+
+try {
+  // Require built output. When installed via npm the package root
+  // will contain `dist/index.js` after `npm pack` / `npm publish`.
+  require('../dist/index.js');
+} catch (err) {
+  // Provide a helpful error for local development if the package
+  // hasn't been built yet.
+  console.error('Failed to start MCP Optimizer. Have you run `npm run build`?');
+  console.error(err && err.stack ? err.stack : String(err));
+  process.exit(1);
+}

package/dist/fix/fixer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFixFromReport = autoFixFromReport;
+async function autoFixFromReport(report, opts) {
+    const performance = report.lhr?.categories?.performance || null;
+    const audits = report.lhr?.audits || {};
+    let failures = null;
+    if (opts?.onlyFailures) {
+        failures = Object.fromEntries(Object.entries(audits).filter(([, v]) => {
+            const score = v && (v.score ?? v.scoreDisplayMode === 'notApplicable' ? 1 : v.score);
+            return typeof score === 'number' ? score < 1 : false;
+        }));
+    }
+    return {
+        suggestion: 'Review performance opportunities and apply targeted fixes',
+        performance,
+        failures,
+    };
+}

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcpServer_1 = require("./mcpServer");
+(async () => {
+    try {
+        await (0, mcpServer_1.startMcpServer)();
+    }
+    catch (err) {
+        console.error('Failed to start services:', err);
+        process.exit(1);
+    }
+})();

package/dist/mcpServer.js

@@ -0,0 +1,351 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LighthouseMcpServer = void 0;
+exports.startMcpServer = startMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const lighthouseRunner_1 = require("./runner/lighthouseRunner");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const http = __importStar(require("http"));
+const fixer_1 = require("./fix/fixer");
+class LighthouseMcpServer {
+    constructor() {
+        this.reports = new Map();
+        this.server = new mcp_js_1.McpServer({ name: "Lighthouse MCP Server", version: "0.1.0" });
+        this.registerTools();
+    }
+    /**
+     * Run an audit and store the report. Returns stored record.
+     */
+    async runAudit(options) {
+        const { url, categories, formFactor } = options;
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const opts = {};
+        if (categories && categories.length > 0)
+            opts.categories = categories;
+        if (formFactor === 'mobile')
+            opts.emulateMobile = true;
+        const runnerResult = await (0, lighthouseRunner_1.runLighthouseAudit)(url, opts);
+        const reportJson = runnerResult.report;
+        const lhr = runnerResult.lhr;
+        const reportObj = typeof reportJson === 'string' ? JSON.parse(reportJson) : reportJson;
+        const record = {
+            id,
+            url,
+            fetchedAt: new Date().toISOString(),
+            lhr,
+            report: reportObj
+        };
+        this.reports.set(id, record);
+        return record;
+    }
+    registerTools() {
+        this.server.tool("lighthouse_run_audit", "Run a Lighthouse audit against a URL and store the report", {
+            url: zod_1.z.string().describe("The URL to audit, including protocol (http:// or https://)"),
+            categories: zod_1.z.array(zod_1.z.string()).optional().describe("Optional Lighthouse categories to run, e.g. ['performance','accessibility']"),
+            formFactor: zod_1.z.enum(["mobile", "desktop"]).optional().describe("Emulated form factor")
+        }, async ({ url, categories, formFactor }) => {
+            const id = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+            try {
+                const opts = {};
+                if (categories && categories.length > 0)
+                    opts.categories = categories;
+                if (formFactor === 'mobile')
+                    opts.emulateMobile = true;
+                const runnerResult = await (0, lighthouseRunner_1.runLighthouseAudit)(url, opts);
+                const reportJson = runnerResult.report;
+                const lhr = runnerResult.lhr;
+                const reportObj = typeof reportJson === 'string' ? JSON.parse(reportJson) : reportJson;
+                this.reports.set(id, {
+                    id,
+                    url,
+                    fetchedAt: new Date().toISOString(),
+                    lhr,
+                    report: reportObj
+                });
+                const perf = lhr.categories?.performance?.score ?? null;
+                const accessibility = lhr.categories?.accessibility?.score ?? null;
+                const summary = {
+                    reportId: id,
+                    url,
+                    fetchedAt: new Date().toISOString(),
+                    performance: perf !== null ? Math.round(perf * 100) : undefined,
+                    accessibility: accessibility !== null ? Math.round(accessibility * 100) : undefined
+                };
+                // 返回所有信息，便于 HTTP 路由复用
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(summary, null, 2) },
+                        { type: "text", text: JSON.stringify(lhr, null, 2) },
+                        { type: "text", text: JSON.stringify(reportObj, null, 2) }
+                    ]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        { type: "text", text: `Lighthouse audit failed: ${error}` }
+                    ]
+                };
+            }
+        });
+        this.server.tool("lighthouse_get_report", "Retrieve a previously-run Lighthouse report by reportId", {
+            reportId: zod_1.z.string().describe("The report id returned by `lighthouse_run_audit`")
+        }, async ({ reportId }) => {
+            const record = this.reports.get(reportId);
+            if (!record) {
+                return {
+                    content: [
+                        { type: "text", text: `Report not found: ${reportId}` }
+                    ]
+                };
+            }
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(record.report, null, 2) }
+                ]
+            };
+        });
+        // 新增：从用户 Prompt 中识别 URL 并自动运行 Lighthouse 审计
+        this.server.tool("lighthouse_analyze_prompt", "Scan a text prompt for a URL, run Lighthouse, and return a summary", {
+            prompt: zod_1.z.string().describe("A text prompt that may contain a URL to analyze")
+        }, async ({ prompt }) => {
+            try {
+                const urlMatch = prompt.match(/https?:\/\/[^\s"'<>]+/i);
+                if (!urlMatch) {
+                    return {
+                        content: [{ type: "text", text: "No URL found in prompt." }]
+                    };
+                }
+                const url = urlMatch[0];
+                const result = await this.runAuditViaTool({ url });
+                let fix = null;
+                if (result && result.lhr) {
+                    fix = await (0, fixer_1.autoFixFromReport)({ lhr: result.lhr, report: JSON.stringify(result.report) });
+                }
+                const perf = result.lhr?.categories?.performance?.score ?? null;
+                const accessibility = result.lhr?.categories?.accessibility?.score ?? null;
+                const summary = {
+                    reportId: result.id,
+                    url: result.url,
+                    fetchedAt: result.fetchedAt,
+                    performance: perf !== null ? Math.round(perf * 100) : undefined,
+                    accessibility: accessibility !== null ? Math.round(accessibility * 100) : undefined
+                };
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(summary, null, 2) },
+                        { type: "text", text: JSON.stringify(result.lhr || {}, null, 2) },
+                        { type: "text", text: JSON.stringify(result.report || {}, null, 2) },
+                        { type: "text", text: JSON.stringify({ fix }, null, 2) }
+                    ]
+                };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error analyzing prompt: ${String(err)}` }] };
+            }
+        });
+    }
+    // 新增：暴露一个直接调用 MCP 工具的接口
+    async runAuditViaTool(params) {
+        // Some versions of the MCP SDK don't expose an `invokeTool` helper.
+        // Call the internal runner directly and return a shape similar to the
+        // tool's output so HTTP callers can use `result.summary` / `result.lhr`.
+        const record = await this.runAudit(params);
+        const perf = record.lhr?.categories?.performance?.score ?? null;
+        const accessibility = record.lhr?.categories?.accessibility?.score ?? null;
+        const summary = {
+            reportId: record.id,
+            url: record.url,
+            fetchedAt: record.fetchedAt,
+            performance: perf !== null ? Math.round(perf * 100) : undefined,
+            accessibility: accessibility !== null ? Math.round(accessibility * 100) : undefined
+        };
+        // return record plus a `summary` to match existing HTTP handler expectations
+        return { ...record, summary };
+    }
+    async connect(transport) {
+        await this.server.connect(transport);
+    }
+}
+exports.LighthouseMcpServer = LighthouseMcpServer;
+exports.default = LighthouseMcpServer;
+async function startMcpServer() {
+    // Run HTTP/SSE server
+    const port = Number(process.env.PORT || process.env.AUDIT_PORT || 5000);
+    const mcp = new LighthouseMcpServer();
+    let sseTransport = null;
+    const pendingPosts = [];
+    const { Readable, Writable } = await (async () => {
+        const mod = await Promise.resolve().then(() => __importStar(require('stream')));
+        return { Readable: mod.Readable, Writable: mod.Writable };
+    })();
+    function makeMockReq(body, url, headers) {
+        const r = new Readable({ read() { this.push(body); this.push(null); } });
+        r.method = 'POST';
+        r.url = url || '/sse';
+        r.headers = headers || { 'content-type': 'application/json' };
+        return r;
+    }
+    function makeMockRes() {
+        const w = new Writable({ write(chunk, _enc, cb) { cb(); } });
+        w.writeHead = (status, headers) => { w.statusCode = status; w._headers = headers; };
+        w.end = (data) => { if (data) {
+            try { /* consume */ }
+            catch (_) { }
+        } };
+        return w;
+    }
+    const server = http.createServer(async (req, res) => {
+        try {
+            if (req.method === 'GET' && req.url && req.url.startsWith('/sse')) {
+                // SSE handshake: set headers and create transport
+                // Ensure we send proper SSE headers so clients don't fallback to polling.
+                // Register the transport using '/sse' as the message POST path
+                sseTransport = new sse_js_1.SSEServerTransport('/sse', res);
+                try {
+                    await mcp.connect(sseTransport);
+                    console.info('SSE: new connection established');
+                }
+                catch (err) {
+                    console.error('SSE: failed to start transport:', err);
+                    // Ensure client receives an error
+                    try {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'failed to start sse transport' }));
+                    }
+                    catch (_) { }
+                    return;
+                }
+                // replay any pending POSTs that arrived before the GET
+                if (pendingPosts.length > 0) {
+                    console.info(`SSE: replaying ${pendingPosts.length} pending POST(s)`);
+                    for (const p of pendingPosts.splice(0)) {
+                        try {
+                            const mockReq = makeMockReq(p.body, p.url, p.headers);
+                            const mockRes = makeMockRes();
+                            // don't await to avoid blocking the handshake
+                            sseTransport.handlePostMessage(mockReq, mockRes).catch((err) => {
+                                console.error('SSE: replay handlePostMessage failed:', err);
+                            });
+                        }
+                        catch (err) {
+                            console.error('SSE: failed to replay pending POST:', err);
+                        }
+                    }
+                }
+                return;
+            }
+            if (req.method === 'POST' && req.url && (req.url === '/messages' || req.url.startsWith('/sse'))) {
+                console.info(`SSE: received POST to ${req.url}`);
+                if (!sseTransport) {
+                    // Buffer the POST body so it can be processed once the GET arrives.
+                    try {
+                        let body = '';
+                        for await (const chunk of req) {
+                            body += chunk;
+                        }
+                        console.info('SSE: POST received before GET; buffering');
+                        pendingPosts.push({ body, url: req.url, headers: req.headers });
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true }));
+                        return;
+                    }
+                    catch (e) {
+                        console.error('SSE: error reading POST body before GET:', e);
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: String(e) }));
+                        return;
+                    }
+                }
+                try {
+                    await sseTransport.handlePostMessage(req, res);
+                    return;
+                }
+                catch (err) {
+                    console.error('SSE: handlePostMessage failed:', err);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: String(err) }));
+                    return;
+                }
+            }
+            if (req.method === 'POST' && req.url === '/audit') {
+                let body = '';
+                for await (const chunk of req) {
+                    body += chunk;
+                }
+                const parsed = JSON.parse(body || '{}');
+                const url = parsed.url;
+                if (!url) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'missing url' }));
+                    return;
+                }
+                try {
+                    const result = await mcp.runAuditViaTool({ url, categories: parsed.categories, formFactor: parsed.formFactor });
+                    let fix = null;
+                    if (result && result.lhr) {
+                        fix = await (0, fixer_1.autoFixFromReport)({ lhr: result.lhr, report: JSON.stringify(result.report) });
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ summary: result.summary, fix, error: result.error }));
+                }
+                catch (err) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            // fallback
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ message: 'MCP Optimizer running — POST /audit { "url": "https://..." }' }));
+        }
+        catch (outerErr) {
+            // ensure no plain-text stdout noise
+            try {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: String(outerErr) }));
+            }
+            catch (_) {
+                // ignore
+            }
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.listen(port, () => resolve());
+        server.on('error', reject);
+    });
+}

package/dist/runner/lighthouseRunner.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLighthouseAudit = runLighthouseAudit;
+async function runLighthouseAudit(url, opts) {
+    // Use the Lighthouse CLI via `npx` to avoid importing the ESM-only
+    // Lighthouse package into this CommonJS runtime.
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    const chromeLauncherModule = await dynamicImport('chrome-launcher');
+    const chromeLauncher = (chromeLauncherModule && (chromeLauncherModule.default ?? chromeLauncherModule));
+    const { execFile } = await dynamicImport('node:child_process');
+    const os = await dynamicImport('node:os');
+    const pathMod = await dynamicImport('node:path');
+    const tmpDir = pathMod.join(os.tmpdir(), `lighthouse-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+    const fs = await dynamicImport('node:fs');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const chrome = await chromeLauncher.launch({ chromeFlags: ['--headless'], userDataDir: tmpDir });
+    try {
+        const port = chrome.port;
+        const args = [
+            'lighthouse',
+            url,
+            `--port=${port}`,
+            '--output=json',
+            '--quiet'
+        ];
+        if (opts?.emulateMobile)
+            args.push('--preset=mobile');
+        if (opts?.categories && opts.categories.length)
+            args.push(`--only-categories=${opts.categories.join(',')}`);
+        // Run via npx to ensure local package is used
+        const cmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const reportJson = await new Promise((resolve, reject) => {
+            execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+                if (err) {
+                    const message = stderr || (err && err.message) || String(err);
+                    return reject(new Error(message));
+                }
+                resolve(stdout);
+            });
+        });
+        // The CLI returns a JSON string containing the report and LHR; parse it
+        const parsed = JSON.parse(reportJson);
+        // Lighthouse CLI places the LHR inside `lhr` when output=json
+        const lhr = parsed.lhr ?? parsed;
+        return { lhr, report: parsed };
+    }
+    catch (err) {
+        // If anything goes wrong launching Chrome or running Lighthouse,
+        // return a minimal error-shaped report so the MCP server can continue
+        // to respond and surface the error to callers instead of crashing.
+        const message = (err && (err.stack || err.message)) || String(err);
+        return {
+            lhr: { categories: {} },
+            report: { error: message },
+            error: message
+        };
+    }
+    finally {
+        try {
+            await chrome.kill();
+        }
+        catch (_) {
+            // ignore cleanup errors
+        }
+    }
+}

package/dist/server.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHttpServer = startHttpServer;
+const http = __importStar(require("http"));
+const lighthouseRunner_1 = require("./runner/lighthouseRunner");
+const fixer_1 = require("./fix/fixer");
+async function startHttpServer(port) {
+    const p = Number(port ?? process.env.PORT ?? process.env.AUDIT_PORT ?? 5000);
+    const requestHandler = async (req, res) => {
+        if (req.method === 'POST' && req.url === '/audit') {
+            let body = '';
+            for await (const chunk of req) {
+                body += chunk;
+            }
+            const parsed = JSON.parse(body || '{}');
+            const url = parsed.url;
+            if (!url) {
+                res.writeHead(400);
+                res.end('missing url');
+                return;
+            }
+            try {
+                const report = await (0, lighthouseRunner_1.runLighthouseAudit)(url);
+                const fix = await (0, fixer_1.autoFixFromReport)(report);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ summary: report.lhr?.categories || null, fix }));
+            }
+            catch (err) {
+                res.writeHead(500);
+                res.end(String(err));
+            }
+        }
+        else {
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('MCP Optimizer running — POST /audit { "url": "https://..." }');
+        }
+    };
+    const server = http.createServer(requestHandler);
+    return new Promise((resolve, reject) => {
+        server.listen(p, () => {
+            console.log(`Server listening on ${p}`);
+            resolve(server);
+        });
+        server.on('error', reject);
+    });
+}

package/docs/MCP.md

@@ -0,0 +1,21 @@
+# MCP Server (MCP-Optimizer)
+
+This project includes a minimal MCP server implementation using `@modelcontextprotocol/sdk`.
+
+Files
+- `src/mcpServer.ts` — minimal MCP server exposing a `run-audit` tool that calls the existing Lighthouse runner and fixer. Defaults to port `4010` (env `MCP_PORT`).
+- `src/index.ts` — starts both the existing HTTP audit endpoint and the MCP server.
+
+Extended features
+- The `run-audit` tool now accepts optional parameters: `categories` (string[]), `emulateMobile` (boolean), and `onlyFailures` (boolean). These are passed to the handler and can be used to tune the audit or filter results.
+- A read-only resource `latest-audit` is registered and returns the most recent Lighthouse report stored in memory.
+
+Run (development)
+
+```bash
+npm install
+npm run dev
+```
+
+Notes
+- The MCP implementation is intentionally minimal and uses `any` in a few places to remain compatible across SDK versions. If the SDK API differs, consult the SDK examples and docs at https://github.com/model-context-protocol/typescript-sdk and adjust `src/mcpServer.ts` accordingly.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "mcp-optimizer",
+  "version": "0.0.1-alpha.1",
+  "description": "An MCP server that runs Lighthouse audits and enables LLMs to automatically optimize your code.",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-optimizer": "bin/mcp-optimizer.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jayzoou/MCP-Optimizer.git"
+  },
+  "keywords": [
+    "mcp"
+  ],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jayzoou/MCP-Optimizer/issues"
+  },
+  "homepage": "https://github.com/jayzoou/MCP-Optimizer#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "zod": "^4.3.4",
+    "lighthouse": "^10.0.0",
+    "chrome-launcher": "^1.2.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.1.6",
+    "ts-node": "^10.9.1",
+    "ts-node-dev": "^2.0.0",
+    "@types/node": "^20.5.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}