Antigravity × AI-Driven Security Audit Automation— Building an Agent Pipeline That Detects and Fixes Vulnerabilities

# Security Audit Manager
 
You are the security audit orchestrator.
Manage the three specialized agents below and produce a comprehensive security report.
 
## Delegation Rules
1. Delegate dependency vulnerability checks to `dependency-scanner`
2. Delegate source code security reviews to `code-reviewer`
3. Delegate infrastructure and environment audits to `infra-checker`
4. Aggregate all results into a severity-sorted report
 
---
 
# dependency-scanner
 
You are a dependency security specialist.
- Analyze package.json and package-lock.json
- Cross-reference against known CVE databases
- Check if patched versions are available
- Classify severity as Critical / High / Medium / Low
 
---
 
# code-reviewer
 
You are an application security specialist.
Review source code against the OWASP Top 10:
- SQL Injection
- Cross-Site Scripting (XSS)
- Broken Authentication & Authorization
- Hardcoded Secrets
- Insecure Deserialization
 
---
 
# infra-checker
 
You are an infrastructure security specialist.
- Verify environment variable management
- Validate CORS configuration
- Confirm HTTPS enforcement
- Audit security headers (CSP, HSTS, etc.)

// scripts/security-audit.ts
// Automated security audit execution script
 
import { execSync } from "child_process";
import * as fs from "fs";
 
interface AuditVulnerability {
  name: string;
  severity: "critical" | "high" | "moderate" | "low";
  title: string;
  url: string;
  fixAvailable: boolean;
}
 
function runDependencyAudit(): AuditVulnerability[] {
  try {
    // Run npm audit in JSON format
    const result = execSync("npm audit --json", {
      encoding: "utf-8",
      timeout: 30000,
    });
    const audit = JSON.parse(result);
 
    return Object.entries(audit.vulnerabilities || {}).map(
      ([name, data]: [string, any]) => ({
        name,
        severity: data.severity,
        title: data.title || "Unknown vulnerability",
        url: data.url || "",
        fixAvailable: !!data.fixAvailable,
      })
    );
  } catch (error: any) {
    // npm audit exits with code 1 when vulnerabilities are found
    if (error.stdout) {
      const audit = JSON.parse(error.stdout);
      return Object.entries(audit.vulnerabilities || {}).map(
        ([name, data]: [string, any]) => ({
          name,
          severity: data.severity,
          title: data.title || "Unknown vulnerability",
          url: data.url || "",
          fixAvailable: !!data.fixAvailable,
        })
      );
    }
    throw error;
  }
}
 
// Execute and output results
const vulnerabilities = runDependencyAudit();
const critical = vulnerabilities.filter((v) => v.severity === "critical");
const high = vulnerabilities.filter((v) => v.severity === "high");
 
console.log(`\n🔍 Dependency Security Report`);
console.log(`${"=".repeat(50)}`);
console.log(`Critical: ${critical.length}`);
console.log(`High: ${high.length}`);
console.log(`Total: ${vulnerabilities.length}`);
 
// Expected output:
// 🔍 Dependency Security Report
// ==================================================
// Critical: 0
// High: 2
// Total: 8

## Dependency Vulnerability Report
 
| Package   | Severity | CVE       | Reachable?              | Fixed In | Action                    |
|-----------|----------|-----------|-------------------------|----------|---------------------------|
| lodash    | High     | (CVE id)  | Direct dep, call path   | 4.17.22  | `npm update lodash`       |
| express   | Medium   | (CVE id)  | Transitive, no path     | 4.19.3   | Absorb in next bump cycle |

// lib/security-patterns.ts
// Security pattern detection library
 
