qa360 2.1.2 → 2.1.4

package/dist/core/assertions/types.js

@@ -1,37 +0,0 @@
-/**
- * QA360 Assertions Engine - Type Definitions
- *
- * Comprehensive assertions for UI testing
- */
-/**
- * Assertion error
- */
-export class AssertionError extends Error {
-    assertion;
-    actual;
-    expected;
-    constructor(message, assertion, actual, expected) {
-        super(message);
-        this.name = 'AssertionError';
-        this.assertion = assertion;
-        this.actual = actual;
-        this.expected = expected;
-    }
-    toString() {
-        const expected = this.expected !== undefined ? ` expected: ${JSON.stringify(this.expected)}` : '';
-        const actual = this.actual !== undefined ? ` actual: ${JSON.stringify(this.actual)}` : '';
-        return `${this.message}${expected}${actual}`;
-    }
-}
-/**
- * Soft assertion collection
- */
-export class SoftAssertionError extends Error {
-    results;
-    constructor(results) {
-        const failures = results.filter(r => !r.passed);
-        super(`${failures.length} soft assertion(s) failed:\n${failures.map(f => `  - ${f.error || f.assertion.message || f.assertion.type}`).join('\n')}`);
-        this.name = 'SoftAssertionError';
-        this.results = results;
-    }
-}

package/dist/core/auth/api-key-provider.d.ts

@@ -1,16 +0,0 @@
-/**
- * API Key Authentication Provider
- *
- * Handles API key authentication with support for:
- * - Custom header names (default: X-API-Key)
- * - Custom prefix (e.g., "Bearer ")
- * - Header or query param location
- */
-import { AuthProvider, AuthResult, APIKeyAuthConfig } from './index.js';
-export declare class APIKeyProvider implements AuthProvider<APIKeyAuthConfig> {
-    readonly type: "api_key";
-    authenticate(config: APIKeyAuthConfig): Promise<AuthResult>;
-    clear(config: APIKeyAuthConfig): Promise<void>;
-    validate(config: APIKeyAuthConfig): Promise<boolean>;
-    private getCacheKey;
-}

package/dist/core/auth/api-key-provider.js

@@ -1,63 +0,0 @@
-/**
- * API Key Authentication Provider
- *
- * Handles API key authentication with support for:
- * - Custom header names (default: X-API-Key)
- * - Custom prefix (e.g., "Bearer ")
- * - Header or query param location
- */
-import { authCache, createCacheKey } from './index.js';
-export class APIKeyProvider {
-    type = 'api_key';
-    async authenticate(config) {
-        const { key, header_name = 'X-API-Key', prefix = '', location = 'header', cache } = config;
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first
-        if (cache?.enabled !== false) {
-            const cached = authCache.get(cacheKey);
-            if (cached) {
-                return { success: true, credentials: cached };
-            }
-        }
-        const credentials = {
-            type: 'api_key'
-        };
-        // Prefix is used as-is, no automatic space added
-        const fullKey = prefix + key;
-        if (location === 'header') {
-            credentials.headers = {
-                [header_name]: fullKey
-            };
-        }
-        else {
-            credentials.queryParams = {
-                api_key: fullKey
-            };
-        }
-        // Cache if enabled
-        if (cache?.enabled !== false) {
-            const ttl = cache?.ttl || 3600;
-            authCache.set(cacheKey, credentials, ttl);
-        }
-        return {
-            success: true,
-            credentials
-        };
-    }
-    async clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-    }
-    async validate(config) {
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first, then validate key
-        if (authCache.has(cacheKey)) {
-            return true;
-        }
-        return !!config.key && config.key.length > 0;
-    }
-    getCacheKey(config) {
-        // Use header name as identifier
-        return createCacheKey('api_key', config.header_name || 'default');
-    }
-}

package/dist/core/auth/aws-iam-provider.d.ts

@@ -1,35 +0,0 @@
-/**
- * AWS IAM Authentication Provider
- *
- * Handles AWS authentication using IAM credentials.
- * Supports credential chains, environment variables, and profiles.
- */
-import { AuthProvider, AuthResult, AWSIamConfig } from './index.js';
-export declare class AWSIamProvider implements AuthProvider<AWSIamConfig> {
-    readonly type: "aws_iam";
-    authenticate(config: AWSIamConfig): Promise<AuthResult>;
-    refresh(config: AWSIamConfig): Promise<AuthResult>;
-    clear(config: AWSIamConfig): Promise<void>;
-    validate(config: AWSIamConfig): Promise<boolean>;
-    /**
-     * Get AWS credentials from various sources
-     */
-    private getCredentials;
-    /**
-     * Get credentials from environment variables
-     */
-    private getFromEnv;
-    /**
-     * Get credentials from AWS profile file
-     */
-    private getFromProfile;
-    /**
-     * Get credentials from AWS SDK v3
-     */
-    private getFromSDK;
-    /**
-     * Get AMZ date format for AWS signing
-     */
-    private getAmzDate;
-    private getCacheKey;
-}

