@avi770/testteam 1.2.0 → 2.0.0

package/agents/63-log-quality-auditor.ts

@@ -0,0 +1,136 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+
+/** Glob-like manual scan for .ts files under src/. */
+function findTsFiles(dir: string, results: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return results;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git') {
+      findTsFiles(fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts') && !entry.name.endsWith('.spec.ts')) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+export class LogQualityAuditorAgent extends BaseAgent {
+  readonly agentId = 63;
+  readonly agentName = 'Log Quality Auditor';
+
+  protected async preFlight(): Promise<void> {
+    // File-based agent
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const srcDir = path.join(projectRoot, 'src');
+
+    if (!fs.existsSync(srcDir)) {
+      findings.push({
+        id: `${this.agentId}-no-src-dir`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'log-quality-auditor',
+        description: 'No src/ directory found in project root',
+      });
+      return findings;
+    }
+
+    const tsFiles = findTsFiles(srcDir);
+    let consoleLogCount = 0;
+    let consoleErrorWithoutContextCount = 0;
+    let hasStructuredLogging = false;
+
+    for (const filePath of tsFiles) {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+
+      // Check for structured logging libraries
+      if (content.includes('winston') || content.includes('pino') || content.includes('bunyan') || content.includes('log4js')) {
+        hasStructuredLogging = true;
+      }
+
+      for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+        const line = lines[lineNum];
+
+        // Check for console.log
+        if (/console\.log\(/.test(line)) {
+          consoleLogCount++;
+          if (consoleLogCount <= 5) {
+            findings.push({
+              id: `${this.agentId}-console-log-${consoleLogCount}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: 'log-quality-auditor',
+              file: filePath,
+              line: lineNum + 1,
+              description: `console.log() found — use structured logging instead`,
+            });
+          }
+        }
+
+        // Check for console.error without structured context
+        if (/console\.error\(/.test(line)) {
+          // Check if it's just a string (no object context)
+          if (/console\.error\(\s*['"`]/.test(line) || /console\.error\(\s*[^{]/.test(line)) {
+            consoleErrorWithoutContextCount++;
+            if (consoleErrorWithoutContextCount <= 3) {
+              findings.push({
+                id: `${this.agentId}-unstructured-error-${consoleErrorWithoutContextCount}`,
+                type: 'test-bug',
+                severity: 'medium',
+                agentId: this.agentId,
+                module: 'log-quality-auditor',
+                file: filePath,
+                line: lineNum + 1,
+                description: 'console.error() without structured context — include error object or metadata',
+              });
+            }
+          }
+        }
+      }
+    }
+
+    // Summary findings
+    if (consoleLogCount > 5) {
+      findings.push({
+        id: `${this.agentId}-console-log-summary`,
+        type: 'test-bug',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'log-quality-auditor',
+        description: `${consoleLogCount} total console.log() calls found (showing first 5)`,
+      });
+    }
+
+    if (!hasStructuredLogging) {
+      findings.push({
+        id: `${this.agentId}-no-structured-logging`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'log-quality-auditor',
+        description: 'No structured logging library (winston, pino, bunyan) detected',
+        suggestedFix: 'Consider adopting a structured logging library like pino or winston',
+      });
+    }
+
+    this.addEvidence({
+      type: 'log',
+      path: '',
+      description: `Scanned ${tsFiles.length} TypeScript files: ${consoleLogCount} console.log, ${consoleErrorWithoutContextCount} unstructured console.error`,
+    });
+
+    return findings;
+  }
+}

package/agents/64-analytics-tracker-tester.ts

@@ -0,0 +1,165 @@
+import type { Browser, Page, Request } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { login } from '../helpers/navigation';
+
+/** Analytics domains to detect. */
+const ANALYTICS_DOMAINS = [
+  'google-analytics.com',
+  'www.google-analytics.com',
+  'analytics.google.com',
+  'segment.com',
+  'api.segment.io',
+  'cdn.segment.com',
+  'mixpanel.com',
+  'api.mixpanel.com',
+  'amplitude.com',
+  'api.amplitude.com',
+  'api2.amplitude.com',
+  'gtag',
+  'googletagmanager.com',
+] as const;
+
+export class AnalyticsTrackerTesterAgent extends BaseAgent {
+  readonly agentId = 64;
+  readonly agentName = 'Analytics Tracker Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('AnalyticsTrackerTesterAgent requires at least one module in config.modules');
+    }
+
+    const { env } = await resolveEnvironment(this.config, this.phase);
+    this.baseUrl = env.baseUrl;
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    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();
+
+      // Track analytics requests
+      const analyticsRequests: { url: string; module: string }[] = [];
+      const pageviewUrls: string[] = [];
+
+      page.on('request', (request: Request) => {
+        const url = request.url();
+        const isAnalytics = ANALYTICS_DOMAINS.some(domain => url.includes(domain));
+        if (isAnalytics) {
+          analyticsRequests.push({ url, module: 'unknown' });
+          if (url.includes('pageview') || url.includes('collect') || url.includes('/t?') || url.includes('/g/collect')) {
+            pageviewUrls.push(url);
+          }
+        }
+      });
+
+      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: 'analytics-tracker-tester',
+            description: 'Login failed — continuing anonymously',
+          });
+        }
+      }
+
+      // Navigate through modules
+      for (const mod of this.config.modules) {
+        const preNavCount = analyticsRequests.length;
+        const fullUrl = mod.route.startsWith('http')
+          ? mod.route
+          : `${this.baseUrl}${mod.route}`;
+
+        try {
+          await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+          await new Promise(resolve => setTimeout(resolve, 2_000));
+        } catch {
+          // Navigation failure — skip module
+          continue;
+        }
+
+        // Tag recent analytics requests with module
+        for (let i = preNavCount; i < analyticsRequests.length; i++) {
+          analyticsRequests[i].module = mod.id;
+        }
+      }
+
+      // Analyze results
+      if (analyticsRequests.length === 0) {
+        findings.push({
+          id: `${this.agentId}-no-analytics`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'analytics-tracker-tester',
+          description: 'No analytics tracking detected — no requests to analytics providers found',
+        });
+      }
+
+      // Check for duplicate pageviews
+      if (pageviewUrls.length > this.config.modules.length) {
+        findings.push({
+          id: `${this.agentId}-duplicate-pageviews`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'analytics-tracker-tester',
+          description: `${pageviewUrls.length} pageview events fired for ${this.config.modules.length} pages — possible duplicate tracking`,
+        });
+      }
+
+      // Report detected analytics
+      const uniqueDomains = new Set(
+        analyticsRequests.map(r => {
+          try {
+            return new URL(r.url).hostname;
+          } catch {
+            return r.url;
+          }
+        }),
+      );
+
+      if (uniqueDomains.size > 0) {
+        this.addEvidence({
+          type: 'log',
+          path: '',
+          description: `Analytics providers detected: ${Array.from(uniqueDomains).join(', ')}`,
+        });
+      }
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'analytics-tracker-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;
+  }
+}

