@elia97/officina 0.8.0 → 0.9.1

package/README.md

@@ -36,6 +36,8 @@ pnpm add -D @elia97/officina
 
 I gate leggono dalla cartella corrente, che deve essere la radice del repository. Opzioni comuni dei gate sui sorgenti: `--diff`, `--base <ref>`, `--head <ref>`, `--strict`, `--format text|github`.
 
+`check language` vuole in italiano i commenti del codice e i Markdown di documentazione. Lascia fuori per intero ciò che non è documentazione del progetto: i dizionari di `src/i18n/strings/` e i Markdown sotto `src/content/`, che sono copy nelle lingue del sito; le fonti del cliente in `docs/sources/`; i `CHANGELOG.md`, generati in inglese. Un file YAML di `src/content/` invece è codice, e i suoi commenti si controllano come altrove.
+
 ## Verifiche di build e di produzione
 
 | Comando | Cosa guarda | Da dove prende le rotte |
@@ -50,6 +52,8 @@ Una rotta renderizzata a richiesta non emette HTML. Con l'adapter Vercel, `check
 
 Per Lighthouse un sito SSR si misura con `check lighthouse <url>`, sulla produzione o su un'anteprima: al posto del server del progetto visita quell'indirizzo, ed è l'unico modo di avere numeri di produzione. `--local` serve i file statici della build, quindi su un sito renderizzato a richiesta si ferma e lo dice, invece di misurare dei 404. Un'anteprima Vercel con la Deployment Protection risponde con la pagina di accesso, e il check non la può misurare: serve la produzione o un'anteprima non protetta. La porta del server locale segue `LH_PORT` sia con `--listen` sia con `--port`.
 
+Lo smoke legge gli header di sicurezza sulla pagina a cui arriva la radice. Se `/` è un redirect sulla stessa origine — il 302 di lingua che Astro emette con `i18n.routing.redirectToDefaultLocale`, per esempio — li cerca sulla destinazione, perché il redirect non porta la CSP delle pagine renderizzate, e il nome del controllo dice dove li ha letti: `header content-security-policy su /it`. Un redirect verso un'altra origine, o senza `location`, è un fallimento. Anche l'attesa che l'alias di produzione punti al deployment nuovo conta un 3xx come una risposta.
+
 Il motore è uguale per tutti; ciò che cambia da un progetto all'altro sta in un file solo, `officina.config.ts` nella radice:
 
 ```ts
@@ -66,7 +70,7 @@ export default defineConfig({
   icons: { background: SITE.themeColor.light },
   bundle: { budgets: [motion], cssMaxGzip: 14 * 1024 },
   smoke: { checks: [...DEFAULT_CHECKS, checkLanguageRedirect] },
-  features: { analytics: 'required', roadmap: false },
+  features: { analytics: 'required', roadmap: false, botId: 'required' },
   routes: { representatives: { '/blog/[slug]': '/blog/ciao-mondo' } },
 })
 ```
@@ -79,14 +83,16 @@ La radice del pacchetto esporta `defineConfig` e i tipi; i pezzi del motore stan
 | `@elia97/officina/bundle` | `CSS_BUDGET_GZIP` |
 | `@elia97/officina/icons` | `ICON_SPECS` |
 
-`siteUrl` serve a `check smoke` e `icons.background` a `gen icons`. I budget del progetto vengono prima del default di 20 KB, nell'ordine in cui sono scritti; `smoke.checks` sostituisce la lista del pacchetto, quindi chi non ha BotID la ricompone senza `checkBotIdChallenge`; `smoke.securityHeaders` e `smoke.nonHtmlRoutes` sostituiscono `SECURITY_HEADERS` e `NON_HTML_ROUTES`.
+`siteUrl` serve a `check smoke` e `icons.background` a `gen icons`. I budget del progetto vengono prima del default di 20 KB, nell'ordine in cui sono scritti; `smoke.checks` sostituisce la lista del pacchetto, quindi chi ne toglie un controllo la ricompone da `DEFAULT_CHECKS`; `smoke.securityHeaders` e `smoke.nonHtmlRoutes` sostituiscono `SECURITY_HEADERS` e `NON_HTML_ROUTES`.
 
