@reddoorla/maintenance 0.7.0 → 0.9.0

package/dist/cli/commands/audit.d.ts

@@ -4,6 +4,12 @@ type AuditCommandOptions = {
     fleet?: string;
     workdir?: string;
     cwd?: string;
+    /**
+     * After running, push the lighthouse scores to the matching Websites row
+     * in Airtable. `true` (no value) = derive slug from cwd/package.json#name;
+     * string = explicit slug (e.g. "med-solutions-of-texas").
+     */
+    writeAirtable?: string | boolean;
 };
 declare function runAuditCommand(site: string | undefined, opts: AuditCommandOptions): Promise<{
     output: string;

package/dist/cli/commands/audit.js

@@ -1,3 +1,179 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/reports/airtable/client.ts
+var client_exports = {};
+__export(client_exports, {
+  openBase: () => openBase,
+  readAirtableConfig: () => readAirtableConfig
+});
+import Airtable from "airtable";
+function readAirtableConfig() {
+  const apiKey = process.env.AIRTABLE_PAT;
+  const baseId = process.env.AIRTABLE_BASE_ID;
+  if (!apiKey) throw Object.assign(new Error("AIRTABLE_PAT not set"), { exitCode: 2 });
+  if (!baseId) throw Object.assign(new Error("AIRTABLE_BASE_ID not set"), { exitCode: 2 });
+  return { apiKey, baseId };
+}
+function openBase(cfg) {
+  return new Airtable({ apiKey: cfg.apiKey }).base(cfg.baseId);
+}
+var init_client = __esm({
+  "src/reports/airtable/client.ts"() {
+    "use strict";
+  }
+});
+
+// src/reports/airtable/websites.ts
+var websites_exports = {};
+__export(websites_exports, {
+  WEBSITES_TABLE: () => WEBSITES_TABLE,
+  getWebsiteBySlug: () => getWebsiteBySlug,
+  listWebsites: () => listWebsites,
+  siteSlug: () => siteSlug,
+  updateScores: () => updateScores
+});
+function siteSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function mapRow(rec) {
+  const f = rec.fields;
+  const attachments = f["Header image"] ?? [];
+  const header = attachments[0] ?? null;
+  return {
+    id: rec.id,
+    name: String(f["Name"] ?? ""),
+    url: String(f["url"] ?? ""),
+    status: f["Status"] ?? null,
+    pointOfContact: f["point of contact"] ?? null,
+    maintenanceFreq: f["maintenence freq"] ?? "None",
+    testingFreq: f["testing freq"] ?? "None",
+    maintenanceDay: f["maintenance day"] ?? null,
+    testingDay: f["testing day"] ?? null,
+    ga4PropertyId: f["GA4 property ID"] ?? null,
+    reportRecipientsTo: f["Report recipients (To)"] ?? null,
+    reportRecipientsCc: f["Report recipients (CC)"] ?? null,
+    headerImage: header,
+    pScore: f["pScore"] ?? null,
+    rScore: f["rScore"] ?? null,
+    bpScore: f["bpScore"] ?? null,
+    seoScore: f["seoScore"] ?? null,
+    lastLighthouseAuditAt: f["Last lighthouse audit at"] ?? null
+  };
+}
+async function listWebsites(base) {
+  const out = [];
+  await base(WEBSITES_TABLE).select({ pageSize: 100 }).eachPage((records, fetchNextPage) => {
+    for (const rec of records) out.push(mapRow({ id: rec.id, fields: rec.fields }));
+    fetchNextPage();
+  });
+  return out;
+}
+async function getWebsiteBySlug(base, slug) {
+  const all = await listWebsites(base);
+  return all.find((w) => siteSlug(w.name) === slug) ?? null;
+}
+async function updateScores(base, recordId, scores) {
+  const fields = {
+    pScore: scores.performance,
+    rScore: scores.accessibility,
+    bpScore: scores.bestPractices,
+    seoScore: scores.seo,
+    "Last lighthouse audit at": (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await base(WEBSITES_TABLE).update([{ id: recordId, fields }]);
+}
+var WEBSITES_TABLE;
+var init_websites = __esm({
+  "src/reports/airtable/websites.ts"() {
+    "use strict";
+    WEBSITES_TABLE = "Websites";
+  }
+});
+
+// src/inventory/airtable.ts
+var airtable_exports = {};
+__export(airtable_exports, {
+  fromAirtableBase: () => fromAirtableBase
+});
+function fromAirtableBase(base, opts = {}) {
+  return async () => {
+    const workdir = opts.workdir ?? process.env.REDDOOR_FLEET_WORKDIR;
+    if (!workdir) {
+      throw new Error(
+        "fromAirtableBase requires `workdir` option or REDDOOR_FLEET_WORKDIR env (sites need a local path)"
+      );
+    }
+    const websites = await listWebsites(base);
+    return websites.filter((w) => w.maintenanceFreq !== "None" || w.testingFreq !== "None").map((w) => {
+      const slug = siteSlug(w.name);
+      const site = {
+        path: `${workdir}/${slug}`,
+        name: slug,
+        meta: { airtableRowId: w.id, displayName: w.name }
+      };
+      if (w.url) site.repoUrl = w.url;
+      return site;
+    });
+  };
+}
+var init_airtable = __esm({
+  "src/inventory/airtable.ts"() {
+    "use strict";
+    init_websites();
+  }
+});
+
+// src/audits/lighthouse-airtable.ts
+var lighthouse_airtable_exports = {};
+__export(lighthouse_airtable_exports, {
+  lighthouseScoresFromResult: () => lighthouseScoresFromResult,
+  resolveSlugFromCwd: () => resolveSlugFromCwd
+});
+import { readFile as readFile7 } from "fs/promises";
+import { join as join7 } from "path";
+function lighthouseScoresFromResult(result) {
+  if (result.audit !== "lighthouse") {
+    throw new Error(`Expected a 'lighthouse' AuditResult, got '${result.audit}'`);
+  }
+  const details = result.details ?? {};
+  const summary = details.summary ?? {};
+  const toPct = (n) => typeof n === "number" && !Number.isNaN(n) ? Math.round(n * 100) : 0;
+  return {
+    performance: toPct(summary["performance"]),
+    accessibility: toPct(summary["accessibility"]),
+    bestPractices: toPct(summary["best-practices"]),
+    seo: toPct(summary["seo"])
+  };
+}
+async function resolveSlugFromCwd(cwd) {
+  try {
+    const pkgPath = join7(cwd, "package.json");
+    const raw = await readFile7(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    if (!pkg.name) throw new Error("package.json has no 'name' field");
+    return siteSlug(pkg.name);
+  } catch (e) {
+    throw new Error(
+      `Could not derive site slug from ${cwd}/package.json: ${e.message}. Pass --write-airtable=<slug> explicitly.`,
+      { cause: e }
+    );
+  }
+}
+var init_lighthouse_airtable = __esm({
+  "src/audits/lighthouse-airtable.ts"() {
+    "use strict";
+    init_websites();
+  }
+});
+
 // src/cli/commands/audit.ts
 import { resolve as resolve2 } from "path";
 
@@ -338,9 +514,9 @@ async function securityAudit(ctx) {
 }
 
 // src/audits/lighthouse.ts
-import { readFile as readFile3, writeFile, mkdtemp, rm } from "fs/promises";
+import { readFile as readFile4, writeFile, mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/configs/lighthouse.ts
 var lighthouseConfig = {
@@ -373,10 +549,37 @@ var lighthouseConfig = {
   }
 };
 
+// src/audits/util/site-config.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+async function readSiteConfig(sitePath) {
+  let raw;
+  try {
+    raw = await readFile3(join3(sitePath, "package.json"), "utf-8");
+  } catch {
+    return {};
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!pkg || typeof pkg !== "object") return {};
+  const cfg = pkg.reddoor;
+  if (!cfg || typeof cfg !== "object") return {};
+  const out = {};
+  const url = cfg.lighthouseUrl;
+  if (typeof url === "string" && url.length > 0) {
+    out.lighthouseUrl = url;
+  }
+  return out;
+}
+
 // src/audits/lighthouse.ts
 async function readJsonMaybe(path) {
   try {
-    const raw = await readFile3(path, "utf-8");
+    const raw = await readFile4(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -412,15 +615,28 @@ async function lighthouseAudit(ctx) {
   const spawn2 = ctx.spawn ?? defaultSpawn;
   const site = ctx.site;
   const label = siteLabel(site);
-  const configDir = await mkdtemp(join3(tmpdir(), "reddoor-lhci-"));
-  const configPath = join3(configDir, "lighthouserc.json");
-  await writeFile(configPath, JSON.stringify(lighthouseConfig), "utf-8");
-  const resultsDir = join3(site.path, ".lighthouseci");
+  const siteCfg = await readSiteConfig(site.path);
+  const resolvedConfig = siteCfg.lighthouseUrl ? {
+    ...lighthouseConfig,
+    ci: {
+      ...lighthouseConfig.ci,
+      collect: { ...lighthouseConfig.ci.collect, url: [siteCfg.lighthouseUrl] }
+    }
+  } : lighthouseConfig;
+  const configDir = await mkdtemp(join4(tmpdir(), "reddoor-lhci-"));
+  const configPath = join4(configDir, "lighthouserc.json");
+  await writeFile(configPath, JSON.stringify(resolvedConfig), "utf-8");
+  const resultsDir = join4(site.path, ".lighthouseci");
   await rm(resultsDir, { recursive: true, force: true });
   let raw;
   try {
     raw = await spawn2("npx", ["--yes", "@lhci/cli", "autorun", `--config=${configPath}`], {
-      cwd: site.path
+      cwd: site.path,
+      // lhci autorun boots the site's dev server, downloads Chrome on first
+      // use, and runs the audit — easily 2–3 min on a cold tree. The shared
+      // 30 s default in runAudits is fine for deps/lint/security but starves
+      // lhci.
+      timeoutMs: 5 * 6e4
     });
   } catch (err) {
     await rm(configDir, { recursive: true, force: true });
@@ -436,7 +652,7 @@ async function lighthouseAudit(ctx) {
     throw err;
   }
   await rm(configDir, { recursive: true, force: true });
-  const manifest = await readJsonMaybe(join3(resultsDir, "manifest.json"));
+  const manifest = await readJsonMaybe(join4(resultsDir, "manifest.json"));
   if (!manifest || manifest.length === 0) {
     return {
       audit: "lighthouse",
@@ -445,7 +661,7 @@ async function lighthouseAudit(ctx) {
       summary: `lighthouse: no manifest written (exit ${raw.code})${raw.stderr ? ` \u2014 ${raw.stderr.slice(0, 200)}` : ""}`
     };
   }
-  const assertionResults = await readJsonMaybe(join3(resultsDir, "assertion-results.json")) ?? [];
+  const assertionResults = await readJsonMaybe(join4(resultsDir, "assertion-results.json")) ?? [];
   const failed = assertionResults.filter((a) => !a.passed);
   const assertions = failed.map((a) => ({
     category: categoryFromAssertion(a),
@@ -471,9 +687,9 @@ async function lighthouseAudit(ctx) {
 }
 
 // src/audits/a11y.ts
-import { readFile as readFile4, writeFile as writeFile2, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/configs/playwright-a11y.ts
 import { defineConfig, devices } from "@playwright/test";
@@ -511,7 +727,7 @@ var playwrightA11yConfig = defineConfig({
 var RESULTS_REL = ".reddoor-a11y/results.json";
 async function readJsonMaybe2(path) {
   try {
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -567,11 +783,11 @@ async function a11yAudit(ctx) {
   const spawn2 = ctx.spawn ?? defaultSpawn;
   const site = ctx.site;
   const label = siteLabel(site);
-  const specDir = await mkdtemp2(join4(tmpdir2(), "reddoor-a11y-spec-"));
-  const specPath = join4(specDir, "a11y.spec.ts");
+  const specDir = await mkdtemp2(join5(tmpdir2(), "reddoor-a11y-spec-"));
+  const specPath = join5(specDir, "a11y.spec.ts");
   await writeFile2(specPath, buildSpec(), "utf-8");
-  const resultsPath = join4(site.path, RESULTS_REL);
-  await rm2(join4(site.path, ".reddoor-a11y"), { recursive: true, force: true });
+  const resultsPath = join5(site.path, RESULTS_REL);
+  await rm2(join5(site.path, ".reddoor-a11y"), { recursive: true, force: true });
   let raw;
   try {
     raw = await spawn2("npx", ["--yes", "playwright", "test", "--reporter=line", specPath], {
@@ -647,6 +863,10 @@ async function runAudits(site, which) {
     )
   );
 }
+async function runAuditsAcross(sites, which) {
+  const all = await Promise.all(sites.map((s) => runAudits(s, which)));
+  return all.flat();
+}
 
 // src/cli/fleet/resolve-sites.ts
 import { pathToFileURL } from "url";
@@ -660,7 +880,7 @@ function localPath(path, opts = {}) {
 }
 
 // src/inventory/json.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { isAbsolute } from "path";
 function validate(raw) {
   if (!Array.isArray(raw)) {
@@ -690,7 +910,7 @@ function validate(raw) {
 }
 function fromJsonFile(path) {
   return async () => {
-    const raw = JSON.parse(await readFile5(path, "utf-8"));
+    const raw = JSON.parse(await readFile6(path, "utf-8"));
     return validate(raw);
   };
 }
@@ -702,6 +922,13 @@ async function resolveSites(input) {
       exitCode: 2
     });
   }
+  if (input.fleet === "airtable") {
+    const { openBase: openBase2, readAirtableConfig: readAirtableConfig2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+    const { fromAirtableBase: fromAirtableBase2 } = await Promise.resolve().then(() => (init_airtable(), airtable_exports));
+    const base = openBase2(readAirtableConfig2());
+    const provider = fromAirtableBase2(base, input.workdir ? { workdir: input.workdir } : {});
+    return provider();
+  }
   if (input.fleet) {
     const fleetPath = resolve(input.cwd, input.fleet);
     const ext = extname(fleetPath).toLowerCase();
@@ -729,7 +956,7 @@ async function resolveSites(input) {
 
 // src/cli/fleet/clone-if-needed.ts
 import { stat, readdir, mkdir } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5 } from "path";
+import { isAbsolute as isAbsolute2, join as join6 } from "path";
 function deriveNameFromRepoUrl(repoUrl) {
   const slash = repoUrl.split("/").pop() ?? repoUrl;
   return slash.replace(/\.git$/, "");
@@ -770,7 +997,7 @@ async function cloneIfNeeded(site, opts) {
   const name = site.name ?? deriveNameFromRepoUrl(site.repoUrl);
   assertSafeName(name);
   assertSafeRepoUrl(site.repoUrl);
-  const target = join5(opts.workdir, name);
+  const target = join6(opts.workdir, name);
   await mkdir(opts.workdir, { recursive: true });
   if (await isNonEmptyDir(target)) {
     return { ...site, name, path: target };
@@ -810,18 +1037,49 @@ async function runAuditCommand(site, opts) {
   let sites = await resolveSites({
     ...site !== void 0 ? { site } : {},
     ...opts.fleet !== void 0 ? { fleet: opts.fleet } : {},
+    ...opts.workdir !== void 0 ? { workdir: opts.workdir } : {},
     cwd
   });
   if (opts.fleet) {
     const workdir = opts.workdir ?? `${process.env.HOME ?? ""}/.reddoor-maint/sites`;
     sites = await Promise.all(sites.map((s) => cloneIfNeeded(s, { workdir })));
   }
-  const results = [];
-  for (const s of sites) {
-    const r = await runAudits(s, which);
-    results.push(...r);
+  const results = await runAuditsAcross(sites, which);
+  let output = opts.json ? JSON.stringify(results, null, 2) : formatTable(results);
+  if (opts.writeAirtable !== void 0) {
+    const { openBase: openBase2, readAirtableConfig: readAirtableConfig2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+    const { listWebsites: listWebsites2, updateScores: updateScores2, siteSlug: siteSlug2 } = await Promise.resolve().then(() => (init_websites(), websites_exports));
+    const { lighthouseScoresFromResult: lighthouseScoresFromResult2, resolveSlugFromCwd: resolveSlugFromCwd2 } = await Promise.resolve().then(() => (init_lighthouse_airtable(), lighthouse_airtable_exports));
+    const slug = typeof opts.writeAirtable === "string" && opts.writeAirtable.length > 0 ? opts.writeAirtable : await resolveSlugFromCwd2(cwd);
+    const lhResult = results.find((r) => r.audit === "lighthouse");
+    if (!lhResult) {
+      throw Object.assign(
+        new Error(
+          "--write-airtable requires a lighthouse result; did you pass --only without lighthouse?"
+        ),
+        { exitCode: 2 }
+      );
+    }
+    if (lhResult.status === "fail") {
+      throw Object.assign(
+        new Error(
+          `Lighthouse audit failed; refusing to write scores to Airtable. Summary: ${lhResult.summary}`
+        ),
+        { exitCode: 1 }
+      );
+    }
+    const base = openBase2(readAirtableConfig2());
+    const websites = await listWebsites2(base);
+    const target = websites.find((w) => siteSlug2(w.name) === slug);
+    if (!target) {
+      throw Object.assign(new Error(`No Websites row matched slug "${slug}"`), { exitCode: 2 });
+    }
+    const scores = lighthouseScoresFromResult2(lhResult);
+    await updateScores2(base, target.id, scores);
+    output += `
+
+\u2192 wrote scores to Websites[${target.name}]: P=${scores.performance} A=${scores.accessibility} BP=${scores.bestPractices} SEO=${scores.seo}`;
   }
-  const output = opts.json ? JSON.stringify(results, null, 2) : formatTable(results);
   return { output, code: exitCode(results) };
 }
 export {