qa360 2.2.20 → 2.3.1

package/dist/core/crawler/permissions-handler.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Permissions Handler
+ *
+ * P1 - Browser permissions management
+ *
+ * Supports:
+ * - Grant/revoke permissions
+ * - Permission state checking
+ * - Common permission presets
+ * - Permission change tracking
+ *
+ * @see https://playwright.dev/docs/emulation
+ */
+export type PermissionType = 'geolocation' | 'midi' | 'notifications' | 'camera' | 'microphone' | 'clipboard-read' | 'clipboard-write' | 'payment-handler' | 'accelerometer' | 'ambient-light-sensor' | 'background-sync' | 'gyroscope' | 'magnetometer' | 'midi-sysex' | 'nfc' | 'speaker-selection';
+export type PermissionState = 'granted' | 'denied' | 'prompt' | 'unsupported';
+export interface PermissionConfig {
+    /** Permissions to auto-grant */
+    grant?: PermissionType[];
+    /** Permissions to auto-deny */
+    deny?: PermissionType[];
+    /** Track permission changes */
+    trackChanges?: boolean;
+}
+export interface PermissionChange {
+    permission: PermissionType;
+    from: PermissionState;
+    to: PermissionState;
+    timestamp: number;
+}
+/**
+ * Permission presets for common scenarios
+ */
+export declare const PERMISSION_PRESETS: Record<string, PermissionType[]>;
+/**
+ * Permissions Handler class
+ */
+export declare class PermissionsHandler {
+    private granted;
+    private denied;
+    private changes;
+    private trackChanges;
+    constructor(config?: PermissionConfig);
+    /**
+     * Grant permissions for a context
+     */
+    grantPermissions(context: any, permissions: PermissionType | PermissionType[]): Promise<void>;
+    /**
+     * Clear all permissions for a context
+     */
+    clearPermissions(context: any): Promise<void>;
+    /**
+     * Check if a permission is granted
+     */
+    isGranted(permission: PermissionType): boolean;
+    /**
+     * Check if a permission is denied
+     */
+    isDenied(permission: PermissionType): boolean;
+    /**
+     * Get permission state
+     */
+    getState(permission: PermissionType): 'granted' | 'denied' | 'prompt';
+    /**
+     * Get all granted permissions
+     */
+    getGrantedPermissions(): PermissionType[];
+    /**
+     * Get all denied permissions
+     */
+    getDeniedPermissions(): PermissionType[];
+    /**
+     * Apply a preset of permissions
+     */
+    applyPreset(context: any, preset: string | PermissionType[]): Promise<void>;
+    /**
+     * Get permission state from page (what the page sees)
+     */
+    getPagePermissionState(page: any, permission: PermissionType): Promise<PermissionState>;
+    /**
+     * Watch for permission changes on a page
+     */
+    watchPermissionChanges(page: any, permission: PermissionType, callback: (state: PermissionState) => void): Promise<void>;
+    /**
+     * Get permission changes history
+     */
+    getChanges(): PermissionChange[];
+    /**
+     * Clear permission changes history
+     */
+    clearChanges(): void;
+    /**
+     * Map our permission names to PermissionDescriptor names
+     */
+    private mapPermissionName;
+    /**
+     * Get all available presets
+     */
+    getAvailablePresets(): string[];
+    /**
+     * Get permissions in a preset
+     */
+    getPresetPermissions(preset: string): PermissionType[] | undefined;
+    /**
+     * Create a custom preset
+     */
+    createPreset(name: string, permissions: PermissionType[]): void;
+}
+/**
+ * Factory function to create Permissions Handler
+ */
+export declare function createPermissionsHandler(config?: PermissionConfig): PermissionsHandler;
+export default PermissionsHandler;

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

