import { mkdir, readFile, readdir } from "node:fs/promises"; import { INSTALLED_RUNTIME_CAPABILITIES } from "../src/features/installed-runtime-capabilities.ts"; import { hostingHeadersArtifactSchema } from "./contracts/release-artifacts.ts"; import { checkPublicServiceWorkers, classifyLiveHostingBaseUrl, hostingVerdict, probeLiveRelease, shipsServiceWorker, type HostingMode, type ProbeResult, type ResponseHeaders, } from "./lib/hosting-probe.ts"; import { writeValidatedJsonArtifact } from "./lib/validated-json-artifact.ts"; type Document = Record; function isRecord(value: unknown): value is Document { return Boolean(value) && typeof value === "object" && !Array.isArray(value); } function recordValue(value: unknown): Document { return isRecord(value) ? value : {}; } function strings(value: unknown): string[] { return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : []; } function stringRecord(value: unknown): Record { return Object.fromEntries( Object.entries(recordValue(value)).filter( (entry): entry is [string, string] => typeof entry[1] === "string", ), ); } function responseHeaders(value: unknown): ResponseHeaders { return Object.fromEntries( Object.entries(recordValue(value)).map(([surface, headers]) => [ surface, stringRecord(headers), ]), ); } async function readDocument(file: string): Promise { const parsed: unknown = JSON.parse(await readFile(file, "utf8")); if (!isRecord(parsed)) throw new Error(`${file} must be a JSON object`); return parsed; } const cachePolicy = await readDocument("config/hosting/cache-policy.json"); const cacheSurfaces = recordValue(cachePolicy.surfaces); const securityPolicy = await readDocument( "config/hosting/security-headers.json", ); const securityHeaders = stringRecord(securityPolicy.headers); const baseUrl = process.env.HOSTING_BASE_URL; const liveTarget = baseUrl ? classifyLiveHostingBaseUrl(baseUrl) : null; const distFiles = (await readdir("dist", { recursive: true })).map(String); const publicSourceMaps = distFiles.filter((file) => file.endsWith(".map")); // 1101/13-04. The worker script surface exists only in a build that ships one. const workerShipped = shipsServiceWorker(INSTALLED_RUNTIME_CAPABILITIES.serviceWorker); const requiredSurfaces = Object.entries(cacheSurfaces) .map(([surface, policy]) => [surface, recordValue(policy)] as const) .filter(([, policy]) => policy.requiredWhen !== "service-worker-shipped" || workerShipped); let responses: ResponseHeaders = {}; let mode: HostingMode; const probeResults: ProbeResult[] = []; if (liveTarget?.passed) { mode = "live"; const paths = Object.fromEntries( requiredSurfaces.flatMap(([surface, policy]) => typeof policy.path === "string" ? [[surface, policy.path] as const] : [], ), ); const probed = await probeLiveRelease(liveTarget.url, paths); responses = probed.responses; probeResults.push(...probed.results); } else if (liveTarget) { mode = "invalid-live"; probeResults.push({ surface: "deployment", header: "base-url", expected: "canonical non-loopback HTTPS root URL", observed: liveTarget.observedOrigin, reason: liveTarget.reason, passed: false, }); } else { mode = "fixture"; const fixture = await readDocument( "config/hosting/response-headers.fixture.json", ); responses = responseHeaders(fixture.responses); } const results: ProbeResult[] = [...probeResults]; for (const [surface, policy] of requiredSurfaces) { if (typeof policy.cacheControl !== "string") continue; const contentTypes = strings(policy.contentTypes); const observed = responses[surface]?.["cache-control"]; results.push({ surface, header: "cache-control", expected: policy.cacheControl, observed, passed: observed === policy.cacheControl, }); const observedContentType = responses[surface]?.["content-type"]; const observedMime = observedContentType ?.split(";", 1)[0] ?.trim() .toLowerCase(); results.push({ surface, header: "content-type", expected: contentTypes, observed: observedContentType, passed: observedMime !== undefined && contentTypes.includes(observedMime), }); if (policy.securityHeaders === true) { for (const [header, expected] of Object.entries(securityHeaders)) { const observedSecurity = responses[surface]?.[header.toLowerCase()]; results.push({ surface, header: header.toLowerCase(), expected, observed: observedSecurity, passed: observedSecurity === expected, }); } } } const sourceMapPolicy = recordValue(cacheSurfaces.sourceMap); results.push({ surface: "sourceMap", header: "public", expected: false, observed: publicSourceMaps.length > 0, passed: sourceMapPolicy.public === false && publicSourceMaps.length === 0, }); results.push( checkPublicServiceWorkers( distFiles, INSTALLED_RUNTIME_CAPABILITIES.serviceWorker, ), ); const passed = results.every((result) => result.passed); const status = hostingVerdict(mode, passed); await mkdir("artifacts/release", { recursive: true }); await writeValidatedJsonArtifact({ path: "artifacts/release/hosting-headers.json", schema: hostingHeadersArtifactSchema, value: { schemaVersion: 1, generatedAt: new Date().toISOString(), mode, baseUrl: liveTarget?.observedOrigin ?? null, providerVerificationRequired: mode !== "live", results, passed, status, }, }); if (status === "FAIL") { process.stderr.write( "Hosting cache/content-type/security header verification failed.\n", ); process.exit(1); } if (status === "UNVERIFIED") { // Not a pass (D-14): set HOSTING_BASE_URL to the deployed release. process.stderr.write( "Hosting header contract: UNVERIFIED (fixture: declared headers are consistent; set HOSTING_BASE_URL to probe the deployed release)\n", ); process.exit(3); } process.stdout.write("Hosting header contract: PASS (live)\n");