@j0hanz/superfetch 2.0.0 → 2.1.0

package/dist/http/mcp-session-eviction.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStore } from './sessions.js';
+export declare function evictExpiredSessions(store: SessionStore): number;
+export declare function evictOldestSession(store: SessionStore): boolean;

package/dist/http/mcp-session-eviction.js

@@ -0,0 +1,24 @@
+import { logWarn } from '../services/logger.js';
+import { getErrorMessage } from '../utils/error-details.js';
+export function evictExpiredSessions(store) {
+    const evicted = store.evictExpired();
+    for (const session of evicted) {
+        void session.transport.close().catch((error) => {
+            logWarn('Failed to close expired session', {
+                error: getErrorMessage(error),
+            });
+        });
+    }
+    return evicted.length;
+}
+export function evictOldestSession(store) {
+    const session = store.evictOldest();
+    if (!session)
+        return false;
+    void session.transport.close().catch((error) => {
+        logWarn('Failed to close evicted session', {
+            error: getErrorMessage(error),
+        });
+    });
+    return true;
+}

package/dist/http/mcp-session-init.d.ts

@@ -0,0 +1,7 @@
+import type { Response } from 'express';
+import type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { McpSessionOptions } from './mcp-session-types.js';
+export declare function createAndConnectTransport({ options, res, }: {
+    options: McpSessionOptions;
+    res: Response;
+}): Promise<StreamableHTTPServerTransport | null>;

package/dist/http/mcp-session-init.js

@@ -0,0 +1,94 @@
+import { logError, logInfo, logWarn } from '../services/logger.js';
+import { getErrorMessage } from '../utils/error-details.js';
+import { createMcpServer } from '../server.js';
+import { evictOldestSession } from './mcp-session-eviction.js';
+import { createSlotTracker, ensureSessionCapacity, reserveSessionSlot, respondBadRequest, respondServerBusy, } from './mcp-session-slots.js';
+import { createSessionTransport } from './mcp-session-transport-init.js';
+import { createTimeoutController, createTransportAdapter, } from './mcp-session-transport.js';
+async function connectTransportOrThrow({ transport, clearInitTimeout, releaseSlot, }) {
+    const mcpServer = createMcpServer();
+    const transportAdapter = createTransportAdapter(transport);
+    try {
+        await mcpServer.connect(transportAdapter);
+    }
+    catch (error) {
+        clearInitTimeout();
+        releaseSlot();
+        void transport.close().catch((closeError) => {
+            logWarn('Failed to close transport after connect error', {
+                error: getErrorMessage(closeError),
+            });
+        });
+        logError('Failed to initialize MCP session', error instanceof Error ? error : undefined);
+        throw error;
+    }
+}
+export async function createAndConnectTransport({ options, res, }) {
+    if (!reserveSessionIfPossible({ options, res }))
+        return null;
+    const tracker = createSlotTracker();
+    const timeoutController = createTimeoutController();
+    const transport = createSessionTransport({ tracker, timeoutController });
+    await connectTransportOrThrow({
+        transport,
+        clearInitTimeout: timeoutController.clear,
+        releaseSlot: tracker.releaseSlot,
+    });
+    const sessionId = resolveSessionId({
+        transport,
+        res,
+        tracker,
+        clearInitTimeout: timeoutController.clear,
+    });
+    if (!sessionId)
+        return null;
+    finalizeSession({
+        store: options.sessionStore,
+        transport,
+        sessionId,
+        tracker,
+        clearInitTimeout: timeoutController.clear,
+    });
+    return transport;
+}
+function reserveSessionIfPossible({ options, res, }) {
+    if (!ensureSessionCapacity({
+        store: options.sessionStore,
+        maxSessions: options.maxSessions,
+        res,
+        evictOldest: evictOldestSession,
+    })) {
+        return false;
+    }
+    if (!reserveSessionSlot(options.sessionStore, options.maxSessions)) {
+        respondServerBusy(res);
+        return false;
+    }
+    return true;
+}
+function resolveSessionId({ transport, res, tracker, clearInitTimeout, }) {
+    const { sessionId } = transport;
+    if (typeof sessionId !== 'string') {
+        clearInitTimeout();
+        tracker.releaseSlot();
+        respondBadRequest(res);
+        return null;
+    }
+    return sessionId;
+}
+function finalizeSession({ store, transport, sessionId, tracker, clearInitTimeout, }) {
+    clearInitTimeout();
+    tracker.markInitialized();
+    tracker.releaseSlot();
+    const now = Date.now();
+    store.set(sessionId, {
+        transport,
+        createdAt: now,
+        lastSeen: now,
+    });
+    transport.onclose = () => {
+        store.remove(sessionId);
+        logInfo('Session closed');
+    };
+    logInfo('Session initialized');
+}

