@elia97/officina 0.1.0 → 0.3.0

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.1.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"
   },
@@ -29,8 +35,20 @@
     "typescript": "^7.0.2",
     "vitest": "^4.1.11"
   },
+  "dependencies": {
+    "plop": "^4.0.5",
+    "ts-morph": "^28.0.0"
+  },
+  "peerDependencies": {
+    "sharp": ">=0.34.0"
+  },
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    }
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "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 .",