@stack-mode/site-manager-kit 0.0.0-stage → 1.44.1

package/audit/ts-hooks.mjs

@@ -0,0 +1,68 @@
+// Module hooks that let the wiring audit import a site's src/copy-keys.ts in plain Node, with the TypeScript the site
+// already has (every Next.js site does). Handles the site's tsconfig `paths` (such as "@/*"), imports without an
+// extension, JSON imports and server-only markers. Registered by wiring-audit.mjs; nothing else uses it.
+
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+let ts = null;
+let aliases = [];
+
+/** data: { siteDir, aliases: [{ prefix, targets: [absolute dir prefix] }] } */
+export async function initialize(data) {
+  const require = createRequire(path.join(data.siteDir, "package.json"));
+  ts = require("typescript");
+  aliases = data.aliases ?? [];
+}
+
+const EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs", ".jsx", ".json"];
+const EMPTY = "data:text/javascript,export%20default%20undefined%3B";
+
+function fileIfExists(p) {
+  try {
+    return existsSync(p) && statSync(p).isFile() ? p : null;
+  } catch {
+    return null;
+  }
+}
+
+function withExtension(base) {
+  return fileIfExists(base) ?? EXTENSIONS.map((e) => fileIfExists(base + e)).find(Boolean) ?? EXTENSIONS.map((e) => fileIfExists(path.join(base, "index" + e))).find(Boolean) ?? null;
+}
+
+export async function resolve(specifier, context, next) {
+  if (specifier === "server-only" || specifier === "client-only") return { url: EMPTY, shortCircuit: true };
+  for (const a of aliases) {
+    if (specifier.startsWith(a.prefix)) {
+      const rest = specifier.slice(a.prefix.length);
+      for (const t of a.targets) {
+        const hit = withExtension(t + rest);
+        if (hit) return { url: pathToFileURL(hit).href, shortCircuit: true };
+      }
+    }
+  }
+  if ((specifier.startsWith("./") || specifier.startsWith("../")) && context.parentURL?.startsWith("file:")) {
+    const hit = withExtension(path.resolve(path.dirname(fileURLToPath(context.parentURL)), specifier));
+    if (hit) return { url: pathToFileURL(hit).href, shortCircuit: true };
+  }
+  return next(specifier, context);
+}
+
+export async function load(url, context, next) {
+  if (url.startsWith("file:")) {
+    const file = fileURLToPath(url);
+    if (/\.(ts|tsx|mts)$/.test(file)) {
+      const out = ts.transpileModule(readFileSync(file, "utf8"), {
+        fileName: file,
+        compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.ReactJSX, esModuleInterop: true },
+      });
+      return { format: "module", source: out.outputText, shortCircuit: true };
+    }
+    if (file.endsWith(".json")) {
+      return { format: "module", source: `export default ${readFileSync(file, "utf8")};`, shortCircuit: true };
+    }
+  }
+  return next(url, context);
+}

package/audit/wiring-audit.d.mts

@@ -0,0 +1,37 @@
+// Types for wiring-audit.mjs, which stays plain JavaScript so it runs in a site's folder without a build.
+
+export type AuditStatus = "wired" | "not_wired" | "missing" | "hard_coded" | "unknown" | "info";
+export type Where = { file: string; line: number };
+export type AuditItem = { area: string; status: AuditStatus; name: string; detail: string; fix: string | null; where: Where[]; more: number };
+export type SiteFile = { rel: string; text: string; lines: string[]; usesKit: boolean };
+export type SiteFiles = { files: SiteFile[]; publicFiles: string[] };
+export type ApiAnswer = { status: number; data: any; meta: any; code: string | null };
+export type Readers = { names: string[]; paths: string[]; imports?: string[] };
+
+export const STATUS: Record<AuditStatus, string>;
+export const MODULE_READERS: Record<string, Readers>;
+export const ADMIN_ONLY: Set<string>;
+export function parseEnv(text: string): Record<string, string>;
+export function phonePattern(phone: string | null | undefined): RegExp | null;
+export function literalPattern(value: string): RegExp;
+export function containsPattern(value: string): RegExp;
+export function bareUrl(url: string | null | undefined): string;
+export function fileStem(name: string): string;
+export function keyRefsIn(line: string): string[];
+export function declaredFrom(mod: Record<string, unknown>): Map<string, { label: string; kind: string; image?: string }> | null;
+export function readSite(siteDir: string, opts?: { ignore?: string[]; roots?: string[] }): SiteFiles;
+export function findAll(files: SiteFile[], re: RegExp, filter?: (f: SiteFile) => boolean): Where[];
+export function readsModule(files: SiteFile[], readers: Readers): boolean;
+export function loadDeclaredKeys(siteDir: string, keysFile: string): Promise<{ declared?: Map<string, any>; error?: string }>;
+export function makeApi(base: string, key: string, fetchImpl?: typeof fetch): (path: string) => Promise<ApiAnswer>;
+export function uploadResult(base: string, key: string, result: { items: AuditItem[] }, kitVersion: string, fetchImpl?: typeof fetch): Promise<{ ok: boolean; message: string }>;
+export function audit(input: {
+  site: SiteFiles;
+  api: (path: string) => Promise<ApiAnswer>;
+  declaredResult: { declared?: Map<string, any>; error?: string };
+  keysFile: string;
+  hasCopyKeysRoute: boolean;
+}): Promise<{ site: { name: string; websiteUrl: string | null; modules: string[] }; items: AuditItem[] }>;
+export function summarize(items: AuditItem[]): { counts: Record<AuditStatus, number>; failed: boolean };
+export function renderReport(result: { site: { name: string }; items: AuditItem[] }, meta: { when: string; host: string; siteId: string; kitVersion: string; all?: boolean }): string;
+export function main(argv: string[]): Promise<number>;