@j0hanz/fetch-url-mcp 1.9.1 → 1.9.2

package/dist/lib/core.js

@@ -56,129 +56,117 @@ function loadEnvFileIfAvailable() {
 }
 loadEnvFileIfAvailable();
 const { env } = process;
-function formatHostForUrl(hostname) {
-    if (hostname.includes(':') && !hostname.startsWith('['))
-        return `[${hostname}]`;
-    return hostname;
-}
-function normalizeHostValue(value) {
-    const raw = value.trim();
-    if (!raw)
-        return null;
-    if (raw.includes('://') && URL.canParse(raw)) {
-        return normalizeHostname(new URL(raw).hostname);
-    }
-    const candidateUrl = `http://${raw}`;
-    if (URL.canParse(candidateUrl)) {
-        return normalizeHostname(new URL(candidateUrl).hostname);
-    }
-    const lowered = raw.toLowerCase();
-    if (lowered.startsWith('[')) {
-        const end = lowered.indexOf(']');
-        if (end === -1)
+const EnvParser = {
+    integerValue(envValue, min, max) {
+        if (!envValue)
             return null;
-        return normalizeHostname(lowered.slice(1, end));
-    }
-    if (isIP(lowered) === 6)
-        return stripTrailingDots(lowered);
-    const firstColon = lowered.indexOf(':');
-    if (firstColon === -1)
-        return normalizeHostname(lowered);
-    if (lowered.includes(':', firstColon + 1))
-        return null;
-    const host = lowered.slice(0, firstColon);
-    return host ? normalizeHostname(host) : null;
-}
-function parseIntegerValue(envValue, min, max) {
-    if (!envValue)
-        return null;
-    const parsed = Number.parseInt(envValue, 10);
-    if (Number.isNaN(parsed))
-        return null;
-    if (min !== undefined && parsed < min)
-        return null;
-    if (max !== undefined && parsed > max)
-        return null;
-    return parsed;
-}
-function parseOptionalInteger(envValue, min, max) {
-    return parseIntegerValue(envValue, min, max) ?? undefined;
-}
-function parseInteger(envValue, defaultValue, min, max) {
-    return parseIntegerValue(envValue, min, max) ?? defaultValue;
-}
-function parseBoolean(envValue, defaultValue) {
-    if (!envValue)
-        return defaultValue;
-    return envValue.trim().toLowerCase() !== 'false';
-}
-function parseList(envValue) {
-    if (!envValue)
-        return [];
-    return envValue
-        .split(/[\s,]+/)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
-function parseListOrDefault(envValue, defaultValue) {
-    const parsed = parseList(envValue);
-    return parsed.length > 0 ? parsed : [...defaultValue];
-}
-function normalizeLocale(value) {
-    if (!value)
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    const lowered = trimmed.toLowerCase();
-    if (lowered === 'system' || lowered === 'default')
-        return undefined;
-    return trimmed;
-}
-function isLogLevel(value) {
-    return ALLOWED_LOG_LEVELS.has(value);
-}
-function parseLogLevel(envValue) {
-    if (!envValue)
-        return 'info';
-    const level = envValue.toLowerCase();
-    return isLogLevel(level) ? level : 'info';
-}
-function parseTransformWorkerMode(envValue) {
-    if (!envValue)
+        const parsed = Number.parseInt(envValue, 10);
+        if (Number.isNaN(parsed))
+            return null;
+        if (min !== undefined && parsed < min)
+            return null;
+        if (max !== undefined && parsed > max)
+            return null;
+        return parsed;
+    },
+    optionalInteger(envValue, min, max) {
+        return EnvParser.integerValue(envValue, min, max) ?? undefined;
+    },
+    integer(envValue, defaultValue, min, max) {
+        return EnvParser.integerValue(envValue, min, max) ?? defaultValue;
+    },
+    boolean(envValue, defaultValue) {
+        if (!envValue)
+            return defaultValue;
+        return envValue.trim().toLowerCase() !== 'false';
+    },
+    list(envValue, defaultValue) {
+        if (!envValue)
+            return defaultValue ? [...defaultValue] : [];
+        const parsed = envValue
+            .split(/[\s,]+/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        return parsed.length > 0 || !defaultValue ? parsed : [...defaultValue];
+    },
+    locale(value) {
+        if (!value)
+            return undefined;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        const lowered = trimmed.toLowerCase();
+        if (lowered === 'system' || lowered === 'default')
+            return undefined;
+        return trimmed;
+    },
+    logLevel(envValue) {
+        if (!envValue)
+            return 'info';
+        const level = envValue.toLowerCase();
+        return ALLOWED_LOG_LEVELS.has(level) ? level : 'info';
+    },
+    transformWorkerMode(envValue) {
+        if (!envValue)
+            return 'threads';
+        const normalized = envValue.trim().toLowerCase();
+        if (normalized === 'process' || normalized === 'fork')
+            return 'process';
         return 'threads';
-    const normalized = envValue.trim().toLowerCase();
-    if (normalized === 'process' || normalized === 'fork')
-        return 'process';
-    return 'threads';
-}
-function parsePort(envValue) {
-    if (envValue?.trim() === '0')
-        return 0;
-    return parseInteger(envValue, 3000, 1024, 65535);
-}
-function parseUrlEnv(value, name) {
-    if (!value)
-        return undefined;
-    if (!URL.canParse(value)) {
-        throw new ConfigError(`Invalid ${name} value: ${value}`);
-    }
-    return new URL(value);
-}
-function readUrlEnv(name) {
-    return parseUrlEnv(env[name], name);
-}
-function parseAllowedHosts(envValue) {
-    return new Set(parseList(envValue)
-        .map(normalizeHostValue)
-        .filter((h) => h !== null));
-}
-function readOptionalFilePath(value) {
-    if (!value)
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
+    },
+    url(value, name) {
+        if (!value)
+            return undefined;
+        if (!URL.canParse(value)) {
+            throw new ConfigError(`Invalid ${name} value: ${value}`);
+        }
+        return new URL(value);
+    },
+    allowedHosts(envValue) {
+        return new Set(EnvParser.list(envValue)
+            .map((h) => EnvParser.normalizeHostValue(h))
+            .filter((h) => h !== null));
+    },
+    optionalFilePath(value) {
+        if (!value)
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    },
+    normalizeHostValue(value) {
+        const raw = value.trim();
+        if (!raw)
+            return null;
+        if (raw.includes('://') && URL.canParse(raw)) {
+            return normalizeHostname(new URL(raw).hostname);
+        }
+        const candidateUrl = `http://${raw}`;
+        if (URL.canParse(candidateUrl)) {
+            return normalizeHostname(new URL(candidateUrl).hostname);
+        }
+        const lowered = raw.toLowerCase();
+        if (lowered.startsWith('[')) {
+            const end = lowered.indexOf(']');
+            if (end === -1)
+                return null;
+            return normalizeHostname(lowered.slice(1, end));
+        }
+        if (isIP(lowered) === 6)
+            return stripTrailingDots(lowered);
+        const firstColon = lowered.indexOf(':');
+        if (firstColon === -1)
+            return normalizeHostname(lowered);
+        if (lowered.includes(':', firstColon + 1))
+            return null;
+        const host = lowered.slice(0, firstColon);
+        return host ? normalizeHostname(host) : null;
+    },
+    formatHostForUrl(hostname) {
+        if (hostname.includes(':') && !hostname.startsWith('['))
+            return `[${hostname}]`;
+        return hostname;
+    },
+};
 function assertFileReadable(filePath, envVar) {
     try {
         accessSync(filePath, fsConstants.R_OK);
@@ -188,55 +176,59 @@ function assertFileReadable(filePath, envVar) {
     }
 }
 const MAX_HTML_BYTES = 10 * 1024 * 1024;
-const MAX_INLINE_CONTENT_CHARS = parseInteger(env['MAX_INLINE_CONTENT_CHARS'], 0, 0, MAX_HTML_BYTES);
+const MAX_INLINE_CONTENT_CHARS = EnvParser.integer(env['MAX_INLINE_CONTENT_CHARS'], 0, 0, MAX_HTML_BYTES);
 const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
 const DEFAULT_SESSION_INIT_TIMEOUT_MS = 10000;
 const DEFAULT_MAX_SESSIONS = 200;
 const DEFAULT_USER_AGENT = `fetch-url-mcp/${serverVersion}`;
 const DEFAULT_TOOL_TIMEOUT_PADDING_MS = 5000;
 const DEFAULT_TRANSFORM_TIMEOUT_MS = 30000;
-const DEFAULT_FETCH_TIMEOUT_MS = parseInteger(env['FETCH_TIMEOUT_MS'], 15000, 1000, 60000);
+const DEFAULT_FETCH_TIMEOUT_MS = EnvParser.integer(env['FETCH_TIMEOUT_MS'], 15000, 1000, 60000);
 const DEFAULT_TOOL_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS +
     DEFAULT_TRANSFORM_TIMEOUT_MS +
     DEFAULT_TOOL_TIMEOUT_PADDING_MS;
-const DEFAULT_TASKS_MAX_TOTAL = parseInteger(env['TASKS_MAX_TOTAL'], 5000, 1);
-const DEFAULT_TASKS_MAX_PER_OWNER = parseInteger(env['TASKS_MAX_PER_OWNER'], 1000, 1);
+const DEFAULT_TASKS_MAX_TOTAL = EnvParser.integer(env['TASKS_MAX_TOTAL'], 5000, 1);
+const DEFAULT_TASKS_MAX_PER_OWNER = EnvParser.integer(env['TASKS_MAX_PER_OWNER'], 1000, 1);
 const RESOLVED_TASKS_MAX_PER_OWNER = Math.min(DEFAULT_TASKS_MAX_PER_OWNER, DEFAULT_TASKS_MAX_TOTAL);
 function resolveWorkerResourceLimits() {
-    const limits = {};
-    let hasAny = false;
-    const entries = [
-        [
-            'maxOldGenerationSizeMb',
-            parseOptionalInteger(env['TRANSFORM_WORKER_MAX_OLD_GENERATION_MB'], 1),
-        ],
-        [
-            'maxYoungGenerationSizeMb',
-            parseOptionalInteger(env['TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB'], 1),
-        ],
-        [
-            'codeRangeSizeMb',
-            parseOptionalInteger(env['TRANSFORM_WORKER_CODE_RANGE_MB'], 1),
-        ],
-        ['stackSizeMb', parseOptionalInteger(env['TRANSFORM_WORKER_STACK_MB'], 1)],
-    ];
-    for (const [key, value] of entries) {
-        if (value === undefined)
-            continue;
-        limits[key] = value;
-        hasAny = true;
+    const maxOldGenerationSizeMb = EnvParser.optionalInteger(env['TRANSFORM_WORKER_MAX_OLD_GENERATION_MB'], 1);
+    const maxYoungGenerationSizeMb = EnvParser.optionalInteger(env['TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB'], 1);
+    const codeRangeSizeMb = EnvParser.optionalInteger(env['TRANSFORM_WORKER_CODE_RANGE_MB'], 1);
+    const stackSizeMb = EnvParser.optionalInteger(env['TRANSFORM_WORKER_STACK_MB'], 1);
+    if (maxOldGenerationSizeMb === undefined &&
+        maxYoungGenerationSizeMb === undefined &&
+        codeRangeSizeMb === undefined &&
+        stackSizeMb === undefined) {
+        return undefined;
     }
-    return hasAny ? limits : undefined;
-}
-function readOAuthUrls(baseUrl) {
-    const issuerUrl = readUrlEnv('OAUTH_ISSUER_URL');
-    const authorizationUrl = readUrlEnv('OAUTH_AUTHORIZATION_URL');
-    const tokenUrl = readUrlEnv('OAUTH_TOKEN_URL');
-    const revocationUrl = readUrlEnv('OAUTH_REVOCATION_URL');
-    const registrationUrl = readUrlEnv('OAUTH_REGISTRATION_URL');
-    const introspectionUrl = readUrlEnv('OAUTH_INTROSPECTION_URL');
+    const limits = {};
+    if (maxOldGenerationSizeMb !== undefined)
+        limits.maxOldGenerationSizeMb = maxOldGenerationSizeMb;
+    if (maxYoungGenerationSizeMb !== undefined)
+        limits.maxYoungGenerationSizeMb = maxYoungGenerationSizeMb;
+    if (codeRangeSizeMb !== undefined)
+        limits.codeRangeSizeMb = codeRangeSizeMb;
+    if (stackSizeMb !== undefined)
+        limits.stackSizeMb = stackSizeMb;
+    return limits;
+}
+function buildAuthConfig(baseUrl) {
+    const issuerUrl = EnvParser.url(env['OAUTH_ISSUER_URL'], 'OAUTH_ISSUER_URL');
+    const authorizationUrl = EnvParser.url(env['OAUTH_AUTHORIZATION_URL'], 'OAUTH_AUTHORIZATION_URL');
+    const tokenUrl = EnvParser.url(env['OAUTH_TOKEN_URL'], 'OAUTH_TOKEN_URL');
+    const revocationUrl = EnvParser.url(env['OAUTH_REVOCATION_URL'], 'OAUTH_REVOCATION_URL');
+    const registrationUrl = EnvParser.url(env['OAUTH_REGISTRATION_URL'], 'OAUTH_REGISTRATION_URL');
+    const introspectionUrl = EnvParser.url(env['OAUTH_INTROSPECTION_URL'], 'OAUTH_INTROSPECTION_URL');
     const resourceUrl = new URL('/mcp', baseUrl);
+    const oauthConfigured = issuerUrl !== undefined ||
+        authorizationUrl !== undefined ||
+        tokenUrl !== undefined ||
+        introspectionUrl !== undefined;
+    const tokens = EnvParser.list(env['ACCESS_TOKENS']);
+    if (env['API_KEY'])
+        tokens.push(env['API_KEY']);
     return {
+        mode: oauthConfigured ? 'oauth' : 'static',
         issuerUrl,
         authorizationUrl,
         tokenUrl,
@@ -244,40 +236,17 @@ function readOAuthUrls(baseUrl) {
         registrationUrl,
         introspectionUrl,
         resourceUrl,
-    };
-}
-function resolveAuthMode(urls) {
-    const oauthConfigured = [
-        urls.issuerUrl,
-        urls.authorizationUrl,
-        urls.tokenUrl,
-        urls.introspectionUrl,
-    ].some((value) => value !== undefined);
-    return oauthConfigured ? 'oauth' : 'static';
-}
-function collectStaticTokens() {
-    const tokens = parseList(env['ACCESS_TOKENS']);
-    if (env['API_KEY'])
-        tokens.push(env['API_KEY']);
-    return [...new Set(tokens)];
-}
-function buildAuthConfig(baseUrl) {
-    const urls = readOAuthUrls(baseUrl);
-    const mode = resolveAuthMode(urls);
-    return {
-        mode,
-        ...urls,
-        requiredScopes: parseList(env['OAUTH_REQUIRED_SCOPES']),
+        requiredScopes: EnvParser.list(env['OAUTH_REQUIRED_SCOPES']),
         clientId: env['OAUTH_CLIENT_ID'],
         clientSecret: env['OAUTH_CLIENT_SECRET'],
         introspectionTimeoutMs: 5000,
-        staticTokens: collectStaticTokens(),
+        staticTokens: [...new Set(tokens)],
     };
 }
 function buildHttpsConfig() {
-    const keyFile = readOptionalFilePath(env['SERVER_TLS_KEY_FILE']);
-    const certFile = readOptionalFilePath(env['SERVER_TLS_CERT_FILE']);
-    const caFile = readOptionalFilePath(env['SERVER_TLS_CA_FILE']);
+    const keyFile = EnvParser.optionalFilePath(env['SERVER_TLS_KEY_FILE']);
+    const certFile = EnvParser.optionalFilePath(env['SERVER_TLS_CERT_FILE']);
+    const caFile = EnvParser.optionalFilePath(env['SERVER_TLS_CA_FILE']);
     if (keyFile)
         assertFileReadable(keyFile, 'SERVER_TLS_KEY_FILE');
     if (certFile)
@@ -310,23 +279,17 @@ const BLOCKED_HOSTS = new Set([
     'instance-data',
 ]);
 const host = (env['HOST'] ?? LOOPBACK_V4).trim();
-const port = parsePort(env['PORT']);
+const port = env['PORT']?.trim() === '0'
+    ? 0
+    : EnvParser.integer(env['PORT'], 3000, 1024, 65535);
 const httpsConfig = buildHttpsConfig();
-const maxConnections = parseInteger(env['SERVER_MAX_CONNECTIONS'], 0, 0);
-const headersTimeoutMs = parseOptionalInteger(env['SERVER_HEADERS_TIMEOUT_MS'], 1);
-const requestTimeoutMs = parseOptionalInteger(env['SERVER_REQUEST_TIMEOUT_MS'], 0);
-const keepAliveTimeoutMs = parseOptionalInteger(env['SERVER_KEEP_ALIVE_TIMEOUT_MS'], 1);
-const keepAliveTimeoutBufferMs = parseOptionalInteger(env['SERVER_KEEP_ALIVE_TIMEOUT_BUFFER_MS'], 0);
-const maxHeadersCount = parseOptionalInteger(env['SERVER_MAX_HEADERS_COUNT'], 1);
-const blockPrivateConnections = parseBoolean(env['SERVER_BLOCK_PRIVATE_CONNECTIONS'], false);
-const allowRemote = parseBoolean(env['ALLOW_REMOTE'], false);
-const requireProtocolVersionHeaderOnSessionInit = parseBoolean(env['MCP_STRICT_PROTOCOL_VERSION_HEADER'], true);
-const baseUrl = new URL(`${httpsConfig.enabled ? 'https' : 'http'}://${formatHostForUrl(host)}:${port}`);
+const allowRemote = EnvParser.boolean(env['ALLOW_REMOTE'], false);
+const baseUrl = new URL(`${httpsConfig.enabled ? 'https' : 'http'}://${EnvParser.formatHostForUrl(host)}:${port}`);
 const runtimeState = {
     httpMode: false,
 };
-export const config = {
-    server: {
+function buildServerConfig() {
+    return {
         name: 'fetch-url-mcp',
         version: serverVersion,
         port,
@@ -336,56 +299,57 @@ export const config = {
         sessionInitTimeoutMs: DEFAULT_SESSION_INIT_TIMEOUT_MS,
         maxSessions: DEFAULT_MAX_SESSIONS,
         http: {
-            headersTimeoutMs,
-            requestTimeoutMs,
-            keepAliveTimeoutMs,
-            keepAliveTimeoutBufferMs,
-            maxHeadersCount,
-            maxConnections,
-            blockPrivateConnections,
-            requireProtocolVersionHeaderOnSessionInit,
+            headersTimeoutMs: EnvParser.optionalInteger(env['SERVER_HEADERS_TIMEOUT_MS'], 1),
+            requestTimeoutMs: EnvParser.optionalInteger(env['SERVER_REQUEST_TIMEOUT_MS'], 0),
+            keepAliveTimeoutMs: EnvParser.optionalInteger(env['SERVER_KEEP_ALIVE_TIMEOUT_MS'], 1),
+            keepAliveTimeoutBufferMs: EnvParser.optionalInteger(env['SERVER_KEEP_ALIVE_TIMEOUT_BUFFER_MS'], 0),
+            maxHeadersCount: EnvParser.optionalInteger(env['SERVER_MAX_HEADERS_COUNT'], 1),
+            maxConnections: EnvParser.integer(env['SERVER_MAX_CONNECTIONS'], 0, 0),
+            blockPrivateConnections: EnvParser.boolean(env['SERVER_BLOCK_PRIVATE_CONNECTIONS'], false),
             shutdownCloseIdleConnections: true,
             shutdownCloseAllConnections: false,
         },
-    },
-    fetcher: {
+    };
+}
+function buildFetcherConfig() {
+    return {
         timeout: DEFAULT_FETCH_TIMEOUT_MS,
         maxRedirects: 5,
         userAgent: env['USER_AGENT'] ?? DEFAULT_USER_AGENT,
         maxContentLength: MAX_HTML_BYTES,
-    },
-    transform: {
+    };
+}
+function buildTransformConfig() {
+    return {
         timeoutMs: DEFAULT_TRANSFORM_TIMEOUT_MS,
         stageWarnRatio: 0.5,
         metadataFormat: 'markdown',
         maxWorkerScale: 4,
-        cancelAckTimeoutMs: parseInteger(env['TRANSFORM_CANCEL_ACK_TIMEOUT_MS'], 200, 50, 5000),
-        workerMode: parseTransformWorkerMode(env['TRANSFORM_WORKER_MODE']),
+        cancelAckTimeoutMs: EnvParser.integer(env['TRANSFORM_CANCEL_ACK_TIMEOUT_MS'], 200, 50, 5000),
+        workerMode: EnvParser.transformWorkerMode(env['TRANSFORM_WORKER_MODE']),
         workerResourceLimits: resolveWorkerResourceLimits(),
-    },
-    tools: {
-        enabled: ['fetch-url'],
-        timeoutMs: DEFAULT_TOOL_TIMEOUT_MS,
-    },
-    tasks: {
+    };
+}
+function buildTasksConfig() {
+    return {
         maxTotal: DEFAULT_TASKS_MAX_TOTAL,
         maxPerOwner: RESOLVED_TASKS_MAX_PER_OWNER,
-        emitStatusNotifications: parseBoolean(env['TASKS_STATUS_NOTIFICATIONS'], false),
-        requireInterception: parseBoolean(env['TASKS_REQUIRE_INTERCEPTION'], true),
-    },
-    cache: {
-        enabled: parseBoolean(env['CACHE_ENABLED'], true),
+        emitStatusNotifications: EnvParser.boolean(env['TASKS_STATUS_NOTIFICATIONS'], false),
+        requireInterception: EnvParser.boolean(env['TASKS_REQUIRE_INTERCEPTION'], true),
+    };
+}
+function buildCacheConfig() {
+    return {
+        enabled: EnvParser.boolean(env['CACHE_ENABLED'], true),
         ttl: 86400,
         maxKeys: 100,
-        maxSizeBytes: 50 * 1024 * 1024, // 50MB
-    },
-    extraction: {
-        maxBlockLength: 5000,
-        minParagraphLength: 10,
-    },
-    noiseRemoval: {
-        extraTokens: parseList(env['FETCH_URL_MCP_EXTRA_NOISE_TOKENS']),
-        extraSelectors: parseList(env['FETCH_URL_MCP_EXTRA_NOISE_SELECTORS']),
+        maxSizeBytes: 50 * 1024 * 1024,
+    };
+}
+function buildNoiseRemovalConfig() {
+    return {
+        extraTokens: EnvParser.list(env['FETCH_URL_MCP_EXTRA_NOISE_TOKENS']),
+        extraSelectors: EnvParser.list(env['FETCH_URL_MCP_EXTRA_NOISE_SELECTORS']),
         enabledCategories: [
             'cookie-banners',
             'newsletters',
@@ -402,19 +366,38 @@ export const config = {
             stickyFixed: 30,
             threshold: 50,
         },
-    },
-    markdownCleanup: {
+    };
+}
+function buildMarkdownCleanupConfig() {
+    return {
         promoteOrphanHeadings: true,
         removeSkipLinks: true,
         removeTocBlocks: true,
         removeTypeDocComments: true,
-        headingKeywords: parseListOrDefault(env['MARKDOWN_HEADING_KEYWORDS'], DEFAULT_HEADING_KEYWORDS),
+        headingKeywords: EnvParser.list(env['MARKDOWN_HEADING_KEYWORDS'], DEFAULT_HEADING_KEYWORDS),
+    };
+}
+export const config = {
+    server: buildServerConfig(),
+    fetcher: buildFetcherConfig(),
+    transform: buildTransformConfig(),
+    tools: {
+        enabled: ['fetch-url'],
+        timeoutMs: DEFAULT_TOOL_TIMEOUT_MS,
     },
+    tasks: buildTasksConfig(),
+    cache: buildCacheConfig(),
+    extraction: {
+        maxBlockLength: 5000,
+        minParagraphLength: 10,
+    },
+    noiseRemoval: buildNoiseRemovalConfig(),
+    markdownCleanup: buildMarkdownCleanupConfig(),
     i18n: {
-        locale: normalizeLocale(env['FETCH_URL_MCP_LOCALE']),
+        locale: EnvParser.locale(env['FETCH_URL_MCP_LOCALE']),
     },
     logging: {
-        level: parseLogLevel(env['LOG_LEVEL']),
+        level: EnvParser.logLevel(env['LOG_LEVEL']),
         format: env['LOG_FORMAT']?.toLowerCase() === 'json' ? 'json' : 'text',
     },
     constants: {
@@ -424,10 +407,10 @@ export const config = {
     },
     security: {
         blockedHosts: BLOCKED_HOSTS,
-        allowedHosts: parseAllowedHosts(env['ALLOWED_HOSTS']),
+        allowedHosts: EnvParser.allowedHosts(env['ALLOWED_HOSTS']),
         apiKey: env['API_KEY'],
         allowRemote,
-        allowLocalFetch: parseBoolean(env['ALLOW_LOCAL_FETCH'], false),
+        allowLocalFetch: EnvParser.boolean(env['ALLOW_LOCAL_FETCH'], false),
     },
     auth: buildAuthConfig(baseUrl),
     rateLimit: {
@@ -441,40 +424,30 @@ export const config = {
 export function enableHttpMode() {
     runtimeState.httpMode = true;
 }
-const CACHE_CONSTANTS = {
-    URL_HASH_LENGTH: 32,
-    VARY_HASH_LENGTH: 16,
-};
-function createHashFragment(input, length) {
-    return sha256Hex(input).substring(0, length);
-}
-function buildCacheKey(namespace, urlHash, varyHash) {
-    return varyHash
-        ? `${namespace}:${urlHash}.${varyHash}`
-        : `${namespace}:${urlHash}`;
-}
-function resolveVaryString(vary) {
-    if (typeof vary === 'string')
-        return vary;
-    try {
-        return stableJsonStringify(vary);
-    }
-    catch {
-        return null;
-    }
-}
 export function createCacheKey(namespace, url, vary) {
     if (!namespace || !url)
         return null;
-    const urlHash = createHashFragment(url, CACHE_CONSTANTS.URL_HASH_LENGTH);
+    const urlHash = sha256Hex(url).substring(0, 32);
     if (!vary)
-        return buildCacheKey(namespace, urlHash);
-    const varyString = resolveVaryString(vary);
+        return `${namespace}:${urlHash}`;
+    const varyString = typeof vary === 'string'
+        ? vary
+        : (() => {
+            try {
+                return stableJsonStringify(vary);
+            }
+            catch {
+                return null;
+            }
+        })();
     if (varyString === null)
         return null;
-    return buildCacheKey(namespace, urlHash, varyString
-        ? createHashFragment(varyString, CACHE_CONSTANTS.VARY_HASH_LENGTH)
-        : undefined);
+    const varyHash = varyString
+        ? sha256Hex(varyString).substring(0, 16)
+        : undefined;
+    return varyHash
+        ? `${namespace}:${urlHash}.${varyHash}`
+        : `${namespace}:${urlHash}`;
 }
 export function parseCacheKey(cacheKey) {
     if (!cacheKey)
@@ -745,33 +718,23 @@ export function getOperationId() {
 function isDebugEnabled() {
     return config.logging.level === 'debug';
 }
-function buildContextMetadata() {
+function mergeMetadata(meta) {
     const ctx = requestContext.getStore();
+    const hasMeta = meta && Object.keys(meta).length > 0;
     if (!ctx)
-        return undefined;
+        return hasMeta ? meta : undefined;
     const { requestId, operationId, sessionId } = ctx;
     const includeSession = sessionId && isDebugEnabled();
     if (!requestId && !operationId && !includeSession)
-        return undefined;
-    const meta = {};
+        return hasMeta ? meta : undefined;
+    const contextMeta = {};
     if (requestId)
-        meta['requestId'] = requestId;
+        contextMeta['requestId'] = requestId;
     if (operationId)
-        meta['operationId'] = operationId;
+        contextMeta['operationId'] = operationId;
     if (includeSession)
-        meta['sessionId'] = sessionId;
-    return meta;
-}
-function mergeMetadata(meta) {
-    const contextMeta = buildContextMetadata();
-    const hasMeta = meta && Object.keys(meta).length > 0;
-    if (!contextMeta && !hasMeta)
-        return undefined;
-    if (!contextMeta)
-        return meta;
-    if (!hasMeta)
-        return contextMeta;
-    return { ...contextMeta, ...meta };
+        contextMeta['sessionId'] = sessionId;
+    return hasMeta ? { ...contextMeta, ...meta } : contextMeta;
 }
 function formatMetadata(meta) {
     const merged = mergeMetadata(meta);
@@ -806,36 +769,25 @@ const LEVEL_PRIORITY = {
 function shouldLog(level) {
     return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[config.logging.level];
 }
+const LOG_LEVEL_ALIASES = {
+    debug: 'debug',
+    info: 'info',
+    notice: 'info',
+    warning: 'warn',
+    warn: 'warn',
+    error: 'error',
+    critical: 'error',
+    alert: 'error',
+    emergency: 'error',
+};
 function normalizeLogLevel(level) {
-    switch (level.toLowerCase()) {
-        case 'debug':
-            return 'debug';
-        case 'info':
-        case 'notice':
-            return 'info';
-        case 'warning':
-        case 'warn':
-            return 'warn';
-        case 'error':
-        case 'critical':
-        case 'alert':
-        case 'emergency':
-            return 'error';
-        default:
-            return undefined;
-    }
-}
-function resolveMcpLogLevel(sessionId) {
-    if (sessionId) {
-        return sessionMcpLogLevels.get(sessionId) ?? config.logging.level;
-    }
-    return stdioMcpLogLevel ?? config.logging.level;
+    return LOG_LEVEL_ALIASES[level.toLowerCase()];
 }
 function shouldForwardMcpLog(level, sessionId) {
-    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[resolveMcpLogLevel(sessionId)];
-}
-function mapToMcpLevel(level) {
-    return level === 'warn' ? 'warning' : level;
+    const mcpLevel = sessionId
+        ? (sessionMcpLogLevels.get(sessionId) ?? config.logging.level)
+        : (stdioMcpLogLevel ?? config.logging.level);
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[mcpLevel];
 }
 function resolveErrorText(err) {
     if (err instanceof Error) {
@@ -886,7 +838,7 @@ function writeLog(level, message, meta) {
     try {
         server.server
             .sendLoggingMessage({
-            level: mapToMcpLevel(level),
+            level: level === 'warn' ? 'warning' : level,
             logger: 'fetch-url-mcp',
             // Preserve existing behavior: MCP payload includes only message + provided meta (not ALS context meta).
             data: meta ? { message, ...meta } : message,
@@ -933,7 +885,10 @@ export function logError(message, error) {
     writeLog('error', message, errorMeta);
 }
 export function getMcpLogLevel(sessionId) {
-    return resolveMcpLogLevel(sessionId);
+    if (sessionId) {
+        return sessionMcpLogLevels.get(sessionId) ?? config.logging.level;
+    }
+    return stdioMcpLogLevel ?? config.logging.level;
 }
 export function setLogLevel(level, sessionId) {
     const normalized = normalizeLogLevel(level);
@@ -990,11 +945,6 @@ function logRejectedSettledResults(results, message) {
         }
     }
 }
-function isSessionExpired(session, now, sessionTtlMs) {
-    if (sessionTtlMs <= 0)
-        return false;
-    return now - session.lastSeen > sessionTtlMs;
-}
 class SessionCleanupLoop {
     store;
     sessionTtlMs;
@@ -1075,18 +1025,6 @@ class SessionCleanupLoop {
 export function startSessionCleanupLoop(store, sessionTtlMs, options) {
     return new SessionCleanupLoop(store, sessionTtlMs, options?.onEvictSession, options?.cleanupIntervalMs).start();
 }
-function moveSessionToEnd(sessions, sessionId, session) {
-    sessions.delete(sessionId);
-    sessions.set(sessionId, session);
-}
-function removeSessionById(sessions, sessionId) {
-    const session = sessions.get(sessionId);
-    sessions.delete(sessionId);
-    return session;
-}
-function isBlankSessionId(sessionId) {
-    return sessionId.length === 0;
-}
 class InMemorySessionStore {
     sessionTtlMs;
     sessions = new Map();
@@ -1095,28 +1033,32 @@ class InMemorySessionStore {
         this.sessionTtlMs = sessionTtlMs;
     }
     get(sessionId) {
-        if (isBlankSessionId(sessionId))
+        if (sessionId.length === 0)
             return undefined;
         return this.sessions.get(sessionId);
     }
     touch(sessionId) {
-        if (isBlankSessionId(sessionId))
+        if (sessionId.length === 0)
             return;
         const session = this.sessions.get(sessionId);
         if (!session)
             return;
         session.lastSeen = Date.now();
-        moveSessionToEnd(this.sessions, sessionId, session);
+        this.sessions.delete(sessionId);
+        this.sessions.set(sessionId, session);
     }
     set(sessionId, entry) {
-        if (isBlankSessionId(sessionId))
+        if (sessionId.length === 0)
             return;
-        moveSessionToEnd(this.sessions, sessionId, entry);
+        this.sessions.delete(sessionId);
+        this.sessions.set(sessionId, entry);
     }
     remove(sessionId) {
-        if (isBlankSessionId(sessionId))
+        if (sessionId.length === 0)
             return undefined;
-        return removeSessionById(this.sessions, sessionId);
+        const session = this.sessions.get(sessionId);
+        this.sessions.delete(sessionId);
+        return session;
     }
     size() {
         return this.sessions.size;
@@ -1141,10 +1083,13 @@ class InMemorySessionStore {
         const now = Date.now();
         const evicted = [];
         for (const [id, session] of this.sessions.entries()) {
-            if (!isSessionExpired(session, now, this.sessionTtlMs))
-                continue;
-            this.sessions.delete(id);
-            evicted.push(session);
+            if (this.sessionTtlMs > 0 && now - session.lastSeen > this.sessionTtlMs) {
+                this.sessions.delete(id);
+                evicted.push(session);
+            }
+            else {
+                break;
+            }
         }
         return evicted;
     }
@@ -1152,49 +1097,40 @@ class InMemorySessionStore {
         const oldest = this.sessions.keys().next();
         if (oldest.done)
             return undefined;
-        return removeSessionById(this.sessions, oldest.value);
+        const session = this.sessions.get(oldest.value);
+        this.sessions.delete(oldest.value);
+        return session;
     }
 }
 export function createSessionStore(sessionTtlMs) {
     return new InMemorySessionStore(sessionTtlMs);
 }
-class SessionSlotTracker {
-    store;
-    slotReleased = false;
-    initialized = false;
-    constructor(store) {
-        this.store = store;
-    }
-    releaseSlot() {
-        if (this.slotReleased)
-            return;
-        this.slotReleased = true;
-        this.store.decrementInFlight();
-    }
-    markInitialized() {
-        this.initialized = true;
-    }
-    isInitialized() {
-        return this.initialized;
-    }
-}
 export function createSlotTracker(store) {
-    return new SessionSlotTracker(store);
-}
-function currentLoad(store) {
-    return store.size() + store.inFlight();
+    let slotReleased = false;
+    let initialized = false;
+    return {
+        releaseSlot() {
+            if (slotReleased)
+                return;
+            slotReleased = true;
+            store.decrementInFlight();
+        },
+        markInitialized() {
+            initialized = true;
+        },
+        isInitialized() {
+            return initialized;
+        },
+    };
 }
 export function reserveSessionSlot(store, maxSessions) {
     if (maxSessions <= 0)
         return false;
-    if (currentLoad(store) >= maxSessions)
+    if (store.size() + store.inFlight() >= maxSessions)
         return false;
     store.incrementInFlight();
     return true;
 }
-function isAtCapacity(store, maxSessions) {
-    return currentLoad(store) >= maxSessions;
-}
 export function ensureSessionCapacity({ store, maxSessions, evictOldest, }) {
     if (maxSessions <= 0)
         return false;
@@ -1207,5 +1143,5 @@ export function ensureSessionCapacity({ store, maxSessions, evictOldest, }) {
         return false;
     if (!evictOldest(store))
         return false;
-    return !isAtCapacity(store, maxSessions);
+    return store.size() + store.inFlight() < maxSessions;
 }