-`features` dice quali controlli il progetto pretende: `'required'` fa fallire il gate quando ciò che deve guardare non c'è, `false` lo spegne dicendolo. Una voce non dichiarata vale `'required'`, e `doctor` la segnala: un gate che esce 0 su un container GTM che non esiste non afferma niente. `routes.representatives` dà a ogni pattern dinamico di `src/pages` un percorso vero, e da lì smoke e Lighthouse guardano anche quelle pagine.
+`features` dice quali controlli il progetto pretende: `'required'` fa fallire il gate quando ciò che deve guardare non c'è, `false` lo spegne dicendolo. Per BotID è `features.botId`: con `false` lo smoke salta la challenge e lo scrive nell'uscita, anche dentro una lista di `smoke.checks` che la contiene. Una voce non dichiarata vale `'required'`, e `doctor` la segnala: un gate che esce 0 su un container GTM che non esiste non afferma niente. `routes.representatives` dà a ogni pattern dinamico di `src/pages` un percorso vero, e da lì smoke e Lighthouse guardano anche quelle pagine.
 
-`features.generators` ha un valore in più delle altre due, perché non tutti i siti in produzione nascono dallo scaffold: `'required'` è il comportamento di sempre; `false` spegne i generatori del pacchetto, e `doctor` smette di chiedere i punti di aggancio e gli ancoraggi invece di pretendere file che nessun codice di quel sito userebbe; `'project'` fa lo stesso ma lascia vivi i generatori che il progetto scrive in `officina.generators.mjs`, che a quel punto `doctor` pretende. Con `false` o `'project'`, `officina gen section|page|component|collection` si ferma dicendolo, mentre gli script `gen` e `gen:*` restano attesi in `package.json`: meglio un comando che spiega di uno script che manca. `gen icons` non c'entra con i generatori di codice e non cambia.
+`features.generators` ha un valore in più delle altre, perché non tutti i siti in produzione nascono dallo scaffold: `'required'` è il comportamento di sempre; `false` spegne i generatori del pacchetto, e `doctor` smette di chiedere i punti di aggancio e gli ancoraggi invece di pretendere file che nessun codice di quel sito userebbe; `'project'` fa lo stesso ma lascia vivi i generatori che il progetto scrive in `officina.generators.mjs`, che a quel punto `doctor` pretende. Con `false` o `'project'`, `officina gen section|page|component|collection` si ferma dicendolo, mentre gli script `gen` e `gen:*` restano attesi in `package.json`: meglio un comando che spiega di uno script che manca. `gen icons` non c'entra con i generatori di codice e non cambia.
 
 `placeholders` dice a `check placeholders` cosa guardare: `sources` sono i file da scandire, `contactEnvKeys` le variabili che `--env` pretende. Una lista dichiarata **sostituisce** quella del pacchetto, dizionari compresi: senza dichiarazione i sorgenti sono `src/lib/site.ts`, `src/lib/company.ts` e i dizionari di `src/i18n/strings`, quando la cartella esiste. Serve ai progetti che non nascono dallo scaffold: se partita IVA, recapiti e destinatario dei form stanno nel contenuto invece che in un modulo, i sorgenti del template non sono i suoi, e crearli per far passare il gate terrebbe gli stessi dati in due sedi. Un sorgente elencato che non esiste è un ritrovamento con il suo percorso, non un errore che ferma il comando.
 
+Nel deploy `check placeholders` gira due volte sui file di Vercel. Con `--env .vercel/.env.production.local`, dopo `vercel pull`, distingue una chiave che su Vercel non esiste, una vuota e una che porta un segnaposto del template, tutte e tre errori, da una variabile **Sensitive**: `vercel pull` non ne scarica il valore e scrive al suo posto `[SENSITIVE]`, quindi il check lo dice con un avviso, che non ferma il deploy, invece di darla per verificata. Il segnaposto però diventa un problema se la build legge la variabile, per esempio una variabile di `astro:env` con `access: 'public'`, che Astro incorpora nel codice: con `--output .vercel/output`, dopo `vercel build`, il check cerca `[SENSITIVE]` nei file della build e ferma il deploy nominandoli. Una variabile che la build legge va tenuta Encrypted su Vercel, o letta a runtime.
+
 Il file lo carica Node, che fuori da `node_modules` toglie i tipi da sé: niente `enum`, niente alias `@/`. Due file `officina.config.*` insieme sono un errore, come un file senza default export; il resto lo valida `loadConfig` a runtime, nominando il percorso della voce sbagliata — `bundle.cssMaxGzip: atteso un numero, ricevuto una stringa` — e una voce sconosciuta, perché `sitUrl` al posto di `siteUrl` non deve passare in silenzio.
 
 `sharp` è una dipendenza facoltativa del progetto, non del pacchetto: serve solo a `gen icons`, che senza lo dice ed esce 1. Un ingresso che manca — il favicon, `.lighthouserc.json`, `src/pages`, la build in `dist/client` — è sempre una riga che nomina il file e dice a cosa serve, mai uno stack trace. `@biomejs/biome` invece è una peer dependency con l'intervallo che il preset regge, e `doctor` confronta la versione del progetto con quello.
