nerdsystem 0.0.0-stage → 0.0.2

package/dist/commands/org.js

@@ -0,0 +1,121 @@
+import { ApiClient } from "../api.js";
+import { findProjectRoot, projectPath, readNerdJson } from "../project.js";
+import { CliError, log, printJson, table } from "../util.js";
+function orgSlug(opts) {
+    return opts.org ?? readNerdJson(findProjectRoot()).org;
+}
+export async function membersList(opts) {
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().get(`/v1/orgs/${org}/members`);
+    if (opts.json)
+        return printJson(r);
+    table(r.members.map((m) => ({ email: m.email, name: m.name, role: m.role, joined: m.joinedAt })), ["email", "name", "role", "joined"]);
+    if (r.invites.length) {
+        log.info("\npending invites:");
+        table(r.invites.map((i) => ({ email: i.email, role: i.role, expires: i.expiresAt, id: i.id })), ["email", "role", "expires", "id"]);
+    }
+}
+export async function membersInvite(email, opts) {
+    if (!email)
+        throw new CliError("Usage: nerd members invite someone@example.com [--role admin|member]");
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().post(`/v1/orgs/${org}/invites`, { email, role: opts.role ?? "member" });
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Invited ${r.invite.email} as ${r.invite.role}. The invitation email is valid for seven days.`);
+    if (r.debugToken)
+        log.info(`  (fake email provider) accept link: /invite/${r.debugToken}`);
+}
+export async function membersRemove(userId, opts) {
+    if (!userId)
+        throw new CliError("Usage: nerd members remove <userId>");
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().delete(`/v1/orgs/${org}/members/${userId}`);
+    if (opts.json)
+        return printJson(r);
+    log.ok("Removed.");
+}
+export async function domainsList(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().get(projectPath(nerd, "/domains"));
+    if (opts.json)
+        return printJson(r);
+    if (!r.domains.length)
+        return log.info(`No custom domains. Add one: nerd domains add app.example.com`);
+    table(r.domains.map((d) => ({ hostname: d.hostname, status: d.status, ssl: d.sslStatus ?? "", error: d.lastError ?? "", id: d.id })), ["hostname", "status", "ssl", "error", "id"]);
+    log.info(`\nPoint each hostname at ${r.cnameTarget} with a CNAME record.`);
+}
+export async function domainsAdd(hostname, opts) {
+    if (!hostname)
+        throw new CliError("Usage: nerd domains add app.example.com");
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().post(projectPath(nerd, "/domains"), { hostname });
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Added ${r.domain.hostname}. Create this DNS record, then check with \`nerd domains\`:\n\n  ${r.domain.hostname}  CNAME  ${r.cnameTarget}`);
+}
+export async function domainsRemove(id, opts) {
+    if (!id)
+        throw new CliError("Usage: nerd domains remove <domainId>");
+    const nerd = readNerdJson(findProjectRoot());
+    const r = await ApiClient.fromConfig().delete(projectPath(nerd, `/domains/${id}`));
+    if (opts.json)
+        return printJson(r);
+    log.ok("Removed.");
+}
+export async function logs(opts) {
+    const nerd = readNerdJson(findProjectRoot());
+    const params = new URLSearchParams({ since: opts.since ?? "30m", limit: opts.limit ?? "100" });
+    if (opts.q)
+        params.set("q", opts.q);
+    if (opts.pr)
+        params.set("environment", "preview"), params.set("pr", opts.pr);
+    const r = await ApiClient.fromConfig().get(projectPath(nerd, `/logs?${params}`));
+    if (opts.json)
+        return printJson(r);
+    if (!r.events.length)
+        return log.info(`No log events for ${r.scriptName} in the last ${opts.since ?? "30m"}.`);
+    for (const e of [...r.events].reverse())
+        process.stdout.write(`${e.timestamp} ${e.level.padEnd(5)} ${e.context ? `${e.context} ` : ""}${e.message}\n`);
+}
+export async function auditExport(opts) {
+    const org = orgSlug(opts);
+    const api = ApiClient.fromConfig();
+    if (opts.json)
+        return printJson(await api.get(`/v1/orgs/${org}/audit?format=json`));
+    const res = await fetch(`${api.apiUrl}/v1/orgs/${org}/audit?format=csv`, { headers: { authorization: `Bearer ${process.env.NERD_TOKEN ?? (await import("../config.js")).loadConfig().token ?? ""}` } });
+    if (!res.ok)
+        throw new CliError(`${res.status}: ${(await res.text()).slice(0, 200)}`);
+    const csv = await res.text();
+    if (opts.out)
+        (await import("node:fs")).writeFileSync(opts.out, csv), log.ok(`Wrote ${opts.out}`);
+    else
+        process.stdout.write(csv);
+}
+export async function clientsList(opts) {
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().get(`/v1/orgs/${org}/clients`);
+    if (opts.json)
+        return printJson(r);
+    if (!r.clients.length)
+        return log.info(`No client orgs yet. Create one with: nerd clients create <slug> --name "Client name"`);
+    table(r.clients.map((c) => ({ slug: c.slug, name: c.name, projects: String(c.projects), created: c.createdAt })), ["slug", "name", "projects", "created"]);
+}
+export async function clientsCreate(slug, opts) {
+    if (!slug)
+        throw new CliError('Usage: nerd clients create <slug> --name "Client name"');
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().post(`/v1/orgs/${org}/clients`, { slug, name: opts.name ?? slug });
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Created client org ${r.client.slug}, billed through ${org}. Start a project in it with: npx nerdsystem init my-app --org ${r.client.slug}`);
+}
+export async function clientsRelease(slug, opts) {
+    if (!slug)
+        throw new CliError("Usage: nerd clients release <slug>");
+    const org = orgSlug(opts);
+    const r = await ApiClient.fromConfig().post(`/v1/orgs/${org}/clients/${slug}/release`, {});
+    if (opts.json)
+        return printJson(r);
+    log.ok(`Released ${r.client.slug}. ${r.note}`);
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,24 @@
+import { type Finding, type GateResult } from "../gates/index.js";
+export interface VerifyOutput {
+    ok: boolean;
+    /** Decision 3 shape: every failure the agent (or a person) must act on. */
+    failures: Finding[];
+    /** Rules that hit the retry cap; the agent must stop and hand over. */
+    stop: string[];
+    results: GateResult[];
+}
+/** Suppressions a human approved in the dashboard, so they stop being reported. Best effort. */
+export declare function approvedSuppressions(root: string): Promise<Set<string>>;
+/** Runs every gate that can run locally. With a dist/ present, also scans the built output. */
+export declare function runVerify(root: string, opts: {
+    withBuild: boolean;
+    stopOnFail: boolean;
+    quiet?: boolean;
+    onlyRules?: string[] | undefined;
+    trackAttempts?: boolean;
+}): Promise<VerifyOutput>;
+export declare function verify(opts: {
+    json: boolean;
+    "no-build": boolean;
+    rule?: string | undefined;
+}): Promise<void>;

package/dist/commands/verify.js

@@ -0,0 +1,50 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { ApiClient } from "../api.js";
+import { BUILD_GATES, knownSecretsFrom, runGates, SOURCE_GATES } from "../gates/index.js";
+import { findProjectRoot, projectPath, readDevVars, readNerdJson } from "../project.js";
+import { CliError, log } from "../util.js";
+import { readBuildOutput } from "./deploy.js";
+/** Suppressions a human approved in the dashboard, so they stop being reported. Best effort. */
+export async function approvedSuppressions(root) {
+    try {
+        const nerd = readNerdJson(root);
+        const r = await ApiClient.fromConfig().get(projectPath(nerd, "/gates/overrides"));
+        return new Set(r.overrides.map((o) => o.fingerprint));
+    }
+    catch {
+        return new Set();
+    }
+}
+/** Runs every gate that can run locally. With a dist/ present, also scans the built output. */
+export async function runVerify(root, opts) {
+    const logLine = opts.quiet ? () => { } : (l) => log.info(l);
+    const knownSecrets = knownSecretsFrom(readDevVars(root));
+    const approved = await approvedSuppressions(root);
+    const ctxBase = { root, knownSecrets, approvedSuppressions: approved, onlyRules: opts.onlyRules, log: logLine };
+    const source = await runGates(SOURCE_GATES, ctxBase, { stopOnFail: opts.stopOnFail, trackAttempts: opts.trackAttempts ?? true });
+    let results = source.results;
+    let failures = source.failures;
+    let stop = source.capped;
+    if (opts.withBuild && source.ok && existsSync(path.join(root, "dist"))) {
+        const build = readBuildOutput(root);
+        const built = await runGates(BUILD_GATES.filter((g) => g.name !== "policy"), { ...ctxBase, build }, { stopOnFail: opts.stopOnFail, trackAttempts: false });
+        results = [...results, ...built.results];
+        failures = [...failures, ...built.failures];
+        stop = [...stop, ...built.capped];
+    }
+    return { ok: results.every((r) => r.status !== "fail"), failures, stop, results };
+}
+export async function verify(opts) {
+    const root = findProjectRoot();
+    const out = await runVerify(root, { withBuild: !opts["no-build"], stopOnFail: false, quiet: opts.json, onlyRules: opts.rule ? [opts.rule] : undefined });
+    if (opts.json)
+        process.stdout.write(`${JSON.stringify({ ok: out.ok, failures: out.failures, stop: out.stop }, null, 2)}\n`);
+    else if (out.ok)
+        log.ok("All gates passed");
+    const human = out.failures.filter((f) => f.audience === "human" && f.severity === "block");
+    if (!opts.json && human.length)
+        log.warn(`${human.length} finding(s) need a person, not the agent: ${human.map((f) => f.rule_id).join(", ")}`);
+    if (!out.ok)
+        throw new CliError(`${out.results.filter((r) => r.status === "fail").length} gate(s) failed`, 2);
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export interface GlobalConfig {
+    apiUrl: string;
+    token?: string;
+}
+export declare const DEFAULT_API_URL = "https://api.nerdsystem.com";
+export declare function loadConfig(): GlobalConfig;
+export declare function saveConfig(cfg: GlobalConfig): string;

package/dist/config.js

@@ -0,0 +1,22 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const DEFAULT_API_URL = "https://api.nerdsystem.com";
+function configPath() {
+    const base = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+    return path.join(base, "nerdsystem", "config.json");
+}
+export function loadConfig() {
+    const p = configPath();
+    const file = existsSync(p) ? JSON.parse(readFileSync(p, "utf8")) : {};
+    return {
+        apiUrl: process.env.NERD_API_URL ?? file.apiUrl ?? DEFAULT_API_URL,
+        ...(process.env.NERD_TOKEN ?? file.token ? { token: process.env.NERD_TOKEN ?? file.token } : {}),
+    };
+}
+export function saveConfig(cfg) {
+    const p = configPath();
+    mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+    writeFileSync(p, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+    return p;
+}

package/dist/gates/attempts.d.ts

@@ -0,0 +1,18 @@
+import type { Finding } from "./types.js";
+/**
+ * Attempt counting for the agent loop. A rule that fails on consecutive runs gets attempt 1, 2, 3;
+ * on the fourth consecutive failure the runner stops the loop and hands the summary to a human.
+ * State lives in .nerd/attempts.json (gitignored); a rule that passes resets to zero.
+ */
+export declare const MAX_ATTEMPTS = 3;
+interface State {
+    [rule_id: string]: number;
+}
+export declare function readAttempts(root: string): State;
+export declare function writeAttempts(root: string, state: State): void;
+/** Stamps attempt numbers on findings and returns the rules that have hit the cap. */
+export declare function applyAttempts(root: string, findings: Finding[], persist?: boolean): {
+    findings: Finding[];
+    capped: string[];
+};
+export {};

package/dist/gates/attempts.js

@@ -0,0 +1,38 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * Attempt counting for the agent loop. A rule that fails on consecutive runs gets attempt 1, 2, 3;
+ * on the fourth consecutive failure the runner stops the loop and hands the summary to a human.
+ * State lives in .nerd/attempts.json (gitignored); a rule that passes resets to zero.
+ */
+export const MAX_ATTEMPTS = 3;
+function file(root) {
+    return path.join(root, ".nerd", "attempts.json");
+}
+export function readAttempts(root) {
+    try {
+        return JSON.parse(readFileSync(file(root), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeAttempts(root, state) {
+    mkdirSync(path.dirname(file(root)), { recursive: true });
+    writeFileSync(file(root), `${JSON.stringify(state, null, 2)}\n`);
+    const gi = path.join(root, ".gitignore");
+    if (existsSync(gi) && !readFileSync(gi, "utf8").includes(".nerd/"))
+        writeFileSync(gi, `${readFileSync(gi, "utf8").replace(/\n?$/, "\n")}.nerd/\n`);
+}
+/** Stamps attempt numbers on findings and returns the rules that have hit the cap. */
+export function applyAttempts(root, findings, persist = true) {
+    const prev = readAttempts(root);
+    const next = {};
+    const failedRules = new Set(findings.filter((f) => f.severity === "block").map((f) => f.rule_id));
+    for (const r of failedRules)
+        next[r] = (prev[r] ?? 0) + 1;
+    if (persist)
+        writeAttempts(root, next);
+    const capped = Array.from(failedRules).filter((r) => (next[r] ?? 0) > MAX_ATTEMPTS);
+    return { findings: findings.map((f) => ({ ...f, attempt: next[f.rule_id] ?? 1 })), capped };
+}

package/dist/gates/code.d.ts

@@ -0,0 +1,15 @@
+import { type Gate } from "./types.js";
+export declare function exec(cmd: string, args: string[], cwd: string): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function hasTool(name: string): Promise<boolean>;
+/** Platform rules, as `nerd check` enforces them. The rule text is ours, so it is safe to show verbatim. */
+export declare const rulesGate: Gate;
+export declare const typecheckGate: Gate;
+/** Known vulnerabilities in dependencies. Critical blocks; high warns. Package names come from the registry, not the repo. */
+export declare const depsGate: Gate;
+export declare const policyGate: Gate;
+/** Heuristics for careless handling of personal data. Advisory: warns, never blocks. */
+export declare const piiGate: Gate;

package/dist/gates/code.js

@@ -0,0 +1,179 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { staticChecks } from "../commands/check.js";
+import { lineOf, sourceFiles } from "./fs.js";
+import { finding } from "./secrets.js";
+import { counts, result, verdict } from "./types.js";
+export function exec(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d));
+        child.stderr.on("data", (d) => (stderr += d));
+        child.on("error", (e) => resolve({ code: 127, stdout, stderr: String(e) }));
+        child.on("exit", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+}
+export async function hasTool(name) {
+    const r = await exec(name, ["--version"], process.cwd());
+    return r.code === 0;
+}
+/** Platform rules, as `nerd check` enforces them. The rule text is ours, so it is safe to show verbatim. */
+export const rulesGate = {
+    name: "rules",
+    title: "Platform rules",
+    blocking: true,
+    rulePrefixes: ["rules/"],
+    async run(ctx) {
+        const t = Date.now();
+        const problems = staticChecks(ctx.root);
+        const findings = problems.map((p, i) => {
+            const advisory = p.endsWith("(warning)") || p.startsWith("Agent instruction files");
+            const fileMatch = /^([\w./-]+\.(ts|tsx|json|jsonc|md|yml))\b/.exec(p);
+            return finding(advisory ? "rules/advisory" : "rules/platform", { file: fileMatch?.[1], risk: advisory ? p : `${p} The app would not run correctly on the platform.`, fingerprint: `rules-${i}-${p.slice(0, 40)}` });
+        });
+        return result(this, verdict(findings), findings.length ? counts(findings) : "All platform rules pass", findings, t);
+    },
+};
+export const typecheckGate = {
+    name: "typecheck",
+    title: "TypeScript",
+    blocking: true,
+    rulePrefixes: ["typecheck/"],
+    async run(ctx) {
+        const t = Date.now();
+        const r = await exec("npx", ["tsc", "-b", "--pretty", "false"], ctx.root);
+        if (r.code === 0)
+            return result(this, "pass", "No type errors", [], t, "tsc");
+        const findings = [];
+        for (const line of `${r.stdout}\n${r.stderr}`.split("\n")) {
+            const m = /^(.+?)\((\d+),\d+\): error (TS\d+): /.exec(line.trim());
+            // The compiler's message can quote identifiers from the code, so only the file, line, and code are reported.
+            if (m)
+                findings.push(finding("typecheck/error", { file: m[1], line: Number(m[2]), fix: `Run \`npx tsc -b\` to see ${m[3]} at ${m[1]}:${m[2]} and fix it.` }));
+            if (findings.length >= 50)
+                break;
+        }
+        if (!findings.length)
+            findings.push(finding("typecheck/failed", {}));
+        return result(this, "fail", counts(findings), findings, t, "tsc");
+    },
+};
+function depsVerdictSummary(findings) {
+    if (findings.some((f) => f.rule_id === "deps/lockfile-required"))
+        return "No lockfile; commit one so installs are reproducible";
+    return findings.length ? counts(findings) : "No known vulnerabilities";
+}
+/** Known vulnerabilities in dependencies. Critical blocks; high warns. Package names come from the registry, not the repo. */
+export const depsGate = {
+    name: "dependencies",
+    title: "Dependency vulnerabilities",
+    blocking: true,
+    rulePrefixes: ["deps/"],
+    async run(ctx) {
+        const t = Date.now();
+        const findings = [];
+        const lock = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"].find((f) => existsSync(path.join(ctx.root, f)));
+        if (!lock)
+            findings.push(finding("deps/lockfile-required", {}));
+        const sev = (s) => (s.toUpperCase() === "CRITICAL" ? "deps/critical-vulnerability" : s.toUpperCase() === "HIGH" ? "deps/high-vulnerability" : "deps/advisory");
+        if (await hasTool("osv-scanner")) {
+            const r = await exec("osv-scanner", ["scan", "source", "--format", "json", "--lockfile", lock ?? "pnpm-lock.yaml"], ctx.root);
+            try {
+                const json = JSON.parse(r.stdout);
+                for (const res of json.results ?? [])
+                    for (const p of res.packages ?? [])
+                        for (const v of p.vulnerabilities) {
+                            const id = sev(v.database_specific?.severity ?? "MODERATE");
+                            findings.push(finding(id, { file: lock, fix: `Update ${p.package.name} from ${p.package.version} to a version without ${v.id} (https://osv.dev/vulnerability/${v.id}); \`pnpm update ${p.package.name}\`.`, fingerprint: `${v.id}:${p.package.name}` }));
+                        }
+                return result(this, verdict(findings), depsVerdictSummary(findings), findings, t, "osv-scanner");
+            }
+            catch {
+                // fall through to the package manager's audit
+            }
+        }
+        const pm = lock === "package-lock.json" ? "npm" : lock === "yarn.lock" ? "yarn" : "pnpm";
+        const r = await exec(pm, pm === "pnpm" ? ["audit", "--json", "--prod"] : ["audit", "--json"], ctx.root);
+        try {
+            const json = JSON.parse(r.stdout);
+            for (const a of Object.values(json.advisories ?? {})) {
+                findings.push(finding(sev(a.severity), { file: lock, fix: `Update ${a.module_name} to a fixed version${a.url ? ` (${a.url})` : ""}; \`${pm} update ${a.module_name}\`.`, fingerprint: `${a.url ?? a.module_name}` }));
+            }
+        }
+        catch {
+            if (r.code !== 0 && !r.stdout)
+                findings.push(finding("deps/audit-unavailable", {}));
+        }
+        return result(this, verdict(findings), depsVerdictSummary(findings), findings, t, `${pm} audit`);
+    },
+};
+/** Packages that have no place in a hosted web app, and size caps. Deterministic policy only. */
+import { BLOCKED_PACKAGES, MINING_POOLS } from "./text.js";
+const MAX_WORKER_BYTES = 10 * 1024 * 1024;
+const MAX_ASSET_BYTES = 25 * 1024 * 1024;
+export const policyGate = {
+    name: "policy",
+    title: "Acceptable use policy",
+    blocking: true,
+    rulePrefixes: ["policy/"],
+    async run(ctx) {
+        const t = Date.now();
+        const findings = [];
+        const pkg = JSON.parse(readFileSync(path.join(ctx.root, "package.json"), "utf8"));
+        for (const name of Object.keys(pkg.dependencies ?? {}))
+            if (BLOCKED_PACKAGES.has(name))
+                findings.push(finding("policy/blocked-package", { file: "package.json", fix: `Remove the ${name} package and the code that uses it.`, fingerprint: `blocked:${name}` }));
+        for (const f of sourceFiles(ctx.root)) {
+            const m = MINING_POOLS.exec(f.text);
+            if (m)
+                findings.push(finding("policy/mining-pool", { file: f.rel, line: lineOf(f.text, m.index) }));
+        }
+        if (ctx.build) {
+            const worker = ctx.build.modules.reduce((n, m) => n + statSync(path.join(ctx.build.workerDir, m)).size, 0);
+            const assets = ctx.build.assetsDir ? ctx.build.assets.reduce((n, a) => n + statSync(path.join(ctx.build.assetsDir, a)).size, 0) : 0;
+            if (worker > MAX_WORKER_BYTES)
+                findings.push(finding("policy/worker-size", { risk: `The server bundle is ${Math.round(worker / 1024 / 1024)} MB; the limit is ${MAX_WORKER_BYTES / 1024 / 1024} MB.` }));
+            if (assets > MAX_ASSET_BYTES)
+                findings.push(finding("policy/assets-size", { risk: `Static assets total ${Math.round(assets / 1024 / 1024)} MB; the limit is ${MAX_ASSET_BYTES / 1024 / 1024} MB.` }));
+        }
+        return result(this, verdict(findings), findings.length ? counts(findings) : "No policy violations", findings, t);
+    },
+};
+/** Heuristics for careless handling of personal data. Advisory: warns, never blocks. */
+export const piiGate = {
+    name: "pii",
+    title: "Personal data handling",
+    blocking: false,
+    rulePrefixes: ["pii/"],
+    async run(ctx) {
+        const t = Date.now();
+        const findings = [];
+        const checks = [
+            { rule: "pii/log-credentials", re: /console\.(log|info|debug|warn|error)\([^)]*\b(password|passwd|secret|token|authorization|cookie)\b/gi },
+            { rule: "pii/log-request-body", re: /console\.(log|info|debug)\([^)]*\b(req\.json\(\)|body)\b/gi },
+            { rule: "pii/email-in-query-string", re: /[?&]email=\$\{/g },
+            { rule: "pii/plaintext-password-column", re: /\b(password|passwd)\b\s*:\s*text\(/g, files: /schema\.ts$/ },
+            { rule: "pii/unscoped-user-table", re: /\.from\(schema\.(\w+)\)\s*(\.orderBy|\.limit|\.all\(\)|\.get\(\))/g },
+            { rule: "pii/wildcard-cors", re: /Access-Control-Allow-Origin["']?\s*[:,]\s*["']\*["']/g },
+        ];
+        for (const f of sourceFiles(ctx.root)) {
+            if (!/\.(ts|tsx|js|jsx|mjs)$/.test(f.rel) || !f.rel.startsWith("src/"))
+                continue;
+            for (const c of checks) {
+                if (c.files && !c.files.test(f.rel))
+                    continue;
+                c.re.lastIndex = 0;
+                let m;
+                while ((m = c.re.exec(f.text))) {
+                    if (c.rule === "pii/unscoped-user-table" && !/user_id|userId/.test(f.text))
+                        continue;
+                    findings.push(finding(c.rule, { file: f.rel, line: lineOf(f.text, m.index) }));
+                }
+            }
+        }
+        return result(this, verdict(findings), findings.length ? counts(findings) : "Nothing flagged", findings, t);
+    },
+};

package/dist/gates/fs.d.ts

@@ -0,0 +1,7 @@
+export interface SourceFile {
+    rel: string;
+    text: string;
+}
+/** Text files under root, skipping dependencies and build output. */
+export declare function sourceFiles(root: string): SourceFile[];
+export declare function lineOf(text: string, index: number): number;

package/dist/gates/fs.js

@@ -0,0 +1,35 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", ".wrangler", ".vite", "coverage"]);
+const TEXT_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".jsonc", ".md", ".mdc", ".yml", ".yaml", ".toml", ".env", ".txt", ".html", ".css", ".sql", ".example"]);
+const MAX_BYTES = 2 * 1024 * 1024;
+/** Text files under root, skipping dependencies and build output. */
+export function sourceFiles(root) {
+    const out = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = path.join(dir, entry);
+            const st = statSync(full);
+            if (st.isDirectory()) {
+                if (!SKIP_DIRS.has(entry))
+                    walk(full);
+                continue;
+            }
+            const ext = path.extname(entry) || (entry.startsWith(".env") ? ".env" : "");
+            if (!TEXT_EXT.has(ext) && !entry.startsWith(".env"))
+                continue;
+            if (st.size > MAX_BYTES)
+                continue;
+            out.push({ rel: path.relative(root, full).split(path.sep).join("/"), text: readFileSync(full, "utf8") });
+        }
+    };
+    walk(root);
+    return out;
+}
+export function lineOf(text, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            line++;
+    return line;
+}

