qa360 2.2.20 → 2.3.1

package/dist/core/crawler/reporting-api-handler.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Reporting API Handler
+ *
+ * P1 - Reporting API and Reporting Observer management
+ *
+ * Supports:
+ * - Reporting API header parsing
+ * - Reporting Observer setup
+ * - Report collection (CSP, COOP/COEP, etc.)
+ * - Report analysis and categorization
+ * - Reporting endpoint monitoring
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Reporting_API
+ */
+export type ReportType = 'csp-violation' | 'permissions-policy-violation' | 'intervention' | 'deprecation' | 'network-error' | 'crash';
+export interface Report {
+    /** Report type */
+    type: ReportType;
+    /** Report URL (where it was generated) */
+    url: string;
+    /** Report body (type-specific) */
+    body: Record<string, unknown>;
+    /** Report timestamp */
+    timestamp: number;
+    /** Report ID (for deduplication) */
+    id: string;
+}
+export interface CSPViolationReport extends Report {
+    type: 'csp-violation';
+    body: {
+        /** Violated directive */
+        directive: string;
+        /** Blocked resource */
+        blockedURL?: string;
+        /** Original policy */
+        policy?: string;
+        /** Source file */
+        sourceFile?: string;
+        /** Line number */
+        lineNumber?: number;
+        /** Column number */
+        columnNumber?: number;
+        /** Disposition */
+        disposition?: 'report' | 'enforce';
+    };
+}
+export interface PermissionsPolicyViolationReport extends Report {
+    type: 'permissions-policy-violation';
+    body: {
+        /** Violated feature */
+        feature: string;
+        /** Source file */
+        sourceFile?: string;
+        /** Line number */
+        lineNumber?: number;
+        /** Column number */
+        columnNumber?: number;
+    };
+}
+export interface InterventionReport extends Report {
+    type: 'intervention';
+    body: {
+        /** Intervention reason */
+        reason?: string;
+    };
+}
+export interface DeprecationReport extends Report {
+    type: 'deprecation';
+    body: {
+        /** Deprecated feature */
+        id?: string;
+        /** Expected removal date */
+        anticipatedRemoval?: string;
+        /** Message */
+        message?: string;
+    };
+}
+export interface ReportingEndpoint {
+    /** Endpoint name */
+    name: string;
+    /** Endpoint URL */
+    url: string;
+    /** Priority */
+    priority?: number;
+    /** Weight for load balancing */
+    weight?: number;
+}
+export interface ReportingAPIConfig {
+    /** Report-To header value */
+    reportTo: string | null;
+    /** Reporting endpoints */
+    endpoints: ReportingEndpoint[];
+    /** Reporting-Endpoints header value */
+    reportingEndpoints: string | null;
+}
+export interface ReportingSummary {
+    /** Total reports collected */
+    totalReports: number;
+    /** Reports by type */
+    reportsByType: Record<ReportType, number>;
+    /** CSP violations */
+    cspViolations: CSPViolationReport[];
+    /** Permissions policy violations */
+    permissionsViolations: PermissionsPolicyViolationReport[];
+    /** Interventions */
+    interventions: InterventionReport[];
+    /** Deprecations */
+    deprecations: DeprecationReport[];
+    /** Most common issues */
+    commonIssues: Array<{
+        type: string;
+        count: number;
+        description: string;
+    }>;
+}
+/**
+ * Reporting API Handler class
+ */
+export declare class ReportingAPIHandler {
+    private page;
+    private reports;
+    private observerInstalled;
+    constructor(page: any);
+    /**
+     * Check if Reporting Observer is supported
+     */
+    isSupported(): Promise<boolean>;
+    /**
+     * Get Reporting API headers
+     */
+    getReportingHeaders(): Promise<ReportingAPIConfig>;
+    /**
+     * Install Reporting Observer
+     */
+    installObserver(options?: {
+        buffered?: boolean;
+        types?: ReportType[];
+    }): Promise<boolean>;
+    /**
+     * Get all collected reports
+     */
+    getReports(): Promise<Report[]>;
+    /**
+     * Get reports by type
+     */
+    getReportsByType<T extends Report>(type: ReportType): Promise<T[]>;
+    /**
+     * Get CSP violation reports
+     */
+    getCSPViolations(): Promise<CSPViolationReport[]>;
+    /**
+     * Get permissions policy violation reports
+     */
+    getPermissionsPolicyViolations(): Promise<PermissionsPolicyViolationReport[]>;
+    /**
+     * Get intervention reports
+     */
+    getInterventions(): Promise<InterventionReport[]>;
+    /**
+     * Get deprecation reports
+     */
+    getDeprecations(): Promise<DeprecationReport[]>;
+    /**
+     * Generate reporting summary
+     */
+    getSummary(): Promise<ReportingSummary>;
+    /**
+     * Clear all collected reports
+     */
+    clearReports(): Promise<void>;
+    /**
+     * Wait for new reports
+     */
+    waitForNewReports(timeout?: number): Promise<Report[]>;
+    /**
+     * Generate mock report (for testing)
+     */
+    generateMockReport(type: ReportType, body: Record<string, unknown>): Promise<void>;
+    /**
+     * Analyze CSP violations for patterns
+     */
+    analyzeCSPViolations(): Promise<{
+        total: number;
+        byDirective: Record<string, number>;
+        byBlockedURL: Record<string, number>;
+        recommendations: string[];
+    }>;
+    /**
+     * Check for critical issues
+     */
+    checkCriticalIssues(): Promise<{
+        hasCriticalIssues: boolean;
+        issues: string[];
+    }>;
+    /**
+     * Export reports as JSON
+     */
+    exportReports(): Promise<string>;
+    /**
+     * Get Reporting API documentation
+     */
+    getDocumentation(): {
+        overview: string;
+        url: string;
+        reportTypes: Record<ReportType, string>;
+    };
+}
+/**
+ * Factory function to create Reporting API Handler
+ */
+export declare function createReportingAPIHandler(page: any): ReportingAPIHandler;
+export default ReportingAPIHandler;