@@ -116,7 +122,7 @@ I passi dei workflow stanno in `actions/` di questo repository, come composite a
 |---|---|---|
 | `actions/ci` | checkout, node, install, `astro sync`, `pnpm run ci`, build, `perf:bundle`; con `e2e: 'true'` anche Playwright | trigger, permessi, il job `ci` |
 | `actions/review` | `astro sync`, poi `fallow review` sul diff contro il merge-base | il job informativo |
-| `actions/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel passati in `with:`, il job che controlla se i segreti ci sono |
+| `actions/deploy` | risoluzione del tag, gate, `vercel pull`, `build`, controllo della build, `deploy`, smoke; espone `url` | trigger, `environment`, i tre segreti Vercel passati in `with:`, il job che controlla se i segreti ci sono |
 | `actions/lighthouse` | build equivalente alla produzione e `pnpm run lhci` | trigger, etichetta, `continue-on-error` |
 
 ```yaml
@@ -165,6 +171,8 @@ Le altre sezioni misurano che il progetto e il pacchetto si muovano insieme:
 
 `package.json`, `.claude/settings.json`, `biome.json` e `.mcp.json` si leggono come JSON, non cercandoci dentro delle stringhe: `"hooks"` in un valore qualunque non è un blocco `hooks`. I workflow restano una ricerca testuale — non c'è un parser YAML nel pacchetto — ma una riga commentata non soddisfa nessun controllo.
 
+**Un requisito nuovo nasce come avviso.** Quando `doctor` impara a chiedere una cosa nuova, la mancanza è un `warning` nella versione che la introduce e diventa un `error` dalla successiva. `doctor` gira dentro `pnpm run ci` senza `--strict`, quindi la PR di Dependabot che porta la versione nuova passa, e il progetto ha una versione di tempo per adeguarsi.
+
 ## Sviluppo
 
 ```sh
@@ -181,13 +189,22 @@ I sorgenti sono TypeScript, ma il pacchetto pubblica JavaScript: Node toglie i t
 
 ## Pubblicare
 
+**Una release a settimana**, salvo una rottura che ferma un progetto: le correzioni si accumulano su `main` ed escono insieme. Ogni release è un aggiornamento da portare in ogni progetto e nel template, e il gruppo `officina` di Dependabot lo propone una volta a settimana: rilasciare più spesso non lo fa arrivare prima, moltiplica soltanto le PR da seguire.
+
 ```sh
