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

Reviewed-on: #20

.gitea/workflows/binarka.yml

@@ -66,10 +66,15 @@ jobs:
 
       - 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
@@ -79,15 +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
-          ./dist/kostky --version
+          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}"
@@ -104,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

.github/workflows/binarky.yml

@@ -31,17 +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: kostky-linux-arm64
-            built: dist/kostky
+            asset: dice-counter-linux-arm64
+            built: dist/dice-counter
 
     runs-on: ${{ matrix.os }}
     defaults:
@@ -124,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"

README.md

@@ -13,19 +13,19 @@ Stáhni binárku pro svůj systém z
 
 | Systém | Soubor |
 |---|---|
-| Linux (x86-64) | `kostky-linux-x86_64` |
-| Linux (ARM64) | `kostky-linux-arm64` |
-| 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.
@@ -38,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* →
@@ -60,7 +60,7 @@ 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ý:
 
 ```
-Kostky v1.1.0
+dice-counter v1.2.2
 
 Počitadlo je dostupné na:
  → http://10.186.234.182:8000     místní síť
@@ -68,7 +68,7 @@ Počitadlo je dostupné na:
    http://172.17.0.1:8000         virtuální síť
 ```
 
-Kterou verzi máš, řekne i `kostky --version`; visí taky v patičce každé
+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
@@ -88,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
@@ -129,7 +129,7 @@ nastaví ho, stáhne poslední vydanou binárku, ověří kontrolní součet a z
 službu:
 
 ```bash
-bash -c "$(curl -fsSL https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/pve-kostky.sh)"
+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
@@ -143,21 +143,39 @@ MEMORY=1024 STORAGE=local-zfs PORT=8080 bash -c "$(curl -fsSL ...)"
 | Proměnná | Výchozí |
 |---|---|
 | `CTID` | první volné číslo |
-| `CT_HOSTNAME` | `kostky` |
+| `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í je ten samý příkaz s číslem kontejneru:
+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.
@@ -167,20 +185,35 @@ přes rouru z curlu na disku hostitele žádný druhý soubor není. O Proxmoxu
 neví, takže se dá použít i v kontejneru, který sis založil sám:
 
 ```bash
-bash pve-kostky.sh instalator > install.sh
+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
-cd deploy && docker compose up -d
+curl -fsSLO https://gitea.spacilovi.eu/david-spacil/dice-counter/raw/branch/main/deploy/docker-compose.yaml
+docker compose up -d
 ```
 
-Staví se ze zdrojáků, takže image jde sestavit pro amd64 i arm64 a nezávisí
-na tom, jestli release pro danou architekturu proběhl. Databáze leží
-v pojmenovaném svazku, appka běží pod nerootovým uživatelem.
+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ě
@@ -189,9 +222,9 @@ Kdo bridge potřebuje, musí nastavit `DICE_HOST` na adresu hostitele v LAN.
 
 | | LXC | Docker |
 |---|---|---|
-| Odkud | vydaná binárka z releasu | zdrojáky |
-| Databáze | `/var/lib/kostky/dice.db` | svazek `kostky-data` |
-| Aktualizace | `pve-kostky.sh update <ctid>` | `docker compose build --pull` |
+| 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í
@@ -229,8 +262,8 @@ při remíze na prvním místě se hraje dál.
 | `dice.py` | totéž v terminálu, bez ukládání |
 | `console.py` | aby čeština prošla i windowsovou konzolí |
 | `version.py` | která verze to je — z gitu, nebo z binárky |
-| `build.sh`, `kostky.spec` | stavba binárky |
-| `.gitea/workflows/` | testy a linuxová binárka doma |
+| `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 |
 
@@ -288,7 +321,7 @@ srovnat.
 ```
 
 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`, `kostky.spec` ji
+`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`.
 
@@ -313,6 +346,7 @@ Otagovaný commit spustí stavbu na obou stranách:
 |---|---|---|
 | 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
@@ -332,10 +366,17 @@ ji kamkoli pověsí. Vedle každé visí i `.sha256`, takže se stažený soubor
 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
 

build.sh

@@ -38,7 +38,7 @@ fi
 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/

deploy/Dockerfile

@@ -5,7 +5,7 @@
 # proběhl. Závislosti jsou zamčené v requirements.txt, takže je sestavení
 # opakovatelné.
 #
-#     docker build -f deploy/Dockerfile -t kostky .
+#     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
@@ -13,7 +13,16 @@ FROM python:3.11-slim
 # Verze se jinak nemá kde vzít — v image není git ani zabalená binárka.
 ARG VERSION=neznámá
 
-RUN useradd --system --uid 1000 --home-dir /app --shell /usr/sbin/nologin kostky
+# 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
 
@@ -29,15 +38,15 @@ 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
-# kostky by do něj nezapsala.
-RUN install -d -o kostky -g kostky /data
+# 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 kostky
+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.

deploy/docker-compose.yaml

@@ -1,19 +1,20 @@
 # Počitadlo kostek v Dockeru.
 #
-#     cd deploy && docker compose up -d
+#     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:
-  kostky:
-    build:
-      context: ..
-      dockerfile: deploy/Dockerfile
-      args:
-        VERSION: ${VERSION:-vlastní sestavení}
-    image: kostky:latest
-    container_name: kostky
+  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.
@@ -38,8 +39,8 @@ services:
       DICE_DB: /data/dice.db
 
     volumes:
-      - kostky-data:/data
+      - dice-counter-data:/data
 
 volumes:
   # Zálohu si stáhneš rovnou z appky přes /export, takže se sem nemusí lézt.
-  kostky-data:
+  dice-counter-data:

deploy/pve-dice-counter.sh

@@ -3,14 +3,14 @@
 #
 # 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-kostky.sh)"
+#   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-kostky.sh)"
+#   CTID=123 MODE=update bash -c "$(curl -fsSL .../pve-dice-counter.sh)"
 #
-# Ze staženého souboru jde i obojí postaru: `bash pve-kostky.sh` a
-# `bash pve-kostky.sh update 123`.
+# 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
@@ -20,13 +20,13 @@
 # nezabezpečuje; do internetu ji nepouštěj.
 set -euo pipefail
 
-APP="Kostky"
+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:-kostky}"
+CT_HOSTNAME="${CT_HOSTNAME:-dice-counter}"
 CORES="${CORES:-1}"
 MEMORY="${MEMORY:-512}"
 DISK="${DISK:-4}"
@@ -37,6 +37,7 @@ 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 ------------------------------------------------------------------
@@ -63,7 +64,7 @@ header() {
 # '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-kostky.sh instalator > install.sh`,