package/dist/core/crawler/reporting-api-handler.js

@@ -0,0 +1,344 @@
+/**
+ * Reporting API Handler
+ *
+ * P1 - Reporting API and Reporting Observer management
+ *
+ * Supports:
+ * - Reporting API header parsing
+ * - Reporting Observer setup
+ * - Report collection (CSP, COOP/COEP, etc.)
+ * - Report analysis and categorization
+ * - Reporting endpoint monitoring
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Reporting_API
+ */
+/**
+ * Reporting API Handler class
+ */
+export class ReportingAPIHandler {
+    page;
+    reports = [];
+    observerInstalled = false;
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Check if Reporting Observer is supported
+     */
+    async isSupported() {
+        return await this.page.evaluate(() => {
+            return 'ReportingObserver' in window;
+        });
+    }
+    /**
+     * Get Reporting API headers
+     */
+    async getReportingHeaders() {
+        return await this.page.evaluate(async () => {
+            try {
+                const response = await fetch(window.location.href, { method: 'HEAD' });
+                const reportTo = response.headers.get('Report-To');
+                const reportingEndpoints = response.headers.get('Reporting-Endpoints');
+                // Parse Report-To header (JSON format)
+                let endpoints = [];
+                if (reportTo) {
+                    try {
+                        const parsed = JSON.parse(reportTo);
+                        if (parsed.headers) {
+                            endpoints = parsed.headers;
+                        }
+                        else if (Array.isArray(parsed)) {
+                            endpoints = parsed;
+                        }
+                    }
+                    catch {
+                        // Invalid JSON
+                    }
+                }
+                return {
+                    reportTo,
+                    endpoints,
+                    reportingEndpoints,
+                };
+            }
+            catch {
+                return {
+                    reportTo: null,
+                    endpoints: [],
+                    reportingEndpoints: null,
+                };
+            }
+        });
+    }
+    /**
+     * Install Reporting Observer
+     */
+    async installObserver(options) {
+        if (!(await this.isSupported())) {
+            return false;
+        }
+        await this.page.evaluate((opts) => {
+            // Initialize report storage
+            if (!window.__reportingObserverReports) {
+                window.__reportingObserverReports = [];
+            }
+            const observerOptions = {
+                buffered: opts.buffered ?? true,
+            };
+            if (opts.types && opts.types.length > 0) {
+                observerOptions.types = opts.types;
+            }
+            const observer = new ReportingObserver((reports) => {
+                reports.forEach((report) => {
+                    const enriched = {
+                        ...report,
+                        id: `${report.type}-${report.url}-${Date.now()}`,
+                        timestamp: Date.now(),
+                    };
+                    window.__reportingObserverReports.push(enriched);
+                });
+            }, observerOptions);
+            observer.observe();
+            window.__reportingObserver = observer;
+        }, {
+            buffered: options?.buffered,
+            types: options?.types,
+        });
+        this.observerInstalled = true;
+        return true;
+    }
+    /**
+     * Get all collected reports
+     */
+    async getReports() {
+        if (!this.observerInstalled) {
+            await this.installObserver();
+        }
+        const pageReports = await this.page.evaluate(() => {
+            return window.__reportingObserverReports || [];
+        });
+        // Combine with local reports
+        return [...pageReports, ...this.reports];
+    }
+    /**
+     * Get reports by type
+     */
+    async getReportsByType(type) {
+        const allReports = await this.getReports();
+        return allReports.filter(r => r.type === type);
+    }
+    /**
+     * Get CSP violation reports
+     */
+    async getCSPViolations() {
+        return await this.getReportsByType('csp-violation');
+    }
+    /**
+     * Get permissions policy violation reports
+     */
+    async getPermissionsPolicyViolations() {
+        return await this.getReportsByType('permissions-policy-violation');
+    }
+    /**
+     * Get intervention reports
+     */
+    async getInterventions() {
+        return await this.getReportsByType('intervention');
+    }
+    /**
+     * Get deprecation reports
+     */
+    async getDeprecations() {
+        return await this.getReportsByType('deprecation');
+    }
+    /**
+     * Generate reporting summary
+     */
+    async getSummary() {
+        const allReports = await this.getReports();
+        // Count by type
+        const reportsByType = {
+            'csp-violation': 0,
+            'permissions-policy-violation': 0,
+            'intervention': 0,
+            'deprecation': 0,
+            'network-error': 0,
+            'crash': 0,
+        };
+        for (const report of allReports) {
+            reportsByType[report.type]++;
+        }
+        // Get typed reports
+        const cspViolations = await this.getCSPViolations();
+        const permissionsViolations = await this.getPermissionsPolicyViolations();
+        const interventions = await this.getInterventions();
+        const deprecations = await this.getDeprecations();
+        // Find common issues
+        const commonIssues = [];
+        // CSP violations summary
+        const cspByDirective = new Map();
+        for (const violation of cspViolations) {
+            const dir = violation.body.directive || 'unknown';
+            cspByDirective.set(dir, (cspByDirective.get(dir) || 0) + 1);
+        }
+        for (const [directive, count] of cspByDirective) {
+            commonIssues.push({
+                type: 'CSP',
+                count,
+                description: `"${directive}" directive violations`,
+            });
+        }
+        // Deprecations summary
+        for (const dep of deprecations) {
+            commonIssues.push({
+                type: 'Deprecation',
+                count: 1,
+                description: dep.body.id || dep.body.message || 'Deprecated API used',
+            });
+        }
+        // Sort by count
+        commonIssues.sort((a, b) => b.count - a.count);
+        return {
+            totalReports: allReports.length,
+            reportsByType,
+            cspViolations,
+            permissionsViolations,
+            interventions,
+            deprecations,
+            commonIssues: commonIssues.slice(0, 10),
+        };
+    }
+    /**
+     * Clear all collected reports
+     */
+    async clearReports() {
+        this.reports = [];
+        await this.page.evaluate(() => {
+            if (window.__reportingObserverReports) {
+                window.__reportingObserverReports = [];
+            }
+        });
+    }
+    /**
+     * Wait for new reports
+     */
+    async waitForNewReports(timeout = 5000) {
+        const startTime = Date.now();
+        const initialReports = await this.getReports();
+        while (Date.now() - startTime < timeout) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const currentReports = await this.getReports();
+            if (currentReports.length > initialReports.length) {
+                return currentReports.slice(initialReports.length);
+            }
+        }
+        return [];
+    }
+    /**
+     * Generate mock report (for testing)
+     */
+    async generateMockReport(type, body) {
+        const report = {
+            type,
+            url: this.page.url(),
+            body,
+            timestamp: Date.now(),
+            id: `mock-${type}-${Date.now()}`,
+        };
+        this.reports.push(report);
+    }
+    /**
+     * Analyze CSP violations for patterns
+     */
+    async analyzeCSPViolations() {
+        const violations = await this.getCSPViolations();
+        const byDirective = {};
+        const byBlockedURL = {};
+        const recommendations = [];
+        for (const violation of violations) {
+            const dir = violation.body.directive || 'unknown';
+            byDirective[dir] = (byDirective[dir] || 0) + 1;
+            const url = violation.body.blockedURL || 'unknown';
+            // Group by domain
+            try {
+                const domain = new URL(url).hostname;
+                byBlockedURL[domain] = (byBlockedURL[domain] || 0) + 1;
+            }
+            catch {
+                byBlockedURL[url] = (byBlockedURL[url] || 0) + 1;
+            }
+        }
+        // Generate recommendations
+        if (byDirective['script-src'] > 5) {
+            recommendations.push('Review script-src directive: many violations detected');
+        }
+        if (byDirective['style-src'] > 5) {
+            recommendations.push('Review style-src directive: consider allowing unsafe-inline or using nonces');
+        }
+        if (byDirective['img-src'] > 10) {
+            recommendations.push('Review img-src directive: many image violations');
+        }
+        return {
+            total: violations.length,
+            byDirective,
+            byBlockedURL: Object.fromEntries(Object.entries(byBlockedURL)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 10)),
+            recommendations,
+        };
+    }
+    /**
+     * Check for critical issues
+     */
+    async checkCriticalIssues() {
+        const summary = await this.getSummary();
+        const issues = [];
+        // Check for CSP violations
+        if (summary.reportsByType['csp-violation'] > 0) {
+            issues.push(`CSP violations detected: ${summary.reportsByType['csp-violation']}`);
+        }
+        // Check for deprecations
+        if (summary.reportsByType['deprecation'] > 0) {
+            issues.push(`Deprecated APIs in use: ${summary.reportsByType['deprecation']}`);
+        }
+        // Check for interventions
+        if (summary.reportsByType['intervention'] > 0) {
+            issues.push(`Browser interventions: ${summary.reportsByType['intervention']}`);
+        }
+        return {
+            hasCriticalIssues: issues.length > 0,
+            issues,
+        };
+    }
+    /**
+     * Export reports as JSON
+     */
+    async exportReports() {
+        const summary = await this.getSummary();
+        return JSON.stringify(summary, null, 2);
+    }
+    /**
+     * Get Reporting API documentation
+     */
+    getDocumentation() {
+        return {
+            overview: 'The Reporting API provides a generic mechanism for web applications to report various browser warnings and errors to server endpoints',
+            url: 'https://developer.mozilla.org/en-US/docs/Web/API/Reporting_API',
+            reportTypes: {
+                'csp-violation': 'Content Security Policy violations',
+                'permissions-policy-violation': 'Permissions Policy violations',
+                'intervention': 'Browser interventions (ad filtering, etc.)',
+                'deprecation': 'Use of deprecated features',
+                'network-error': 'Network errors (resource loading failures)',
+                'crash': 'Browser/tab crashes',
+            },
+        };
+    }
+}
+/**
+ * Factory function to create Reporting API Handler
+ */
+export function createReportingAPIHandler(page) {
+    return new ReportingAPIHandler(page);
+}
+export default ReportingAPIHandler;