-pnpm version <patch|minor|major>   # scrive package.json e crea il tag
+npm pkg set version=X.Y.Z
+git diff                                  # una riga sola: "version" in package.json
+git commit -am "chore(release): X.Y.Z"
+git tag -a vX.Y.Z -m "vX.Y.Z"
 git push --follow-tags
 ```
 
+Il tag va creato **annotato**: `--follow-tags` spinge soltanto i tag annotati, e un tag leggero resta in locale senza nessun errore, quindi il rilascio non parte. È successo con la 0.6.0.
+
 Il resto lo fa `.github/workflows/release.yml`, sul push di un tag `v*`: controlla che il tag corrisponda a `version`, rilancia il gate, la build e il test del tarball, pubblica su npm con trusted publishing (OIDC) e provenance, e crea la release su GitHub con le note generate. Niente `pnpm publish` dal terminale: quello che finisce su npm esce da un tag, e da nient'altro.
 
+Il rilascio è fatto quando lo confermano tre cose: `git ls-remote --tags origin` mostra `vX.Y.Z^{}`, cioè il tag annotato arrivato sul remoto; il workflow «Rilascio» sul tag è verde; `curl -fsS https://registry.npmjs.org/@elia97%2Fofficina/X.Y.Z` risponde con il manifesto della versione. `npm view`, anche con `@X.Y.Z`, passa invece dal documento aggregato del pacchetto, che arriva da una CDN e per qualche minuto dopo la pubblicazione può ancora rispondere 404.
+
 Le action si richiamano per tag, quindi **una versione senza tag non è adottabile**: `doctor` chiede ai progetti la stessa versione del pacchetto installato, e un tag che non esiste non si può scrivere in un workflow.
 
 Una volta sola, a mano: su npmjs.com il trusted publisher per `Elia97/officina` e `release.yml`; su GitHub un ruleset sui tag `v*` che ne vieta modifica e cancellazione.

package/dist/checks/placeholders.js

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import process from 'node:process';
 import { parseArgs } from 'node:util';
-import { contactEnvKeys, envFindings, placeholderSources, sourceFindings } from '../lib/check-placeholders.js';
+import { contactEnvKeys, envFindings, outputFindings, placeholderSources, sourceFindings, } from '../lib/check-placeholders.js';
 import { cliOptions, exitCode, printFindings } from '../lib/cli.js';
 import { loadConfig } from '../lib/config.js';
 const MISSING_SOURCE = 'sorgente assente: `placeholders.sources` in officina.config.ts dice quali file guardare';
