@adminforth/mcp 1.1.2 → 1.3.0

package/dist/index.d.ts

@@ -4,16 +4,16 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
     options: PluginOptions;
     pluginsScope: 'global';
     private authSecretStore;
-    /** Null when OAuth sign-in is not configured; then only auth secrets authenticate. */
     private oauth;
     private apiTools;
+    private adminPanelConfirmation?;
     private skills;
-    /** Null without adminPanelOrigin; then the settings page shows the MCP URL of the address it was opened at. */
     private urls;
+    private readonly protocol;
+    private readonly serverReadOnly;
     constructor(options: PluginOptions);
     instanceUniqueRepresentation(): string;
     modifyGlobalConfig(adminforth: IAdminForth): void;
-    private createOAuth;
     private validateAuthSecretResource;
     setupEndpoints(server: IHttpServer): void;
     /** Accepts personal auth secrets and OAuth access tokens; access tokens are JWTs, secrets have their prefix. */
@@ -22,4 +22,3 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
 }
 export type { McpAuthSecretResourceOptions, McpOAuthClient, PluginOptions } from './types.js';
 export { canonicalAgentName, formatMcpExecutedBy, readMcpClient } from './clientInfo.js';
-export { handleMcpProtocol } from './mcpProtocol.js';

package/dist/index.js

@@ -1,53 +1,27 @@
-import { AdminForthPlugin, logger, } from 'adminforth';
+import { AdminForthPlugin, } from 'adminforth';
+import { McpAdminPanelConfirmation, WAIT_FOR_CONFIRMATION_TOOL_NAME } from './adminPanelConfirmation.js';
+import { registerConfirmationEndpoints } from './endpoints/confirmation.js';
 import { AdminForthApiTools } from './apiTools.js';
 import { formatMcpExecutedBy, readMcpClient, UNKNOWN_CLIENT } from './clientInfo.js';
-import { createMcpServerPresentation, handleMcpProtocol } from './mcpProtocol.js';
+import { createMcpServerPresentation, McpProtocol } from './mcpProtocol.js';
 import { McpAuthSecretStore, SECRET_PREFIX } from './authSecretStore.js';
-import { CONSENT_PAGE_PATH, McpOAuth } from './oauth.js';
-import { isLoopbackUrl } from './oauthClientMetadata.js';
-import { setupOAuthEndpoints } from './oauthEndpoints.js';
+import { registerMcpEndpoints } from './endpoints/mcp.js';
+import { registerOAuthEndpoints } from './endpoints/oAuth.js';
+import { registerSettingsEndpoints } from './endpoints/settings.js';
+import { registerToolEndpoints } from './endpoints/tools.js';
+import { AuthSecretRepository } from './repositories/authSecret.js';
+import { setupOAuth } from './oauth/setup.js';
+import { requestExtra } from './requestExtra.js';
+import { createServerReadOnly } from './serverReadOnly.js';
 import { FETCH_SKILL_TOOL_NAME, McpSkills } from './skills.js';
-import { adminApiPrefix, createMcpUrls, MCP_PATH } from './urls.js';
+import { findContextualTwoFactorsAuth } from './twoFactorContext.js';
+import { adminApiPrefix, CONFIRMATION_PAGE_PATH, createMcpUrls } from './urls.js';
 const BEARER_TOKEN_RE = /^Bearer (\S+)$/i;
 const CREDENTIAL_HEADERS = new Set(['authorization', 'proxy-authorization', 'cookie']);
 const DEFAULT_PAGE_SIZE = 10;
 const MAX_PAGE_SIZE = 100;
 const DEFAULT_TOOL_TIMEOUT_MS = 15_000;
 const DEFAULT_TOOL_CALLS_PER_REQUEST = 10;
