nerdsystem 0.0.18 → 0.0.19

package/dist/commands/deploy.js

@@ -8,6 +8,7 @@ import { CliError, log, printJson, runOrThrow, table, dashboardUrl, ensureDeps }
 import { runChecks } from "./check.js";
 import { appendLineage, cliVersion, LOCAL_ONLY_NOTE, packProject, readLineage, uploadSnapshot, uploadStopMessage } from "./source.js";
 import { lockedGetPaths } from "../gates/tests.js";
+import { platformScan } from "./platform-scan.js";
 import { BUILD_GATES, gateSummary, knownSecretsFrom, probeDeployment, runGates, skippedProbe, SOURCE_GATES, waitForDeployment } from "../gates/index.js";
 const MODULE_EXT = new Set([".js", ".mjs", ".wasm"]);
 function walk(dir, base = dir) {
@@ -155,6 +156,8 @@ export async function shipBuild(args) {
         appendLineage(root, source.id);
         // "Stored", not "saved": the one line that says "saved" is the final one, which also says the work after it is only on this computer (invariant 7).
         log.ok(`Stored ${pack.fileCount} files (${formatMb(pack.bytes)}) as ${source.id}`);
+        // The scanners this computer lacks run on the platform against the copy just stored, before migrations or upload.
+        args.results = await platformScan(api, `${projectPath(nerd)}/sources/${source.id}`, args.results);
     }
     log.step("Applying migrations to the production database");
     const mig = await applyRemoteMigrations(root, api);

package/dist/commands/init.js

@@ -192,4 +192,4 @@ export async function init(dir, args) {
     log.ok(`Ready. Next:\n  cd ${dir}\n  pnpm install\n  nerd dev\n\nThen open the folder in your coding agent and ask it to build the first feature; the nerdsystem skill walks it through.\nDeploys go to ${project.url}`);
 }
 // Kept in sync with packages/sdk/package.json by the release script.
-const SDK_VERSION = "0.0.18";
+const SDK_VERSION = "0.0.19";

package/dist/commands/platform-scan.d.ts

@@ -0,0 +1,18 @@
+import type { ApiClient } from "../api.js";
+import type { GateResult } from "../gates/index.js";
+export interface PlatformScanOptions {
+    /** How long the deploy waits for the answer. */
+    timeoutMs?: number;
+    pollMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * When gitleaks or semgrep did not run here because they are not installed, has the platform run them
+ * on the copy of the code that was just stored, and waits for the answer before anything goes live.
+ * Returns the gate results with the platform's answers in place of the skipped ones.
+ *
+ * A blocking finding stops the deploy, exactly as it would have locally. Anything else that goes wrong
+ * (the scanners are busy or down, the hourly allowance is used, the answer is late) does not: the two
+ * results stay "skip" with the reason, because a platform hiccup must not be what keeps an app offline.
+ */
+export declare function platformScan(api: ApiClient, sourcePath: string, results: GateResult[], opts?: PlatformScanOptions): Promise<GateResult[]>;

package/dist/commands/platform-scan.js

@@ -0,0 +1,58 @@
+import { CliError, log } from "../util.js";
+/** The two scanners most computers do not have. The platform's builder has both. */
+const SCANNERS = ["gitleaks", "semgrep"];
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * When gitleaks or semgrep did not run here because they are not installed, has the platform run them
+ * on the copy of the code that was just stored, and waits for the answer before anything goes live.
+ * Returns the gate results with the platform's answers in place of the skipped ones.
+ *
+ * A blocking finding stops the deploy, exactly as it would have locally. Anything else that goes wrong
+ * (the scanners are busy or down, the hourly allowance is used, the answer is late) does not: the two
+ * results stay "skip" with the reason, because a platform hiccup must not be what keeps an app offline.
+ */
+export async function platformScan(api, sourcePath, results, opts = {}) {
+    const missing = results.filter((r) => SCANNERS.includes(r.name) && r.status === "skip");
+    if (!missing.length)
+        return results;
+    const sleep = opts.sleep ?? defaultSleep;
+    const pollMs = opts.pollMs ?? 2500;
+    const deadline = Date.now() + (opts.timeoutMs ?? 150_000);
+    const skipped = (reason) => results.map((r) => (missing.includes(r) ? { ...r, summary: `${r.name} is not installed here, and the platform's scan ${reason}` } : r));
+    log.step(`Scanning the stored code on the platform (${missing.map((m) => m.name).join(" and ")} are not installed here)`);
+    let scan;
+    try {
+        scan = (await api.post(`${sourcePath}/scan`)).scan;
+        while ((scan.status === "queued" || scan.status === "running") && Date.now() < deadline) {
+            await sleep(pollMs);
+            const next = (await api.get(`${sourcePath}/scan`)).scan;
+            if (next)
+                scan = next;
+        }
+    }
+    catch (err) {
+        const why = err instanceof CliError && err.status === 429 ? "was not run: this organization has used its scans for the hour" : "could not be started";
+        log.warn(`The platform's scan ${why}. Continuing with the checks that ran here.`);
+        return skipped(why);
+    }
+    if (scan.status !== "done" || !scan.results) {
+        const why = scan.status === "failed" ? "failed" : "did not answer in time";
+        log.warn(`The platform's scan ${why}. Continuing with the checks that ran here.`);
+        return skipped(why);
+    }
+    const answered = new Map(scan.results.filter((r) => SCANNERS.includes(r.name)).map((r) => [r.name, r]));
+    const merged = results.map((r) => (missing.includes(r) && answered.has(r.name) ? { ...answered.get(r.name), summary: `${answered.get(r.name).summary} (scanned on the platform)` } : r));
+    const ran = merged.filter((r) => missing.some((m) => m.name === r.name));
+    for (const r of ran) {
+        log.info(`  ${r.status === "pass" ? "✓" : r.status === "fail" ? "✗" : r.status === "warn" ? "!" : "–"} ${r.title}: ${r.summary}`);
+        for (const f of r.findings.slice(0, 20)) {
+            log.info(`    ${f.severity === "block" ? "✗" : "!"} ${f.rule_id}${f.file ? ` ${f.file}${f.line ? `:${f.line}` : ""}` : ""}${f.masked ? ` (${f.masked})` : ""}`);
+            log.info(`      ${f.risk}`);
+            log.info(`      Fix: ${f.fix}`);
+        }
+    }
+    const blocked = ran.filter((r) => r.status === "fail");
+    if (blocked.length)
+        throw new CliError(`Blocked by: ${blocked.map((g) => g.title).join(", ")}. Nothing went live. Fix the findings above, then deploy again.`, 2, { code: "gate_failed" });
+    return merged;
+}

package/dist/gates/tools.js

@@ -53,6 +53,10 @@ export const semgrepGate = {
         const findings = [];
         try {
             const json = JSON.parse(r.stdout);
+            // Semgrep exits 0 and reports nothing when its rules file does not load, which reads exactly like a clean
+            // scan. That hid a broken rules file from 2026-11-02 to 2026-11-10: a run that could not use the rules is not a pass.
+            if ((json.errors ?? []).some((e) => e.level === "error" && /SemgrepError|InvalidRule|config/i.test(e.type ?? "")))
+                return result(this, "warn", "semgrep could not load its rules", [], t, "semgrep");
             for (const x of json.results.slice(0, 100)) {
                 const short = x.check_id.split(".").pop() ?? x.check_id;
                 const rule_id = `semgrep/${short}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nerdsystem",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "nerd: start, check, and deploy a web app on nerdsystem from the terminal or a coding agent.",
   "type": "module",
   "bin": {

package/rules/semgrep.yml

@@ -22,8 +22,9 @@ rules:
     severity: WARNING
     message: dangerouslySetInnerHTML with a non-literal value can inject scripts. Sanitize or avoid.
     patterns:
-      - pattern: dangerouslySetInnerHTML={{ __html: $X }}
-      - pattern-not: dangerouslySetInnerHTML={{ __html: "..." }}
+      # Quoted: an unquoted "__html: $X" reads as a YAML mapping and makes the whole file invalid.
+      - pattern: '<$EL dangerouslySetInnerHTML={{ __html: $X }} />'
+      - pattern-not: '<$EL dangerouslySetInnerHTML={{ __html: "..." }} />'
   - id: nerd-innerhtml-assignment
     languages: [typescript, javascript]
     severity: WARNING