@j0hanz/superfetch 2.6.0 → 2.7.0

package/dist/http-native.js

@@ -5,6 +5,8 @@ import { isIP } from 'node:net';
 import { freemem, hostname, totalmem } from 'node:os';
 import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
 import process from 'node:process';
+import { Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { setInterval as setIntervalPromise } from 'node:timers/promises';
 import { InvalidTokenError, ServerError, } from '@modelcontextprotocol/sdk/server/auth/errors.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -248,7 +250,7 @@ class JsonBodyReader {
             const { chunks, size } = await this.collectChunks(req, limit, signal);
             if (chunks.length === 0)
                 return undefined;
-            return Buffer.concat(chunks, size).toString();
+            return Buffer.concat(chunks, size).toString('utf8');
         }
         finally {
             this.detachAbortListener(signal, abortListener);
@@ -286,19 +288,34 @@ class JsonBodyReader {
     async collectChunks(req, limit, signal) {
         let size = 0;
         const chunks = [];
-        try {
-            for await (const chunk of req) {
-                if (signal?.aborted || req.destroyed) {
-                    throw new JsonBodyError('read-failed', 'Request aborted');
+        const sink = new Writable({
+            write: (chunk, _encoding, callback) => {
+                try {
+                    if (signal?.aborted || req.destroyed) {
+                        callback(new JsonBodyError('read-failed', 'Request aborted'));
+                        return;
+                    }
+                    const buf = this.normalizeChunk(chunk);
+                    size += buf.length;
+                    if (size > limit) {
+                        req.destroy();
+                        callback(new JsonBodyError('payload-too-large', 'Payload too large'));
+                        return;
+                    }
+                    chunks.push(buf);
+                    callback();
                 }
-                const buf = this.normalizeChunk(chunk);
-                size += buf.length;
-                if (size > limit) {
-                    req.destroy();
-                    throw new JsonBodyError('payload-too-large', 'Payload too large');
+                catch (err) {
+                    callback(err instanceof Error ? err : new Error(String(err)));
                 }
-                chunks.push(buf);
+            },
+        });
+        try {
+            if (signal?.aborted || req.destroyed) {
+                throw new JsonBodyError('read-failed', 'Request aborted');
             }
+            await pipeline(req, sink, signal ? { signal } : undefined);
+            return { chunks, size };
         }
         catch (err) {
             if (err instanceof JsonBodyError)
@@ -308,13 +325,12 @@ class JsonBodyReader {
             }
             throw new JsonBodyError('read-failed', err instanceof Error ? err.message : String(err));
         }
-        return { chunks, size };
     }
     normalizeChunk(chunk) {
         if (Buffer.isBuffer(chunk))
             return chunk;
         if (typeof chunk === 'string')
-            return Buffer.from(chunk);
+            return Buffer.from(chunk, 'utf8');
         return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
     }
 }
@@ -556,8 +572,9 @@ class AuthService {
         return clean.href;
     }
     buildBasicAuthHeader(clientId, clientSecret) {
+        // Base64 is only an encoding for header transport; it is NOT encryption.
         const credentials = `${clientId}:${clientSecret ?? ''}`;
-        return `Basic ${Buffer.from(credentials).toString('base64')}`;
+        return `Basic ${Buffer.from(credentials, 'utf8').toString('base64')}`;
     }
     buildIntrospectionRequest(token, resourceUrl, clientId, clientSecret) {
         const body = new URLSearchParams({

package/dist/language-detection.js

@@ -71,8 +71,10 @@ const HTML_TAGS = [
 ];
 const RUST_REGEX = /\b(?:fn|impl|struct|enum)\b/;
 const JS_REGEX = /\b(?:const|let|var|function|class|async|await|export|import)\b/;
-const PYTHON_REGEX = /\b(?:def|class|import|from)\b/;
+const PYTHON_UNIQUE_REGEX = /\b(?:def |elif |except |finally:|yield |lambda |raise |pass$)/m;
+const JS_SIGNAL_REGEX = /\b(?:const |let |var |function |require\(|=>|===|!==|console\.)/;
 const CSS_REGEX = /@media|@import|@keyframes/;
+const CSS_PROPERTY_REGEX = /^\s*[a-z][\w-]*\s*:/;
 function containsJsxTag(code) {
     const len = code.length;
     for (let i = 0; i < len - 1; i++) {
@@ -129,7 +131,11 @@ function detectCssStructure(lines) {
             continue;
         const hasSelector = (trimmed.startsWith('.') || trimmed.startsWith('#')) &&
             trimmed.includes('{');
-        if (hasSelector || (trimmed.includes(':') && trimmed.includes(';'))) {
+        if (hasSelector)
+            return true;
+        if (trimmed.includes(';') &&
+            CSS_PROPERTY_REGEX.test(trimmed) &&
+            !trimmed.includes('(')) {
             return true;
         }
     }
@@ -214,7 +220,25 @@ const LANGUAGES = [
             const l = ctx.lower;
             if (l.includes('print(') || l.includes('__name__'))
                 return true;
-            return PYTHON_REGEX.test(l);
+            if (l.includes('self.') || l.includes('elif '))
+                return true;
+            // Check for Python's None/True/False using original case (they are capitalized in Python)
+            if (ctx.code.includes('None') ||
+                ctx.code.includes('True') ||
+                ctx.code.includes('False')) {
+                return true;
+            }
+            // Python-unique keywords that JS doesn't have
+            if (PYTHON_UNIQUE_REGEX.test(l))
+                return true;
+            // Shared keywords (import, from, class) — only match if no JS signals present
+            if (/\b(?:import|from|class)\b/.test(l) &&
+                !JS_SIGNAL_REGEX.test(l) &&
+                !l.includes('{') &&
+                !l.includes("from '")) {
+                return true;
+            }
+            return false;
         },
     },
     {
@@ -238,7 +262,7 @@ const LANGUAGES = [
     },
     {
         lang: 'javascript',
-        weight: 12,
+        weight: 15,
         match: (ctx) => JS_REGEX.test(ctx.lower),
     },
     {

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import process from 'node:process';
 import { z } from 'zod';
 import { McpServer, ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -17,8 +17,14 @@ import { isObject } from './type-guards.js';
  * Icons + server info
  * ------------------------------------------------------------------------------------------------- */
 async function getLocalIcons(signal) {
+    const MAX_ICON_BYTES = 10 * 1024;
     try {
         const iconPath = new URL('../assets/logo.svg', import.meta.url);
+        if (signal?.aborted)
+            return undefined;
+        const { size } = await stat(iconPath);
+        if (size > MAX_ICON_BYTES)
+            return undefined;
         const base64 = await readFile(iconPath, {
             encoding: 'base64',
             ...(signal ? { signal } : {}),

package/dist/tasks.d.ts

@@ -40,6 +40,7 @@ declare class TaskManager {
     getTask(taskId: string, ownerKey?: string): TaskState | undefined;
     updateTask(taskId: string, updates: Partial<Omit<TaskState, 'taskId' | 'createdAt'>>): void;
     cancelTask(taskId: string, ownerKey?: string): TaskState | undefined;
+    private collectPage;
     listTasks(options: {
         ownerKey: string;
         cursor?: string;

package/dist/tasks.js

@@ -4,18 +4,21 @@ import { randomUUID } from 'node:crypto';
 import { setInterval } from 'node:timers';
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { createUnrefTimeout } from './timer-utils.js';
-const DEFAULT_TTL_MS = 60000;
-const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_TTL_MS = 60_000;
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
 const DEFAULT_OWNER_KEY = 'default';
 const DEFAULT_PAGE_SIZE = 50;
-const TERMINAL_STATUSES = new Set([
-    'completed',
-    'failed',
-    'cancelled',
-]);
+const CLEANUP_INTERVAL_MS = 60_000;
+const MAX_CURSOR_LENGTH = 256;
 function isTerminalStatus(status) {
-    return TERMINAL_STATUSES.has(status);
+    return (status === 'completed' || status === 'failed' || status === 'cancelled');
 }
+const asyncLocalStorageSnapshot = AsyncLocalStorage.snapshot;
+const snapshotRunInContext = typeof asyncLocalStorageSnapshot === 'function'
+    ? asyncLocalStorageSnapshot
+    : () => (fn) => {
+        fn();
+    };
 class TaskManager {
     tasks = new Map();
     waiters = new Map();
@@ -24,28 +27,30 @@ class TaskManager {
     }
     startCleanupLoop() {
         const interval = setInterval(() => {
+            const now = Date.now();
             for (const [id, task] of this.tasks) {
-                if (this.isExpired(task)) {
+                if (now - task._createdAtMs > task.ttl) {
                     this.tasks.delete(id);
                 }
             }
-        }, 60000);
+        }, CLEANUP_INTERVAL_MS);
         interval.unref();
     }
     createTask(options, statusMessage = 'Task started', ownerKey = DEFAULT_OWNER_KEY) {
-        const taskId = randomUUID();
-        const now = new Date().toISOString();
+        const now = new Date();
+        const createdAt = now.toISOString();
         const task = {
-            taskId,
+            taskId: randomUUID(),
             ownerKey,
             status: 'working',
             statusMessage,
-            createdAt: now,
-            lastUpdatedAt: now,
+            createdAt,
+            lastUpdatedAt: createdAt,
             ttl: options?.ttl ?? DEFAULT_TTL_MS,
             pollInterval: DEFAULT_POLL_INTERVAL_MS,
+            _createdAtMs: now.getTime(),
         };
-        this.tasks.set(taskId, task);
+        this.tasks.set(task.taskId, task);
         return task;
     }
     getTask(taskId, ownerKey) {
@@ -78,9 +83,7 @@ class TaskManager {
         const task = this.getTask(taskId, ownerKey);
         if (!task)
             return undefined;
-        if (task.status === 'completed' ||
-            task.status === 'failed' ||
-            task.status === 'cancelled') {
+        if (isTerminalStatus(task.status)) {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task: already in terminal status '${task.status}'`);
         }
         this.updateTask(taskId, {
@@ -89,6 +92,27 @@ class TaskManager {
         });
         return this.tasks.get(taskId);
     }
+    collectPage(ownerKey, startIndex, pageSize) {
+        const page = [];
+        let currentIndex = 0;
+        const now = Date.now();
+        for (const task of this.tasks.values()) {
+            if (task.ownerKey !== ownerKey)
+                continue;
+            if (now - task._createdAtMs > task.ttl) {
+                this.tasks.delete(task.taskId);
+                continue;
+            }
+            if (currentIndex >= startIndex) {
+                page.push(task);
+                if (page.length > pageSize) {
+                    break;
+                }
+            }
+            currentIndex++;
+        }
+        return page;
+    }
     listTasks(options) {
         const { ownerKey, cursor, limit } = options;
         const pageSize = limit && limit > 0 ? limit : DEFAULT_PAGE_SIZE;
@@ -96,36 +120,36 @@ class TaskManager {
         if (startIndex === null) {
             throw new McpError(ErrorCode.InvalidParams, 'Invalid cursor');
         }
-        const allTasks = Array.from(this.tasks.values()).filter((task) => {
-            if (task.ownerKey !== ownerKey)
-                return false;
-            if (this.isExpired(task)) {
-                this.tasks.delete(task.taskId);
-                return false;
-            }
-            return true;
-        });
-        const page = allTasks.slice(startIndex, startIndex + pageSize);
-        const nextIndex = startIndex + page.length;
-        const nextCursor = nextIndex < allTasks.length ? this.encodeCursor(nextIndex) : undefined;
+        const page = this.collectPage(ownerKey, startIndex, pageSize);
+        const hasMore = page.length > pageSize;
+        if (hasMore) {
+            page.pop();
+        }
+        const nextCursor = hasMore
+            ? this.encodeCursor(startIndex + page.length)
+            : undefined;
         return nextCursor ? { tasks: page, nextCursor } : { tasks: page };
     }
     async waitForTerminalTask(taskId, ownerKey, signal) {
-        const task = this.getTask(taskId, ownerKey);
+        const task = this.tasks.get(taskId);
         if (!task)
             return undefined;
+        if (ownerKey && task.ownerKey !== ownerKey)
+            return undefined;
+        if (this.isExpired(task)) {
+            this.tasks.delete(taskId);
+            return undefined;
+        }
         if (isTerminalStatus(task.status))
             return task;
-        const createdAtMs = Date.parse(task.createdAt);
-        const deadlineMs = Number.isFinite(createdAtMs)
-            ? createdAtMs + task.ttl
-            : Number.NaN;
-        if (Number.isFinite(deadlineMs) && deadlineMs <= Date.now()) {
+        const deadlineMs = task._createdAtMs + task.ttl;
+        const now = Date.now();
+        if (deadlineMs <= now) {
             this.tasks.delete(taskId);
             return undefined;
         }
         return new Promise((resolve, reject) => {
-            const runInContext = AsyncLocalStorage.snapshot();
+            const runInContext = snapshotRunInContext();
             const resolveInContext = (value) => {
                 runInContext(() => {
                     resolve(value);
@@ -133,30 +157,12 @@ class TaskManager {
             };
             const rejectInContext = (error) => {
                 runInContext(() => {
-                    if (error instanceof Error) {
-                        reject(error);
-                    }
-                    else {
-                        reject(new Error(String(error)));
-                    }
+                    reject(error instanceof Error ? error : new Error(String(error)));
                 });
             };
             let settled = false;
             let waiter = null;
             let deadlineTimeout;
-            const settle = (fn) => {
-                if (settled)
-                    return;
-                settled = true;
-                fn();
-            };
-            const onAbort = () => {
-                settle(() => {
-                    cleanup();
-                    removeWaiter();
-                    rejectInContext(new McpError(ErrorCode.ConnectionClosed, 'Request was cancelled'));
-                });
-            };
             const cleanup = () => {
                 if (deadlineTimeout) {
                     deadlineTimeout.cancel();
@@ -167,17 +173,35 @@ class TaskManager {
                 }
             };
             const removeWaiter = () => {
-                const waiters = this.waiters.get(taskId);
-                if (!waiters)
+                if (waiter) {
+                    const set = this.waiters.get(taskId);
+                    if (set) {
+                        set.delete(waiter);
+                        if (set.size === 0)
+                            this.waiters.delete(taskId);
+                    }
+                }
+            };
+            const settleOnce = (fn) => {
+                if (settled)
                     return;
-                if (waiter)
-                    waiters.delete(waiter);
-                if (waiters.size === 0)
-                    this.waiters.delete(taskId);
+                settled = true;
+                fn();
+            };
+            const onAbort = () => {
+                settleOnce(() => {
+                    cleanup();
+                    removeWaiter();
+                    rejectInContext(new McpError(ErrorCode.ConnectionClosed, 'Request was cancelled'));
+                });
             };
             waiter = (updated) => {
-                settle(() => {
+                settleOnce(() => {
                     cleanup();
+                    if (updated.ownerKey !== ownerKey) {
+                        resolveInContext(undefined);
+                        return;
+                    }
                     resolveInContext(updated);
                 });
             };
@@ -185,35 +209,27 @@ class TaskManager {
                 onAbort();
                 return;
             }
-            const waiters = this.waiters.get(taskId) ?? new Set();
-            waiters.add(waiter);
-            this.waiters.set(taskId, waiters);
+            let set = this.waiters.get(taskId);
+            if (!set) {
+                set = new Set();
+                this.waiters.set(taskId, set);
+            }
+            set.add(waiter);
             if (signal) {
                 signal.addEventListener('abort', onAbort, { once: true });
             }
-            if (Number.isFinite(deadlineMs)) {
-                const timeoutMs = Math.max(0, deadlineMs - Date.now());
-                if (timeoutMs === 0) {
-                    settle(() => {
-                        cleanup();
-                        removeWaiter();
-                        this.tasks.delete(taskId);
-                        resolveInContext(undefined);
-                    });
-                    return;
-                }
-                deadlineTimeout = createUnrefTimeout(timeoutMs, { timeout: true });
-                void deadlineTimeout.promise
-                    .then(() => {
-                    settle(() => {
-                        cleanup();
-                        removeWaiter();
-                        this.tasks.delete(taskId);
-                        resolveInContext(undefined);
-                    });
-                })
-                    .catch(rejectInContext);
-            }
+            const timeoutMs = Math.max(0, deadlineMs - Date.now());
+            deadlineTimeout = createUnrefTimeout(timeoutMs, { timeout: true });
+            void deadlineTimeout.promise
+                .then(() => {
+                settleOnce(() => {
+                    cleanup();
+                    removeWaiter();
+                    this.tasks.delete(taskId);
+                    resolveInContext(undefined);
+                });
+            })
+                .catch(rejectInContext);
         });
     }
     notifyWaiters(task) {
@@ -227,17 +243,18 @@ class TaskManager {
             waiter(task);
     }
     isExpired(task) {
-        const createdAt = Date.parse(task.createdAt);
-        if (!Number.isFinite(createdAt))
-            return false;
-        return Date.now() - createdAt > task.ttl;
+        return Date.now() - task._createdAtMs > task.ttl;
     }
     encodeCursor(index) {
-        return Buffer.from(String(index)).toString('base64url');
+        return Buffer.from(String(index), 'utf8').toString('base64url');
     }
     decodeCursor(cursor) {
         try {
+            if (!isValidBase64UrlCursor(cursor))
+                return null;
             const decoded = Buffer.from(cursor, 'base64url').toString('utf8');
+            if (!/^\d+$/u.test(decoded))
+                return null;
             const value = Number.parseInt(decoded, 10);
             if (!Number.isFinite(value) || value < 0)
                 return null;
@@ -248,4 +265,21 @@ class TaskManager {
         }
     }
 }
+function isValidBase64UrlCursor(cursor) {
+    if (!cursor)
+        return false;
+    if (cursor.length > MAX_CURSOR_LENGTH)
+        return false;
+    if (!/^[A-Za-z0-9_-]+={0,2}$/u.test(cursor))
+        return false;
+    const firstPaddingIndex = cursor.indexOf('=');
+    if (firstPaddingIndex !== -1) {
+        for (let i = firstPaddingIndex; i < cursor.length; i += 1) {
+            if (cursor[i] !== '=')
+                return false;
+        }
+        return cursor.length % 4 === 0;
+    }
+    return cursor.length % 4 !== 1;
+}
 export const taskManager = new TaskManager();

package/dist/tools.d.ts

@@ -47,6 +47,7 @@ export interface FetchPipelineOptions<T> {
     transform: (input: {
         buffer: Uint8Array;
         encoding: string;
+        truncated?: boolean;
     }, url: string) => T | Promise<T>;
     serialize?: (result: T) => string;
     deserialize?: (cached: string) => T | undefined;
@@ -116,6 +117,7 @@ interface SharedFetchOptions<T extends {
     readonly transform: (input: {
         buffer: Uint8Array;
         encoding: string;
+        truncated?: boolean;
     }, normalizedUrl: string) => T | Promise<T>;
     readonly serialize?: (result: T) => string;
     readonly deserialize?: (cached: string) => T | undefined;

package/dist/tools.js

@@ -453,8 +453,8 @@ export async function executeFetchPipeline(options) {
         }
     }
     logDebug('Fetching URL', { url: resolvedUrl.normalizedUrl });
-    const { buffer, encoding } = await fetchNormalizedUrlBuffer(resolvedUrl.normalizedUrl, withSignal(options.signal));
-    const data = await options.transform({ buffer, encoding }, resolvedUrl.normalizedUrl);
+    const { buffer, encoding, truncated } = await fetchNormalizedUrlBuffer(resolvedUrl.normalizedUrl, withSignal(options.signal));
+    const data = await options.transform({ buffer, encoding, ...(truncated ? { truncated: true } : {}) }, resolvedUrl.normalizedUrl);
     if (cache.isEnabled()) {
         persistCache({
             cacheKey,
@@ -572,7 +572,8 @@ const markdownTransform = async (input, url, signal, skipNoiseRemoval) => {
         ...withSignal(signal),
         ...(skipNoiseRemoval ? { skipNoiseRemoval: true } : {}),
     });
-    return { ...result, content: result.markdown };
+    const truncated = Boolean(result.truncated || input.truncated);
+    return { ...result, content: result.markdown, truncated };
 };
 function serializeMarkdownResult(result) {
     return JSON.stringify({

package/dist/transform-types.d.ts

@@ -32,6 +32,7 @@ export interface ExtractedMetadata {
     description?: string;
     author?: string;
     image?: string;
+    favicon?: string;
     publishedAt?: string;
     modifiedAt?: string;
 }