Merge pull request 'Zaříznout stará jména kostky' (#20) from agents/claude/zariznout-stara-jmena into main

Reviewed-on: #20

.dockerignore

@@ -0,0 +1,20 @@
+# Do image patří jen to, co appka za běhu potřebuje.
+.git/
+.github/
+.gitea/
+.venv/
+.build/
+.pytest_cache/
+__pycache__/
+dist/
+tests/
+deploy/
+*.db
+*.spec
+build.sh
+dice.py
+verze.txt
+README.md
+requirements*.in
+requirements-dev.txt
+requirements-build.txt

.gitea/workflows/binarka.yml

@@ -53,17 +53,28 @@ jobs:
           uv --version
 
       - name: Testy
-        run: uv run --with-requirements requirements.txt --no-project pytest -q
+        run: uv run --with-requirements requirements-dev.txt --no-project pytest -q
 
       - name: Binárka
-        run: ./build.sh
+        run: |
+          # Runner klonuje jeden commit bez značek, takže si git describe
+          # nemá o co opřít — na tagu mu verzi řekneme rovnou.
+          if [ "$GITHUB_REF_TYPE" = tag ]; then
+              export VERSION="$GITHUB_REF_NAME"
+          fi
+          ./build.sh
 
       - name: Zkouška
         run: |
-          XDG_DATA_HOME=/tmp/zkouska DICE_PORT=8321 DICE_HOST=127.0.0.1 \
-              ./dist/kostky > /tmp/server.log 2>&1 &
+          # Vlastní adresář pro každý běh. Runner si /tmp mezi běhy drží
+          # a binárka umí sáhnout po databázi ve starém umístění, takže
+          # zbytek po dřívější zkoušce by tuhle poslal vedle.
+          XDG=$(mktemp -d)
+
+          XDG_DATA_HOME="$XDG" DICE_PORT=8321 DICE_HOST=127.0.0.1 \
+              ./dist/dice-counter > /tmp/server.log 2>&1 &
           server=$!
-          trap 'kill $server 2>/dev/null || true' EXIT
+          trap 'kill $server 2>/dev/null || true; rm -rf "$XDG"' EXIT
 
           for _ in $(seq 30); do
               curl -sf -o /dev/null http://127.0.0.1:8321/ && break
@@ -73,14 +84,15 @@ jobs:
           curl -sf -o /dev/null http://127.0.0.1:8321/
           curl -sf -o /dev/null http://127.0.0.1:8321/static/style.css
           curl -sf -o /dev/null http://127.0.0.1:8321/board
-          test -f /tmp/zkouska/kostky/dice.db
+          test -f "$XDG/dice-counter/dice.db"
+          ./dist/dice-counter --version
           cat /tmp/server.log
 
       - name: Na release
         if: startsWith(github.ref, 'refs/tags/')
         env:
           TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ASSET: kostky-linux-x86_64
+          ASSET: dice-counter-linux-x86_64
         run: |
           api="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
           auth="Authorization: token ${TOKEN}"
@@ -97,8 +109,8 @@ jobs:
           fi
 
           # Součet se počítá nad jménem, pod kterým se soubor stahuje, aby
-          # šel ověřit rovnou: sha256sum -c kostky-linux-x86_64.sha256
-          cp dist/kostky "$ASSET"
+          # šel ověřit rovnou: sha256sum -c dice-counter-linux-x86_64.sha256
+          cp dist/dice-counter "$ASSET"
           sha256sum "$ASSET" | tee "$ASSET.sha256"
 
           for file in "$ASSET" "$ASSET.sha256"; do

.gitea/workflows/image.yml

@@ -0,0 +1,85 @@
+# Postaví kontejnerový image a zkusí ho spustit. Nikam ho neposílá.
+#
+# Dockerfile by se jinak rozbil až ve chvíli, kdy se tagne release — tohle ho
+# ohlídá nad každým pull requestem.
+#
+# Publikuje se jinde: .github/workflows/image.yml. Zdejší runner běží v LXC,
+# kde nejde zaregistrovat binfmt, takže arm64 by se tu postavit nedalo.
+# Registrace je vlastnost jádra hostitele a to je produkční stroj, do kterého
+# se kvůli počitadlu kostek vrtat nebude.
+#
+# Staví se nativní amd64 obyčejným `docker build`, žádný buildx ani emulace.
+name: image
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  ZKOUSKA_PORT: "18000"
+
+jobs:
+  image:
+    runs-on: homelab
+
+    steps:
+      - name: Zdrojáky
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git init -q .
+          git remote remove origin 2>/dev/null || true
+          git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
+          git config http.extraheader "Authorization: token ${TOKEN}"
+          git fetch -q --depth 1 origin "${GITHUB_REF}"
+          git config --unset http.extraheader
+          git checkout -qf FETCH_HEAD
+          git clean -qfd
+
+      - name: Předpoklady
+        run: |
+          command -v docker >/dev/null \
+              || { echo "Docker na runneru není." >&2; exit 1; }
+          docker version --format '{{.Server.Version}}'
+
+      - name: Stavba
+        run: |
+          docker build -f deploy/Dockerfile \
+              --build-arg VERSION="zkouska-${GITHUB_SHA:0:7}" \
+              -t dice-counter:zkouska .
+
+      - name: Zkouška
+        run: |
+          trap 'docker rm -f dice-counter-zkouska >/dev/null 2>&1 || true' EXIT
+
+          # Port musí být stejný uvnitř i venku: appka poslouchá na DICE_PORT,
+          # takže mapovat ho na jiný by znamenalo mířit do prázdna.
+          # Adresa se vnucuje, ať zkouška nezávisí na síti runneru a dá se
+          # ověřit, co přesně tabule nabídne.
+          docker run -d --name dice-counter-zkouska --init \
+              -p "${ZKOUSKA_PORT}:${ZKOUSKA_PORT}" -e DICE_HOST=127.0.0.1 \
+              -e DICE_PORT="${ZKOUSKA_PORT}" dice-counter:zkouska
+
+          for _ in $(seq 30); do
+              curl -sf -o /dev/null "http://127.0.0.1:${ZKOUSKA_PORT}/" && break
+              sleep 1
+          done
+
+          curl -sf -o /dev/null "http://127.0.0.1:${ZKOUSKA_PORT}/" || {
+              echo "Kontejner se nerozeběhl." >&2
+              docker logs dice-counter-zkouska >&2
+              exit 1; }
+          curl -sf -o /dev/null "http://127.0.0.1:${ZKOUSKA_PORT}/static/style.css"
+          curl -sf "http://127.0.0.1:${ZKOUSKA_PORT}/board" | grep -q "127.0.0.1:${ZKOUSKA_PORT}"
+          curl -sf -o /dev/null "http://127.0.0.1:${ZKOUSKA_PORT}/export"
+
+          # Verze se musí do image opravdu dostat, ne se hlásit jako neznámá.
+          docker run --rm dice-counter:zkouska python web.py --version
+          ! docker run --rm dice-counter:zkouska python web.py --version | grep -q "neznámá"
+
+          docker logs dice-counter-zkouska
+          echo "Image jede."
+
+      - name: Úklid
+        if: always()
+        run: docker rmi dice-counter:zkouska >/dev/null 2>&1 || true

.gitea/workflows/testy.yml

@@ -49,7 +49,7 @@ jobs:
       - name: Testy
         run: |
           uv run --managed-python --python "${{ matrix.python }}" \
-              --with-requirements requirements.txt --no-project \
+              --with-requirements requirements-dev.txt --no-project \
               pytest -q
 
       - name: Terminálová verze

.github/workflows/binarky.yml

@@ -1,4 +1,4 @@
-# Binárky pro Windows a macOS.
+# Binárky pro Windows, macOS a Linux na ARM.
 #
 # PyInstaller neumí křížovou kompilaci: binárku pro každý systém musí postavit
 # ten systém. Kupovat kvůli tomu Mac nebo krmit Windows VM by bylo přehnané,
@@ -8,8 +8,10 @@
 # z Gitey zrcadlí a hotové soubory se posílají zpátky na tamní release přes
 # Gitea API. Jedna stránka s releasy, ta původní.
 #
-# Linux se tu schválně nestaví — o ten se stará vlastní runner
-# (.gitea/workflows/binarka.yml) a dělá to líp, proti glibc 2.17.
+# Linux na x86-64 se tu schválně nestaví — o ten se stará vlastní runner
+# (.gitea/workflows/binarka.yml). Když GitHub vypadne, release má pořád tu
+# platformu, na které to reálně poběží. ARM doma není na čem postavit, takže
+# ten jediný linuxový sem patří.
 name: binárky
 
 on:
@@ -29,14 +31,17 @@ jobs:
       matrix:
         include:
           - os: windows-latest
-            asset: kostky-windows-x86_64.exe
-            built: dist/kostky.exe
+            asset: dice-counter-windows-x86_64.exe
+            built: dist/dice-counter.exe
           - os: macos-15-intel    # Intel; macos-13 GitHub zrušil
-            asset: kostky-macos-x86_64
-            built: dist/kostky
+            asset: dice-counter-macos-x86_64
+            built: dist/dice-counter
           - os: macos-latest      # Apple Silicon
-            asset: kostky-macos-arm64
-            built: dist/kostky
+            asset: dice-counter-macos-arm64
+            built: dist/dice-counter
+          - os: ubuntu-24.04-arm  # pro Raspberry Pi a spol.
+            asset: dice-counter-linux-arm64
+            built: dist/dice-counter
 
     runs-on: ${{ matrix.os }}
     defaults:
@@ -52,10 +57,16 @@ jobs:
       - uses: astral-sh/setup-uv@v10.0.1
 
       - name: Testy
-        run: uv run --with-requirements requirements.txt --no-project pytest -q
+        run: uv run --with-requirements requirements-dev.txt --no-project pytest -q
 
       - name: Binárka
-        run: ./build.sh
+        run: |
+          # Na tagu je verze jistá. Jinde je repozitář naklonovaný mělce
+          # a build.sh si vystačí s tím, co z gitu vyčte.
+          if [ "$GITHUB_REF_TYPE" = tag ]; then
+              export VERSION="$GITHUB_REF_NAME"
+          fi
+          ./build.sh
 
       - name: Zkouška
         run: |
@@ -75,6 +86,10 @@ jobs:
           curl -sf "http://127.0.0.1:8123/board" | grep -q "127.0.0.1:8123"
           test -f zkouska/dice.db
 
+          # Verze se musí do binárky opravdu dostat, ne se hlásit jako neznámá.
+          "${{ matrix.built }}" --version
+          ! "${{ matrix.built }}" --version | grep -q "neznámá"
+
           echo "Binárka jede."
 
       - name: Na release
@@ -109,7 +124,7 @@ jobs:
           fi
 
           # Součet se počítá nad jménem, pod kterým se soubor stahuje, aby
-          # šel ověřit rovnou: shasum -a 256 -c kostky-macos-arm64.sha256
+          # šel ověřit rovnou: shasum -a 256 -c dice-counter-macos-arm64.sha256
           cp "${{ matrix.built }}" "$ASSET"
           soucet "$ASSET" | tee "$ASSET.sha256"
 

.github/workflows/image.yml

@@ -0,0 +1,79 @@
+# Publikuje kontejnerový image do registru balíčků Gitey, pro amd64 i arm64.
+#
+# Proč zrovna odsud: domácí runner běží v LXC, kde nejde zaregistrovat binfmt
+# — je to vlastnost jádra hostitele a ten je produkční. Běhouni GitHubu jsou
+# plnohodnotné virtuály, kde emulace funguje bez řečí.
+#
+# Doma se image přesto staví a zkouší nad každým pull requestem
+# (.gitea/workflows/image.yml), jen se nikam neposílá. Stejná dělba jako
+# u binárek: doma se hlídá, tady se vydává.
+name: image
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+env:
+  REGISTRY: gitea.spacilovi.eu
+  IMAGE: david-spacil/dice-counter
+  PLATFORMS: linux/amd64,linux/arm64
+
+jobs:
+  publikace:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Přesná verze, ne plovoucí značka — viz binarky.yml.
+      - uses: actions/checkout@v7.0.1
+
+      - name: QEMU pro arm64
+        run: |
+          # Bez hotové akce z marketplace, ať není co udržovat. Běhoun je
+          # virtuál, takže privilegovaný kontejner smí zapisovat do binfmt
+          # a registrace platí pro celé jádro.
+          docker run --privileged --rm tonistiigi/binfmt --install arm64
+
+      - name: Builder
+        run: |
+          # Výchozí ovladač Dockeru multiplatformní stavbu neumí.
+          docker buildx create --name dice-counter --driver docker-container --use
+          docker buildx inspect --bootstrap
+
+          # Bez tohohle by stavba spadla až na konci a hláška by nic neřekla.
+          PLATFORMY=$(docker buildx inspect)
+          echo "$PLATFORMY" | grep -q "linux/arm64" || {
+              echo "Buildkit nevidí linux/arm64, emulace se nezaregistrovala." >&2
+              exit 1; }
+
+      - name: Publikace
+        env:
+          TOKEN: ${{ secrets.PACKAGE_TOKEN }}
+          # Uživatel v Gitee, ne na GitHubu. Shodou okolností je to totéž.
+          VLASTNIK: david-spacil
+        run: |
+          # Spouští se to i ručně, a to klidně nad větví. Bez tagu není z čeho
+          # udělat verzi a `:latest` by ukazoval na rozdělanou práci.
+          [ "$GITHUB_REF_TYPE" = tag ] || {
+              echo "Publikovat jde jen z tagu, tohle je ${GITHUB_REF_TYPE} ${GITHUB_REF_NAME}." >&2
+              exit 1; }
+
+          # Automatický token na balíčky nestačí ani u Gitey samotné, natož
+          # odsud — musí to být osobní token s oprávněním write:package.
+          [ -n "$TOKEN" ] || { echo "Chybí secret PACKAGE_TOKEN." >&2; exit 1; }
+          echo "$TOKEN" | docker login "$REGISTRY" -u "$VLASTNIK" --password-stdin
+          trap 'docker logout "$REGISTRY" >/dev/null 2>&1 || true' EXIT
+
+          # Značka bez počátečního "v": v repozitáři je v1.2.0, u image se
+          # čeká 1.2.0. Verze vypálená do image ale zůstává s "v", ať --version
+          # hlásí totéž co binárky.
+          VERZE="${GITHUB_REF_NAME#v}"
+
+          docker buildx build --platform "$PLATFORMS" --push \
+              -f deploy/Dockerfile \
+              --build-arg VERSION="${GITHUB_REF_NAME}" \
+              -t "$REGISTRY/$IMAGE:$VERZE" \
+              -t "$REGISTRY/$IMAGE:latest" .
+
+          echo "Publikováno: $REGISTRY/$IMAGE:$VERZE a :latest"
+          docker buildx imagetools inspect "$REGISTRY/$IMAGE:$VERZE"

.gitignore

@@ -5,3 +5,4 @@ __pycache__/
 dist/
 build/
 .build/
+verze.txt

README.md

@@ -13,18 +13,19 @@ Stáhni binárku pro svůj systém z
 
 | Systém | Soubor |
 |---|---|
-| Linux (x86-64) | `kostky-linux-x86_64` |
-| macOS (Apple Silicon) | `kostky-macos-arm64` |
-| macOS (Intel) | `kostky-macos-x86_64` |
-| Windows (x86-64) | `kostky-windows-x86_64.exe` |
+| Linux (x86-64) | `dice-counter-linux-x86_64` |
+| Linux (ARM64) | `dice-counter-linux-arm64` |
+| macOS (Apple Silicon) | `dice-counter-macos-arm64` |
+| macOS (Intel) | `dice-counter-macos-x86_64` |
+| Windows (x86-64) | `dice-counter-windows-x86_64.exe` |
 
 Nic se neinstaluje — Python, Flask i šablony jsou uvnitř.
 
 Na Linuxu a macOS:
 
 ```bash
-chmod +x kostky-*
-./kostky-linux-x86_64
+chmod +x dice-counter-*
+./dice-counter-linux-x86_64
 ```
 
 Na Windows stačí na `.exe` poklepat.
@@ -37,7 +38,7 @@ Binárky nejsou podepsané — podpisové certifikáty stojí tisíce ročně a
 počitadlo kostek by to byl nesmysl. Systémy si toho všimnou:
 
 - **macOS** stažený soubor označí za karanténní a odmítne ho spustit. Buď
-  značku sundej (`xattr -dr com.apple.quarantine kostky-macos-arm64`), nebo
+  značku sundej (`xattr -dr com.apple.quarantine dice-counter-macos-arm64`), nebo
   soubor stáhni rovnou z terminálu přes `curl -LO` — tudy se karanténa
   nenastavuje.
 - **Windows** ukáže modré okno SmartScreenu. *Další informace* →
@@ -59,12 +60,17 @@ Závislosti si skript nese v hlavičce (PEP 723) a `uv` je obstará sám.
 Server vypíše všechny adresy, na kterých je dostupný:
 
 ```
+dice-counter v1.2.2
+
 Počitadlo je dostupné na:
  → http://10.186.234.182:8000     místní síť
    http://100.91.0.24:8000        přes Tailscale
    http://172.17.0.1:8000         virtuální síť
 ```
 
+Kterou verzi máš, řekne i `dice-counter --version`; visí taky v patičce každé
+stránky. Když něco nefunguje, je to první věc, na kterou se zeptám.
+
 Na notebooku otevři `/board`, naskenuj QR kód telefonem a hraj. Tabule
 nabízí i zbylé adresy — když jedna nefunguje, klikni na jinou a QR kód se
 přepne na ni. Zastavuje se `Ctrl+C`.
@@ -82,9 +88,9 @@ server vypíše při startu.
 
 | Spuštěno | Databáze |
 |---|---|
-| binárkou na Linuxu | `~/.local/share/kostky/dice.db` |
-| binárkou na macOS | `~/Library/Application Support/kostky/dice.db` |
-| binárkou na Windows | `%LOCALAPPDATA%\kostky\dice.db` |
+| binárkou na Linuxu | `~/.local/share/dice-counter/dice.db` |
+| binárkou na macOS | `~/Library/Application Support/dice-counter/dice.db` |
+| binárkou na Windows | `%LOCALAPPDATA%\dice-counter\dice.db` |
 | ze zdrojáků | `dice.db` v pracovním adresáři |
 
 Binárka se při každém spuštění rozbaluje do dočasného adresáře a pouští se
@@ -93,11 +99,134 @@ napevno domovský adresář. Ze zdrojáků zůstává relativní, ať se dá mí
 sad vedle sebe.
 
 Zálohovat i stěhovat jde prostým zkopírováním souboru; `DICE_DB` si ho
-najde kdekoli.
+najde kdekoli. Kdo ho hledat nechce — a z binárky na Windows je zalezlý —
+si ho stáhne ze síně slávy odkazem **Stáhnout databázi** (`/export`). Kopie
+se dělá přes `VACUUM INTO`, takže je použitelná i uprostřed rozehrané hry.
+
+Schéma má verzi uloženou v `PRAGMA user_version` a `storage.migrate()` si
+databázi při každém připojení dorovná. Starší soubory z verzí, kdy se verze
+schématu ještě nepsala, se poznají podle nuly a orazítkují se. Databázi
+založenou novější verzí počitadla appka odmítne otevřít, místo aby ji tiše
+rozbila.
+
+Obsluhuje to `waitress` — čistě pythonní WSGI server, který se zabalí do
+binárky stejně snadno jako zbytek. Vestavěný server Flasku by pod úvodní
+hlášku vysypal varování, že takhle se to nemá, a měl by pravdu.
 
 Počítá se s domácí sítí — appka nemá přihlašování a kdokoli na stejné WiFi
 může zapisovat.
 
+## Nasazení na server
+
+Kdo nechce každý večer spouštět binárku na notebooku, může to nechat běžet
+pořád. Obojí níž počítá **jen s domácí sítí** — appka nemá přihlašování
+a ani jedno nasazení ji nijak nezabezpečuje. Do internetu to nepatří.
+
+### Proxmox (LXC)
+
+Jeden příkaz v terminálu uzlu Proxmoxu, jako root. Založí kontejner,
+nastaví ho, stáhne poslední vydanou binárku, ověří kontrolní součet a zapne
+službu:
+
+```bash
+bash -c "$(curl -fsSL https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/pve-dice-counter.sh)"
+```
+
+Na konci vypíše adresu, na které počitadlo poslouchá. Výchozí nastavení je
+1 jádro, 512 MB, 4 GB disku a Debian 13; úložiště si najde samo. Přebíjí se
+proměnnými před příkazem:
+
+```bash
+MEMORY=1024 STORAGE=local-zfs PORT=8080 bash -c "$(curl -fsSL ...)"
+```
+
+| Proměnná | Výchozí |
+|---|---|
+| `CTID` | první volné číslo |
+| `CT_HOSTNAME` | `dice-counter` |
+| `CORES`, `MEMORY`, `DISK` | `1`, `512`, `4` |
+| `STORAGE` | první aktivní úložiště pro kontejnery |
+| `TEMPLATE_STORAGE`, `BRIDGE` | `local`, `vmbr0` |
+| `PORT` | `8000` |
+| `UNPRIVILEGED`, `OSVERSION` | `1`, `13` |
+| `NESTING` | `1` — systemd v Debianu 13 ho potřebuje |
+| `AUTOLOGIN` | `1` — konzole ve webu Proxmoxu bez hesla |
+| `VERSION` | poslední vydání |
+
+Aktualizace na novější vydání se dá spustit dvěma způsoby. Buď zevnitř
+kontejneru, kde na to stačí jedno slovo:
+
+```bash
+update
+```
+
+Nebo z uzlu Proxmoxu tím samým příkazem s číslem kontejneru:
+
+```bash
+CTID=123 MODE=update bash -c "$(curl -fsSL ...)"
+```
+
+Obojí vymění binárku za poslední vydání a službu restartuje; databáze zůstává.
+Příkaz `update` si přitom obnoví i sám sebe — instalátor bere z větve `main`,
+takže jede na nejnovější verzi skriptu, ne na té, se kterou se instalovalo.
+
+Do konzole kontejneru se dostaneš přímo z webu Proxmoxu, **žádné jméno ani
+heslo se nezadává** — kontejner root heslo nemá a konzole se přihlašuje sama.
+Nová práva to nikomu nedává: kdo se dostane do webu Proxmoxu, má root na uzlu
+tak jako tak. Komu se to nezdá, vypne to přes `AUTOLOGIN=0` a do kontejneru
+pak leze přes `pct enter <ctid>`.
+
+Podoba je odkoukaná od [community-scripts.org](https://community-scripts.org),
+ale nic z jejich frameworku se nestahuje — jejich `build.func` si instalační
+skript hledá natvrdo ve vlastním repozitáři, takže mimo něj nefunguje.
+
+Instalátor, který běží uvnitř kontejneru, je ve skriptu vložený jako text —
+přes rouru z curlu na disku hostitele žádný druhý soubor není. O Proxmoxu nic
+neví, takže se dá použít i v kontejneru, který sis založil sám:
+
+```bash
+bash pve-dice-counter.sh instalator > install.sh
+```
+
+Je idempotentní; druhé spuštění jen vymění binárku za nejnovější.
+
+### Docker
+
+Stačí jeden soubor, repozitář k tomu potřeba není:
+
+```bash
+curl -fsSLO https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/docker-compose.yaml
+docker compose up -d
+```
+
+Image se stáhne hotový z registru Gitey, pro amd64 i arm64 — Docker si vybere
+svoji variantu sám. Databáze leží v pojmenovaném svazku, appka běží pod
+nerootovým uživatelem.
+
+Aktualizace na novější vydání:
+
+```bash
+docker compose pull && docker compose up -d
+```
+
+Kdo si ho radši postaví ze zdrojáků, přebije ten stažený stejnou značkou:
+
+```bash
+docker build -f deploy/Dockerfile -t gitea.spacilovi.eu/david-spacil/dice-counter:latest .
+```
+
+**Pozor na síť.** Compose schválně používá `network_mode: host`. V bridge
+režimu kontejner uvnitř vidí adresu jako `172.17.0.2`, tabule ji poctivě
+nabídne a vygeneruje na ni QR kód — jenže z telefonu je nedosažitelná.
+Kdo bridge potřebuje, musí nastavit `DICE_HOST` na adresu hostitele v LAN.
+
+| | LXC | Docker |
+|---|---|---|
+| Odkud | vydaná binárka z releasu | image z registru |
+| Databáze | `/var/lib/dice-counter/dice.db` | svazek `dice-counter-data` |
+| Aktualizace | `update` uvnitř kontejneru | `docker compose pull` |
+| Adresa a QR | funguje samo | potřeba síť hostitele |
+
 ## Když se telefon nepřipojí
 
 Adresy se hledají při každém načtení tabule, takže přechod z domácí WiFi na
@@ -132,9 +261,11 @@ při remíze na prvním místě se hraje dál.
 | `web.py` | Flask aplikace |
 | `dice.py` | totéž v terminálu, bez ukládání |
 | `console.py` | aby čeština prošla i windowsovou konzolí |
-| `build.sh`, `kostky.spec` | stavba binárky |
-| `.gitea/workflows/` | testy a linuxová binárka doma |
+| `version.py` | která verze to je — z gitu, nebo z binárky |
+| `build.sh`, `dice-counter.spec` | stavba binárky |
+| `.gitea/workflows/` | testy, linuxová binárka a zkouška image doma |
 | `.github/workflows/` | binárky pro Windows a macOS |
+| `deploy/` | nasazení na server: Proxmox LXC a Docker |
 
 Terminálová verze zůstává funkční jako záloha:
 
@@ -155,16 +286,45 @@ python -m venv .venv
 Na Fedoře stačí i systémové balíčky, pak se nemusí řešit vůbec nic:
 
 ```bash
-sudo dnf install python3-flask python3-qrcode python3-tabulate
+sudo dnf install python3-flask python3-qrcode python3-tabulate python3-waitress
 python3 web.py
 ```
 
+## Závislosti
+
+Verze jsou zamčené, aby binárka postavená dnes a za půl roku obsahovala
+totéž. Volné seznamy jsou v `.in`, zamčené v `.txt`:
+
+| Soubor | K čemu |
+|---|---|
+| `requirements.in` → `.txt` | běh aplikace |
+| `requirements-dev.in` → `.txt` | + pytest, pro testy |
+| `requirements-build.in` → `.txt` | + PyInstaller, pro stavbu binárky |
+
+Aktualizace je vědomý krok, ne vedlejší efekt toho, že něco vyšlo na PyPI:
+
+```bash
+for f in requirements requirements-dev requirements-build; do
+    uv pip compile "$f.in" -o "$f.txt"
+done
+```
+
+Verze se píšou ještě jednou v hlavičce PEP 723 na začátku `web.py` a
+`dice.py`, aby fungovalo `uv run web.py`. Že se ty dva zápisy shodují, hlídá
+`tests/test_zavislosti.py` — po každém přegenerování je potřeba hlavičky
+srovnat.
+
 ## Vlastní binárka
 
 ```bash
 ./build.sh
 ```
 
+Verzi si `build.sh` vezme z `git describe`, nebo se dá vnutit přes
+`VERSION=v1.2.3 ./build.sh`. Zapíše ji do `verze.txt`, `dice-counter.spec` ji
+přibalí a binárka ji pak umí ohlásit i na cizím počítači, kde žádný git není.
+Verzi Pythonu, proti kterému se staví, přebíjí `PYTHON_VERSION`.
+
 Staví se proti samostatnému CPythonu od `uv`, ne proti systémovému. Ten je
 slinkovaný s glibc 2.17; postavené proti Pythonu z Fedory 44 by to chtělo
 glibc 2.43 a nešlo by spustit skoro nikde — glibc drží zpětnou kompatibilitu,
@@ -184,8 +344,9 @@ Otagovaný commit spustí stavbu na obou stranách:
 
 | Kde | Co staví | Workflow |
 |---|---|---|
-| vlastní runner u Gitey | Linux | `.gitea/workflows/binarka.yml` |
-| GitHub Actions | Windows, macOS ×2 | `.github/workflows/binarky.yml` |
+| vlastní runner u Gitey | Linux x86-64 | `.gitea/workflows/binarka.yml` |
+| GitHub Actions | Windows, macOS ×2, Linux ARM64 | `.github/workflows/binarky.yml` |
+| GitHub Actions | image amd64 + arm64 | `.github/workflows/image.yml` |
 
 ```bash
 git tag v1.0.0 && git push origin v1.0.0
@@ -194,19 +355,28 @@ git tag v1.0.0 && git push origin v1.0.0
 GitHub je tu jen půjčená dílna. Repozitář se tam z Gitey zrcadlí
 ([mirror](https://github.com/david-spacil/dice-counter)), postavené soubory
 se posílají zpátky na zdejší release přes Gitea API a projekt má pořád jednu
-stránku s releasy — tuhle. Linux se na GitHubu schválně nestaví; doma to jde
-proti staré glibc, a když GitHub vypadne, release má aspoň tu platformu,
-na které to reálně poběží.
+stránku s releasy — tuhle. Linux na x86-64 se na GitHubu schválně nestaví;
+doma to jde proti staré glibc, a když GitHub vypadne, release má aspoň tu
+platformu, na které to reálně poběží. ARM64 je výjimka — doma na něm není
+na čem stavět, a hodí se pro Raspberry Pi nebo jinou malou pořád zapnutou
+krabičku.
 
 Každá stavba nejdřív projede testy a zkusí hotovou binárku nastartovat, než
 ji kamkoli pověsí. Vedle každé visí i `.sha256`, takže se stažený soubor dá
 ověřit:
 
 ```bash
-sha256sum -c kostky-linux-x86_64.sha256     # na macOS: shasum -a 256 -c
+sha256sum -c dice-counter-linux-x86_64.sha256   # na macOS: shasum -a 256 -c
 ```
 
-Nad pull requesty se Linux staví taky, jen se nikam nevěší.
+Nad pull requesty se Linux staví taky, jen se nikam nevěší. Totéž platí pro
+kontejnerový image — doma se nad každým PR postaví a zkusí nastartovat
+(`.gitea/workflows/image.yml`), publikuje se ale až z tagu na GitHubu.
+
+Image se schválně nevydává doma: tamní runner běží v LXC, kde nejde
+zaregistrovat emulaci pro arm64 — je to vlastnost jádra hostitele a ten je
+produkční stroj. Běhouni GitHubu jsou plnohodnotné virtuály, kde to funguje
+bez zásahu do čehokoli.
 
 ## Testy
 
@@ -217,5 +387,5 @@ uv run --with-requirements requirements.txt --no-project pytest
 Nebo z připraveného prostředí prostě `pytest`.
 
 Nad každým pull requestem a nad `main` běží `.gitea/workflows/testy.yml` —
-102 testů na Pythonu 3.11, 3.12, 3.13 i 3.14, a k tomu skriptovaná partie
+118 testů na Pythonu 3.11, 3.12, 3.13 i 3.14, a k tomu skriptovaná partie
 v terminálové verzi, na kterou pytest nesahá.

build.sh

@@ -12,11 +12,20 @@
 # se do ní nedostane, takže kontejner k tomu není potřeba.
 set -euo pipefail
 
-VERSION=${VERSION:-3.11}
+PYTHON_VERSION=${PYTHON_VERSION:-3.11}
 BUILD=${BUILD:-.build}
 
-uv python install "$VERSION"
-uv venv --quiet --managed-python --python "$VERSION" "$BUILD"
+# Verze, kterou binárka ohlásí přes --version. V CI ji na tagu vnutíme
+# proměnnou, protože tam je repozitář naklonovaný na jeden commit a git
+# describe nemá o co se opřít.
+VERSION=${VERSION:-$(git describe --tags --always --dirty 2>/dev/null || echo neznámá)}
+printf '%s\n' "$VERSION" > verze.txt
+echo "Verze: $VERSION"
+
+uv python install "$PYTHON_VERSION"
+# --clear, protože runner si pracovní adresář mezi běhy drží a uv nad
+# existujícím prostředím jinak skončí chybou. Stavíme načisto.
+uv venv --quiet --clear --managed-python --python "$PYTHON_VERSION" "$BUILD"
 
 # Windows dává spustitelné soubory venvu do Scripts/, zbytek světa do bin/.
 python="$BUILD/bin/python"
@@ -26,10 +35,10 @@ if [ -d "$BUILD/Scripts" ]; then
     pyinstaller="$BUILD/Scripts/pyinstaller.exe"
 fi
 
-uv pip install --quiet --python "$python" -r requirements.txt pyinstaller
+uv pip install --quiet --python "$python" -r requirements-build.txt
 
 "$pyinstaller" --clean --noconfirm \
-    --distpath dist --workpath "$BUILD/work" kostky.spec
+    --distpath dist --workpath "$BUILD/work" dice-counter.spec
 
 echo
 ls -lh dist/

console.py

@@ -1,10 +1,10 @@
-"""Aby čeština prošla i tam, kde konzole čeká něco jiného."""
+"""Aby výstup prošel i tam, kde ho nikdo nečeká na konzoli."""
 
 import sys
 
 
 def utf8() -> None:
-    """Přepne standardní výstup na UTF-8.
+    """Přepne standardní výstup na UTF-8 a na řádkové bufferování.
 
     Windows sahá po historické kódové stránce (cp1252, cp852) všude, kde
     výstup není konzole — přesměrovaný do souboru, puštěný ze skriptu, ve
@@ -14,7 +14,14 @@ def utf8() -> None:
     Na konzoli i na ostatních systémech je UTF-8 dávno výchozí a tohle je
     tam prázdná operace. `errors="replace"` je pojistka pro zbylé případy:
     rozsypaný háček je pořád lepší než spadlý server.
+
+    Řádkové bufferování řeší druhou půlku téhož problému. Mimo konzoli
+    Python drží výstup v bloku a pouští ho, až se naplní nebo až program
+    skončí — jenže server neskončí, ten běží. Kdo si ho pustí na pozadí
+    s výpisem do souboru, našel by tam prázdno; přesně to dělá zkouška
+    binárky v CI. Pár řádek hlášky za to bufferovat nemá cenu.
     """
     for stream in (sys.stdout, sys.stderr):
         if hasattr(stream, "reconfigure"):
-            stream.reconfigure(encoding="utf-8", errors="replace")
+            stream.reconfigure(encoding="utf-8", errors="replace",
+                               line_buffering=True)

deploy/Dockerfile

@@ -0,0 +1,56 @@
+# Počitadlo kostek jako kontejner.
+#
+# Staví se ze zdrojáků, ne z vydané binárky: image jde pak sestavit pro
+# amd64 i arm64 a nezávisí na tom, jestli pro danou architekturu release
+# proběhl. Závislosti jsou zamčené v requirements.txt, takže je sestavení
+# opakovatelné.
+#
+#     docker build -f deploy/Dockerfile -t gitea.spacilovi.eu/david-spacil/dice-counter:latest .
+#
+# Sestavuje se z kořene repozitáře, ne z deploy/.
+FROM python:3.11-slim
+
+# Verze se jinak nemá kde vzít — v image není git ani zabalená binárka.
+ARG VERSION=neznámá
+
+# Podle image.source si Gitea připne balíček k repozitáři. Bez toho labelu
+# image sice existuje, ale visí jen pod uživatelem a záložka Packages
+# u repozitáře zůstane prázdná.
+LABEL org.opencontainers.image.source="https://gitea.spacilovi.eu/david-spacil/dice-counter" \
+      org.opencontainers.image.url="https://gitea.spacilovi.eu/david-spacil/dice-counter" \
+      org.opencontainers.image.title="dice-counter" \
+      org.opencontainers.image.description="Počitadlo kostek: telefon zapisuje skóre, notebook ukazuje zápisník" \
+      org.opencontainers.image.version="$VERSION"
+
+RUN useradd --system --uid 1000 --home-dir /app --shell /usr/sbin/nologin dice-counter
+
+WORKDIR /app
+
+# Závislosti zvlášť a dřív než kód, ať se vrstva s pipem přestavuje jen tehdy,
+# když se opravdu změnily.
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY console.py core.py net.py stats.py storage.py version.py web.py ./
+COPY templates/ templates/
+COPY static/ static/
+RUN echo "$VERSION" > verze.txt
+
+# Adresář pro databázi musí vzniknout už tady a patřit správnému uživateli —
+# svazek, který Docker založí sám, by jinak patřil rootovi a appka běžící pod
+# dice-counter by do něj nezapsala.
+RUN install -d -o dice-counter -g dice-counter /data
+VOLUME ["/data"]
+
+ENV DICE_DB=/data/dice.db \
+    DICE_PORT=8000
+
+EXPOSE 8000
+USER dice-counter
+
+# Bez curlu, ten ve slim image není. Stačí, že stránka odpoví — sahá i do
+# databáze, takže se tím kontroluje i ta.
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD python -c "import os,urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ.get('DICE_PORT','8000') + '/')"
+
+CMD ["python", "web.py"]

deploy/docker-compose.yaml

@@ -0,0 +1,46 @@
+# Počitadlo kostek v Dockeru.
+#
+#     curl -fsSLO https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/docker-compose.yaml
+#     docker compose up -d
+#
+# Nic dalšího není potřeba — image se stáhne hotový, pro amd64 i arm64.
+# Kdo si ho chce postavit ze zdrojáků, přebije ten stažený stejnou značkou:
+#
+#     docker build -f deploy/Dockerfile -t gitea.spacilovi.eu/david-spacil/dice-counter:latest .
+#
+# Počítá se s domácí sítí. Appka nemá přihlašování, tohle ji nijak
+# nezabezpečuje a do internetu nepatří.
+
+services:
+  dice-counter:
+    image: gitea.spacilovi.eu/david-spacil/dice-counter:latest
+    container_name: dice-counter
+    restart: unless-stopped
+
+    # Python jako PID 1 nesklízí osiřelé procesy a hůř reaguje na signály.
+    init: true
+
+    # Síť hostitele schválně. V bridge režimu kontejner uvnitř vidí adresu
+    # jako 172.17.0.2, tabule ji poctivě nabídne a vygeneruje na ni QR kód —
+    # jenže z telefonu je nedosažitelná. Se sítí hostitele appka najde tu
+    # adresu, na kterou se telefon opravdu dovolá.
+    #
+    # Kdo bridge potřebuje, ať zakomentuje řádek níž, odkomentuje ports
+    # a nastaví DICE_HOST na adresu hostitele v LAN:
+    #
+    #   ports:
+    #     - "8000:8000"
+    #   environment:
+    #     DICE_HOST: 192.168.1.10
+    network_mode: host
+
+    environment:
+      DICE_PORT: 8000
+      DICE_DB: /data/dice.db
+
+    volumes:
+      - dice-counter-data:/data
+
+volumes:
+  # Zálohu si stáhneš rovnou z appky přes /export, takže se sem nemusí lézt.
+  dice-counter-data:

deploy/pve-dice-counter.sh

@@ -0,0 +1,391 @@
+#!/usr/bin/env bash
+# Založí na Proxmoxu LXC kontejner s počitadlem kostek.
+#
+# Pouští se v terminálu uzlu Proxmoxu jako root, jedním příkazem:
+#
+#   bash -c "$(curl -fsSL https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/pve-dice-counter.sh)"
+#
+# Aktualizace stávajícího kontejneru na novější vydání:
+#
+#   CTID=123 MODE=update bash -c "$(curl -fsSL .../pve-dice-counter.sh)"
+#
+# Ze staženého souboru jde i obojí postaru: `bash pve-dice-counter.sh` a
+# `bash pve-dice-counter.sh update 123`.
+#
+# Podoba je odkoukaná od community-scripts.org, ale nic z jejich frameworku
+# se tu nestahuje — jejich build.func si instalační skript hledá natvrdo ve
+# vlastním repozitáři, takže mimo něj nefunguje.
+#
+# Počítá se s domácí sítí. Appka nemá přihlašování a tenhle skript ji nijak
+# nezabezpečuje; do internetu ji nepouštěj.
+set -euo pipefail
+
+APP="dice-counter"
+GITEA="${GITEA:-https://gitea.spacilovi.eu}"
+REPO="${REPO:-david-spacil/dice-counter}"
+
+# Výchozí hodnoty. Všechny se dají přebít proměnnou prostředí, třeba:
+#     MEMORY=1024 STORAGE=local-zfs bash -c "$(curl -fsSL ...)"
+CT_HOSTNAME="${CT_HOSTNAME:-dice-counter}"
+CORES="${CORES:-1}"
+MEMORY="${MEMORY:-512}"
+DISK="${DISK:-4}"
+STORAGE="${STORAGE:-}"
+TEMPLATE_STORAGE="${TEMPLATE_STORAGE:-local}"
+BRIDGE="${BRIDGE:-vmbr0}"
+PORT="${PORT:-8000}"
+UNPRIVILEGED="${UNPRIVILEGED:-1}"
+OSVERSION="${OSVERSION:-13}"
+NESTING="${NESTING:-1}"
+AUTOLOGIN="${AUTOLOGIN:-1}"      # konzole ve webu Proxmoxu bez hesla
+VERSION="${VERSION:-}"          # prázdné = poslední vydání
+
+# --- výpisy ------------------------------------------------------------------
+
+# Bez tohohle Ctrl+C zabije jen rozdělaný podproces a skript jede vesele dál
+# — třeba rovnou zakládat kontejner, na který se čekat nemá.
+trap 'echo; echo -e "\e[1;31m  ✗\e[0m Přerušeno." >&2; exit 130' INT TERM
+
+msg() { echo -e "\e[1;34m  →\e[0m $*"; }
+ok()  { echo -e "\e[1;32m  ✓\e[0m $*"; }
+die() { echo -e "\e[1;31m  ✗\e[0m $*" >&2; exit 1; }
+
+header() {
+    echo
+    echo -e "\e[1;36m  $APP\e[0m — počitadlo kostek do LXC"
+    echo -e "  \e[2m$GITEA/$REPO\e[0m"
+    echo
+}
+
+# --- instalátor, který poběží uvnitř kontejneru ------------------------------
+#
+# Je tu jako text schválně. Skript se pouští i rourou z curlu, kdy na disku
+# hostitele žádný soubor není a nebylo by co poslat dovnitř. Uvozovky kolem
+# 'INSTALL' jsou podstatné: nic z toho se tady nesmí rozvinout, všechny
+# proměnné patří až tomu, co poběží v kontejneru.
+#
+# Vypsat se dá i samostatně: `bash pve-dice-counter.sh instalator > install.sh`,
+# což se hodí, když chceš appku dostat do kontejneru, který sis založil sám.
+installer() {
+cat <<'INSTALL'
+#!/usr/bin/env bash
+# Instalace počitadla uvnitř kontejneru. O Proxmoxu nic neví, takže se dá
+# pustit v jakémkoli Debianu. Je idempotentní — druhé spuštění jen vymění
+# binárku za nejnovější.
+set -euo pipefail
+
+GITEA="${GITEA:-https://gitea.spacilovi.eu}"
+REPO="${REPO:-david-spacil/dice-counter}"
+PORT="${PORT:-8000}"
+VERSION="${VERSION:-}"
+
+USER_NAME=dice-counter
+HOME_DIR=/opt/dice-counter
+DATA_DIR=/var/lib/dice-counter
+SERVICE=dice-counter
+
+msg() { echo -e "\e[1;34m  →\e[0m $*"; }
+ok()  { echo -e "\e[1;32m  ✓\e[0m $*"; }
+die() { echo -e "\e[1;31m  ✗\e[0m $*" >&2; exit 1; }
+
+case "$(dpkg --print-architecture)" in
+    amd64) ASSET=dice-counter-linux-x86_64 ;;
+    arm64) ASSET=dice-counter-linux-arm64 ;;
+    *)     die "Pro architekturu $(dpkg --print-architecture) binárka není." ;;
+esac
+
+msg "Doinstalovávám, co je potřeba ke stažení"
+export DEBIAN_FRONTEND=noninteractive
+apt-get update -qq
+apt-get install -y -qq curl ca-certificates >/dev/null
+ok "Základ je hotový"
+
+if [ -z "$VERSION" ]; then
+    msg "Zjišťuji poslední vydanou verzi"
+    # Jen tag; adresa přílohy se z něj složí, takže tu nepotřebujeme jq.
+    VERSION=$(curl -fsSL "$GITEA/api/v1/repos/$REPO/releases/latest" \
+        | grep -o '"tag_name":[[:space:]]*"[^"]*"' | head -1 | cut -d'"' -f4)
+    [ -n "$VERSION" ] || die "Nepodařilo se zjistit poslední verzi z $GITEA."
+fi
+ok "Instaluje se $VERSION ($ASSET)"
+
+BASE="$GITEA/$REPO/releases/download/$VERSION"
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+
+msg "Stahuji binárku"
+curl -fsSL -o "$TMP/$ASSET" "$BASE/$ASSET" \
+    || die "$ASSET pro $VERSION na releasu není. Vydání pro tuhle architekturu možná ještě neproběhlo."
+curl -fsSL -o "$TMP/$ASSET.sha256" "$BASE/$ASSET.sha256" \
+    || die "Chybí kontrolní součet — radši nic neinstaluju."
+
+msg "Ověřuji kontrolní součet"
+( cd "$TMP" && sha256sum -c "$ASSET.sha256" >/dev/null ) \
+    || die "Kontrolní součet nesedí. Stažený soubor zahazuju."
+ok "Součet sedí"
+
+id -u "$USER_NAME" >/dev/null 2>&1 \
+    || useradd --system --home-dir "$HOME_DIR" --shell /usr/sbin/nologin "$USER_NAME"
+
+install -d -o root -g root -m 755 "$HOME_DIR"
+
+# Zastavit se dá jen to, co běží — při první instalaci služba ještě není.
+if systemctl is-active --quiet "$SERVICE"; then
+    systemctl stop "$SERVICE"
+fi
+
+install -o root -g root -m 755 "$TMP/$ASSET" "$HOME_DIR/dice-counter"
+echo "$VERSION" > "$HOME_DIR/verze"
+ok "Binárka je na místě"
+
+msg "Zapisuji službu"
+cat > "/etc/systemd/system/$SERVICE.service" <<EOF
+[Unit]
+Description=Počitadlo kostek
+Documentation=$GITEA/$REPO
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=$USER_NAME
+Environment=DICE_DB=$DATA_DIR/dice.db
+Environment=DICE_PORT=$PORT
+ExecStart=$HOME_DIR/dice-counter
+Restart=on-failure
+RestartSec=5
+
+# Databáze je jediné, co appka potřebuje mít zapisovatelné. StateDirectory ji
+# založí a předá správnému uživateli, takže se tu nemusí nic chownovat.
+StateDirectory=dice-counter
+ReadWritePaths=$DATA_DIR
+
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+# Binárka se při každém startu rozbaluje do /tmp; tady do vlastního, ne do
+# sdíleného.
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+systemctl daemon-reload
+systemctl enable --quiet --now "$SERVICE"
+ok "Služba běží"
+
+# --- konzole v rozhraní Proxmoxu --------------------------------------------
+
+if [ "${AUTOLOGIN:-1}" = "1" ]; then
+    msg "Nastavuji konzoli"
+    # Kontejner nemá root heslo, takže by se do konzole ve webu Proxmoxu
+    # nedalo dostat. Autologin to řeší stejně, jako to dělají community-scripts.
+    # Nová práva to nikomu nedává — kdo má web Proxmoxu, má root na uzlu tak
+    # jako tak.
+    mkdir -p /etc/systemd/system/container-getty@1.service.d
+    cat > /etc/systemd/system/container-getty@1.service.d/override.conf <<'GETTY'
+[Service]
+ExecStart=
+ExecStart=-/sbin/agetty --autologin root --noclear --keep-baud tty%I 115200,38400,9600 $TERM
+GETTY
+    systemctl daemon-reload
+    systemctl restart container-getty@1.service 2>/dev/null || true
+    ok "Konzole se přihlásí sama"
+fi
+
+# --- příkaz update ----------------------------------------------------------
+
+# Instalátor si necháme, ať je z čeho aktualizovat. Když se skript pouští
+# rourou, soubor neexistuje a zůstane ten z minula.
+#
+# `-ef` je tu nutnost, ne opatrnost: příkaz `update` si nový instalátor uloží
+# rovnou sem a odsud ho pustí, takže `$0` a cíl jsou tentýž soubor. `install`
+# na to řekne "are the same file", skončí chybou a se `set -e` by celý update
+# spadl dřív, než by stihl cokoli udělat.
+if [ -f "$0" ] && ! [ "$0" -ef "$HOME_DIR/install.sh" ]; then
+    install -m 755 "$0" "$HOME_DIR/install.sh"
+fi
+
+cat > /usr/bin/update <<UPDATE
+#!/usr/bin/env bash
+# Aktualizace počitadla na poslední vydání. Stačí napsat: update
+set -euo pipefail
+
+# Nejdřív zkusíme obnovit i samotný instalátor, kdyby se mezitím zlepšil.
+# Bez sítě nebo při změněné adrese se použije ten uložený.
+NOVY=\$(mktemp)
+if curl -fsSL "$GITEA/$REPO/raw/branch/main/deploy/pve-dice-counter.sh" -o "\$NOVY" 2>/dev/null \\
+    && bash "\$NOVY" instalator > "\$NOVY.in" 2>/dev/null \\
+    && bash -n "\$NOVY.in" 2>/dev/null; then
+    install -m 755 "\$NOVY.in" "$HOME_DIR/install.sh"
+fi
+rm -f "\$NOVY" "\$NOVY.in"
+
+exec env PORT="$PORT" GITEA="$GITEA" REPO="$REPO" bash "$HOME_DIR/install.sh"
+UPDATE
+chmod 755 /usr/bin/update
+ok "Aktualizovat půjde příkazem: update"
+
+msg "Čekám, až začne odpovídat"
+for _ in $(seq 30); do
+    curl -fsS -o /dev/null "http://127.0.0.1:$PORT/" 2>/dev/null && break
+    sleep 1
+done
+curl -fsS -o /dev/null "http://127.0.0.1:$PORT/" \
+    || die "Služba nastartovala, ale neodpovídá. Mrkni na journalctl -u $SERVICE."
+
+# Verzi bereme ze souboru, ne z binárky. Starší vydání --version neumí
+# a místo výpisu by nastartovala server, který by tenhle skript zavěsil.
+ok "Počitadlo $(cat "$HOME_DIR/verze") odpovídá na portu $PORT"
+INSTALL
+}
+
+# --- společné části ----------------------------------------------------------
+
+install_into() {
+    local ctid="$1" tmp
+    tmp=$(mktemp)
+    installer > "$tmp"
+
+    msg "Posílám instalátor do kontejneru $ctid"
+    pct push "$ctid" "$tmp" /root/dice-counter-install.sh --perms 0755
+    rm -f "$tmp"
+
+    pct exec "$ctid" -- env PORT="$PORT" GITEA="$GITEA" REPO="$REPO" \
+        VERSION="$VERSION" AUTOLOGIN="$AUTOLOGIN" bash /root/dice-counter-install.sh
+}
+
+address_of() {
+    pct exec "$1" -- hostname -I 2>/dev/null | awk '{print $1}'
+}
+
+hotovo() {
+    local ctid="$1" ip jmeno
+    ip=$(address_of "$ctid")
+    jmeno=$(pct config "$ctid" | awk -F': ' '/^hostname:/ {print $2}')
+
+    echo
+    ok "Hotovo. Kontejner $ctid ($jmeno) běží."
+    echo
+    echo -e "  Zápisník na notebook:  \e[1;32mhttp://${ip}:${PORT}/board\e[0m"
+    echo -e "  Zadávání z telefonu:   \e[1;32mhttp://${ip}:${PORT}/\e[0m"
+    echo
+    echo -e "  \e[2mDatabáze:  /var/lib/dice-counter/dice.db (uvnitř kontejneru)"
+    echo -e "  Aktualizace: v konzoli kontejneru napiš  update"
+    echo -e "  Log:       pct exec $ctid -- journalctl -u dice-counter -f"
+    echo -e "  Konzole:   pct enter $ctid"
+    echo -e "  Zrušit:    pct stop $ctid && pct destroy $ctid\e[0m"
+    echo
+}
+
+# --- co se má vlastně dělat --------------------------------------------------
+#
+# Rourou z curlu se argumenty předávají mizerně, tak jde všechno i proměnnou:
+# MODE=update CTID=123. Ze souboru funguje i `bash pve-dice-counter.sh update 123`.
+MODE="${MODE:-${1:-create}}"
+[ "$MODE" = "update" ] && CTID="${CTID:-${2:-}}"
+
+if [ "$MODE" = "instalator" ]; then
+    installer
+    exit 0
+fi
+
+command -v pct >/dev/null || die "Tohle patří na uzel Proxmoxu — pct tu není."
+[ "$(id -u)" -eq 0 ] || die "Spusť to jako root."
+
+# --- aktualizace -------------------------------------------------------------
+
+if [ "$MODE" = "update" ]; then
+    [ -n "${CTID:-}" ] || die "Řekni který: CTID=123 MODE=update ..."
+    pct status "$CTID" >/dev/null 2>&1 || die "Kontejner $CTID neexistuje."
+
+    header
+    if [ "$(pct status "$CTID")" != "status: running" ]; then
+        msg "Startuji kontejner"
+        pct start "$CTID"
+        sleep 5
+    fi
+
+    install_into "$CTID"
+    hotovo "$CTID"
+    exit 0
+fi
+
+# --- nový kontejner ----------------------------------------------------------
+
+header
+
+# Úložiště se nehádá. local-lvm na ZFS instalacích neexistuje a pct create by
+# spadlo až po půlce práce, tak se radši zeptáme systému, co tu opravdu je.
+if [ -z "$STORAGE" ]; then
+    STORAGE=$(pvesm status -content rootdir 2>/dev/null \
+        | awk 'NR>1 && $3=="active" {print $1; exit}')
+    [ -n "$STORAGE" ] || die "Nenašel jsem úložiště pro kontejnery. Zadej STORAGE=<jméno>; co máš, ukáže pvesm status."
+    msg "Úložiště: $STORAGE (nalezeno automaticky)"
+else
+    pvesm status -content rootdir 2>/dev/null | awk 'NR>1 {print $1}' | grep -qx "$STORAGE" \
+        || die "Úložiště $STORAGE pro kontejnery nesedí. Co máš, ukáže: pvesm status -content rootdir"
+    msg "Úložiště: $STORAGE"
+fi
+
+CTID="${CTID:-$(pvesh get /cluster/nextid)}"
+msg "Kontejner dostane číslo $CTID"
+
+# Architektura uzlu, ne první šablona v seznamu. pveam nabízí amd64 i arm64
+# vedle sebe a bez tohohle filtru by výběr padl na tu abecedně poslední.
+ARCH=$(dpkg --print-architecture)
+SABLONA="debian-${OSVERSION}-standard[^[:space:]]*_${ARCH}\.tar\.[a-z]*"
+
+msg "Hledám šablonu Debianu $OSVERSION pro $ARCH"
+
+# Nejdřív co už na uzlu leží — stahovat 120 MB znovu je zbytečné.
+TEMPLATE=$(pveam list "$TEMPLATE_STORAGE" 2>/dev/null | grep -o "$SABLONA" | sort -V | tail -1)
+
+if [ -n "$TEMPLATE" ]; then
+    ok "Šablona $TEMPLATE (už je na uzlu)"
+else
+    pveam update >/dev/null 2>&1 || true
+    TEMPLATE=$(pveam available --section system 2>/dev/null | grep -o "$SABLONA" | sort -V | tail -1)
+    [ -n "$TEMPLATE" ] || die "Šablona pro Debian $OSVERSION a $ARCH není k dispozici."
+
+    msg "Stahuji $TEMPLATE (asi 120 MB, chvíli to trvá)"
+    pveam download "$TEMPLATE_STORAGE" "$TEMPLATE" >/dev/null \
+        || die "Stažení šablony selhalo."
+    ok "Šablona $TEMPLATE"
+fi
+
+# Nesting: Debian 13 veze systemd 257 a ten v neprivilegovaném kontejneru bez
+# něj nedostane, co potřebuje — Proxmox na to při startu sám upozorňuje.
+# Stejnou výchozí hodnotu mají i community-scripts.
+msg "Zakládám kontejner"
+pct create "$CTID" "$TEMPLATE_STORAGE:vztmpl/$TEMPLATE" \
+    --hostname "$CT_HOSTNAME" \
+    --cores "$CORES" \
+    --memory "$MEMORY" \
+    --swap 256 \
+    --rootfs "$STORAGE:$DISK" \
+    --net0 "name=eth0,bridge=$BRIDGE,ip=dhcp" \
+    --unprivileged "$UNPRIVILEGED" \
+    --features "nesting=$NESTING" \
+    --ostype debian \
+    --onboot 1 \
+    --description "$APP — $GITEA/$REPO" >/dev/null
+ok "Kontejner $CTID založen"
+
+msg "Startuji"
+pct start "$CTID"
+
+msg "Čekám na síť"
+for _ in $(seq 60); do
+    if [ -n "$(address_of "$CTID")" ] \
+        && pct exec "$CTID" -- getent hosts deb.debian.org >/dev/null 2>&1; then
+        break
+    fi
+    sleep 2
+done
+[ -n "$(address_of "$CTID")" ] || die "Kontejner nedostal adresu. Sedí bridge $BRIDGE?"
+ok "Adresa $(address_of "$CTID")"
+
+install_into "$CTID"
+hotovo "$CTID"

dice-counter.spec

@@ -5,12 +5,19 @@ Staví se přes `./build.sh`, ne ručně — ta se stará o to, aby výsledek je
 i na starších systémech, než je ten tvůj.
 """
 
+import os
 import sys
 
+# Verzi zapisuje build.sh těsně před stavbou. Když se pyinstaller pustí
+# ručně bez ní, binárka se postaví taky — jen se pak hlásí jako neznámá.
+datas = [("templates", "templates"), ("static", "static")]
+if os.path.exists("verze.txt"):
+    datas.append(("verze.txt", "."))
+
 analysis = Analysis(
     ["web.py"],
     pathex=["."],
-    datas=[("templates", "templates"), ("static", "static")],
+    datas=datas,
     noarchive=False,
 )
 
@@ -21,7 +28,7 @@ exe = EXE(
     analysis.scripts,
     analysis.binaries,
     analysis.datas,
-    name="kostky",
+    name="dice-counter",
     console=True,
     # Ořezání symbolů šetří pár megabajtů, ale jen na Linuxu. Na macOS by
     # rozbilo podpis, který si PyInstaller sám přidává a bez kterého se

dice.py

@@ -1,6 +1,6 @@
 # /// script
 # requires-python = ">=3.11"
-# dependencies = ["tabulate"]
+# dependencies = ["tabulate==0.10.0"]
 # ///
 """Počitadlo skóre v terminálu.
 
@@ -8,11 +8,13 @@ Pravidla žijí v `core.Game`, tenhle modul je jen vstup a výstup. Hraje se
 v paměti, nic se neukládá — na historii je webová aplikace (`web.py`).
 """
 
+import sys
 from os import name, system
 
 from tabulate import tabulate
 
 import console
+import version
 from core import FINAL_SCORE, Game
 
 table_header = ["Hráč", "Skóre"]
@@ -130,4 +132,9 @@ def main() -> None:
 
 if __name__ == "__main__":
     console.utf8()
+
+    if {"--version", "-V"} & set(sys.argv[1:]):
+        print(f"dice-counter {version.current()}")
+        sys.exit(0)
+
     main()

requirements-build.in

@@ -0,0 +1,4 @@
+# Co je potřeba ke stavbě binárky. Zamyká se do requirements-build.txt:
+#     uv pip compile requirements-build.in -o requirements-build.txt
+-r requirements.in
+pyinstaller

requirements-build.txt

@@ -0,0 +1,37 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements-build.in -o requirements-build.txt --python-version 3.11
+altgraph==0.17.5
+    # via pyinstaller
+blinker==1.9.0
+    # via flask
+click==8.4.2
+    # via flask
+flask==3.1.3
+    # via -r requirements.in
+itsdangerous==2.2.0
+    # via flask
+jinja2==3.1.6
+    # via flask
+markupsafe==3.0.3
+    # via
+    #   flask
+    #   jinja2
+    #   werkzeug
+packaging==26.3
+    # via
+    #   pyinstaller
+    #   pyinstaller-hooks-contrib
+pyinstaller==6.22.2
+    # via -r requirements-build.in
+pyinstaller-hooks-contrib==2026.6
+    # via pyinstaller
+qrcode==8.2
+    # via -r requirements.in
+setuptools==84.0.0
+    # via pyinstaller
+tabulate==0.10.0
+    # via -r requirements.in
+waitress==3.0.2
+    # via -r requirements.in
+werkzeug==3.1.8
+    # via flask

requirements-dev.in

@@ -0,0 +1,4 @@
+# Co je potřeba k vývoji a testům. Zamyká se do requirements-dev.txt:
+#     uv pip compile requirements-dev.in -o requirements-dev.txt
+-r requirements.in
+pytest

requirements-dev.txt

@@ -0,0 +1,35 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements-dev.in -o requirements-dev.txt --python-version 3.11
+blinker==1.9.0
+    # via flask
+click==8.4.2
+    # via flask
+flask==3.1.3
+    # via -r requirements.in
+iniconfig==2.3.0
+    # via pytest
+itsdangerous==2.2.0
+    # via flask
+jinja2==3.1.6
+    # via flask
+markupsafe==3.0.3
+    # via
+    #   flask
+    #   jinja2
+    #   werkzeug
+packaging==26.3
+    # via pytest
+pluggy==1.6.0
+    # via pytest
+pygments==2.21.0
+    # via pytest
+pytest==9.1.1
+    # via -r requirements-dev.in
+qrcode==8.2
+    # via -r requirements.in
+tabulate==0.10.0
+    # via -r requirements.in
+waitress==3.0.2
+    # via -r requirements.in
+werkzeug==3.1.8
+    # via flask

requirements.in

@@ -0,0 +1,6 @@
+# Běhové závislosti. Verze se zamykají do requirements.txt přes:
+#     uv pip compile requirements.in -o requirements.txt
+flask
+qrcode
+tabulate
+waitress

requirements.txt

@@ -1,4 +1,25 @@
-flask
-qrcode
-tabulate
-pytest
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in -o requirements.txt --python-version 3.11
+blinker==1.9.0
+    # via flask
+click==8.4.2
+    # via flask
+flask==3.1.3
+    # via -r requirements.in
+itsdangerous==2.2.0
+    # via flask
+jinja2==3.1.6
+    # via flask
+markupsafe==3.0.3
+    # via
+    #   flask
+    #   jinja2
+    #   werkzeug
+qrcode==8.2
+    # via -r requirements.in
+tabulate==0.10.0
+    # via -r requirements.in
+waitress==3.0.2
+    # via -r requirements.in
+werkzeug==3.1.8
+    # via flask

static/style.css

@@ -513,3 +513,11 @@ button {
   font-size: 0.85em;
   color: var(--ink);
 }
+
+/* Verze v patičce. Má být k nalezení, když ji někdo hledá, a jinak neplést. */
+.verze {
+  margin: 2rem 0 0.75rem;
+  text-align: center;
+  font-size: 0.75rem;
+  opacity: 0.35;
+}

storage.py

@@ -39,7 +39,7 @@ def default_db() -> Path:
     if chosen:
         return Path(chosen)
     if getattr(sys, "frozen", False):
-        return data_home() / "kostky" / "dice.db"
+        return data_home() / "dice-counter" / "dice.db"
     return Path("dice.db")
 
 
@@ -86,6 +86,45 @@ CREATE TABLE IF NOT EXISTS turns (
 CREATE INDEX IF NOT EXISTS turns_game ON turns(game_id, id);
 """
 
+# Každý krok posouvá schéma o jedno dál; krok na indexu 0 vede z verze 1 na 2.
+# Přidávat jen na konec a nikdy nesahat na ten, který už někomu proběhl —
+# databáze leží lidem na discích a zpátky se nedají stáhnout.
+MIGRATIONS: list[str] = []
+
+SCHEMA_VERSION = 1 + len(MIGRATIONS)
+
+
+def migrate(conn: sqlite3.Connection) -> int:
+    """Dorovná databázi na aktuální schéma a vrátí její verzi.
+
+    Verze se drží v `PRAGMA user_version`, což je celé číslo, které si SQLite
+    veze v hlavičce souboru a jinak si ho nevšímá.
+
+    Nula znamená dvojí: buď je soubor prázdný, nebo pochází z doby, kdy se
+    verze ještě nezapisovala. Obojí se vyřeší stejně — `SCHEMA` je samé
+    `IF NOT EXISTS`, takže na hotové databázi neudělá nic a jen se orazítkuje.
+    """
+    version = conn.execute("PRAGMA user_version").fetchone()[0]
+
+    if version > SCHEMA_VERSION:
+        raise RuntimeError(
+            f"Databáze je ve verzi {version}, tahle aplikace umí "
+            f"{SCHEMA_VERSION}. Nejspíš ji založila novější verze počitadla; "
+            f"aktualizuj, ať o data nepřijdeš.")
+
+    if version == 0:
+        conn.executescript(SCHEMA)
+        version = 1
+
+    for step in MIGRATIONS[version - 1:]:
+        conn.executescript(step)
+        version += 1
+
+    # PRAGMA neumí zástupné otazníky. Číslo sem teče z kódu, ne od uživatele.
+    conn.execute(f"PRAGMA user_version = {version}")
+    conn.commit()
+    return version
+
 
 def connect(path: Path | str | None = None) -> sqlite3.Connection:
     target = Path(path or DB_PATH)
@@ -93,7 +132,7 @@ def connect(path: Path | str | None = None) -> sqlite3.Connection:
     conn = sqlite3.connect(target)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA foreign_keys = ON")
-    conn.executescript(SCHEMA)
+    migrate(conn)
     return conn
 
 

templates/base.html

@@ -8,5 +8,6 @@
 </head>
 <body>
 {% block body %}{% endblock %}
+<footer class="verze">dice-counter {{ verze }}</footer>
 </body>
 </html>

templates/stats.html

@@ -8,7 +8,8 @@
       <p class="eyebrow">Počitadlo</p>
       <h1>Síň slávy</h1>
     </div>
-    <p class="meta"><a href="{{ url_for('index') }}">Nová hra</a></p>
+    <p class="meta"><a href="{{ url_for('index') }}">Nová hra</a>
+      · <a href="{{ url_for('export') }}">Stáhnout databázi</a></p>
   </header>
 
   {% if records.best_turn %}

tests/test_console.py

@@ -9,10 +9,12 @@ class Proud:
     def __init__(self):
         self.encoding = "cp1252"
         self.errors = "strict"
+        self.line_buffering = False
 
-    def reconfigure(self, encoding, errors):
+    def reconfigure(self, encoding, errors, line_buffering=False):
         self.encoding = encoding
         self.errors = errors
+        self.line_buffering = line_buffering
 
 
 def test_vystup_se_prepne_na_utf8(monkeypatch):
@@ -24,6 +26,7 @@ def test_vystup_se_prepne_na_utf8(monkeypatch):
 
     assert (out.encoding, out.errors) == ("utf-8", "replace")
     assert (err.encoding, err.errors) == ("utf-8", "replace")
+    assert out.line_buffering and err.line_buffering
 
 
 def test_cestina_projde_i_pres_cp1252(monkeypatch):
@@ -46,3 +49,17 @@ def test_proud_bez_reconfigure_se_prezije(monkeypatch):
     monkeypatch.setattr(console.sys, "stderr", object())
 
     console.utf8()
+
+
+def test_hlaska_je_v_souboru_hned(tmp_path, monkeypatch):
+    """Server běží dál, takže na vyprázdnění bufferu při konci se čekat nedá."""
+    cesta = tmp_path / "server.log"
+    with cesta.open("w", encoding="utf-8") as soubor:
+        monkeypatch.setattr(console.sys, "stdout", soubor)
+        monkeypatch.setattr(console.sys, "stderr", soubor)
+
+        console.utf8()
+        print("Počitadlo je dostupné na:", file=console.sys.stdout)
+
+        # Bez zavření souboru — přesně jako u běžícího serveru.
+        assert "Počitadlo je dostupné" in cesta.read_text(encoding="utf-8")

tests/test_storage.py

@@ -1,3 +1,4 @@
+import sqlite3
 from pathlib import Path
 
 import pytest
@@ -151,7 +152,7 @@ def test_umisteni_databaze_z_binarky(monkeypatch, tmp_path):
     monkeypatch.setattr(storage.sys, "platform", "linux")
     monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
 
-    assert storage.default_db() == tmp_path / "kostky" / "dice.db"
+    assert storage.default_db() == tmp_path / "dice-counter" / "dice.db"
 
 
 def test_data_home_podle_systemu(monkeypatch, tmp_path):
@@ -182,3 +183,69 @@ def test_connect_zalozi_chybejici_adresar(tmp_path):
     conn.close()
 
     assert (tmp_path / "novy" / "adresar" / "dice.db").exists()
+
+
+# --- verze schématu ---------------------------------------------------------
+
+def verze(conn) -> int:
+    return conn.execute("PRAGMA user_version").fetchone()[0]
+
+
+def test_nova_databaze_je_orazitkovana(tmp_path):
+    conn = storage.connect(tmp_path / "nova.db")
+    try:
+        assert verze(conn) == storage.SCHEMA_VERSION
+    finally:
+        conn.close()
+
+
+def test_databaze_z_doby_pred_verzovanim_prezije(tmp_path):
+    """Přesně to, co lidem leží na disku z verzí 1.0 a 1.1.
+
+    Tabulky má, razítko ne. Nesmí se ani přijít o data, ani spadnout.
+    """
+    path = tmp_path / "stara.db"
+    stara = sqlite3.connect(path)
+    stara.executescript(storage.SCHEMA)      # bez PRAGMA user_version
+    stara.execute("INSERT INTO players (name, key, created_at) "
+                  "VALUES ('Adam', 'adam', '2026-01-01T00:00:00')")
+    stara.commit()
+    stara.close()
+
+    conn = storage.connect(path)
+    try:
+        assert verze(conn) == storage.SCHEMA_VERSION
+        assert [p["name"] for p in storage.known_players(conn)] == ["Adam"]
+    finally:
+        conn.close()
+
+
+def test_migrace_dojede_jen_ty_chybejici(tmp_path, monkeypatch):
+    """Podruhé už krok proběhnout nesmí — jinak by ALTER TABLE spadl."""
+    monkeypatch.setattr(storage, "MIGRATIONS",
+                        ["ALTER TABLE players ADD COLUMN barva TEXT;"])
+    monkeypatch.setattr(storage, "SCHEMA_VERSION", 2)
+
+    path = tmp_path / "migrovana.db"
+    conn = storage.connect(path)
+    conn.close()
+
+    conn = storage.connect(path)             # druhé spuštění téže verze
+    try:
+        assert verze(conn) == 2
+        sloupce = [r[1] for r in conn.execute("PRAGMA table_info(players)")]
+        assert "barva" in sloupce
+    finally:
+        conn.close()
+
+
+def test_databaze_z_novejsi_verze_se_odmitne(tmp_path):
+    """Radši srozumitelná hláška než tiše rozbitá data."""
+    path = tmp_path / "budouci.db"
+    conn = storage.connect(path)
+    conn.execute(f"PRAGMA user_version = {storage.SCHEMA_VERSION + 1}")
+    conn.commit()
+    conn.close()
+
+    with pytest.raises(RuntimeError, match="novější verze"):
+        storage.connect(path)

tests/test_version.py

@@ -0,0 +1,48 @@
+"""Verze se musí poznat i z binárky, kde žádný git není."""
+
+import pytest
+
+import version
+
+
+@pytest.fixture(autouse=True)
+def bez_pameti():
+    """`current()` si výsledek pamatuje; mezi testy je potřeba čistý stůl."""
+    version.current.cache_clear()
+    yield
+    version.current.cache_clear()
+
+
+def test_z_binarky_se_cte_pribaleny_soubor(monkeypatch, tmp_path):
+    """V binárce leží verze.txt v dočasném adresáři vedle šablon."""
+    (tmp_path / version.NAME).write_text("v9.9.9\n", encoding="utf-8")
+    monkeypatch.setattr(version.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(version.sys, "_MEIPASS", str(tmp_path), raising=False)
+
+    assert version.current() == "v9.9.9"
+
+
+def test_binarka_se_gitu_nepta(monkeypatch, tmp_path):
+    """Na cizím počítači žádný repozitář není a ptát se nemá koho."""
+    monkeypatch.setattr(version.sys, "frozen", True, raising=False)
+    monkeypatch.setattr(version.sys, "_MEIPASS", str(tmp_path), raising=False)
+    monkeypatch.setattr(version, "described",
+                        lambda: pytest.fail("binárka se ptala gitu"))
+
+    assert version.current() == version.UNKNOWN
+
+
+def test_ze_zdrojaku_ma_prednost_git(monkeypatch):
+    monkeypatch.delattr(version.sys, "frozen", raising=False)
+    monkeypatch.setattr(version, "described", lambda: "v1.2.3-4-gabcdef")
+    monkeypatch.setattr(version, "bundled", lambda: "v1.0.0")
+
+    assert version.current() == "v1.2.3-4-gabcdef"
+
+
+def test_bez_gitu_a_bez_souboru_zbyde_neznama(monkeypatch):
+    monkeypatch.delattr(version.sys, "frozen", raising=False)
+    monkeypatch.setattr(version, "described", lambda: "")
+    monkeypatch.setattr(version, "bundled", lambda: "")
+
+    assert version.current() == version.UNKNOWN

tests/test_web.py

@@ -326,3 +326,36 @@ def test_qr_obdelniky_kryji_stejne_moduly():
 
     assert painted == expected
     assert svg.count("<rect") < len(expected)
+
+
+# --- záloha -----------------------------------------------------------------
+
+def test_export_vrati_pouzitelnou_databazi(client, tmp_path):
+    """Ze staženého souboru musí jít data přečíst zpátky, ne jen že se stáhne."""
+    game_id = start_game(client, "Adam", "Eva")
+    score(client, game_id, 150)
+
+    response = client.get("/export")
+
+    assert response.status_code == 200
+    assert "attachment" in response.headers["Content-Disposition"]
+    assert response.headers["Content-Disposition"].endswith(".db")
+
+    stazeny = tmp_path / "stazeny.db"
+    stazeny.write_bytes(response.data)
+
+    conn = storage.connect(stazeny)
+    try:
+        assert [p["name"] for p in storage.seating(conn, game_id)] == ["Adam", "Eva"]
+        assert storage.load_game(conn, game_id).totals()["Adam"] == 150
+    finally:
+        conn.close()
+
+
+def test_export_zabere_i_rozehranou_hru(client):
+    """Kopie se dělá za běhu, uprostřed nedohrané hry."""
+    game_id = start_game(client, "Adam")
+    score(client, game_id, 100)
+
+    assert client.get("/export").status_code == 200
+    assert text(client.get("/stats")).count("Stáhnout databázi") == 1

tests/test_zavislosti.py

@@ -0,0 +1,60 @@
+"""Závislosti jsou zamčené a všechna místa se shodnou.
+
+Verze se píšou na dvou místech: v `requirements.txt` pro stavbu binárky
+a v hlavičce PEP 723 pro `uv run web.py`. Ta dvě místa se dřív nebo později
+rozejdou — leda že by to někdo hlídal. Proto tenhle soubor.
+"""
+
+import re
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).parent.parent
+
+# Skript a to, co si podle hlavičky nese s sebou.
+SCRIPTS = {"web.py": {"flask", "qrcode", "waitress"},
+           "dice.py": {"tabulate"}}
+
+
+def pins(name: str) -> dict[str, str]:
+    """Zamčené verze z compilovaného requirements souboru."""
+    text = (ROOT / name).read_text(encoding="utf-8")
+    return {m.group(1).lower(): m.group(2)
+            for m in re.finditer(r"^([A-Za-z0-9_.\-]+)==(\S+)", text, re.M)}
+
+
+def header(script: str) -> dict[str, str]:
+    """Závislosti z hlavičky PEP 723 na začátku skriptu."""
+    text = (ROOT / script).read_text(encoding="utf-8")
+    line = re.search(r"^# dependencies = \[(.*)\]$", text, re.M)
+    assert line, f"{script} nemá hlavičku PEP 723"
+
+    return {m.group(1).lower(): m.group(2)
+            for m in re.finditer(r'"([A-Za-z0-9_.\-]+)==(\S+?)"', line.group(1))}
+
+
+@pytest.mark.parametrize("name", ["requirements.txt", "requirements-dev.txt",
+                                  "requirements-build.txt"])
+def test_zavislosti_jsou_zamcene(name):
+    """Bez zamčených verzí se binárka z března liší od binárky z dubna."""
+    lines = [line.strip() for line in (ROOT / name).read_text().splitlines()]
+    volne = [line for line in lines
+             if line and not line.startswith("#") and "==" not in line]
+
+    assert not volne, f"{name} má nezamčené závislosti: {volne}"
+
+
+@pytest.mark.parametrize("script", sorted(SCRIPTS))
+def test_hlavicka_sedi_s_requirements(script):
+    """`uv run web.py` musí dostat totéž, co se zabalí do binárky."""
+    zamcene = pins("requirements.txt")
+    v_hlavicce = header(script)
+
+    assert set(v_hlavicce) == SCRIPTS[script]
+
+    for balicek, verze in v_hlavicce.items():
+        assert balicek in zamcene, f"{balicek} chybí v requirements.txt"
+        assert verze == zamcene[balicek], (
+            f"{script}: {balicek}=={verze}, ale zamčeno je "
+            f"{zamcene[balicek]} — přepiš hlavičku")

version.py

@@ -0,0 +1,49 @@
+"""Která verze počitadla to vlastně je.
+
+Venku jsou čtyři binárky pro tři systémy a k tomu zdrojáky. Když někdo
+napíše, že mu něco nefunguje, je první otázka vždycky stejná — a bez
+`--version` na ni nemá jak odpovědět.
+"""
+
+import subprocess
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+NAME = "verze.txt"
+UNKNOWN = "neznámá"
+
+
+def bundled() -> str:
+    """Verze vypálená do binárky při stavbě.
+
+    `build.sh` ji zapíše do souboru, `dice-counter.spec` ji přibalí. V binárce
+    leží vedle šablon v dočasném adresáři, na který ukazuje `sys._MEIPASS`.
+    """
+    root = Path(getattr(sys, "_MEIPASS", Path(__file__).parent))
+    try:
+        return (root / NAME).read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def described() -> str:
+    """Verze podle gitu. Ze zdrojáků je to přesnější než cokoli zapsaného."""
+    try:
+        done = subprocess.run(
+            ["git", "describe", "--tags", "--always", "--dirty"],
+            cwd=Path(__file__).parent, capture_output=True, text=True,
+            timeout=5, check=True)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+    return done.stdout.strip()
+
+
+@lru_cache(maxsize=1)
+def current() -> str:
+    """Verze pro výpis. Ptát se gitu má smysl jen mimo binárku."""
+    if getattr(sys, "frozen", False):
+        return bundled() or UNKNOWN
+
+    return described() or bundled() or UNKNOWN

web.py

@@ -1,6 +1,6 @@
 # /// script
 # requires-python = ">=3.11"
-# dependencies = ["flask", "qrcode"]
+# dependencies = ["flask==3.1.3", "qrcode==8.2", "waitress==3.0.2"]
 # ///
 """Webové počitadlo pro domácí síť.
 
@@ -8,20 +8,26 @@ Telefon zapisuje skóre (`/game/<id>`), notebook ukazuje zápisník (`/board`).
 Server-rendered HTML, formuláře přes POST/redirect/GET, žádný build step.
 """
 
+import io
 import os
+import shutil
 import socket
 import sys
+import tempfile
+from datetime import date
 from pathlib import Path
 
 import qrcode
 from flask import (Flask, abort, g, redirect, render_template, request,
-                   url_for)
+                   send_file, url_for)
 from markupsafe import Markup, escape
+from waitress import serve
 
 import console
 import net
 import stats
 import storage
+import version
 from core import FINAL_SCORE, Game, GameOver
 
 def bundled(folder: str) -> str:
@@ -125,6 +131,12 @@ def qr_svg(data: str) -> Markup:
     )
 
 
+@app.context_processor
+def verze():
+    """Verze do patičky. Když někdo hlásí chybu, tohle je první otázka."""
+    return {"verze": version.current()}
+
+
 @app.template_filter("datum")
 def datum(value: str) -> str:
     """Z ISO textu udělá 12. 8. 2026."""
@@ -311,6 +323,36 @@ def board_panel(game_id: int):
     return render_template("_panel.html", **view(game, game_id, row))
 
 
+@app.route("/export")
+def export():
+    """Databáze ke stažení.
+
+    Dokud se hrálo ze zdrojáků, ležel `dice.db` v pracovním adresáři a záloha
+    byla otázka zkopírování. Z binárky se schovává do systémového datového
+    adresáře, který na Windows běžný člověk nenajde — tak ať se dá stáhnout
+    přes prohlížeč.
+
+    `VACUUM INTO` udělá konzistentní kopii i uprostřed zápisu, na rozdíl od
+    prostého přečtení souboru. Výsledek si přečteme do paměti a kopii hned
+    zahodíme: databáze počitadla se počítá v kilobajtech a takhle nezůstane
+    ležet v dočasném adresáři, když si ji někdo nestáhne celou.
+    """
+    conn = db()
+    conn.commit()                       # VACUUM nesmí běžet v transakci
+
+    docasny = tempfile.mkdtemp()
+    try:
+        kopie = Path(docasny) / "dice.db"
+        conn.execute("VACUUM INTO ?", (str(kopie),))
+        data = kopie.read_bytes()
+    finally:
+        shutil.rmtree(docasny, ignore_errors=True)
+
+    return send_file(io.BytesIO(data), mimetype="application/vnd.sqlite3",
+                     as_attachment=True,
+                     download_name=f"dice-counter-{date.today().isoformat()}.db")
+
+
 @app.route("/stats")
 def hall():
     conn = db()
@@ -320,8 +362,9 @@ def hall():
                            games=storage.recent_games(conn))
 
 
-if __name__ == "__main__":
-    console.utf8()
+def announce() -> None:
+    """Vypíše, kde všude je počitadlo k mání, a čím je zrovna spuštěné."""
+    print(f"dice-counter {version.current()}\n")
 
     found = net.addresses()
 
@@ -336,4 +379,18 @@ if __name__ == "__main__":
 
     print(f"\nDatabáze: {storage.DB_PATH.resolve()}")
 
-    app.run(host="0.0.0.0", port=PORT, threaded=True)
+
+if __name__ == "__main__":
+    console.utf8()
+
+    if {"--version", "-V"} & set(sys.argv[1:]):
+        print(f"dice-counter {version.current()}")
+        sys.exit(0)
+
+    announce()
+
+    # Ne vestavěný server Flasku: ten pod úvodní hlášku vysype červené
+    # varování, že takhle se to nemá, a má pravdu. Waitress je čistě
+    # pythonní, takže se zabalí do binárky bez řečí, a osm vláken pobere
+    # telefony u stolu i tabuli, která se doptává každé dvě vteřiny.
+    serve(app, host="0.0.0.0", port=PORT, threads=8)