import { mkdir, readFile, readdir } from "node:fs/promises"; import path from "node:path"; import { INSTALLED_RUNTIME_CAPABILITIES } from "../src/features/installed-runtime-capabilities.ts"; import { hostingHeadersArtifactSchema } from "./contracts/release-artifacts.ts"; import { checkPublicServiceWorkers, classifyLiveHostingBaseUrl, hostingVerdict, probeAssetContentTypes, probeLiveRelease, releaseIdentity, 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; // 1101/13-01. FE-GATE-019 passes the promoted archive it extracted, so the // files checked here and the identity the host must serve are the candidate's, // not a local rebuild's. Without the flag a local run checks its own `dist`. const releaseRootFlag = process.argv.indexOf("--release-root"); const releaseRoot = releaseRootFlag >= 0 ? process.argv[releaseRootFlag + 1] : "."; if (!releaseRoot) { process.stderr.write("Usage: verify:hosting-headers [-- --release-root ]\n"); process.exit(2); } const distRoot = path.join(releaseRoot, "dist"); const distFiles = (await readdir(distRoot, { recursive: true })).map(String); // 1101/13-01. The deployment slot job reports whether it deployed this // candidate. An empty slot deployed nothing, so the host still serves an // earlier release: probing it proves nothing about this one (UNVERIFIED). const deployedBySlot = process.env.RELEASE_DEPLOYED; const slotEmpty = deployedBySlot !== undefined && deployedBySlot !== "true"; 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 && !slotEmpty) { mode = "live"; const paths = Object.fromEntries( requiredSurfaces.flatMap(([surface, policy]) => typeof policy.path === "string" ? [[surface, policy.path] as const] : [], ), ); const candidateManifest = await readFile(path.join(distRoot, "release-manifest.json"), "utf8").catch(() => null); const candidate = releaseIdentity(candidateManifest); if (!candidate) { throw new Error(`${distRoot}/release-manifest.json does not name a buildId and releaseId`); } const probed = await probeLiveRelease(liveTarget.url, paths, candidate); responses = probed.responses; probeResults.push(...probed.results); // 1103/06-03. The worker needs every precached asset kind typed exactly. probeResults.push(...(await probeAssetContentTypes(liveTarget.url, distFiles))); } else if (liveTarget && !liveTarget.passed) { 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, // The schema records a base URL only for a host that was probed. baseUrl: mode === "live" ? (liveTarget?.observedOrigin ?? null) : 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" && slotEmpty) { process.stderr.write( "Hosting header contract: UNVERIFIED (the deployment slot is empty: nothing deployed this release, so the host was not probed; fill the deployment job in config/ci/gates.json)\n", ); process.exit(3); } 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");