@@ -16,30 +16,47 @@ function sourceScan(paths) {
 function envScan(path, keys) {
     if (!existsSync(path))
         return [{ path, message: "file dell'ambiente assente: lo scrive vercel pull", severity: 'error' }];
-    return envFindings(readFileSync(path, 'utf8'), keys).map((hit) => ({ path, ...hit, severity: 'error' }));
+    return envFindings(readFileSync(path, 'utf8'), keys).map((hit) => ({ path, ...hit }));
 }
-function scan(env, config) {
+function outputScan(dir) {
+    if (!existsSync(dir))
+        return [{ path: dir, message: 'cartella della build assente: la scrive vercel build', severity: 'error' }];
+    return outputFindings(dir);
+}
+function scan(env, output, config) {
+    if (output !== undefined) {
+        return {
+            scope: `build in ${output}`,
+            findings: outputScan(output),
+            clean: 'Nessuna variabile Sensitive entrata nella build.',
+            advice: 'Una variabile che la build legge non può essere Sensitive su Vercel: portala a Encrypted, o leggila a runtime',
+        };
+    }
     if (env !== undefined) {
         return {
             scope: `ambiente in ${env}`,
             findings: envScan(env, contactEnvKeys(config)),
-            fix: 'docs/guides/deploy-ops.md § Checklist per il go-live',
+            clean: 'Nessun segnaposto del template.',
+            advice: 'Da sostituire prima del deploy: docs/guides/deploy-ops.md § Checklist per il go-live',
         };
     }
     const paths = placeholderSources(config);
-    return { scope: `${paths.length} sorgenti`, findings: sourceScan(paths), fix: 'README.md § Cosa tocca il rebranding' };
+    return {
+        scope: `${paths.length} sorgenti`,
+        findings: sourceScan(paths),
+        clean: 'Nessun segnaposto del template.',
+        advice: 'Da sostituire prima del deploy: README.md § Cosa tocca il rebranding',
+    };
 }
 export async function main(args = process.argv.slice(2)) {
-    const { env } = parseArgs({ args, options: { env: { type: 'string' } } }).values;
-    const { scope, findings, fix } = scan(env, await loadConfig(process.cwd()));
+    const { env, output } = parseArgs({ args, options: { env: { type: 'string' }, output: { type: 'string' } } }).values;
+    const { scope, findings, clean, advice } = scan(env, output, await loadConfig(process.cwd()));
     console.log(`\ncheck:placeholders — ${scope}\n`);
     printFindings(findings, cliOptions([]).format);
-    if (findings.length === 0) {
-        console.log('  Nessun segnaposto del template.\n');
-    }
-    else {
-        console.log(`\n  Da sostituire prima del deploy: ${fix}.\n`);
-    }
+    if (findings.length === 0)
+        console.log(`  ${clean}\n`);
+    else if (findings.some(({ severity }) => severity === 'error'))
+        console.log(`\n  ${advice}.\n`);
     return exitCode(findings, false);
 }
 if (import.meta.main)

package/dist/checks/smoke.js

@@ -2,7 +2,7 @@
 // L'unico controllo che vede cosa serve davvero il bordo: i test del progetto fissano solo vercel.json.
 import process from 'node:process';
 import { missingInput } from '../lib/cli.js';
-import { loadConfig } from '../lib/config.js';
+import { isRequired, loadConfig } from '../lib/config.js';
 import { expectedRoutes, readPageFiles, smokeRoutes } from '../lib/routes.js';
 import { runChecks, SECURITY_HEADERS, waitForAlias, } from '../lib/smoke-production.js';
 const PAGES_DIR = 'src/pages';
@@ -23,7 +23,8 @@ function printFailures(failures) {
     console.error('Deployments → l’ultimo deployment di produzione sano → Promote to Production.\n');
 }
 export async function main(args = []) {
-    const { siteUrl, smoke = {}, routes = {} } = await loadConfig(process.cwd());
+    const config = await loadConfig(process.cwd());
+    const { siteUrl, smoke = {}, routes = {} } = config;
     const [url] = args;
     if (siteUrl === undefined) {
         console.error('\n✗ officina.config.ts non dichiara siteUrl: il controllo dell’host canonico non ha con cosa confrontarsi.\n');
@@ -40,6 +41,7 @@ export async function main(args = []) {
         baseUrl,
         siteUrl,
         securityHeaders: smoke.securityHeaders ?? SECURITY_HEADERS,
+        botIdRequired: isRequired(config, 'botId'),
     };
     if (missingInput(PAGES_DIR, 'le rotte da visitare si derivano da lì'))
         return 1;

package/dist/lib/check-language.js

@@ -1,8 +1,9 @@
 import { commentBlocks, styleOf } from './comment-syntax.js';
 import { ENGLISH, ITALIAN } from './language-words.js';
 const CODE = /^(?:(?:src|scripts|test|\.claude\/hooks|\.github)\/.*|[^/]+)\.(?:ts|tsx|astro|mjs|cjs|js|css|ya?ml|jsonc)$/;
-// Fuori le fonti del cliente (materiale altrui) e i changelog, generati in inglese.
-const DOCS = /^(?!docs\/sources\/)(?!(?:.*\/)?CHANGELOG\.md$).*\.md$/;
+// Fuori le fonti del cliente (materiale altrui) e i changelog, generati in inglese; fuori anche
+// src/content/, della stessa natura dei dizionari in LOCALIZED.
+const DOCS = /^(?!docs\/sources\/|src\/content\/)(?!(?:.*\/)?CHANGELOG\.md$).*\.md$/;
 // I dizionari sono copy per l'utente nelle lingue del sito: en e de leggono inglese e tedesco
 // per definizione, ed è il solo posto sotto CODE dove non deve leggersi italiano.
 const LOCALIZED = /^src\/i18n\/strings\//;

package/dist/lib/check-placeholders.d.ts

@@ -1,8 +1,9 @@
 import { type Finding, type Hit } from './cli.ts';
 import type { OfficinaConfig } from './config.ts';
-type EnvHit = Omit<Finding, 'path' | 'severity'>;
+type EnvHit = Omit<Finding, 'path'>;
 export declare function placeholderSources(config?: OfficinaConfig): string[];
 export declare const contactEnvKeys: (config?: OfficinaConfig) => readonly string[];
 export declare function sourceFindings(source: string): Hit[];
 export declare function envFindings(content: string, keys: readonly string[]): EnvHit[];
+export declare const outputFindings: (dir: string) => Finding[];
 export {};

package/dist/lib/check-placeholders.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseEnv } from 'node:util';
 import { readLines } from './cli.js';
@@ -11,6 +11,8 @@ const STRING_LITERAL = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g;
 const COMMENT_ONLY = /^\s*(?:\/\/|\/\*|\*)/;
 const ZERO_POSTAL_CODE = /\bpostalCode:\s*(['"])00000\1/;
 const EMPTY_HREF = /\bhref:\s*(['"])#\1/;
+// `SENSITIVE_ENV_VALUE_PLACEHOLDER` di vercel@59.22.0: `vercel pull` lo scrive al posto del valore di una Sensitive.
+const SENSITIVE = '[SENSITIVE]';
 const dictionaries = () => existsSync(DICTIONARIES)
     ? readdirSync(DICTIONARIES)
         .filter((name) => name.endsWith('.ts'))
@@ -51,13 +53,35 @@ export function envFindings(content, keys) {
     const env = parseEnv(content);
     const lines = readLines(content);
     return keys.flatMap((key) => {
-        const value = env[key]?.trim() ?? '';
-        const declaration = lines.find(({ text }) => new RegExp(`^\\s*${key}\\s*=`).test(text));
-        const at = declaration ? { line: declaration.n } : {};
+        const value = env[key]?.trim();
+        const declaration = lines.find(({ text }) => new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`).test(text));
+        if (value === undefined || declaration === undefined) {
+            const message = `${key} non c'è fra le variabili di produzione su Vercel: vale il default di astro.config.mjs`;
+            return [{ severity: 'error', message }];
+        }
+        const hit = (severity, message) => [
+            { line: declaration.n, severity, message: `${key} ${message}` },
+        ];
+        if (value === SENSITIVE)
+            return hit('warning', 'è Sensitive su Vercel: vercel pull non ne scarica il valore, e il deploy non lo può verificare');
         if (value === '')
-            return [{ ...at, message: `${key} non è impostata: vale il default di astro.config.mjs` }];
+            return hit('error', 'è vuota: vale il default di astro.config.mjs');
         if (TOKEN.test(value) || DOMAIN.test(value))
-            return [{ ...at, message: `${key} porta un segnaposto del template` }];
+            return hit('error', 'porta un segnaposto del template');
         return [];
     });
 }
+const filesUnder = (dir) => readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory())
+        return filesUnder(path);
+    return entry.isFile() ? [path] : [];
+});
+export const outputFindings = (dir) => filesUnder(dir)
+    .filter((path) => readFileSync(path).includes(SENSITIVE))
+    .sort()
+    .map((path) => ({
+    path,
+    severity: 'error',
+    message: `contiene ${SENSITIVE}, il segnaposto che vercel pull scrive per una variabile Sensitive: la build l'ha incorporato al posto del valore`,
+}));

package/dist/lib/config.d.ts

@@ -27,6 +27,7 @@ export interface OfficinaConfig {
         analytics?: FeatureSetting;
         roadmap?: FeatureSetting;
         generators?: GeneratorsSetting;
+        botId?: FeatureSetting;
     };
     placeholders?: {
         sources?: readonly string[];
@@ -37,7 +38,7 @@ export interface OfficinaConfig {
         representatives?: Representatives;
     };
 }
-export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators'];
+export declare const FEATURES: readonly ['analytics', 'roadmap', 'generators', 'botId'];
 export type FeatureName = (typeof FEATURES)[number];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export declare const isRequired: (config: OfficinaConfig, name: FeatureName) => boolean;

package/dist/lib/config.js

@@ -10,7 +10,7 @@ import { existsSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { aFunction, aNumber, anArrayOf, aRecordOf, aShape, aString, aStringOrNull, oneOf } from './validate.js';
-export const FEATURES = ['analytics', 'roadmap', 'generators'];
+export const FEATURES = ['analytics', 'roadmap', 'generators', 'botId'];
 /** Un controllo si spegne solo scrivendolo: il silenzio vale `'required'`. */
 export const isRequired = (config, name) => (config.features?.[name] ?? 'required') === 'required';
 export const generatorsSetting = (config) => config.features?.generators ?? 'required';
@@ -28,7 +28,7 @@ const SHAPE = aShape({
         checks: anArrayOf(aFunction),
     }),
     analytics: aShape({ linkTracking: aString }),
-    features: aShape({ analytics: feature, roadmap: feature, generators }),
+    features: aShape({ analytics: feature, roadmap: feature, generators, botId: feature }),
     placeholders: aShape({ sources: anArrayOf(aString), contactEnvKeys: anArrayOf(aString) }),
     routes: aShape({ representatives: aRecordOf(aString) }),
 });

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

@@ -12,6 +12,7 @@ export interface SmokeContext {
     baseUrl: string;
     siteUrl: string;
     securityHeaders: Record<string, string | null>;
+    botIdRequired: boolean;
 }
 export type SmokeCheck = (context: SmokeContext, pages: readonly VerifiedRoute[]) => Promise<CheckResult[]>;
 export interface CheckResult {
@@ -26,7 +27,7 @@ export declare const BOTID_CHALLENGE = "/149e9513-01fa-4fb0-aad4-566afd725d1b/2d
 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[]>;
+export declare function checkBotIdChallenge({ get, baseUrl, botIdRequired }: 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[]>;

package/dist/lib/smoke-production.js

@@ -13,11 +13,14 @@ export const SECURITY_HEADERS = {
 };
 /** 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';
+const isRedirect = (status) => status >= 300 && status < 400;
+const MAX_REDIRECTS = 5;
 /** 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)
+            const response = await get(baseUrl);
+            if (response.ok || isRedirect(response.status))
                 return;
         }
         catch { }
@@ -25,6 +28,25 @@ export async function waitForAlias({ get, baseUrl }, sleep, attempts = 5) {
             await sleep(attempt * 2000);
     }
 }
+/** La radice può essere un redirect, come il 302 di lingua di Astro, che non porta la CSP delle pagine renderizzate. */
+async function landingPage(get, baseUrl) {
+    const { origin } = new URL(baseUrl);
+    let url = baseUrl;
+    for (let hops = 0;; hops++) {
+        const response = await get(url);
+        if (!isRedirect(response.status))
+            return { url, response };
+        if (hops === MAX_REDIRECTS)
+            throw new Error(`più di ${MAX_REDIRECTS} redirect a partire da ${baseUrl}`);
+        const location = response.headers.get('location');
+        if (location === null)
+            throw new Error(`${url} risponde ${response.status} senza location`);
+        const next = new URL(location, url);
+        if (next.origin !== origin)
+            throw new Error(`${url} rimanda a ${next.href}, fuori da ${origin}`);
+        url = next.href;
+    }
+}
 export async function checkPages({ get, baseUrl }, pages) {
     const results = [];
     for (const { path, type } of pages) {
@@ -46,15 +68,17 @@ export async function checkPages({ get, baseUrl }, pages) {
     return results;
 }
 export async function checkSecurityHeaders({ get, baseUrl, securityHeaders }) {
-    let response;
+    let landing;
     try {
-        response = await get(baseUrl);
+        landing = await landingPage(get, baseUrl);
     }
     catch (error) {
         return [fail('header di sicurezza', messageOf(error))];
     }
+    const { url, response } = landing;
+    const where = url === baseUrl ? '' : ` su ${new URL(url).pathname}`;
     const results = Object.entries(securityHeaders).map(([header, expected]) => {
-        const check = `header ${header}`;
+        const check = `header ${header}${where}`;
         const value = response.headers.get(header);
         if (value === null)
             return fail(check, 'assente');
@@ -65,11 +89,13 @@ export async function checkSecurityHeaders({ get, baseUrl, securityHeaders }) {
     // Il noindex `has: host = *.vercel.app` di vercel.json applicato al dominio vero farebbe sparire il sito da ogni indice.
     const check = 'nessun x-robots-tag sull’host di produzione';
     const robots = response.headers.get('x-robots-tag');
-    results.push(robots === null ? pass(check) : fail(check, `presente su ${baseUrl}: "${robots}"`));
+    results.push(robots === null ? pass(check) : fail(check, `presente su ${url}: "${robots}"`));
     return results;
 }
-export async function checkBotIdChallenge({ get, baseUrl }) {
+export async function checkBotIdChallenge({ get, baseUrl, botIdRequired }) {
     const check = 'challenge di BotID servita dalla stessa origine';
+    if (!botIdRequired)
+        return [skip(check, 'spento da `features.botId: false`')];
     try {
         const response = await get(`${baseUrl}${BOTID_CHALLENGE}`);
         if (response.status !== 200)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elia97/officina",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "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",