@j0hanz/fetch-url-mcp 1.4.0 → 1.5.0

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-export interface CliValues {
+interface CliValues {
     readonly stdio: boolean;
     readonly http: boolean;
     readonly help: boolean;
@@ -12,8 +12,7 @@ interface CliParseFailure {
     readonly ok: false;
     readonly message: string;
 }
-export type CliParseResult = CliParseSuccess | CliParseFailure;
+type CliParseResult = CliParseSuccess | CliParseFailure;
 export declare function renderCliUsage(): string;
 export declare function parseCliArgs(args: readonly string[]): CliParseResult;
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 import { parseArgs } from 'node:util';
-import { getErrorMessage } from './lib/errors.js';
+import { getErrorMessage } from './lib/utils.js';
 const usageLines = [
     'Fetch URL MCP server',
     '',
@@ -63,4 +63,3 @@ export function parseCliArgs(args) {
         };
     }
 }
-//# sourceMappingURL=cli.js.map

package/dist/http/auth.d.ts

@@ -1,5 +1,5 @@
-import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
 import { type RequestContext } from './helpers.js';
 declare class CorsPolicy {
     handle(ctx: RequestContext): boolean;
@@ -8,7 +8,9 @@ export declare const corsPolicy: CorsPolicy;
 declare class HostOriginPolicy {
     validate(ctx: RequestContext): boolean;
     private resolveHostHeader;
-    private resolveOriginHost;
+    private resolveRequestOrigin;
+    private resolveOrigin;
+    private defaultPortForScheme;
     private reject;
 }
 export declare const hostOriginPolicy: HostOriginPolicy;
@@ -33,6 +35,7 @@ declare class AuthService {
     private buildIntrospectionRequest;
     private requestIntrospection;
     private buildIntrospectionAuthInfo;
+    private assertRequiredScopes;
     private verifyWithIntrospection;
 }
 export declare function applyUnauthorizedAuthHeaders(req: IncomingMessage, res: ServerResponse): void;
@@ -46,4 +49,3 @@ export declare function buildProtectedResourceMetadataDocument(req: IncomingMess
 export declare function isProtectedResourceMetadataPath(pathname: string): boolean;
 export declare const authService: AuthService;
 export {};
-//# sourceMappingURL=auth.d.ts.map

package/dist/http/auth.js

@@ -1,10 +1,10 @@
-import { InvalidTokenError, ServerError, } from '@modelcontextprotocol/sdk/server/auth/errors.js';
 import { Buffer } from 'node:buffer';
 import { randomBytes } from 'node:crypto';
-import { config } from '../lib/config.js';
-import { hmacSha256Hex, timingSafeEqualUtf8 } from '../lib/crypto.js';
-import { normalizeHost } from '../lib/host-normalization.js';
-import { isObject } from '../lib/type-guards.js';
+import { InvalidTokenError, ServerError, } from '@modelcontextprotocol/sdk/server/auth/errors.js';
+import { config } from '../lib/core.js';
+import { normalizeHost } from '../lib/url.js';
+import { hmacSha256Hex, timingSafeEqualUtf8 } from '../lib/utils.js';
+import { isObject } from '../lib/utils.js';
 import { getHeaderValue, sendEmpty, sendError, sendJson, } from './helpers.js';
 // ---------------------------------------------------------------------------
 // CORS
@@ -20,9 +20,6 @@ class CorsPolicy {
             res.setHeader('Access-Control-Allow-Origin', origin);
             res.setHeader('Vary', 'Origin');
         }
-        else {
-            res.setHeader('Access-Control-Allow-Origin', '*');
-        }
         res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key, MCP-Protocol-Version, MCP-Session-ID, X-MCP-Session-ID, Last-Event-ID');
         res.setHeader('Access-Control-Expose-Headers', 'MCP-Session-ID, X-MCP-Session-ID, MCP-Protocol-Version, WWW-Authenticate');
@@ -77,10 +74,16 @@ class HostOriginPolicy {
         const originHeader = getHeaderValue(req, 'origin');
         if (!originHeader)
             return true;
-        const originHost = this.resolveOriginHost(originHeader);
-        if (!originHost)
+        const requestOrigin = this.resolveRequestOrigin(req);
+        const origin = this.resolveOrigin(originHeader);
+        if (!requestOrigin || !origin)
             return this.reject(res, 403, 'Invalid Origin header');
-        if (!ALLOWED_HOSTS.has(originHost))
+        if (!ALLOWED_HOSTS.has(origin.host))
+            return this.reject(res, 403, 'Origin not allowed');
+        const isSameOrigin = requestOrigin.scheme === origin.scheme &&
+            requestOrigin.host === origin.host &&
+            requestOrigin.port === origin.port;
+        if (!isSameOrigin)
             return this.reject(res, 403, 'Origin not allowed');
         return true;
     }
@@ -90,17 +93,52 @@ class HostOriginPolicy {
             return null;
         return normalizeHost(host);
     }
-    resolveOriginHost(origin) {
+    resolveRequestOrigin(req) {
+        const hostHeader = getHeaderValue(req, 'host');
+        if (!hostHeader)
+            return null;
+        const isEncrypted = req.socket.encrypted === true;
+        const scheme = isEncrypted ? 'https' : 'http';
+        try {
+            const parsed = new URL(`${scheme}://${hostHeader}`);
+            const normalizedHost = normalizeHost(parsed.host);
+            if (!normalizedHost)
+                return null;
+            return {
+                scheme,
+                host: normalizedHost,
+                port: parsed.port || this.defaultPortForScheme(scheme),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveOrigin(origin) {
         if (origin === 'null')
             return null;
         try {
             const parsed = new URL(origin);
-            return normalizeHost(parsed.host);
+            const scheme = parsed.protocol === 'https:' ? 'https' : 'http';
+            if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+                return null;
+            }
+            const normalizedHost = normalizeHost(parsed.host);
+            if (!normalizedHost)
+                return null;
+            return {
+                scheme,
+                host: normalizedHost,
+                port: parsed.port || this.defaultPortForScheme(scheme),
+            };
         }
         catch {
             return null;
         }
     }
+    defaultPortForScheme(scheme) {
+        return scheme === 'https' ? '443' : '80';
+    }
     reject(res, status, message) {
         sendJson(res, status, { error: message });
         return false;
@@ -293,6 +331,16 @@ class AuthService {
             info.expiresAt = expiresAt;
         return info;
     }
+    assertRequiredScopes(tokenScopes) {
+        const { requiredScopes } = config.auth;
+        if (requiredScopes.length === 0)
+            return;
+        const tokenScopeSet = new Set(tokenScopes);
+        const missing = requiredScopes.filter((s) => !tokenScopeSet.has(s));
+        if (missing.length > 0) {
+            throw new InvalidTokenError('Insufficient scope');
+        }
+    }
     async verifyWithIntrospection(token, signal) {
         if (!config.auth.introspectionUrl) {
             throw new ServerError('Introspection not configured');
@@ -302,7 +350,9 @@ class AuthService {
         if (!isObject(payload) || payload['active'] !== true) {
             throw new InvalidTokenError('Token is inactive');
         }
-        return this.buildIntrospectionAuthInfo(token, payload);
+        const info = this.buildIntrospectionAuthInfo(token, payload);
+        this.assertRequiredScopes(info.scopes);
+        return info;
     }
 }
 function resolvePublicOrigin(req) {
@@ -347,4 +397,3 @@ export function isProtectedResourceMetadataPath(pathname) {
         pathname === '/.well-known/oauth-protected-resource/mcp');
 }
 export const authService = new AuthService();
-//# sourceMappingURL=auth.js.map

package/dist/http/health.d.ts

@@ -1,7 +1,6 @@
-import type { SessionStore } from '../lib/session.js';
+import type { SessionStore } from '../lib/core.js';
 import { type RequestContext } from './helpers.js';
 export declare function resetEventLoopMonitoring(): void;
 export declare function disableEventLoopMonitoring(): void;
 export declare function shouldHandleHealthRoute(ctx: RequestContext): boolean;
 export declare function sendHealthRouteResponse(store: SessionStore, ctx: RequestContext, authPresent: boolean): boolean;
-//# sourceMappingURL=health.d.ts.map

package/dist/http/health.js

@@ -1,8 +1,8 @@
 import { freemem, hostname, totalmem } from 'node:os';
 import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
 import process from 'node:process';
-import { keys as cacheKeys } from '../lib/cache.js';
-import { config, serverVersion } from '../lib/config.js';
+import { keys as cacheKeys } from '../lib/core.js';
+import { config, serverVersion } from '../lib/core.js';
 import { getTransformPoolStats } from '../transform/transform.js';
 import { sendJson } from './helpers.js';
 // ---------------------------------------------------------------------------
@@ -110,20 +110,14 @@ function isVerboseHealthRequest(ctx) {
     const normalized = value.trim().toLowerCase();
     return normalized === '1' || normalized === 'true';
 }
-function isGetHealthRoute(ctx) {
+function isHealthRoute(ctx) {
     return ctx.method === 'GET' && ctx.url.pathname === '/health';
 }
 function isVerboseHealthRoute(ctx) {
-    return isGetHealthRoute(ctx) && isVerboseHealthRequest(ctx);
-}
-function isHealthRoute(ctx) {
-    return isGetHealthRoute(ctx);
+    return isHealthRoute(ctx) && isVerboseHealthRequest(ctx);
 }
 function ensureHealthAuthIfNeeded(ctx, authPresent) {
-    if (!isHealthRoute(ctx))
-        return true;
-    const isVerbose = isVerboseHealthRequest(ctx);
-    if (!isVerbose)
+    if (!isVerboseHealthRoute(ctx))
         return true;
     if (!config.security.allowRemote)
         return true;
@@ -135,14 +129,10 @@ function ensureHealthAuthIfNeeded(ctx, authPresent) {
     return false;
 }
 function resolveHealthDiagnosticsMode(ctx, authPresent) {
-    if (!isVerboseHealthRoute(ctx))
-        return false;
-    if (authPresent)
-        return true;
-    return !config.security.allowRemote;
+    return (isVerboseHealthRoute(ctx) && (authPresent || !config.security.allowRemote));
 }
 export function shouldHandleHealthRoute(ctx) {
-    return isGetHealthRoute(ctx);
+    return isHealthRoute(ctx);
 }
 export function sendHealthRouteResponse(store, ctx, authPresent) {
     if (!shouldHandleHealthRoute(ctx))
@@ -153,4 +143,3 @@ export function sendHealthRouteResponse(store, ctx, authPresent) {
     sendHealth(store, ctx.res, includeDiagnostics);
     return true;
 }
-//# sourceMappingURL=health.js.map

package/dist/http/helpers.d.ts

@@ -1,10 +1,10 @@
+import type { IncomingMessage, Server, ServerResponse } from 'node:http';
+import type { Server as HttpsServer } from 'node:https';
 import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { IncomingMessage, Server, ServerResponse } from 'node:http';
-import type { Server as HttpsServer } from 'node:https';
-import type { JsonRpcId } from '../lib/mcp-validator.js';
+import type { JsonRpcId } from '../lib/mcp-tools.js';
 export type NetworkServer = Server | HttpsServer;
 export interface RequestContext {
     req: IncomingMessage;
@@ -48,4 +48,3 @@ declare class JsonBodyReader {
 }
 export declare const jsonBodyReader: JsonBodyReader;
 export {};
-//# sourceMappingURL=helpers.d.ts.map

package/dist/http/helpers.js

@@ -1,11 +1,23 @@
 import { Buffer } from 'node:buffer';
 import { Writable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { config } from '../lib/config.js';
-import { getErrorMessage, toError } from '../lib/errors.js';
-import { createDefaultBlockList, normalizeIpForBlockList, } from '../lib/ip-blocklist.js';
-import { logWarn } from '../lib/observability.js';
-import { composeCloseHandlers } from '../lib/session.js';
+import { config } from '../lib/core.js';
+import { logWarn } from '../lib/core.js';
+import { composeCloseHandlers } from '../lib/core.js';
+import { createDefaultBlockList, normalizeIpForBlockList } from '../lib/url.js';
+import { getErrorMessage, toError } from '../lib/utils.js';
+function abortControllerBestEffort(controller) {
+    if (!controller.signal.aborted)
+        controller.abort();
+}
+function destroyRequestBestEffort(req) {
+    try {
+        req.destroy();
+    }
+    catch {
+        // Best-effort only.
+    }
+}
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
@@ -90,8 +102,7 @@ export function createRequestAbortSignal(req) {
     const abortRequest = () => {
         if (cleanedUp)
             return;
-        if (!controller.signal.aborted)
-            controller.abort();
+        abortControllerBestEffort(controller);
     };
     if (req.destroyed) {
         abortRequest();
@@ -256,12 +267,7 @@ class JsonBodyReader {
         if (contentLengthHeader) {
             const contentLength = Number.parseInt(contentLengthHeader, 10);
             if (Number.isFinite(contentLength) && contentLength > limit) {
-                try {
-                    req.destroy();
-                }
-                catch {
-                    // Best-effort only.
-                }
+                destroyRequestBestEffort(req);
                 throw new JsonBodyError('payload-too-large', 'Payload too large');
             }
         }
@@ -294,12 +300,7 @@ class JsonBodyReader {
         if (!signal)
             return null;
         const listener = () => {
-            try {
-                req.destroy();
-            }
-            catch {
-                // Best-effort only.
-            }
+            destroyRequestBestEffort(req);
         };
         if (signal.aborted) {
             listener();
@@ -332,7 +333,7 @@ class JsonBodyReader {
                     const buf = this.normalizeChunk(chunk);
                     size += buf.length;
                     if (size > limit) {
-                        req.destroy();
+                        destroyRequestBestEffort(req);
                         callback(new JsonBodyError('payload-too-large', 'Payload too large'));
                         return;
                     }
@@ -369,4 +370,3 @@ class JsonBodyReader {
     }
 }
 export const jsonBodyReader = new JsonBodyReader();
-//# sourceMappingURL=helpers.js.map

package/dist/http/native.d.ts

@@ -3,4 +3,3 @@ export declare function startHttpServer(): Promise<{
     port: number;
     host: string;
 }>;
-//# sourceMappingURL=native.d.ts.map

package/dist/http/native.js

@@ -1,20 +1,20 @@
-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 '../lib/config.js';
-import { handleDownload } from '../lib/download.js';
-import { toError } from '../lib/errors.js';
-import { acceptsEventStream, acceptsJsonAndEventStream, isJsonRpcBatchRequest, isMcpRequestBody, } from '../lib/mcp-validator.js';
-import { cancelTasksForOwner } from '../lib/mcp.js';
-import { logError, logInfo, registerMcpSessionServer, resolveMcpSessionIdByServer, runWithRequestContext, unregisterMcpSessionServer, unregisterMcpSessionServerByServer, } from '../lib/observability.js';
-import { applyHttpServerTuning, drainConnectionsOnShutdown, } from '../lib/server-tuning.js';
-import { composeCloseHandlers, createSessionStore, createSlotTracker, ensureSessionCapacity, reserveSessionSlot, startSessionCleanupLoop, } from '../lib/session.js';
-import { isObject } from '../lib/type-guards.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 { applyUnauthorizedAuthHeaders, assertHttpModeConfiguration, authService, buildAuthFingerprint, buildProtectedResourceMetadataDocument, corsPolicy, ensureMcpProtocolVersion, hostOriginPolicy, isProtectedResourceMetadataPath, SUPPORTED_MCP_PROTOCOL_VERSIONS, } from './auth.js';
 import { disableEventLoopMonitoring, resetEventLoopMonitoring, sendHealthRouteResponse, shouldHandleHealthRoute, } from './health.js';
@@ -37,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;
 }
@@ -71,10 +71,10 @@ class McpSessionGateway {
             return;
         }
         const requestId = body.id ?? null;
-        const isInitMethod = isInitializedNotification(body.method);
-        const isInitNotification = isInitMethod && body.id === undefined;
+        const isInitializedMethod = isInitializedNotification(body.method);
+        const isInitNotification = isInitializedMethod && body.id === undefined;
         const sessionId = getMcpSessionId(ctx.req);
-        if (isInitMethod && !isInitNotification) {
+        if (isInitializedMethod && !isInitNotification) {
             sendError(ctx.res, -32600, 'notifications/initialized must be sent as a notification', 400, requestId);
             return;
         }
@@ -185,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) {
@@ -294,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;
@@ -366,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);
@@ -404,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;
         }
     }
@@ -524,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);
 }
@@ -629,4 +638,3 @@ export async function startHttpServer() {
         }),
     };
 }
-//# sourceMappingURL=native.js.map

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

@@ -11,4 +11,3 @@ export interface RateLimitManagerImpl {
 }
 export declare function createRateLimitManagerImpl(options: RateLimitConfig): RateLimitManagerImpl;
 export {};
-//# sourceMappingURL=rate-limit.d.ts.map

package/dist/http/rate-limit.js

@@ -1,6 +1,6 @@
-import { isAbortError } from '../lib/errors.js';
-import { logWarn } from '../lib/observability.js';
-import { startAbortableIntervalLoop } from '../lib/timer-utils.js';
+import { logWarn } from '../lib/core.js';
+import { isAbortError } from '../lib/utils.js';
+import { startAbortableIntervalLoop } from '../lib/utils.js';
 import { sendJson } from './helpers.js';
 // ---------------------------------------------------------------------------
 // Rate limiter
@@ -85,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,13 +1,17 @@
 #!/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 { startHttpServer } from './http/native.js';
-import { serverVersion } from './lib/config.js';
-import { toError } from './lib/errors.js';
-import { logError } from './lib/observability.js';
 import { startStdioServer } from './server.js';
 const FORCE_EXIT_TIMEOUT_MS = 10_000;
 let forcedExitTimer;
+function writeAndExit(stream, text, code) {
+    stream.write(text);
+    process.exit(code);
+}
 function scheduleForcedExit(reason) {
     if (forcedExitTimer)
         return;
@@ -19,18 +23,14 @@ 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.http;
 let isShuttingDown = false;
@@ -45,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);
@@ -95,4 +95,3 @@ try {
 catch (error) {
     writeStartupError(toError(error));
 }
-//# sourceMappingURL=index.js.map

package/dist/lib/{markdown-cleanup.d.ts → 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