@j0hanz/fetch-url-mcp 1.3.1 → 1.5.0

package/dist/http/native.js

@@ -1,20 +1,21 @@
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { createServer, } from 'node:http';
 import { createServer as createHttpsServer, } from 'node:https';
 import { hostname } from 'node:os';
 import process from 'node:process';
-import { config, enableHttpMode } from '../config.js';
-import { handleDownload } from '../download.js';
-import { acceptsEventStream, acceptsJsonAndEventStream, isJsonRpcBatchRequest, isMcpRequestBody, } from '../mcp-validator.js';
-import { cancelTasksForOwner } from '../mcp.js';
-import { logError, logInfo, registerMcpSessionServer, resolveMcpSessionIdByServer, runWithRequestContext, unregisterMcpSessionServer, unregisterMcpSessionServerByServer, } from '../observability.js';
-import { applyHttpServerTuning, drainConnectionsOnShutdown, } from '../server-tuning.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { config, enableHttpMode } from '../lib/core.js';
+import { logError, logInfo, registerMcpSessionServer, resolveMcpSessionIdByServer, runWithRequestContext, unregisterMcpSessionServer, unregisterMcpSessionServerByServer, } from '../lib/core.js';
+import { composeCloseHandlers, createSessionStore, createSlotTracker, ensureSessionCapacity, reserveSessionSlot, startSessionCleanupLoop, } from '../lib/core.js';
+import { handleDownload } from '../lib/http.js';
+import { acceptsEventStream, acceptsJsonAndEventStream, isJsonRpcBatchRequest, isMcpRequestBody, } from '../lib/mcp-tools.js';
+import { cancelTasksForOwner } from '../lib/mcp-tools.js';
+import { toError } from '../lib/utils.js';
+import { applyHttpServerTuning, drainConnectionsOnShutdown, } from '../lib/utils.js';
+import { isObject } from '../lib/utils.js';
 import { createMcpServerForHttpSession } from '../server.js';
-import { composeCloseHandlers, createSessionStore, createSlotTracker, ensureSessionCapacity, reserveSessionSlot, startSessionCleanupLoop, } from '../session.js';
-import { isObject } from '../type-guards.js';
 import { applyUnauthorizedAuthHeaders, assertHttpModeConfiguration, authService, buildAuthFingerprint, buildProtectedResourceMetadataDocument, corsPolicy, ensureMcpProtocolVersion, hostOriginPolicy, isProtectedResourceMetadataPath, SUPPORTED_MCP_PROTOCOL_VERSIONS, } from './auth.js';
 import { disableEventLoopMonitoring, resetEventLoopMonitoring, sendHealthRouteResponse, shouldHandleHealthRoute, } from './health.js';
 import { buildRequestContext, closeMcpServerBestEffort, closeTransportBestEffort, createRequestAbortSignal, createTransportAdapter, DEFAULT_BODY_LIMIT_BYTES, drainRequest, findDuplicateSingleValueHeader, getHeaderValue, getMcpSessionId, jsonBodyReader, registerInboundBlockList, sendError, sendJson, sendText, } from './helpers.js';
@@ -36,7 +37,7 @@ function resolveRequestedProtocolVersion(body) {
     if (normalized.length === 0)
         return DEFAULT_MCP_PROTOCOL_VERSION;
     if (!SUPPORTED_MCP_PROTOCOL_VERSIONS.has(normalized)) {
-        return DEFAULT_MCP_PROTOCOL_VERSION;
+        return null;
     }
     return normalized;
 }
@@ -70,13 +71,22 @@ class McpSessionGateway {
             return;
         }
         const requestId = body.id ?? null;
-        const isInitNotification = isInitializedNotification(body.method);
+        const isInitializedMethod = isInitializedNotification(body.method);
+        const isInitNotification = isInitializedMethod && body.id === undefined;
         const sessionId = getMcpSessionId(ctx.req);
-        let session = sessionId ? this.store.get(sessionId) : undefined;
+        if (isInitializedMethod && !isInitNotification) {
+            sendError(ctx.res, -32600, 'notifications/initialized must be sent as a notification', 400, requestId);
+            return;
+        }
+        const session = sessionId ? this.store.get(sessionId) : undefined;
         if (sessionId && !session) {
             sendError(ctx.res, -32600, 'Session not found', 404, requestId);
             return;
         }
