qa360 2.3.0 → 2.3.2

package/dist/core/crawler/consent-handler.js

@@ -0,0 +1,258 @@
+/**
+ * QA360 Consent Handler
+ *
+ * Automatically detects and dismisses GDPR/CCPA cookie consent banners.
+ * Supports all major Consent Management Platforms (CMPs).
+ *
+ * Philosophy: "80% of EU sites block interaction with consent banners"
+ */
+/**
+ * CMP (Consent Management Platform) Selectors
+ */
+const CONSENT_SELECTORS = {
+    // === OneTrust (most popular, ~30% of EU sites) ===
+    oneTrust: {
+        accept: '#onetrust-accept-btn-handler, #accept-recommended-btn-handler',
+        reject: '#onetrust-reject-all-handler',
+        banner: '#onetrust-banner-sdk, #onetrust-consent-sdk',
+        name: 'OneTrust',
+    },
+    // === Cookiebot (~15% of EU sites) ===
+    cookiebot: {
+        accept: '#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll, #CybotCookiebotDialogBodyButtonAccept',
+        reject: '#CybotCookiebotDialogBodyLevelButtonLevelOptinDeclineAll',
+        banner: '#CybotCookiebotDialog, .CookieDialog',
+        name: 'Cookiebot',
+    },
+    // === Cookie Consent (Osano) ===
+    cookieConsent: {
+        accept: '.cc-accept, .cc-btn.cc-accept, .cc-compliance .cc-btn.cc-allow',
+        reject: '.cc-deny, .cc-btn.cc-deny, .cc-compliance .cc-btn.cc-deny',
+        banner: '.cc-window, #cc-main, .cookieconsent',
+        name: 'Cookie Consent (Osano)',
+    },
+    // === Quantcast ===
+    quantcast: {
+        accept: '.qc-cmp2-summary-buttons button:first-child, .qc-cmp2-button[mode="primary"]',
+        reject: '.qc-cmp2-summary-buttons button:last-child',
+        banner: '.qc-cmp2-container, .qc-cmp2-ui-container',
+        name: 'Quantcast',
+    },
+    // === TrustArc (formerly TRUSTe) ===
+    trustArc: {
+        accept: '.pdynamicbutton .call, #truste-consent-button, .truste-consent-button',
+        reject: '.pdynamicbutton .call, #truste-consent-button', // Usually same button
+        banner: '#truste-consent-track, .truste-consent-frame',
+        name: 'TrustArc',
+    },
+    // === Didomi (popular in France) ===
+    didomi: {
+        accept: '#didomi-notice-agree-button, .didomi-continue-without-agreeing',
+        reject: '#didomi-notice-disagree-button',
+        banner: '#didomi-popup, .didomi-popup-notice',
+        name: 'Didomi',
+    },
+    // === Axeptio (popular in France) ===
+    axeptio: {
+        accept: '[data-axeptio-action="accept"], .axeptio-btn-accept',
+        reject: '[data-axeptio-action="deny"], .axeptio-btn-deny',
+        banner: '#axeptio_overlay, .axeptio-modal',
+        name: 'Axeptio',
+    },
+    // === Usercentrics (German GDPR) ===
+    usercentrics: {
+        accept: '#uc-btn-accept-banner, .uc-btn-accept',
+        reject: '#uc-btn-deny-banner, .uc-btn-deny',
+        banner: '#uc-banner-modal, .usercentrics-root',
+        name: 'Usercentrics',
+    },
+    // === Cookie Information (ixelium) ===
+    cookieInfo: {
+        accept: '.c-i-btn-accept, #js-accept-cookies',
+        reject: '.c-i-btn-reject, #js-reject-cookies',
+        banner: '#cookie-consent-banner, .c-i-banner',
+        name: 'Cookie Information',
+    },
+    // === Termly (US CCPA) ===
+    termly: {
+        accept: '.termly-css-override, #termly-consent-accept',
+        banner: '#termly-consent-banner, .termly-banner',
+        name: 'Termly',
+    },
+    // === GENERIC PATTERNS (fallback for unknown CMPs) ===
+    generic: {
+        accept: [
+            '[id*="cookie"][id*="accept"]',
+            '[id*="cookie"][id*="agree"]',
+            '[class*="cookie"][class*="accept"]',
+            '[class*="cookie"][class*="agree"]',
+            '[id*="consent"][id*="accept"]',
+            '[class*="consent"][class*="accept"]',
+            'button:has-text("Accept")',
+            'button:has-text("Accept All")',
+            'button:has-text("Accepter")',
+            'button:has-text("Tout accepter")',
+            "button:has-text(\"J'accepte\")",
+            'button:has-text("I agree")',
+            'button:has-text("OK")',
+            'button:has-text("Got it")',
+            'button:has-text("Accepter les cookies")',
+        ],
+        reject: [
+            '[id*="cookie"][id*="reject"]',
+            '[id*="cookie"][id*="decline"]',
+            '[id*="cookie"][id*="refuse"]',
+            '[class*="cookie"][class*="reject"]',
+            'button:has-text("Reject")',
+            'button:has-text("Refuser")',
+            'button:has-text("Decline")',
+            'button:has-text("Tout refuser")',
+        ],
+        banner: [
+            '[id*="cookie-banner"]',
+            '[id*="cookie-consent"]',
+            '[id*="cookie-notice"]',
+            '[id*="gdpr"]',
+            '[id*="consent-banner"]',
+            '[id*="consent-notice"]',
+            '[class*="cookie-banner"]',
+            '[class*="cookie-consent"]',
+            '[class*="gdpr-banner"]',
+            '[class*="consent-banner"]',
+            '[aria-label*="cookie"]',
+            '[aria-label*="consent"]',
+            '[role="dialog"][id*="cookie"]',
+            '.cookie-banner',
+            '.cookie-consent',
+            '.gdpr-banner',
+            '#cookie-banner',
+            '#cookie-consent',
+        ],
+        name: 'Generic',
+    },
+};
+/**
+ * Consent Handler - Auto-detects and handles GDPR/CCPA banners
+ */
+export class ConsentHandler {
+    /**
+     * Handle consent banners on the page
+     *
+     * @param page - Playwright Page instance
+     * @param options - Consent handling options
+     * @returns true if a banner was found and handled, false otherwise
+     */
+    static async handleConsent(page, options = {}) {
+        const { action = 'accept', timeout = 3000, customSelector } = options;
+        if (action === 'ignore') {
+            return false;
+        }
+        // Check for custom selector first
+        if (customSelector) {
+            return await this.handleCustom(page, customSelector, timeout);
+        }
+        // Try each known CMP
+        for (const [cmpName, selectors] of Object.entries(CONSENT_SELECTORS)) {
+            try {
+                const handled = await this.tryCMP(page, cmpName, selectors, action, timeout);
+                if (handled) {
+                    return true;
+                }
+            }
+            catch {
+                // Try next CMP
+                continue;
+            }
+        }
+        return false; // No consent banner found
+    }
+    /**
+     * Try a specific CMP
+     */
+    static async tryCMP(page, cmpName, selectors, action, timeout) {
+        // Get banner selectors (could be string or array)
+        const bannerSelectors = Array.isArray(selectors.banner)
+            ? selectors.banner
+            : [selectors.banner];
+        // Check if any banner selector exists and is visible
+        let bannerFound = false;
+        let bannerSelector = '';
+        for (const bannerSel of bannerSelectors) {
+            try {
+                const element = await page.$(bannerSel);
+                if (element) {
+                    const isVisible = await element.isVisible().catch(() => false);
+                    if (isVisible) {
+                        bannerFound = true;
+                        bannerSelector = bannerSel;
+                        break;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!bannerFound) {
+            return false;
+        }
+        console.log(`  🍪 Detected consent banner: ${selectors.name || cmpName}`);
+        // Get button selectors for the action
+        const buttonKey = action === 'reject' && selectors.reject ? 'reject' : 'accept';
+        const buttonSelectors = Array.isArray(selectors[buttonKey])
+            ? selectors[buttonKey]
+            : [selectors[buttonKey]];
+        // Try each button selector
+        for (const btnSel of buttonSelectors) {
+            try {
+                const button = await page.$(btnSel);
+                if (button) {
+                    const isVisible = await button.isVisible().catch(() => false);
+                    if (isVisible) {
+                        await button.click({ timeout: 2000 });
+                        console.log(`  ✅ Consent banner handled (${action})`);
+                        // Wait for banner to disappear
+                        await page.waitForSelector(bannerSelector, {
+                            state: 'hidden',
+                            timeout: 2000,
+                        }).catch(() => {
+                            // Banner might not disappear, that's okay
+                        });
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // Try next selector
+                continue;
+            }
+        }
+        return false;
+    }
+    /**
+     * Handle custom consent selector
+     */
+    static async handleCustom(page, selector, timeout) {
+        try {
+            await page.waitForSelector(selector, { timeout, state: 'visible' });
+            await page.click(selector);
+            console.log(`  ✅ Custom consent button clicked: ${selector}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get all supported CMP names
+     */
+    static getSupportedCMPs() {
+        return Object.keys(CONSENT_SELECTORS).filter(name => name !== 'generic');
+    }
+}
+/**
+ * Quick function to handle consent (convenience wrapper)
+ */
+export async function handleConsent(page, options) {
+    return ConsentHandler.handleConsent(page, options);
+}

package/dist/core/crawler/cookie-manager.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Cookie Manager
+ *
+ * P1 - Browser cookie management
+ *
+ * Supports:
+ * - Cookie CRUD operations
+ * - HttpOnly cookie handling
+ * - Secure cookies (HTTPS only)
+ * - SameSite attribute (Strict, Lax, None)
+ * - Third-party cookie detection
+ * - Cookie validation and security checks
+ *
+ * @see https://playwright.dev/docs/api/class-browsercontext#browser-context-cookies
+ */
+export interface CookieOptions {
+    /** Cookie name */
+    name: string;
+    /** Cookie value */
+    value: string;
+    /** Cookie domain */
+    domain?: string;
+    /** Cookie path */
+    path?: string;
+    /** HttpOnly flag (JS inaccessible) */
+    httpOnly?: boolean;
+    /** Secure flag (HTTPS only) */
+    secure?: boolean;
+    /** SameSite attribute */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    /** Expiration date (Unix timestamp) */
+    expires?: number;
+    /** URL for setting cookie */
+    url?: string;
+}
+export interface CookieValidationResult {
+    /** Cookie is valid */
+    valid: boolean;
+    /** Cookie has HttpOnly flag */
+    httpOnly: boolean;
+    /** Cookie has Secure flag */
+    secure: boolean;
+    /** SameSite attribute value */
+    sameSite: 'Strict' | 'Lax' | 'None' | null;
+    /** Security score (0-100) */
+    securityScore: number;
+    /** Security issues found */
+    issues: string[];
+    /** Is third-party cookie */
+    isThirdParty: boolean;
+}
+export interface CookieFilterOptions {
+    /** Filter by name pattern */
+    namePattern?: string | RegExp;
+    /** Filter by domain */
+    domain?: string;
+    /** HttpOnly only */
+    httpOnly?: boolean;
+    /** Secure only */
+    secure?: boolean;
+    /** SameSite value */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    /** Third-party only */
+    thirdParty?: boolean;
+}
+/**
+ * Cookie Manager class
+ */
+export declare class CookieManager {
+    private context;
+    private baseUrl;
+    constructor(context: any, baseUrl: string);
+    /**
+     * Get all cookies from context
+     */
+    getAllCookies(): Promise<any[]>;
+    /**
+     * Get cookies filtered by criteria
+     */
+    getCookies(filter?: CookieFilterOptions): Promise<any[]>;
+    /**
+     * Get a specific cookie by name
+     */
+    getCookie(name: string): Promise<any | undefined>;
+    /**
+     * Set a cookie
+     */
+    setCookie(options: CookieOptions): Promise<void>;
+    /**
+     * Set multiple cookies
+     */
+    setCookies(cookies: CookieOptions[]): Promise<void>;
+    /**
+     * Update a cookie's value
+     */
+    updateCookie(name: string, value: string, options?: Partial<CookieOptions>): Promise<boolean>;
+    /**
+     * Remove a specific cookie
+     */
+    removeCookie(name: string): Promise<void>;
+    /**
+     * Remove cookies by filter
+     */
+    removeCookies(filter: CookieFilterOptions): Promise<number>;
+    /**
+     * Clear all cookies
+     */
+    clearAllCookies(): Promise<void>;
+    /**
+     * Validate a cookie's security settings
+     */
+    validateCookie(cookie: any, baseUrl: string): CookieValidationResult;
+    /**
+     * Validate all cookies
+     */
+    validateAllCookies(): Promise<Map<string, CookieValidationResult>>;
+    /**
+     * Get security report for all cookies
+     */
+    getSecurityReport(): Promise<{
+        total: number;
+        secure: number;
+        httpOnly: number;
+        sameSite: {
+            Strict: number;
+            Lax: number;
+            None: number;
+            unset: number;
+        };
+        thirdParty: number;
+        avgSecurityScore: number;
+        vulnerableCookies: Array<{
+            name: string;
+            issues: string[];
+        }>;
+    }>;
+    /**
+     * Export cookies as JSON string
+     */
+    exportCookies(): Promise<string>;
+    /**
+     * Import cookies from JSON string
+     */
+    importCookies(cookieJson: string): Promise<number>;
+    /**
+     * Get cookies sorted by name
+     */
+    getSortedCookies(): Promise<any[]>;
+    /**
+     * Get session cookies (no expiration)
+     */
+    getSessionCookies(): Promise<any[]>;
+    /**
+     * Get persistent cookies (with expiration)
+     */
+    getPersistentCookies(): Promise<any[]>;
+    /**
+     * Get expired cookies
+     */
+    getExpiredCookies(): Promise<any[]>;
+}
+/**
+ * Factory function to create Cookie Manager
+ */
+export declare function createCookieManager(context: any, baseUrl: string): CookieManager;
+export default CookieManager;