@frontmcp/testing 0.5.0

package/src/client/mcp-test-client.js

@@ -0,0 +1,929 @@
+"use strict";
+/**
+ * @file mcp-test-client.ts
+ * @description Main MCP Test Client implementation for E2E testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpTestClient = void 0;
+const mcp_test_client_builder_1 = require("./mcp-test-client.builder");
+const streamable_http_transport_1 = require("../transport/streamable-http.transport");
+const interceptor_1 = require("../interceptor");
+// ═══════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_PROTOCOL_VERSION = '2025-06-18';
+const DEFAULT_CLIENT_INFO = {
+    name: '@frontmcp/testing',
+    version: '0.4.0',
+};
+// ═══════════════════════════════════════════════════════════════════
+// MAIN CLIENT CLASS
+// ═══════════════════════════════════════════════════════════════════
+class McpTestClient {
+    config;
+    transport = null;
+    initResult = null;
+    requestIdCounter = 0;
+    _lastRequestId = 0;
+    _sessionId;
+    _sessionInfo = null;
+    _authState = { isAnonymous: true, scopes: [] };
+    // Logging and tracing
+    _logs = [];
+    _traces = [];
+    _notifications = [];
+    _progressUpdates = [];
+    // Interceptor chain
+    _interceptors;
+    // ═══════════════════════════════════════════════════════════════════
+    // CONSTRUCTOR & FACTORY
+    // ═══════════════════════════════════════════════════════════════════
+    constructor(config) {
+        this.config = {
+            baseUrl: config.baseUrl,
+            transport: config.transport ?? 'streamable-http',
+            auth: config.auth ?? {},
+            publicMode: config.publicMode ?? false,
+            timeout: config.timeout ?? DEFAULT_TIMEOUT,
+            debug: config.debug ?? false,
+            protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
+            clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
+        };
+        // In public mode, user is always anonymous (no token authentication)
+        if (config.publicMode) {
+            this._authState = {
+                isAnonymous: true,
+                scopes: [],
+            };
+        }
+        else if (config.auth?.token) {
+            // Parse auth state from config
+            this._authState = {
+                isAnonymous: false,
+                token: config.auth.token,
+                scopes: this.parseScopesFromToken(config.auth.token),
+                user: this.parseUserFromToken(config.auth.token),
+            };
+        }
+        // Initialize interceptor chain
+        this._interceptors = new interceptor_1.DefaultInterceptorChain();
+    }
+    /**
+     * Create a new McpTestClientBuilder for fluent configuration
+     */
+    static create(config) {
+        return new mcp_test_client_builder_1.McpTestClientBuilder(config);
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // CONNECTION & LIFECYCLE
+    // ═══════════════════════════════════════════════════════════════════
+    /**
+     * Connect to the MCP server and perform initialization
+     */
+    async connect() {
+        this.log('debug', `Connecting to ${this.config.baseUrl}...`);
+        // Create transport based on config
+        this.transport = this.createTransport();
+        // Connect transport
+        await this.transport.connect();
+        // Perform MCP initialization
+        const initResponse = await this.initialize();
+        if (!initResponse.success || !initResponse.data) {
+            throw new Error(`Failed to initialize MCP connection: ${initResponse.error?.message ?? 'Unknown error'}`);
+        }
+        this.initResult = initResponse.data;
+        this._sessionId = this.transport.getSessionId();
+        this._sessionInfo = {
+            id: this._sessionId ?? `session-${Date.now()}`,
+            createdAt: new Date(),
+            lastActivityAt: new Date(),
+            requestCount: 1,
+        };
+        // Send initialized notification per MCP protocol
+        // This notification MUST be sent after receiving initialize response
+        // before the client can make any other requests
+        await this.transport.notify({
+            jsonrpc: '2.0',
+            method: 'notifications/initialized',
+        });
+        this.log('info', `Connected to ${this.initResult.serverInfo?.name ?? 'MCP Server'}`);
+        return this.initResult;
+    }
+    /**
+     * Disconnect from the MCP server
+     */
+    async disconnect() {
+        if (this.transport) {
+            await this.transport.close();
+            this.transport = null;
+        }
+        this.initResult = null;
+        this.log('info', 'Disconnected from MCP server');
+    }
+    /**
+     * Reconnect to the server, optionally with an existing session ID
+     */
+    async reconnect(options) {
+        await this.disconnect();
+        if (options?.sessionId && this.transport) {
+            // Set session ID before reconnecting
+            this._sessionId = options.sessionId;
+        }
+        await this.connect();
+    }
+    /**
+     * Check if the client is currently connected
+     */
+    isConnected() {
+        return this.transport?.isConnected() ?? false;
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // SESSION & AUTH PROPERTIES
+    // ═══════════════════════════════════════════════════════════════════
+    get sessionId() {
+        return this._sessionId ?? '';
+    }
+    get session() {
+        const info = this._sessionInfo ?? {
+            id: '',
+            createdAt: new Date(),
+            lastActivityAt: new Date(),
+            requestCount: 0,
+        };
+        return {
+            ...info,
+            expire: async () => {
+                // Force session expiration for testing
+                this._sessionId = undefined;
+                this._sessionInfo = null;
+            },
+        };
+    }
+    get auth() {
+        return this._authState;
+    }
+    /**
+     * Authenticate with a token
+     */
+    async authenticate(token) {
+        this._authState = {
+            isAnonymous: false,
+            token,
+            scopes: this.parseScopesFromToken(token),
+            user: this.parseUserFromToken(token),
+        };
+        // Update transport headers
+        if (this.transport) {
+            this.transport.setAuthToken(token);
+        }
+        this.log('debug', 'Authentication updated');
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // SERVER INFO & CAPABILITIES
+    // ═══════════════════════════════════════════════════════════════════
+    get serverInfo() {
+        return {
+            name: this.initResult?.serverInfo?.name ?? '',
+            version: this.initResult?.serverInfo?.version ?? '',
+        };
+    }
+    get protocolVersion() {
+        return this.initResult?.protocolVersion ?? '';
+    }
+    get instructions() {
+        return this.initResult?.instructions ?? '';
+    }
+    get capabilities() {
+        return this.initResult?.capabilities ?? {};
+    }
+    /**
+     * Check if server has a specific capability
+     */
+    hasCapability(name) {
+        return !!this.capabilities[name];
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // TOOLS API
+    // ═══════════════════════════════════════════════════════════════════
+    tools = {
+        /**
+         * List all available tools
+         */
+        list: async () => {
+            const response = await this.listTools();
+            if (!response.success || !response.data) {
+                throw new Error(`Failed to list tools: ${response.error?.message}`);
+            }
+            return response.data.tools;
+        },
+        /**
+         * Call a tool by name with arguments
+         */
+        call: async (name, args) => {
+            const response = await this.callTool(name, args);
+            return this.wrapToolResult(response);
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // RESOURCES API
+    // ═══════════════════════════════════════════════════════════════════
+    resources = {
+        /**
+         * List all static resources
+         */
+        list: async () => {
+            const response = await this.listResources();
+            if (!response.success || !response.data) {
+                throw new Error(`Failed to list resources: ${response.error?.message}`);
+            }
+            return response.data.resources;
+        },
+        /**
+         * List all resource templates
+         */
+        listTemplates: async () => {
+            const response = await this.listResourceTemplates();
+            if (!response.success || !response.data) {
+                throw new Error(`Failed to list resource templates: ${response.error?.message}`);
+            }
+            return response.data.resourceTemplates;
+        },
+        /**
+         * Read a resource by URI
+         */
+        read: async (uri) => {
+            const response = await this.readResource(uri);
+            return this.wrapResourceContent(response);
+        },
+        /**
+         * Subscribe to resource changes (placeholder for future implementation)
+         */
+        subscribe: async (_uri) => {
+            // TODO: Implement resource subscription
+            this.log('warn', 'Resource subscription not yet implemented');
+        },
+        /**
+         * Unsubscribe from resource changes (placeholder for future implementation)
+         */
+        unsubscribe: async (_uri) => {
+            // TODO: Implement resource unsubscription
+            this.log('warn', 'Resource unsubscription not yet implemented');
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // PROMPTS API
+    // ═══════════════════════════════════════════════════════════════════
+    prompts = {
+        /**
+         * List all available prompts
+         */
+        list: async () => {
+            const response = await this.listPrompts();
+            if (!response.success || !response.data) {
+                throw new Error(`Failed to list prompts: ${response.error?.message}`);
+            }
+            return response.data.prompts;
+        },
+        /**
+         * Get a prompt with arguments
+         */
+        get: async (name, args) => {
+            const response = await this.getPrompt(name, args);
+            return this.wrapPromptResult(response);
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // RAW PROTOCOL ACCESS
+    // ═══════════════════════════════════════════════════════════════════
+    raw = {
+        /**
+         * Send any JSON-RPC request
+         */
+        request: async (message) => {
+            this.ensureConnected();
+            const start = Date.now();
+            const response = await this.transport.request(message);
+            this.traceRequest(message.method, message.params, message.id, response, Date.now() - start);
+            return response;
+        },
+        /**
+         * Send a notification (no response expected)
+         */
+        notify: async (message) => {
+            this.ensureConnected();
+            await this.transport.notify(message);
+        },
+        /**
+         * Send raw string data (for error testing)
+         */
+        sendRaw: async (data) => {
+            this.ensureConnected();
+            return this.transport.sendRaw(data);
+        },
+    };
+    get lastRequestId() {
+        return this._lastRequestId;
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // TRANSPORT INFO
+    // ═══════════════════════════════════════════════════════════════════
+    /**
+     * Get transport information and utilities
+     */
+    get transport_info() {
+        return {
+            type: this.config.transport,
+            isConnected: () => this.transport?.isConnected() ?? false,
+            messageEndpoint: this.transport?.getMessageEndpoint?.(),
+            connectionCount: this.transport?.getConnectionCount?.() ?? 0,
+            reconnectCount: this.transport?.getReconnectCount?.() ?? 0,
+            lastRequestHeaders: this.transport?.getLastRequestHeaders?.() ?? {},
+            simulateDisconnect: async () => {
+                await this.transport?.simulateDisconnect?.();
+            },
+            waitForReconnect: async (timeoutMs) => {
+                await this.transport?.waitForReconnect?.(timeoutMs);
+            },
+        };
+    }
+    // Alias for transport info
+    get transport_() {
+        return this.transport_info;
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // NOTIFICATIONS
+    // ═══════════════════════════════════════════════════════════════════
+    notifications = {
+        /**
+         * Start collecting server notifications
+         */
+        collect: () => {
+            return new NotificationCollector(this._notifications);
+        },
+        /**
+         * Collect progress notifications specifically
+         */
+        collectProgress: () => {
+            return new ProgressCollector(this._progressUpdates);
+        },
+        /**
+         * Send a notification to the server
+         */
+        send: async (method, params) => {
+            await this.raw.notify({ jsonrpc: '2.0', method, params });
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // LOGGING & DEBUGGING
+    // ═══════════════════════════════════════════════════════════════════
+    logs = {
+        all: () => [...this._logs],
+        filter: (level) => this._logs.filter((l) => l.level === level),
+        search: (text) => this._logs.filter((l) => l.message.includes(text)),
+        last: () => this._logs[this._logs.length - 1],
+        clear: () => {
+            this._logs = [];
+        },
+    };
+    trace = {
+        all: () => [...this._traces],
+        last: () => this._traces[this._traces.length - 1],
+        clear: () => {
+            this._traces = [];
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // MOCKING & INTERCEPTION
+    // ═══════════════════════════════════════════════════════════════════
+    /**
+     * API for mocking MCP requests
+     *
+     * @example
+     * ```typescript
+     * // Mock a specific tool call
+     * const handle = mcp.mock.tool('my-tool', { result: 'mocked!' });
+     *
+     * // Mock with params matching
+     * mcp.mock.add({
+     *   method: 'tools/call',
+     *   params: { name: 'my-tool' },
+     *   response: mockResponse.toolResult([{ type: 'text', text: 'mocked' }]),
+     * });
+     *
+     * // Clear all mocks after test
+     * mcp.mock.clear();
+     * ```
+     */
+    mock = {
+        /**
+         * Add a mock definition
+         */
+        add: (mock) => {
+            return this._interceptors.mocks.add(mock);
+        },
+        /**
+         * Mock a tools/call request for a specific tool
+         */
+        tool: (name, result, options) => {
+            return this._interceptors.mocks.add({
+                method: 'tools/call',
+                params: { name },
+                response: interceptor_1.mockResponse.toolResult([
+                    { type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) },
+                ]),
+                times: options?.times,
+                delay: options?.delay,
+            });
+        },
+        /**
+         * Mock a tools/call request to return an error
+         */
+        toolError: (name, code, message, options) => {
+            return this._interceptors.mocks.add({
+                method: 'tools/call',
+                params: { name },
+                response: interceptor_1.mockResponse.error(code, message),
+                times: options?.times,
+            });
+        },
+        /**
+         * Mock a resources/read request
+         */
+        resource: (uri, content, options) => {
+            const contentObj = typeof content === 'string' ? { uri, text: content } : { uri, ...content };
+            return this._interceptors.mocks.add({
+                method: 'resources/read',
+                params: { uri },
+                response: interceptor_1.mockResponse.resourceRead([contentObj]),
+                times: options?.times,
+                delay: options?.delay,
+            });
+        },
+        /**
+         * Mock a resources/read request to return an error
+         */
+        resourceError: (uri, options) => {
+            return this._interceptors.mocks.add({
+                method: 'resources/read',
+                params: { uri },
+                response: interceptor_1.mockResponse.errors.resourceNotFound(uri),
+                times: options?.times,
+            });
+        },
+        /**
+         * Mock the tools/list response
+         */
+        toolsList: (tools, options) => {
+            return this._interceptors.mocks.add({
+                method: 'tools/list',
+                response: interceptor_1.mockResponse.toolsList(tools),
+                times: options?.times,
+            });
+        },
+        /**
+         * Mock the resources/list response
+         */
+        resourcesList: (resources, options) => {
+            return this._interceptors.mocks.add({
+                method: 'resources/list',
+                response: interceptor_1.mockResponse.resourcesList(resources),
+                times: options?.times,
+            });
+        },
+        /**
+         * Clear all mocks
+         */
+        clear: () => {
+            this._interceptors.mocks.clear();
+        },
+        /**
+         * Get all active mocks
+         */
+        all: () => {
+            return this._interceptors.mocks.getAll();
+        },
+    };
+    /**
+     * API for intercepting requests and responses
+     *
+     * @example
+     * ```typescript
+     * // Log all requests
+     * const remove = mcp.intercept.request((ctx) => {
+     *   console.log('Request:', ctx.request.method);
+     *   return { action: 'passthrough' };
+     * });
+     *
+     * // Modify requests
+     * mcp.intercept.request((ctx) => {
+     *   if (ctx.request.method === 'tools/call') {
+     *     return {
+     *       action: 'modify',
+     *       request: { ...ctx.request, params: { ...ctx.request.params, extra: true } },
+     *     };
+     *   }
+     *   return { action: 'passthrough' };
+     * });
+     *
+     * // Add latency to all requests
+     * mcp.intercept.delay(100);
+     *
+     * // Clean up
+     * remove();
+     * mcp.intercept.clear();
+     * ```
+     */
+    intercept = {
+        /**
+         * Add a request interceptor
+         * @returns Function to remove the interceptor
+         */
+        request: (interceptor) => {
+            return this._interceptors.addRequestInterceptor(interceptor);
+        },
+        /**
+         * Add a response interceptor
+         * @returns Function to remove the interceptor
+         */
+        response: (interceptor) => {
+            return this._interceptors.addResponseInterceptor(interceptor);
+        },
+        /**
+         * Add latency to all requests
+         * @returns Function to remove the interceptor
+         */
+        delay: (ms) => {
+            return this._interceptors.addRequestInterceptor(async () => {
+                await new Promise((r) => setTimeout(r, ms));
+                return { action: 'passthrough' };
+            });
+        },
+        /**
+         * Fail requests matching a method
+         * @returns Function to remove the interceptor
+         */
+        failMethod: (method, error) => {
+            return this._interceptors.addRequestInterceptor((ctx) => {
+                if (ctx.request.method === method) {
+                    return { action: 'error', error: new Error(error ?? `Intercepted: ${method}`) };
+                }
+                return { action: 'passthrough' };
+            });
+        },
+        /**
+         * Clear all interceptors (but not mocks)
+         */
+        clear: () => {
+            this._interceptors.request = [];
+            this._interceptors.response = [];
+        },
+        /**
+         * Clear everything (interceptors and mocks)
+         */
+        clearAll: () => {
+            this._interceptors.clear();
+        },
+    };
+    // ═══════════════════════════════════════════════════════════════════
+    // TIMEOUT
+    // ═══════════════════════════════════════════════════════════════════
+    setTimeout(ms) {
+        this.config.timeout = ms;
+        if (this.transport) {
+            this.transport.setTimeout(ms);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // PRIVATE: MCP OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════
+    async initialize() {
+        return this.request('initialize', {
+            protocolVersion: this.config.protocolVersion,
+            capabilities: {
+                sampling: {},
+            },
+            clientInfo: this.config.clientInfo,
+        });
+    }
+    async listTools() {
+        return this.request('tools/list', {});
+    }
+    async callTool(name, args) {
+        return this.request('tools/call', {
+            name,
+            arguments: args ?? {},
+        });
+    }
+    async listResources() {
+        return this.request('resources/list', {});
+    }
+    async listResourceTemplates() {
+        return this.request('resources/templates/list', {});
+    }
+    async readResource(uri) {
+        return this.request('resources/read', { uri });
+    }
+    async listPrompts() {
+        return this.request('prompts/list', {});
+    }
+    async getPrompt(name, args) {
+        return this.request('prompts/get', {
+            name,
+            arguments: args ?? {},
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // PRIVATE: TRANSPORT & REQUEST HELPERS
+    // ═══════════════════════════════════════════════════════════════════
+    createTransport() {
+        switch (this.config.transport) {
+            case 'streamable-http':
+                return new streamable_http_transport_1.StreamableHttpTransport({
+                    baseUrl: this.config.baseUrl,
+                    timeout: this.config.timeout,
+                    auth: this.config.auth,
+                    publicMode: this.config.publicMode,
+                    debug: this.config.debug,
+                    interceptors: this._interceptors,
+                });
+            case 'sse':
+                // TODO: Implement SSE transport
+                throw new Error('SSE transport not yet implemented');
+            default:
+                throw new Error(`Unknown transport type: ${this.config.transport}`);
+        }
+    }
+    async request(method, params) {
+        this.ensureConnected();
+        const id = ++this.requestIdCounter;
+        this._lastRequestId = id;
+        const start = Date.now();
+        try {
+            const response = await this.transport.request({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            });
+            const durationMs = Date.now() - start;
+            this.updateSessionActivity();
+            if ('error' in response && response.error) {
+                const error = response.error;
+                this.traceRequest(method, params, id, response, durationMs);
+                return {
+                    success: false,
+                    error,
+                    durationMs,
+                    requestId: id,
+                };
+            }
+            this.traceRequest(method, params, id, response, durationMs);
+            return {
+                success: true,
+                data: response.result,
+                durationMs,
+                requestId: id,
+            };
+        }
+        catch (err) {
+            const durationMs = Date.now() - start;
+            const error = {
+                code: -32603,
+                message: err instanceof Error ? err.message : 'Unknown error',
+            };
+            return {
+                success: false,
+                error,
+                durationMs,
+                requestId: id,
+            };
+        }
+    }
+    ensureConnected() {
+        if (!this.transport?.isConnected()) {
+            throw new Error('Not connected to MCP server. Call connect() first.');
+        }
+    }
+    updateSessionActivity() {
+        if (this._sessionInfo) {
+            this._sessionInfo.lastActivityAt = new Date();
+            this._sessionInfo.requestCount++;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // PRIVATE: RESULT WRAPPERS
+    // ═══════════════════════════════════════════════════════════════════
+    wrapToolResult(response) {
+        const raw = response.data ?? { content: [] };
+        const isError = !response.success || raw.isError === true;
+        // Check for Tool UI response - has structuredContent and ui/html in _meta
+        const meta = raw._meta;
+        const hasUI = meta?.['ui/html'] !== undefined;
+        const structuredContent = raw['structuredContent'];
+        return {
+            raw,
+            isSuccess: !isError,
+            isError,
+            error: response.error,
+            durationMs: response.durationMs,
+            json() {
+                // For Tool UI responses, return structuredContent (the typed output)
+                if (hasUI && structuredContent !== undefined) {
+                    return structuredContent;
+                }
+                // For regular responses, parse text content as JSON
+                const textContent = raw.content?.find((c) => c.type === 'text');
+                if (textContent && 'text' in textContent) {
+                    return JSON.parse(textContent.text);
+                }
+                throw new Error('No text content to parse as JSON');
+            },
+            text() {
+                const textContent = raw.content?.find((c) => c.type === 'text');
+                if (textContent && 'text' in textContent) {
+                    return textContent.text;
+                }
+                return undefined;
+            },
+            hasTextContent() {
+                return raw.content?.some((c) => c.type === 'text') ?? false;
+            },
+            hasImageContent() {
+                return raw.content?.some((c) => c.type === 'image') ?? false;
+            },
+            hasResourceContent() {
+                return raw.content?.some((c) => c.type === 'resource') ?? false;
+            },
+            hasToolUI() {
+                return hasUI;
+            },
+        };
+    }
+    wrapResourceContent(response) {
+        const raw = response.data ?? { contents: [] };
+        const isError = !response.success;
+        const firstContent = raw.contents?.[0];
+        return {
+            raw,
+            isSuccess: !isError,
+            isError,
+            error: response.error,
+            durationMs: response.durationMs,
+            json() {
+                if (firstContent && 'text' in firstContent) {
+                    return JSON.parse(firstContent.text);
+                }
+                throw new Error('No text content to parse as JSON');
+            },
+            text() {
+                if (firstContent && 'text' in firstContent) {
+                    return firstContent.text;
+                }
+                return undefined;
+            },
+            mimeType() {
+                return firstContent?.mimeType;
+            },
+            hasMimeType(type) {
+                return firstContent?.mimeType === type;
+            },
+        };
+    }
+    wrapPromptResult(response) {
+        const raw = response.data ?? { messages: [] };
+        const isError = !response.success;
+        return {
+            raw,
+            isSuccess: !isError,
+            isError,
+            error: response.error,
+            durationMs: response.durationMs,
+            messages: raw.messages ?? [],
+            description: raw.description,
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // PRIVATE: LOGGING & TRACING
+    // ═══════════════════════════════════════════════════════════════════
+    log(level, message, data) {
+        const entry = {
+            level,
+            message,
+            timestamp: new Date(),
+            data,
+        };
+        this._logs.push(entry);
+        if (this.config.debug) {
+            console.log(`[${level.toUpperCase()}] ${message}`, data ?? '');
+        }
+    }
+    traceRequest(method, params, id, response, durationMs) {
+        this._traces.push({
+            request: { method, params, id },
+            response: {
+                result: 'result' in response ? response.result : undefined,
+                error: 'error' in response ? response.error : undefined,
+            },
+            durationMs,
+            timestamp: new Date(),
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════
+    // PRIVATE: TOKEN PARSING
+    // ═══════════════════════════════════════════════════════════════════
+    parseScopesFromToken(token) {
+        try {
+            const payload = this.decodeJwtPayload(token);
+            if (!payload)
+                return [];
+            const scope = payload['scope'];
+            const scopes = payload['scopes'];
+            if (typeof scope === 'string') {
+                return scope.split(' ');
+            }
+            if (Array.isArray(scopes)) {
+                return scopes;
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+    parseUserFromToken(token) {
+        try {
+            const payload = this.decodeJwtPayload(token);
+            const sub = payload?.['sub'];
+            if (!sub || typeof sub !== 'string')
+                return undefined;
+            return {
+                sub,
+                email: payload['email'],
+                name: payload['name'],
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    decodeJwtPayload(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3)
+                return null;
+            const payload = Buffer.from(parts[1], 'base64url').toString('utf-8');
+            return JSON.parse(payload);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.McpTestClient = McpTestClient;
+// ═══════════════════════════════════════════════════════════════════
+// NOTIFICATION COLLECTORS
+// ═══════════════════════════════════════════════════════════════════
+class NotificationCollector {
+    notifications;
+    constructor(notifications) {
+        this.notifications = notifications;
+    }
+    get received() {
+        return [...this.notifications];
+    }
+    has(method) {
+        return this.notifications.some((n) => n.method === method);
+    }
+    async waitFor(method, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const found = this.notifications.find((n) => n.method === method);
+            if (found)
+                return found;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        throw new Error(`Timeout waiting for notification: ${method}`);
+    }
+}
+class ProgressCollector {
+    updates;
+    constructor(updates) {
+        this.updates = updates;
+    }
+    get all() {
+        return [...this.updates];
+    }
+    async waitForComplete(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const last = this.updates[this.updates.length - 1];
+            if (last && last.total !== undefined && last.progress >= last.total) {
+                return;
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        throw new Error('Timeout waiting for progress to complete');
+    }
+}
+//# sourceMappingURL=mcp-test-client.js.map