+        if (!session && isInitNotification) {
+            sendError(ctx.res, -32600, 'Missing session ID', 400, requestId);
+            return;
+        }
         if (session) {
             if (!ensureMcpProtocolVersion(ctx.req, ctx.res, {
                 requireHeader: true,
@@ -91,17 +101,20 @@ class McpSessionGateway {
                     return;
                 }
             }
-            if (isInitNotification && !session.protocolInitialized) {
-                session.protocolInitialized = true;
-                if (sessionId)
-                    this.store.touch(sessionId);
-            }
         }
         else {
-            if (!ensureMcpProtocolVersion(ctx.req, ctx.res))
+            if (!ensureMcpProtocolVersion(ctx.req, ctx.res, {
+                requireHeader: config.server.http.requireProtocolVersionHeaderOnSessionInit,
+            })) {
                 return;
+            }
         }
-        if (isInitNotification && body.id === undefined) {
+        if (session && isInitNotification) {
+            if (!session.protocolInitialized) {
+                session.protocolInitialized = true;
+            }
+            if (sessionId)
+                this.store.touch(sessionId);
             sendText(ctx.res, 200, '');
             return;
         }
@@ -114,13 +127,6 @@ class McpSessionGateway {
         if (!transport)
             return;
         await transport.handleRequest(ctx.req, ctx.res, body);
-        if (sessionId && isInitNotification) {
-            session = this.store.get(sessionId);
-            if (session) {
-                session.protocolInitialized = true;
-                this.store.touch(sessionId);
-            }
-        }
     }
     async handleGet(ctx) {
         const sessionId = getMcpSessionId(ctx.req);
@@ -179,6 +185,10 @@ class McpSessionGateway {
             return null;
         }
         const negotiatedProtocolVersion = resolveRequestedProtocolVersion(ctx.body);
+        if (!negotiatedProtocolVersion) {
+            sendError(ctx.res, -32602, `Unsupported protocolVersion; supported versions: ${[...SUPPORTED_MCP_PROTOCOL_VERSIONS].join(', ')}`, 400, requestId);
+            return null;
+        }
         return this.createNewSession(ctx, requestId, negotiatedProtocolVersion);
     }
     getExistingTransport(sessionId, authFingerprint, res, requestId) {
@@ -288,6 +298,7 @@ class McpSessionGateway {
             sendError(res, -32000, 'Server busy', 503, requestId);
             return false;
         }
+        // Double-check: capacity may have changed during the async eviction window above.
         if (!reserveSessionSlot(this.store, config.server.maxSessions)) {
             sendError(res, -32000, 'Server busy', 503, requestId);
             return false;
@@ -360,7 +371,7 @@ class HttpDispatcher {
             if (!auth)
                 return;
             const authCtx = { ...ctx, auth };
-            if (this.tryHandleDownloadRoute(ctx))
+            if (this.tryHandleDownloadRoute(authCtx))
                 return;
             if (ctx.url.pathname === '/mcp') {
                 const handled = await this.handleMcpRoutes(authCtx);
@@ -370,7 +381,7 @@ class HttpDispatcher {
             sendJson(ctx.res, 404, { error: 'Not Found' });
         }
         catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
+            const error = toError(err);
             logError('Request failed', error);
             if (!ctx.res.writableEnded) {
                 sendJson(ctx.res, 500, { error: 'Internal Server Error' });
@@ -398,9 +409,7 @@ class HttpDispatcher {
         }
         catch (err) {
             applyUnauthorizedAuthHeaders(ctx.req, ctx.res);
-            sendJson(ctx.res, 401, {
-                error: err instanceof Error ? err.message : 'Unauthorized',
-            });
+            sendError(ctx.res, -32000, err instanceof Error ? err.message : 'Unauthorized', 401);
             return null;
         }
     }
@@ -500,7 +509,7 @@ class HttpRequestPipeline {
 // Server bootstrap
 // ---------------------------------------------------------------------------
 function handlePipelineError(error, res) {
-    logError('Request pipeline failed', error instanceof Error ? error : new Error(String(error)));
+    logError('Request pipeline failed', toError(error));
     if (res.writableEnded)
         return;
     if (!res.headersSent) {
@@ -518,12 +527,18 @@ function createNetworkServer(listener) {
     if (!keyFile || !certFile) {
         throw new Error('HTTPS enabled but SERVER_TLS_KEY_FILE / SERVER_TLS_CERT_FILE are missing');
     }
-    const tlsOptions = {
-        key: readFileSync(keyFile),
-        cert: readFileSync(certFile),
-    };
-    if (caFile) {
-        tlsOptions.ca = readFileSync(caFile);
+    let tlsOptions;
+    try {
+        tlsOptions = {
+            key: readFileSync(keyFile),
+            cert: readFileSync(certFile),
+        };
+        if (caFile) {
+            tlsOptions.ca = readFileSync(caFile);
+        }
+    }
+    catch (err) {
+        throw new Error(`Failed to read TLS files (key=${keyFile}, cert=${certFile}): ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
     return createHttpsServer(tlsOptions, listener);
 }
@@ -584,7 +599,15 @@ export async function startHttpServer() {
     resetEventLoopMonitoring();
     const rateLimiter = createRateLimitManagerImpl(config.rateLimit);
     const sessionStore = createSessionStore(config.server.sessionTtlMs);
-    const sessionCleanup = startSessionCleanupLoop(sessionStore, config.server.sessionTtlMs);
+    const sessionCleanup = startSessionCleanupLoop(sessionStore, config.server.sessionTtlMs, {
+        onEvictSession: (session) => {
+            const sessionId = resolveMcpSessionIdByServer(session.server);
+            if (!sessionId)
+                return;
+            cancelTasksForOwner(`session:${sessionId}`, 'The task was cancelled because the MCP session expired.');
+            unregisterMcpSessionServer(sessionId);
+        },
+    });
     const mcpGateway = new McpSessionGateway(sessionStore, createMcpServerForHttpSession);
     const dispatcher = new HttpDispatcher(sessionStore, mcpGateway);
     const pipeline = new HttpRequestPipeline(rateLimiter, dispatcher);
@@ -615,4 +638,3 @@ export async function startHttpServer() {
         }),
     };
 }
-//# sourceMappingURL=native.js.map

package/dist/http/rate-limit.d.ts

@@ -1,5 +1,5 @@
 import { type RequestContext } from './helpers.js';
-export interface RateLimitConfig {
+interface RateLimitConfig {
     maxRequests: number;
     windowMs: number;
     cleanupIntervalMs: number;
@@ -10,4 +10,4 @@ export interface RateLimitManagerImpl {
     stop(): void;
 }
 export declare function createRateLimitManagerImpl(options: RateLimitConfig): RateLimitManagerImpl;
-//# sourceMappingURL=rate-limit.d.ts.map
+export {};

package/dist/http/rate-limit.js

@@ -1,9 +1,7 @@
-import { setInterval as setIntervalPromise } from 'node:timers/promises';
-import { logWarn } from '../observability.js';
+import { logWarn } from '../lib/core.js';
+import { isAbortError } from '../lib/utils.js';
+import { startAbortableIntervalLoop } from '../lib/utils.js';
 import { sendJson } from './helpers.js';
-function isAbortError(error) {
-    return error instanceof Error && error.name === 'AbortError';
-}
 // ---------------------------------------------------------------------------
 // Rate limiter
 // ---------------------------------------------------------------------------
@@ -16,19 +14,17 @@ class RateLimiter {
         this.startCleanupLoop();
     }
     startCleanupLoop() {
-        const interval = setIntervalPromise(this.options.cleanupIntervalMs, Date.now, { signal: this.cleanup.signal, ref: false });
-        void (async () => {
-            try {
-                for await (const getNow of interval) {
-                    this.cleanupEntries(getNow());
-                }
-            }
-            catch (err) {
+        startAbortableIntervalLoop(this.options.cleanupIntervalMs, Date.now, {
+            signal: this.cleanup.signal,
+            onTick: (getNow) => {
+                this.cleanupEntries(getNow());
+            },
+            onError: (err) => {
                 if (!isAbortError(err)) {
                     logWarn('Rate limit cleanup failed', { error: err });
                 }
-            }
-        })();
+            },
+        });
     }
     cleanupEntries(now) {
         const maxIdle = this.options.windowMs * 2;
@@ -89,4 +85,3 @@ class RateLimiter {
 export function createRateLimitManagerImpl(options) {
     return new RateLimiter(options);
 }
-//# sourceMappingURL=rate-limit.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import process from 'node:process';
+import { serverVersion } from './lib/core.js';
+import { logError } from './lib/core.js';
+import { toError } from './lib/utils.js';
 import { parseCliArgs, renderCliUsage } from './cli.js';
-import { serverVersion } from './config.js';
 import { startHttpServer } from './http/native.js';
-import { logError } from './observability.js';
 import { startStdioServer } from './server.js';
 const FORCE_EXIT_TIMEOUT_MS = 10_000;
 let forcedExitTimer;
-function toError(value) {
-    return value instanceof Error ? value : new Error(String(value));
+function writeAndExit(stream, text, code) {
+    stream.write(text);
+    process.exit(code);
 }
 function scheduleForcedExit(reason) {
     if (forcedExitTimer)
@@ -21,20 +23,16 @@ function scheduleForcedExit(reason) {
 }
 const parseResult = parseCliArgs(process.argv.slice(2));
 if (!parseResult.ok) {
-    process.stderr.write(`Invalid arguments: ${parseResult.message}\n\n`);
-    process.stderr.write(renderCliUsage());
-    process.exit(1);
+    writeAndExit(process.stderr, `Invalid arguments: ${parseResult.message}\n\n${renderCliUsage()}`, 1);
 }
 const { values } = parseResult;
 if (values.help) {
-    process.stdout.write(renderCliUsage());
-    process.exit(0);
+    writeAndExit(process.stdout, renderCliUsage(), 0);
 }
 if (values.version) {
-    process.stdout.write(`${serverVersion}\n`);
-    process.exit(0);
+    writeAndExit(process.stdout, `${serverVersion}\n`, 0);
 }
-const isStdioMode = values.stdio;
+const isStdioMode = !values.http;
 let isShuttingDown = false;
 const shutdownHandlerRef = {};
 function shouldAttemptShutdown() {
@@ -47,19 +45,19 @@ function attemptShutdown(signal) {
     process.stderr.write('Attempting graceful shutdown...\n');
     void shutdownHandlerRef.current(signal);
 }
-function registerOnceSignal(signal, handler) {
-    process.once(signal, () => {
-        handler(signal);
-    });
+function registerSignalHandlers(signals, handler) {
+    for (const signal of signals) {
+        process.once(signal, () => {
+            handler(signal);
+        });
+    }
 }
 function registerHttpSignalHandlers() {
     const tryShutdown = (signal) => {
         if (shouldAttemptShutdown())
             attemptShutdown(signal);
     };
-    for (const signal of ['SIGINT', 'SIGTERM']) {
-        registerOnceSignal(signal, tryShutdown);
-    }
+    registerSignalHandlers(['SIGINT', 'SIGTERM'], tryShutdown);
 }
 function writeStartupError(error) {
     logError('Failed to start server', error);
@@ -97,4 +95,3 @@ try {
 catch (error) {
     writeStartupError(toError(error));
 }
-//# sourceMappingURL=index.js.map

package/dist/{markdown-cleanup.d.ts → lib/content.d.ts}

@@ -1,4 +1,7 @@
-import type { MetadataBlock } from './transform/types.js';
+import { type MetadataBlock } from '../transform/types.js';
+export declare function removeNoiseFromHtml(html: string, document?: Document, baseUrl?: string, signal?: AbortSignal): string;
+export declare function resolveLanguageFromAttributes(className: string, dataLang: string): string | undefined;
+export declare function detectLanguageFromCode(code: string): string | undefined;
 interface CleanupOptions {
     signal?: AbortSignal;
     url?: string;
@@ -9,4 +12,3 @@ export declare function addSourceToMarkdown(content: string, url: string): strin
 export declare function isRawTextContent(content: string): boolean;
 export declare function buildMetadataFooter(metadata?: MetadataBlock, fallbackUrl?: string): string;
 export {};
-//# sourceMappingURL=markdown-cleanup.d.ts.map