@avi770/testteam 1.2.0 → 2.0.0

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

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

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

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

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

@@ -0,0 +1,152 @@
+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;
+  }
+}