package/dist/core/auth/aws-iam-provider.js

@@ -1,177 +0,0 @@
-/**
- * AWS IAM Authentication Provider
- *
- * Handles AWS authentication using IAM credentials.
- * Supports credential chains, environment variables, and profiles.
- */
-import { authCache, createCacheKey } from './index.js';
-export class AWSIamProvider {
-    type = 'aws_iam';
-    async authenticate(config) {
-        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 };
-            }
-        }
-        // Get AWS credentials
-        const awsCreds = await this.getCredentials(config);
-        if (!awsCreds) {
-            return {
-                success: false,
-                error: 'Failed to obtain AWS credentials. Ensure you have configured AWS credentials via environment variables, ~/.aws/credentials, or IAM role.'
-            };
-        }
-        // Sign request to get session token if using temporary credentials
-        const credentials = {
-            type: 'aws_iam',
-            headers: {
-                'X-Amz-Security-Token': awsCreds.session_token || '',
-                'X-Amz-Date': this.getAmzDate()
-            }
-        };
-        // Add basic auth header for some AWS services
-        if (awsCreds.access_key_id && awsCreds.secret_access_key) {
-            credentials.headers['X-Amz-Credential'] = `${awsCreds.access_key_id}`;
-        }
-        // Cache credentials (AWS temp tokens expire in 1 hour typically)
-        if (config.cache?.enabled !== false) {
-            const ttl = config.cache?.ttl || 3600;
-            authCache.set(cacheKey, credentials, ttl);
-        }
-        return {
-            success: true,
-            credentials,
-            expiresAt: awsCreds.expiration || Date.now() + 3600 * 1000
-        };
-    }
-    async refresh(config) {
-        authCache.clear(this.getCacheKey(config));
-        return this.authenticate(config);
-    }
-    clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-        return Promise.resolve();
-    }
-    async validate(config) {
-        const key = this.getCacheKey(config);
-        return authCache.has(key);
-    }
-    /**
-     * Get AWS credentials from various sources
-     */
-    async getCredentials(config) {
-        // Method 1: Direct credentials from config
-        if (config.access_key_id && config.secret_access_key) {
-            return {
-                access_key_id: config.access_key_id,
-                secret_access_key: config.secret_access_key,
-                session_token: config.session_token
-            };
-        }
-        // Method 2: Environment variables
-        const envCreds = this.getFromEnv();
-        if (envCreds)
-            return envCreds;
-        // Method 3: AWS profile
-        if (config.profile) {
-            const profileCreds = await this.getFromProfile(config.profile);
-            if (profileCreds)
-                return profileCreds;
-        }
-        // Method 4: Try AWS SDK if available
-        const sdkCreds = await this.getFromSDK(config);
-        if (sdkCreds)
-            return sdkCreds;
-        return null;
-    }
-    /**
-     * Get credentials from environment variables
-     */
-    getFromEnv() {
-        const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
-        const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
-        const sessionToken = process.env.AWS_SESSION_TOKEN;
-        if (accessKeyId && secretAccessKey) {
-            return {
-                access_key_id: accessKeyId,
-                secret_access_key: secretAccessKey,
-                session_token: sessionToken
-            };
-        }
-        return null;
-    }
-    /**
-     * Get credentials from AWS profile file
-     */
-    async getFromProfile(profile) {
-        try {
-            const fs = require('node:fs');
-            const path = require('node:path');
-            const { execSync } = require('node:child_process');
-            const homeDir = process.env.HOME || process.env.USERPROFILE;
-            const credentialsPath = path.join(homeDir, '.aws', 'credentials');
-            if (!fs.existsSync(credentialsPath)) {
-                return null;
-            }
-            // Use AWS CLI to get credentials for profile
-            const creds = execSync(`aws configure export --profile ${profile}`, {
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe']
-            });
-            // Parse the export output
-            const accessKeyMatch = creds.match(/AWS_ACCESS_KEY_ID="([^"]+)"/);
-            const secretKeyMatch = creds.match(/AWS_SECRET_ACCESS_KEY="([^"]+)"/);
-            const sessionMatch = creds.match(/AWS_SESSION_TOKEN="([^"]+)"/);
-            if (accessKeyMatch && secretKeyMatch) {
-                return {
-                    access_key_id: accessKeyMatch[1],
-                    secret_access_key: secretKeyMatch[1],
-                    session_token: sessionMatch?.[1]
-                };
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get credentials from AWS SDK v3
-     */
-    async getFromSDK(config) {
-        try {
-            // Try to import AWS SDK
-            // @ts-ignore - AWS SDK is optional dependency
-            const { defaultProvider } = await import('@aws-sdk/credential-providers');
-            const provider = defaultProvider({
-                profile: config.profile
-            });
-            const creds = await provider();
-            return {
-                access_key_id: creds.accessKeyId,
-                secret_access_key: creds.secretAccessKey,
-                session_token: creds.sessionToken,
-                expiration: creds.expiration?.getTime()
-            };
-        }
-        catch {
-            // AWS SDK not available or error
-            return null;
-        }
-    }
-    /**
-     * Get AMZ date format for AWS signing
-     */
-    getAmzDate() {
-        const now = new Date();
-        return now.toISOString().replace(/[:\-]|\.\d{3}/g, '');
-    }
-    getCacheKey(config) {
-        const identifier = config.profile || config.region || 'default';
-        return createCacheKey('aws_iam', identifier);
-    }
-}

