@j0hanz/fetch-url-mcp 1.1.1 → 1.1.2

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.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.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.js

@@ -50,12 +50,14 @@ function throwIfAborted(signal, url, stage) {
 function getLineEnding(content) {
     return content.includes('\r\n') ? '\r\n' : '\n';
 }
+function isBlank(line) {
+    return line === undefined || line.trim().length === 0;
+}
 function hasFollowingContent(lines, startIndex) {
     // Optimization: Bound lookahead to avoid checking too many lines in huge files
     const max = Math.min(lines.length, startIndex + 50);
     for (let i = startIndex + 1; i < max; i++) {
-        const line = lines[i];
-        if (line && line.trim().length > 0)
+        if (!isBlank(lines[i]))
             return true;
     }
     return false;
@@ -145,11 +147,12 @@ function getTocBlockStats(lines, headingIndex) {
 function skipTocLines(lines, startIndex) {
     for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
-        if (!line)
+        if (line === undefined)
             continue;
-        if (line.trim().length === 0)
+        const trimmed = line.trim();
+        if (!trimmed)
             continue;
-        if (!REGEX.TOC_LINK.test(line))
+        if (!REGEX.TOC_LINK.test(trimmed))
             return i;
     }
     return lines.length;

package/dist/mcp-validator.js

@@ -13,17 +13,16 @@ export function isJsonRpcBatchRequest(body) {
 export function isMcpRequestBody(body) {
     return mcpRequestSchema.safeParse(body).success;
 }
-export function acceptsEventStream(header) {
+function parseAcceptHeader(header) {
     if (!header)
-        return false;
-    return header
-        .split(',')
-        .some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
+        return [];
+    return header.split(',').map((value) => value.trim());
+}
+export function acceptsEventStream(header) {
+    return parseAcceptHeader(header).some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
 }
 function hasAcceptedMediaType(header, exact, wildcardPrefix) {
-    if (!header)
-        return false;
-    return header.split(',').some((rawPart) => {
+    return parseAcceptHeader(header).some((rawPart) => {
         const mediaType = rawPart.trim().split(';', 1)[0]?.trim().toLowerCase();
         if (!mediaType)
             return false;

package/dist/mcp.js

@@ -8,26 +8,35 @@ import { isObject } from './type-guards.js';
 /* -------------------------------------------------------------------------------------------------
  * Tasks API schemas
  * ------------------------------------------------------------------------------------------------- */
-const TaskGetSchema = z.strictObject({
+const TaskGetSchema = z
+    .object({
     method: z.literal('tasks/get'),
-    params: z.strictObject({ taskId: z.string() }),
-});
-const TaskListSchema = z.strictObject({
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
+const TaskListSchema = z
+    .object({
     method: z.literal('tasks/list'),
     params: z
-        .strictObject({
+        .object({
         cursor: z.string().optional(),
     })
+        .loose()
         .optional(),
-});
-const TaskCancelSchema = z.strictObject({
+})
+    .loose();
+const TaskCancelSchema = z
+    .object({
     method: z.literal('tasks/cancel'),
-    params: z.strictObject({ taskId: z.string() }),
-});
-const TaskResultSchema = z.strictObject({
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
+const TaskResultSchema = z
+    .object({
     method: z.literal('tasks/result'),
-    params: z.strictObject({ taskId: z.string() }),
-});
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
 const MIN_TASK_TTL_MS = 1_000;
 const MAX_TASK_TTL_MS = 86_400_000;
 const ExtendedCallToolRequestSchema = z
@@ -71,6 +80,14 @@ function parseExtendedCallToolRequest(request) {
 function isRecord(value) {
     return isObject(value);
 }
+function normalizeSendNotification(sendNotification) {
+    if (typeof sendNotification !== 'function')
+        return undefined;
+    const notify = sendNotification;
+    return async (notification) => {
+        await Promise.resolve(notify(notification));
+    };
+}
 function parseHandlerExtra(extra) {
     if (!isObject(extra))
         return undefined;
@@ -93,11 +110,9 @@ function parseHandlerExtra(extra) {
     if (typeof requestId === 'string' || typeof requestId === 'number') {
         parsed.requestId = requestId;
     }
-    if (typeof sendNotification === 'function') {
-        const notify = sendNotification;
-        parsed.sendNotification = async (notification) => {
-            await Promise.resolve(notify(notification));
-        };
+    const normalizedSendNotification = normalizeSendNotification(sendNotification);
+    if (normalizedSendNotification) {
+        parsed.sendNotification = normalizedSendNotification;
     }
     return parsed;
 }

package/dist/observability.js

@@ -128,6 +128,13 @@ function mapToMcpLevel(level) {
             return 'info';
     }
 }
+function resolveErrorText(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === 'string')
+        return err;
+    return 'unknown error';
+}
 function safeWriteStderr(line) {
     if (!stderrAvailable)
         return;
@@ -164,20 +171,14 @@ function writeLog(level, message, meta) {
             .catch((err) => {
             if (!isDebugEnabled())
                 return;
-            let errorText = 'unknown error';
-            if (err instanceof Error) {
-                errorText = err.message;
-            }
-            else if (typeof err === 'string') {
-                errorText = err;
-            }
+            const errorText = resolveErrorText(err);
             safeWriteStderr(`[${createTimestamp()}] WARN: Failed to forward log to MCP${sessionId ? ` (sessionId=${sessionId})` : ''}: ${errorText}\n`);
         });
     }
     catch (err) {
         if (!isDebugEnabled())
             return;
-        const errorText = err instanceof Error ? err.message : 'unknown error';
+        const errorText = resolveErrorText(err);
         safeWriteStderr(`[${createTimestamp()}] WARN: Failed to forward log to MCP (sync error): ${errorText}\n`);
     }
 }

package/dist/prompts.js

@@ -1,18 +1,10 @@
 export function registerGetHelpPrompt(server, instructions, iconInfo) {
     const description = 'Return the Fetch URL usage instructions.';
+    const iconConfig = iconInfo ? { icons: [{ ...iconInfo }] } : {};
     server.registerPrompt('get-help', {
         title: 'Get Help',
         description,
-        ...(iconInfo
-            ? {
-                icons: [
-                    {
-                        src: iconInfo.src,
-                        mimeType: iconInfo.mimeType,
-                    },
-                ],
-            }
-            : {}),
+        ...iconConfig,
     }, () => ({
         description,
         messages: [

package/dist/resources.js

@@ -21,17 +21,19 @@ function decodeSegment(value) {
         return value;
     }
 }
+function trimToValue(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 function firstVariableValue(value) {
     if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
+        return trimToValue(value);
     }
     if (Array.isArray(value)) {
         const first = value[0];
         if (typeof first !== 'string')
             return undefined;
-        const trimmed = first.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
+        return trimToValue(first);
     }
     return undefined;
 }

package/dist/server-tuning.js

@@ -1,23 +1,28 @@
 import { config } from './config.js';
 import { logDebug, logWarn } from './observability.js';
 const DROP_LOG_INTERVAL_MS = 10_000;
+function setIfDefined(value, setter) {
+    if (value === undefined)
+        return;
+    setter(value);
+}
 export function applyHttpServerTuning(server) {
     const { headersTimeoutMs, requestTimeoutMs, keepAliveTimeoutMs, keepAliveTimeoutBufferMs, maxHeadersCount, maxConnections, } = config.server.http;
-    if (headersTimeoutMs !== undefined) {
-        server.headersTimeout = headersTimeoutMs;
-    }
-    if (requestTimeoutMs !== undefined) {
-        server.requestTimeout = requestTimeoutMs;
-    }
-    if (keepAliveTimeoutMs !== undefined) {
-        server.keepAliveTimeout = keepAliveTimeoutMs;
-    }
-    if (keepAliveTimeoutBufferMs !== undefined) {
-        server.keepAliveTimeoutBuffer = keepAliveTimeoutBufferMs;
-    }
-    if (maxHeadersCount !== undefined) {
-        server.maxHeadersCount = maxHeadersCount;
-    }
+    setIfDefined(headersTimeoutMs, (value) => {
+        server.headersTimeout = value;
+    });
+    setIfDefined(requestTimeoutMs, (value) => {
+        server.requestTimeout = value;
+    });
+    setIfDefined(keepAliveTimeoutMs, (value) => {
+        server.keepAliveTimeout = value;
+    });
+    setIfDefined(keepAliveTimeoutBufferMs, (value) => {
+        server.keepAliveTimeoutBuffer = value;
+    });
+    setIfDefined(maxHeadersCount, (value) => {
+        server.maxHeadersCount = value;
+    });
     if (typeof maxConnections === 'number' && maxConnections > 0) {
         server.maxConnections = maxConnections;
         if (typeof server.on === 'function') {

package/dist/server.js

@@ -70,6 +70,9 @@ function createServerInfo(icons) {
         ...(icons ? { icons } : {}),
     };
 }
+function toIconList(icon) {
+    return icon ? [icon] : undefined;
+}
 /* -------------------------------------------------------------------------------------------------
  * Server lifecycle
  * ------------------------------------------------------------------------------------------------- */
@@ -88,14 +91,7 @@ async function createMcpServerWithOptions(options) {
     if (serverInstructions) {
         serverConfig.instructions = serverInstructions;
     }
-    const serverInfo = createServerInfo(localIcon
-        ? [
-            {
-                src: localIcon.src,
-                mimeType: localIcon.mimeType,
-            },
-        ]
-        : undefined);
+    const serverInfo = createServerInfo(toIconList(localIcon));
     const server = new McpServer(serverInfo, serverConfig);
     if (options?.registerObservabilityServer ?? true) {
         setMcpServer(server);

package/dist/session.js

@@ -96,6 +96,9 @@ function moveSessionToEnd(sessions, sessionId, session) {
     sessions.delete(sessionId);
     sessions.set(sessionId, session);
 }
+function isBlankSessionId(sessionId) {
+    return sessionId.length === 0;
+}
 class InMemorySessionStore {
     sessionTtlMs;
     sessions = new Map();
@@ -104,12 +107,12 @@ class InMemorySessionStore {
         this.sessionTtlMs = sessionTtlMs;
     }
     get(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return undefined;
         return this.sessions.get(sessionId);
     }
     touch(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return;
         const session = this.sessions.get(sessionId);
         if (!session)
@@ -118,12 +121,12 @@ class InMemorySessionStore {
         moveSessionToEnd(this.sessions, sessionId, session);
     }
     set(sessionId, entry) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return;
         moveSessionToEnd(this.sessions, sessionId, entry);
     }
     remove(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return undefined;
         const session = this.sessions.get(sessionId);
         this.sessions.delete(sessionId);

package/dist/tasks.js

@@ -41,7 +41,7 @@ class TaskManager {
     removeExpiredTasks() {
         const now = Date.now();
         for (const [id, task] of this.tasks) {
-            if (now - task._createdAtMs > task.ttl) {
+            if (this.isExpired(task, now)) {
                 this.tasks.delete(id);
             }
         }
@@ -146,7 +146,7 @@ class TaskManager {
         for (const task of this.tasks.values()) {
             if (task.ownerKey !== ownerKey)
                 continue;
-            if (now - task._createdAtMs > task.ttl) {
+            if (this.isExpired(task, now)) {
                 this.tasks.delete(task.taskId);
                 continue;
             }
@@ -284,8 +284,8 @@ class TaskManager {
         for (const waiter of waiters)
             waiter(task);
     }
-    isExpired(task) {
-        return Date.now() - task._createdAtMs > task.ttl;
+    isExpired(task, now = Date.now()) {
+        return now - task._createdAtMs > task.ttl;
     }
     encodeCursor(index) {
         return Buffer.from(String(index), 'utf8').toString('base64url');

package/dist/timer-utils.js

@@ -1,12 +1,15 @@
 import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
 import { isError } from './type-guards.js';
+function isAbortError(error) {
+    return isError(error) && error.name === 'AbortError';
+}
 export function createUnrefTimeout(timeoutMs, value) {
     const controller = new AbortController();
     const promise = setTimeoutPromise(timeoutMs, value, {
         ref: false,
         signal: controller.signal,
     }).catch((err) => {
-        if (isError(err) && err.name === 'AbortError') {
+        if (isAbortError(err)) {
             return new Promise(() => { });
         }
         throw err;

package/dist/tools.js

@@ -708,10 +708,7 @@ function serializeMarkdownResult(result) {
 function buildStructuredContent(pipeline, inlineResult, inputUrl) {
     const cacheResourceUri = resolveCacheResourceUri(pipeline.cacheKey);
     const truncated = inlineResult.truncated ?? pipeline.data.truncated;
-    let markdown = inlineResult.content;
-    if (pipeline.data.truncated && typeof markdown === 'string') {
-        markdown = appendTruncationMarker(markdown, TRUNCATION_MARKER);
-    }
+    const markdown = applyTruncationMarker(inlineResult.content, pipeline.data.truncated);
     const { metadata } = pipeline.data;
     return {
         url: pipeline.originalUrl ?? pipeline.url,
@@ -728,6 +725,11 @@ function buildStructuredContent(pipeline, inlineResult, inputUrl) {
         ...(truncated ? { truncated: true } : {}),
     };
 }
+function applyTruncationMarker(content, truncated) {
+    if (!truncated || typeof content !== 'string')
+        return content;
+    return appendTruncationMarker(content, TRUNCATION_MARKER);
+}
 function resolveCacheResourceUri(cacheKey) {
     if (!cacheKey)
         return undefined;
@@ -864,14 +866,14 @@ function resolveSessionIdFromExtra(extra) {
 export function registerTools(server) {
     if (!config.tools.enabled.includes(FETCH_URL_TOOL_NAME))
         return;
-    server.registerTool(TOOL_DEFINITION.name, {
+    const registeredTool = server.registerTool(TOOL_DEFINITION.name, {
         title: TOOL_DEFINITION.title,
         description: TOOL_DEFINITION.description,
         inputSchema: TOOL_DEFINITION.inputSchema,
         outputSchema: TOOL_DEFINITION.outputSchema,
         annotations: TOOL_DEFINITION.annotations,
         execution: TOOL_DEFINITION.execution,
-        // Use specific tool icon here
         icons: [TOOL_ICON],
     }, withRequestContextIfMissing(TOOL_DEFINITION.handler));
+    registeredTool.execution = TOOL_DEFINITION.execution;
 }

package/dist/transform.js

@@ -42,6 +42,9 @@ function getTagName(node) {
     const raw = node.tagName;
     return typeof raw === 'string' ? raw.toUpperCase() : '';
 }
+function asError(value) {
+    return value instanceof Error ? value : undefined;
+}
 function getAbortReason(signal) {
     const record = isObject(signal) ? signal : null;
     return record && 'reason' in record ? record['reason'] : undefined;
@@ -513,7 +516,7 @@ function extractArticle(document, url, signal) {
         };
     }
     catch (error) {
-        logError('Failed to extract article with Readability', error instanceof Error ? error : undefined);
+        logError('Failed to extract article with Readability', asError(error));
         return null;
     }
 }
@@ -573,7 +576,7 @@ function extractContentContext(html, url, options) {
         if (error instanceof FetchError)
             throw error;
         abortPolicy.throwIfAborted(options.signal, url, 'extract:error');
-        logError('Failed to extract content', error instanceof Error ? error : undefined);
+        logError('Failed to extract content', asError(error));
         const { document } = parseHTML('<html></html>');
         return { article: null, metadata: {}, document };
     }
@@ -1177,7 +1180,7 @@ export function htmlToMarkdown(html, metadata, options) {
     catch (error) {
         if (error instanceof FetchError)
             throw error;
-        logError('Failed to convert HTML to markdown', error instanceof Error ? error : undefined);
+        logError('Failed to convert HTML to markdown', asError(error));
         throw new FetchError('Failed to convert HTML to markdown', url, 500, {
             reason: 'markdown_convert_failed',
         });

package/dist/type-guards.js

@@ -2,9 +2,9 @@ export function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 export function isError(value) {
-    const ErrorConstructor = Error;
-    if (typeof ErrorConstructor.isError === 'function') {
-        return ErrorConstructor.isError(value);
+    const { isError: isErrorFn } = Error;
+    if (typeof isErrorFn === 'function') {
+        return isErrorFn(value);
     }
     return value instanceof Error;
 }

package/dist/workers/transform-child.js

@@ -4,11 +4,15 @@ import { transformHtmlToMarkdownInProcess } from '../transform.js';
 const send = process.send?.bind(process);
 if (!send)
     throw new Error('transform-child started without IPC channel');
+const sendMessage = send;
+function postMessage(message) {
+    sendMessage(message);
+}
 const controllersById = new Map();
 const decoder = new TextDecoder('utf-8');
 function postError(id, url, error) {
     if (error instanceof FetchError) {
-        send?.({
+        postMessage({
             type: 'error',
             id,
             error: {
@@ -21,7 +25,7 @@ function postError(id, url, error) {
         });
         return;
     }
-    send?.({
+    postMessage({
         type: 'error',
         id,
         error: {
@@ -52,7 +56,7 @@ function isValidMessage(msg) {
     return true;
 }
 function postValidationError(id, url, message) {
-    send?.({
+    postMessage({
         type: 'error',
         id,
         error: { name: 'ValidationError', message, url },
@@ -94,7 +98,7 @@ function handleTransform(msg) {
             ...(inputTruncated ? { inputTruncated: true } : {}),
         });
         const { markdown, metadata, title, truncated } = result;
-        send?.({
+        postMessage({
             type: 'result',
             id,
             result: title === undefined

package/dist/workers/transform-worker.js

@@ -61,6 +61,9 @@ function decodeHtmlBuffer(htmlBuffer, encoding) {
         return decoder.decode(htmlBuffer);
     }
 }
+function resolveHtmlContent(html, htmlBuffer, encoding) {
+    return htmlBuffer ? decodeHtmlBuffer(htmlBuffer, encoding) : (html ?? '');
+}
 function handleTransform(msg) {
     if (!isValidMessage(msg))
         return;
@@ -76,9 +79,7 @@ function handleTransform(msg) {
     const controller = new AbortController();
     controllersById.set(id, controller);
     try {
-        const content = htmlBuffer
-            ? decodeHtmlBuffer(htmlBuffer, encoding)
-            : (html ?? '');
+        const content = resolveHtmlContent(html, htmlBuffer, encoding);
         const result = transformHtmlToMarkdownInProcess(content, url, {
             includeMetadata,
             signal: controller.signal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/fetch-url-mcp",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "mcpName": "io.github.j0hanz/fetch-url-mcp",
   "description": "Intelligent web content fetcher MCP server that converts HTML to clean, AI-readable Markdown",
   "type": "module",