package/{cli/dist → dist}/core/crawler/selector-generator.d.ts

@@ -2,8 +2,17 @@
  * QA360 Selector Generator
  *
  * Generates stable, resilient CSS selectors for web elements
+ *
+ * NOW WITH INTELLIGENT PROFILE-AWARE GENERATION!
+ * The selector generation adapts to the detected site profile:
+ * - PROFIL_MODERN: data-testid first (React apps, SaaS)
+ * - PROFIL_ACCESSIBLE: ARIA role first (banks, government)
+ * - PROFIL_LEGACY: Semantic ID first (ASP.NET, PHP legacy)
+ * - PROFIL_MINIMAL: Text content first (landing pages)
  */
 import type { ElementInfo } from './types.js';
+export { SiteProfiler, analyzeSite, determineSiteProfile, type SiteAnalysis, type SiteProfile, type Framework, type CssFramework, } from './site-profiler.js';
+export { IntelligentSelectorGenerator, generateSelector as generateIntelligentSelector, generateSelectorWithMetadata, initializeSelectorGenerator, getSiteProfile, getSelectorStrategy, SELECTOR_STRATEGIES, isGeneratedId, isSemanticId, isUtilityClass, type SelectorResult, type SelectorTier, type ElementInfo as IntelligentElementInfo, } from './intelligent-selector-generator.js';
 /**
  * Generate optimal selector for an element
  */