auditai-scan 0.1.0

package/dist/auditai-scan.mjs

@@ -0,0 +1,1811 @@
+#!/usr/bin/env node
+
+// packages/scanner/src/bin.ts
+import { resolve as resolve3 } from "node:path";
+import { parseArgs } from "node:util";
+
+// packages/core/src/coverage.ts
+function summarizeCoverage(findings) {
+  const s = {
+    checked: findings.length,
+    verified: 0,
+    confirmed: 0,
+    unverified: 0,
+    candidates: 0,
+    suppressed: 0
+  };
+  for (const f of findings) {
+    switch (f.status) {
+      case "verified":
+        s.verified += 1;
+        break;
+      case "confirmed":
+      case "fix_proposed":
+      case "fix_applied":
+        s.confirmed += 1;
+        break;
+      case "unverified":
+        s.unverified += 1;
+        break;
+      case "suppressed":
+        s.suppressed += 1;
+        break;
+      case "candidate":
+      case "likely":
+        s.candidates += 1;
+        break;
+    }
+  }
+  return s;
+}
+function renderCoverageStatement(s, riskClass = "authorization/RLS") {
+  return `Checked ${s.checked} risk${s.checked === 1 ? "" : "s"} in class ${riskClass}. Verified: ${s.verified}. Confirmed (no sandbox): ${s.confirmed}. Unverified: ${s.unverified}.`;
+}
+
+// packages/core/src/finding.ts
+var FINDING_STATUSES = [
+  "candidate",
+  "likely",
+  "confirmed",
+  "unverified",
+  "fix_proposed",
+  "fix_applied",
+  "verified",
+  "suppressed"
+];
+var TRANSITIONS = {
+  candidate: ["likely", "unverified", "suppressed"],
+  likely: ["confirmed", "unverified", "suppressed"],
+  confirmed: ["fix_proposed", "suppressed"],
+  unverified: ["likely", "confirmed", "suppressed"],
+  fix_proposed: ["fix_applied", "confirmed", "suppressed"],
+  fix_applied: ["verified", "fix_proposed", "suppressed"],
+  verified: ["suppressed"],
+  suppressed: []
+};
+function canTransition(from, to) {
+  return TRANSITIONS[from].includes(to);
+}
+var IllegalTransitionError = class extends Error {
+  constructor(findingId, from, to) {
+    super(`Finding ${findingId}: illegal transition ${from} -> ${to}`);
+    this.findingId = findingId;
+    this.from = from;
+    this.to = to;
+  }
+  name = "IllegalTransitionError";
+};
+function transition(finding2, to, opts = {}) {
+  if (!canTransition(finding2.status, to)) {
+    throw new IllegalTransitionError(finding2.id, finding2.status, to);
+  }
+  const requiresEvidence = to === "confirmed" || to === "verified";
+  if (requiresEvidence && !opts.evidence) {
+    throw new Error(`Finding ${finding2.id}: transition to ${to} requires evidence`);
+  }
+  if (to === "verified" && !isVerificationPassing(finding2.verification)) {
+    throw new Error(`Finding ${finding2.id}: cannot mark verified without a passing verification`);
+  }
+  const evidence = opts.evidence ? [...finding2.evidence, opts.evidence] : finding2.evidence;
+  return {
+    ...finding2,
+    status: to,
+    evidence,
+    updatedAt: opts.now ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isVerificationPassing(v) {
+  return v !== void 0 && v.securityTestBefore === "failed" && v.securityTestAfter === "passed" && (v.existingTests === "passed" || v.existingTests === "skipped") && v.rescan === "passed";
+}
+function isDeterministic(finding2) {
+  return finding2.evidence.some((e) => e.kind === "rule" && e.data?.deterministic === true);
+}
+var DEFAULT_BLOCKING_POLICY = {
+  minConfidence: 0.8,
+  blockOnConfirmedSeverities: ["high", "critical"],
+  blockDeterministicCritical: true
+};
+var CONFIRMED_OR_LATER = ["confirmed", "fix_proposed", "fix_applied"];
+function isBlocking(finding2, policy = DEFAULT_BLOCKING_POLICY) {
+  if (finding2.status === "suppressed") return false;
+  if (finding2.status === "verified") return true;
+  if (finding2.confidence < policy.minConfidence) return false;
+  if (CONFIRMED_OR_LATER.includes(finding2.status) && policy.blockOnConfirmedSeverities.includes(finding2.severity)) {
+    return true;
+  }
+  if (policy.blockDeterministicCritical && finding2.severity === "critical" && isDeterministic(finding2) && finding2.status !== "unverified") {
+    return true;
+  }
+  return false;
+}
+
+// packages/scanner/src/format.ts
+function loc(f) {
+  const first = f.evidence.find((e) => e.locations && e.locations.length > 0)?.locations?.[0];
+  return first ? `${first.file}:${first.line}` : "";
+}
+function where(f) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of f.evidence) for (const l of e.locations ?? []) seen.add(`${l.file}:${l.line}`);
+  return [...seen].join(", ");
+}
+function formatFinding(f) {
+  const why = f.evidence.find((e) => e.kind === "rule")?.summary ?? "";
+  const lines = [
+    `${f.id}  ${f.status.toUpperCase()}  ${f.severity.toUpperCase()}  ${f.title}`,
+    `  Entry   ${f.entrypoints.join(", ")}   ${loc(f)}`,
+    `  Path    ${f.path.join(" -> ")}`,
+    `  Why     ${why}`,
+    `  Where   ${where(f)}`,
+    `  Rule    ${f.ruleId} \xB7 ${(f.cwe ?? []).join(", ")} \xB7 confidence ${f.confidence.toFixed(2)}`
+  ];
+  if (f.status === "suppressed") {
+    const s = [...f.evidence].reverse().find((e) => e.data?.suppressed === true);
+    if (s) lines.push(`  Ignored ${s.summary}`);
+  }
+  return lines.join("\n");
+}
+function formatScanText(r) {
+  const s = r.summary;
+  const out = [
+    `Audit AI scan  ${s.root}`,
+    `Files ${s.files} \xB7 Routes ${s.routes} \xB7 Supabase queries ${s.queries} \xB7 Tables with RLS ${s.tablesWithRls}/${s.tablesKnown} \xB7 Rules ${s.rules}`,
+    ""
+  ];
+  if (r.findings.length === 0) {
+    out.push(
+      `No findings. ${s.routes} route${s.routes === 1 ? "" : "s"} and ${s.queries} quer${s.queries === 1 ? "y" : "ies"} checked.`
+    );
+  } else {
+    for (const f of r.findings) out.push(formatFinding(f), "");
+  }
+  out.push("", r.coverageStatement);
+  const likely = r.findings.filter((f) => f.status === "likely" || f.status === "candidate").length;
+  if (likely > 0) {
+    out.push(
+      `${likely} likely finding${likely === 1 ? "" : "s"} need${likely === 1 ? "s" : ""} reasoning and verification (audit explain / audit verify, coming in later weeks).`
+    );
+  }
+  out.push(r.blocking ? "Blocking findings present." : "No blocking findings.");
+  for (const w of s.warnings) out.push(`warning: ${w}`);
+  return `${out.join("\n")}
+`;
+}
+
+// packages/scanner/src/scan.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// packages/graph/src/graph.ts
+var SecurityGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  addNode(node) {
+    const existing = this.nodes.get(node.id);
+    if (existing) return existing;
+    this.nodes.set(node.id, node);
+    return node;
+  }
+  addEdge(from, to, kind) {
+    if (!this.nodes.has(from) || !this.nodes.has(to))
+      throw new Error(`edge ${kind} references unknown node: ${from} -> ${to}`);
+    if (!this.edges.some((e) => e.from === from && e.to === to && e.kind === kind))
+      this.edges.push({ from, to, kind });
+  }
+  nodesOfKind(kind) {
+    return [...this.nodes.values()].filter((n) => n.kind === kind);
+  }
+  /** Targets of edges leaving `id`, optionally filtered by edge kind. */
+  out(id, kind) {
+    return this.edges.filter((e) => e.from === id && (kind === void 0 || e.kind === kind)).map((e) => this.nodes.get(e.to)).filter((n) => n !== void 0);
+  }
+  /** Sources of edges entering `id`, optionally filtered by edge kind. */
+  in(id, kind) {
+    return this.edges.filter((e) => e.to === id && (kind === void 0 || e.kind === kind)).map((e) => this.nodes.get(e.from)).filter((n) => n !== void 0);
+  }
+};
+function buildGraph(model) {
+  const g = new SecurityGraph();
+  const tableInfo = new Map(model.tables.map((t) => [t.table, t]));
+  const tableNode = (table) => {
+    const info = tableInfo.get(table.toLowerCase());
+    const data = {
+      table,
+      known: info !== void 0,
+      rlsEnabled: info?.rlsEnabled ?? false,
+      policies: info?.policies ?? [],
+      policyDetails: info?.policyDetails ?? [],
+      columns: info?.columns ?? []
+    };
+    const node = g.addNode(
+      info ? {
+        id: `table:${table}`,
+        kind: "Table",
+        label: `public.${table}`,
+        data: { ...data },
+        location: info.location
+      } : { id: `table:${table}`, kind: "Table", label: `public.${table}`, data: { ...data } }
+    );
+    for (const p of data.policies) {
+      const pn = g.addNode({
+        id: `policy:${table}:${p}`,
+        kind: "RLSPolicy",
+        label: p,
+        data: { table, name: p }
+      });
+      g.addEdge(node.id, pn.id, "GUARDED_BY");
+    }
+    return node;
+  };
+  for (const h of model.routes) {
+    const route = g.addNode({
+      id: `route:${h.entry}`,
+      kind: "Route",
+      label: h.entry,
+      data: { method: h.method, route: h.route, kind: h.kind }
+    });
+    const hd = {
+      kind: h.kind,
+      entry: h.entry,
+      method: h.method,
+      route: h.route,
+      inputs: h.inputs,
+      metadataAccesses: h.metadataAccesses
+    };
+    const handler = g.addNode({
+      id: `handler:${h.location.file}:${h.location.line}`,
+      kind: "Handler",
+      label: `${h.entry} handler`,
+      data: { ...hd },
+      location: h.location
+    });
+    g.addEdge(route.id, handler.id, "HANDLES");
+    for (const i of h.inputs) {
+      const s = g.addNode({
+        id: `source:${handler.id}:${i.kind}:${i.name}`,
+        kind: "Source",
+        label: `${i.kind}:${i.name}`,
+        data: { kind: i.kind, name: i.name },
+        location: i.location
+      });
+      g.addEdge(handler.id, s.id, "READS");
+    }
+    for (const a of h.authChecks) {
+      const an = g.addNode({
+        id: `auth:${a.file}:${a.line}`,
+        kind: "AuthCheck",
+        label: "auth check",
+        data: {},
+        location: a
+      });
+      g.addEdge(handler.id, an.id, "AUTHENTICATED_BY");
+    }
+    h.queries.forEach((q, i) => {
+      const qd = {
+        operation: q.operation,
+        filters: q.filters,
+        payload: q.payload,
+        text: q.text,
+        table: q.table
+      };
+      const qn = g.addNode({
+        id: `query:${q.location.file}:${q.location.line}:${i}`,
+        kind: "Query",
+        label: `${q.table}.${q.operation}`,
+        data: { ...qd },
+        location: q.location
+      });
+      g.addEdge(handler.id, qn.id, "CALLS");
+      const cd = { kind: q.client, name: q.clientName ?? "inline" };
+      const cn = g.addNode(
+        q.clientLocation ? {
+          id: `client:${cd.name}:${cd.kind}`,
+          kind: "Client",
+          label: `${cd.name} (${cd.kind})`,
+          data: { ...cd },
+          location: q.clientLocation
+        } : {
+          id: `client:${cd.name}:${cd.kind}`,
+          kind: "Client",
+          label: `${cd.name} (${cd.kind})`,
+          data: { ...cd }
+        }
+      );
+      g.addEdge(qn.id, cn.id, "USES_CLIENT");
+      g.addEdge(qn.id, tableNode(q.table).id, "TARGETS");
+    });
+  }
+  return g;
+}
+
+// packages/parser/src/discover.ts
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".next",
+  "dist",
+  ".git",
+  ".vercel",
+  ".supabase",
+  "coverage",
+  ".turbo",
+  "build",
+  "out"
+]);
+var SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+function globToRegExp(glob) {
+  const g = glob.replace(/^\.\//, "").replace(/\/$/, "");
+  let re = "";
+  let i = 0;
+  while (i < g.length) {
+    if (g.startsWith("**/", i)) {
+      re += "(?:.*/)?";
+      i += 3;
+    } else if (g.startsWith("/**", i) && i + 3 === g.length) {
+      re += "(?:/.*)?";
+      i += 3;
+    } else if (g.startsWith("**", i)) {
+      re += ".*";
+      i += 2;
+    } else if (g[i] === "*") {
+      re += "[^/]*";
+      i += 1;
+    } else if (g[i] === "?") {
+      re += "[^/]";
+      i += 1;
+    } else {
+      re += (g[i] ?? "").replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i += 1;
+    }
+  }
+  return new RegExp(`^${re}(?:/.*)?$`);
+}
+function isIgnored(rel, patterns) {
+  return patterns.some((p) => p.test(rel));
+}
+function discoverFiles(root, extraSqlDirs = [], ignoreGlobs = []) {
+  const source = [];
+  const sql = [];
+  const ignore = ignoreGlobs.map(globToRegExp);
+  const walk2 = (dir, sqlOnly = false) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const full = join(dir, name);
+      let isDir;
+      try {
+        isDir = statSync(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        const relDir = relative(root, full).split(sep).join("/");
+        if (!SKIP_DIRS.has(name) && !name.startsWith(".") && !isIgnored(relDir, ignore))
+          walk2(full, sqlOnly);
+        continue;
+      }
+      const rel = relative(root, full).split(sep).join("/");
+      if (isIgnored(rel, ignore)) continue;
+      if (name.endsWith(".sql")) {
+        if (!sql.includes(rel)) sql.push(rel);
+        continue;
+      }
+      if (sqlOnly || name.endsWith(".d.ts")) continue;
+      if (SOURCE_EXT.test(name)) source.push(rel);
+    }
+  };
+  walk2(root);
+  for (const extra of extraSqlDirs) walk2(resolve(root, extra), true);
+  source.sort();
+  sql.sort();
+  return { source, sql };
+}
+
+// packages/parser/src/model.ts
+var HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+
+// packages/parser/src/nextjs.ts
+import ts2 from "typescript";
+
+// packages/parser/src/ast.ts
+import ts from "typescript";
+function parseSource(fileName, text) {
+  const kind = fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  return ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true, kind);
+}
+function lineOf(sf, node) {
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+function walk(node, visit) {
+  if (visit(node) === false) return;
+  node.forEachChild((child) => {
+    walk(child, visit);
+  });
+}
+function collect(root, pred) {
+  const out = [];
+  walk(root, (n) => {
+    if (pred(n)) out.push(n);
+    return void 0;
+  });
+  return out;
+}
+function stringLiteralValue(e) {
+  if (!e) return null;
+  if (ts.isStringLiteral(e) || ts.isNoSubstitutionTemplateLiteral(e)) return e.text;
+  return null;
+}
+function unwrap(e) {
+  let cur = e;
+  for (; ; ) {
+    if (ts.isAwaitExpression(cur) || ts.isParenthesizedExpression(cur) || ts.isNonNullExpression(cur) || ts.isAsExpression(cur) || ts.isTypeAssertionExpression(cur) || ts.isSatisfiesExpression(cur)) {
+      cur = cur.expression;
+    } else {
+      return cur;
+    }
+  }
+}
+function flattenChain(call) {
+  const segments = [];
+  let expr = call;
+  for (; ; ) {
+    expr = unwrap(expr);
+    if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
+      segments.unshift({ name: expr.expression.name.text, args: expr.arguments, node: expr });
+      expr = expr.expression.expression;
+    } else {
+      break;
+    }
+  }
+  return { root: expr, segments };
+}
+function isChainTail(call) {
+  let p = call.parent;
+  while (p && (ts.isAwaitExpression(p) || ts.isParenthesizedExpression(p) || ts.isNonNullExpression(p) || ts.isAsExpression(p))) {
+    p = p.parent;
+  }
+  if (p && ts.isPropertyAccessExpression(p) && p.parent && ts.isCallExpression(p.parent)) {
+    return p.parent.expression !== p;
+  }
+  return true;
+}
+function hasExportModifier(node) {
+  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function exportedFunctions(sf) {
+  const out = [];
+  for (const stmt of sf.statements) {
+    if (ts.isFunctionDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+      out.push({ name: stmt.name.text, fn: stmt, node: stmt });
+    } else if (ts.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (ts.isIdentifier(d.name) && d.initializer) {
+          const init = unwrap(d.initializer);
+          if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+            out.push({ name: d.name.text, fn: init, node: d });
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+function boundNames(name) {
+  if (ts.isIdentifier(name)) return [name.text];
+  const out = [];
+  for (const el of name.elements) {
+    if (ts.isOmittedExpression(el)) continue;
+    out.push(...boundNames(el.name));
+  }
+  return out;
+}
+function identifiersIn(node) {
+  const out = /* @__PURE__ */ new Set();
+  walk(node, (n) => {
+    if (ts.isIdentifier(n)) out.add(n.text);
+    return void 0;
+  });
+  return out;
+}
+var IGNORE_RE = /auditai:ignore(?:\s+([A-Za-z0-9_.*-]+))?(?:\s*(?:--|:)\s*(.*))?/;
+function parseIgnoreDirectives(sf, pos) {
+  const out = [];
+  const ranges = ts.getLeadingCommentRanges(sf.text, pos) ?? [];
+  for (const r of ranges) {
+    const text = sf.text.slice(r.pos, r.end);
+    const m = IGNORE_RE.exec(text);
+    if (!m) continue;
+    const reason = (m[2] ?? "").replace(/\*\/\s*$/, "").trim();
+    out.push({
+      ruleId: m[1] ?? "*",
+      reason: reason || "(no reason given)",
+      line: sf.getLineAndCharacterOfPosition(r.pos).line + 1
+    });
+  }
+  return out;
+}
+function enclosingStatement(node) {
+  let cur = node;
+  while (cur.parent && !ts.isSourceFile(cur.parent)) cur = cur.parent;
+  return cur;
+}
+
+// packages/parser/src/nextjs.ts
+var ROUTE_FILE = /^(?:(.*?)\/)?(?:src\/)?app\/(.*?)\/?route\.(ts|tsx|js|jsx|mjs)$/;
+function appRootOf(rel) {
+  const m = /^(?:(.*?)\/)?(?:src\/)?app\//.exec(rel);
+  if (!m) return null;
+  const prefix = m[1] ?? "";
+  return prefix;
+}
+function routeFromFile(rel) {
+  const m = ROUTE_FILE.exec(rel);
+  if (!m) return null;
+  const dir = m[2] ?? "";
+  const parts = dir.split("/").filter((p) => p.length > 0 && !p.startsWith("(") && !p.startsWith("@"));
+  return `/${parts.join("/")}`;
+}
+function routeHandlersIn(sf) {
+  const out = [];
+  for (const ex of exportedFunctions(sf)) {
+    if (HTTP_METHODS.includes(ex.name)) {
+      out.push({ method: ex.name, exported: ex });
+    }
+  }
+  return out;
+}
+function fileDirective(sf) {
+  const first = sf.statements[0];
+  if (first && ts2.isExpressionStatement(first) && ts2.isStringLiteral(first.expression))
+    return first.expression.text;
+  return null;
+}
+function isServerActionFile(sf) {
+  return fileDirective(sf) === "use server";
+}
+function isClientComponentFile(sf) {
+  return fileDirective(sf) === "use client";
+}
+
+// packages/parser/src/parse-project.ts
+import { readFileSync } from "node:fs";
+import { join as join2, posix, resolve as resolve2 } from "node:path";
+import ts4 from "typescript";
+
+// packages/parser/src/rls.ts
+var CONSTRAINT_WORDS = /* @__PURE__ */ new Set([
+  "primary",
+  "unique",
+  "constraint",
+  "foreign",
+  "check",
+  "exclude",
+  "like"
+]);
+function lineAt(text, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < text.length; i += 1) if (text.charCodeAt(i) === 10) line += 1;
+  return line;
+}
+function balanced(text, open) {
+  if (text[open] !== "(") return null;
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) return { inner: text.slice(open + 1, i), end: i };
+    }
+  }
+  return null;
+}
+function splitTopLevel(text) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of text) {
+    if (ch === "(") depth += 1;
+    if (ch === ")") depth -= 1;
+    if (ch === "," && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur.trim()) out.push(cur);
+  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+var IDENT = String.raw`(?:public\.)?"?([A-Za-z_][A-Za-z0-9_]*)"?`;
+var CREATE_TABLE = new RegExp(
+  String.raw`^create\s+table\s+(?:if\s+not\s+exists\s+)?${IDENT}\s*\(`,
+  "i"
+);
+var ENABLE_RLS = new RegExp(
+  String.raw`^alter\s+table\s+(?:only\s+)?(?:if\s+exists\s+)?${IDENT}\s+(enable|disable)\s+row\s+level\s+security`,
+  "i"
+);
+var CREATE_POLICY = new RegExp(
+  String.raw`^create\s+policy\s+("([^"]+)"|\S+)\s+on\s+${IDENT}`,
+  "i"
+);
+function parseSqlForRls(rel, text, into) {
+  const stripped = text.replace(/--[^\n]*/g, "").replace(/\$[A-Za-z_]*\$[\s\S]*?\$[A-Za-z_]*\$/g, "$$body$$");
+  const ensure = (name, index) => {
+    const key = name.toLowerCase();
+    let t = into.get(key);
+    if (!t) {
+      t = {
+        table: key,
+        rlsEnabled: false,
+        policies: [],
+        policyDetails: [],
+        columns: [],
+        location: { file: rel, line: lineAt(stripped, index) }
+      };
+      into.set(key, t);
+    }
+    return t;
+  };
+  let offset = 0;
+  for (const raw of stripped.split(";")) {
+    const start = offset;
+    offset += raw.length + 1;
+    const stmt = raw.trim();
+    if (!stmt) continue;
+    const at = start + raw.indexOf(stmt);
+    const ct = CREATE_TABLE.exec(stmt);
+    if (ct?.[1]) {
+      const t = ensure(ct[1], at);
+      const open = stmt.indexOf("(", ct[0].length - 1);
+      const body = balanced(stmt, open);
+      if (body) {
+        for (const part of splitTopLevel(body.inner)) {
+          const first = part.split(/\s+/)[0]?.replace(/^"|"$/g, "") ?? "";
+          if (first && !CONSTRAINT_WORDS.has(first.toLowerCase()))
+            t.columns.push(first.toLowerCase());
+        }
+      }
+      continue;
+    }
+    const rls = ENABLE_RLS.exec(stmt);
+    if (rls?.[1] && rls[2]) {
+      ensure(rls[1], at).rlsEnabled = rls[2].toLowerCase() === "enable";
+      continue;
+    }
+    const cp = CREATE_POLICY.exec(stmt);
+    if (cp?.[1] && cp[3]) {
+      const t = ensure(cp[3], at);
+      const name = cp[2] ?? cp[1];
+      const rest = stmt.slice(cp[0].length);
+      const cmdMatch = /\bfor\s+(select|insert|update|delete|all)\b/i.exec(rest);
+      const command = cmdMatch?.[1]?.toLowerCase() ?? "all";
+      const rolesMatch = /\bto\s+([A-Za-z_][A-Za-z0-9_]*(?:\s*,\s*[A-Za-z_][A-Za-z0-9_]*)*)/i.exec(
+        rest
+      );
+      const roles = rolesMatch?.[1] ? rolesMatch[1].split(/\s*,\s*/).map((r) => r.toLowerCase()) : [];
+      let using = null;
+      let check = null;
+      const u = /\busing\s*\(/i.exec(rest);
+      if (u) using = balanced(rest, u.index + u[0].length - 1)?.inner.trim() ?? null;
+      const c = /\bwith\s+check\s*\(/i.exec(rest);
+      if (c) check = balanced(rest, c.index + c[0].length - 1)?.inner.trim() ?? null;
+      t.policies.push(name);
+      t.policyDetails.push({
+        name,
+        command,
+        roles,
+        using,
+        check,
+        location: { file: rel, line: lineAt(stripped, at) }
+      });
+    }
+  }
+}
+
+// packages/parser/src/supabase.ts
+import ts3 from "typescript";
+var CREATE_CLIENT_CALLEES = /^(createClient|createServerClient|createBrowserClient)$/;
+function isCreateClientCall(call, sf) {
+  const callee = call.expression;
+  if (ts3.isIdentifier(callee)) return CREATE_CLIENT_CALLEES.test(callee.text);
+  if (ts3.isPropertyAccessExpression(callee)) return CREATE_CLIENT_CALLEES.test(callee.name.text);
+  return CREATE_CLIENT_CALLEES.test(callee.getText(sf));
+}
+function resolveArgText(expr, sf) {
+  const u = unwrap(expr);
+  if (!ts3.isIdentifier(u)) return expr.getText(sf);
+  let scope = expr.parent;
+  while (scope) {
+    if (ts3.isFunctionLike(scope) || ts3.isBlock(scope) || ts3.isSourceFile(scope)) {
+      const decl = collect(scope, ts3.isVariableDeclaration).find(
+        (d) => ts3.isIdentifier(d.name) && d.name.text === u.text && d.initializer
+      );
+      if (decl?.initializer) return `${u.text} = ${decl.initializer.getText(sf)}`;
+    }
+    scope = scope.parent;
+  }
+  return expr.getText(sf);
+}
+function classifyCreateClientCall(call, sf) {
+  const callee = call.expression.getText(sf);
+  const args = call.arguments.map((a) => resolveArgText(a, sf));
+  const keyArg = args[1] ?? "";
+  const optArg = args[2] ?? "";
+  if (/createServerClient|createBrowserClient/.test(callee)) {
+    return {
+      kind: "user_scoped",
+      evidence: `${callee}() from @supabase/ssr acts as the signed-in user; RLS applies`
+    };
+  }
+  if (/SERVICE_ROLE|service_role|SECRET_KEY|SB_SECRET|sb_secret/i.test(keyArg)) {
+    return {
+      kind: "service_role",
+      evidence: `key ${keyArg} is a service-role secret; RLS is bypassed`
+    };
+  }
+  const anonKey = /ANON|PUBLISHABLE|anon|publishable/.test(keyArg);
+  if (anonKey && /Authorization|headers/i.test(optArg)) {
+    return {
+      kind: "user_scoped",
+      evidence: "anon key with a per-request Authorization header; RLS applies as the caller"
+    };
+  }
+  if (anonKey) {
+    return {
+      kind: "anon",
+      evidence: "anon key without a user token; RLS applies as the anonymous role"
+    };
+  }
+  return { kind: "unknown", evidence: `could not classify key argument ${keyArg || "(none)"}` };
+}
+var AUTH_CALL = /\.auth\.(getUser|getSession|getClaims)\s*\(/;
+function analyzeModule(rel, sf) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (!ts3.isImportDeclaration(stmt) || !ts3.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const spec = stmt.moduleSpecifier.text;
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name) imports.set(clause.name.text, spec);
+    const nb = clause.namedBindings;
+    if (nb && ts3.isNamedImports(nb)) for (const el of nb.elements) imports.set(el.name.text, spec);
+    if (nb && ts3.isNamespaceImport(nb)) imports.set(nb.name.text, spec);
+  }
+  const clientFactories = [];
+  const authHelpers = [];
+  for (const ex of exportedFunctions(sf)) {
+    const text = ex.fn.getText(sf);
+    const location = { file: rel, line: lineOf(sf, ex.node) };
+    if (AUTH_CALL.test(text)) {
+      authHelpers.push({
+        name: ex.name,
+        location,
+        evidence: "calls supabase auth.getUser/getSession/getClaims"
+      });
+      continue;
+    }
+    const creates = collect(ex.fn, ts3.isCallExpression).filter((c) => isCreateClientCall(c, sf));
+    const first = creates[0];
+    if (first) {
+      const { kind, evidence } = classifyCreateClientCall(first, sf);
+      clientFactories.push({ name: ex.name, kind, location, evidence });
+    }
+  }
+  return { file: rel, clientFactories, authHelpers, imports };
+}
+
+// packages/parser/src/parse-project.ts
+var FILTER_METHODS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "is",
+  "in",
+  "contains",
+  "containedBy",
+  "match",
+  "filter",
+  "not",
+  "or",
+  "textSearch"
+]);
+var WRITE_OPERATIONS = /* @__PURE__ */ new Set(["insert", "update", "upsert"]);
+var OPERATIONS = /* @__PURE__ */ new Set(["select", "insert", "update", "delete", "upsert"]);
+var PUBLIC_SECRET_ENV = /process\.env\.NEXT_PUBLIC_[A-Z0-9_]*(?:SERVICE_ROLE|SECRET)[A-Z0-9_]*/g;
+function resolveImport(spec, fromRel, files) {
+  let base;
+  const bases = [];
+  if (spec.startsWith("@/") || spec.startsWith("~/")) {
+    base = spec.slice(2);
+    const appRoot = appRootOf(fromRel);
+    if (appRoot) bases.push(posix.join(appRoot, base), posix.join(appRoot, "src", base));
+    bases.push(base, `src/${base}`);
+  } else if (spec.startsWith(".")) {
+    base = posix.normalize(posix.join(posix.dirname(fromRel), spec));
+    bases.push(base);
+  } else return null;
+  for (const b of bases) {
+    for (const c of [
+      `${b}.ts`,
+      `${b}.tsx`,
+      `${b}.js`,
+      `${b}.jsx`,
+      `${b}/index.ts`,
+      `${b}/index.tsx`,
+      b
+    ]) {
+      if (files.has(c)) return c;
+    }
+  }
+  return null;
+}
+function analyzeHandler(ctx) {
+  const { rel, sf, fn, facts, registry, files } = ctx;
+  const loc2 = (n) => ({ file: rel, line: lineOf(sf, n) });
+  const factories = /* @__PURE__ */ new Map();
+  const authHelpers = /* @__PURE__ */ new Map();
+  for (const [local, spec] of facts.imports) {
+    const target = resolveImport(spec, rel, files);
+    const tf = target ? registry.get(target) : void 0;
+    if (tf) {
+      const cf = tf.clientFactories.find((c) => c.name === local);
+      if (cf) factories.set(local, cf);
+      const ah = tf.authHelpers.find((a) => a.name === local);
+      if (ah) authHelpers.set(local, ah);
+    } else if (spec.startsWith(".") || spec.startsWith("@/") || spec.startsWith("~/")) {
+      let matched = false;
+      for (const f of registry.values()) {
+        const cf = f.clientFactories.find((c) => c.name === local);
+        if (cf) {
+          factories.set(local, cf);
+          matched = true;
+        }
+        const ah = f.authHelpers.find((a) => a.name === local);
+        if (ah) {
+          authHelpers.set(local, ah);
+          matched = true;
+        }
+      }
+      if (matched)
+        ctx.warnings.push(`unresolved import "${spec}" in ${rel}; matched "${local}" by name`);
+    }
+  }
+  for (const cf of facts.clientFactories) factories.set(cf.name, cf);
+  for (const ah of facts.authHelpers) authHelpers.set(ah.name, ah);
+  const body = fn.body ?? fn;
+  const firstParam = fn.parameters[0];
+  const reqName = firstParam && ts4.isIdentifier(firstParam.name) ? firstParam.name.text : null;
+  const inputs = [];
+  const inputNames = /* @__PURE__ */ new Set(["params", "searchParams"]);
+  const addInput = (kind, name, n, bind) => {
+    if (!inputs.some((i) => i.kind === kind && i.name === name))
+      inputs.push({ kind, name, location: loc2(n) });
+    if (bind) inputNames.add(name);
+  };
+  if (ctx.kind === "server_action") {
+    for (const p of fn.parameters)
+      for (const nm of boundNames(p.name)) addInput("action_arg", nm, p, true);
+  }
+  walk(body, (n) => {
+    if (ts4.isVariableDeclaration(n) && n.initializer) {
+      const init = unwrap(n.initializer);
+      const text = init.getText(sf);
+      if (/^(params|context\.params|ctx\.params|props\.params)$/.test(text)) {
+        for (const nm of boundNames(n.name)) addInput("route_param", nm, n, true);
+      } else if (ts4.isCallExpression(init) && /\.(json|formData|text)\(\)$/.test(text) && (reqName ? text.startsWith(`${reqName}.`) : /^(req|request)\./.test(text))) {
+        for (const nm of boundNames(n.name)) addInput("body", nm, n, true);
+      } else if (/searchParams\.get\(|\.searchParams$|^new URL\(/.test(text)) {
+        for (const nm of boundNames(n.name)) addInput("query", nm, n, true);
+      } else if (/headers\.get\(/.test(text)) {
+        for (const nm of boundNames(n.name)) addInput("header", nm, n, true);
+      } else if (ts4.isIdentifier(init) && inputNames.has(init.text)) {
+        for (const nm of boundNames(n.name)) addInput("body", nm, n, true);
+      }
+    }
+    if (ts4.isPropertyAccessExpression(n) && ts4.isIdentifier(n.expression) && n.expression.text === "params") {
+      addInput("route_param", n.name.text, n, false);
+    }
+    return void 0;
+  });
+  const derived = (e) => {
+    for (const id of identifiersIn(e)) if (inputNames.has(id)) return true;
+    return /^(params|body|query|searchParams)\b/.test(e.getText(sf));
+  };
+  const isWholeInput = (e) => {
+    const u = unwrap(e);
+    if (ts4.isIdentifier(u)) return inputNames.has(u.text);
+    if (ts4.isObjectLiteralExpression(u)) {
+      return u.properties.some(
+        (p) => ts4.isSpreadAssignment(p) && ts4.isIdentifier(unwrap(p.expression)) && inputNames.has(unwrap(p.expression).text)
+      );
+    }
+    return false;
+  };
+  const classifyClientCall = (call) => {
+    if (ts4.isIdentifier(call.expression)) {
+      const f = factories.get(call.expression.text);
+      if (f) return { kind: f.kind, name: f.name, location: f.location };
+    }
+    if (isCreateClientCall(call, sf)) {
+      const c = classifyCreateClientCall(call, sf);
+      return { kind: c.kind, name: call.expression.getText(sf), location: loc2(call) };
+    }
+    return null;
+  };
+  const clients = /* @__PURE__ */ new Map();
+  const authChecks = [];
+  for (const call of collect(body, ts4.isCallExpression)) {
+    const calleeText = call.expression.getText(sf);
+    if (/\.auth\.(getUser|getSession|getClaims)$/.test(calleeText)) authChecks.push(loc2(call));
+    else if (ts4.isIdentifier(call.expression) && authHelpers.has(call.expression.text))
+      authChecks.push(loc2(call));
+  }
+  for (const decl of collect(body, ts4.isVariableDeclaration)) {
+    if (!decl.initializer || !ts4.isIdentifier(decl.name)) continue;
+    const init = unwrap(decl.initializer);
+    if (!ts4.isCallExpression(init)) continue;
+    const binding = classifyClientCall(init);
+    if (binding) clients.set(decl.name.text, binding);
+  }
+  const metadataAccesses = [];
+  for (const pa of collect(body, ts4.isPropertyAccessExpression)) {
+    const inner = pa.expression;
+    if (ts4.isPropertyAccessExpression(inner) && (inner.name.text === "user_metadata" || inner.name.text === "app_metadata")) {
+      metadataAccesses.push({ path: pa.getText(sf), bucket: inner.name.text, location: loc2(pa) });
+    }
+  }
+  const queries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of collect(body, ts4.isCallExpression)) {
+    if (!isChainTail(call)) continue;
+    const chain = flattenChain(call);
+    const fromIdx = chain.segments.findIndex((s) => s.name === "from");
+    const rpcIdx = chain.segments.findIndex((s) => s.name === "rpc");
+    const anchorIdx = fromIdx >= 0 ? fromIdx : rpcIdx;
+    const anchor = chain.segments[anchorIdx];
+    if (anchorIdx < 0 || !anchor) continue;
+    if (seen.has(anchor.node.pos)) continue;
+    seen.add(anchor.node.pos);
+    let client = "unknown";
+    let clientName = null;
+    let clientLocation = null;
+    const root = unwrap(chain.root);
+    let binding = null;
+    if (ts4.isIdentifier(root)) {
+      binding = clients.get(root.text) ?? null;
+      if (!binding) clientName = root.text;
+    } else if (ts4.isCallExpression(root)) {
+      binding = classifyClientCall(root);
+    }
+    if (binding) {
+      client = binding.kind;
+      clientName = binding.name;
+      clientLocation = binding.location;
+    }
+    const after = chain.segments.slice(anchorIdx + 1);
+    let operation = fromIdx >= 0 ? "unknown" : "rpc";
+    let payload = null;
+    for (const s of after) {
+      if (OPERATIONS.has(s.name)) {
+        operation = s.name;
+        const arg = s.args[0];
+        if (WRITE_OPERATIONS.has(operation) && arg) {
+          payload = {
+            text: arg.getText(sf).replace(/\s+/g, " ").slice(0, 200),
+            inputDerived: derived(arg),
+            wholeInput: isWholeInput(arg)
+          };
+        }
+        break;
+      }
+    }
+    const filters = [];
+    for (const s of after) {
+      if (!FILTER_METHODS.has(s.name)) continue;
+      const first = s.args[0];
+      if (s.name === "match" && first && ts4.isObjectLiteralExpression(first)) {
+        for (const p of first.properties) {
+          if (ts4.isPropertyAssignment(p)) {
+            filters.push({
+              method: "match",
+              column: p.name.getText(sf).replace(/['"]/g, ""),
+              valueText: p.initializer.getText(sf),
+              inputDerived: derived(p.initializer)
+            });
+          }
+        }
+        continue;
+      }
+      const val = s.args[1];
+      filters.push({
+        method: s.name,
+        column: stringLiteralValue(first),
+        valueText: val ? val.getText(sf) : "",
+        inputDerived: val ? derived(val) : false
+      });
+    }
+    queries.push({
+      table: stringLiteralValue(anchor.args[0]) ?? "(dynamic)",
+      operation,
+      client,
+      clientName,
+      clientLocation,
+      filters,
+      payload,
+      location: loc2(anchor.node),
+      text: call.getText(sf).replace(/\s+/g, " ").slice(0, 200)
+    });
+  }
+  const entry = ctx.kind === "route" ? `${ctx.method} ${ctx.route}` : `server action ${ctx.route}`;
+  const stmt = enclosingStatement(ctx.node);
+  const ignores = parseIgnoreDirectives(sf, stmt.getFullStart()).map((d) => ({
+    ruleId: d.ruleId,
+    reason: d.reason,
+    location: { file: rel, line: d.line }
+  }));
+  return {
+    kind: ctx.kind,
+    route: ctx.route,
+    method: ctx.method,
+    entry,
+    location: loc2(ctx.node),
+    inputs,
+    authChecks,
+    queries,
+    metadataAccesses,
+    ignores
+  };
+}
+function findExposures(rel, sf) {
+  const out = [];
+  const text = sf.text;
+  for (const m of text.matchAll(PUBLIC_SECRET_ENV)) {
+    const line = sf.getLineAndCharacterOfPosition(m.index ?? 0).line + 1;
+    out.push({
+      kind: "public_env_service_role",
+      location: { file: rel, line },
+      evidence: `${m[0]} is inlined into the browser bundle by Next.js because of the NEXT_PUBLIC_ prefix`
+    });
+  }
+  if (isClientComponentFile(sf)) {
+    for (const call of collect(sf, ts4.isCallExpression)) {
+      if (!isCreateClientCall(call, sf)) continue;
+      const c = classifyCreateClientCall(call, sf);
+      if (c.kind === "service_role") {
+        out.push({
+          kind: "service_role_in_client_component",
+          location: { file: rel, line: lineOf(sf, call) },
+          evidence: `"use client" file creates a Supabase client with a service-role key: ${c.evidence}`
+        });
+      }
+    }
+  }
+  if (out.some((x) => x.kind === "service_role_in_client_component")) {
+    return out.filter((x) => x.kind !== "public_env_service_role");
+  }
+  return out;
+}
+function parseProject(rootInput, opts = {}) {
+  const root = resolve2(rootInput);
+  const { source, sql } = discoverFiles(root, opts.sqlDirs ?? [], opts.ignore ?? []);
+  const warnings = [];
+  const sources = /* @__PURE__ */ new Map();
+  for (const rel of source) {
+    try {
+      sources.set(rel, parseSource(rel, readFileSync(join2(root, rel), "utf8")));
+    } catch (e) {
+      warnings.push(`could not read ${rel}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  const registry = /* @__PURE__ */ new Map();
+  for (const [rel, sf] of sources) registry.set(rel, analyzeModule(rel, sf));
+  const tables = /* @__PURE__ */ new Map();
+  for (const rel of sql) {
+    try {
+      parseSqlForRls(rel, readFileSync(resolve2(root, rel), "utf8"), tables);
+    } catch (e) {
+      warnings.push(`could not read ${rel}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  const files = new Set(source);
+  const routes = [];
+  const exposures = [];
+  const fileIgnores = {};
+  for (const [rel, sf] of sources) {
+    const top = parseIgnoreDirectives(sf, 0).map((d) => ({
+      ruleId: d.ruleId,
+      reason: d.reason,
+      location: { file: rel, line: d.line }
+    }));
+    if (top.length > 0) fileIgnores[rel] = top;
+    exposures.push(...findExposures(rel, sf));
+    const facts = registry.get(rel) ?? analyzeModule(rel, sf);
+    const common = { rel, sf, facts, registry, files, warnings };
+    const route = routeFromFile(rel);
+    if (route) {
+      for (const { method, exported } of routeHandlersIn(sf)) {
+        routes.push(
+          analyzeHandler({
+            ...common,
+            kind: "route",
+            route,
+            method,
+            fn: exported.fn,
+            node: exported.node
+          })
+        );
+      }
+    } else if (isServerActionFile(sf)) {
+      for (const ex of exportedFunctions(sf)) {
+        routes.push(
+          analyzeHandler({
+            ...common,
+            kind: "server_action",
+            route: ex.name,
+            method: "ACTION",
+            fn: ex.fn,
+            node: ex.node
+          })
+        );
+      }
+    }
+  }
+  routes.sort((a, b) => a.entry.localeCompare(b.entry));
+  const all = [...registry.values()];
+  return {
+    root,
+    files: [...source, ...sql],
+    routes,
+    clientFactories: all.flatMap((f) => f.clientFactories),
+    authHelpers: all.flatMap((f) => f.authHelpers),
+    tables: [...tables.values()],
+    exposures,
+    fileIgnores,
+    warnings
+  };
+}
+
+// packages/rules/src/packs/supabase-authorization.ts
+var SCOPE_COLUMNS = /* @__PURE__ */ new Set([
+  "tenant_id",
+  "org_id",
+  "organization_id",
+  "workspace_id",
+  "team_id",
+  "account_id",
+  "company_id",
+  "owner_id",
+  "user_id",
+  "created_by",
+  "author_id",
+  "profile_id"
+]);
+function isScopeColumn(column) {
+  return column !== null && SCOPE_COLUMNS.has(column.toLowerCase());
+}
+function isObjectIdColumn(column) {
+  if (column === null || isScopeColumn(column)) return false;
+  const c = column.toLowerCase();
+  return c === "id" || c === "uuid" || c === "slug" || c.endsWith("_id") || c.endsWith("id");
+}
+function policyScopesToCaller(expr) {
+  if (expr === null) return false;
+  return /auth\.uid\(\)|auth\.jwt\(\)|current_setting\(|current_tenant|current_user_id|is_member|has_role|tenant_id|owner_id|user_id|created_by/i.test(
+    expr
+  );
+}
+function handlerViews(ctx) {
+  return ctx.graph.nodesOfKind("Handler").map((handler) => {
+    const data = handler.data;
+    return {
+      handler,
+      data,
+      inputs: data.inputs ?? [],
+      authenticated: ctx.graph.out(handler.id, "AUTHENTICATED_BY").length > 0
+    };
+  });
+}
+function queryViews(ctx, handler) {
+  return ctx.graph.out(handler.id, "CALLS").map((query) => {
+    const client = ctx.graph.out(query.id, "USES_CLIENT")[0];
+    const table = ctx.graph.out(query.id, "TARGETS")[0];
+    return {
+      query,
+      data: query.data,
+      client,
+      clientData: client?.data,
+      table,
+      tableData: table?.data
+    };
+  });
+}
+function locations(...refs) {
+  return refs.filter((r) => r !== void 0);
+}
+function rlsNote(t, tableName) {
+  if (!t?.known) return `public.${tableName} was not found in migrations; RLS state unknown.`;
+  if (!t.rlsEnabled) return `RLS is disabled on public.${tableName}.`;
+  return `RLS is enabled on public.${tableName} with ${t.policies.length} polic${t.policies.length === 1 ? "y" : "ies"}, but the service role bypasses it.`;
+}
+function finding(ctx, rule, partial) {
+  return {
+    id: ctx.nextId(),
+    ruleId: rule.id,
+    status: "likely",
+    severity: rule.severity,
+    confidence: rule.confidence,
+    cwe: rule.cwe,
+    createdAt: ctx.now,
+    updatedAt: ctx.now,
+    ...partial
+  };
+}
+function coveredByObjectAccessRule(q) {
+  const idFilter = q.filters.find((f) => f.inputDerived && isObjectIdColumn(f.column));
+  return idFilter !== void 0 && !q.filters.some((f) => isScopeColumn(f.column));
+}
+var serviceRoleObjectAccessWithoutTenantScope = {
+  id: "supabase.service-role-object-access-without-tenant-scope",
+  title: "Object access via service-role client without tenant scope",
+  description: "A query filtered by a user-controlled id runs with the service-role key, so Row Level Security does not apply, and nothing restricts the row to the caller's tenant or ownership.",
+  severity: "critical",
+  confidence: 0.85,
+  cwe: ["CWE-639", "CWE-284"],
+  evaluate(ctx) {
+    const out = [];
+    for (const h of handlerViews(ctx)) {
+      for (const v of queryViews(ctx, h.handler)) {
+        const q = v.data;
+        if (v.clientData?.kind !== "service_role") continue;
+        if (!["select", "update", "delete"].includes(q.operation)) continue;
+        const filters = q.filters;
+        const idFilter = filters.find((f) => f.inputDerived && isObjectIdColumn(f.column));
+        if (!idFilter || filters.some((f) => isScopeColumn(f.column))) continue;
+        const tableName = v.tableData?.table ?? q.table;
+        const authNote = h.authenticated ? "The handler authenticates the caller but never checks that the row belongs to them." : "The handler does not authenticate the caller at all.";
+        const path = [
+          h.data.kind === "server_action" ? "Server action call" : "HTTP request",
+          h.data.entry,
+          `${idFilter.column} ${idFilter.method} ${idFilter.valueText} (user-controlled)`,
+          `${v.clientData.name} (service role, bypasses RLS)`,
+          `public.${tableName}.${q.operation}`
+        ];
+        const evidence = [
+          {
+            kind: "rule",
+            summary: `${q.operation} on public.${tableName} filtered by user-controlled "${idFilter.column}" through a service-role client, with no tenant/owner scoping. ${authNote} ${rlsNote(v.tableData, tableName)}`,
+            locations: locations(h.handler.location, v.query.location, v.client?.location),
+            data: {
+              deterministic: false,
+              ruleId: this.id,
+              authenticated: h.authenticated,
+              query: q.text
+            }
+          },
+          { kind: "trace", summary: path.join(" -> ") }
+        ];
+        out.push(
+          finding(ctx, this, {
+            title: `${h.authenticated ? "Cross-tenant" : "Unauthenticated"} ${q.operation} on "${tableName}" via service-role client`,
+            entrypoints: [h.data.entry],
+            sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+            sinks: [`supabase.${q.operation}:public.${tableName}`],
+            path,
+            evidence
+          })
+        );
+      }
+    }
+    return out;
+  }
+};
+var tableWithoutRls = {
+  id: "supabase.table-without-rls",
+  title: "Table queried by a user-facing client has RLS disabled",
+  description: "Queries made with the anon key run as the caller against PostgREST. Without Row Level Security the table is fully exposed to anyone with the public key.",
+  severity: "high",
+  confidence: 0.9,
+  cwe: ["CWE-284", "CWE-862"],
+  evaluate(ctx) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const h of handlerViews(ctx)) {
+      for (const v of queryViews(ctx, h.handler)) {
+        const c = v.clientData;
+        if (c?.kind !== "anon" && c?.kind !== "user_scoped") continue;
+        const t = v.tableData;
+        if (!t?.known || t.rlsEnabled) continue;
+        const key = `${t.table}:${h.data.entry}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const path = [
+          "HTTP request",
+          h.data.entry,
+          `${c.name} (${c.kind}, RLS would apply)`,
+          `public.${t.table} (RLS disabled)`
+        ];
+        out.push(
+          finding(ctx, this, {
+            title: `Table "${t.table}" is exposed without RLS`,
+            entrypoints: [h.data.entry],
+            sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+            sinks: [`supabase.${v.data.operation}:public.${t.table}`],
+            path,
+            evidence: [
+              {
+                kind: "rule",
+                summary: `public.${t.table} has no "enable row level security" in migrations but is queried with a ${c.kind} client. Anyone holding the public anon key can read every row directly through PostgREST.`,
+                locations: locations(v.query.location, v.table?.location),
+                data: { deterministic: true, ruleId: this.id }
+              },
+              { kind: "trace", summary: path.join(" -> ") }
+            ]
+          })
+        );
+      }
+    }
+    return out;
+  }
+};
+var rlsPolicyWithoutCallerPredicate = {
+  id: "supabase.rls-policy-without-caller-predicate",
+  title: "RLS policy grants rows without a caller predicate",
+  description: "A policy such as `using (true)` or one that never references auth.uid()/tenant makes RLS a no-op for that command: every authenticated user sees every row.",
+  severity: "high",
+  confidence: 0.85,
+  cwe: ["CWE-863", "CWE-284"],
+  evaluate(ctx) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const h of handlerViews(ctx)) {
+      for (const v of queryViews(ctx, h.handler)) {
+        const c = v.clientData;
+        const t = v.tableData;
+        if (c?.kind !== "anon" && c?.kind !== "user_scoped") continue;
+        if (!t?.known || !t.rlsEnabled) continue;
+        if (!t.columns.some((col) => isScopeColumn(col))) continue;
+        const op = v.data.operation === "unknown" ? "select" : v.data.operation;
+        for (const p of t.policyDetails) {
+          if (p.command !== "all" && p.command !== op) continue;
+          const expr = op === "insert" ? p.check : p.using;
+          if (expr === null || policyScopesToCaller(expr)) continue;
+          const key = `${t.table}:${p.name}:${h.data.entry}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          const path = [
+            "HTTP request",
+            h.data.entry,
+            `${c.name} (${c.kind})`,
+            `public.${t.table} policy "${p.name}" ${op === "insert" ? "with check" : "using"} (${expr})`
+          ];
+          out.push(
+            finding(ctx, this, {
+              title: `RLS policy "${p.name}" on "${t.table}" does not scope rows to the caller`,
+              entrypoints: [h.data.entry],
+              sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+              sinks: [`supabase.${op}:public.${t.table}`],
+              path,
+              evidence: [
+                {
+                  kind: "rule",
+                  summary: `Policy "${p.name}" for ${p.command} on public.${t.table} uses (${expr}). The table has a scope column (${t.columns.filter(isScopeColumn).join(", ")}) but the policy never compares it to auth.uid() or the caller's tenant, so RLS lets every ${p.roles.join("/") || "authenticated"} user through.`,
+                  locations: locations(v.query.location, p.location),
+                  data: { deterministic: false, ruleId: this.id, policy: p.name }
+                },
+                { kind: "trace", summary: path.join(" -> ") }
+              ]
+            })
+          );
+        }
+      }
+    }
+    return out;
+  }
+};
+var userControlledTenantScope = {
+  id: "supabase.user-controlled-tenant-scope",
+  title: "Tenant scope taken from the request",
+  description: "The query is scoped by a tenant/owner column, but the value comes from user input. An attacker supplies another tenant's id and the service-role client happily returns its rows.",
+  severity: "critical",
+  confidence: 0.85,
+  cwe: ["CWE-639", "CWE-566"],
+  evaluate(ctx) {
+    const out = [];
+    for (const h of handlerViews(ctx)) {
+      for (const v of queryViews(ctx, h.handler)) {
+        if (v.clientData?.kind !== "service_role") continue;
+        const scope = v.data.filters.find((f) => isScopeColumn(f.column) && f.inputDerived);
+        if (!scope) continue;
+        const tableName = v.tableData?.table ?? v.data.table;
+        const path = [
+          "HTTP request",
+          h.data.entry,
+          `${scope.column} ${scope.method} ${scope.valueText} (user-controlled)`,
+          `${v.clientData.name} (service role, bypasses RLS)`,
+          `public.${tableName}.${v.data.operation}`
+        ];
+        out.push(
+          finding(ctx, this, {
+            title: `Tenant scope for "${tableName}" comes from the request`,
+            entrypoints: [h.data.entry],
+            sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+            sinks: [`supabase.${v.data.operation}:public.${tableName}`],
+            path,
+            evidence: [
+              {
+                kind: "rule",
+                summary: `${v.data.operation} on public.${tableName} is filtered by "${scope.column}" = ${scope.valueText}, which the caller controls. The tenant must come from the authenticated session (profile lookup or JWT claim), never from the request. ${rlsNote(v.tableData, tableName)}`,
+                locations: locations(h.handler.location, v.query.location, v.client?.location),
+                data: { deterministic: false, ruleId: this.id, authenticated: h.authenticated }
+              },
+              { kind: "trace", summary: path.join(" -> ") }
+            ]
+          })
+        );
+      }
+    }
+    return out;
+  }
+};
+var roleFromUserMetadata = {
+  id: "supabase.role-check-from-user-metadata",
+  title: "Authorization based on user-editable metadata",
+  description: "user.user_metadata is writable by the user themselves via updateUser(). Roles and flags must live in app_metadata or a server-controlled table.",
+  severity: "high",
+  confidence: 0.85,
+  cwe: ["CWE-602", "CWE-863"],
+  evaluate(ctx) {
+    const out = [];
+    for (const h of handlerViews(ctx)) {
+      const hits = h.data.metadataAccesses.filter(
+        (m) => m.bucket === "user_metadata" && /role|admin|permission|plan|tier|scope|is_/i.test(m.path)
+      );
+      const first = hits[0];
+      if (!first) continue;
+      const path = [
+        "HTTP request",
+        h.data.entry,
+        `${first.path} (end-user editable)`,
+        "authorization decision"
+      ];
+      out.push(
+        finding(ctx, this, {
+          title: `Role check reads user_metadata in ${h.data.entry}`,
+          entrypoints: [h.data.entry],
+          sources: ["auth.user_metadata (editable by the user)"],
+          sinks: [h.data.entry],
+          path,
+          evidence: [
+            {
+              kind: "rule",
+              summary: `${hits.map((m) => m.path).join(", ")} is read from user_metadata, which any signed-in user can change with supabase.auth.updateUser({ data: { role: "admin" } }). Use app_metadata (service-role only) or a profiles.role column.`,
+              locations: locations(h.handler.location, ...hits.map((m) => m.location)),
+              data: { deterministic: false, ruleId: this.id }
+            },
+            { kind: "trace", summary: path.join(" -> ") }
+          ]
+        })
+      );
+    }
+    return out;
+  }
+};
+var serviceRoleKeyExposedToClient = {
+  id: "supabase.service-role-key-exposed-to-client",
+  title: "Service-role key shipped to the browser",
+  description: "The service-role key bypasses RLS entirely. Anything in a NEXT_PUBLIC_ variable or a client component is downloadable by every visitor.",
+  severity: "critical",
+  confidence: 1,
+  cwe: ["CWE-798", "CWE-200"],
+  evaluate(ctx) {
+    return ctx.model.exposures.map(
+      (x) => finding(ctx, this, {
+        title: x.kind === "public_env_service_role" ? `Service-role key in a NEXT_PUBLIC_ variable (${x.location.file})` : `Service-role client inside a client component (${x.location.file})`,
+        entrypoints: [x.location.file],
+        sources: ["browser bundle"],
+        sinks: ["supabase service role"],
+        path: [
+          "browser bundle",
+          x.location.file,
+          "service-role key",
+          "full database access, RLS bypassed"
+        ],
+        evidence: [
+          {
+            kind: "rule",
+            summary: x.evidence,
+            locations: [x.location],
+            data: { deterministic: true, ruleId: this.id, exposure: x.kind }
+          },
+          {
+            kind: "trace",
+            summary: `browser bundle -> ${x.location.file}:${x.location.line} -> service-role key`
+          }
+        ]
+      })
+    );
+  }
+};
+var serviceRoleQueryWithoutAuthentication = {
+  id: "supabase.service-role-query-without-authentication",
+  title: "Service-role query in an unauthenticated handler",
+  description: "The handler performs privileged database access with the service-role key but never establishes who is calling. Anyone on the internet can invoke it.",
+  severity: "critical",
+  confidence: 0.8,
+  cwe: ["CWE-306", "CWE-284"],
+  evaluate(ctx) {
+    const out = [];
+    for (const h of handlerViews(ctx)) {
+      if (h.authenticated) continue;
+      const views = queryViews(ctx, h.handler).filter(
+        (v2) => v2.clientData?.kind === "service_role" && !coveredByObjectAccessRule(v2.data)
+      );
+      const v = views[0];
+      if (!v) continue;
+      const tables = [...new Set(views.map((x) => x.tableData?.table ?? x.data.table))];
+      const path = [
+        h.data.kind === "server_action" ? "Server action call" : "HTTP request",
+        h.data.entry,
+        "no authentication",
+        `${v.clientData?.name ?? "client"} (service role, bypasses RLS)`,
+        `public.${tables.join(", public.")}`
+      ];
+      out.push(
+        finding(ctx, this, {
+          title: `Unauthenticated service-role access to "${tables.join('", "')}" in ${h.data.entry}`,
+          entrypoints: [h.data.entry],
+          sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+          sinks: views.map(
+            (x) => `supabase.${x.data.operation}:public.${x.tableData?.table ?? x.data.table}`
+          ),
+          path,
+          evidence: [
+            {
+              kind: "rule",
+              summary: `${h.data.entry} runs ${views.length} service-role quer${views.length === 1 ? "y" : "ies"} (${tables.join(", ")}) and contains no auth.getUser/getSession/getClaims call or auth helper. If this is a webhook or cron endpoint, it needs signature verification, which was not detected either.`,
+              locations: locations(h.handler.location, ...views.map((x) => x.query.location)),
+              data: { deterministic: false, ruleId: this.id }
+            },
+            { kind: "trace", summary: path.join(" -> ") }
+          ]
+        })
+      );
+    }
+    return out;
+  }
+};
+var massAssignmentFromRequestBody = {
+  id: "supabase.mass-assignment-from-request-body",
+  title: "Request body written to a table without an allow-list",
+  description: "insert/update/upsert receives the parsed request body as-is. Any column the caller names gets written, including role, tenant_id or owner_id.",
+  severity: "high",
+  confidence: 0.85,
+  cwe: ["CWE-915"],
+  evaluate(ctx) {
+    const out = [];
+    for (const h of handlerViews(ctx)) {
+      for (const v of queryViews(ctx, h.handler)) {
+        const p = v.data.payload;
+        if (!p?.wholeInput) continue;
+        const tableName = v.tableData?.table ?? v.data.table;
+        const cols = v.tableData?.columns ?? [];
+        const sensitive = cols.filter(
+          (c) => isScopeColumn(c) || /role|admin|price|amount|status|plan|tier|balance/i.test(c)
+        );
+        const path = [
+          "HTTP request",
+          h.data.entry,
+          `${p.text} (entire request input)`,
+          `${v.clientData?.name ?? "client"} (${v.clientData?.kind ?? "unknown"})`,
+          `public.${tableName}.${v.data.operation}`
+        ];
+        out.push(
+          finding(ctx, this, {
+            title: `Mass assignment into "${tableName}" from the request body`,
+            entrypoints: [h.data.entry],
+            sources: h.inputs.map((i) => `${i.kind}:${i.name}`),
+            sinks: [`supabase.${v.data.operation}:public.${tableName}`],
+            path,
+            evidence: [
+              {
+                kind: "rule",
+                summary: `${v.data.operation} on public.${tableName} writes ${p.text} directly. ${sensitive.length > 0 ? `Columns the caller could set: ${sensitive.join(", ")}.` : "Every column of the table is writable by the caller."} Pick the allowed fields explicitly.`,
+                locations: locations(h.handler.location, v.query.location),
+                data: { deterministic: false, ruleId: this.id, payload: p.text }
+              },
+              { kind: "trace", summary: path.join(" -> ") }
+            ]
+          })
+        );
+      }
+    }
+    return out;
+  }
+};
+var supabaseAuthorizationPack = [
+  serviceRoleKeyExposedToClient,
+  serviceRoleObjectAccessWithoutTenantScope,
+  userControlledTenantScope,
+  serviceRoleQueryWithoutAuthentication,
+  massAssignmentFromRequestBody,
+  roleFromUserMetadata,
+  tableWithoutRls,
+  rlsPolicyWithoutCallerPredicate
+];
+
+// packages/rules/src/rule.ts
+function runRules(rules, model, graph, opts = {}) {
+  const now = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = opts.idPrefix ?? "AUDIT";
+  let counter = 0;
+  const nextId = () => {
+    counter += 1;
+    return `${prefix}-${String(counter).padStart(3, "0")}`;
+  };
+  let findings = [];
+  for (const rule of rules) {
+    try {
+      findings.push(...rule.evaluate({ model, graph, now, nextId }));
+    } catch (e) {
+      model.warnings.push(`rule ${rule.id} failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  findings = applySuppressions(findings, model, now);
+  return findings;
+}
+function applySuppressions(findings, model, now) {
+  const byEntry = new Map(model.routes.map((h) => [h.entry, h.ignores]));
+  return findings.map((f) => {
+    if (f.status === "suppressed") return f;
+    const candidates = [...byEntry.get(f.entrypoints[0] ?? "") ?? []];
+    for (const ev of f.evidence)
+      for (const l of ev.locations ?? []) candidates.push(...model.fileIgnores[l.file] ?? []);
+    const hit = candidates.find((d) => d.ruleId === "*" || d.ruleId === f.ruleId);
+    if (!hit) return f;
+    return transition(f, "suppressed", {
+      evidence: {
+        kind: "rule",
+        summary: `Suppressed by auditai:ignore at ${hit.location.file}:${hit.location.line}: ${hit.reason}`,
+        locations: [hit.location],
+        data: { suppressed: true, ruleId: hit.ruleId }
+      },
+      now
+    });
+  });
+}
+
+// packages/rules/src/index.ts
+var defaultRules = [...supabaseAuthorizationPack];
+
+// packages/scanner/src/scan.ts
+function readAuditConfig(root) {
+  const p = join3(root, "audit.config.json");
+  if (!existsSync(p)) return {};
+  try {
+    const raw = JSON.parse(readFileSync2(p, "utf8"));
+    return {
+      ...Array.isArray(raw.ignore) ? { ignore: raw.ignore.filter((x) => typeof x === "string") } : {},
+      ...Array.isArray(raw.migrations) ? { migrations: raw.migrations.filter((x) => typeof x === "string") } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function summarize(model, rules) {
+  return {
+    root: model.root,
+    files: model.files.length,
+    routes: model.routes.length,
+    queries: model.routes.reduce((n, r) => n + r.queries.length, 0),
+    tablesKnown: model.tables.length,
+    tablesWithRls: model.tables.filter((t) => t.rlsEnabled).length,
+    rules,
+    warnings: model.warnings
+  };
+}
+function runScan(path, opts = {}) {
+  const cfg = readAuditConfig(path);
+  const sqlDirs = [...cfg.migrations ?? [], ...opts.sqlDirs ?? []];
+  const ignore = [...cfg.ignore ?? [], ...opts.ignore ?? []];
+  const model = parseProject(path, {
+    ...sqlDirs.length > 0 ? { sqlDirs } : {},
+    ...ignore.length > 0 ? { ignore } : {}
+  });
+  const graph = buildGraph(model);
+  const runOpts = opts.now === void 0 ? {} : { now: opts.now };
+  const findings = runRules(defaultRules, model, graph, runOpts);
+  const coverage = summarizeCoverage(findings);
+  return {
+    summary: summarize(model, defaultRules.length),
+    findings,
+    coverage,
+    coverageStatement: renderCoverageStatement(coverage),
+    blocking: findings.some((f) => isBlocking(f))
+  };
+}
+
+// packages/scanner/src/bin.ts
+var USAGE = `auditai-scan \u2014 deterministic security scan for Next.js + Supabase apps (open source)
+
+Usage:
+  auditai-scan [path] [--json] [--fail-on <status>] [--migrations <dir>]...
+
+Options:
+  --json               machine-readable output
+  --fail-on <status>   exit 1 when a finding reaches this status (default: confirmed)
+                       one of: candidate, likely, confirmed, verified
+  --migrations <dir>   extra directory with Supabase migration SQL (repeatable)
+  -h, --help           show this help
+
+Config: <path>/audit.config.json { "ignore": ["evals/**"], "migrations": ["supabase/migrations"] }
+Suppress a finding: // auditai:ignore <ruleId|*> -- reason   (above the handler or at the top of a file)
+`;
+var RANK = {
+  suppressed: -1,
+  unverified: -1,
+  candidate: 0,
+  likely: 1,
+  confirmed: 2,
+  fix_proposed: 2,
+  fix_applied: 2,
+  verified: 3
+};
+function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      json: { type: "boolean", default: false },
+      "fail-on": { type: "string", default: "confirmed" },
+      migrations: { type: "string", multiple: true, default: [] },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  if (values.help) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  const failOn = values["fail-on"];
+  if (!FINDING_STATUSES.includes(failOn)) {
+    process.stderr.write(`error: --fail-on must be one of ${FINDING_STATUSES.join(", ")}
+`);
+    return 2;
+  }
+  const migrations = values.migrations.map((m) => resolve3(m));
+  const result = runScan(
+    positionals[0] ?? ".",
+    migrations.length > 0 ? { sqlDirs: migrations } : {}
+  );
+  process.stdout.write(
+    values.json ? `${JSON.stringify(result, null, 2)}
+` : formatScanText(result)
+  );
+  const threshold = RANK[failOn];
+  return result.findings.some((f) => RANK[f.status] >= 0 && RANK[f.status] >= threshold) ? 1 : 0;
+}
+try {
+  process.exitCode = main(process.argv.slice(2));
+} catch (e) {
+  process.stderr.write(`error: ${e instanceof Error ? e.message : String(e)}
+`);
+  process.exitCode = 2;
+}