mcp-web-reader 2.1.0 → 2.2.0

package/README.md

@@ -11,6 +11,7 @@ A powerful MCP (Model Context Protocol) server that enables Claude and other LLM
 - 🌐 **Bypass restrictions**: Cloudflare, CAPTCHAs, access controls
 - 📦 **Batch processing**: Fetch multiple URLs simultaneously
 - 📝 **Markdown output**: Automatic conversion to clean Markdown
+- 🔌 **Transport compatibility**: stdio + Streamable HTTP (optional legacy SSE compatibility mode)
 
 ## Installation
 
@@ -61,6 +62,28 @@ claude mcp add web-reader -- mcp-web-reader
 claude mcp list
 ```
 
+### Streamable HTTP (Remote Deployment)
+
+Start server in Streamable HTTP mode:
+
+```bash
+MCP_TRANSPORT=http MCP_HTTP_HOST=0.0.0.0 MCP_HTTP_PORT=3000 npm run start:http
+```
+
+Optional environment variables:
+
+- `MCP_HTTP_PATH` (default: `/mcp`)
+- `MCP_ENABLE_LEGACY_SSE=true` to expose deprecated `/sse` + `/messages` endpoints
+
+Codex MCP config (HTTP):
+
+```toml
+[mcp_servers.web-reader]
+type = "http"
+url = "https://your-domain.com/mcp"
+bearer_token_env_var = "WEB_READER_TOKEN"
+```
+
 ## Usage
 
 In Claude:
@@ -102,6 +125,7 @@ Auto-detects restrictions and switches to browser for:
 npm run dev    # Development with auto-rebuild
 npm run build  # Build production version
 npm start      # Test run
+npm run start:http  # Run Streamable HTTP server
 ```
 
 ## License

package/dist/index.js

@@ -1,19 +1,14 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, isInitializeRequest, } from "@modelcontextprotocol/sdk/types.js";
 import fetch from "node-fetch";
 import { JSDOM } from "jsdom";
 import TurndownService from "turndown";
 import { chromium } from "playwright";
-// Create server instance
-const server = new Server({
-    name: "web-reader",
-    version: "2.0.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
+import { randomUUID } from "node:crypto";
 // Initialize Turndown service (convert HTML to Markdown)
 const turndownService = new TurndownService({
     headingStyle: "atx",
@@ -371,226 +366,459 @@ async function fetchWebContent(url, preferJina = true) {
         }
     }
 }
-// Handle tool list requests
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                name: "fetch_url",
-                description: "Fetch web content from specified URL and convert to Markdown format. Uses Jina Reader by default, automatically falls back to local parser on failure",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        url: {
-                            type: "string",
-                            description: "Webpage URL to fetch (must be http or https protocol)",
-                        },
-                        preferJina: {
-                            type: "boolean",
-                            description: "Whether to prioritize Jina Reader (default: true)",
-                            default: true,
+const streamableSessions = new Map();
+const legacySseSessions = new Map();
+function createServerInstance() {
+    const server = new Server({
+        name: "web-reader",
+        version: "2.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    registerServerHandlers(server);
+    return server;
+}
+function registerServerHandlers(server) {
+    // Handle tool list requests
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "fetch_url",
+                    description: "Fetch web content from specified URL and convert to Markdown format. Uses Jina Reader by default, automatically falls back to local parser on failure",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: {
+                                type: "string",
+                                description: "Webpage URL to fetch (must be http or https protocol)",
+                            },
+                            preferJina: {
+                                type: "boolean",
+                                description: "Whether to prioritize Jina Reader (default: true)",
+                                default: true,
+                            },
                         },
+                        required: ["url"],
                     },
-                    required: ["url"],
                 },
-            },
-            {
-                name: "fetch_multiple_urls",
-                description: "Batch fetch web content from multiple URLs",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        urls: {
-                            type: "array",
-                            items: {
-                                type: "string",
+                {
+                    name: "fetch_multiple_urls",
+                    description: "Batch fetch web content from multiple URLs",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            urls: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                                description: "List of webpage URLs to fetch",
+                                maxItems: 10, // Limit to 10 URLs
+                            },
+                            preferJina: {
+                                type: "boolean",
+                                description: "Whether to prioritize Jina Reader (default: true)",
+                                default: true,
                             },
-                            description: "List of webpage URLs to fetch",
-                            maxItems: 10, // Limit to 10 URLs
-                        },
-                        preferJina: {
-                            type: "boolean",
-                            description: "Whether to prioritize Jina Reader (default: true)",
-                            default: true,
                         },
+                        required: ["urls"],
                     },
-                    required: ["urls"],
                 },
-            },
-            {
-                name: "fetch_url_with_jina",
-                description: "Force fetch using Jina Reader (suitable for complex webpages)",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        url: {
-                            type: "string",
-                            description: "Webpage URL to fetch",
+                {
+                    name: "fetch_url_with_jina",
+                    description: "Force fetch using Jina Reader (suitable for complex webpages)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: {
+                                type: "string",
+                                description: "Webpage URL to fetch",
+                            },
                         },
+                        required: ["url"],
                     },
-                    required: ["url"],
                 },
