qa360 1.4.5 → 2.0.1

package/dist/core/auth/ui-login-provider.js

@@ -0,0 +1,198 @@
+/**
+ * UI Login Authentication Provider
+ *
+ * Handles form-based UI login authentication using Playwright.
+ * Supports TOTP for 2FA and session persistence.
+ */
+import { authCache, createCacheKey } from './index.js';
+import { chromium } from 'playwright';
+export class UILoginProvider {
+    type = 'ui_login';
+    async authenticate(config) {
+        const { url, username, password, username_selector = 'input[name="username"], input[type="text"]', password_selector = 'input[name="password"], input[type="password"]', submit_selector = 'button[type="submit"], input[type="submit"]', totp_secret, totp_selector } = config;
+        if (!url) {
+            return {
+                success: false,
+                error: 'Login URL is required'
+            };
+        }
+        if (!username || !password) {
+            return {
+                success: false,
+                error: 'Username and password are required'
+            };
+        }
+        const cacheKey = this.getCacheKey(config);
+        // Check cache first
+        if (config.cache?.enabled !== false) {
+            const cached = authCache.get(cacheKey);
+            if (cached) {
+                return { success: true, credentials: cached };
+            }
+        }
+        let browser;
+        let context;
+        try {
+            // Launch browser
+            browser = await chromium.launch({ headless: true });
+            context = await browser.newContext();
+            const page = await context.newPage();
+            // Navigate to login page
+            await page.goto(url);
+            // Fill username
+            await page.fill(username_selector, username);
+            // Fill password
+            await page.fill(password_selector, password);
+            // Handle TOTP if provided
+            if (totp_secret && totp_selector) {
+                const totpCode = this.generateTOTP(totp_secret);
+                await page.fill(totp_selector, totpCode);
+            }
+            // Submit form and wait for navigation or network idle
+            // Use race to handle both traditional navigation and AJAX auth (Supabase, etc.)
+            await Promise.race([
+                page.waitForNavigation({ url: '*/*', timeout: 10000 }).catch(() => null),
+                page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => null),
+                page.waitForTimeout(5000) // Fallback: wait 5s max
+            ]);
+            // Get cookies
+            const cookies = await context.cookies();
+            // Create credentials with cookies
+            const credentials = {
+                type: 'ui_login',
+                cookies: cookies.map(c => ({
+                    name: c.name,
+                    value: c.value,
+                    domain: c.domain,
+                    path: c.path,
+                    expires: c.expires ? new Date(c.expires * 1000) : undefined,
+                    httpOnly: c.httpOnly,
+                    secure: c.secure
+                }))
+            };
+            // Save session to file if specified
+            if (config.session_file) {
+                await this.saveSession(config.session_file, cookies);
+            }
+            // Cache credentials (default 24 hours for UI sessions)
+            if (config.cache?.enabled !== false) {
+                const ttl = config.cache?.ttl || 86400;
+                authCache.set(cacheKey, credentials, ttl);
+            }
+            return {
+                success: true,
+                credentials
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `UI login failed: ${error.message}`
+            };
+        }
+        finally {
+            if (browser) {
+                await browser.close();
+            }
+        }
+    }
+    async clear(config) {
+        const key = this.getCacheKey(config);
+        authCache.clear(key);
+        // Clear session file if exists
+        if (config.session_file) {
+            try {
+                const fs = require('node:fs');
+                if (fs.existsSync(config.session_file)) {
+                    fs.unlinkSync(config.session_file);
+                }
+            }
+            catch {
+                // Ignore file errors
+            }
+        }
+        return Promise.resolve();
+    }
+    async validate(config) {
+        const key = this.getCacheKey(config);
+        return authCache.has(key);
+    }
+    getCacheKey(config) {
+        const identifier = config.url || 'default';
+        return createCacheKey('ui_login', identifier);
+    }
+    /**
+     * Generate TOTP code (simplified version)
+     */
+    generateTOTP(secret, digits = 6) {
+        // For a full implementation, this would use the TOTPProvider
+        // For now, provide a basic implementation
+        const crypto = require('node:crypto');
+        let time = Math.floor(Date.now() / 1000 / 30);
+        const timeBuffer = Buffer.alloc(8);
+        for (let i = 7; i >= 0; i--) {
+            timeBuffer[i] = time & 0xff;
+            time = time >> 8;
+        }
+        // Decode base32 secret
+        const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+        const bits = secret.toUpperCase().replace(/[^A-Z2-7]/g, '');
+        const keyBytes = [];
+        for (let i = 0; i < bits.length; i += 8) {
+            const chunk = bits.substring(i, i + 8);
+            let byte = 0;
+            for (let j = 0; j < 8; j++) {
+                const val = alphabet.indexOf(chunk[j]);
+                if (val === -1)
+                    continue;
+                byte = (byte << 5) | val;
+            }
+            keyBytes.push((byte >> 16) & 0xff);
+            keyBytes.push((byte >> 8) & 0xff);
+            keyBytes.push(byte & 0xff);
+        }
+        const hmac = crypto.createHmac('sha1', Buffer.from(keyBytes));
+        hmac.update(timeBuffer);
+        const result = hmac.digest();
+        const offset = result[result.length - 1] & 0xf;
+        const binary = ((result[offset] & 0x7f) << 24) |
+            ((result[offset + 1] & 0xff) << 16) |
+            ((result[offset + 2] & 0xff) << 8) |
+            (result[offset + 3] & 0xff);
+        const otp = binary % Math.pow(10, digits);
+        return otp.toString().padStart(digits, '0');
+    }
+    /**
+     * Save session cookies to file
+     */
+    async saveSession(filepath, cookies) {
+        const fs = require('node:fs');
+        const path = require('node:path');
+        // Ensure directory exists
+        const dir = path.dirname(filepath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filepath, JSON.stringify(cookies, null, 2));
+    }
+    /**
+     * Load session cookies from file
+     */
+    async loadSession(filepath) {
+        const fs = require('node:fs');
+        if (!fs.existsSync(filepath)) {
+            return [];
+        }
+        const data = fs.readFileSync(filepath, 'utf-8');
+        const cookies = JSON.parse(data);
+        return cookies.map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path,
+            expires: c.expires ? new Date(c.expires) : undefined,
+            httpOnly: c.httpOnly,
+            secure: c.secure
+        }));
+    }
+}