-const RESOURCES_LIST_RESPONSE_SCHEMA = {
-    type: 'object',
-    required: ['resources'],
-    properties: {
-        resources: {
-            type: 'array',
-            description: 'Every resource of the admin panel. Access is checked when a resource is used, so the user may still be forbidden to list, show, create, edit or delete records of a listed resource.',
-            items: {
-                type: 'object',
-                required: ['resourceId', 'label'],
-                properties: {
-                    resourceId: {
-                        type: 'string',
-                        description: 'Resource identifier. Pass it as resourceId to get_resource, get_resource_data, aggregate, create_record, update_record, delete_record and other resource tools. Call get_resource with it to get the columns and allowed actions of the resource.',
-                    },
-                    label: {
-                        type: 'string',
-                        description: 'Human readable resource name, translated for the current user.',
-                    },
-                },
-            },
-        },
-    },
-};
-function requestExtra(input) {
-    return {
-        body: input.body,
-        query: input.query,
-        headers: input.headers,
-        cookies: input.cookies,
-        requestUrl: input.requestUrl,
-        response: input.response,
-    };
-}
 /**
  * The MCP auth secret is a long-lived credential, so it is dropped as soon as it is verified and
  * never reaches tool handlers, which may log, persist or forward the headers they are given.
@@ -66,15 +40,17 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
     options;
     pluginsScope = 'global';
     authSecretStore;
-    /** Null when OAuth sign-in is not configured; then only auth secrets authenticate. */
     oauth;
     apiTools;
+    adminPanelConfirmation;
     skills;
-    /** Null without adminPanelOrigin; then the settings page shows the MCP URL of the address it was opened at. */
     urls;
+    protocol = new McpProtocol();
+    serverReadOnly;
     constructor(options) {
         super(options, import.meta.url);
         this.options = options;
+        this.serverReadOnly = createServerReadOnly(options.readOnly);
         this.shouldHaveSingleInstancePerWholeApp = () => true;
     }
     instanceUniqueRepresentation() {
@@ -107,47 +83,29 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
                 isVisible: () => true,
             });
         }
-        this.urls = this.options.adminPanelOrigin
-            ? createMcpUrls(this.options.adminPanelOrigin, adminforth.config.baseUrl)
-            : null;
-        this.authSecretStore = new McpAuthSecretStore(adminforth, this.options.authSecretResource);
-        this.oauth = this.options.authSecretResource.oauthClientIdField ? this.createOAuth(adminforth) : null;
+        this.urls = createMcpUrls(this.options.adminPanelOrigin, adminforth.config.baseUrl);
+        this.authSecretStore = new McpAuthSecretStore(adminforth, new AuthSecretRepository(adminforth, this.options.authSecretResource));
+        this.oauth = setupOAuth(adminforth, this.authSecretStore, this.urls, this.options, this.componentPath('McpAuthorize.vue'), this.serverReadOnly);
+        const toolTimeoutMs = this.options.toolTimeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
+        const twoFactorsAuth = findContextualTwoFactorsAuth(adminforth);
+        if (twoFactorsAuth) {
+            adminforth.config.customization.customPages.push({
+                path: CONFIRMATION_PAGE_PATH,
+                component: { file: this.componentPath('McpConfirm.vue'), meta: { sidebarAndHeader: 'none' } },
+            });
+            this.adminPanelConfirmation = new McpAdminPanelConfirmation(adminforth, this.urls, twoFactorsAuth, toolTimeoutMs);
+        }
         const pageSize = {
             default: this.options.pageSize?.default ?? DEFAULT_PAGE_SIZE,
             max: this.options.pageSize?.max ?? MAX_PAGE_SIZE,
         };
-        this.apiTools = new AdminForthApiTools(adminforth, new Set([this.options.authSecretResource.resourceId]), pageSize, this.options.toolTimeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS);
+        this.apiTools = new AdminForthApiTools(adminforth, new Set([this.options.authSecretResource.resourceId]), pageSize, toolTimeoutMs, this.adminPanelConfirmation);
         this.skills = new McpSkills(this.customFolderPath, {
             'pageSize.default': pageSize.default,
             'pageSize.max': pageSize.max,
             toolCallsPerRequest: this.options.toolCallsPerRequest ?? DEFAULT_TOOL_CALLS_PER_REQUEST,
         });
     }