+# 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'
@@ -78,17 +79,18 @@ REPO="${REPO:-david-spacil/dice-counter}"
 PORT="${PORT:-8000}"
 VERSION="${VERSION:-}"
 
-USER_NAME=kostky
-HOME_DIR=/opt/kostky
-DATA_DIR=/var/lib/kostky
+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=kostky-linux-x86_64 ;;
-    arm64) ASSET=kostky-linux-arm64 ;;
+    amd64) ASSET=dice-counter-linux-x86_64 ;;
+    arm64) ASSET=dice-counter-linux-arm64 ;;
     *)     die "Pro architekturu $(dpkg --print-architecture) binárka není." ;;
 esac
 
@@ -128,16 +130,16 @@ id -u "$USER_NAME" >/dev/null 2>&1 \
 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 kostky; then
-    systemctl stop kostky
+if systemctl is-active --quiet "$SERVICE"; then
+    systemctl stop "$SERVICE"
 fi
 
-install -o root -g root -m 755 "$TMP/$ASSET" "$HOME_DIR/kostky"
+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/kostky.service <<EOF
+cat > "/etc/systemd/system/$SERVICE.service" <<EOF
 [Unit]
 Description=Počitadlo kostek
 Documentation=$GITEA/$REPO
@@ -149,13 +151,13 @@ Type=simple
 User=$USER_NAME
 Environment=DICE_DB=$DATA_DIR/dice.db
 Environment=DICE_PORT=$PORT
-ExecStart=$HOME_DIR/kostky
+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=kostky
+StateDirectory=dice-counter
 ReadWritePaths=$DATA_DIR
 
 NoNewPrivileges=true
@@ -170,16 +172,68 @@ WantedBy=multi-user.target
 EOF
 
 systemctl daemon-reload
-systemctl enable --quiet --now kostky
+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 kostky."
+    || 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.
@@ -195,11 +249,11 @@ install_into() {
     installer > "$tmp"
 
     msg "Posílám instalátor do kontejneru $ctid"
-    pct push "$ctid" "$tmp" /root/kostky-install.sh --perms 0755
+    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" bash /root/kostky-install.sh
+        VERSION="$VERSION" AUTOLOGIN="$AUTOLOGIN" bash /root/dice-counter-install.sh
 }
 
 address_of() {
@@ -217,8 +271,9 @@ hotovo() {
     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/kostky/dice.db (uvnitř kontejneru)"
-    echo -e "  Log:       pct exec $ctid -- journalctl -u kostky -f"
+    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
@@ -227,7 +282,7 @@ hotovo() {
 # --- 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-kostky.sh update 123`.
+# MODE=update CTID=123. Ze souboru funguje i `bash pve-dice-counter.sh update 123`.
 MODE="${MODE:-${1:-create}}"
 [ "$MODE" = "update" ] && CTID="${CTID:-${2:-}}"
 

dice-counter.spec

@@ -28,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

@@ -134,7 +134,7 @@ if __name__ == "__main__":
     console.utf8()
 
     if {"--version", "-V"} & set(sys.argv[1:]):
-        print(f"kostky {version.current()}")
+        print(f"dice-counter {version.current()}")
         sys.exit(0)
 
     main()

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")
 
 

templates/base.html

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

tests/test_storage.py

@@ -152,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):

version.py

@@ -17,7 +17,7 @@ UNKNOWN = "neznámá"
 def bundled() -> str:
     """Verze vypálená do binárky při stavbě.
 
-    `build.sh` ji zapíše do souboru, `kostky.spec` ji přibalí. V binárce
+    `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))

web.py

@@ -350,7 +350,7 @@ def export():
 
     return send_file(io.BytesIO(data), mimetype="application/vnd.sqlite3",
                      as_attachment=True,
-                     download_name=f"kostky-{date.today().isoformat()}.db")
+                     download_name=f"dice-counter-{date.today().isoformat()}.db")
 
 
 @app.route("/stats")
@@ -364,7 +364,7 @@ def hall():
 
 def announce() -> None:
     """Vypíše, kde všude je počitadlo k mání, a čím je zrovna spuštěné."""
-    print(f"Kostky {version.current()}\n")
+    print(f"dice-counter {version.current()}\n")
 
     found = net.addresses()
 
@@ -384,7 +384,7 @@ if __name__ == "__main__":
     console.utf8()
 
     if {"--version", "-V"} & set(sys.argv[1:]):
-        print(f"kostky {version.current()}")
+        print(f"dice-counter {version.current()}")
         sys.exit(0)
 
     announce()