@elia97/officina 0.2.0 → 0.3.0

package/dist/lib/routes.js

@@ -0,0 +1,97 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const ERROR_PAGES = ['/404', '/500'];
+// Non escono da una pagina .astro: `robots.txt.ts` e `site.webmanifest.ts` sono endpoint,
+// `sitemap-index.xml` lo emette @astrojs/sitemap e `/api/health` è `prerender = false`.
+export const NON_HTML_ROUTES = [
+    { path: '/robots.txt', type: 'text/plain' },
+    { path: '/sitemap-index.xml', type: 'xml' },
+    // In produzione il MIME viene dall'estensione .webmanifest, non dall'intestazione che
+    // l'endpoint imposta: si verifica la famiglia json invece di fissarne una delle due forme.
+    { path: '/site.webmanifest', type: 'json' },
+    { path: '/api/health', type: 'application/json' },
+];
+export function filesWithExtension(dir, extension) {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            return filesWithExtension(path, extension);
+        return entry.name.endsWith(extension) ? [path] : [];
+    });
+}
+export function readPageFiles(pagesDir) {
+    return filesWithExtension(pagesDir, '.astro').map((file) => ({ file, source: readFileSync(file, 'utf8') }));
+}
+const toPosix = (path, prefix) => path.slice(prefix.length).split(/[\\/]/).join('/');
+export function routeOf(htmlPath, dist) {
+    const route = toPosix(htmlPath, dist).replace(/\/index\.html$/, '');
+    return route.replace(/\.html$/, '') || '/';
+}
+const SSR_OPT_OUT = /^\s*export\s+const\s+prerender\s*=\s*false\b/m;
+function pageRouteOf(file, pagesDir) {
+    return (toPosix(file, pagesDir)
+        .replace(/\.astro$/, '')
+        .replace(/\/index$/, '') || '/');
+}
+function segmentPattern(segment) {
+    if (segment.startsWith('['))
+        return '[^/]+';
+    return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const TRAILING_REST_SEGMENT = /\/\[\.\.\.[^/]*\]$/;
+// Anche un segmento rest finale fa match col vuoto: `paginate()` emette la prima pagina come
+// percorso nudo (`/news`, mai `/news/1`), quindi esigere un segmento boccia un archivio di una pagina.
+function routePattern(route) {
+    const body = (path) => path.split('/').map(segmentPattern).join('/');
+    if (!TRAILING_REST_SEGMENT.test(route))
+        return new RegExp(`^${body(route)}$`);
+    return new RegExp(`^${body(route.replace(TRAILING_REST_SEGMENT, ''))}(?:/.*)?$`);
+}
+export function expectedRoutes(pages, pagesDir) {
+    const expectations = { exact: [], patterns: [], ssr: [] };
+    for (const { file, source } of pages) {
+        if (SSR_OPT_OUT.test(source)) {
+            expectations.ssr.push(file);
+            continue;
+        }
+        const route = pageRouteOf(file, pagesDir);
+        if (!route.includes('[')) {
+            expectations.exact.push({ route, file });
+            continue;
+        }
+        expectations.patterns.push({ pattern: routePattern(route), label: route, file });
+    }
+    return expectations;
+}
+/** [HARD] Guardia fail-open: ogni asserzione per rotta itera sulle pagine emesse, quindi una dist vuota non asserisce niente. */
+export function missingRouteFailures(expected, emitted, dist) {
+    if (emitted.length === 0) {
+        return [`${dist} holds no .html file — no route was measured, so the per-route budgets assert nothing`];
+    }
+    const failures = [];
+    const routes = new Set(emitted);
+    for (const { route, file } of expected.exact) {
+        if (!routes.has(route))
+            failures.push(`missing route ${route} — ${file} is prerendered but emitted no HTML`);
+    }
+    for (const { pattern, label, file } of expected.patterns) {
+        if (emitted.some((route) => pattern.test(route)))
+            continue;
+        failures.push(`missing route ${label} — ${file} is prerendered but getStaticPaths emitted nothing`);
+    }
+    return failures;
+}
+// Ordinate: l'ordine nativo di readdirSync cambia da un filesystem all'altro.
+export function auditRoutes(expected) {
+    return expected.exact
+        .map(({ route }) => route)
+        .filter((route) => !ERROR_PAGES.includes(route))
+        .sort();
+}
+export function smokeRoutes(expected, nonHtmlRoutes = NON_HTML_ROUTES) {
+    return [...auditRoutes(expected).map((path) => ({ path, type: 'text/html' })), ...nonHtmlRoutes];
+}
+export function orphanExceptions(expected) {
+    const routes = new Set(expected.exact.map(({ route }) => route));
+    return ERROR_PAGES.filter((page) => !routes.has(page));
+}

package/dist/lib/smoke-production.d.ts

@@ -0,0 +1,35 @@
+import type { VerifiedRoute } from './routes.ts';
+export interface SmokeResponse {
+    ok: boolean;
+    status: number;
+    headers: {
+        get: (name: string) => string | null;
+    };
+}
+export type Fetcher = (url: string) => Promise<SmokeResponse>;
+export interface SmokeContext {
+    get: Fetcher;
+    baseUrl: string;
+    siteUrl: string;
+    securityHeaders: Record<string, string | null>;
+}
+export type SmokeCheck = (context: SmokeContext, pages: readonly VerifiedRoute[]) => Promise<CheckResult[]>;
+export interface CheckResult {
+    check: string;
+    status: 'pass' | 'fail' | 'skip';
+    detail?: string;
+}
+export declare const SECURITY_HEADERS: Record<string, string | null>;
+/** Deve corrispondere al `source` del rewrite in vercel.json. */
+export declare const BOTID_CHALLENGE = "/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js";
+/** L'alias di produzione di Vercel impiega un attimo a puntare al deployment appena caricato. */
+export declare function waitForAlias({ get, baseUrl }: SmokeContext, sleep: (ms: number) => Promise<void>, attempts?: number): Promise<void>;
+export declare function checkPages({ get, baseUrl }: SmokeContext, pages: readonly VerifiedRoute[]): Promise<CheckResult[]>;
+export declare function checkSecurityHeaders({ get, baseUrl, securityHeaders }: SmokeContext): Promise<CheckResult[]>;
+export declare function checkBotIdChallenge({ get, baseUrl }: SmokeContext): Promise<CheckResult[]>;
+/** Il 308 da www all'apice, da vercel.json: dipende dal DNS e dal dominio del progetto Vercel, non dal deployment. */
+export declare function checkCanonicalHost({ get, baseUrl, siteUrl }: SmokeContext): Promise<CheckResult[]>;
+export declare function checkTrailingSlash({ get, baseUrl }: SmokeContext, pages: readonly VerifiedRoute[]): Promise<CheckResult[]>;
+export declare const DEFAULT_CHECKS: readonly SmokeCheck[];
+/** In sequenza, non in parallelo: l'ordine dei risultati è quello dei controlli. */
+export declare function runChecks(context: SmokeContext, pages: readonly VerifiedRoute[], checks?: readonly SmokeCheck[]): Promise<CheckResult[]>;

package/dist/lib/smoke-production.js

@@ -0,0 +1,132 @@
+const pass = (check) => ({ check, status: 'pass' });
+const fail = (check, detail) => ({ check, status: 'fail', detail });
+const skip = (check, detail) => ({ check, status: 'skip', detail });
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+// Dalla regola globale `/(.*)` di vercel.json. `null` = verifica solo la presenza; src/vercel-headers.test.ts fissa i valori.
+export const SECURITY_HEADERS = {
+    'content-security-policy': null,
+    'strict-transport-security': null,
+    'x-content-type-options': 'nosniff',
+    'x-frame-options': 'DENY',
+    'referrer-policy': null,
+    'permissions-policy': null,
+};
+/** Deve corrispondere al `source` del rewrite in vercel.json. */
+export const BOTID_CHALLENGE = '/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js';
+/** L'alias di produzione di Vercel impiega un attimo a puntare al deployment appena caricato. */
+export async function waitForAlias({ get, baseUrl }, sleep, attempts = 5) {
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            if ((await get(baseUrl)).ok)
+                return;
+        }
+        catch { }
+        if (attempt < attempts)
+            await sleep(attempt * 2000);
+    }
+}
+export async function checkPages({ get, baseUrl }, pages) {
+    const results = [];
+    for (const { path, type } of pages) {
+        const check = `GET ${path}`;
+        try {
+            const response = await get(`${baseUrl}${path}`);
+            const contentType = response.headers.get('content-type') ?? '';
+            if (response.status !== 200)
+                results.push(fail(check, `expected 200, got ${response.status}`));
+            else if (!contentType.includes(type))
+                results.push(fail(check, `expected a ${type} content-type, got "${contentType}"`));
+            else
+                results.push(pass(check));
+        }
+        catch (error) {
+            results.push(fail(check, messageOf(error)));
+        }
+    }
+    return results;
+}
+export async function checkSecurityHeaders({ get, baseUrl, securityHeaders }) {
+    let response;
+    try {
+        response = await get(baseUrl);
+    }
+    catch (error) {
+        return [fail('security headers', messageOf(error))];
+    }
+    const results = Object.entries(securityHeaders).map(([header, expected]) => {
+        const check = `header ${header}`;
+        const value = response.headers.get(header);
+        if (value === null)
+            return fail(check, 'missing');
+        if (expected !== null && value !== expected)
+            return fail(check, `expected "${expected}", got "${value}"`);
+        return pass(check);
+    });
+    // Il noindex `has: host = *.vercel.app` di vercel.json applicato al dominio vero farebbe sparire il sito da ogni indice.
+    const check = 'no x-robots-tag on the production host';
+    const robots = response.headers.get('x-robots-tag');
+    results.push(robots === null ? pass(check) : fail(check, `present on ${baseUrl}: "${robots}"`));
+    return results;
+}
+export async function checkBotIdChallenge({ get, baseUrl }) {
+    const check = 'BotID challenge proxied same-origin';
+    try {
+        const response = await get(`${baseUrl}${BOTID_CHALLENGE}`);
+        if (response.status !== 200)
+            return [fail(check, `expected 200 from the rewrite, got ${response.status}`)];
+        return [pass(check)];
+    }
+    catch (error) {
+        return [fail(check, messageOf(error))];
+    }
+}
+/** Il 308 da www all'apice, da vercel.json: dipende dal DNS e dal dominio del progetto Vercel, non dal deployment. */
+export async function checkCanonicalHost({ get, baseUrl, siteUrl }) {
+    const check = 'www → apex 308';
+    if (baseUrl !== siteUrl)
+        return [skip(check, `base URL is not ${siteUrl}`)];
+    try {
+        const response = await get(`https://www.${new URL(siteUrl).host}/`);
+        const location = response.headers.get('location') ?? '';
+        if (response.status !== 308)
+            return [fail(check, `expected 308, got ${response.status}`)];
+        if (!location.startsWith(siteUrl))
+            return [fail(check, `location "${location}" does not point at ${siteUrl}`)];
+        return [pass(check)];
+    }
+    catch (error) {
+        return [fail(check, messageOf(error))];
+    }
+}
+export async function checkTrailingSlash({ get, baseUrl }, pages) {
+    const page = pages.find(({ path, type }) => type === 'text/html' && path !== '/');
+    const check = 'trailing slash → 308';
+    if (page === undefined)
+        return [skip(check, 'no HTML page other than / to probe')];
+    try {
+        const response = await get(`${baseUrl}${page.path}/`);
+        if (response.status !== 308)
+            return [fail(check, `expected 308 on ${page.path}/, got ${response.status}`)];
+        const location = response.headers.get('location') ?? '';
+        if (!location.endsWith(page.path))
+            return [fail(check, `location "${location}" does not point at ${page.path}`)];
+        return [pass(check)];
+    }
+    catch (error) {
+        return [fail(check, messageOf(error))];
+    }
+}
+export const DEFAULT_CHECKS = [
+    checkPages,
+    checkSecurityHeaders,
+    checkBotIdChallenge,
+    checkCanonicalHost,
+    checkTrailingSlash,
+];
+/** In sequenza, non in parallelo: l'ordine dei risultati è quello dei controlli. */
+export async function runChecks(context, pages, checks = DEFAULT_CHECKS) {
+    const results = [];
+    for (const check of checks)
+        results.push(...(await check(context, pages)));
+    return results;
+}

