qa360 2.1.2 → 2.1.4

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

@@ -1,198 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,203 +0,0 @@
-/**
- * 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;