Versione 0.1.68

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GiECd9RWGMKV7n3K1mdy8T

.gitea/workflows/test.yml

@@ -0,0 +1,45 @@
+# Le Gitea Actions del gioco: girano sul runner del PC di Andrea (make runner; label ubuntu-latest = node:22-bookworm).
+# A ogni push su main e a ogni tag i test unitari; su un tag vX.Y.Z, se passano, la release con i commit dal tag prima.
+# Il controllo dei file pubblicabili non sta qui (a pipeline partita il push è già pubblico): è l'hook pre-push.
+name: test
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Test unitari
+        run: node --version && node --test tests/*.test.mjs
+
+  release:
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Release del tag
+        env:
+          TOKEN: ${{ secrets.GITEA_TOKEN }}
+          TAG: ${{ github.ref_name }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          prev=$(git describe --tags --abbrev=0 "$TAG^" 2>/dev/null || true)
+          {
+            echo "Si gioca su https://50037.manzolo.it; qui sotto lo zip di questa versione."
+            echo
+            echo "Cosa cambia${prev:+ da $prev}:"
+            echo
+            git log --no-merges --format='- %s' ${prev:+$prev..}"$TAG" | grep -v -e '^- Versione [0-9]' | cut -c1-400
+          } > note.md
+          node -e 'const fs=require("fs");process.stdout.write(JSON.stringify({tag_name:process.env.TAG,name:"Versione "+process.env.TAG.slice(1),body:fs.readFileSync("note.md","utf8")}))' > release.json
+          code=$(curl -s -o risposta.json -w '%{http_code}' -X POST -H "Authorization: token $TOKEN" -H 'Content-Type: application/json' --data @release.json "$API/releases")
+          cat risposta.json | head -c 400; echo
+          [ "$code" = 201 ] || [ "$code" = 409 ]

CLAUDE.md

@@ -22,3 +22,7 @@ i suoi ricordi: non inventare persone, luoghi o fatti del paese al posto suoi; p
 - Prompt delle immagini in `prompts/` e fogli grezzi in `assets/raw/`: esclusi da git.
 - Sfondi nuovi: li genera **Codex** con il suo strumento immagini integrato, gratis e senza chiave API
   (`codex exec`, ricetta in `docs/GENERAZIONE_SFONDI.md`, «Generare con Codex»). Si lancia da qui, senza chiedere la chiave ad Andrea.
+- **Pubblicare (dal 2026-11-01)**: origin è https://git.manzolo.it/manzolo/leggenda-del-regolo, pubblico: prima `make check-public`, poi `git push origin main --tags`, solo se Andrea lo chiede.
+  `make deploy` costruisce l'immagine dal tag della versione, la spinge su `git.manzolo.it/manzolo/leggenda-regolo:vX.Y.Z` (e `:latest`); sul VPS il compose fissa quel tag e fa `docker compose pull && up -d`.
+  Per tornare indietro: sul VPS (`Workspaces/docker/leggenda-regolo/docker-compose.yml`) si rimette il tag precedente e si rifà pull e up.
+  Hook pre-push (`make hooks`, una volta per clone) lancia check-public; le Gitea Actions (`.gitea/workflows/test.yml`: test, e release sui tag) girano sul runner del PC, che si crea o riavvia con `make runner`.

Makefile

@@ -23,8 +23,8 @@ DST         ?= assets/scenes/$(notdir $(SRC))
 CROP        ?=
 COLORS      ?= 64
 
-.PHONY: help serve open test browser verify check-public bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
-        build up down restart logs ps shell image-size deploy deploy-logs clean distclean
+.PHONY: help serve open test browser verify check-public hooks bump voci voci-elenco sfondi sfondi-genera sfondi-confronto background character \
+        build up down restart logs ps shell image-size deploy deploy-logs runner clean distclean
 
 ## ------------------------------------------------------------ sviluppo
 
@@ -55,6 +55,10 @@ verify: test browser check-public ## Tutti i controlli
 check-public: ## Prima di pubblicare: niente prompt, fogli grezzi, segreti o nomi della rete di casa (tutta la storia)
 	bash scripts/check-public.sh
 
+hooks: ## Attiva gli hook del repo (pre-push: check-public prima di ogni push)
+	git config core.hooksPath scripts/git-hooks
+	@echo "hook attivi da scripts/git-hooks: $$(ls scripts/git-hooks | tr '\n' ' ')"
+
 bump: ## Nuova versione (PARTE=patch|minor|major): verifica, commit e tag v<versione>; poi make deploy
 	scripts/bump.sh $(or $(PARTE),patch)
 
@@ -121,40 +125,53 @@ image-size: ## Dimensione dell'immagine
 
 ## ------------------------------------------------------------ deploy su un server proprio
 
-# Host e indirizzo stanno in deploy.local.mk, fuori da git, per esempio:
-#   DEPLOY_HOST = root@mio-server
-#   DEPLOY_URL  = https://gioco.esempio
-#   DEPLOY_DIR  = docker/leggenda-regolo   (la cartella del compose sul server)
+# Host e cartella stanno in deploy.local.mk, fuori da git, per esempio:
+#   DEPLOY_HOST  = root@mio-server
+#   DEPLOY_URL   = https://gioco.esempio
+#   DEPLOY_DIR   = docker/leggenda-regolo   (la cartella del compose sul server)
+#   DEPLOY_IMAGE = registry.esempio/utente/leggenda-regolo
 -include deploy.local.mk
-DEPLOY_DIR  ?= /root/leggenda-regolo
-DEPLOY_TMP  := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
+DEPLOY_DIR   ?= /root/leggenda-regolo
+DEPLOY_IMAGE ?= git.manzolo.it/manzolo/leggenda-regolo
+DEPLOY_TMP   := $(shell mktemp -d -u /tmp/regolo-deploy.XXXXXX)
+# La versione dell'ultimo commit (non della cartella di lavoro): il tag git, dell'immagine e del compose.
+DEPLOY_VER   := v$(shell git show HEAD:src/version.js 2>/dev/null | sed -n "s/.*VERSION = '\([^']*\)'.*/\1/p")
 
