@frontmcp/testing 0.6.0 → 0.6.2

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

@@ -1,937 +0,0 @@
-"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 {
-    // Platform and capabilities are optional - only set when testing platform-specific behavior
-    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,
-            platform: config.platform,
-            capabilities: config.capabilities,
-        };
-        // If a token is provided, user is authenticated (even in public mode)
-        // Public mode just means anonymous access is allowed, not that tokens are ignored
-        if (config.auth?.token) {
-            this._authState = {
-                isAnonymous: false,
-                token: config.auth.token,
-                scopes: this.parseScopesFromToken(config.auth.token),
-                user: this.parseUserFromToken(config.auth.token),
-            };
-        }
-        // Otherwise, user is anonymous (default _authState is already { isAnonymous: true, scopes: [] })
-        // 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() {
-        // Use configured capabilities or default to base capabilities
-        const capabilities = this.config.capabilities ?? {
-            sampling: {},
-        };
-        return this.request('initialize', {
-            protocolVersion: this.config.protocolVersion,
-            capabilities,
-            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,
-                    clientInfo: this.config.clientInfo,
-                });
-            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 UI metadata in _meta
-        // Platform-specific HTML keys:
-        // - OpenAI: openai/html
-        // - ext-apps: ui/html
-        // - Others: frontmcp/html (+ ui/html for compatibility)
-        const meta = raw._meta;
-        const hasUI = meta?.['ui/html'] !== undefined ||
-            meta?.['ui/component'] !== undefined ||
-            meta?.['openai/html'] !== undefined ||
-            meta?.['frontmcp/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