package/dist/gates/index.d.ts

@@ -0,0 +1,26 @@
+import type { Finding, Gate, GateContext, GateResult } from "./types.js";
+export type { Audience, Finding, Gate, GateContext, GateResult, GateStatus, Severity } from "./types.js";
+export { RULES, ruleFor, type RuleDef } from "./rules.js";
+export { mask } from "./secrets.js";
+export { MAX_ATTEMPTS, readAttempts } from "./attempts.js";
+/** Gates that run on source, before the build. Suppressions first so a human sees them before anything else. */
+export declare const SOURCE_GATES: Gate[];
+/** Gates that need the built output. */
+export declare const BUILD_GATES: Gate[];
+export interface GateRun {
+    results: GateResult[];
+    ok: boolean;
+    failed: GateResult[];
+    /** Every finding across gates, attempt-stamped, the agent's work list. */
+    failures: Finding[];
+    /** Rules that failed more than MAX_ATTEMPTS consecutive runs: stop and ask a person. */
+    capped: string[];
+}
+/** Runs gates in order, stopping after the first blocking failure so logs stay readable. */
+export declare function runGates(gates: Gate[], ctx: GateContext, opts?: {
+    stopOnFail?: boolean;
+    trackAttempts?: boolean;
+}): Promise<GateRun>;
+export declare function icon(status: GateResult["status"]): string;
+/** Reads server-side secret values from .dev.vars so the bundle gate can detect them in output. */
+export declare function knownSecretsFrom(vars: Record<string, string>): string[];