export const SQL_INJECTION_PATTERNS = [
  // String concatenation in queries (dangerous)
  /`SELECT.*\$\{.*\}`/g,
  /['"]SELECT.*['"] \+ /g,
  /query\(.*\+.*\)/g,
 
  // Direct template literal interpolation (dangerous)
  /\.query\(`[^`]*\$\{[^}]+\}[^`]*`\)/g,
 
  // eval or Function constructor (extremely dangerous)
  /eval\s*\(/g,
  /new\s+Function\s*\(/g,
] as const;
 
export const XSS_PATTERNS = [
  // Unsanitized input to innerHTML
  /\.innerHTML\s*=\s*(?!['"`])/g,
  // dangerouslySetInnerHTML (React)
  /dangerouslySetInnerHTML\s*=\s*\{\s*\{\s*__html:\s*(?!DOMPurify)/g,
  // document.write
  /document\.write\s*\(/g,
] as const;
 
export const AUTH_PATTERNS = [
  // Hardcoded secrets
  /(?:password|secret|api[_-]?key|token)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
  // Skipping JWT verification
  /verify\s*:\s*false/g,
] as const;
 
// Math.random() is genuinely unsafe for token generation — but it matches just
// as often in animation jitter, retry backoff, and shuffle logic. Mixing it into
// critical buries the findings that actually matter, so it gets its own bucket.
export const WEAK_RANDOM_PATTERNS = [
  /Math\.random\(\)/g,
] as const;
 
/**
 * Scan a file for security issues
 */
export function scanFile(
  content: string,
  filePath: string
): SecurityIssue[] {
  const issues: SecurityIssue[] = [];
  const lineStarts = buildLineIndex(content);
 
  for (const rule of RULES) {
    for (const pattern of rule.patterns) {
      // matchAll requires the g flag. Clone so we never dirty the source
      // regex's lastIndex between files.
      const re = new RegExp(
        pattern.source,
        pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g"
      );
      for (const match of content.matchAll(re)) {
        issues.push({
          type: rule.type,
          severity: rule.severity,
          file: filePath,
          line: lineFromIndex(lineStarts, match.index!),
          message: rule.message,
          recommendation: rule.recommendation,
        });
      }
    }
  }
 
  const order = { critical: 0, high: 1, medium: 2, low: 3 } as const;
  return issues.sort((a, b) => order[a.severity] - order[b.severity]);
}
 
interface SecurityIssue {
  type: string;
  severity: "critical" | "high" | "medium" | "low";
  file: string;
  line: number;
  message: string;
  recommendation: string;
}
 
/** Rule table. Adding a check should be a one-line change. */
const RULES = [
  {
    patterns: SQL_INJECTION_PATTERNS,
    type: "SQL_INJECTION",
    severity: "critical",
    message: "Unsanitized input directly interpolated in SQL query",
    recommendation: "Use parameterized queries or an ORM instead",
  },
  {
    patterns: XSS_PATTERNS,
    type: "XSS",
    severity: "high",
    message: "Unsanitized input may be injected into the DOM",
    recommendation: "Use DOMPurify or text nodes instead",
  },
  {
    // Forget to wire this in and hardcoded secrets sail straight through
    patterns: AUTH_PATTERNS,
    type: "AUTH",
    severity: "critical",
    message: "Hardcoded credentials or skipped verification suspected",
    recommendation: "Move to environment variables and re-enable verification",
  },
  {
    patterns: WEAK_RANDOM_PATTERNS,
    type: "WEAK_RANDOM",
    severity: "low",
    message: "Math.random() is not cryptographically secure",
    recommendation:
      "For tokens use crypto.randomUUID() or randomBytes(). For visual effects, ignore this.",
  },
] as const satisfies readonly {
  patterns: readonly RegExp[];
  type: string;
  severity: SecurityIssue["severity"];
  message: string;
  recommendation: string;
}[];
 
/** Index newline offsets once, then binary-search for the line number. */
function buildLineIndex(content: string): number[] {
  const starts = [0];
  for (let i = 0; i < content.length; i++) {
    if (content[i] === "\n") starts.push(i + 1);
  }
  return starts;
}
 
function lineFromIndex(starts: number[], pos: number): number {
  let lo = 0;
  let hi = starts.length - 1;
  while (lo < hi) {
    const mid = (lo + hi + 1) >> 1;
    if (starts[mid] <= pos) lo = mid;
    else hi = mid - 1;
  }
  return lo + 1;
}
 
// Actual run against a 4-line sample, sorted by severity:
// critical SQL_INJECTION  line 1
// critical AUTH           line 2
// high     XSS            line 3
// low      WEAK_RANDOM    line 4

// scripts/check-security-headers.ts
// Validates security headers for a web application
 
interface SecurityHeaderCheck {
  header: string;
  expected: string | RegExp;
  severity: "critical" | "high" | "medium";
  description: string;
}
 
const REQUIRED_HEADERS: SecurityHeaderCheck[] = [
  {
    header: "Strict-Transport-Security",
    expected: /max-age=\d{8,}/,
    severity: "critical",
    description: "HSTS: Enforce HTTPS (max-age of at least 1 year recommended)",
  },
  {
    header: "Content-Security-Policy",
    expected: /default-src/,
    severity: "high",
    description: "CSP: Defend against XSS and data injection attacks",
  },
  {
    header: "X-Content-Type-Options",
    expected: "nosniff",
    severity: "medium",
    description: "Prevent MIME-type sniffing",
  },
  {
    header: "X-Frame-Options",
    expected: /DENY|SAMEORIGIN/,
    severity: "medium",
    description: "Prevent clickjacking attacks",
  },
  {
    header: "Referrer-Policy",
    expected: /strict-origin|no-referrer/,
    severity: "medium",
    description: "Prevent referrer information leakage",
  },
];
 
async function checkSecurityHeaders(url: string): Promise<number> {
  // GET, not HEAD. If CSP is attached on the HTML-rendering path,
  // a HEAD request skips that path entirely and reports "not set."
  const response = await fetch(url, { method: "GET" });
  await response.arrayBuffer(); // Discard the body, but drain it to free the socket
 
  console.log(`\n🛡️ Security Headers Audit: ${url}`);
  console.log("=".repeat(60));
 
  let issues = 0;
 
  for (const check of REQUIRED_HEADERS) {
    const value = response.headers.get(check.header);
    const passed = value
      ? typeof check.expected === "string"
        ? value === check.expected
        : check.expected.test(value)
      : false;
 
    const status = passed ? "✅" : "❌";
    console.log(`${status} ${check.header}`);
 
    if (!passed) {
      console.log(`   Severity: ${check.severity}`);
      console.log(`   ${check.description}`);
      console.log(`   Current value: ${value || "(not set)"}`);
      issues++;
    }
  }
 
  console.log(`\nTotal: ${issues} issue(s) found`);
  return issues;
}
 
// CI entry point. Read TARGET_URL and exit non-zero on findings —
// without this, the job always passes no matter what it finds.
const targetUrl = process.env.TARGET_URL;
if (!targetUrl) {
  console.error("TARGET_URL is not set");
  process.exit(2);
}
const found = await checkSecurityHeaders(targetUrl);
process.exit(found > 0 ? 1 : 0);
 
// Expected output:
// 🛡️ Security Headers Audit: https://your-app.example.com
// ============================================================
// ✅ Strict-Transport-Security
// ❌ Content-Security-Policy
//    Severity: high
//    CSP: Defend against XSS and data injection attacks
//    Current value: (not set)
// ✅ X-Content-Type-Options
// ✅ X-Frame-Options
// ✅ Referrer-Policy
//
// Total: 1 issue(s) found

// csp-head-vs-get.mjs — headers can differ between HEAD and GET
import http from "node:http";
 
const srv = http.createServer((req, res) => {
  const headers = {
    "Strict-Transport-Security": "max-age=31536000",
    "X-Content-Type-Options": "nosniff",
  };
  // Mimics a setup that attaches CSP only on the HTML-rendering path
  if (req.method === "GET") headers["Content-Security-Policy"] = "default-src 'self'";
  res.writeHead(200, headers);
  res.end(req.method === "GET" ? "<html></html>" : undefined);
});
 
await new Promise((r) => srv.listen(0, r));
const url = `http://127.0.0.1:${srv.address().port}/`;
 
for (const method of ["HEAD", "GET"]) {
  const r = await fetch(url, { method });
  if (method === "GET") await r.arrayBuffer();
  console.log(method.padEnd(4), "CSP =", r.headers.get("content-security-policy") ?? "(reported as not set)");
}
srv.close();
 
// Output:
// HEAD CSP = (reported as not set)
// GET  CSP = default-src 'self'

// scripts/check-env-security.ts
// Audits environment variable management and secret handling
 
import * as fs from "fs";
import * as path from "path";
import { execSync } from "child_process";
 
const SENSITIVE_PATTERNS = [
  /API[_-]?KEY/i,
  /SECRET/i,
  /PASSWORD/i,
  /TOKEN/i,
  /PRIVATE[_-]?KEY/i,
  /DATABASE[_-]?URL/i,
  /STRIPE[_-]?SECRET/i,
];
 
function auditEnvSecurity(projectRoot: string): number {
  const issues: string[] = [];
 
  // Check .gitignore. A naive includes(".env") also matches ".env.example",
  // so an unprotected repo reports as safe. Match whole lines instead.
  const gitignorePath = path.join(projectRoot, ".gitignore");
  const ignoredLines = fs.existsSync(gitignorePath)
    ? fs
        .readFileSync(gitignorePath, "utf-8")
        .split("\n")
        .map((l) => l.trim())
    : [];
  const envIgnored = ignoredLines.some((l) =>
    [".env", ".env*", "*.env", ".env.local"].includes(l)
  );
  if (!envIgnored) {
    issues.push("⚠️ CRITICAL: .env is not ignored by .gitignore");
  }
 
  // Stronger evidence than .gitignore: what git is actually tracking.
  // Adding a .gitignore rule after the fact does not untrack existing files.
  const tracked = execSync("git ls-files", { cwd: projectRoot, encoding: "utf-8" })
    .split("\n")
    .filter((f) => /(^|\/)\.env($|\.)/.test(f) && !/\.example$/.test(f));
  for (const f of tracked) {
    issues.push(`🚨 CRITICAL: ${f} is tracked by git (needs history rewrite)`);
  }
 
  // Scan source code for hardcoded secrets
  const srcDir = path.join(projectRoot, "src");
  if (fs.existsSync(srcDir)) {
    scanDirectory(srcDir, issues);
  }
 
  console.log("\n🔐 Environment Variable Security Audit");
  console.log("=".repeat(50));
 
  if (issues.length === 0) {
    console.log("✅ No issues detected");
  } else {
    issues.forEach((issue) => console.log(issue));
  }
  return issues.length;
}
 
function scanDirectory(dir: string, issues: string[]): void {
  const files = fs.readdirSync(dir, { withFileTypes: true });
 
  for (const file of files) {
    const fullPath = path.join(dir, file.name);
 
    if (file.isDirectory() && file.name !== "node_modules") {
      scanDirectory(fullPath, issues);
    } else if (
      file.isFile() &&
      /\.(ts|js|tsx|jsx)$/.test(file.name)
    ) {
      const content = fs.readFileSync(fullPath, "utf-8");
      const lines = content.split("\n");
 
      lines.forEach((line, index) => {
        SENSITIVE_PATTERNS.forEach((pattern) => {
          if (
            pattern.test(line) &&
            /['"][^'"]{8,}['"]/.test(line)
          ) {
            issues.push(
              `⚠️ HIGH: ${fullPath}:${index + 1} — ` +
                `Possible hardcoded secret detected`
            );
          }
        });
      });
    }
  }
}
 
// CI entry point. Exit non-zero when anything is found.
process.exit(auditEnvSecurity(process.cwd()) > 0 ? 1 : 0);
 
// Output:
// 🔐 Environment Variable Security Audit
// ==================================================
// ⚠️ HIGH: src/config/database.ts:15 — Possible hardcoded secret detected
// 🚨 CRITICAL: .env.local is tracked by git (needs history rewrite)

# .github/workflows/security-audit.yml
name: Security Audit
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
  schedule:
    # Run weekly on Mondays at 9:00 JST
    - cron: "0 0 * * 1"
 
jobs:
  dependency-scan:
    name: Dependency Vulnerability Scan
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Run npm audit
        run: |
          # --json exits non-zero when findings exist; absorb that on the report step
          npm audit --json > audit-report.json || true
          # Gate here. Adding `|| true` to this line means the job passes
          # no matter what the scan finds.
          npm audit --audit-level=high
 
      - name: Upload audit report
        uses: actions/upload-artifact@v4
        with:
          name: audit-report
          path: audit-report.json
 
  code-security-review:
    name: Code Security Review
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Run security pattern scan
        # Fails the job when scanFile returns anything at critical severity
        run: npx tsx scripts/security-audit.ts
 
      - name: Check for hardcoded secrets
        run: |
          # Detect hardcoded sensitive values
          if grep -rn \
            -e "API_KEY\s*=\s*['\"][^'\"]*['\"]" \
            -e "SECRET\s*=\s*['\"][^'\"]*['\"]" \
            --include="*.ts" --include="*.js" \
            --exclude-dir=node_modules \
            src/; then
            echo "::error::Hardcoded secrets detected!"
            exit 1
          fi
 
  security-headers:
    name: Security Headers Check
    runs-on: ubuntu-latest
    if: github.event_name == 'schedule'
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
 
      - run: npm ci
 
      - name: Check production security headers
        # The script reads TARGET_URL and returns 0 = clean / 1 = findings / 2 = unset
        run: npx tsx scripts/check-security-headers.ts
        env:
          TARGET_URL: ${{ secrets.PRODUCTION_URL }}

// Flagged: sort column interpolated into the query
const rows = await db.query(
  `SELECT * FROM wallpapers ORDER BY ${sortColumn} DESC LIMIT 50`
);

// Agent's proposal (does not work)
const rows = await db.query(
  "SELECT * FROM wallpapers ORDER BY $1 DESC LIMIT 50",
  [sortColumn]
);

const SORTABLE = {
  created: "created_at",
  downloads: "download_count",
  rating: "rating_avg",
} as const;
 
// Unknown keys fall back to the default; only vetted values reach the SQL
const column = SORTABLE[sortColumn as keyof typeof SORTABLE] ?? "created_at";
const rows = await db.query(
  `SELECT * FROM wallpapers ORDER BY ${column} DESC LIMIT 50`
);