diff --git a/CLAUDE.md b/CLAUDE.md index 0dc4bf7..f058d64 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,6 +38,11 @@ Conserva: tappa in corso, file modificati, controlli ancora da eseguire, domande ## Repository e rilascio - Repository: Gitea di casa, https://gitea.encke-hake.ts.net/Alby96/Febe (ramo main). Non è GitHub: niente strumenti GitHub. -- CI in `.gitea/workflows/`: `verifica.yml` a ogni push e pull request, `rilascio.yml` a ogni tag `vX.Y.Z` (immagine Docker sul registro di Gitea, installatore Windows e release). +- Processo (rami `/`, commit piccoli, una richiesta di unione per ramo, verifica verde per unire in main, commit di unione, rilasci, correzioni urgenti): docs/processo.md. +- CI in `.gitea/workflows/`, script comuni in `.gitea/scripts/`: + - `verifica.yml` a ogni push su qualunque ramo (non sui tag) e a mano, niente pull_request: controlli e gitleaks; compilazione di tutta la soluzione e tutte le prove di `tests/Febe.Tests` con Chromium, Xvfb, ffmpeg e NSIS veri in Debian, nessuna saltata, anche con il seme dell'esecuzione (`FEBE_SEME_PROVA`); installatore e zip `-ci.`; immagine provata senza rete e scansionata con Trivy. Dopo un push su main pubblica `:main` e `:sha-` (con il segreto `REGISTRY_TOKEN`; senza, un avviso). + - `rilascio.yml` a ogni tag `vX.Y.Z`: immagine `:X.Y.Z` (e `:latest`) sul registro di Gitea, installatore Windows e release. + - `pulizia.yml` ogni lunedì: solo i resti della CI di Febe sul demone Docker condiviso. +- Le prove nella CI passano solo da `tests/Febe.Tests`, mai `dotnet test` sulla soluzione intera. - La versione sta solo in `Directory.Build.props` (``); il tag deve coincidere. - Guida per l'uso: wiki del repository (sorgenti in `docs/guida/`). diff --git a/docs/decisioni.md b/docs/decisioni.md index faa77b7..01641a8 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -241,3 +241,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | Artefatti con `actions/upload-artifact@v3` e `retention-days: 14` (risultati delle prove, installatore e zip, rapporti di sicurezza) | La v4 rifiuta di girare dove il server non è github.com (prende Gitea per GHES) e la sua copia per Gitea sarebbe un'azione nuova, non approvata; il backend v3 di Gitea 28 rispetta `retentionDays` (`routers/api/actions/artifacts.go`) | | 2026-10-20 | `permissions: contents: read` in `verifica` e `pulizia`; i riepiloghi delle prove e di Trivy vanno nel registro e anche in `GITHUB_STEP_SUMMARY` | Gitea 28 applica `permissions` al gettone del lavoro (docs.gitea.com, «Actions job token permissions»), che così non può scrivere nel repository; i riepiloghi dei lavori esistono da Gitea 1.27 ma compaiono solo se il runner li carica, quindi il registro resta la fonte | | 2026-10-20 | Ciò che la CI usa di Gitea 28 e di act_runner: `concurrency` con espressioni, `timeout-minutes` dei lavori (lo applica il runner), `workflow_dispatch` con `inputs`, `schedule`, `defaults.run.shell`, `container` del lavoro, contesti `gitea.*`, `vars` e `secrets`; gli stati dei commit si chiamano «verifica / (push)» (`modules/actions/workflows.go`) e solo push, pull_request e release ne creano | Controllato sul codice di Gitea `release/v28` e su docs.gitea.com il 20 ottobre 2026; ciò che solo la prima esecuzione vera può provare è in `docs/processo.md` | +| 2026-10-20 | Processo in `docs/processo.md`: rami `/` da `main`, commit piccoli in italiano, una richiesta di unione per ramo con il modello di `.gitea/` (comprese le 14 regole di §2), unione con commit di unione e ramo cancellato; `main` protetto con i quattro lavori di `verifica` come controlli richiesti e «blocca se indietro»; tag `v*` protetti; Alberto proprietario di tutto (`CODEOWNERS`) | Decisione di Alberto del 20 ottobre (processo da grande azienda); con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato, quindi in `main` entra solo codice provato. Le approvazioni richieste dipendono da chi apre le richieste (Gitea non conta quella dell'autore): domanda aperta per Alberto | diff --git a/docs/docker.md b/docs/docker.md index 521d3b2..87ad929 100644 --- a/docs/docker.md +++ b/docs/docker.md @@ -20,6 +20,25 @@ display virtuale (Xvfb) e la libreria su disco. Si usa dal browser di casa; il b - L'immagine si costruisce solo con le prove verdi: la compilazione e tutte le prove girano dentro la costruzione (quelle con il browser vero lì si saltano da sole, perché nello stadio di compilazione non ci sono Chromium e Xvfb; girano nella CI e in sviluppo). +- I pacchetti di Debian sono aggiornati al momento della costruzione (anche le correzioni uscite dopo l'immagine di + base). Prima di ogni pubblicazione la CI fa partire il contenitore senza rete fino al controllo di salute e lo + scansiona con Trivy: una vulnerabilità CRITICAL con correzione disponibile ferma la pubblicazione + (`docs/processo.md`, «Rilievi di sicurezza»). + +## Etichette dell'immagine + +Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: + +| Etichetta | Che cos'è | Quando cambia | +|---|---|---| +| `:latest` | l'ultima versione rilasciata senza trattino: quella del modello di Unraid e di `compose.yml` | a ogni rilascio stabile | +| `:X.Y.Z` | una versione rilasciata (anche `X.Y.Z-rc.N` per un'anteprima) | mai: serve per tornare a una versione precisa | +| `:main` | l'ultimo commit di `main` che ha passato la verifica | a ogni unione in `main`: per provare, non per l'archivio vero | +| `:sha-<7 caratteri>` | un commit di `main` preciso | mai | + +Ogni immagine costruita dalla CI dice da dove viene, nelle etichette Docker `febe.ci.workflow`, `febe.ci.run`, +`febe.ci.ref` e `febe.ci.commit` e in `org.opencontainers.image.version` e `.revision`: +`docker inspect --format '{{json .Config.Labels}}' `. ## Volumi diff --git a/docs/guida/Sviluppo.md b/docs/guida/Sviluppo.md index 045686d..03e7713 100644 --- a/docs/guida/Sviluppo.md +++ b/docs/guida/Sviluppo.md @@ -129,12 +129,27 @@ da sole). Vedi [Installazione con Docker e Unraid](Installazione-Docker-e-Unraid ## CI e rilascio Il repository è sul Gitea di casa (); la CI usa Gitea Actions in -`.gitea/workflows/`: +`.gitea/workflows/`, con il codice comune in `.gitea/scripts/`. Il processo completo (nomi dei rami, commit, +richieste di unione, protezione di `main`, rilievi di sicurezza, rilasci, correzioni urgenti) è in `docs/processo.md`. -- `verifica.yml`, a ogni push e pull request: compilazione con gli avvisi come errori, tutte le prove, costruzione - dell'immagine Docker (senza pubblicarla) e due controlli sull'immagine (Chromium presente, lingua italiana generata); -- `rilascio.yml`, a ogni tag `vX.Y.Z`: immagine Docker sul registro di Gitea, installatore Windows e release. Al 13 - ottobre 2026 è in preparazione: se il file non c'è ancora in `.gitea/workflows/`, il rilascio non è automatico. +- `verifica.yml`, a ogni push su qualunque ramo e a mano (non sui tag, non sulle richieste di unione, che mostrano lo + stato del loro ultimo commit). Quattro lavori, che sono i controlli richiesti per unire in `main`: + - `controlli`: sintassi degli script, file di testo, versione, progetti della soluzione, JSON, e nessun segreto in + tutta la storia (gitleaks); + - `prove`: compilazione di tutta la soluzione con gli avvisi come errori e tutte le prove di `tests/Febe.Tests` in + un contenitore Debian con Chromium, Xvfb, ffmpeg, NSIS e Node veri: nessuna prova si salta; + - `installatore`: `Febe-Setup--ci..exe` e lo zip portabile, fra gli artefatti per 14 giorni; + - `immagine`: l'immagine Docker, provata senza rete (parte, diventa «healthy», si ferma) e scansionata con Trivy; + dopo un push su `main` va sul registro come `:main` e `:sha-`. Alla fine si toglie tutto ciò che + l'esecuzione ha creato sul demone Docker, che è condiviso con gli altri progetti; +- `rilascio.yml`, a ogni tag `vX.Y.Z`: prove, installatore e zip, immagine provata e scansionata, pubblicata come + `:X.Y.Z` e `:latest` (solo per le versioni senza trattino), poi la release; +- `pulizia.yml`, ogni lunedì e a mano: i resti delle esecuzioni interrotte e le immagini senza nome vecchie. + +Nella CI le prove del sito di prova (categoria `SitoDiProva`) girano due volte: con il seme 13 e con un seme diverso +a ogni esecuzione, scritto nel registro del lavoro. Per rifare un errore con quel seme: +`FEBE_SEME_PROVA= dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva"`. I controlli veloci della +CI si lanciano anche a mano: `bash .gitea/scripts/controlli.sh`. La versione sta solo in `Directory.Build.props` (``); il tag deve coincidere. diff --git a/docs/processo.md b/docs/processo.md new file mode 100644 index 0000000..e7fbac4 --- /dev/null +++ b/docs/processo.md @@ -0,0 +1,198 @@ +# Processo: dal ramo al rilascio + +Come una modifica arriva in `main` e da lì a una versione, con le stesse garanzie di un'azienda che non accetta codice +non verificato. Vale per Alberto e per chiunque lavori al repository, persone o agenti. Repository: il Gitea di casa, + (non GitHub: niente strumenti di GitHub). Il motivo di ogni scelta è in +`docs/decisioni.md`, alle righe del 20 ottobre 2026. + +## In breve + +1. Un ramo per filone di lavoro, nato da `main`. +2. Commit piccoli e separati, ciascuno con un messaggio che dice che cosa cambia e perché. +3. A ogni push la verifica parte da sola: controlli, prove, installatore, immagine. +4. Una richiesta di unione per ramo, con il modello compilato, e una revisione. +5. Si unisce in `main` solo con la verifica verde sull'ultimo commit (protezione di `main`), con un commit di unione; + il ramo si cancella. +6. Dopo l'unione la verifica gira su `main` e pubblica l'immagine `:main` e `:sha-`. +7. Un rilascio è un tag `vX.Y.Z` su `main`. + +## Rami + +- Nome: `/`, in minuscolo, parole separate da trattini, in italiano. Tipi: + + | Tipo | Per | + |---|---| + | `funzione/` | una funzione nuova (`funzione/esporta-csv`) | + | `correzione/` | un difetto (`correzione/webview2-avvio`) | + | `urgente/` | una correzione da rilasciare subito (vedi «Correzioni urgenti») | + | `ci/` | flussi, script e immagini della CI (`ci/pipeline-aziendale`) | + | `strumenti/` | strumenti di sviluppo (`strumenti/vscode`) | + | `documenti/` | solo documenti e guida | + | `rilascio/` | la preparazione di una versione (`rilascio/0.2.0`) | + +- Si parte da `main` aggiornato e si resta brevi: giorni, non settimane. Se `main` va avanti, il ramo si aggiorna + (pulsante «Aggiorna il ramo» della richiesta di unione, o `git merge origin/main`) prima di unire. +- Su `main` non si fa push diretto: ci si arriva solo da una richiesta di unione. + +## Commit + +- Piccoli e logici: ogni commit compila e passa le prove da solo (così `git bisect` funziona). +- Messaggio in italiano: la prima riga (al massimo 72 caratteri) dice che cosa cambia; il corpo, dopo una riga vuota, + dice perché. Non un elenco di file. +- I commit scritti con un agente finiscono con una riga vuota e `Co-Authored-By: …` dell'agente. +- Mai nel repository: risultati di compilazione (`bin/`, `obj/`, `out/`), segreti, campioni grezzi della sonda, dati + di Alberto. + +## Richieste di unione + +- Una per ramo, con il modello (`.gitea/pull_request_template.md`): sintesi, perché, che cosa cambia, come è stato + provato (comandi e risultati, e che cosa non è stato provato), rischi e ritorno indietro, le quattordici regole di + §2 della specifica. Le righe per `CHANGELOG.md` e `docs/stato.md` stanno nella richiesta: le aggiunge chi integra. +- Revisione: Alberto è il proprietario di tutto (`.gitea/CODEOWNERS`). Le osservazioni si risolvono con commit nuovi + sullo stesso ramo, non riscrivendo quelli già rivisti. +- Stile di unione: **commit di unione** («Crea un commit di unione»), con il titolo della richiesta; poi il ramo si + cancella («Elimina il ramo dopo l'unione», da tenere attivo nelle impostazioni del repository). +- Tornare indietro: `git revert -m 1 ` in una nuova richiesta di unione. + +## Controlli richiesti e protezione di main + +I controlli richiesti sono i quattro lavori della verifica, come Gitea li riporta sul commit: +`verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`, +`verifica / immagine (push)`. Una richiesta di unione mostra lo stato del suo ultimo commit, che il push del ramo ha +già verificato: per questo la verifica non gira anche su `pull_request`. + +Regola di protezione di `main` (Impostazioni ▸ Rami ▸ Aggiungi regola; la imposta chi integra, una volta che i +quattro controlli sono comparsi almeno una volta): + +| Impostazione | Valore | +|---|---| +| Schema del ramo | `main` | +| Push | disattivato: solo da richiesta di unione | +| Push forzato | disattivato | +| Controllo di stato | attivo, con gli schemi `verifica / controlli (push)`, `verifica / prove (push)`, `verifica / installatore (push)`, `verifica / immagine (push)` | +| Blocca l'unione se la richiesta è indietro rispetto al ramo di base | attivo: con il ramo aggiornato il commit di unione ha lo stesso contenuto del commit verificato | +| Approvazioni richieste | 1 se le richieste le apre un account diverso da quello di Alberto; 0 se le apre lui (Gitea non conta l'approvazione dell'autore) | +| Annulla le approvazioni superate da nuovi commit | attivo | +| Blocca l'unione con revisioni che chiedono modifiche | attivo | +| Anche gli amministratori seguono la regola | attivo | + +E nei tag protetti (Impostazioni ▸ Tag): `v*` creabili solo da Alberto. + +## La CI + +Gitea Actions su un solo act_runner (etichetta `ubuntu-latest`, un lavoro alla volta). I lavori parlano con il demone +Docker del server, lo stesso che costruisce Encelado, Mimante e gli altri progetti di Alberto. I flussi stanno in +`.gitea/workflows/`, il codice comune in `.gitea/scripts/` (si lancia anche a mano). + +| Lavoro | Quando | Che cosa garantisce | +|---|---|---| +| `controlli` | ogni push | sintassi di tutti gli script di shell (`bash -n`, `sh -n`) e righe Unix; flussi senza tabulazioni; nessun segno di conflitto; versione in `Directory.Build.props` valida; ogni progetto di `Febe.slnx` esiste; ogni JSON si legge; nessun segreto in tutta la storia (gitleaks 8.30.1, `--redact`) | +| `prove` | dopo `controlli` | in un contenitore Debian 13 (`node:24-trixie`) con Chromium della distribuzione, Xvfb, ffmpeg, NSIS, Node e la lingua italiana: tutta la soluzione compila con gli avvisi come errori e **tutte** le prove di `tests/Febe.Tests` passano senza saltarsi; quelle della categoria `SitoDiProva` passano anche con il seme dell'esecuzione. Risultati `.trx` fra gli artefatti (14 giorni) | +| `installatore` | dopo `prove` | `Febe.exe` in un file solo, `Febe-Setup--ci..exe` e lo zip portabile si costruiscono, ciascuno sotto i 100 MB; artefatti per 14 giorni | +| `immagine` | dopo `prove` | l'immagine si costruisce con buildx (dentro girano compilazione e prove), il contenitore parte **senza rete** come dice la guida e diventa «healthy», Chromium e la lingua italiana ci sono, si ferma entro 30 secondi; Trivy 0.75.0 non trova vulnerabilità CRITICAL con correzione disponibile. Solo dopo un push su `main`: pubblicazione `:main` e `:sha-` | + +La verifica gira a ogni push su qualunque ramo e a mano (Actions ▸ verifica ▸ Esegui, con un seme facoltativo). Su un +ramo un push nuovo annulla l'esecuzione in corso; su `main` ogni unione arriva fino in fondo. + +Altri flussi: `rilascio.yml` a ogni tag (vedi «Rilasci») e `pulizia.yml` ogni lunedì (vedi «Pulizia»). + +### Il mondo sintetico e il suo seme + +Le prove non contattano mai Instagram: usano il sito di prova (`tools/Febe.SitoDiProva`), con dati sintetici generati +da un seme. Nella CI le prove girano con il seme 13 e quelle della categoria `SitoDiProva` di nuovo con il seme +`1000 + numero dell'esecuzione`, scritto nel registro del passo «Semi del mondo sintetico». Per rifare un errore, in +locale o dalla CI a mano con quel seme: + +```sh +FEBE_SEME_PROVA= dotnet test tests/Febe.Tests --filter "TestCategory=SitoDiProva" +``` + +### Segreti e variabili + +- `REGISTRY_TOKEN` (segreto del repository): token di Alberto con «package: read and write». Senza, `verifica` e + `rilascio` costruiscono, provano e scansionano l'immagine ma non la pubblicano, con un avviso, e restano verdi. +- `REGISTRY` (variabile, facoltativa): il registro come lo raggiunge il runner (`192.168.30.23:3000`); se manca si usa + l'host dell'indirizzo del server Gitea. +- Le credenziali vanno nella configurazione del client Docker del lavoro, mai nel demone, e si tolgono alla fine. + Nessun flusso stampa segreti; `PipelineTests` lo controlla a ogni esecuzione. +- I segreti sono leggibili da qualunque flusso di questo repository, su qualunque ramo: chi può fare push può leggerli. + Per questo il permesso di scrittura sul repository resta ad Alberto e agli account di cui si fida. + +## Registro dei container: le etichette + +Sul registro di Gitea, `192.168.30.23:3000/alby96/febe`: + +| Etichetta | Chi la crea | Quando cambia | Per che cosa | +|---|---|---|---| +| `:latest` | `rilascio`, solo versioni senza trattino | a ogni rilascio stabile | Unraid e Docker Compose | +| `:X.Y.Z` | `rilascio` (anche `X.Y.Z-rc.1` per un'anteprima) | mai | una versione precisa, per tornare indietro | +| `:main` | `verifica`, dopo ogni unione in `main` | a ogni unione (mai all'indietro) | provare `main` su un server di prova; non per l'archivio vero | +| `:sha-<7 caratteri>` | `verifica`, dopo ogni unione in `main` | mai | un commit preciso di `main` | + +Ogni immagine della CI porta le etichette Docker `febe.ci.workflow`, `febe.ci.run`, `febe.ci.ref` e `febe.ci.commit`, +oltre a quelle OCI del Dockerfile: da un'immagine si risale all'esecuzione e al commit. Le `:sha-` si accumulano: una +regola di pulizia dei pacchetti (Impostazioni ▸ Pacchetti ▸ Regole di pulizia) può tenere sempre `latest`, `main` e +le versioni e togliere le `sha-.*` più vecchie di 30 giorni. + +## Pulizia + +Il demone Docker è condiviso con gli altri progetti: la CI di Febe toglie solo ciò che porta i suoi segni (etichetta +`febe.ci.run`, repository locale `febe-ci`, builder `febe-ci-`), più le immagini senza nome più vecchie di +72 ore (`.gitea/scripts/pulizia-docker.sh`). + +| Quando | Che cosa si toglie | +|---|---| +| alla fine di ogni lavoro «immagine», sempre | il contenitore di prova con i suoi volumi anonimi, l'immagine provata, il builder buildx dell'esecuzione con la sua cache, l'archivio dell'immagine, le credenziali del registro | +| all'inizio di ogni lavoro «immagine» | i resti di esecuzioni interrotte più vecchi di 90 minuti (un lavoro dura al massimo 60 minuti) e di un tentativo precedente della stessa esecuzione | +| ogni lunedì e a mano (`pulizia.yml`) | gli stessi resti, l'immagine `febe:ci` del vecchio flusso se nessuno la usa, le immagini senza nome più vecchie di 72 ore | +| mai | immagini, contenitori e volumi degli altri progetti; la cache di costruzione del demone; i volumi con un nome; le immagini col nome del registro | + +## Rilievi di sicurezza + +- **gitleaks** (lavoro `controlli`). Un segreto vero si **revoca subito** (gettone di Telegram da BotFather, token di + Gitea dalle impostazioni dell'utente) e se ne crea uno nuovo: toglierlo dalla storia non basta, perché qualcuno può + averlo già. Solo dopo, se serve, si riscrive la storia, d'accordo con Alberto. Un falso allarme (un dato di prova + finto, già controllato) si toglie aggiungendo la sua impronta («Fingerprint», nel registro del lavoro o nel + rapporto `rapporto-gitleaks`) a `.gitleaksignore`, con un commento sulla riga sopra: che cos'è, chi l'ha + controllato, quando. Mai disattivare una regola. +- **Trivy** (lavoro `immagine`, anche nel rilascio). Una vulnerabilità CRITICAL con correzione disponibile ferma il + lavoro e l'immagine non si pubblica. Che cosa fare: per un pacchetto di Debian di solito basta rilanciare (il + Dockerfile applica gli aggiornamenti della distribuzione); per una dipendenza .NET si aggiorna la sua versione in + `Directory.Packages.props` (una dipendenza nuova va chiesta ad Alberto); per il runtime .NET si ricostruisce con + l'SDK aggiornato. Le HIGH, e le CRITICAL ancora senza correzione, non fermano nulla ma si guardano nel rapporto + `sicurezza-immagine` (`trivy.json`) e, se riguardano ciò che Febe usa, diventano una segnalazione. Un'eccezione si + scrive solo in `.trivyignore`, alla radice: l'identificativo con una scadenza (`CVE-AAAA-NNNN exp:AAAA-MM-GG`, al + massimo 90 giorni) e, sulla riga sopra, il motivo e chi l'ha deciso. +- Strumenti: gitleaks e Trivy sono gli unici strumenti esterni della CI, approvati da Alberto, e girano solo nella + CI. Si aggiornano cambiando versione e impronta SHA-256 in `.gitea/scripts/strumento.sh`, in una richiesta di + unione con una riga in `docs/decisioni.md`, preferendo versioni uscite da almeno due settimane. + +## Rilasci + +1. In un ramo `rilascio/X.Y.Z`: `` in `Directory.Build.props`, la sezione `## X.Y.Z` di `CHANGELOG.md` (è il + testo delle note della release), `docs/stato.md`. Richiesta di unione, verifica verde, unione. +2. Sul commit di unione in `main`: `git tag -a vX.Y.Z -m "Febe X.Y.Z"` e `git push origin vX.Y.Z`. +3. `rilascio.yml` controlla che il tag coincida con ``, rifà le prove, costruisce installatore e zip, + costruisce, prova e scansiona l'immagine, la pubblica come `:X.Y.Z` (e `:latest` se la versione non ha trattini) e + crea la release con installatore, zip, modello di Unraid e archivio per Compose. +4. Un'anteprima è `vX.Y.Z-rc.N`: stessa strada, `:latest` non si sposta e la release è segnata come anteprima (come + ogni versione `0.x`). +5. Se manca `REGISTRY_TOKEN` la release esce senza immagine e lo dice; aggiunto il segreto, si rilancia il flusso del + tag e le note si correggono. + +## Correzioni urgenti + +- Se `main` contiene solo ciò che si vuole rilasciare: ramo `urgente/` da `main`, richiesta di unione con la + verifica verde come sempre (nessuna scorciatoia), poi un rilascio di correzione (`X.Y.Z+1`) come sopra. +- Se `main` contiene già lavoro da non rilasciare: ramo `rilascio/X.Y` dal tag della versione in uso, la correzione con + `git cherry-pick` (o scritta lì), `` a `X.Y.Z+1`, tag `vX.Y.Z+1` su quel ramo (il rilascio parte da + qualunque tag); poi la stessa correzione entra in `main` con la sua richiesta di unione. + +## Che cosa solo la prima esecuzione vera può provare + +Qui non ci sono runner né demone Docker: i flussi sono stati controllati come testo (struttura, espressioni, `bash -n` +di ogni blocco `run`), gli script con un client Docker finto. Restano da vedere alla prima esecuzione: il contenitore +`node:24-trixie` con le azioni dentro; le prove con il browser nel contenitore (nessuna saltata); `upload-artifact@v3` +con `retention-days`; la concorrenza; il builder buildx con il nome dell'esecuzione; la prova del contenitore senza +rete fino a «healthy»; il download e la scansione di Trivy (e se trova CRITICAL da correggere); gitleaks sulla storia; +la pubblicazione su `main` con il segreto; la pulizia settimanale sul demone vero.