@avi770/testteam 1.2.0 → 2.0.0

package/agents/43-data-consistency-checker.ts

@@ -0,0 +1,205 @@
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { ApiClient } from '../helpers/api-client';
+
+const REQUEST_TIMEOUT_MS = 10_000;
+
+export class DataConsistencyCheckerAgent extends BaseAgent {
+  readonly agentId = 43;
+  readonly agentName = 'Data Consistency Checker';
+  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 credentials =
+      this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    let client: ApiClient;
+
+    if (credentials) {
+      try {
+        client = await Promise.race([
+          ApiClient.createAuthenticated(this.baseUrl, credentials),
+          new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error('Auth timeout')), REQUEST_TIMEOUT_MS),
+          ),
+        ]);
+      } catch (authError) {
+        findings.push({
+          id: `${this.agentId}-auth-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'data-consistency',
+          description: `Authentication failed: ${authError instanceof Error ? authError.message.split('\n')[0] : String(authError)}`,
+        });
+        return findings;
+      }
+    } else {
+      client = new ApiClient(this.baseUrl);
+    }
+
+    // Test CRUD consistency for each module
+    const endpoints = this.config.modules.map(m => `/api${m.route}`);
+
+    for (const endpoint of endpoints) {
+      const endpointFindings = await this.testCrudConsistency(client, endpoint);
+      findings.push(...endpointFindings);
+    }
+
+    return findings;
+  }
+
+  private async testCrudConsistency(client: ApiClient, endpoint: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const testData = { name: `consistency-test-${Date.now()}`, test: true };
+
+    // Step 1: Create
+    let createdId: string | null = null;
+    try {
+      const createResponse = await Promise.race([
+        client.post(endpoint, testData),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      if (createResponse.status >= 200 && createResponse.status < 300) {
+        const body = createResponse.body as Record<string, unknown>;
+        createdId = String(body?.id ?? body?.['_id'] ?? '');
+      } else {
+        findings.push({
+          id: `${this.agentId}-create-failed-${endpoint.replace(/\//g, '_')}`,
+          type: 'infra-issue',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'data-consistency',
+          description: `Cannot test consistency — create returned ${createResponse.status} for ${endpoint}`,
+        });
+        return findings;
+      }
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-create-error-${endpoint.replace(/\//g, '_')}`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'data-consistency',
+        description: `Cannot test consistency — create failed for ${endpoint}: ${error instanceof Error ? error.message : String(error)}`,
+      });
+      return findings;
+    }
+
+    if (!createdId) {
+      return findings;
+    }
+
+    // Step 2: Read back and compare
+    try {
+      const readResponse = await Promise.race([
+        client.get(`${endpoint}/${createdId}`),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      if (readResponse.status === 200) {
+        const body = readResponse.body as Record<string, unknown>;
+        if (body.name !== testData.name) {
+          findings.push({
+            id: `${this.agentId}-read-mismatch-${endpoint.replace(/\//g, '_')}`,
+            type: 'code-bug-logic',
+            severity: 'high',
+            agentId: this.agentId,
+            module: 'data-consistency',
+            description: `Data mismatch after create+read for ${endpoint}: expected name="${testData.name}", got name="${body.name}"`,
+          });
+        }
+      } else {
+        findings.push({
+          id: `${this.agentId}-read-failed-${endpoint.replace(/\//g, '_')}`,
+          type: 'code-bug-logic',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'data-consistency',
+          description: `Read after create returned ${readResponse.status} for ${endpoint}/${createdId}`,
+        });
+      }
+    } catch {
+      // Read failed
+    }
+
+    // Step 3: Update and verify
+    const updatedName = `updated-${Date.now()}`;
+    try {
+      await Promise.race([
+        client.put(`${endpoint}/${createdId}`, { name: updatedName }),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      const verifyResponse = await Promise.race([
+        client.get(`${endpoint}/${createdId}`),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      if (verifyResponse.status === 200) {
+        const body = verifyResponse.body as Record<string, unknown>;
+        if (body.name !== updatedName) {
+          findings.push({
+            id: `${this.agentId}-update-mismatch-${endpoint.replace(/\//g, '_')}`,
+            type: 'code-bug-logic',
+            severity: 'high',
+            agentId: this.agentId,
+            module: 'data-consistency',
+            description: `Data mismatch after update for ${endpoint}: expected name="${updatedName}", got name="${body.name}"`,
+          });
+        }
+      }
+    } catch {
+      // Update flow failed
+    }
+
+    // Step 4: Delete and verify 404
+    try {
+      await Promise.race([
+        client.delete(`${endpoint}/${createdId}`),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      const deleteVerify = await Promise.race([
+        client.get(`${endpoint}/${createdId}`),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      if (deleteVerify.status !== 404) {
+        findings.push({
+          id: `${this.agentId}-delete-not-404-${endpoint.replace(/\//g, '_')}`,
+          type: 'code-bug-logic',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'data-consistency',
+          description: `After delete, GET ${endpoint}/${createdId} returned ${deleteVerify.status} instead of 404`,
+        });
+      }
+    } catch {
+      // Delete flow failed
+    }
+
+    return findings;
+  }
+}

package/agents/44-backup-recovery-tester.ts

@@ -0,0 +1,152 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+
+const execFileAsync = promisify(execFile);
+const EXEC_TIMEOUT_MS = 30_000;
+
+export class BackupRecoveryTesterAgent extends BaseAgent {
+  readonly agentId = 44;
+  readonly agentName = 'Backup Recovery Tester';
+
+  protected async preFlight(): Promise<void> {
+    // No special pre-conditions
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const projectRoot = this.config.projectRoot ?? process.cwd();
+    const schemaPath = join(projectRoot, 'prisma', 'schema.prisma');
+
+    // Check if prisma schema exists
+    try {
+      await stat(schemaPath);
+    } catch {
+      findings.push({
+        id: `${this.agentId}-no-prisma-schema`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'backup-recovery',
+        description: `No prisma/schema.prisma found in ${projectRoot} — skipping database recovery tests`,
+      });
+      return findings;
+    }
+
+    // Test 1: Schema pull verification
+    const schemaFindings = await this.testSchemaPull(projectRoot);
+    findings.push(...schemaFindings);
+
+    // Test 2: Migration status
+    const migrationFindings = await this.testMigrationStatus(projectRoot);
+    findings.push(...migrationFindings);
+
+    return findings;
+  }
+
+  private async testSchemaPull(projectRoot: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const { stdout, stderr } = await execFileAsync(
+        'npx',
+        ['prisma', 'db', 'pull', '--print'],
+        { cwd: projectRoot, timeout: EXEC_TIMEOUT_MS },
+      );
+
+      if (stderr && stderr.includes('Error')) {
+        findings.push({
+          id: `${this.agentId}-schema-pull-error`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'backup-recovery',
+          description: `prisma db pull reported errors: ${stderr.split('\n')[0]}`,
+        });
+      }
+
+      this.addEvidence({
+        type: 'report',
+        path: 'prisma-schema-pull',
+        description: `prisma db pull --print completed (${stdout.length} chars of schema output)`,
+      });
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-schema-pull-failed`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'backup-recovery',
+        description: `prisma db pull failed: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+
+    return findings;
+  }
+
+  private async testMigrationStatus(projectRoot: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      let stdout = '';
+      let stderr = '';
+      try {
+        const result = await execFileAsync(
+          'npx',
+          ['prisma', 'migrate', 'status'],
+          { cwd: projectRoot, timeout: EXEC_TIMEOUT_MS },
+        );
+        stdout = result.stdout;
+        stderr = result.stderr;
+      } catch (execError) {
+        const err = execError as { stdout?: string; stderr?: string };
+        stdout = err.stdout ?? '';
+        stderr = err.stderr ?? '';
+      }
+
+      const output = `${stdout}\n${stderr}`;
+
+      if (output.includes('pending') || output.includes('not yet applied')) {
+        findings.push({
+          id: `${this.agentId}-pending-migrations`,
+          type: 'infra-issue',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'backup-recovery',
+          description: 'Pending database migrations detected — schema may be out of sync with production',
+        });
+      }
+
+      if (output.includes('drift') || output.includes('modified')) {
+        findings.push({
+          id: `${this.agentId}-schema-drift`,
+          type: 'infra-issue',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'backup-recovery',
+          description: 'Database schema drift detected — production database differs from migration history',
+        });
+      }
+
+      this.addEvidence({
+        type: 'report',
+        path: 'prisma-migrate-status',
+        description: `prisma migrate status output: ${output.substring(0, 200)}`,
+      });
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-migration-status-error`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'backup-recovery',
+        description: `prisma migrate status failed: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+
+    return findings;
+  }
+}

package/agents/45-data-privacy-scanner.ts

@@ -0,0 +1,125 @@
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { ApiClient } from '../helpers/api-client';
+
+const REQUEST_TIMEOUT_MS = 10_000;
+
+interface PiiPattern {
+  name: string;
+  regex: RegExp;
+}
+
+const PII_PATTERNS: PiiPattern[] = [
+  { name: 'Email', regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g },
+  { name: 'Phone', regex: /(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}/g },
+  { name: 'SSN', regex: /\d{3}-\d{2}-\d{4}/g },
+  { name: 'Credit Card', regex: /\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}/g },
+];
+
+export class DataPrivacyScannerAgent extends BaseAgent {
+  readonly agentId = 45;
+  readonly agentName = 'Data Privacy Scanner';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('DataPrivacyScannerAgent 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 credentials =
+      this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    let client: ApiClient;
+
+    if (credentials) {
+      try {
+        client = await Promise.race([
+          ApiClient.createAuthenticated(this.baseUrl, credentials),
+          new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error('Auth timeout')), REQUEST_TIMEOUT_MS),
+          ),
+        ]);
+      } catch (authError) {
+        findings.push({
+          id: `${this.agentId}-auth-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'data-privacy',
+          description: `Authentication failed: ${authError instanceof Error ? authError.message.split('\n')[0] : String(authError)}`,
+        });
+        return findings;
+      }
+    } else {
+      client = new ApiClient(this.baseUrl);
+    }
+
+    const endpoints = this.config.modules.map(m => `/api${m.route}`);
+
+    for (const endpoint of endpoints) {
+      const endpointFindings = await this.scanEndpointForPii(client, endpoint);
+      findings.push(...endpointFindings);
+    }
+
+    return findings;
+  }
+
+  private async scanEndpointForPii(client: ApiClient, endpoint: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const response = await Promise.race([
+        client.get(endpoint),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), REQUEST_TIMEOUT_MS),
+        ),
+      ]);
+
+      if (response.status !== 200) {
+        return findings;
+      }
+
+      const responseText = JSON.stringify(response.body);
+
+      for (const pattern of PII_PATTERNS) {
+        pattern.regex.lastIndex = 0;
+        const matches = responseText.match(pattern.regex);
+
+        if (matches && matches.length > 0) {
+          findings.push({
+            id: `${this.agentId}-unmasked-${pattern.name.toLowerCase()}-${endpoint.replace(/\//g, '_')}`,
+            type: 'code-bug-security',
+            severity: 'high',
+            agentId: this.agentId,
+            module: 'data-privacy',
+            description: `Unmasked ${pattern.name} found in response from ${endpoint} (${matches.length} occurrence(s))`,
+          });
+        }
+      }
+
+      this.addEvidence({
+        type: 'log',
+        path: `pii-scan-${endpoint.replace(/\//g, '_')}`,
+        description: `PII scan for ${endpoint}: response size=${responseText.length} chars`,
+      });
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-scan-error-${endpoint.replace(/\//g, '_')}`,
+        type: 'infra-issue',
+        severity: 'low',
+        agentId: this.agentId,
+        module: 'data-privacy',
+        description: `Failed to scan ${endpoint}: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+
+    return findings;
+  }
+}