package/dist/http/mcp-session-slots.d.ts

@@ -0,0 +1,17 @@
+import type { Response } from 'express';
+import type { SessionStore } from './sessions.js';
+export interface SlotTracker {
+    readonly releaseSlot: () => void;
+    readonly markInitialized: () => void;
+    readonly isInitialized: () => boolean;
+}
+export declare function reserveSessionSlot(store: SessionStore, maxSessions: number): boolean;
+export declare function createSlotTracker(): SlotTracker;
+export declare function ensureSessionCapacity({ store, maxSessions, res, evictOldest, }: {
+    store: SessionStore;
+    maxSessions: number;
+    res: Response;
+    evictOldest: (store: SessionStore) => boolean;
+}): boolean;
+export declare function respondServerBusy(res: Response): void;
+export declare function respondBadRequest(res: Response): void;

package/dist/http/mcp-session-slots.js

@@ -0,0 +1,55 @@
+import { sendJsonRpcError } from './jsonrpc-http.js';
+let inFlightSessions = 0;
+export function reserveSessionSlot(store, maxSessions) {
+    if (store.size() + inFlightSessions >= maxSessions) {
+        return false;
+    }
+    inFlightSessions += 1;
+    return true;
+}
+function releaseSessionSlot() {
+    if (inFlightSessions > 0) {
+        inFlightSessions -= 1;
+    }
+}
+export function createSlotTracker() {
+    let slotReleased = false;
+    let initialized = false;
+    return {
+        releaseSlot: () => {
+            if (slotReleased)
+                return;
+            slotReleased = true;
+            releaseSessionSlot();
+        },
+        markInitialized: () => {
+            initialized = true;
+        },
+        isInitialized: () => initialized,
+    };
+}
+export function ensureSessionCapacity({ store, maxSessions, res, evictOldest, }) {
+    if (!isServerAtCapacity(store, maxSessions)) {
+        return true;
+    }
+    if (tryEvictSlot(store, maxSessions, evictOldest)) {
+        return !isServerAtCapacity(store, maxSessions);
+    }
+    respondServerBusy(res);
+    return false;
+}
+function isServerAtCapacity(store, maxSessions) {
+    return store.size() + inFlightSessions >= maxSessions;
+}
+function tryEvictSlot(store, maxSessions, evictOldest) {
+    const currentSize = store.size();
+    const canFreeSlot = currentSize >= maxSessions &&
+        currentSize - 1 + inFlightSessions < maxSessions;
+    return canFreeSlot && evictOldest(store);
+}
+export function respondServerBusy(res) {
+    sendJsonRpcError(res, -32000, 'Server busy: maximum sessions reached', 503);
+}
+export function respondBadRequest(res) {
+    sendJsonRpcError(res, -32000, 'Bad Request: Missing session ID or not an initialize request', 400);
+}

package/dist/http/mcp-session-transport-init.d.ts

@@ -0,0 +1,7 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { SlotTracker } from './mcp-session-slots.js';
+import type { createTimeoutController } from './mcp-session-transport.js';
+export declare function createSessionTransport({ tracker, timeoutController, }: {
+    tracker: SlotTracker;
+    timeoutController: ReturnType<typeof createTimeoutController>;
+}): StreamableHTTPServerTransport;

package/dist/http/mcp-session-transport-init.js

@@ -0,0 +1,41 @@
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { config } from '../config/index.js';
+import { logWarn } from '../services/logger.js';
+import { getErrorMessage } from '../utils/error-details.js';
+function startSessionInitTimeout({ transport, tracker, clearInitTimeout, timeoutMs, }) {
+    if (timeoutMs <= 0)
+        return null;
+    const timeout = setTimeout(() => {
+        clearInitTimeout();
+        if (tracker.isInitialized())
+            return;
+        tracker.releaseSlot();
+        void transport.close().catch((error) => {
+            logWarn('Failed to close stalled session', {
+                error: getErrorMessage(error),
+            });
+        });
+        logWarn('Session initialization timed out', { timeoutMs });
+    }, timeoutMs);
+    timeout.unref();
+    return timeout;
+}
+export function createSessionTransport({ tracker, timeoutController, }) {
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+    });
+    transport.onclose = () => {
+        timeoutController.clear();
+        if (!tracker.isInitialized()) {
+            tracker.releaseSlot();
+        }
+    };
+    timeoutController.set(startSessionInitTimeout({
+        transport,
+        tracker,
+        clearInitTimeout: timeoutController.clear,
+        timeoutMs: config.server.sessionInitTimeoutMs,
+    }));
+    return transport;
+}

