@j0hanz/superfetch 2.4.2 → 2.4.4

package/dist/resources.js

@@ -0,0 +1,44 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { config } from './config.js';
+import { stableStringify } from './json.js';
+/* -------------------------------------------------------------------------------------------------
+ * Configuration Resource
+ * ------------------------------------------------------------------------------------------------- */
+function scrubAuth(auth) {
+    return {
+        ...auth,
+        clientSecret: auth.clientSecret ? '<REDACTED>' : undefined,
+        staticTokens: auth.staticTokens.map(() => '<REDACTED>'),
+    };
+}
+function scrubSecurity(security) {
+    return {
+        ...security,
+        apiKey: security.apiKey ? '<REDACTED>' : undefined,
+    };
+}
+function scrubConfig(source) {
+    return {
+        ...source,
+        auth: scrubAuth(source.auth),
+        security: scrubSecurity(source.security),
+    };
+}
+export function registerConfigResource(server) {
+    server.registerResource('config', new ResourceTemplate('internal://config', { list: undefined }), {
+        title: 'Server Configuration',
+        description: 'Current runtime configuration (secrets redacted)',
+        mimeType: 'application/json',
+    }, (uri) => {
+        const scrubbed = scrubConfig(config);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: stableStringify(scrubbed),
+                },
+            ],
+        };
+    });
+}

package/dist/session.js

@@ -14,128 +14,163 @@ export function composeCloseHandlers(first, second) {
         }
     };
 }
-// --- Session Store ---
+/* -------------------------------------------------------------------------------------------------
+ * Cleanup loop
+ * ------------------------------------------------------------------------------------------------- */
 function getCleanupIntervalMs(sessionTtlMs) {
-    return Math.min(Math.max(Math.floor(sessionTtlMs / 2), 10000), 60000);
+    return Math.min(Math.max(Math.floor(sessionTtlMs / 2), 10_000), 60_000);
 }
 function isAbortError(error) {
     return error instanceof Error && error.name === 'AbortError';
 }
 function handleSessionCleanupError(error) {
-    if (isAbortError(error)) {
+    if (isAbortError(error))
         return;
-    }
     logWarn('Session cleanup loop failed', {
         error: error instanceof Error ? error.message : 'Unknown error',
     });
 }
-function moveSessionToEnd(sessions, sessionId, session) {
-    sessions.delete(sessionId);
-    sessions.set(sessionId, session);
-}
 function isSessionExpired(session, now, sessionTtlMs) {
     return now - session.lastSeen > sessionTtlMs;
 }