package/dist/core/auth/azure-ad-provider.d.ts

@@ -1,15 +0,0 @@
-/**
- * Azure AD Authentication Provider
- *
- * Handles Azure Active Directory authentication.
- * Supports OAuth2 client credentials flow with Azure AD.
- */
-import { AuthProvider, AuthResult, AzureADConfig } from './index.js';
-export declare class AzureADProvider implements AuthProvider<AzureADConfig> {
-    readonly type: "azure_ad";
-    authenticate(config: AzureADConfig): Promise<AuthResult>;
-    refresh(config: AzureADConfig): Promise<AuthResult>;
-    clear(config: AzureADConfig): Promise<void>;
-    validate(config: AzureADConfig): Promise<boolean>;
-    private getCacheKey;
-}

package/dist/core/auth/azure-ad-provider.js

@@ -1,99 +0,0 @@
-/**
- * Azure AD Authentication Provider
- *
- * Handles Azure Active Directory authentication.
- * Supports OAuth2 client credentials flow with Azure AD.
- */
-import { authCache, createCacheKey } from './index.js';
-export class AzureADProvider {
-    type = 'azure_ad';
-    async authenticate(config) {
-        const { tenant_id, client_id, client_secret, scope = 'https://management.azure.com/.default' } = config;
-        if (!tenant_id || !client_id) {
-            return {
-                success: false,
-                error: 'Azure AD requires tenant_id and client_id'
-            };
-        }
-        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 };
-            }
-        }
-        // Default token endpoint for Azure AD
-        const tokenEndpoint = config.token_endpoint ||
-            `https://login.microsoftonline.com/${tenant_id}/oauth2/v2.0/token`;
-        try {
-            const body = new URLSearchParams({
-                grant_type: 'client_credentials',
-                client_id,
-                client_secret: client_secret || '',
-                scope
-            });
-            const response = await fetch(tokenEndpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded'
-                },
-                body: body.toString()
-            });
-            if (!response.ok) {
-                const error = await response.text().catch(() => 'Unknown error');
-                return {
-                    success: false,
-                    error: `Azure AD token request failed: ${response.status} ${error}`
-                };
-            }
-            const data = await response.json();
-            const token = data.access_token;
-            if (!token) {
-                return {
-                    success: false,
-                    error: 'No access_token in Azure AD response'
-                };
-            }
-            const credentials = {
-                type: 'azure_ad',
-                headers: {
-                    'Authorization': `Bearer ${token}`
-                }
-            };
-            // Cache with calculated expiration
-            if (config.cache?.enabled !== false) {
-                const expiresIn = data.expires_in || 3600;
-                const ttl = config.cache?.ttl || expiresIn;
-                authCache.set(cacheKey, credentials, ttl);
-            }
-            return {
-                success: true,
-                credentials,
-                expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Azure AD authentication failed: ${error.message}`
-            };
-        }
-    }
-    async refresh(config) {
-        authCache.clear(this.getCacheKey(config));
-        return this.authenticate(config);
-    }
-    clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-        return Promise.resolve();
-    }
-    async validate(config) {
-        const key = this.getCacheKey(config);
-        return authCache.has(key);
-    }
-    getCacheKey(config) {
-        return createCacheKey('azure_ad', config.client_id);
-    }
-}

package/dist/core/auth/basic-auth-provider.d.ts

@@ -1,26 +0,0 @@
-/**
- * Bearer Token and Basic Authentication Providers
- *
- * Handles generic bearer token and HTTP Basic Authentication.
- */
-import { AuthProvider, AuthResult, BearerAuthConfig, BasicAuthConfig } from './index.js';
-/**
- * Bearer Token Authentication Provider
- */
-export declare class BearerProvider implements AuthProvider<BearerAuthConfig> {
-    readonly type: "bearer";
-    authenticate(config: BearerAuthConfig): Promise<AuthResult>;
-    clear(config: BearerAuthConfig): Promise<void>;
-    validate(config: BearerAuthConfig): Promise<boolean>;
-    private getCacheKey;
-}
-/**
- * Basic Authentication Provider
- */
-export declare class BasicAuthProvider implements AuthProvider<BasicAuthConfig> {
-    readonly type: "basic";
-    authenticate(config: BasicAuthConfig): Promise<AuthResult>;
-    clear(config: BasicAuthConfig): Promise<void>;
-    validate(config: BasicAuthConfig): Promise<boolean>;
-    private getCacheKey;
-}

package/dist/core/auth/basic-auth-provider.js

@@ -1,111 +0,0 @@
-/**
- * Bearer Token and Basic Authentication Providers
- *
- * Handles generic bearer token and HTTP Basic Authentication.
- */
-import { parseToken, encodeBasicAuth, authCache, createCacheKey } from './index.js';
-/**
- * Bearer Token Authentication Provider
- */
-export class BearerProvider {
-    type = 'bearer';
-    async authenticate(config) {
-        const { token, cache } = config;
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first
-        if (cache?.enabled !== false) {
-            const cached = authCache.get(cacheKey);
-            if (cached) {
-                return { success: true, credentials: cached };
-            }
-        }
-        const cleanToken = parseToken(token);
-        const credentials = {
-            type: 'bearer',
-            headers: {
-                'Authorization': `Bearer ${cleanToken}`
-            }
-        };
-        // Cache if enabled
-        if (cache?.enabled !== false) {
-            const ttl = cache?.ttl || 3600;
-            authCache.set(cacheKey, credentials, ttl);
-        }
-        return {
-            success: true,
-            credentials
-        };
-    }
-    async clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-    }
-    async validate(config) {
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first, then validate token
-        if (authCache.has(cacheKey)) {
-            return true;
-        }
-        return !!config.token && config.token.length > 0;
-    }
-    getCacheKey(config) {
-        // Use token hash as identifier
-        const crypto = require('node:crypto');
-        const hash = crypto.createHash('sha256').update(config.token || '').digest('hex').substring(0, 16);
-        return createCacheKey('bearer', hash);
-    }
-}
-/**
- * Basic Authentication Provider
- */
-export class BasicAuthProvider {
-    type = 'basic';
-    async authenticate(config) {
-        const { username, password, cache } = config;
-        if (!username || !password) {
-            return {
-                success: false,
-                error: 'Username and password are required for Basic auth'
-            };
-        }
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first
-        if (cache?.enabled !== false) {
-            const cached = authCache.get(cacheKey);
-            if (cached) {
-                return { success: true, credentials: cached };
-            }
-        }
-        const credentials = {
-            type: 'basic',
-            headers: {
-                'Authorization': encodeBasicAuth(username, password)
-            }
-        };
-        // Cache if enabled
-        if (cache?.enabled !== false) {
-            const ttl = cache?.ttl || 3600;
-            authCache.set(cacheKey, credentials, ttl);
-        }
-        return {
-            success: true,
-            credentials
-        };
-    }
-    async clear(config) {
-        const key = this.getCacheKey(config);
-        authCache.clear(key);
-    }
-    async validate(config) {
-        const cacheKey = this.getCacheKey(config);
-        // Check cache first, then validate credentials
-        if (authCache.has(cacheKey)) {
-            return true;
-        }
-        return !!config.username && !!config.password;
-    }
-    getCacheKey(config) {
-        // Use username as identifier
-        return createCacheKey('basic', config.username || 'default');
-    }
-}

package/dist/core/auth/gcp-adc-provider.d.ts

@@ -1,27 +0,0 @@
-/**
- * GCP Application Default Credentials Provider
- *
- * Handles GCP authentication using Application Default Credentials.
- * Supports service account credentials and ADC resolution.
- */
-import { AuthProvider, AuthResult, GCPADCConfig } from './index.js';
-export declare class GCPADCProvider implements AuthProvider<GCPADCConfig> {
-    readonly type: "gcp_adc";
-    authenticate(config: GCPADCConfig): Promise<AuthResult>;
-    refresh(config: GCPADCConfig): Promise<AuthResult>;
-    clear(config: GCPADCConfig): Promise<void>;
-    validate(config: GCPADCConfig): Promise<boolean>;
-    /**
-     * Get GCP access token from various sources
-     */
-    private getAccessToken;
-    /**
-     * Get token from gcloud CLI
-     */
-    private getTokenFromGcloud;
-    /**
-     * Get token from GCP metadata server
-     */
-    private getTokenFromMetadataServer;
-    private getCacheKey;
-}