package/dist/gates/index.js

@@ -0,0 +1,68 @@
+import { bundleGate, finding, secretsGate } from "./secrets.js";
+import { depsGate, piiGate, policyGate, rulesGate, typecheckGate } from "./code.js";
+import { gitleaksGate, semgrepGate } from "./tools.js";
+import { suppressionsGate } from "./suppressions.js";
+import { applyAttempts, MAX_ATTEMPTS } from "./attempts.js";
+export { RULES, ruleFor } from "./rules.js";
+export { mask } from "./secrets.js";
+export { MAX_ATTEMPTS, readAttempts } from "./attempts.js";
+/** Gates that run on source, before the build. Suppressions first so a human sees them before anything else. */
+export const SOURCE_GATES = [suppressionsGate, secretsGate, gitleaksGate, depsGate, rulesGate, semgrepGate, policyGate, piiGate, typecheckGate];
+/** Gates that need the built output. */
+export const BUILD_GATES = [bundleGate, policyGate];
+function selectGates(gates, onlyRules) {
+    if (!onlyRules?.length)
+        return gates;
+    return gates.filter((g) => onlyRules.some((r) => g.rulePrefixes.some((p) => r.startsWith(p))));
+}
+/** Runs gates in order, stopping after the first blocking failure so logs stay readable. */
+export async function runGates(gates, ctx, opts = {}) {
+    const results = [];
+    for (const g of selectGates(gates, ctx.onlyRules)) {
+        ctx.log(`› ${g.title}`);
+        let r;
+        try {
+            r = await g.run(ctx);
+        }
+        catch (err) {
+            r = { name: g.name, title: g.title, status: "warn", summary: `Gate crashed: ${err instanceof Error ? err.message : String(err)}`, findings: [], durationMs: 0, tool: "builtin" };
+        }
+        if (ctx.onlyRules?.length)
+            r = { ...r, findings: r.findings.filter((f) => ctx.onlyRules.some((x) => f.rule_id.startsWith(x))) };
+        results.push(r);
+        ctx.log(`  ${icon(r.status)} ${r.summary}${r.status === "skip" ? "" : ` (${r.durationMs} ms)`}`);
+        for (const f of r.findings.slice(0, 20))
+            ctx.log(`    ${f.severity === "block" ? "✗" : f.severity === "warn" ? "!" : "·"} ${f.rule_id}${f.file ? ` ${f.file}${f.line ? `:${f.line}` : ""}` : ""}${f.masked ? ` (${f.masked})` : ""}${f.audience === "human" ? " [needs a person]" : ""}\n      ${f.risk}\n      Fix: ${f.fix}`);
+        if (r.findings.length > 20)
+            ctx.log(`    … ${r.findings.length - 20} more`);
+        if (r.status === "fail" && g.blocking && opts.stopOnFail)
+            break;
+    }
+    let failures = results.flatMap((r) => r.findings);
+    let capped = [];
+    if (opts.trackAttempts !== false) {
+        const a = applyAttempts(ctx.root, failures);
+        failures = a.findings;
+        capped = a.capped;
+        if (capped.length) {
+            const cap = finding("gates/retry-cap", { risk: `${capped.join(", ")} failed ${MAX_ATTEMPTS + 1} runs in a row. Automatic fixing stopped.`, attempt: MAX_ATTEMPTS + 1 });
+            failures.push(cap);
+            const last = results[results.length - 1];
+            if (last)
+                last.findings.push(cap);
+            ctx.log(`  ✗ ${cap.risk}\n      ${cap.fix}`);
+        }
+    }
+    const failed = results.filter((r) => r.status === "fail");
+    return { results, ok: failed.length === 0, failed, failures, capped };
+}
+export function icon(status) {
+    return status === "pass" ? "✓" : status === "warn" ? "!" : status === "fail" ? "✗" : "–";
+}
+/** Reads server-side secret values from .dev.vars so the bundle gate can detect them in output. */
+export function knownSecretsFrom(vars) {
+    return Object.entries(vars)
+        .filter(([k]) => /SECRET|KEY|TOKEN|PASSWORD/i.test(k) && !/^VITE_/.test(k))
+        .map(([, v]) => v)
+        .filter((v) => v.length >= 12);
+}

package/dist/gates/rules.d.ts

@@ -0,0 +1,19 @@
+import type { Audience, Severity } from "./types.js";
+/**
+ * The rule catalog. Every finding's text comes from here, with only file, line, and a masked value
+ * substituted. `example` shows the wrong and the right pattern for explain_failure.
+ */
+export interface RuleDef {
+    title: string;
+    severity: Severity;
+    audience: Audience;
+    risk: string;
+    fix: string;
+    example?: {
+        wrong: string;
+        right: string;
+    };
+}
+export declare const RULES: Record<string, RuleDef>;
+/** Fallback for scanner rule ids not in the catalog (semgrep and gitleaks have their own). */
+export declare function ruleFor(id: string, fallback?: Partial<RuleDef>): RuleDef;