package/dist/core/cache/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * QA360 Cache Module
+ *
+ * Intelligent caching system for HTTP responses and test results.
+ */
+export { ResponseCache, generateCacheKey, createResponseCache, getDefaultCache, resetDefaultCache } from './lru-cache.js';
+export type { CacheEntry, CacheOptions, CacheStats, CacheKeyOptions } from './lru-cache.js';

package/dist/core/cache/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Cache Module
+ *
+ * Intelligent caching system for HTTP responses and test results.
+ */
+export { ResponseCache, generateCacheKey, createResponseCache, getDefaultCache, resetDefaultCache } from './lru-cache.js';

package/dist/core/cache/lru-cache.d.ts

@@ -0,0 +1,203 @@
+/**
+ * QA360 LRU Cache Module
+ *
+ * Intelligent caching system for HTTP responses to avoid redundant requests.
+ * Features:
+ * - LRU (Least Recently Used) eviction policy
+ * - TTL (Time To Live) expiration
+ * - Size-based limits
+ * - Cache key generation based on request parameters
+ * - Thread-safe operations (async-friendly)
+ * - Metrics and statistics
+ *
+ * @example
+ * ```typescript
+ * const cache = new ResponseCache({
+ *   maxSize: 100,
+ *   ttl: 60000, // 1 minute
+ *   maxSizeBytes: 10 * 1024 * 1024 // 10MB
+ * });
+ *
+ * const response = await cache.getOrFetch('GET:/api/users', async () => {
+ *   return await fetch('/api/users');
+ * });
+ * ```
+ */
+/**
+ * Cache entry containing response data and metadata
+ */
+export interface CacheEntry<T> {
+    /** Cached response data */
+    data: T;
+    /** Timestamp when entry was created (ms) */
+    createdAt: number;
+    /** Timestamp when entry was last accessed (ms) */
+    lastAccessed: number;
+    /** Number of times this entry was accessed */
+    hitCount: number;
+    /** Size of the cached data in bytes (approximate) */
+    size: number;
+    /** Optional cache key for this entry */
+    key?: string;
+}
+/**
+ * Cache configuration options
+ */
+export interface CacheOptions {
+    /** Maximum number of entries in the cache (default: 100) */
+    maxSize?: number;
+    /** Time to live for entries in milliseconds (default: 300000 = 5 minutes) */
+    ttl?: number;
+    /** Maximum total size of cache in bytes (default: 10MB) */
+    maxSizeBytes?: number;
+    /** Whether to enable cache statistics (default: true) */
+    enableStats?: boolean;
+    /** Whether to log cache operations (default: false) */
+    verbose?: boolean;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /** Total number of cache hits */
+    hits: number;
+    /** Total number of cache misses */
+    misses: number;
+    /** Total number of entries added to cache */
+    additions: number;
+    /** Total number of entries evicted from cache */
+    evictions: number;
+    /** Current number of entries in cache */
+    size: number;
+    /** Current approximate size in bytes */
+    sizeBytes: number;
+    /** Cache hit rate (0-1) */
+    hitRate: number;
+    /** Average entry size in bytes */
+    avgEntrySize: number;
+}
+/**
+ * Cache key generation options
+ */
+export interface CacheKeyOptions {
+    /** HTTP method (GET, POST, etc.) */
+    method: string;
+    /** Request URL/endpoint */
+    url: string;
+    /** Request headers (for cache key variation) */
+    headers?: Record<string, string>;
+    /** Request body (for POST/PUT/PATCH) */
+    body?: string | Record<string, unknown>;
+    /** Query parameters */
+    params?: Record<string, string>;
+    /** Vary headers (headers that affect cacheability) */
+    varyHeaders?: string[];
+}
+/**
+ * LRU Response Cache
+ *
+ * Thread-safe LRU cache with TTL and size-based eviction.
+ */
+export declare class ResponseCache<T = unknown> {
+    private cache;
+    private maxSize;
+    private ttl;
+    private maxSizeBytes;
+    private currentSizeBytes;
+    private enableStats;
+    private verbose;
+    private stats;
+    constructor(options?: CacheOptions);
+    /**
+     * Get a value from cache by key
+     * Returns undefined if not found or expired
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set a value in cache by key
+     * If key exists, updates the entry
+     * If cache is full, evicts LRU entry
+     */
+    set(key: string, data: T, size?: number): void;
+    /**
+     * Get a value from cache, or compute and cache it if not present
+     * This is the main method to use for caching operations
+     */
+    getOrFetch(key: string, fetchFn: () => Promise<T>, size?: number): Promise<T>;
+    /**
+     * Check if a key exists in cache and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a specific entry from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all entries from cache
+     */
+    clear(): void;
+    /**
+     * Remove expired entries from cache
+     * Returns the number of entries removed
+     */
+    purgeExpired(): number;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Reset cache statistics
+     */
+    resetStats(): void;
+    /**
+     * Get all cache keys (useful for debugging)
+     */
+    keys(): string[];
+    /**
+     * Get cache size
+     */
+    get size(): number;
+    /**
+     * Check if cache is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Evict least recently used entry (private method)
+     * Since we move accessed entries to the end, the first entry is the LRU
+     */
+    private _evictLRU;
+    /**
+     * Remove entry and update size tracking (private method)
+     */
+    private _remove;
+    /**
+     * Estimate size of data in bytes (private method)
+     */
+    private _estimateSize;
+    private _recordHit;
+    private _recordMiss;
+    private _recordAddition;
+}
+/**
+ * Generate a cache key from request parameters
+ *
+ * The key is generated based on:
+ * - HTTP method
+ * - URL
+ * - Vary headers (Authorization, Content-Type, etc.)
+ * - Request body (for POST/PUT/PATCH)
+ * - Query parameters
+ */
+export declare function generateCacheKey(options: CacheKeyOptions): string;
+/**
+ * Create a response cache with default options for HTTP caching
+ */
+export declare function createResponseCache<T = unknown>(options?: CacheOptions): ResponseCache<T>;
+/**
+ * Get or create the default cache instance
+ */
+export declare function getDefaultCache<T = unknown>(): ResponseCache<T>;
+/**
+ * Reset the default cache instance
+ */
+export declare function resetDefaultCache(): void;