package/dist/http/mcp-session-types.d.ts

@@ -0,0 +1,5 @@
+import type { SessionStore } from './sessions.js';
+export interface McpSessionOptions {
+    readonly sessionStore: SessionStore;
+    readonly maxSessions: number;
+}

package/dist/http/mcp-session-types.js

@@ -0,0 +1 @@
+export {};

package/dist/http/mcp-session.d.ts

@@ -1,10 +1,10 @@
-import type { Request, Response } from 'express';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { Response } from 'express';
+import type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import type { McpRequestBody } from '../config/types/runtime.js';
-import { type SessionStore } from './sessions.js';
-export interface McpSessionOptions {
-    readonly sessionStore: SessionStore;
-    readonly maxSessions: number;
-}
-export declare function resolveTransportForPost(_req: Request, res: Response, body: McpRequestBody, sessionId: string | undefined, options: McpSessionOptions): Promise<StreamableHTTPServerTransport | null>;
-export declare function evictExpiredSessions(store: SessionStore): number;
+import type { McpSessionOptions } from './mcp-session-types.js';
+export declare function resolveTransportForPost({ res, body, sessionId, options, }: {
+    res: Response;
+    body: McpRequestBody;
+    sessionId: string | undefined;
+    options: McpSessionOptions;
+}): Promise<StreamableHTTPServerTransport | null>;

package/dist/http/mcp-session.js

@@ -1,96 +1,9 @@
-import { randomUUID } from 'node:crypto';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import { config } from '../config/index.js';
-import { logError, logInfo, logWarn } from '../services/logger.js';
-import { getErrorMessage } from '../utils/error-utils.js';
-import { createMcpServer } from '../server.js';
 import { sendJsonRpcError } from './jsonrpc-http.js';