-    createOAuth(adminforth) {
-        if (!this.urls) {
-            throw new Error('AdminForthMcpPlugin: adminPanelOrigin is required with authSecretResource.oauthClientIdField, '
-                + 'OAuth issuer and MCP resource URLs are built from it');
-        }
-        // OAuth sends codes and tokens through these endpoints, so they must be served over TLS (RFC 6749 §3.1);
-        // plain http is left for a local admin panel.
-        const origin = new URL(this.urls.adminPanelUrl);
-        if (origin.protocol !== 'https:' && !isLoopbackUrl(origin)) {
-            throw new Error(`AdminForthMcpPlugin: adminPanelOrigin must use https with OAuth sign-in, got "${origin.origin}"; `
-                + 'http is allowed only for localhost and 127.0.0.1');
-        }
-        adminforth.config.customization.customPages.push({
-            path: CONSENT_PAGE_PATH,
-            component: {
-                file: this.componentPath('McpAuthorize.vue'),
-                meta: { sidebarAndHeader: 'none' },
-            },
-        });
-        const isProduction = process.env.NODE_ENV === 'production';
-        if (isProduction && this.options.devOAuthClients?.length) {
-            logger.warn('AdminForthMcpPlugin: devOAuthClients are ignored because NODE_ENV is "production"');
-        }
-        return new McpOAuth(adminforth, this.authSecretStore, this.urls, isProduction ? [] : this.options.devOAuthClients, this.options.readOnly);
-    }
     validateAuthSecretResource(resource) {
         const fields = this.options.authSecretResource;
         for (const fieldName of [
@@ -159,7 +117,7 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
             fields.lastUsedAtField,
             fields.lastUsedByAgentField,
             fields.readOnlyField,
-            ...(fields.oauthClientIdField ? [fields.oauthClientIdField] : []),
+            fields.oauthClientIdField,
         ]) {
             if (!resource.columns.some((column) => column.name === fieldName)) {
                 throw new Error(`AdminForthMcpPlugin: column "${fieldName}" not found in auth secret resource "${resource.resourceId}"`);
@@ -170,95 +128,17 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
         }
     }
     setupEndpoints(server) {
-        server.endpoint({
-            method: 'GET',
-            path: '/get_resources_list',
-            description: 'Lists the resourceId and label of every resource (data table), including resources the user cannot access: access is checked when a resource is used. Call this first to discover valid resourceId values before using get_resource, get_resource_data, aggregate, create_record, update_record, delete_record or other resource tools.',
-            agent: {
-                onlyReadsData: true,
-            },
-            response_schema: RESOURCES_LIST_RESPONSE_SCHEMA,
-            handler: async ({ tr }) => {
-                const resources = await Promise.all(this.adminforth.config.resources.map(async (resource) => ({
-                    resourceId: resource.resourceId,
-                    label: await tr(resource.label, `resource.${resource.resourceId}`),
-                })));
-                return { resources };
-            },
-        });
-        server.endpoint({
-            method: 'GET',
-            path: `${MCP_PATH}/auth-secrets`,
-            agent: {
-                hiddenFromAgents: true,
-            },
-            handler: async ({ adminUser }) => ({
-                authSecrets: await this.authSecretStore.list(adminUser),
-                oauthEnabled: Boolean(this.oauth),
-                mcpUrl: this.urls?.mcpUrl ?? null,
-                serverReadOnly: this.options.readOnly ?? false,
-            }),
-        });
-        server.endpoint({
-            method: 'POST',
-            path: `${MCP_PATH}/auth-secrets`,
-            agent: {
-                hiddenFromAgents: true,
-            },
-            handler: async (input) => {
-                const name = String(input.body.name ?? '').trim();
-                if (!name) {
-                    input.response.setStatus(400);
-                    return { error: 'Auth secret name is required' };
-                }
-                return this.authSecretStore.create(name, this.options.readOnly || input.body.readOnly === true, input.adminUser, requestExtra(input));
-            },
-        });
-        server.endpoint({
-            method: 'DELETE',
-            path: `${MCP_PATH}/auth-secrets`,
-            agent: {
-                hiddenFromAgents: true,
-            },
-            handler: async (input) => {
-                const result = await this.authSecretStore.revoke(String(input.body.id), input.adminUser, requestExtra(input));
-                if (result.error)
-                    input.response.setStatus(404);
-                return result;
-            },
-        });
-        if (this.oauth) {
-            setupOAuthEndpoints(server, this.oauth, adminApiPrefix(this.adminforth.config.baseUrl));
-        }
-        server.endpoint({
-            method: 'POST',
-            path: MCP_PATH,
-            agent: {
-                hiddenFromAgents: true,
-            },
-            noAuth: true,
-            handler: async (input) => this.handleMcpRequest(input),
-        });
-        // Streamable HTTP clients open a GET stream for server-initiated messages; 405 tells them this server has none.
-        server.endpoint({
-            method: 'GET',
-            path: MCP_PATH,
-            agent: {
-                hiddenFromAgents: true,
-            },
-            noAuth: true,
-            handler: async ({ response }) => {
-                response.setHeader('Allow', 'POST');
-                response.setStatus(405, 'Method Not Allowed');
-            },
-        });
+        registerToolEndpoints(server, this.adminforth);
+        registerSettingsEndpoints(server, this.authSecretStore, this.urls.mcpUrl, this.serverReadOnly);
+        registerOAuthEndpoints(server, this.oauth, adminApiPrefix(this.adminforth.config.baseUrl));
+        if (this.adminPanelConfirmation)
+            registerConfirmationEndpoints(server, this.adminPanelConfirmation);
+        registerMcpEndpoints(server, (input) => this.handleMcpRequest(input));
     }
     /** Accepts personal auth secrets and OAuth access tokens; access tokens are JWTs, secrets have their prefix. */
     async authenticate(token) {
         if (token.startsWith(SECRET_PREFIX))
             return this.authSecretStore.authenticate(token);
-        if (!this.oauth)
-            return null;
         const accessToken = await this.oauth.verifyAccessToken(token);
         return accessToken && this.authSecretStore.authenticateOAuthGrant(accessToken.grantId, accessToken.pk);
     }
@@ -271,13 +151,11 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
                 error: { code: -32003, message: 'Browser-originated MCP requests are not allowed.' },
             };
         }