package/dist/lib/vercel-cli-pin.d.ts

@@ -0,0 +1,2 @@
+import { type Hit } from './cli.ts';
+export declare function pinFindings(workflow: string, latest: string): Hit[];

package/dist/sh/lhci-local.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PORT="${LHCI_PORT:-4399}"
+OUT_DIR='dist/lh-prod'
+REPORT_DIR="${LHCI_REPORT_DIR:-.lighthouseci/local}"
+
+export TMPDIR="${TMPDIR:-/tmp}"
+
+detect_chrome() {
+  local candidate
+  for candidate in \
+    "${CHROME_PATH:-}" \
+    $(ls -d "$HOME"/.cache/ms-playwright/chromium-*/chrome-linux/chrome 2>/dev/null | sort -V -r) \
+    $(ls -d "$HOME"/.cache/puppeteer/chrome/*/chrome-linux*/chrome 2>/dev/null | sort -V -r) \
+    /usr/bin/google-chrome /usr/bin/chromium /usr/bin/chromium-browser
+  do
+    [[ -n "${candidate}" && -x "${candidate}" && "${candidate}" != *.exe ]] || continue
+    if "${candidate}" --version >/dev/null 2>&1; then
+      echo "${candidate}"
+      return 0
+    fi
+  done
+  return 1
+}
+
+if ! CHROME_PATH="$(detect_chrome)"; then
+  echo "✗ no usable Linux Chrome/Chromium found." >&2
+  echo "  Install one with: pnpm dlx playwright@latest install chromium" >&2
+  echo "  Or point at the binary: CHROME_PATH=/path/to/chrome pnpm run lhci:local" >&2
+  exit 1
+fi
+export CHROME_PATH
+echo "✓ chrome: ${CHROME_PATH} ($("${CHROME_PATH}" --version 2>/dev/null))"
+
+SERVER_PID=''
+
+cleanup() {
+  if [[ -n "${SERVER_PID}" ]]; then
+    kill -- "-${SERVER_PID}" 2>/dev/null || kill "${SERVER_PID}" 2>/dev/null || true
+    pkill -f "serve@14 .*--listen ${PORT}" 2>/dev/null || true
+  fi
+  find . -maxdepth 1 \( -name '*wsl.localhost*' -o -name 'undefined*' \) -exec rm -rf {} + 2>/dev/null || true
+}
+trap cleanup EXIT
+
+echo "→ production-equivalent build in ${OUT_DIR}"
+VERCEL_ENV=production pnpm build --outDir "${OUT_DIR}"
+
+if ! grep -qx 'Allow: /' "${OUT_DIR}/client/robots.txt"; then
+  echo "✗ ${OUT_DIR}/client/robots.txt has no 'Allow: /' — the build is not production-equivalent." >&2
+  head -3 "${OUT_DIR}/client/robots.txt" >&2
+  exit 1
+fi
+echo "✓ robots.txt: Allow: /"
+
+echo "→ starting the static server on :${PORT}"
+setsid pnpm dlx serve@14 "${OUT_DIR}/client" --listen "${PORT}" --no-clipboard >/dev/null 2>&1 &
+SERVER_PID=$!
+
+for _ in $(seq 1 60); do
+  if curl -fs -o /dev/null "http://localhost:${PORT}/"; then break; fi
+  sleep 1
+done
+if ! curl -fs -o /dev/null "http://localhost:${PORT}/"; then
+  echo "✗ the server did not answer on :${PORT} within 60s." >&2
+  echo "  Retry on another port: LHCI_PORT=4400 pnpm run lhci:local" >&2
+  exit 1
+fi
+echo "✓ server ready"
+
+rm -rf "${REPORT_DIR}"
+
+LH_PORT="${PORT}" \
+LH_RUNS="${LHCI_RUNS:-1}" \
+LH_OUT="${REPORT_DIR}" \
+LH_EXTERNAL_SERVER=1 \
+LH_CHROME_FLAGS='--no-sandbox --disable-dev-shm-usage' \
+  node "${OFFICINA_BIN}" check lighthouse
+
+echo
+echo "→ score per URL (median over ${LHCI_RUNS:-1} run(s), the way LHCI asserts)"
+node -e '
+const fs = require("fs")
+const dir = process.argv[1]
+const byUrl = new Map()
+for (const f of fs.readdirSync(dir).filter((f) => f.endsWith(".report.json"))) {
+  const r = JSON.parse(fs.readFileSync(`${dir}/${f}`))
+  const url = String(r.finalDisplayedUrl)
+  if (!byUrl.has(url)) byUrl.set(url, [])
+  byUrl.get(url).push(r.categories)
+}
+const median = (xs) => {
+  const s = [...xs].sort((a, b) => a - b)
+  return s[Math.floor(s.length / 2)]
+}
+for (const [url, runs] of [...byUrl].sort()) {
+  const pick = (k) => median(runs.map((c) => c[k].score)).toFixed(2)
+  console.log(
+    url.padEnd(46),
+    "perf", pick("performance"),
+    "a11y", pick("accessibility"),
+    "bp", pick("best-practices"),
+    "seo", pick("seo"),
+  )
+}' "${REPORT_DIR}"

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@elia97/officina",
-  "version": "0.2.0",
-  "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità e, più avanti, generatori.",
+  "version": "0.3.0",
+  "description": "Gli strumenti dei progetti nati dai template di Elia: gate di qualità, generatori e verifiche di build e di produzione.",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Elia97/officina.git"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "bin": {
     "officina": "dist/bin.js"
   },
@@ -33,8 +39,16 @@
     "plop": "^4.0.5",
     "ts-morph": "^28.0.0"
   },
+  "peerDependencies": {
+    "sharp": ">=0.34.0"
+  },
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    }
+  },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp -r src/gen/templates dist/gen/templates",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && cp -r src/gen/templates dist/gen/templates && cp -r src/sh dist/sh",
     "typecheck": "tsc --noEmit",
     "test": "vitest run --coverage",
     "format": "biome check --write .",