ai-debug-local-mcp/dist/local-debug-engine/event-collector.js

🎯 ENHANCED AI GUIDANCE v4.1.2: Dramatically improved tool descriptions help AI users choose the right tools instead of 'close enough' options. Ultra-fast keyboard automation (10x speed), universal recording, multi-ecosystem debugging support, and compreh

/**
 * Collects and manages console messages and network requests from browser debugging sessions
 * Extracted from LocalDebugEngine for better separation of concerns
 */
export class EventCollector {
    consoleMessages = [];
    networkRequests = [];
    /**
     * Add a console message to the collection
     */
    addConsoleMessage(message) {
        this.consoleMessages.push({
            type: message.type(),
            text: message.text(),
            timestamp: new Date()
        });
    }
    /**
     * Add a network request to the collection
     */
    addNetworkRequest(request) {
        let requestBody = null;
        try {
            requestBody = request.postData();
        }
        catch (e) {
            // Some requests may not have accessible body
        }
        const networkRequest = {
            url: request.url(),
            method: request.method(),
            headers: request.headers(),
            requestBody,
            timestamp: new Date(),
            status: 'pending',
            resourceType: request.resourceType(),
            queryParams: this.parseQueryParams(request.url())
        };
        this.networkRequests.push(networkRequest);
    }
    /**
     * Update network request with response data
     */
    updateNetworkRequest(response, responseBody, responseSize) {
        const index = this.networkRequests.findIndex(req => req.url === response.url() && req.status === 'pending');
        if (index !== -1) {
            this.networkRequests[index] = {
                ...this.networkRequests[index],
                status: 'complete',
                responseStatus: response.status(),
                responseStatusText: response.statusText(),
                responseHeaders: response.headers(),
                responseBody,
                responseSize,
                duration: Date.now() - this.networkRequests[index].timestamp.getTime()
            };
        }
    }
    /**
     * Mark network request as failed
     */
    markNetworkRequestFailed(request, failureReason) {
        const index = this.networkRequests.findIndex(req => req.url === request.url() && req.status === 'pending');
        if (index !== -1) {
            this.networkRequests[index] = {
                ...this.networkRequests[index],
                status: 'failed',
                failureReason: failureReason || 'Unknown error'
            };
        }
    }
    /**
     * Get console messages with optional filtering
     */
    getConsoleMessages(filter) {
        let messages = [...this.consoleMessages];
        if (filter?.type) {
            messages = messages.filter(msg => msg.type === filter.type);
        }
        if (filter?.since) {
            messages = messages.filter(msg => msg.timestamp >= filter.since);
        }
        if (filter?.maxTokens) {
            // Truncate messages if they exceed token limit
            messages = messages.map(msg => ({
                ...msg,
                text: msg.text.length > filter.maxTokens ?
                    msg.text.substring(0, filter.maxTokens) + '...' :
                    msg.text
            }));
        }
        return messages;
    }
    /**
     * Get network requests with optional filtering
     */
    getNetworkRequests(filter) {
        let requests = [...this.networkRequests];
        if (filter?.status) {
            requests = requests.filter(req => req.status === filter.status);
        }
        if (filter?.pattern) {
            const regex = new RegExp(filter.pattern, 'i');
            requests = requests.filter(req => regex.test(req.url));
        }
        return requests;
    }
    /**
     * Get failed network requests
     */
    getFailedRequests() {
        return this.networkRequests.filter(req => req.status === 'failed');
    }
    /**
     * Get slow network requests
     */
    getSlowRequests(thresholdMs = 1000) {
        return this.networkRequests.filter(req => req.duration && req.duration > thresholdMs);
    }
    /**
     * Get API requests (JSON content or /api/ URLs)
     */
    getApiRequests() {
        return this.networkRequests.filter(req => req.url.includes('/api/') ||
            req.headers['content-type']?.includes('json') ||
            req.headers['Content-Type']?.includes('json'));
    }
    /**
     * Get requests by HTTP status code
     */
    getRequestsByStatus(status) {
        return this.networkRequests.filter(req => req.responseStatus === status);
    }
    /**
     * Clear all collected data
     */
    clear() {
        this.consoleMessages = [];
        this.networkRequests = [];
    }
    /**
     * Get collection statistics
     */
    getStats() {
        return {
            consoleMessages: this.consoleMessages.length,
            networkRequests: this.networkRequests.length
        };
    }
    /**
     * Parse query parameters from URL
     */
    parseQueryParams(url) {
        try {
            const urlObj = new URL(url);
            const params = {};
            urlObj.searchParams.forEach((value, key) => {
                params[key] = value;
            });
            return params;
        }
        catch {
            return {};
        }
    }
}
//# sourceMappingURL=event-collector.js.map