-        const token = String(input.headers.authorization ?? '').match(BEARER_TOKEN_RE)?.[1];
+        const token = input.headers.authorization?.match(BEARER_TOKEN_RE)?.[1];
         const authenticated = token ? await this.authenticate(token) : null;
         if (!authenticated) {
             // resource_metadata leads OAuth clients to the authorization server; invalid_token makes them refresh.
-            input.response.setHeader('WWW-Authenticate', this.oauth
-                ? `Bearer ${token ? 'error="invalid_token", ' : ''}resource_metadata="${this.oauth.resourceMetadataUrl}"`
-                : 'Bearer');
+            input.response.setHeader('WWW-Authenticate', `Bearer ${token ? 'error="invalid_token", ' : ''}resource_metadata="${this.oauth.resourceMetadataUrl}"`);
             input.response.setStatus(401);
             return jsonRpcAuthError(input.body.id ?? null);
         }
@@ -296,15 +174,20 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
             ...authenticated.adminUser,
             executedBy: formatMcpExecutedBy(client, authenticated.name),
         };
-        const readOnly = this.options.readOnly || authenticated.readOnly;
-        const protocolResponse = await handleMcpProtocol({
-            ...createMcpServerPresentation(this.adminforth.config.customization.brandName, this.urls?.adminPanelUrl, this.skills.serverInstructions(), readOnly),
-            body: input.body,
-            headers: toolHeaders,
-            listTools: () => [...this.apiTools.list(readOnly), this.skills.toolDefinition()],
+        const readOnly = authenticated.readOnly || await this.serverReadOnly(authenticated.adminUser);
+        const protocolResponse = await this.protocol.handle(new Request(this.urls.mcpUrl, { method: 'POST', headers: toolHeaders }), input.body, {
+            ...createMcpServerPresentation(this.adminforth.config.customization.brandName, this.urls.adminPanelUrl, this.skills.serverInstructions(), readOnly),
+            listTools: () => [
+                ...this.apiTools.list(readOnly),
+                this.skills.toolDefinition(),
+                ...(this.adminPanelConfirmation ? [this.adminPanelConfirmation.toolDefinition()] : []),
+            ],
             callTool: async (name, arguments_) => {
                 if (name === FETCH_SKILL_TOOL_NAME)
                     return this.skills.call(arguments_);
+                if (name === WAIT_FOR_CONFIRMATION_TOOL_NAME && this.adminPanelConfirmation) {
+                    return this.adminPanelConfirmation.wait(String(arguments_?.confirmationId), authenticated.recordId);
+                }
                 return this.apiTools.call({
                     name,
                     arguments: arguments_,
@@ -313,16 +196,12 @@ export default class AdminForthMcpPlugin extends AdminForthPlugin {
                     requestUrl: input.requestUrl,
                     abortSignal: input.abortSignal,
                     readOnly,
+                    connection: { id: authenticated.recordId, name: authenticated.name },
                 });
             },
         });
-        input.response.setStatus(protocolResponse.status);
-        if (!protocolResponse.body) {
-            input._raw_express_res.status(protocolResponse.status).end();
-            return null;
-        }
-        return protocolResponse.body;
+        protocolResponse.headers.forEach((value, name) => input.response.setHeader(name, value));
+        input.response.setStatus(protocolResponse.status, await protocolResponse.text());
     }
 }
 export { canonicalAgentName, formatMcpExecutedBy, readMcpClient } from './clientInfo.js';
-export { handleMcpProtocol } from './mcpProtocol.js';

package/dist/mcpProtocol.d.ts

@@ -1,31 +1,18 @@
-import type { McpToolDefinition } from './apiTools.js';
-export declare const MODERN_PROTOCOL_VERSION = "2026-07-28";
-export declare const LEGACY_PROTOCOL_VERSION = "2025-11-25";
-export interface McpServerInfo {
-    name: string;
-    title: string;
-    version: string;
-    description: string;
-    websiteUrl?: string;
-}
+import { type Implementation, type Tool } from '@modelcontextprotocol/server';
 export interface McpServerPresentation {
-    serverInfo: McpServerInfo;
+    serverInfo: Implementation;
     instructions: string;
 }
-export declare function createMcpServerPresentation(brandName: string, adminPanelUrl?: string, guidance?: string, readOnly?: boolean): McpServerPresentation;
-export interface McpProtocolContext {
-    body: Record<string, any>;
-    headers: Record<string, any>;
-    serverInfo: McpServerInfo;
-    instructions: string;
-    listTools: () => McpToolDefinition[];
+export declare function createMcpServerPresentation(brandName: string, adminPanelUrl: string, guidance?: string, readOnly?: boolean): McpServerPresentation;
+export interface McpProtocolContext extends McpServerPresentation {
+    listTools: () => Tool[];
     callTool: (name: string, arguments_: Record<string, unknown> | undefined) => Promise<{
         output: unknown;
         isError: boolean;
     }>;
 }
-export interface McpProtocolResponse {
-    status: number;
-    body?: Record<string, unknown>;
+export declare class McpProtocol {
+    private readonly contexts;
+    private readonly handler;
+    handle(request: Request, parsedBody: unknown, context: McpProtocolContext): Promise<Response>;
 }
-export declare function handleMcpProtocol(context: McpProtocolContext): Promise<McpProtocolResponse>;

package/dist/mcpProtocol.js

@@ -1,23 +1,15 @@
+import { createMcpHandler, Server } from '@modelcontextprotocol/server';
 import YAML from 'yaml';
-export const MODERN_PROTOCOL_VERSION = '2026-07-28';
-export const LEGACY_PROTOCOL_VERSION = '2025-11-25';
-const LEGACY_PROTOCOL_VERSIONS = new Set([
-    LEGACY_PROTOCOL_VERSION,
-    '2025-06-18',
-    '2025-03-26',
-]);
-const PROTOCOL_VERSION_META_KEY = 'io.modelcontextprotocol/protocolVersion';
-const CLIENT_CAPABILITIES_META_KEY = 'io.modelcontextprotocol/clientCapabilities';
-const SERVER_INFO_META_KEY = 'io.modelcontextprotocol/serverInfo';
+const UNCACHED = { ttlMs: 0, cacheScope: 'private' };
 export function createMcpServerPresentation(brandName, adminPanelUrl, guidance = '', readOnly = false) {
-    const adminPanel = `AdminForth admin panel for "${brandName}"${adminPanelUrl ? ` at ${adminPanelUrl}` : ''}`;
+    const adminPanel = `AdminForth admin panel for "${brandName}" at ${adminPanelUrl}`;
     return {
         serverInfo: {
             name: 'adminforth-mcp',
             title: `${brandName} Admin Panel`,
             version: '1.0.0',
             description: `${adminPanel}.`,
-            ...(adminPanelUrl && { websiteUrl: adminPanelUrl }),
+            websiteUrl: adminPanelUrl,
         },
         instructions: [
             `This is the ${adminPanel}. Use its tools to ${readOnly ? 'read' : 'read and update'} data allowed for the authenticated user.`,
@@ -25,115 +17,28 @@ export function createMcpServerPresentation(brandName, adminPanelUrl, guidance =
         ].filter(Boolean).join('\n\n'),
     };
 }
-function errorResponse(id, code, message, status = 400) {
-    return {
-        status,
-        body: { jsonrpc: '2.0', id, error: { code, message } },
-    };
-}
-function isModernRequest(body) {
-    return body.params?._meta?.[PROTOCOL_VERSION_META_KEY] === MODERN_PROTOCOL_VERSION;
-}
-function completeResult(result, modern, serverInfo) {
-    if (!modern)
-        return result;
-    return {
-        resultType: 'complete',
-        ...result,
-        _meta: {
-            ...result._meta,
-            [SERVER_INFO_META_KEY]: serverInfo,
-        },
-    };
-}
-function successResponse(id, result, modern, serverInfo) {
-    return {
-        status: 200,
-        body: {
-            jsonrpc: '2.0',
-            id,
-            result: completeResult(result, modern, serverInfo),
-        },
-    };
-}
-function validateModernHeaders(body, headers) {
-    const meta = body.params?._meta;
-    if (!meta || !(CLIENT_CAPABILITIES_META_KEY in meta)) {
-        return errorResponse(body.id ?? null, -32602, 'Missing required MCP request metadata.');
-    }
-    if (headers['mcp-protocol-version'] !== MODERN_PROTOCOL_VERSION
-        || headers['mcp-method'] !== body.method
-        || (body.method === 'tools/call' && headers['mcp-name'] !== body.params?.name)) {
-        return errorResponse(body.id ?? null, -32020, 'MCP request headers do not match the JSON-RPC body.');
-    }
-    return null;
-}
 // The JSON round trip drops functions and undefined values that handler responses may carry, which YAML cannot serialize.
 function serializeToolOutput(output) {
     return typeof output === 'string' ? output : YAML.stringify(JSON.parse(JSON.stringify(output ?? null)));
 }
-export async function handleMcpProtocol(context) {
-    const { body, headers, serverInfo, instructions } = context;
-    if (body.jsonrpc !== '2.0' || typeof body.method !== 'string') {
-        return errorResponse(body.id ?? null, -32600, 'Invalid JSON-RPC request.');
-    }
-    const modern = isModernRequest(body);
-    const requestedVersion = body.params?._meta?.[PROTOCOL_VERSION_META_KEY];
-    if (requestedVersion && requestedVersion !== MODERN_PROTOCOL_VERSION) {
-        return errorResponse(body.id ?? null, -32000, `Unsupported MCP protocol version: ${requestedVersion}`);
-    }
-    if (modern) {
-        const headerError = validateModernHeaders(body, headers);
-        if (headerError)
-            return headerError;
-    }
-    if (body.id === undefined) {
-        return { status: 202 };
-    }
-    if (typeof body.id !== 'string' && typeof body.id !== 'number') {
-        return errorResponse(null, -32600, 'JSON-RPC id must be a string or number.');
-    }
-    switch (body.method) {
-        case 'server/discover':
-            if (!modern) {
-                return errorResponse(body.id, -32602, 'server/discover requires modern MCP request metadata.');
-            }
-            return successResponse(body.id, {
-                supportedVersions: [MODERN_PROTOCOL_VERSION],
-                capabilities: { tools: {} },
-                instructions,
-                ttlMs: 0,
-                cacheScope: 'private',
-            }, true, serverInfo);
-        case 'initialize': {
-            const requestedVersion = body.params?.protocolVersion;
-            return successResponse(body.id, {
-                protocolVersion: typeof requestedVersion === 'string' && LEGACY_PROTOCOL_VERSIONS.has(requestedVersion)
-                    ? requestedVersion
-                    : LEGACY_PROTOCOL_VERSION,
-                capabilities: { tools: { listChanged: false } },
-                serverInfo,
-                instructions,
-            }, false, serverInfo);
-        }
-        case 'ping':
-            return successResponse(body.id, {}, modern, serverInfo);
-        case 'tools/list':
-            return successResponse(body.id, {
-                tools: context.listTools(),
-                ...(modern && { ttlMs: 0, cacheScope: 'private' }),
-            }, modern, serverInfo);
-        case 'tools/call': {
-            if (typeof body.params?.name !== 'string') {
-                return errorResponse(body.id, -32602, 'Tool name is required.');
-            }
-            const result = await context.callTool(body.params.name, body.params.arguments);
-            return successResponse(body.id, {
-                content: [{ type: 'text', text: serializeToolOutput(result.output) }],
-                isError: result.isError,
-            }, modern, serverInfo);
-        }
-        default:
-            return errorResponse(body.id, -32601, `Method not found: ${body.method}`);
+function createServer({ serverInfo, instructions, listTools, callTool }) {
+    const server = new Server(serverInfo, {
+        capabilities: { tools: { listChanged: false } },
+        instructions,
+        cacheHints: { 'tools/list': UNCACHED, 'server/discover': UNCACHED },
+    });
+    server.setRequestHandler('tools/list', () => ({ tools: listTools() }));
+    server.setRequestHandler('tools/call', async ({ params }) => {
+        const { output, isError } = await callTool(params.name, params.arguments);
+        return { content: [{ type: 'text', text: serializeToolOutput(output) }], isError };
+    });
+    return server;
+}
+export class McpProtocol {
+    contexts = new WeakMap();
+    handler = createMcpHandler(({ requestInfo }) => createServer(this.contexts.get(requestInfo)));
+    handle(request, parsedBody, context) {
+        this.contexts.set(request, context);
+        return this.handler.fetch(request, { parsedBody });
     }
 }

package/dist/{oauth.d.ts → oauth/authorizationServer.d.ts}

@@ -1,17 +1,8 @@
 import type { AdminUser, IAdminForth } from 'adminforth';
-import type { McpAuthSecretStore } from './authSecretStore.js';
-import type { McpOAuthClient } from './types.js';
-import { type McpUrls } from './urls.js';
-/** Endpoint paths relative to the AdminForth API prefix (`<baseUrl>/adminapi/v1`). */
-export declare const OAUTH_PATHS: {
-    protectedResourceMetadata: string;
-    authorizationServerMetadata: string;
-    jwks: string;
-    authorize: string;
-    token: string;
-    authorization: string;
-};
-export declare const CONSENT_PAGE_PATH = "/mcp-authorize";
+import type { McpAuthSecretStore } from '../authSecretStore.js';
+import type { ServerReadOnly } from '../serverReadOnly.js';
+import type { McpOAuthClient } from '../types.js';
+import { type McpUrls } from '../urls.js';
 interface AccessToken {
     pk: string;
     grantId: string;
@@ -35,9 +26,10 @@ export declare class McpOAuth {
     private readonly fetchedClients;
     /**
      * `configuredClients` are trusted as is, without fetching their client metadata documents. `serverReadOnly` is
-     * the plugin readOnly option: it makes every connection read-only, whatever the user chooses on the consent page.
+     * the plugin readOnly option for a user: it makes the connections of that user read-only, whatever they choose on
+     * the consent page.
      */
-    constructor(adminforth: IAdminForth, store: McpAuthSecretStore, urls: McpUrls, configuredClients?: McpOAuthClient[], serverReadOnly?: boolean);
+    constructor(adminforth: IAdminForth, store: McpAuthSecretStore, urls: McpUrls, configuredClients: McpOAuthClient[] | undefined, serverReadOnly: ServerReadOnly);
     protectedResourceMetadata(): {
         resource: string;
         authorization_servers: string[];
@@ -64,7 +56,7 @@ export declare class McpOAuth {
      */
     authorize(query: Record<string, unknown>): Promise<string>;
     /** What the consent page shows about a pending authorization request. */
-    describeAuthorization(signedRequest: string): Promise<{
+    describeAuthorization(signedRequest: string, adminUser: AdminUser): Promise<{
         clientName: string;
         clientHost: string | null;
         redirectHost: string;