-async function runSessionCleanupLoop(store, sessionTtlMs, signal) {
-    const intervalMs = getCleanupIntervalMs(sessionTtlMs);
-    for await (const getNow of setIntervalPromise(intervalMs, Date.now, {
-        signal,
-        ref: false,
-    })) {
-        const evicted = store.evictExpired();
-        for (const session of evicted) {
-            void session.transport.close().catch((err) => {
-                logWarn('Failed to close expired session', {
-                    error: err instanceof Error ? err : new Error(String(err)),
+class SessionCleanupLoop {
+    store;
+    sessionTtlMs;
+    constructor(store, sessionTtlMs) {
+        this.store = store;
+        this.sessionTtlMs = sessionTtlMs;
+    }
+    start() {
+        const controller = new AbortController();
+        void this.run(controller.signal).catch(handleSessionCleanupError);
+        return controller;
+    }
+    async run(signal) {
+        const intervalMs = getCleanupIntervalMs(this.sessionTtlMs);
+        for await (const getNow of setIntervalPromise(intervalMs, Date.now, {
+            signal,
+            ref: false,
+        })) {
+            const now = getNow();
+            const evicted = this.store.evictExpired();
+            for (const session of evicted) {
+                void session.transport.close().catch((err) => {
+                    logWarn('Failed to close expired session', {
+                        error: err instanceof Error ? err : new Error(String(err)),
+                    });
                 });
-            });
-        }
-        if (evicted.length > 0) {
-            logInfo('Expired sessions evicted', {
-                evicted: evicted.length,
-                timestamp: new Date(getNow()).toISOString(),
-            });
+            }
+            if (evicted.length > 0) {
+                logInfo('Expired sessions evicted', {
+                    evicted: evicted.length,
+                    timestamp: new Date(now).toISOString(),
+                });
+            }
         }
     }
 }
 export function startSessionCleanupLoop(store, sessionTtlMs) {
-    const controller = new AbortController();
-    void runSessionCleanupLoop(store, sessionTtlMs, controller.signal).catch(handleSessionCleanupError);
-    return controller;
+    return new SessionCleanupLoop(store, sessionTtlMs).start();
 }
-export function createSessionStore(sessionTtlMs) {
-    const sessions = new Map();
-    let inflight = 0;
-    return {
-        get: (sessionId) => sessions.get(sessionId),
-        touch: (sessionId) => {
-            const session = sessions.get(sessionId);
-            if (session) {
-                session.lastSeen = Date.now();
-                // Move to end (LRU behavior if needed, but Map insertion order)
-                moveSessionToEnd(sessions, sessionId, session);
-            }
-        },
-        set: (sessionId, entry) => {
-            sessions.set(sessionId, entry);
-        },
-        remove: (sessionId) => {
-            const session = sessions.get(sessionId);
-            sessions.delete(sessionId);
-            return session;
-        },
-        size: () => sessions.size,
-        inFlight: () => inflight,
-        incrementInFlight: () => {
-            inflight += 1;
-        },
-        decrementInFlight: () => {
-            if (inflight > 0)
-                inflight -= 1;
-        },
-        clear: () => {
-            const entries = [...sessions.values()];
-            sessions.clear();
-            return entries;
-        },
-        evictExpired: () => {
-            const now = Date.now();
-            const evicted = [];
-            for (const [id, session] of sessions.entries()) {
-                if (isSessionExpired(session, now, sessionTtlMs)) {
-                    sessions.delete(id);
-                    evicted.push(session);
-                }
+/* -------------------------------------------------------------------------------------------------
+ * Session store (in-memory, Map order used for LRU)
+ * ------------------------------------------------------------------------------------------------- */
+function moveSessionToEnd(sessions, sessionId, session) {
+    sessions.delete(sessionId);
+    sessions.set(sessionId, session);
+}
+class InMemorySessionStore {
+    sessionTtlMs;
+    sessions = new Map();
+    inflight = 0;
+    constructor(sessionTtlMs) {
+        this.sessionTtlMs = sessionTtlMs;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    touch(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.lastSeen = Date.now();
+        moveSessionToEnd(this.sessions, sessionId, session);
+    }
+    set(sessionId, entry) {
+        this.sessions.set(sessionId, entry);
+    }
+    remove(sessionId) {
+        const session = this.sessions.get(sessionId);
+        this.sessions.delete(sessionId);
+        return session;
+    }
+    size() {
+        return this.sessions.size;
+    }
+    inFlight() {
+        return this.inflight;
+    }
+    incrementInFlight() {
+        this.inflight += 1;
+    }
+    decrementInFlight() {
+        if (this.inflight > 0)
+            this.inflight -= 1;
+    }
+    clear() {
+        const entries = [...this.sessions.values()];
+        this.sessions.clear();
+        return entries;
+    }
+    evictExpired() {
+        const now = Date.now();
+        const evicted = [];
+        for (const [id, session] of this.sessions.entries()) {
+            if (isSessionExpired(session, now, this.sessionTtlMs)) {
+                this.sessions.delete(id);
+                evicted.push(session);
             }
-            return evicted;
-        },
-        evictOldest: () => {
-            const oldestEntry = sessions.keys().next();
-            if (oldestEntry.done)
-                return undefined;
-            const oldestId = oldestEntry.value;
-            const session = sessions.get(oldestId);
-            sessions.delete(oldestId);
-            return session;
-        },
-    };
+        }
+        return evicted;
+    }
+    evictOldest() {
+        const oldest = this.sessions.keys().next();
+        if (oldest.done)
+            return undefined;
+        const oldestId = oldest.value;
+        const session = this.sessions.get(oldestId);
+        this.sessions.delete(oldestId);
+        return session;
+    }
+}
+export function createSessionStore(sessionTtlMs) {
+    return new InMemorySessionStore(sessionTtlMs);
+}
+/* -------------------------------------------------------------------------------------------------
+ * Slot tracker
+ * ------------------------------------------------------------------------------------------------- */
+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;
+    }
 }
-// --- Slot Tracker ---
 export function createSlotTracker(store) {
-    let slotReleased = false;
-    let initialized = false;
-    return {
-        releaseSlot: () => {
-            if (slotReleased)
-                return;
-            slotReleased = true;
-            store.decrementInFlight();
-        },
-        markInitialized: () => {
-            initialized = true;
-        },
-        isInitialized: () => initialized,
-    };
+    return new SessionSlotTracker(store);
 }
 export function reserveSessionSlot(store, maxSessions) {
     if (store.size() + store.inFlight() >= maxSessions) {
@@ -144,16 +179,20 @@ export function reserveSessionSlot(store, maxSessions) {
     store.incrementInFlight();
     return true;
 }
+/* -------------------------------------------------------------------------------------------------
+ * Capacity policy
+ * ------------------------------------------------------------------------------------------------- */
+function isAtCapacity(store, maxSessions) {
+    return store.size() + store.inFlight() >= maxSessions;
+}
 export function ensureSessionCapacity({ store, maxSessions, evictOldest, }) {
     const currentSize = store.size();
-    const isAtCapacity = currentSize + store.inFlight() >= maxSessions;
-    if (!isAtCapacity)
+    const inflight = store.inFlight();
+    if (currentSize + inflight < maxSessions)
         return true;
-    // Try to free a slot
-    const canFreeSlot = currentSize >= maxSessions &&
-        currentSize - 1 + store.inFlight() < maxSessions;
+    const canFreeSlot = currentSize >= maxSessions && currentSize - 1 + inflight < maxSessions;
     if (canFreeSlot && evictOldest(store)) {
-        return store.size() + store.inFlight() < maxSessions;
+        return !isAtCapacity(store, maxSessions);
     }
     return false;
 }

package/dist/tasks.d.ts

@@ -0,0 +1,37 @@
+export type TaskStatus = 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+export interface TaskState {
+    taskId: string;
+    status: TaskStatus;
+    statusMessage?: string;
+    createdAt: string;
+    lastUpdatedAt: string;
+    ttl: number;
+    pollInterval: number;
+    result?: unknown;
+    error?: unknown;
+}
+export interface CreateTaskOptions {
+    ttl?: number;
+}
+export interface CreateTaskResult {
+    task: {
+        taskId: string;
+        status: TaskStatus;
+        statusMessage?: string;
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttl: number;
+        pollInterval: number;
+    };
+    _meta?: Record<string, unknown>;
+}
+export declare class TaskManager {
+    private tasks;
+    createTask(options?: CreateTaskOptions, statusMessage?: string): TaskState;
+    getTask(taskId: string): TaskState | undefined;
+    updateTask(taskId: string, updates: Partial<Omit<TaskState, 'taskId' | 'createdAt'>>): void;
+    cancelTask(taskId: string): TaskState | undefined;
+    listTasks(): TaskState[];
+    cleanupExpiredTasks(): number;
+}
+export declare const taskManager: TaskManager;

package/dist/tasks.js

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto';
+const DEFAULT_TTL_MS = 60000;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+export class TaskManager {
+    tasks = new Map();
+    createTask(options, statusMessage = 'Task started') {
+        const taskId = randomUUID();
+        const now = new Date().toISOString();
+        const task = {
+            taskId,
+            status: 'working',
+            statusMessage,
+            createdAt: now,
+            lastUpdatedAt: now,
+            ttl: options?.ttl ?? DEFAULT_TTL_MS,
+            pollInterval: DEFAULT_POLL_INTERVAL_MS,
+        };
+        this.tasks.set(taskId, task);
+        return task;
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    updateTask(taskId, updates) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        Object.assign(task, {
+            ...updates,
+            lastUpdatedAt: new Date().toISOString(),
+        });
+    }
+    cancelTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return undefined;
+        if (task.status === 'completed' ||
+            task.status === 'failed' ||
+            task.status === 'cancelled') {
+            throw new Error(`Cannot cancel task: already in terminal status '${task.status}'`);
+        }
+        this.updateTask(taskId, {
+            status: 'cancelled',
+            statusMessage: 'The task was cancelled by request.',
+        });
+        return this.tasks.get(taskId);
+    }
+    listTasks() {
+        return Array.from(this.tasks.values());
+    }
+    // Helper to check if task is expired and could be cleaned up
+    // In a real implementation, this would be called by a periodic job
+    cleanupExpiredTasks() {
+        const now = Date.now();
+        let count = 0;
+        for (const [id, task] of this.tasks.entries()) {
+            const created = new Date(task.createdAt).getTime();
+            if (now - created > task.ttl) {
+                this.tasks.delete(id);
+                count++;
+            }
+        }
+        return count;
+    }
+}
+export const taskManager = new TaskManager();

package/dist/tools.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { CallToolResult, ContentBlock } from '@modelcontextprotocol/sdk/types.js';
+import * as cache from './cache.js';
 import type { MarkdownTransformResult } from './transform-types.js';
 export interface FetchUrlInput {
     url: string;
@@ -34,19 +35,12 @@ export type ToolErrorResponse = CallToolResult & {
 };
 export type ToolResponseBase = CallToolResult;
 export interface FetchPipelineOptions<T> {
-    /** URL to fetch */
     url: string;
-    /** Cache namespace (e.g., 'markdown') */
     cacheNamespace: string;
-    /** Optional: AbortSignal for request cancellation */
     signal?: AbortSignal;
-    /** Optional: cache variation input for headers/flags */
     cacheVary?: Record<string, unknown> | string;
-    /** Transform function to process HTML into desired format */
     transform: (html: string, url: string) => T | Promise<T>;
-    /** Optional: serialize result for caching (defaults to JSON.stringify) */
     serialize?: (result: T) => string;
-    /** Optional: deserialize cached content */
     deserialize?: (cached: string) => T | undefined;
 }
 export interface PipelineResult<T> {
@@ -92,8 +86,12 @@ interface InlineContentResult {
     error?: string;
     truncated?: boolean;
 }
-declare function applyInlineContentLimit(content: string, cacheKey: string | null): InlineContentResult;
-export type InlineResult = ReturnType<typeof applyInlineContentLimit>;
+export type InlineResult = ReturnType<InlineContentLimiter['apply']>;
+declare class InlineContentLimiter {
+    apply(content: string, cacheKey: string | null): InlineContentResult;
+    private resolveResourceUri;
+    private buildTruncatedFallback;
+}
 export declare function executeFetchPipeline<T>(options: FetchPipelineOptions<T>): Promise<PipelineResult<T>>;
 interface SharedFetchOptions<T extends {
     content: string;
@@ -121,5 +119,5 @@ type MarkdownPipelineResult = MarkdownTransformResult & {
 export declare function parseCachedMarkdownResult(cached: string): MarkdownPipelineResult | undefined;
 export declare function fetchUrlToolHandler(input: FetchUrlInput, extra?: ToolHandlerExtra): Promise<ToolResponseBase>;
 export declare function withRequestContextIfMissing<TParams, TResult, TExtra = unknown>(handler: (params: TParams, extra?: TExtra) => Promise<TResult>): (params: TParams, extra?: TExtra) => Promise<TResult>;
-export declare function registerTools(server: McpServer, serverIcon?: string): void;
+export declare function registerTools(server: McpServer, serverIcons?: cache.McpIcon[]): void;
 export {};