-# Si pubblica l'ultimo commit (git archive HEAD), mai la cartella di lavoro: un'altra sessione può avere modifiche a
-# metà. Test su quella copia, immagine costruita e provata qui, poi spedita già pronta (docker save | docker load):
-# sul server non si compila niente.
+# Si pubblica il tag della versione dichiarata dall'ultimo commit (git archive vX.Y.Z, quello di make bump), mai la
+# cartella di lavoro: un'altra sessione può avere modifiche a metà, e i commit dopo il tag aspettano la versione dopo.
+# Test su quella copia, immagine costruita e provata qui, spinta sul registry di Gitea come :vX.Y.Z e :latest; il
+# VPS la scarica con il tag scritto nel suo compose (preso da HEAD, docker-compose.deploy.yml).
 SMOKE_PORT  ?= 18737
-deploy: ## Pubblica l'ultimo commit: test, immagine costruita e provata qui, spedita al server e riavviata
+deploy: ## Pubblica la versione dell'ultimo commit: test, immagine provata qui, push sul registry, pull e riavvio sul server
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }
-	mkdir -p $(DEPLOY_TMP) && git archive HEAD | tar -x -C $(DEPLOY_TMP)
+	@git rev-parse -q --verify 'refs/tags/$(DEPLOY_VER)' >/dev/null || { echo "manca il tag $(DEPLOY_VER): prima make bump"; exit 2; }
+	mkdir -p $(DEPLOY_TMP) && git archive $(DEPLOY_VER) | tar -x -C $(DEPLOY_TMP)
 	cd $(DEPLOY_TMP) && $(NODE) --test tests/*.test.mjs
-	docker build -q -t $(IMAGE):latest -t $(IMAGE):$$(git rev-parse --short HEAD) $(DEPLOY_TMP)
+	docker build -q -t $(DEPLOY_IMAGE):$(DEPLOY_VER) -t $(DEPLOY_IMAGE):latest $(DEPLOY_TMP)
 	@docker rm -f $(IMAGE)-prova >/dev/null 2>&1 || true
-	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(IMAGE):latest >/dev/null
+	docker run -d --rm --name $(IMAGE)-prova -p 127.0.0.1:$(SMOKE_PORT):80 $(DEPLOY_IMAGE):$(DEPLOY_VER) >/dev/null
 	@ok=1; sleep 1; for u in / /src/main.js /assets/voices/index.json /assets/audio/cartello.mp3; do \
 	  c=$$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:$(SMOKE_PORT)$$u); echo "  prova $$u → $$c"; [ "$$c" = 200 ] || ok=0; done; \
 	  docker rm -f $(IMAGE)-prova >/dev/null; [ $$ok = 1 ] || { echo "l'immagine non risponde come deve: non la spedisco"; exit 1; }
-	ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR)'
-	scp -q $(DEPLOY_TMP)/docker-compose.homeserver.yml $(DEPLOY_HOST):$(DEPLOY_DIR)/docker-compose.yml
-	docker save $(IMAGE):latest | gzip | ssh $(DEPLOY_HOST) 'gunzip | docker load -q && cd $(DEPLOY_DIR) && docker compose up -d && docker image prune -f >/dev/null'
+	docker push -q $(DEPLOY_IMAGE):$(DEPLOY_VER)
+	docker push -q $(DEPLOY_IMAGE):latest
+	git show HEAD:docker-compose.deploy.yml | sed 's|$(DEPLOY_IMAGE):VERSIONE|$(DEPLOY_IMAGE):$(DEPLOY_VER)|' | \
+	  ssh $(DEPLOY_HOST) 'mkdir -p $(DEPLOY_DIR) && cat > $(DEPLOY_DIR)/docker-compose.yml'
+	ssh $(DEPLOY_HOST) 'cd $(DEPLOY_DIR) && docker compose pull -q && docker compose up -d && \
+	  docker image ls $(DEPLOY_IMAGE) --format "{{.Repository}}:{{.Tag}}" | grep -v -x -e $(DEPLOY_IMAGE):$(DEPLOY_VER) | xargs -r docker image rm >/dev/null; \
+	  docker image prune -f >/dev/null'
 	rm -rf $(DEPLOY_TMP)
-	@# Sul server il prune toglie l'immagine vecchia; qui restano solo latest e quella appena pubblicata.
-	@docker image ls $(IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $$(git rev-parse --short HEAD) | \
-	  xargs -r -I{} docker image rm -f $(IMAGE):{} >/dev/null
+	@# Qui restano solo latest e la versione appena pubblicata.
+	@docker image ls $(DEPLOY_IMAGE) --format '{{.Tag}}' | grep -v -x -e latest -e $(DEPLOY_VER) | \
+	  xargs -r -I{} docker image rm -f $(DEPLOY_IMAGE):{} >/dev/null
 	@# L'indirizzo pubblico deve servire la versione appena spedita.
-	@v=$$(grep -o "VERSION = '[^']*'" src/version.js); \
+	@v=$$(git show $(DEPLOY_VER):src/version.js | grep -o "VERSION = '[^']*'"); \
 	  for i in 1 2 3 4 5; do curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" && break; sleep 2; done; \
 	  curl -s $(DEPLOY_URL)/src/version.js | grep -qF "$$v" || { echo "$(DEPLOY_URL) non serve $$v"; exit 1; }
-	@echo "→ $(DEPLOY_URL) ($$(git log -1 --format='%h %s'))"
+	@echo "→ $(DEPLOY_URL) ($(DEPLOY_IMAGE):$(DEPLOY_VER), $$(git log -1 --format='%h %s' $(DEPLOY_VER)))"
+
+runner: ## Crea (se manca) e avvia sul PC il runner delle Gitea Actions (tools/gitea-runner, scripts/runner.sh)
+	bash scripts/runner.sh
 
 deploy-logs: ## Log del container sul server di deploy
 	@test -n "$(DEPLOY_HOST)" || { echo "manca DEPLOY_HOST: scrivilo in deploy.local.mk"; exit 2; }

README.md

@@ -23,7 +23,9 @@ Si gioca online su **https://50037.manzolo.it** (50037 è il CAP di San Piero),
 
 ## Giocare in locale
 
-Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES.
+Il gioco si scarica da **https://git.manzolo.it/manzolo/leggenda-del-regolo**: nella pagina dei
+[tag](https://git.manzolo.it/manzolo/leggenda-del-regolo/tags) c'è lo zip di ogni versione (l'ultima è quella online).
+Niente da installare e niente da compilare: HTML, CSS e moduli JavaScript ES. Dentro la cartella scompattata:
 
 ```zsh
 python3 -m http.server 8000     # poi http://localhost:8000
@@ -49,7 +51,7 @@ Oppure `make up` (Docker, su http://localhost:8080). Non aprire `index.html` con
 make verify        # sintassi, test, prova nel browser: quello che gira prima di ogni versione
 make voci          # le voci delle battute nuove (XTTS-v2 su GPU)
 make bump          # nuova versione: verifica, commit e tag
-make deploy        # pubblica l'ultimo commit (immagine Docker spedita al server)
+make deploy        # pubblica la versione: immagine sul registry di Gitea, il server la scarica
 ```
 
 ## Chi ha fatto cosa

docker-compose.deploy.yml

@@ -0,0 +1,15 @@
+# Il compose del VPS (make deploy lo copia in DEPLOY_DIR con il tag della versione al posto di VERSIONE).
+# L'immagine viene dal registry di Gitea; niente porte esposte: il container sta sulla rete esterna nginx-net,
+# dove Nginx Proxy Manager del VPS lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
+# Per tornare indietro: sul VPS si rimette il tag precedente qui sotto e si rifà `docker compose pull && docker compose up -d`.
+services:
+  leggenda-regolo:
+    image: git.manzolo.it/manzolo/leggenda-regolo:VERSIONE
+    container_name: leggenda-regolo
+    restart: unless-stopped
+    networks:
+      - nginx-net
+
+networks:
+  nginx-net:
+    external: true

docker-compose.homeserver.yml

@@ -1,13 +0,0 @@
-# Deploy dietro un reverse proxy (make deploy): l'immagine arriva già costruita dal PC (docker load), niente porte esposte, il container sta sulla rete esterna nginx-net,
-# dove Nginx Proxy Manager del VPS lo pubblica col suo nome (50037.manzolo.it → leggenda-regolo:80).
-services:
-  leggenda-regolo:
-    image: leggenda-regolo:latest
-    container_name: leggenda-regolo
-    restart: unless-stopped
-    networks:
-      - nginx-net
-
-networks:
-  nginx-net:
-    external: true

package.json

@@ -1,6 +1,6 @@
 {
   "name": "leggenda-del-regolo",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "private": true,
   "type": "module",
   "scripts": {

scripts/git-hooks/pre-push

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Prima di ogni push: il repo su git.manzolo.it è pubblico, quindi niente che check-public bocci deve partire.
+# Si attiva una volta con `make hooks` (core.hooksPath = scripts/git-hooks).
+cd "$(git rev-parse --show-toplevel)" || exit 1
+bash scripts/check-public.sh || { echo; echo "pre-push: push bloccato da check-public (vedi sopra)."; exit 1; }

scripts/runner.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Crea (se manca) e avvia il runner delle Gitea Actions su questo PC: `make runner`.
+# Rifarlo da zero: `docker compose -f tools/gitea-runner/docker-compose.yml down`, cancellare $RUNNER_DATA e il runner
+# vecchio da Gitea (repo → Impostazioni → Actions → Runner), poi di nuovo `make runner`.
+# Il token di registrazione si chiede all'API di Gitea con le credenziali di git (serve lo scope write:repository).
+set -euo pipefail
+ROOT=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+COMPOSE="$ROOT/tools/gitea-runner/docker-compose.yml"
+REPO=${RUNNER_REPO:-manzolo/leggenda-del-regolo}
+export RUNNER_DATA=${RUNNER_DATA:-$HOME/.local/share/gitea-runner}
+export GITEA_RUNNER_NAME=${GITEA_RUNNER_NAME:-pc-$(hostname | tr '[:upper:]' '[:lower:]')}
+mkdir -p "$RUNNER_DATA"
+
+if [[ ! -s $RUNNER_DATA/.runner ]]; then
+    pass=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^password=//p')
+    user=$(printf 'protocol=https\nhost=git.manzolo.it\n\n' | git credential fill | sed -n 's/^username=//p')
+    [[ -n $pass ]] || { echo "nessuna credenziale git per git.manzolo.it"; exit 1; }
+    tok=$(curl -sf -X POST -u "$user:$pass" "https://git.manzolo.it/api/v1/repos/$REPO/actions/runners/registration-token" |
+          python3 -c 'import json,sys; print(json.load(sys.stdin)["token"])') ||
+        { echo "Gitea non ha dato il token di registrazione (scope write:repository?)"; exit 1; }
+    echo "registro il runner $GITEA_RUNNER_NAME su $REPO"
+    GITEA_RUNNER_REGISTRATION_TOKEN=$tok docker compose -f "$COMPOSE" up -d
+    for _ in $(seq 30); do [[ -s $RUNNER_DATA/.runner ]] && break; sleep 1; done
+    [[ -s $RUNNER_DATA/.runner ]] || { docker logs --tail 20 gitea-runner; echo "registrazione non riuscita"; exit 1; }
+    chmod 600 "$RUNNER_DATA/.runner" 2>/dev/null || true
+fi
+# Senza token nell'ambiente del container: da qui in poi si autentica con .runner.
+docker compose -f "$COMPOSE" up -d
+sleep 2; docker logs --tail 1 gitea-runner

src/version.js

@@ -1,5 +1,5 @@
 // La versione del gioco: la cambia scripts/bump.sh, insieme a package.json.
-export const VERSION = '0.1.67';
+export const VERSION = '0.1.68';
 
 // Immagini, musiche e voci con ?v=<versione>: a ogni versione l'indirizzo cambia e il browser le riscarica,
 // mentre fra una versione e l'altra le tiene in cache a lungo (nginx.conf).

tools/gitea-runner/config.yaml

@@ -0,0 +1,13 @@
+# Configurazione di act_runner (vedi docker-compose.yml accanto).
+log:
+  level: info
+runner:
+  file: .runner
+  capacity: 2
+  timeout: 30m
+container:
+  network: ""
+  privileged: false
+  options: "--memory=4g"
+  valid_volumes: []
+  force_pull: false

tools/gitea-runner/docker-compose.yml

@@ -0,0 +1,19 @@
+# Runner delle Gitea Actions di git.manzolo.it, sul PC di Andrea (dal 2026-11-01). Si crea e si avvia con
+# `make runner` (scripts/runner.sh): registra il runner sul repo se manca e lo lascia acceso (riparte con Docker).
+# I job girano in container fratelli tramite il socket Docker del PC; le credenziali del runner stanno fuori dal repo.
+name: gitea-runner
+services:
+  runner:
+    image: gitea/act_runner:0.6.1
+    container_name: gitea-runner
+    restart: unless-stopped
+    environment:
+      CONFIG_FILE: /config.yaml
+      GITEA_INSTANCE_URL: https://git.manzolo.it
+      GITEA_RUNNER_REGISTRATION_TOKEN: ${GITEA_RUNNER_REGISTRATION_TOKEN:-}
+      GITEA_RUNNER_NAME: ${GITEA_RUNNER_NAME:-pc-andrea}
+      GITEA_RUNNER_LABELS: ubuntu-latest:docker://node:22-bookworm
+    volumes:
+      - ./config.yaml:/config.yaml:ro
+      - ${RUNNER_DATA:?}:/data
+      - /var/run/docker.sock:/var/run/docker.sock