-import { createSlotTracker, ensureSessionCapacity, reserveSessionSlot, respondBadRequest, respondServerBusy, } from './mcp-session-helpers.js';
-import { createTimeoutController, createTransportAdapter, } from './mcp-session-transport.js';
-import {} from './sessions.js';
-function startSessionInitTimeout(transport, tracker, clearInitTimeout, timeoutMs) {
-    if (timeoutMs <= 0)
-        return null;
-    const timeout = setTimeout(() => {
-        clearInitTimeout();
-        if (tracker.isInitialized())
-            return;
-        tracker.releaseSlot();
-        void transport.close().catch((error) => {
-            logWarn('Failed to close stalled session', {
-                error: getErrorMessage(error),
-            });
-        });
-        logWarn('Session initialization timed out', { timeoutMs });
-    }, timeoutMs);
-    timeout.unref();
-    return timeout;
-}
-async function connectTransportOrThrow(transport, clearInitTimeout, releaseSlot) {
-    const mcpServer = createMcpServer();
-    const transportAdapter = createTransportAdapter(transport);
-    try {
-        await mcpServer.connect(transportAdapter);
-    }
-    catch (error) {
-        clearInitTimeout();
-        releaseSlot();
-        void transport.close().catch((closeError) => {
-            logWarn('Failed to close transport after connect error', {
-                error: getErrorMessage(closeError),
-            });
-        });
-        logError('Failed to initialize MCP session', error instanceof Error ? error : undefined);
-        throw error;
-    }
-}
-async function createAndConnectTransport(options, res) {
-    if (!ensureSessionCapacity(options.sessionStore, options.maxSessions, res, evictOldestSession)) {
-        return null;
-    }
-    if (!reserveSessionSlot(options.sessionStore, options.maxSessions)) {
-        respondServerBusy(res);
-        return null;
-    }
-    const tracker = createSlotTracker();
-    const timeoutController = createTimeoutController();
-    const { clear: clearInitTimeout } = timeoutController;
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-    });
-    transport.onclose = () => {
-        clearInitTimeout();
-        if (!tracker.isInitialized()) {
-            tracker.releaseSlot();
-        }
-    };
-    timeoutController.set(startSessionInitTimeout(transport, tracker, clearInitTimeout, config.server.sessionInitTimeoutMs));
-    await connectTransportOrThrow(transport, clearInitTimeout, tracker.releaseSlot);
-    const { sessionId } = transport;
-    if (typeof sessionId !== 'string') {
-        clearInitTimeout();
-        tracker.releaseSlot();
-        respondBadRequest(res);
-        return null;
-    }
-    clearInitTimeout();
-    tracker.markInitialized();
-    tracker.releaseSlot();
-    const now = Date.now();
-    options.sessionStore.set(sessionId, {
-        transport,
-        createdAt: now,
-        lastSeen: now,
-    });
-    transport.onclose = () => {
-        options.sessionStore.remove(sessionId);
-        logInfo('Session closed');
-    };
-    logInfo('Session initialized');
-    return transport;
-}
-export async function resolveTransportForPost(_req, res, body, sessionId, options) {
+import { evictExpiredSessions } from './mcp-session-eviction.js';
+import { createAndConnectTransport } from './mcp-session-init.js';
+import { respondBadRequest } from './mcp-session-slots.js';
+export async function resolveTransportForPost({ res, body, sessionId, options, }) {
     if (sessionId) {
         const existingSession = options.sessionStore.get(sessionId);
         if (existingSession) {
@@ -106,27 +19,5 @@ export async function resolveTransportForPost(_req, res, body, sessionId, option
         return null;
     }
     evictExpiredSessions(options.sessionStore);
-    return createAndConnectTransport(options, res);
-}
-export function evictExpiredSessions(store) {
-    const evicted = store.evictExpired();
-    for (const session of evicted) {
-        void session.transport.close().catch((error) => {
-            logWarn('Failed to close expired session', {
-                error: getErrorMessage(error),
-            });
-        });
-    }
-    return evicted.length;
-}
-function evictOldestSession(store) {
-    const session = store.evictOldest();
-    if (!session)
-        return false;
-    void session.transport.close().catch((error) => {
-        logWarn('Failed to close evicted session', {
-            error: getErrorMessage(error),
-        });
-    });
-    return true;
+    return createAndConnectTransport({ options, res });
 }

package/dist/http/mcp-sessions.d.ts

@@ -0,0 +1,41 @@
+import type { Request, Response } from 'express';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { McpRequestBody, SessionEntry } from '../config/types/runtime.js';
+export interface SessionStore {
+    get: (sessionId: string) => SessionEntry | undefined;
+    touch: (sessionId: string) => void;
+    set: (sessionId: string, entry: SessionEntry) => void;
+    remove: (sessionId: string) => SessionEntry | undefined;
+    size: () => number;
+    clear: () => SessionEntry[];
+    evictExpired: () => SessionEntry[];
+    evictOldest: () => SessionEntry | undefined;
+}
+export interface McpSessionOptions {
+    readonly sessionStore: SessionStore;
+    readonly maxSessions: number;
+}
+export declare function sendJsonRpcError(res: Response, code: number, message: string, status?: number, id?: string | number | null): void;
+export declare function getSessionId(req: Request): string | undefined;
+export declare function createSessionStore(sessionTtlMs: number): SessionStore;
+export declare function reserveSessionSlot(store: SessionStore, maxSessions: number): boolean;
+interface SlotTracker {
+    readonly releaseSlot: () => void;
+    readonly markInitialized: () => void;
+    readonly isInitialized: () => boolean;
+}
+export declare function createSlotTracker(): SlotTracker;
+export declare function ensureSessionCapacity({ store, maxSessions, res, evictOldest, }: {
+    store: SessionStore;
+    maxSessions: number;
+    res: Response;
+    evictOldest: (store: SessionStore) => boolean;
+}): boolean;
+export declare function resolveTransportForPost({ res, body, sessionId, options, }: {
+    res: Response;
+    body: Pick<McpRequestBody, 'method' | 'id'>;
+    sessionId: string | undefined;
+    options: McpSessionOptions;
+}): Promise<StreamableHTTPServerTransport | null>;
+export declare function startSessionCleanupLoop(store: SessionStore, sessionTtlMs: number): AbortController;
+export {};