@@ -0,0 +1,236 @@
+/**
+ * Permissions Handler
+ *
+ * P1 - Browser permissions management
+ *
+ * Supports:
+ * - Grant/revoke permissions
+ * - Permission state checking
+ * - Common permission presets
+ * - Permission change tracking
+ *
+ * @see https://playwright.dev/docs/emulation
+ */
+/**
+ * Permission presets for common scenarios
+ */
+export const PERMISSION_PRESETS = {
+    'e-commerce': ['geolocation'],
+    'video-call': ['camera', 'microphone'],
+    'social': ['notifications', 'geolocation'],
+    'productivity': ['clipboard-read', 'clipboard-write', 'notifications'],
+    'media': ['camera', 'microphone', 'clipboard-write'],
+    'minimal': [],
+    'all': [
+        'geolocation',
+        'midi',
+        'notifications',
+        'camera',
+        'microphone',
+        'clipboard-read',
+        'clipboard-write',
+        'payment-handler',
+        'accelerometer',
+        'ambient-light-sensor',
+        'background-sync',
+        'gyroscope',
+        'magnetometer',
+        'midi-sysex',
+        'speaker-selection',
+    ],
+};
+/**
+ * Permissions Handler class
+ */
+export class PermissionsHandler {
+    granted = new Set();
+    denied = new Set();
+    changes = [];
+    trackChanges;
+    constructor(config = {}) {
+        this.trackChanges = config.trackChanges !== false;
+        if (config.grant) {
+            for (const permission of config.grant) {
+                this.granted.add(permission);
+            }
+        }
+        if (config.deny) {
+            for (const permission of config.deny) {
+                this.denied.add(permission);
+            }
+        }
+    }
+    /**
+     * Grant permissions for a context
+     */
+    async grantPermissions(context, permissions) {
+        const perms = Array.isArray(permissions) ? permissions : [permissions];
+        await context.grantPermissions(perms);
+        for (const permission of perms) {
+            const wasDenied = this.denied.has(permission);
+            const previousState = wasDenied ? 'denied' : 'prompt';
+            this.granted.add(permission);
+            this.denied.delete(permission);
+            if (this.trackChanges && wasDenied) {
+                this.changes.push({
+                    permission,
+                    from: previousState,
+                    to: 'granted',
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    /**
+     * Clear all permissions for a context
+     */
+    async clearPermissions(context) {
+        await context.clearPermissions();
+        this.granted.clear();
+        this.denied.clear();
+    }
+    /**
+     * Check if a permission is granted
+     */
+    isGranted(permission) {
+        return this.granted.has(permission);
+    }
+    /**
+     * Check if a permission is denied
+     */
+    isDenied(permission) {
+        return this.denied.has(permission);
+    }
+    /**
+     * Get permission state
+     */
+    getState(permission) {
+        if (this.granted.has(permission))
+            return 'granted';
+        if (this.denied.has(permission))
+            return 'denied';
+        return 'prompt';
+    }
+    /**
+     * Get all granted permissions
+     */
+    getGrantedPermissions() {
+        return Array.from(this.granted);
+    }
+    /**
+     * Get all denied permissions
+     */
+    getDeniedPermissions() {
+        return Array.from(this.denied);
+    }
+    /**
+     * Apply a preset of permissions
+     */
+    async applyPreset(context, preset) {
+        const permissions = typeof preset === 'string'
+            ? PERMISSION_PRESETS[preset]
+            : preset;
+        if (!permissions) {
+            throw new Error(`Unknown preset: ${preset}. Available: ${Object.keys(PERMISSION_PRESETS).join(', ')}`);
+        }
+        await this.grantPermissions(context, permissions);
+    }
+    /**
+     * Get permission state from page (what the page sees)
+     */
+    async getPagePermissionState(page, permission) {
+        const result = await page.evaluate(async (perm) => {
+            const navigatorPermissions = navigator.permissions;
+            if (!navigatorPermissions) {
+                return 'unsupported';
+            }
+            try {
+                const status = await navigatorPermissions.query({ name: perm });
+                return status.state;
+            }
+            catch {
+                return 'unsupported';
+            }
+        }, this.mapPermissionName(permission));
+        if (result === 'granted' || result === 'denied' || result === 'prompt' || result === 'unsupported') {
+            return result;
+        }
+        return 'unsupported';
+    }
+    /**
+     * Watch for permission changes on a page
+     */
+    async watchPermissionChanges(page, permission, callback) {
+        await page.evaluate((perm, cb) => {
+            const navigatorPermissions = navigator.permissions;
+            if (!navigatorPermissions) {
+                cb('unsupported');
+                return;
+            }
+            navigatorPermissions.query({ name: perm }).then((status) => {
+                const listener = () => cb(status.state);
+                status.addEventListener('change', listener);
+            });
+        }, this.mapPermissionName(permission), callback);
+    }
+    /**
+     * Get permission changes history
+     */
+    getChanges() {
+        return [...this.changes];
+    }
+    /**
+     * Clear permission changes history
+     */
+    clearChanges() {
+        this.changes = [];
+    }
+    /**
+     * Map our permission names to PermissionDescriptor names
+     */
+    mapPermissionName(permission) {
+        const mapping = {
+            'geolocation': 'geolocation',
+            'midi': 'midi',
+            'notifications': 'notifications',
+            'camera': 'videoCapture',
+            'microphone': 'audioCapture',
+            'clipboard-read': 'clipboard-read',
+            'clipboard-write': 'clipboard-write',
+            'payment-handler': 'payment-handler',
+            'accelerometer': 'accelerometer',
+            'ambient-light-sensor': 'ambient-light-sensor',
+            'background-sync': 'background-sync',
+            'gyroscope': 'gyroscope',
+            'magnetometer': 'magnetometer',
+            'midi-sysex': 'midi-sysex',
+            'speaker-selection': 'speaker-selection',
+        };
+        return mapping[permission] || permission;
+    }
+    /**
+     * Get all available presets
+     */
+    getAvailablePresets() {
+        return Object.keys(PERMISSION_PRESETS);
+    }
+    /**
+     * Get permissions in a preset
+     */
+    getPresetPermissions(preset) {
+        return PERMISSION_PRESETS[preset];
+    }
+    /**
+     * Create a custom preset
+     */
+    createPreset(name, permissions) {
+        PERMISSION_PRESETS[name] = permissions;
+    }
+}
+/**
+ * Factory function to create Permissions Handler
+ */
+export function createPermissionsHandler(config) {
+    return new PermissionsHandler(config);
+}
+export default PermissionsHandler;

package/dist/core/crawler/permissions-policy-handler.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Permissions Policy Handler
+ *
+ * P1 - Permissions Policy (formerly Feature Policy) management
+ *
+ * Supports:
+ * - Permissions-Policy header parsing
+ * - Feature availability checking
+ * - Allowlist validation
+ * - Policy inheritance detection
+ * - iframe-specific policies
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy
+ */
+export type PermissionsPolicyFeature = 'accelerometer' | 'ambient-light-sensor' | 'autoplay' | 'battery' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'compute-pressure' | 'display-capture' | 'document-domain' | 'encrypted-media' | 'execution-while-out-of-viewport' | 'execution-while-not-rendered' | 'focus-without-user-activation' | 'fullscreen' | 'gamepad' | 'geolocation' | 'gyroscope' | 'hid' | 'identity-credentials-get' | 'idle-detection' | 'local-fonts' | 'magnetometer' | 'microphone' | 'midi' | 'otp-credentials' | 'payment' | 'picture-in-picture' | 'publickey-credentials-get' | 'screen-wake-lock' | 'serial' | 'smartcard' | 'storage-access' | 'sync-xhr' | 'touch' | 'usb' | 'web-share' | 'window-management' | 'xr-spatial-tracking';
+export interface PermissionsPolicyDirective {
+    /** Feature name */
+    feature: PermissionsPolicyFeature;
+    /** Allowlist of origins */
+    allowlist: string[];
+    /** Whether 'self' is allowed */
+    allowsSelf: boolean;
+    /** Whether '*' is allowed (all origins) */
+    allowsAll: boolean;
+    /** Whether 'none' is set */
+    allowsNone: boolean;
+    /** Specific allowed origins */
+    allowedOrigins: string[];
+}
+export interface PermissionsPolicyResult {
+    /** Feature is available in current context */
+    available: boolean;
+    /** Feature is allowed by policy */
+    allowed: boolean;
+    /** Policy directive if present */
+    directive?: PermissionsPolicyDirective;
+}
+export interface PermissionsPolicyReport {
+    /** Full header value */
+    header: string | null;
+    /** Parsed directives */
+    directives: Map<PermissionsPolicyFeature, PermissionsPolicyDirective>;
+    /** Features disabled by policy */
+    disabledFeatures: PermissionsPolicyFeature[];
+    /** Features with wildcard allowance */
+    wildcardFeatures: PermissionsPolicyFeature[];
+    /** Security score (0-100) */
+    securityScore: number;
+    /** Recommendations */
+    recommendations: string[];
+}
+/**
+ * Permissions Policy Handler class
+ */
+export declare class PermissionsPolicyHandler {
+    private page;
+    constructor(page: any);
+    /**
+     * Get Permissions-Policy header
+     */
+    getPermissionsPolicyHeader(): Promise<string | null>;
+    /**
+     * Get Permissions-Policy from iframe
+     */
+    getIframePermissionsPolicy(iframeSelector: string): Promise<string | null>;
+    /**
+     * Parse Permissions-Policy header
+     */
+    parsePermissionsPolicy(header: string): Map<PermissionsPolicyFeature, PermissionsPolicyDirective>;
+    /**
+     * Get full policy report
+     */
+    getPolicyReport(): Promise<PermissionsPolicyReport>;
+    /**
+     * Check if a feature is available and allowed
+     */
+    checkFeature(feature: string): Promise<PermissionsPolicyResult>;
+    /**
+     * Check multiple features at once
+     */
+    checkFeatures(features: PermissionsPolicyFeature[]): Promise<Map<PermissionsPolicyFeature, PermissionsPolicyResult>>;
+    /**
+     * Get all iframe policies on the page
+     */
+    getIframePolicies(): Promise<Map<string, string>>;
+    /**
+     * Test if iframe can access a feature
+     */
+    testIframeFeatureAccess(iframeSelector: string, feature: string): Promise<boolean>;
+    /**
+     * Validate security of permissions policy
+     */
+    validateSecurity(): Promise<{
+        secure: boolean;
+        issues: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Generate recommended Permissions-Policy header
+     */
+    generateRecommendedPolicy(options?: {
+        allowGeolocation?: boolean;
+        allowCamera?: boolean;
+        allowMicrophone?: boolean;
+        allowPayment?: boolean;
+        allowedOrigins?: string[];
+    }): string;
+}
+/**
+ * Factory function to create Permissions Policy Handler
+ */
+export declare function createPermissionsPolicyHandler(page: any): PermissionsPolicyHandler;
+export default PermissionsPolicyHandler;