-            },
-            {
-                name: "fetch_url_local",
-                description: "Force fetch using local parser (suitable for simple webpages or when Jina is unavailable)",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        url: {
-                            type: "string",
-                            description: "Webpage URL to fetch",
+                {
+                    name: "fetch_url_local",
+                    description: "Force fetch using local parser (suitable for simple webpages or when Jina is unavailable)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: {
+                                type: "string",
+                                description: "Webpage URL to fetch",
+                            },
                         },
+                        required: ["url"],
                     },
-                    required: ["url"],
                 },
-            },
-            {
-                name: "fetch_url_with_browser",
-                description: "Force fetch using Playwright browser (suitable for websites with access restrictions, such as Cloudflare protection, CAPTCHA, etc.)",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        url: {
-                            type: "string",
-                            description: "Webpage URL to fetch",
+                {
+                    name: "fetch_url_with_browser",
+                    description: "Force fetch using Playwright browser (suitable for websites with access restrictions, such as Cloudflare protection, CAPTCHA, etc.)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: {
+                                type: "string",
+                                description: "Webpage URL to fetch",
+                            },
                         },
+                        required: ["url"],
                     },
-                    required: ["url"],
                 },
-            },
-        ],
-    };
-});
-// Handle tool call requests
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        if (name === "fetch_url") {
-            const { url, preferJina = true } = args;
-            // Validate URL
-            if (!isValidUrl(url)) {
-                throw new McpError(ErrorCode.InvalidParams, "Invalid URL format, please provide http or https protocol URL");
+            ],
+        };
+    });
+    // Handle tool call requests
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            if (name === "fetch_url") {
+                const { url, preferJina = true } = args;
+                // Validate URL
+                if (!isValidUrl(url)) {
+                    throw new McpError(ErrorCode.InvalidParams, "Invalid URL format, please provide http or https protocol URL");
+                }
+                // Fetch web content
+                const result = await fetchWebContent(url, preferJina);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: ${result.metadata.method}\n\n---\n\n${result.content}`,
+                        },
+                    ],
+                };
             }
-            // Fetch web content
-            const result = await fetchWebContent(url, preferJina);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: ${result.metadata.method}\n\n---\n\n${result.content}`,
-                    },
-                ],
-            };
-        }
-        else if (name === "fetch_url_with_jina") {
-            const { url } = args;
-            if (!isValidUrl(url)) {
-                throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
+            else if (name === "fetch_url_with_jina") {
+                const { url } = args;
+                if (!isValidUrl(url)) {
+                    throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
+                }
+                const result = await fetchWithJinaReader(url);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Jina Reader\n\n---\n\n${result.content}`,
+                        },
+                    ],
+                };
             }
-            const result = await fetchWithJinaReader(url);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Jina Reader\n\n---\n\n${result.content}`,
-                    },
-                ],
-            };
-        }
-        else if (name === "fetch_url_local") {
-            const { url } = args;
-            if (!isValidUrl(url)) {
-                throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
+            else if (name === "fetch_url_local") {
+                const { url } = args;
+                if (!isValidUrl(url)) {
+                    throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
+                }
+                const result = await fetchWithLocalParser(url);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Local Parser\n\n---\n\n${result.content}`,
+                        },
+                    ],
+                };
             }
-            const result = await fetchWithLocalParser(url);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Local Parser\n\n---\n\n${result.content}`,
-                    },
-                ],
-            };
-        }
-        else if (name === "fetch_multiple_urls") {
-            const { urls, preferJina = true } = args;
-            // Validate all URLs
-            const invalidUrls = urls.filter(url => !isValidUrl(url));
-            if (invalidUrls.length > 0) {
-                throw new McpError(ErrorCode.InvalidParams, `The following URLs have invalid format: ${invalidUrls.join(", ")}`);
+            else if (name === "fetch_multiple_urls") {
+                const { urls, preferJina = true } = args;
+                // Validate all URLs
+                const invalidUrls = urls.filter(url => !isValidUrl(url));
+                if (invalidUrls.length > 0) {
+                    throw new McpError(ErrorCode.InvalidParams, `The following URLs have invalid format: ${invalidUrls.join(", ")}`);
+                }
+                // Fetch all URLs concurrently
+                const results = await Promise.allSettled(urls.map(url => fetchWebContent(url, preferJina)));
+                // Combine results
+                let combinedContent = "# Batch URL Content Fetch Results\n\n";
+                results.forEach((result, index) => {
+                    const url = urls[index];
+                    combinedContent += `## ${index + 1}. ${url}\n\n`;
+                    if (result.status === "fulfilled") {
+                        const { title, content, metadata } = result.value;
+                        combinedContent += `**Title**: ${title}\n`;
+                        combinedContent += `**Fetched At**: ${metadata.fetchedAt}\n`;
+                        combinedContent += `**Content Length**: ${metadata.contentLength} characters\n`;
+                        combinedContent += `**Method**: ${metadata.method}\n\n`;
+                        combinedContent += `### Content\n\n${content}\n\n`;
+                    }
+                    else {
+                        combinedContent += `**Error**: ${result.reason}\n\n`;
+                    }
+                    combinedContent += "---\n\n";
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: combinedContent,
+                        },
+                    ],
+                };
             }
-            // Fetch all URLs concurrently
-            const results = await Promise.allSettled(urls.map(url => fetchWebContent(url, preferJina)));
-            // Combine results
-            let combinedContent = "# Batch URL Content Fetch Results\n\n";
-            results.forEach((result, index) => {
-                const url = urls[index];
-                combinedContent += `## ${index + 1}. ${url}\n\n`;
-                if (result.status === "fulfilled") {
-                    const { title, content, metadata } = result.value;
-                    combinedContent += `**Title**: ${title}\n`;
-                    combinedContent += `**Fetched At**: ${metadata.fetchedAt}\n`;
-                    combinedContent += `**Content Length**: ${metadata.contentLength} characters\n`;
-                    combinedContent += `**Method**: ${metadata.method}\n\n`;
-                    combinedContent += `### Content\n\n${content}\n\n`;
+            else if (name === "fetch_url_with_browser") {
+                const { url } = args;
+                if (!isValidUrl(url)) {
+                    throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
                 }
-                else {
-                    combinedContent += `**Error**: ${result.reason}\n\n`;
+                const result = await fetchWithPlaywright(url);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Playwright Browser\n\n---\n\n${result.content}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof McpError) {
+                throw error;
+            }
+            throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+function sendJsonRpcError(res, statusCode, message) {
+    res.status(statusCode).json({
+        jsonrpc: "2.0",
+        error: {
+            code: -32000,
+            message,
+        },
+        id: null,
+    });
+}
+function getSessionIdFromHeaders(headers) {
+    const value = headers["mcp-session-id"];
+    if (!value) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value[0] : value;
+}
+function resolveTransportMode() {
+    const cliTransportArg = process.argv.find((arg) => arg.startsWith("--transport="));
+    const cliTransport = cliTransportArg ? cliTransportArg.split("=", 2)[1] : undefined;
+    const legacyHttpFlag = process.argv.includes("--http");
+    const mode = (cliTransport ?? process.env.MCP_TRANSPORT ?? (legacyHttpFlag ? "http" : "stdio"))
+        .toLowerCase();
+    if (mode === "stdio" || mode === "http") {
+        return mode;
+    }
+    throw new Error(`Unsupported transport mode: ${mode}. Use 'stdio' or 'http'.`);
+}
+function resolveLegacySseFlag() {
+    const envValue = (process.env.MCP_ENABLE_LEGACY_SSE ?? "").toLowerCase();
+    return envValue === "1" || envValue === "true" || process.argv.includes("--legacy-sse");
+}
+async function closeAllSessions() {
+    for (const [sessionId, session] of streamableSessions.entries()) {
+        try {
+            await session.server.close();
+        }
+        catch (error) {
+            console.error(`Failed to close streamable server for session ${sessionId}:`, error);
+        }
+    }
+    streamableSessions.clear();
+    for (const [sessionId, session] of legacySseSessions.entries()) {
+        try {
+            await session.server.close();
+        }
+        catch (error) {
+            console.error(`Failed to close SSE server for session ${sessionId}:`, error);
+        }
+    }
+    legacySseSessions.clear();
+}
+async function startStdioServer() {
+    const server = createServerInstance();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Web Reader started in stdio mode");
+}
+async function startHttpServer() {
+    const host = process.env.MCP_HTTP_HOST ?? "127.0.0.1";
+    const port = Number.parseInt(process.env.MCP_HTTP_PORT ?? "3000", 10);
+    const mcpPath = process.env.MCP_HTTP_PATH ?? "/mcp";
+    const enableLegacySse = resolveLegacySseFlag();
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error(`Invalid MCP_HTTP_PORT: ${process.env.MCP_HTTP_PORT}`);
+    }
+    const app = createMcpExpressApp({ host });
+    app.post(mcpPath, async (req, res) => {
+        const sessionId = getSessionIdFromHeaders(req.headers);
+        try {
+            if (sessionId) {
+                const existingSession = streamableSessions.get(sessionId);
+                if (!existingSession) {
+                    sendJsonRpcError(res, 404, "Session not found");
+                    return;
                 }
-                combinedContent += "---\n\n";
+                await existingSession.transport.handleRequest(req, res, req.body);
+                return;
+            }
+            if (!isInitializeRequest(req.body)) {
+                sendJsonRpcError(res, 400, "Missing session ID; initialize request required");
+                return;
+            }
+            let transport;
+            const sessionServer = createServerInstance();
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (initializedSessionId) => {
+                    streamableSessions.set(initializedSessionId, { transport, server: sessionServer });
+                    console.error(`Streamable HTTP session initialized: ${initializedSessionId}`);
+                },
             });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: combinedContent,
-                    },
-                ],
+            transport.onclose = () => {
+                const closedSessionId = transport.sessionId;
+                if (closedSessionId && streamableSessions.delete(closedSessionId)) {
+                    console.error(`Streamable HTTP session closed: ${closedSessionId}`);
+                }
             };
+            await sessionServer.connect(transport);
+            await transport.handleRequest(req, res, req.body);
         }
-        else if (name === "fetch_url_with_browser") {
-            const { url } = args;
-            if (!isValidUrl(url)) {
-                throw new McpError(ErrorCode.InvalidParams, "Invalid URL format");
+        catch (error) {
+            console.error("Error handling streamable HTTP POST request:", error);
+            if (!res.headersSent) {
+                sendJsonRpcError(res, 500, "Internal server error");
+            }
+        }
+    });
+    app.get(mcpPath, async (req, res) => {
+        const sessionId = getSessionIdFromHeaders(req.headers);
+        if (!sessionId) {
+            sendJsonRpcError(res, 400, "Missing mcp-session-id header");
+            return;
+        }
+        const session = streamableSessions.get(sessionId);
+        if (!session) {
+            sendJsonRpcError(res, 404, "Session not found");
+            return;
+        }
+        try {
+            await session.transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("Error handling streamable HTTP GET request:", error);
+            if (!res.headersSent) {
+                sendJsonRpcError(res, 500, "Internal server error");
             }
-            const result = await fetchWithPlaywright(url);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**Fetched At**: ${result.metadata.fetchedAt}\n**Content Length**: ${result.metadata.contentLength} characters\n**Method**: Playwright Browser\n\n---\n\n${result.content}`,
-                    },
-                ],
-            };
         }
-        else {
-            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+    });
+    app.delete(mcpPath, async (req, res) => {
+        const sessionId = getSessionIdFromHeaders(req.headers);
+        if (!sessionId) {
+            sendJsonRpcError(res, 400, "Missing mcp-session-id header");
+            return;
         }
+        const session = streamableSessions.get(sessionId);
+        if (!session) {
+            sendJsonRpcError(res, 404, "Session not found");
+            return;
+        }
+        try {
+            await session.transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("Error handling streamable HTTP DELETE request:", error);
+            if (!res.headersSent) {
+                sendJsonRpcError(res, 500, "Internal server error");
+            }
+        }
+    });
+    if (enableLegacySse) {
+        app.get("/sse", async (_req, res) => {
+            const transport = new SSEServerTransport("/messages", res);
+            const server = createServerInstance();
+            legacySseSessions.set(transport.sessionId, { transport, server });
+            res.on("close", () => {
+                const removed = legacySseSessions.delete(transport.sessionId);
+                if (removed) {
+                    void server.close().catch((error) => {
+                        console.error("Failed to close legacy SSE session server:", error);
+                    });
+                }
+            });
+            await server.connect(transport);
+        });
+        app.post("/messages", async (req, res) => {
+            const querySessionId = req.query.sessionId;
+            const sessionId = typeof querySessionId === "string"
+                ? querySessionId
+                : Array.isArray(querySessionId) && typeof querySessionId[0] === "string"
+                    ? querySessionId[0]
+                    : undefined;
+            if (!sessionId) {
+                sendJsonRpcError(res, 400, "Missing sessionId query parameter");
+                return;
+            }
+            const session = legacySseSessions.get(sessionId);
+            if (!session) {
+                sendJsonRpcError(res, 404, "Session not found");
+                return;
+            }
+            try {
+                await session.transport.handlePostMessage(req, res, req.body);
+            }
+            catch (error) {
+                console.error("Error handling legacy SSE POST request:", error);
+                if (!res.headersSent) {
+                    sendJsonRpcError(res, 500, "Internal server error");
+                }
+            }
+        });
     }
-    catch (error) {
-        if (error instanceof McpError) {
-            throw error;
+    app.get("/healthz", (_req, res) => {
+        res.json({
+            status: "ok",
+            transport: "streamable-http",
+            sessions: streamableSessions.size,
+            legacySseEnabled: enableLegacySse,
+        });
+    });
+    app.listen(port, host, () => {
+        console.error(`MCP Web Reader started in HTTP mode on http://${host}:${port}${mcpPath}`);
+        if (enableLegacySse) {
+            console.error("Legacy SSE compatibility enabled on /sse and /messages");
         }
-        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
+let isShuttingDown = false;
+async function shutdown(signal) {
+    if (isShuttingDown) {
+        return;
     }
-});
+    isShuttingDown = true;
+    console.error(`Received ${signal}, shutting down MCP Web Reader...`);
+    await closeAllSessions();
+    await closeBrowser();
+    process.exit(0);
+}
 // Start server
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("MCP Web Reader v2.0 started (with Jina Reader + Playwright support)");
+    const transportMode = resolveTransportMode();
+    if (transportMode === "http") {
+        await startHttpServer();
+        return;
+    }
+    await startStdioServer();
 }
 // Graceful shutdown handling
-process.on('SIGINT', async () => {
-    console.error("Received SIGINT signal, closing browser...");
-    await closeBrowser();
-    process.exit(0);
+process.on("SIGINT", () => {
+    void shutdown("SIGINT");
 });
-process.on('SIGTERM', async () => {
-    console.error("Received SIGTERM signal, closing browser...");
-    await closeBrowser();
-    process.exit(0);
+process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
 });
 main().catch((error) => {
     console.error("Server startup failed:", error);

package/package.json

@@ -1,46 +1,52 @@
 {
     "name": "mcp-web-reader",
-    "version": "2.1.0",
+    "version": "2.2.0",
     "description": "MCP server for reading web content with Jina Reader and local parser support",
     "main": "dist/index.js",
     "bin": {
-      "mcp-web-reader": "./dist/index.js"
+        "mcp-web-reader": "./dist/index.js"
     },
     "type": "module",
     "scripts": {
-      "build": "tsc",
-      "start": "node dist/index.js",
-      "dev": "tsc --watch",
-      "claude-code": "node dist/index.js",
-      "postinstall": "npx playwright install chromium"
+        "build": "tsc",
+        "start": "node dist/index.js",
+        "start:http": "node dist/index.js --transport=http",
+        "dev": "tsc --watch",
+        "claude-code": "node dist/index.js",
+        "postinstall": "npx playwright install chromium"
     },
     "repository": {
-      "type": "git",
-      "url": "git+https://github.com/Gracker/mcp-web-reader.git"
+        "type": "git",
+        "url": "git+https://github.com/Gracker/mcp-web-reader.git"
     },
     "bugs": {
-      "url": "https://github.com/Gracker/mcp-web-reader/issues"
+        "url": "https://github.com/Gracker/mcp-web-reader/issues"
     },
     "homepage": "https://github.com/Gracker/mcp-web-reader#readme",
-    "keywords": ["mcp", "claude", "web-scraping", "jina-reader"],
+    "keywords": [
+        "mcp",
+        "claude",
+        "web-scraping",
+        "jina-reader"
+    ],
     "author": "Gracker",
     "license": "MIT",
     "files": [
-      "dist",
-      "README.md",
-      "LICENSE"
+        "dist",
+        "README.md",
+        "LICENSE"
     ],
     "dependencies": {
-      "@modelcontextprotocol/sdk": "^0.5.0",
-      "node-fetch": "^3.3.2",
-      "jsdom": "^24.0.0",
-      "turndown": "^7.1.3",
-      "playwright": "^1.40.0"
+        "@modelcontextprotocol/sdk": "^1.26.0",
+        "jsdom": "^24.0.0",
+        "node-fetch": "^3.3.2",
+        "playwright": "^1.40.0",
+        "turndown": "^7.1.3"
     },
     "devDependencies": {
-      "@types/node": "^20.0.0",
-      "@types/jsdom": "^21.1.6",
-      "@types/turndown": "^5.0.4",
-      "typescript": "^5.3.3"
+        "@types/jsdom": "^21.1.6",
+        "@types/node": "^20.0.0",
+        "@types/turndown": "^5.0.4",
+        "typescript": "^5.3.3"
     }
-  }
+}