package/agents/65-gdpr-compliance-tester.ts

@@ -0,0 +1,215 @@
+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';
+
+/** Keywords that indicate cookie consent banner. */
+const CONSENT_KEYWORDS = ['cookie', 'consent', 'privacy', 'gdpr', 'accept all', 'accept cookies'] as const;
+
+/** Common privacy policy link selectors. */
+const PRIVACY_LINK_SELECTORS = [
+  'a:has-text("Privacy")',
+  'a:has-text("Privacy Policy")',
+  'a[href*="privacy"]',
+  'a[href*="datenschutz"]',
+] as const;
+
+export class GdprComplianceTesterAgent extends BaseAgent {
+  readonly agentId = 65;
+  readonly agentName = 'GDPR Compliance 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[] = [];
+
+    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 });
+
+      // Test 1: Cookie consent banner (fresh context, no previous cookies)
+      const freshContext = await browser.newContext();
+      const freshPage = await freshContext.newPage();
+
+      try {
+        await freshPage.goto(this.baseUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+        await new Promise(resolve => setTimeout(resolve, 2_000));
+
+        const consentFindings = await this.checkCookieConsent(freshPage);
+        findings.push(...consentFindings);
+      } catch {
+        findings.push({
+          id: `${this.agentId}-nav-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'gdpr-compliance-tester',
+          description: 'Failed to navigate to base URL for GDPR testing',
+        });
+      }
+
+      await freshPage.close().catch(() => undefined);
+      await freshContext.close().catch(() => undefined);
+
+      // Test 2: Privacy policy link
+      const page = await browser.newPage();
+
+      try {
+        await page.goto(this.baseUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+
+        const privacyFindings = await this.checkPrivacyPolicy(page);
+        findings.push(...privacyFindings);
+      } catch {
+        // Already reported nav failure
+      }
+
+      // Test 3: Delete account option (requires login)
+      if (credentials) {
+        try {
+          await login(page, credentials, loginUrl);
+
+          const deleteAccountFindings = await this.checkDeleteAccount(page);
+          findings.push(...deleteAccountFindings);
+        } catch {
+          findings.push({
+            id: `${this.agentId}-login-failed`,
+            type: 'infra-issue',
+            severity: 'low',
+            agentId: this.agentId,
+            module: 'gdpr-compliance-tester',
+            description: 'Login failed — cannot check delete account option',
+          });
+        }
+      }
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'gdpr-compliance-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 checkCookieConsent(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const bodyText = await page.evaluate(() => document.body.innerText.toLowerCase());
+
+      const hasConsentText = CONSENT_KEYWORDS.some(keyword => bodyText.includes(keyword));
+
+      if (!hasConsentText) {
+        findings.push({
+          id: `${this.agentId}-no-cookie-consent`,
+          type: 'code-bug-security',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'gdpr-compliance-tester',
+          description: 'No cookie consent banner detected on first visit',
+          suggestedFix: 'Implement a cookie consent banner that appears on first visit',
+        });
+      } else {
+        // Check for accept button
+        const acceptBtn = await page.locator('button:has-text("Accept"), button:has-text("Agree"), button:has-text("OK"), button:has-text("Got it")').count();
+        if (acceptBtn === 0) {
+          findings.push({
+            id: `${this.agentId}-no-consent-button`,
+            type: 'code-bug-security',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: 'gdpr-compliance-tester',
+            description: 'Cookie consent text found but no accept/agree button detected',
+          });
+        }
+      }
+    } catch {
+      // Evaluation failed
+    }
+
+    return findings;
+  }
+
+  private async checkPrivacyPolicy(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const selector = PRIVACY_LINK_SELECTORS.join(', ');
+    const privacyLinkCount = await page.locator(selector).count();
+
+    if (privacyLinkCount === 0) {
+      findings.push({
+        id: `${this.agentId}-no-privacy-policy`,
+        type: 'code-bug-security',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'gdpr-compliance-tester',
+        description: 'No privacy policy link found on the page',
+        suggestedFix: 'Add a privacy policy link accessible from the main page',
+      });
+    }
+
+    return findings;
+  }
+
+  private async checkDeleteAccount(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    // Try settings/account pages
+    const settingsRoutes = ['/settings', '/account', '/profile', '/settings/account'];
+
+    for (const route of settingsRoutes) {
+      try {
+        await page.goto(`${this.baseUrl}${route}`, { waitUntil: 'domcontentloaded', timeout: 5_000 });
+
+        const deleteText = await page.evaluate(() => {
+          const body = document.body.innerText.toLowerCase();
+          return body.includes('delete account') || body.includes('remove account') || body.includes('close account');
+        });
+
+        if (deleteText) {
+          this.addEvidence({
+            type: 'log',
+            path: '',
+            description: `Delete account option found at ${route}`,
+          });
+          return findings;
+        }
+      } catch {
+        // Route not found — try next
+      }
+    }
+
+    findings.push({
+      id: `${this.agentId}-no-delete-account`,
+      type: 'test-bug',
+      severity: 'medium',
+      agentId: this.agentId,
+      module: 'gdpr-compliance-tester',
+      description: 'No "Delete account" option found in settings — GDPR right to erasure may not be accessible',
+    });
+
+    return findings;
+  }
+}