@reddoorla/maintenance 0.69.0 → 0.72.0

package/dist/{chunk-6G7BC5SN.js → chunk-BHE5CUWI.js}

@@ -19,7 +19,7 @@ import {
 import {
   a11yRoutes,
   smokeRoutes
-} from "./chunk-LYCKN7ZR.js";
+} from "./chunk-LJPCMXR7.js";
 
 // src/audits/deps.ts
 import { readFile } from "fs/promises";
@@ -496,7 +496,10 @@ async function dependabotAudit(deps, repo, label) {
   let alerts;
   try {
     alerts = await deps.listAlerts(repo);
-  } catch {
+  } catch (e) {
+    console.error(
+      `[security] ${label}: dependabot API failed \u2014 degraded to pnpm audit: ${e instanceof Error ? e.message : String(e)}`
+    );
     return null;
   }
   const counts = { low: 0, moderate: 0, high: 0, critical: 0 };
@@ -1187,11 +1190,29 @@ function summarizeBrowser(routes, links, familyCounts) {
   const mobileOk = routes.length > 0 && routes.every((r) => r.mobile.length > 0 && r.mobile.every((m) => m.ok));
   const brokenLinks = links.filter((l) => isBroken(l.status)).length;
   const linksOk = links.length > 0 && brokenLinks === 0;
+  const reachableOk = routes.length > 0 && routes.every((r) => r.status !== null && r.status >= 200 && r.status < 400);
+  const trimmedTitles = routes.map((r) => (r.title ?? "").trim());
+  const eachTitleMetaValid = routes.length > 0 && routes.every((r, i) => {
+    const t = trimmedTitles[i];
+    const desc = (r.metaDescription ?? "").trim();
+    return t.length > 0 && t.length <= 70 && desc.length > 0;
+  });
+  const noDuplicateTitles = new Set(trimmedTitles).size === trimmedTitles.length;
+  const titleMetaOk = eachTitleMetaValid && noDuplicateTitles;
   const engines = [...new Set(desktopChecks.map((d) => d.engine))];
   const devices = [...new Set(mobileChecks.map((m) => m.device))];
   const families = Object.entries(familyCounts).map(([f, n]) => f === "/" ? "/" : `${f} \xD7${n}`).join(", ");
   const note = `${routes.length} routes (${families}); desktop ${engines.join("/") || "\u2014"}; mobile ${devices.join("/") || "\u2014"}; ${links.length} links, ${brokenLinks} broken`;
-  return { desktopOk, mobileOk, linksOk, brokenLinks, routesChecked: routes.length, note };
+  return {
+    desktopOk,
+    mobileOk,
+    linksOk,
+    reachableOk,
+    titleMetaOk,
+    brokenLinks,
+    routesChecked: routes.length,
+    note
+  };
 }
 async function browserAudit(ctx) {
   const { site } = ctx;
@@ -1263,6 +1284,9 @@ async function defaultBrowserRunner() {
         for (const url of urls) {
           const desktop = [];
           const linkSet = /* @__PURE__ */ new Set();
+          let status = null;
+          let title = null;
+          let metaDescription = null;
           for (let i = 0; i < desktopEngines.length; i++) {
             const engine = desktopEngines[i].engine;
             const browser = browsers[i];
@@ -1279,6 +1303,11 @@ async function defaultBrowserRunner() {
               const hasMain = await page.locator("main, [role=main]").first().isVisible().catch(() => false);
               ok = !!resp && resp.ok() && errors.length === 0 && hasMain;
               if (engine === "chromium") {
+                status = resp ? resp.status() : null;
+                title = (await page.title().catch(() => "")).trim() || null;
+                metaDescription = (await page.evaluate(
+                  `document.querySelector('meta[name="description"]')?.getAttribute('content') || ''`
+                ).catch(() => "") || "").trim() || null;
                 const hrefs = await page.evaluate("Array.from(document.querySelectorAll('a[href]')).map((a) => a.href)").catch(() => []);
                 const origin = new URL(url).origin;
                 for (const h of hrefs) {
@@ -1320,7 +1349,15 @@ async function defaultBrowserRunner() {
             }
             mobile.push({ device, ok });
           }
-          results.push({ url, desktop, mobile, links: [...linkSet] });
+          results.push({
+            url,
+            desktop,
+            mobile,
+            links: [...linkSet],
+            status,
+            title,
+            metaDescription
+          });
         }
       } finally {
         await Promise.all([...browsers, ...mobileBrowsers].map((b) => b.close().catch(() => {
@@ -1357,6 +1394,7 @@ async function defaultBrowserRunner() {
 }
 
 // src/audits/netlify-deploy.ts
+var NETLIFY_FETCH_TIMEOUT_MS = 15e3;
 var READY_STATES = /* @__PURE__ */ new Set(["ready"]);
 var FAILED_STATES = /* @__PURE__ */ new Set(["error", "failed", "rejected"]);
 function isReadyState(state) {
@@ -1381,7 +1419,8 @@ function defaultNetlifyDeployDeps(token, now, fetchImpl = fetch) {
       let res;
       try {
         res = await fetchImpl(url, {
-          headers: { Authorization: `Bearer ${token}` }
+          headers: { Authorization: `Bearer ${token}` },
+          signal: AbortSignal.timeout(NETLIFY_FETCH_TIMEOUT_MS)
         });
       } catch {
         return { ok: false };
@@ -1456,6 +1495,349 @@ async function netlifyDeployAudit(ctx) {
   };
 }
 
+// src/audits/function-health.ts
+var HEALTH_TIMEOUT_MS = 1e4;
+var ERRORING_BODY = { ok: false, prismic: null, forms: null };
+function parseHealthBody(raw) {
+  if (!raw || typeof raw !== "object") return { present: false };
+  const o = raw;
+  if (typeof o["ok"] !== "boolean") return { present: false };
+  const prismic = o["prismic"] === "ok" || o["prismic"] === "error" || o["prismic"] === "skipped" ? o["prismic"] : null;
+  const f = o["forms"];
+  const forms = f && typeof f === "object" ? {
+    ingestUrl: f["ingestUrl"] === true,
+    ingestToken: f["ingestToken"] === true,
+    turnstile: f["turnstile"] === true
+  } : null;
+  return { present: true, body: { ok: o["ok"], prismic, forms } };
+}
+function defaultFunctionHealthDeps(now, fetchImpl = fetch) {
+  return {
+    now,
+    fetchHealth: async (deployedUrl) => {
+      let url;
+      try {
+        url = new URL("/health", deployedUrl).toString();
+      } catch {
+        return { present: false };
+      }
+      let res;
+      try {
+        res = await fetchImpl(url, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) });
+      } catch {
+        return { present: false };
+      }
+      if (res.status === 404) return { present: false };
+      if (!res.ok) return { present: true, body: ERRORING_BODY };
+      let body;
+      try {
+        body = await res.json();
+      } catch {
+        return { present: true, body: ERRORING_BODY };
+      }
+      return parseHealthBody(body);
+    }
+  };
+}
+async function functionHealthAudit(ctx) {
+  const { site } = ctx;
+  const label = siteLabel(site);
+  if (!site.deployedUrl) {
+    return { audit: "function-health", site: label, status: "skip", summary: "no deployed URL" };
+  }
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const deps = ctx.functionHealthDeps ?? defaultFunctionHealthDeps(now);
+  const fetched = await deps.fetchHealth(site.deployedUrl).catch(() => ({ present: false }));
+  if (!fetched.present) {
+    return {
+      audit: "function-health",
+      site: label,
+      status: "skip",
+      summary: "health endpoint unreachable / not adopted"
+    };
+  }
+  const checkedAt = now.toISOString();
+  const status = fetched.body.ok ? "pass" : "fail";
+  const summary = `health ${fetched.body.ok ? "ok" : "not ok"} (prismic ${fetched.body.prismic ?? "?"})`;
+  return {
+    audit: "function-health",
+    site: label,
+    status,
+    summary,
+    details: {
+      ok: fetched.body.ok,
+      prismic: fetched.body.prismic,
+      forms: fetched.body.forms,
+      checkedAt
+    }
+  };
+}
+
+// src/audits/smoke.ts
+import { access, readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function summarizeSmokeFailure(stdout, stderr) {
+  const lines = stdout.replace(ANSI, "").split("\n").map((l) => l.trim());
+  const failing = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (/^\d+\)\s/.test(line)) {
+      failing.push(line);
+      let taken = 0;
+      for (let j = i + 1; j < lines.length && taken < 3; j++) {
+        const next = lines[j];
+        if (!next) continue;
+        if (/^\d+\)\s/.test(next)) break;
+        failing.push(next);
+        taken++;
+      }
+      break;
+    }
+  }
+  const tally = lines.find((l) => l !== void 0 && /\b\d+\s+failed\b/.test(l));
+  const distilled = [tally, ...failing].filter(Boolean).join(" | ");
+  if (distilled) return distilled.slice(0, 300);
+  const err = stderr.replace(ANSI, "").trim();
+  return err ? err.slice(0, 200) : "no reporter output";
+}
+async function hasTestSmokeScript(sitePath) {
+  try {
+    const raw = await readFile6(join7(sitePath, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return typeof pkg.scripts?.["test:smoke"] === "string";
+  } catch {
+    return false;
+  }
+}
+async function hasNodeModules(sitePath) {
+  try {
+    await access(join7(sitePath, "node_modules"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function smokeAudit(ctx) {
+  const spawn = ctx.spawn ?? defaultSpawn;
+  const site = ctx.site;
+  const label = siteLabel(site);
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  if (!await hasTestSmokeScript(site.path)) {
+    return {
+      audit: "smoke",
+      site: label,
+      status: "skip",
+      summary: "no test:smoke script"
+    };
+  }
+  if (!await hasNodeModules(site.path)) {
+    let install;
+    try {
+      install = await spawn("pnpm", ["install", "--frozen-lockfile"], {
+        cwd: site.path,
+        timeoutMs: 5 * 6e4
+      });
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOENT" || /ENOENT/.test(String(err))) {
+        return { audit: "smoke", site: label, status: "skip", summary: "pnpm not available" };
+      }
+      throw err;
+    }
+    if (install.code !== 0) {
+      const retry = await spawn("pnpm", ["install"], { cwd: site.path, timeoutMs: 5 * 6e4 });
+      if (retry.code !== 0) {
+        return {
+          audit: "smoke",
+          site: label,
+          status: "skip",
+          summary: `smoke: pnpm install failed (exit ${retry.code}) \u2014 deps unavailable`
+        };
+      }
+    }
+  }
+  const port = await findFreePort();
+  let raw;
+  try {
+    raw = await spawn("pnpm", ["test:smoke"], {
+      cwd: site.path,
+      env: { ...process.env, REDDOOR_SMOKE_PORT: String(port) },
+      // Playwright on a cold tree installs chromium, boots the site's dev server,
+      // and runs the smoke specs — the shared 30s default starves it (mirrors a11y).
+      timeoutMs: 5 * 6e4
+    });
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT" || /ENOENT/.test(String(err))) {
+      return { audit: "smoke", site: label, status: "skip", summary: "pnpm not available" };
+    }
+    throw err;
+  }
+  if (raw.code === 0) {
+    return {
+      audit: "smoke",
+      site: label,
+      status: "pass",
+      summary: "smoke: suite green",
+      details: { ok: "pass", checkedAt }
+    };
+  }
+  return {
+    audit: "smoke",
+    site: label,
+    status: "fail",
+    summary: `smoke: suite failed (exit ${raw.code}) \u2014 ${summarizeSmokeFailure(raw.stdout, raw.stderr)}`,
+    details: { ok: "fail", checkedAt }
+  };
+}
+
+// src/audits/form-e2e.ts
+var CF_TEST_SITEKEY = "1x00000000000000000000AA";
+var CONTACT_PATH = "/contact";
+var LIVE_ENV_VAR = "REDDOOR_FORM_E2E_LIVE";
+function liveRunnerEnabled(env = process.env) {
+  return env[LIVE_ENV_VAR] === "1" || env[LIVE_ENV_VAR] === "true";
+}
+async function formE2eAudit(ctx) {
+  const { site } = ctx;
+  const label = siteLabel(site);
+  if (!site.deployedUrl) {
+    return { audit: "form-e2e", site: label, status: "skip", summary: "no deployed URL" };
+  }
+  if (!ctx.formRunner && !liveRunnerEnabled()) {
+    return {
+      audit: "form-e2e",
+      site: label,
+      status: "skip",
+      summary: `live form-e2e disabled (central testMode ingest suppression not yet wired \u2014 set ${LIVE_ENV_VAR}=1 once it is)`
+    };
+  }
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const runner = ctx.formRunner ?? await defaultFormRunner();
+  try {
+    const outcome = await runner.submit({
+      baseUrl: site.deployedUrl,
+      testMode: true,
+      testSitekey: CF_TEST_SITEKEY
+    });
+    if ("testModeUndeclared" in outcome) {
+      return {
+        audit: "form-e2e",
+        site: label,
+        status: "skip",
+        summary: "site /health does not declare forms.testMode \u2014 probe refused (testMode forwarding not yet rolled out here)"
+      };
+    }
+    if (!outcome.formPresent) {
+      return {
+        audit: "form-e2e",
+        site: label,
+        status: "skip",
+        summary: "no contact form (n/a)",
+        details: { ok: null, formPresent: false, checkedAt }
+      };
+    }
+    const ok = outcome.success ? "pass" : "fail";
+    return {
+      audit: "form-e2e",
+      site: label,
+      status: outcome.success ? "pass" : "warn",
+      summary: outcome.success ? "form-e2e: synthetic submission succeeded" : `form-e2e: synthetic submission failed${outcome.detail ? ` \u2014 ${outcome.detail}` : ""}`,
+      details: { ok, formPresent: true, checkedAt }
+    };
+  } finally {
+    await runner.close?.();
+  }
+}
+var FILL_SETTLE_MS = 1200;
+var PAGE_TIMEOUT_MS2 = 3e4;
+var HEALTH_TIMEOUT_MS2 = 1e4;
+async function declaresTestModeForwarding(baseUrl) {
+  try {
+    const res = await fetch(new URL("/health", baseUrl), {
+      signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS2)
+    });
+    if (!res.ok) return false;
+    const body = await res.json();
+    if (typeof body !== "object" || body === null) return false;
+    const forms = body.forms;
+    if (typeof forms !== "object" || forms === null) return false;
+    return forms.testMode === true;
+  } catch {
+    return false;
+  }
+}
+async function defaultFormRunner() {
+  const { chromium } = await import("@playwright/test");
+  return {
+    async submit({ baseUrl, testSitekey }) {
+      if (!await declaresTestModeForwarding(baseUrl)) {
+        return { testModeUndeclared: true };
+      }
+      const browser = await chromium.launch();
+      try {
+        const ctx = await browser.newContext();
+        const page = await ctx.newPage();
+        const url = new URL(CONTACT_PATH, baseUrl).toString();
+        const resp = await page.goto(url, { waitUntil: "domcontentloaded", timeout: PAGE_TIMEOUT_MS2 }).catch(() => null);
+        const form = page.locator("form").first();
+        const hasForm = !!resp && resp.ok() && await form.count().catch(() => 0) > 0 && await page.locator('input[name="email"], input[type="email"]').count().catch(() => 0) > 0;
+        if (!hasForm) return { formPresent: false };
+        await page.fill('[name="name"]', "Reddoor Monitor").catch(() => {
+        });
+        await page.fill('[name="email"]', "monitor+e2e@reddoorla.com").catch(() => {
+        });
+        await page.fill('[name="phone"]', "5555550123").catch(() => {
+        });
+        await page.fill('[name="message"]', "Synthetic end-to-end health check \u2014 please ignore.").catch(() => {
+        });
+        await page.evaluate(`
+          (function () {
+            const f = document.querySelector("form");
+            if (!f) return;
+            const add = (name, value) => {
+              let el = f.querySelector('input[name="' + name + '"]');
+              if (!el) {
+                el = document.createElement("input");
+                el.type = "hidden";
+                el.name = name;
+                f.appendChild(el);
+              }
+              el.value = value;
+            };
+            add("testMode", "true");
+            add("cf-turnstile-response", ${JSON.stringify(`testmode-${testSitekey}`)});
+          })();
+        `);
+        await page.waitForTimeout(FILL_SETTLE_MS);
+        const postResponse = page.waitForResponse((r) => r.request().method() === "POST", {
+          timeout: PAGE_TIMEOUT_MS2
+        }).catch(() => null);
+        await page.locator('button[type="submit"], input[type="submit"]').first().click({ timeout: PAGE_TIMEOUT_MS2 });
+        const ok = await page.locator('[role="status"]').first().waitFor({ state: "visible", timeout: PAGE_TIMEOUT_MS2 }).then(() => true).catch(() => false);
+        if (ok) return { formPresent: true, success: true };
+        const actionResp = await postResponse;
+        const alertText = await page.locator('[role="alert"]').first().textContent({ timeout: 1e3 }).catch(() => null);
+        const respBit = actionResp ? `POST ${actionResp.status()}${actionResp.status() >= 400 ? ` ${(await actionResp.text().catch(() => "")).slice(0, 80)}` : ""}` : "no POST observed";
+        return {
+          formPresent: true,
+          success: false,
+          detail: `no success banner after submit \u2014 ${respBit}${alertText ? `; alert: ${alertText.trim().slice(0, 80)}` : ""}`
+        };
+      } catch (err) {
+        return { formPresent: true, success: false, detail: String(err).slice(0, 120) };
+      } finally {
+        await browser.close().catch(() => {
+        });
+      }
+    }
+  };
+}
+
 // src/audits/index.ts
 var REGISTRY = {
   deps: depsAudit,
@@ -1465,7 +1847,10 @@ var REGISTRY = {
   a11y: a11yAudit,
   domain: domainAudit,
   browser: browserAudit,
-  "netlify-deploy": netlifyDeployAudit
+  "netlify-deploy": netlifyDeployAudit,
+  "function-health": functionHealthAudit,
+  smoke: smokeAudit,
+  "form-e2e": formE2eAudit
 };
 var ALL_AUDIT_NAMES = Object.keys(REGISTRY);
 var DEFAULT_AUDIT_TIMEOUT_MS = 3e4;
@@ -1510,4 +1895,4 @@ export {
   runAudits,
   runAuditsAcross
 };
-//# sourceMappingURL=chunk-6G7BC5SN.js.map
+//# sourceMappingURL=chunk-BHE5CUWI.js.map