@avi770/testteam 3.0.0 → 3.2.0

package/agents/58-payment-flow-tester.ts

@@ -1,183 +0,0 @@
-import type { Browser, Page } from 'playwright';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-import { login } from '../helpers/navigation';
-
-/** Routes to check for billing/pricing pages. */
-const BILLING_ROUTES = ['/billing', '/pricing', '/subscription', '/payment', '/plans'] as const;
-
-/** Selectors for Stripe checkout elements. */
-const STRIPE_SELECTORS = [
-  'iframe[src*="stripe"]',
-  '[data-stripe]',
-  '#card-element',
-  '.StripeElement',
-  'button:has-text("Subscribe")',
-  'button:has-text("Checkout")',
-  'button:has-text("Pay")',
-] as const;
-
-export class PaymentFlowTesterAgent extends BaseAgent {
-  readonly agentId = 58;
-  readonly agentName = 'Payment Flow Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    const { env } = await resolveEnvironment(this.config, this.phase);
-    this.baseUrl = env.baseUrl;
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    // Check config for Stripe integration
-    const hasStripe = this.config.integrations.some(
-      i => i.name.toLowerCase().includes('stripe'),
-    );
-
-    if (!hasStripe) {
-      findings.push({
-        id: `${this.agentId}-no-stripe`,
-        type: 'test-bug',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'payment-flow-tester',
-        description: 'No Stripe integration configured — payment flow test skipped',
-      });
-      return findings;
-    }
-
-    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
-    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${this.baseUrl}${rawLoginUrl}`;
-    const credentials =
-      this.config.auth.credentials?.['admin'] ??
-      Object.values(this.config.auth.credentials ?? {})[0];
-
-    const { chromium } = await import('playwright');
-
-    let browser: Browser | null = null;
-
-    try {
-      browser = await chromium.launch({ headless: true });
-      const page = await browser.newPage();
-
-      if (credentials) {
-        try {
-          await login(page, credentials, loginUrl);
-        } catch {
-          findings.push({
-            id: `${this.agentId}-login-failed`,
-            type: 'infra-issue',
-            severity: 'medium',
-            agentId: this.agentId,
-            module: 'payment-flow-tester',
-            description: 'Login failed — continuing anonymously',
-          });
-        }
-      }
-
-      // Try billing routes
-      let billingPageFound = false;
-
-      for (const route of BILLING_ROUTES) {
-        const fullUrl = `${this.baseUrl}${route}`;
-
-        try {
-          const response = await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-          if (response && response.ok()) {
-            billingPageFound = true;
-
-            // Check for Stripe elements
-            const stripeFindings = await this.checkStripeElements(page, route);
-            findings.push(...stripeFindings);
-            break;
-          }
-        } catch {
-          // Route not found — try next
-        }
-      }
-
-      if (!billingPageFound) {
-        findings.push({
-          id: `${this.agentId}-no-billing-page`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'payment-flow-tester',
-          description: `Stripe configured but no billing page found at: ${BILLING_ROUTES.join(', ')}`,
-        });
-      }
-
-      await page.close().catch(() => undefined);
-    } catch (playwrightError) {
-      findings.push({
-        id: `${this.agentId}-playwright-failure`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'payment-flow-tester',
-        description: `Playwright execution failed: ${playwrightError instanceof Error ? playwrightError.message.split('\n')[0] : String(playwrightError)}`,
-      });
-    } finally {
-      if (browser) await browser.close().catch(() => undefined);
-    }
-
-    return findings;
-  }
-
-  private async checkStripeElements(page: Page, route: string): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const selector = STRIPE_SELECTORS.join(', ');
-    const stripeCount = await page.locator(selector).count();
-
-    if (stripeCount === 0) {
-      findings.push({
-        id: `${this.agentId}-no-stripe-elements`,
-        type: 'test-bug',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'payment-flow-tester',
-        description: `Billing page ${route} found but no Stripe checkout elements detected`,
-      });
-      return findings;
-    }
-
-    // Check for Stripe iframe specifically
-    const iframeCount = await page.locator('iframe[src*="stripe"]').count();
-    if (iframeCount > 0) {
-      this.addEvidence({
-        type: 'log',
-        path: '',
-        description: `Stripe iframe detected on ${route}`,
-      });
-    }
-
-    // Try clicking checkout button
-    const checkoutBtn = page.locator('button:has-text("Subscribe"), button:has-text("Checkout"), button:has-text("Pay")');
-    if (await checkoutBtn.count() > 0) {
-      try {
-        await checkoutBtn.first().click();
-        await new Promise(resolve => setTimeout(resolve, 3_000));
-
-        // Check if Stripe iframe loaded after click
-        const postClickIframeCount = await page.locator('iframe[src*="stripe"]').count();
-        if (postClickIframeCount === 0) {
-          findings.push({
-            id: `${this.agentId}-stripe-iframe-not-loaded`,
-            type: 'test-bug',
-            severity: 'medium',
-            agentId: this.agentId,
-            module: 'payment-flow-tester',
-            description: `Checkout button clicked on ${route} but Stripe iframe did not load`,
-          });
-        }
-      } catch {
-        // Click failure — non-critical
-      }
-    }
-
-    return findings;
-  }
-}

package/agents/59-ssl-tls-auditor.ts

@@ -1,141 +0,0 @@
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-
-export class SslTlsAuditorAgent extends BaseAgent {
-  readonly agentId = 59;
-  readonly agentName = 'SSL/TLS Auditor';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    const { env } = await resolveEnvironment(this.config, this.phase);
-    this.baseUrl = env.baseUrl;
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    // Check HSTS header
-    try {
-      const response = await fetch(this.baseUrl, {
-        method: 'HEAD',
-        signal: AbortSignal.timeout(10_000),
-      });
-
-      const hsts = response.headers.get('strict-transport-security');
-
-      if (!hsts) {
-        findings.push({
-          id: `${this.agentId}-no-hsts`,
-          type: 'code-bug-security',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: 'ssl-tls-auditor',
-          description: 'Missing Strict-Transport-Security header',
-          suggestedFix: 'Add Strict-Transport-Security header with max-age of at least 31536000',
-        });
-      } else {
-        // Check max-age value
-        const maxAgeMatch = hsts.match(/max-age=(\d+)/);
-        if (maxAgeMatch) {
-          const maxAge = parseInt(maxAgeMatch[1], 10);
-          if (maxAge < 31_536_000) {
-            findings.push({
-              id: `${this.agentId}-short-hsts`,
-              type: 'code-bug-security',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'ssl-tls-auditor',
-              description: `HSTS max-age is ${maxAge}s (recommended: 31536000+)`,
-            });
-          }
-        }
-      }
-    } catch (fetchError) {
-      findings.push({
-        id: `${this.agentId}-fetch-failed`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'ssl-tls-auditor',
-        description: `Failed to reach ${this.baseUrl}: ${fetchError instanceof Error ? fetchError.message.split('\n')[0] : String(fetchError)}`,
-      });
-    }
-
-    // Check certificate expiry via https module
-    if (this.baseUrl.startsWith('https://')) {
-      try {
-        const https = await import('node:https');
-        const url = new URL(this.baseUrl);
-
-        const certInfo = await new Promise<{ valid_to?: string; valid_from?: string }>((resolve, reject) => {
-          const req = https.get(
-            {
-              hostname: url.hostname,
-              port: url.port || 443,
-              path: '/',
-              rejectUnauthorized: false,
-              timeout: 10_000,
-            },
-            (res) => {
-              const socket = res.socket as import('node:tls').TLSSocket;
-              const cert = socket.getPeerCertificate?.();
-              resolve({ valid_to: cert?.valid_to, valid_from: cert?.valid_from });
-            },
-          );
-          req.on('error', reject);
-          req.on('timeout', () => {
-            req.destroy();
-            reject(new Error('Certificate check timeout'));
-          });
-        });
-
-        if (certInfo.valid_to) {
-          const expiryDate = new Date(certInfo.valid_to);
-          const now = new Date();
-          const daysUntilExpiry = Math.floor((expiryDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-
-          if (daysUntilExpiry < 0) {
-            findings.push({
-              id: `${this.agentId}-cert-expired`,
-              type: 'code-bug-security',
-              severity: 'critical',
-              agentId: this.agentId,
-              module: 'ssl-tls-auditor',
-              description: `SSL certificate expired ${Math.abs(daysUntilExpiry)} days ago`,
-            });
-          } else if (daysUntilExpiry < 30) {
-            findings.push({
-              id: `${this.agentId}-cert-expiring-soon`,
-              type: 'code-bug-security',
-              severity: 'high',
-              agentId: this.agentId,
-              module: 'ssl-tls-auditor',
-              description: `SSL certificate expires in ${daysUntilExpiry} days`,
-            });
-          }
-        }
-      } catch (certError) {
-        findings.push({
-          id: `${this.agentId}-cert-check-failed`,
-          type: 'infra-issue',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'ssl-tls-auditor',
-          description: `Certificate check failed: ${certError instanceof Error ? certError.message.split('\n')[0] : String(certError)}`,
-        });
-      }
-    } else {
-      findings.push({
-        id: `${this.agentId}-no-https`,
-        type: 'code-bug-security',
-        severity: 'high',
-        agentId: this.agentId,
-        module: 'ssl-tls-auditor',
-        description: `Base URL ${this.baseUrl} does not use HTTPS`,
-      });
-    }
-
-    return findings;
-  }
-}

package/agents/60-dns-cdn-tester.ts

@@ -1,117 +0,0 @@
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-
-/** Headers that indicate CDN usage. */
-const CDN_HEADERS: Record<string, string> = {
-  'x-cache': 'Generic CDN',
-  'cf-ray': 'Cloudflare',
-  'x-vercel-cache': 'Vercel',
-  'x-cdn': 'Generic CDN',
-  'x-amz-cf-id': 'AWS CloudFront',
-  'x-served-by': 'Fastly/Varnish',
-  'x-azure-ref': 'Azure CDN',
-};
-
-/** Max acceptable response time in ms. */
-const MAX_RESPONSE_TIME_MS = 2_000;
-
-export class DnsCdnTesterAgent extends BaseAgent {
-  readonly agentId = 60;
-  readonly agentName = 'DNS & CDN Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    const { env } = await resolveEnvironment(this.config, this.phase);
-    this.baseUrl = env.baseUrl;
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    try {
-      const startTime = Date.now();
-
-      const response = await fetch(this.baseUrl, {
-        method: 'GET',
-        signal: AbortSignal.timeout(15_000),
-      });
-
-      const responseTime = Date.now() - startTime;
-
-      // Check response time
-      if (responseTime > MAX_RESPONSE_TIME_MS) {
-        findings.push({
-          id: `${this.agentId}-slow-response`,
-          type: 'infra-issue',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: 'dns-cdn-tester',
-          description: `Response time ${responseTime}ms exceeds ${MAX_RESPONSE_TIME_MS}ms threshold`,
-        });
-      }
-
-      // Check CDN headers
-      let cdnDetected = false;
-      for (const [header, cdnName] of Object.entries(CDN_HEADERS)) {
-        const value = response.headers.get(header);
-        if (value) {
-          cdnDetected = true;
-          this.addEvidence({
-            type: 'log',
-            path: '',
-            description: `CDN detected: ${cdnName} (header: ${header}=${value})`,
-          });
-        }
-      }
-
-      if (!cdnDetected) {
-        findings.push({
-          id: `${this.agentId}-no-cdn`,
-          type: 'infra-issue',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'dns-cdn-tester',
-          description: 'No CDN detected — consider using a CDN for improved performance',
-        });
-      }
-
-      // Check cache-control header
-      const cacheControl = response.headers.get('cache-control');
-      if (!cacheControl) {
-        findings.push({
-          id: `${this.agentId}-no-cache-control`,
-          type: 'infra-issue',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'dns-cdn-tester',
-          description: 'Missing Cache-Control header — caching policy not defined',
-        });
-      } else if (cacheControl.includes('no-store') || cacheControl.includes('no-cache')) {
-        this.addEvidence({
-          type: 'log',
-          path: '',
-          description: `Cache-Control: ${cacheControl} — caching is disabled`,
-        });
-      }
-
-      // Log response details
-      this.addEvidence({
-        type: 'log',
-        path: '',
-        description: `Response time: ${responseTime}ms, Status: ${response.status}`,
-      });
-    } catch (fetchError) {
-      findings.push({
-        id: `${this.agentId}-fetch-failed`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'dns-cdn-tester',
-        description: `Failed to reach ${this.baseUrl}: ${fetchError instanceof Error ? fetchError.message.split('\n')[0] : String(fetchError)}`,
-      });
-    }
-
-    return findings;
-  }
-}

package/agents/61-docker-health-checker.ts

@@ -1,111 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-
-export class DockerHealthCheckerAgent extends BaseAgent {
-  readonly agentId = 61;
-  readonly agentName = 'Docker Health Checker';
-
-  protected async preFlight(): Promise<void> {
-    // No network dependencies — file-based agent
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const projectRoot = this.config.projectRoot ?? process.cwd();
-
-    // Check Dockerfile
-    const dockerfilePath = path.join(projectRoot, 'Dockerfile');
-    const dockerfileExists = fs.existsSync(dockerfilePath);
-
-    if (!dockerfileExists) {
-      findings.push({
-        id: `${this.agentId}-no-dockerfile`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'docker-health-checker',
-        description: 'No Dockerfile found in project root',
-      });
-      return findings;
-    }
-
-    const dockerfileContent = fs.readFileSync(dockerfilePath, 'utf-8');
-    const lines = dockerfileContent.split('\n');
-
-    // Check 1: USER root at end (security risk)
-    const lastUserLine = this.findLastDirective(lines, 'USER');
-    if (lastUserLine !== null && lastUserLine.toLowerCase().includes('root')) {
-      findings.push({
-        id: `${this.agentId}-user-root`,
-        type: 'code-bug-security',
-        severity: 'high',
-        agentId: this.agentId,
-        module: 'docker-health-checker',
-        file: dockerfilePath,
-        description: 'Dockerfile runs as root user — security risk',
-        suggestedFix: 'Add a non-root USER directive at the end of the Dockerfile',
-      });
-    }
-
-    // Check 2: Missing HEALTHCHECK
-    const hasHealthcheck = lines.some(line =>
-      line.trim().toUpperCase().startsWith('HEALTHCHECK'),
-    );
-
-    if (!hasHealthcheck) {
-      findings.push({
-        id: `${this.agentId}-no-healthcheck`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'docker-health-checker',
-        file: dockerfilePath,
-        description: 'Dockerfile missing HEALTHCHECK instruction',
-        suggestedFix: 'Add HEALTHCHECK CMD curl -f http://localhost:PORT/health || exit 1',
-      });
-    }
-
-    // Check 3: Missing .dockerignore
-    const dockerignorePath = path.join(projectRoot, '.dockerignore');
-    if (!fs.existsSync(dockerignorePath)) {
-      findings.push({
-        id: `${this.agentId}-no-dockerignore`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'docker-health-checker',
-        description: 'Missing .dockerignore file — build context may include unnecessary files',
-        suggestedFix: 'Create .dockerignore to exclude node_modules, .git, .env, etc.',
-      });
-    }
-
-    // Log Dockerfile size
-    const stats = fs.statSync(dockerfilePath);
-    this.addEvidence({
-      type: 'log',
-      path: dockerfilePath,
-      description: `Dockerfile: ${lines.length} lines, ${stats.size} bytes`,
-    });
-
-    return findings;
-  }
-
-  private findLastDirective(lines: string[], directive: string): string | null {
-    const upper = directive.toUpperCase();
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const trimmed = lines[i].trim();
-      if (trimmed.toUpperCase().startsWith(upper)) {
-        return trimmed;
-      }
-      // Skip empty lines and comments
-      if (trimmed.length > 0 && !trimmed.startsWith('#')) {
-        // Found a non-matching, non-empty, non-comment line
-        // Keep searching
-      }
-    }
-    return null;
-  }
-}

package/agents/62-env-config-validator.ts

@@ -1,152 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-
-/** Patterns for URL values. */
-const URL_PATTERN = /^https?:\/\/.+/;
-
-/** Patterns for port values. */
-const PORT_PATTERN = /^\d{1,5}$/;
-
-/** Common placeholder values that should be replaced. */
-const PLACEHOLDER_PATTERNS = [
-  'your-',
-  'change-me',
-  'TODO',
-  'FIXME',
-  'xxx',
-  'placeholder',
-  'example',
-  'changeme',
-  'replace-',
-  'set-this',
-] as const;
-
-export class EnvConfigValidatorAgent extends BaseAgent {
-  readonly agentId = 62;
-  readonly agentName = 'Env Config Validator';
-
-  protected async preFlight(): Promise<void> {
-    // File-based agent — no network dependencies
-  }
-
-  protected async execute(): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const projectRoot = this.config.projectRoot ?? process.cwd();
-
-    const envExamplePath = path.join(projectRoot, '.env.example');
-    const envPath = path.join(projectRoot, '.env');
-
-    const envExampleExists = fs.existsSync(envExamplePath);
-    const envExists = fs.existsSync(envPath);
-
-    if (!envExampleExists && !envExists) {
-      findings.push({
-        id: `${this.agentId}-no-env-files`,
-        type: 'infra-issue',
-        severity: 'low',
-        agentId: this.agentId,
-        module: 'env-config-validator',
-        description: 'No .env or .env.example file found in project root',
-      });
-      return findings;
-    }
-
-    const exampleKeys = envExampleExists ? this.parseEnvFile(envExamplePath) : new Map<string, string>();
-    const envKeys = envExists ? this.parseEnvFile(envPath) : new Map<string, string>();
-
-    // Compare keys: required in example but missing from .env
-    if (envExampleExists && envExists) {
-      for (const [key] of exampleKeys) {
-        if (!envKeys.has(key)) {
-          findings.push({
-            id: `${this.agentId}-missing-env-var-${key}`,
-            type: 'infra-issue',
-            severity: 'medium',
-            agentId: this.agentId,
-            module: 'env-config-validator',
-            description: `Required env var ${key} missing from .env (defined in .env.example)`,
-          });
-        }
-      }
-    }
-
-    // Validate .env values format
-    if (envExists) {
-      for (const [key, value] of envKeys) {
-        // Check URLs
-        const keyLower = key.toLowerCase();
-        if ((keyLower.includes('url') || keyLower.includes('uri') || keyLower.includes('endpoint')) && value.length > 0) {
-          if (!URL_PATTERN.test(value)) {
-            findings.push({
-              id: `${this.agentId}-invalid-url-${key}`,
-              type: 'infra-issue',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'env-config-validator',
-              description: `Env var ${key} looks like a URL key but value "${value}" is not a valid URL`,
-            });
-          }
-        }
-
-        // Check ports
-        if (keyLower.includes('port') && value.length > 0) {
-          if (!PORT_PATTERN.test(value)) {
-            findings.push({
-              id: `${this.agentId}-invalid-port-${key}`,
-              type: 'infra-issue',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'env-config-validator',
-              description: `Env var ${key} looks like a port key but value "${value}" is not a valid port number`,
-            });
-          }
-        }
-
-        // Check for placeholder values
-        for (const placeholder of PLACEHOLDER_PATTERNS) {
-          if (value.toLowerCase().includes(placeholder.toLowerCase())) {
-            findings.push({
-              id: `${this.agentId}-placeholder-${key}`,
-              type: 'infra-issue',
-              severity: 'low',
-              agentId: this.agentId,
-              module: 'env-config-validator',
-              description: `Env var ${key} appears to contain a placeholder value: "${value}"`,
-            });
-            break;
-          }
-        }
-      }
-    }
-
-    this.addEvidence({
-      type: 'log',
-      path: '',
-      description: `Checked ${exampleKeys.size} example keys, ${envKeys.size} env keys`,
-    });
-
-    return findings;
-  }
-
-  private parseEnvFile(filePath: string): Map<string, string> {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const result = new Map<string, string>();
-
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (trimmed.length === 0 || trimmed.startsWith('#')) continue;
-
-      const eqIndex = trimmed.indexOf('=');
-      if (eqIndex === -1) continue;
-
-      const key = trimmed.substring(0, eqIndex).trim();
-      const value = trimmed.substring(eqIndex + 1).trim().replace(/^["']|["']$/g, '');
-      result.set(key, value);
-    }
-
-    return result;
-  }
-}