@j0hanz/fetch-url-mcp 1.1.0 → 1.1.2

package/dist/cache.d.ts

@@ -5,22 +5,22 @@ declare const CachedPayloadSchema: z.ZodObject<{
     markdown: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type CachedPayload = z.infer<typeof CachedPayloadSchema>;
-export interface CacheEntry {
+type CachedPayload = z.infer<typeof CachedPayloadSchema>;
+interface CacheEntry {
     url: string;
     title?: string;
     content: string;
     fetchedAt: string;
     expiresAt: string;
 }
-export interface CacheKeyParts {
+interface CacheKeyParts {
     namespace: string;
     urlHash: string;
 }
-export interface CacheSetOptions {
+interface CacheSetOptions {
     force?: boolean;
 }
-export interface CacheGetOptions {
+interface CacheGetOptions {
     force?: boolean;
 }
 interface CacheEntryMetadata {

package/dist/cache.js

@@ -93,13 +93,16 @@ class InMemoryCacheStore {
     isEnabled() {
         return config.cache.enabled;
     }
+    isExpired(entry, now = Date.now()) {
+        return entry.expiresAtMs <= now;
+    }
     keys() {
         if (!this.isEnabled())
             return [];
         const now = Date.now();
         const result = [];
         for (const [key, entry] of this.entries) {
-            if (entry.expiresAtMs > now)
+            if (!this.isExpired(entry, now))
                 result.push(key);
         }
         return result;
@@ -130,7 +133,7 @@ class InMemoryCacheStore {
         if (!entry)
             return undefined;
         const now = Date.now();
-        if (entry.expiresAtMs <= now) {
+        if (this.isExpired(entry, now)) {
             this.delete(cacheKey);
             this.notify(cacheKey, true);
             return undefined;

package/dist/cli.js

@@ -19,6 +19,17 @@ const optionSchema = {
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function toBoolean(value) {
+    return value === true;
+}
+function buildCliValues(values) {
+    const { stdio, help, version } = values;
+    return {
+        stdio: toBoolean(stdio),
+        help: toBoolean(help),
+        version: toBoolean(version),
+    };
+}
 export function renderCliUsage() {
     return `${usageLines.join('\n')}\n`;
 }
@@ -32,11 +43,7 @@ export function parseCliArgs(args) {
         });
         return {
             ok: true,
-            values: {
-                stdio: values.stdio,
-                help: values.help,
-                version: values.version,
-            },
+            values: buildCliValues(values),
         };
     }
     catch (error) {

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 export declare const serverVersion: string;
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export type TransformWorkerMode = 'threads' | 'process';
+type TransformWorkerMode = 'threads' | 'process';
 type AuthMode = 'oauth' | 'static';
 interface WorkerResourceLimits {
     maxOldGenerationSizeMb?: number;

package/dist/config.js

@@ -233,24 +233,25 @@ const RESOLVED_TASKS_MAX_PER_OWNER = Math.min(DEFAULT_TASKS_MAX_PER_OWNER, DEFAU
 function resolveWorkerResourceLimits() {
     const limits = {};
     let hasAny = false;
-    const maxOldGenerationSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_MAX_OLD_GENERATION_MB'], 1);
-    const maxYoungGenerationSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_MAX_YOUNG_GENERATION_MB'], 1);
-    const codeRangeSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_CODE_RANGE_MB'], 1);
-    const stackSizeMb = parseOptionalInteger(env['TRANSFORM_WORKER_STACK_MB'], 1);
-    if (maxOldGenerationSizeMb !== undefined) {
-        limits.maxOldGenerationSizeMb = maxOldGenerationSizeMb;
-        hasAny = true;
-    }
-    if (maxYoungGenerationSizeMb !== undefined) {
-        limits.maxYoungGenerationSizeMb = maxYoungGenerationSizeMb;
-        hasAny = true;
-    }
-    if (codeRangeSizeMb !== undefined) {
-        limits.codeRangeSizeMb = codeRangeSizeMb;
-        hasAny = true;
-    }
-    if (stackSizeMb !== undefined) {
-        limits.stackSizeMb = stackSizeMb;
+    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;
     }
     return hasAny ? limits : undefined;

package/dist/crypto.js

@@ -18,6 +18,11 @@ function assertAllowedAlgorithm(algorithm) {
         throw new Error(`Hash algorithm not allowed: ${algorithm}`);
     }
 }
+function padBuffer(buffer, length) {
+    const padded = Buffer.alloc(length);
+    buffer.copy(padded);
+    return padded;
+}
 export function timingSafeEqualUtf8(a, b) {
     const aBuffer = Buffer.from(a, 'utf8');
     const bBuffer = Buffer.from(b, 'utf8');
@@ -26,10 +31,8 @@ export function timingSafeEqualUtf8(a, b) {
     }
     // Avoid early return timing differences on length mismatch.
     const maxLength = Math.max(aBuffer.length, bBuffer.length);
-    const paddedA = Buffer.alloc(maxLength);
-    const paddedB = Buffer.alloc(maxLength);
-    aBuffer.copy(paddedA);
-    bBuffer.copy(paddedB);
+    const paddedA = padBuffer(aBuffer, maxLength);
+    const paddedB = padBuffer(bBuffer, maxLength);
     return timingSafeEqual(paddedA, paddedB) && aBuffer.length === bBuffer.length;
 }
 function hashHex(algorithm, input) {

package/dist/dom-noise-removal.js

@@ -103,22 +103,25 @@ function buildTokenRegex(tokens) {
         return NO_MATCH_REGEX;
     return new RegExp(`(?:^|[^a-z0-9])(?:${[...tokens].map(escapeRegexLiteral).join('|')})(?:$|[^a-z0-9])`, 'i');
 }
+function addTokens(target, tokens) {
+    for (const token of tokens)
+        target.add(token);
+}
 function getPromoMatchers(currentConfig, flags) {
     const baseTokens = new Set(PROMO_TOKENS_ALWAYS);
     const aggressiveTokens = new Set();
     if (currentConfig.aggressiveMode) {
-        for (const t of PROMO_TOKENS_AGGRESSIVE)
-            aggressiveTokens.add(t);
+        addTokens(aggressiveTokens, PROMO_TOKENS_AGGRESSIVE);
+    }
+    if (flags.cookieBanners) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['cookie-banners']);
+    }
+    if (flags.newsletters) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['newsletters']);
+    }
+    if (flags.socialShare) {
+        addTokens(baseTokens, PROMO_TOKENS_BY_CATEGORY['social-share']);
     }
-    if (flags.cookieBanners)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['cookie-banners'])
-            baseTokens.add(t);
-    if (flags.newsletters)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['newsletters'])
-            baseTokens.add(t);
-    if (flags.socialShare)
-        for (const t of PROMO_TOKENS_BY_CATEGORY['social-share'])
-            baseTokens.add(t);
     for (const t of currentConfig.extraTokens) {
         const n = t.toLowerCase().trim();
         if (n)

package/dist/errors.js

@@ -19,17 +19,20 @@ export class FetchError extends Error {
 export function getErrorMessage(error) {
     if (isError(error))
         return error.message;
-    if (typeof error === 'string' && error.length > 0)
+    if (isNonEmptyString(error))
         return error;
     if (isErrorWithMessage(error))
         return error.message;
     return formatUnknownError(error);
 }
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
 function isErrorWithMessage(error) {
     if (!isObject(error))
         return false;
     const { message } = error;
-    return typeof message === 'string' && message.length > 0;
+    return isNonEmptyString(message);
 }
 function formatUnknownError(error) {
     if (error === null || error === undefined)

package/dist/fetch.d.ts

@@ -1,12 +1,12 @@
-export interface FetchOptions {
+interface FetchOptions {
     signal?: AbortSignal;
 }
-export interface TransformResult {
+interface TransformResult {
     readonly url: string;
     readonly transformed: boolean;
     readonly platform?: string;
 }
-export interface FetchTelemetryContext {
+interface FetchTelemetryContext {
     requestId: string;
     startTime: number;
     url: string;
@@ -40,3 +40,4 @@ export declare function fetchNormalizedUrlBuffer(normalizedUrl: string, options?
     truncated: boolean;
     finalUrl: string;
 }>;
+export {};

package/dist/fetch.js

@@ -569,8 +569,11 @@ function createTooManyRedirectsFetchError(url) {
 function createMissingRedirectLocationFetchError(url) {
     return new FetchError('Redirect response missing Location header', url);
 }
+function buildNetworkErrorMessage(url) {
+    return `Network error: Could not reach ${url}`;
+}
 function createNetworkFetchError(url, message) {
-    return new FetchError(`Network error: Could not reach ${url}`, url, undefined, message ? { message } : {});
+    return new FetchError(buildNetworkErrorMessage(url), url, undefined, message ? { message } : {});
 }
 function createUnknownFetchError(url, message) {
     return new FetchError(message, url);
@@ -619,7 +622,7 @@ function mapFetchError(error, fallbackUrl, timeoutMs) {
         code === 'EINVAL') {
         return new FetchError(error.message, url, 400, { code });
     }
-    return new FetchError(`Network error: Could not reach ${url}`, url, undefined, {
+    return new FetchError(buildNetworkErrorMessage(url), url, undefined, {
         code,
         message: error.message,
     });

package/dist/host-normalization.js

@@ -1,7 +1,7 @@
 import { isIP, SocketAddress } from 'node:net';
 import { domainToASCII } from 'node:url';
 export function normalizeHost(value) {
-    const trimmedLower = value.trim().toLowerCase();
+    const trimmedLower = trimToNull(value)?.toLowerCase();
     if (!trimmedLower)
         return null;
     const first = takeFirstHostValue(trimmedLower);
@@ -25,10 +25,7 @@ function takeFirstHostValue(value) {
     // Faster than split(',') for large forwarded headers; preserves behavior.
     const commaIndex = value.indexOf(',');
     const first = commaIndex === -1 ? value : value.slice(0, commaIndex);
-    if (!first)
-        return null;
-    const trimmed = first.trim();
-    return trimmed ? trimmed : null;
+    return first ? trimToNull(first) : null;
 }
 function stripIpv6Brackets(value) {
     if (!value.startsWith('['))
@@ -48,7 +45,7 @@ function isIpV6Literal(value) {
     return isIP(value) === 6;
 }
 function normalizeHostname(value) {
-    const trimmed = value.trim().toLowerCase();
+    const trimmed = trimToNull(value)?.toLowerCase();
     if (!trimmed)
         return null;
     if (isIP(trimmed))
@@ -68,6 +65,10 @@ function parseHostWithUrl(value) {
         return null;
     }
 }
+function trimToNull(value) {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
 function stripTrailingDots(value) {
     // Keep loop (rather than regex) to preserve exact behavior and avoid hidden allocations.
     let result = value;

package/dist/http-native.js

@@ -63,15 +63,13 @@ function createTransportAdapter(transportImpl) {
 function sendJson(res, status, body) {
     res.statusCode = status;
     res.setHeader('Content-Type', 'application/json; charset=utf-8');
-    res.setHeader('X-Content-Type-Options', 'nosniff');
-    res.setHeader('Cache-Control', 'no-store');
+    setNoStoreHeaders(res);
     res.end(JSON.stringify(body));
 }
 function sendText(res, status, body) {
     res.statusCode = status;
     res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    res.setHeader('X-Content-Type-Options', 'nosniff');
-    res.setHeader('Cache-Control', 'no-store');
+    setNoStoreHeaders(res);
     res.end(body);
 }
 function sendEmpty(res, status) {
@@ -79,6 +77,10 @@ function sendEmpty(res, status) {
     res.setHeader('Content-Length', '0');
     res.end();
 }
+function setNoStoreHeaders(res) {
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('Cache-Control', 'no-store');
+}
 function drainRequest(req) {
     if (req.readableEnded)
         return;

package/dist/index.js

@@ -7,6 +7,9 @@ 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 scheduleForcedExit(reason) {
     if (forcedExitTimer)
         return;
@@ -69,8 +72,7 @@ process.on('uncaughtException', (error) => {
     handleFatalError('Uncaught exception', error, 'UNCAUGHT_EXCEPTION');
 });
 process.on('unhandledRejection', (reason) => {
-    const error = reason instanceof Error ? reason : new Error(String(reason));
-    handleFatalError('Unhandled rejection', error, 'UNHANDLED_REJECTION');
+    handleFatalError('Unhandled rejection', toError(reason), 'UNHANDLED_REJECTION');
 });
 try {
     if (isStdioMode) {
@@ -83,8 +85,9 @@ try {
     }
 }
 catch (error) {
-    logError('Failed to start server', error instanceof Error ? error : undefined);
-    const message = error instanceof Error ? error.message : String(error);
+    const resolvedError = toError(error);
+    logError('Failed to start server', resolvedError);
+    const { message } = resolvedError;
     process.stderr.write(`Failed to start server: ${message}\n`);
     process.exitCode = 1;
     scheduleForcedExit('Startup failure');

package/dist/ip-blocklist.js

@@ -14,6 +14,7 @@ const IPV6_2002 = buildIpv6(['2002', 0, 0, 0, 0, 0, 0, 0]);
 const IPV6_FC00 = buildIpv6(['fc00', 0, 0, 0, 0, 0, 0, 0]);
 const IPV6_FE80 = buildIpv6(['fe80', 0, 0, 0, 0, 0, 0, 0]);
 const IPV6_FF00 = buildIpv6(['ff00', 0, 0, 0, 0, 0, 0, 0]);
+const IPV6_MAPPED_PREFIX = '::ffff:';
 const BLOCKED_SUBNETS = [
     { subnet: buildIpv4([0, 0, 0, 0]), prefix: 8, family: 'ipv4' },
     { subnet: buildIpv4([10, 0, 0, 0]), prefix: 8, family: 'ipv4' },
@@ -42,10 +43,9 @@ export function createDefaultBlockList() {
     return list;
 }
 function extractMappedIpv4(ip) {
-    const prefix = '::ffff:';
-    if (!ip.startsWith(prefix))
+    if (!ip.startsWith(IPV6_MAPPED_PREFIX))
         return null;
-    const mapped = ip.slice(prefix.length);
+    const mapped = ip.slice(IPV6_MAPPED_PREFIX.length);
     return isIP(mapped) === 4 ? mapped : null;
 }
 function stripIpv6ZoneId(ip) {

package/dist/json.js

@@ -13,14 +13,15 @@ function processValue(obj, depth, seen) {
     }
     seen.add(obj);
     try {
+        const processChild = (value) => processValue(value, depth + 1, seen);
         if (Array.isArray(obj)) {
-            return obj.map((item) => processValue(item, depth + 1, seen));
+            return obj.map((item) => processChild(item));
         }
         const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
         const record = obj;
         const sortedObj = {};
         for (const key of keys) {
-            sortedObj[key] = processValue(record[key], depth + 1, seen);
+            sortedObj[key] = processChild(record[key]);
         }
         return sortedObj;
     }

package/dist/language-detection.js

@@ -118,11 +118,7 @@ function isBashLine(line) {
     return false;
 }
 function detectBashIndicators(lines) {
-    for (const line of lines) {
-        if (isBashLine(line))
-            return true;
-    }
-    return false;
+    return lines.some((line) => isBashLine(line));
 }
 function detectCssStructure(lines) {
     for (const line of lines) {

package/dist/markdown-cleanup.d.ts

@@ -1,6 +1,11 @@
 import type { MetadataBlock } from './transform-types.js';
-export declare function cleanupMarkdownArtifacts(content: string): string;
+interface CleanupOptions {
+    signal?: AbortSignal;
+    url?: string;
+}
+export declare function cleanupMarkdownArtifacts(content: string, options?: CleanupOptions): string;
 export declare function extractTitleFromRawMarkdown(content: string): string | undefined;
 export declare function addSourceToMarkdown(content: string, url: string): string;
 export declare function isRawTextContent(content: string): boolean;
 export declare function buildMetadataFooter(metadata?: MetadataBlock, fallbackUrl?: string): string;
+export {};