index.js

import "dotenv/config.js";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import http from "http";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { z } from "zod";
import puppeteer from "puppeteer";
import * as cheerio from "cheerio";
import NodeCache from "node-cache";

const PORT = parseInt(process.env.PORT, 10);
if (isNaN(PORT) || PORT < 1 || PORT > 65535) {
    console.error("Error: PORT environment variable must be set to a valid port number (1-65535).");
    process.exit(1);
}

const cache = new NodeCache({
    checkperiod: 120, // 2 minutes
    stdTTL: 900, // 15 minutes
    maxKeys: 100,
});

let browser;
try {
    browser = await puppeteer.launch({
        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
        args: [
            "--no-sandbox",
            "--disable-setuid-sandbox",
            "--disable-dev-shm-usage",
            "--disable-gpu",
            "--user-data-dir=/tmp/chromium-data",
        ],
        headless: true,
    });
} catch (err) {
    console.error("Failed to launch browser:", err.message);
    console.error("Ensure Chromium is installed and PUPPETEER_EXECUTABLE_PATH is set if needed.");
    process.exit(1);
}

browser.on("disconnected", () => {
    console.error("Browser disconnected unexpectedly. Exiting for container restart.");
    process.exit(1);
});

/**
 * Registers all MCP tools on the given server instance.
 * @param {import("@modelcontextprotocol/sdk/server/mcp.js").McpServer} server
 * @returns {void}
 */
function registerTools(server) {
    server.registerTool(
        "visit_page",
        {
            description: "Get the HTML or clean text of a web page at a given URL",
            inputSchema: {
                url: z.string().url().refine(
                    (v) => /^https?:\/\//i.test(v),
                    { message: "Only http and https URLs are supported" }
                ).describe("HTTP or HTTPS URL to visit"),
                extractText: z.boolean().optional().default(false).describe("When true, returns clean readable text instead of raw HTML"),
            },
        },
        async ({ url, extractText }) => {
            const cacheKey = `${Buffer.from(url, "utf8").toString("base64")}-${extractText}`;
            const cached = cache.get(cacheKey);
            if (cached) return cached;

            let page;
            try {
                page = await browser.newPage();
                await page.setViewport({ width: 1920, height: 1080 });
                await page.goto(url, { waitUntil: "networkidle2", timeout: 30000 });
                const html = await page.content();

                let returnValue;
                if (!extractText) {
                    returnValue = { content: [{ type: "text", text: html }] };
                } else {
                    const $ = cheerio.load(html);
                    $("script, style, noscript, nav, footer, header, aside, iframe, svg, img").remove();

                    const title = $("title").text().trim();
                    const body = $("body").text().replace(/\s+/g, " ").trim();
                    const text = `TITLE: ${title}\n\n${body}`.slice(0, 50000);
                    returnValue = { content: [{ type: "text", text }] };
                }

                cache.set(cacheKey, returnValue);
                return returnValue;
            } catch (err) {
                console.error("[visit_page] Error visiting", url, err);
                return {
                    content: [{ type: "text", text: `Error: ${err.message}` }],
                    isError: true,
                };
            } finally {
                if (page) await page.close().catch((err) => console.error("[visit_page] Failed to close page:", err));
            }
        }
    );
}

const app = http.createServer(async (req, res) => {
    try {
        if (req.method === "POST" && req.url === "/mcp") {
            const server = new McpServer({ name: "browser-mcp", version: "1.0.0" });

            registerTools(server);

            const transport = new StreamableHTTPServerTransport({
                sessionIdGenerator: undefined, // stateless
            });

            res.on("close", () => transport.close());
            await server.connect(transport);
            await transport.handleRequest(req, res);
            return;
        }

        if (req.method === "GET" && req.url === "/health") {
            res.writeHead(200, { "content-type": "application/json" });
            res.end(JSON.stringify({ status: "ok" }));
            return;
        }

        res.writeHead(404);
        res.end("Not found");
    } catch (err) {
        console.error("[http] Unhandled error:", err);
        if (!res.headersSent) {
            res.writeHead(500);
            res.end("Internal Server Error");
        }
    }
});

app.listen(PORT, () => {
    console.log(`Browser MCP server listening on port ${PORT}`);
});