Pin compose example to v0.2.2

cmd/gpu-turnstile/main.go

@@ -39,6 +39,11 @@ var version = "dev"
 // process: a signed update has been staged and the GPU lock is idle.
 const exitCodeUpdate = 3
 
+// exitCodeStaged is returned by an elevated --force-update child when it
+// staged a new binary, so the non-elevated parent can tell "updated" from
+// "up to date" (it cannot see the child's console).
+const exitCodeStaged = 4
+
 // stdoutIsTerminal reports whether stdout is a console (char device), as
 // opposed to a pipe or file — which is what Docker containers and services
 // see.
@@ -348,11 +353,12 @@ func forceUpdateCommand(configPath string, elevatedChild bool) int {
 	// instead of hanging in a TCP connect for minutes.
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
-	staged, err := u.Check(ctx, exePath)
+	staged, to, err := u.Check(ctx, exePath)
 	if err != nil && isPermission(err) && !service.Elevated() {
 		code, _ := elevateAndMirror("--force-update")
-		if code == 0 {
-			fmt.Println("update applied (elevated)")
+		reportElevatedUpdate(code, to)
+		if code == 0 || code == exitCodeStaged {
+			return 0
 		}
 		return code
 	}
@@ -364,12 +370,13 @@ func forceUpdateCommand(configPath string, elevatedChild bool) int {
 		fmt.Printf("%s is up to date\n", versionLine())
 		return 0
 	}
-	fmt.Printf("%s: update staged\n", versionLine())
+	fmt.Printf("gpu-turnstile: updated from %s to %s\n", version, to)
 	restarted, err := service.RestartIfRunning()
 	if err != nil && isPermission(err) && !service.Elevated() {
 		code, _ := elevateAndMirror("--force-update")
-		if code == 0 {
-			fmt.Println("update applied (elevated)")
+		reportElevatedUpdate(code, to)
+		if code == 0 || code == exitCodeStaged {
+			return 0
 		}
 		return code
 	}
@@ -378,13 +385,35 @@ func forceUpdateCommand(configPath string, elevatedChild bool) int {
 		return 1
 	}
 	if restarted {
-		fmt.Println("service restarted on the new version")
+		fmt.Println("service restarted on " + to)
 	} else {
-		fmt.Println("no running service; the new version applies on next start")
+		fmt.Println("no running service; " + to + " applies on the next start")
+	}
+	if elevatedChild {
+		// Tell the non-elevated parent (which cannot see this console)
+		// whether anything was staged, so its mirror message is honest.
+		return exitCodeStaged
 	}
 	return 0
 }
 
+// reportElevatedUpdate prints the parent's summary of an elevated
+// --force-update child: exitCodeStaged means the child staged a new binary,
+// 0 means it found nothing to do. to is the tag the parent's own check
+// resolved before it hit the permission wall ("" when it never got that
+// far).
+func reportElevatedUpdate(code int, to string) {
+	switch {
+	case code == exitCodeStaged && to != "":
+		fmt.Printf("gpu-turnstile: updated from %s to %s (elevated)\n", version, to)
+	case code == exitCodeStaged:
+		fmt.Println("update applied (elevated)")
+	case code == 0:
+		fmt.Printf("%s is up to date\n", versionLine())
+	}
+	// Non-zero, non-staged codes: elevateAndMirror already printed the failure.
+}
+
 // serviceCommand installs (copyBin = register the canonical-layout copy)
 // or removes the service and reports the result. On Windows, when the
 // shell is not elevated, the command relaunches itself through a UAC
@@ -813,16 +842,16 @@ func updateLoop(ctx context.Context, cfg config.Config, log *slog.Logger, lk *lo
 	}
 	u := &update.Updater{Repo: cfg.UpdateRepo, Asset: cfg.UpdateAsset, Version: version, Desired: cfg.AppVersion, Log: log}
 	for {
-		staged, err := u.Check(ctx, exePath)
+		staged, to, err := u.Check(ctx, exePath)
 		if err != nil && ctx.Err() == nil {
 			log.Warn("auto-update check failed", "err", err)
 		}
 		if staged {
 			if !isService {
-				log.Warn("auto-update: new binary staged; restart gpu-turnstile to apply")
+				log.Warn("auto-update: new binary staged; restart gpu-turnstile to apply", "version", to)
 				return
 			}
-			log.Warn("auto-update: staged; restarting once the GPU is idle")
+			log.Warn("auto-update: staged; restarting once the GPU is idle", "version", to)
 			if waitForIdle(ctx, lk, 24*time.Hour) {
 				log.Warn("auto-update: restarting to apply update")
 				os.Exit(exitCodeUpdate)

compose.yaml.example

@@ -6,7 +6,7 @@
 # ComfyUI --listen 0.0.0.0 --port 8189).
 services:
   gpu-turnstile:
-    image: git.rambossek.at/public/gpu-turnstile:v0.2.0
+    image: git.rambossek.at/public/gpu-turnstile:v0.2.2
     restart: unless-stopped
     environment:
       # Each consumer is enabled by setting its URL; leave one unset to

internal/service/service_linux.go

@@ -15,6 +15,8 @@ import (
 	"os/signal"
 	"path/filepath"
 	"syscall"
+
+	"gpu-turnstile/internal/supervise"
 )
 
 // Name matches the Windows service name; the systemd unit is Name + ".service".
@@ -64,11 +66,20 @@ func Run(run func(ctx context.Context) error) error {
 // directives apply. The proxy needs nothing but outbound TCP/UDP and the
 // notify socket, so it loses nothing. A managed ComfyUI (comfyDir) gets a
 // BindPaths hole through ProtectHome/ProtectSystem: it reads its venv and
-// writes output/temp/user data under COMFY_DIR.
+// writes output/temp/user data under COMFY_DIR. A venv whose base
+// interpreter (pyvenv.cfg home) lives outside COMFY_DIR gets an additional
+// read-only bind, and a Comfy-Desktop shared data dir (models, input,
+// output) a read-write one.
 func renderUnit(exePath, configPath, comfyDir string) string {
 	bind := ""
 	if comfyDir != "" {
 		bind = "BindPaths=" + comfyDir + "\n"
+		if home := comfyVenvHome(comfyDir); home != "" {
+			bind += "BindReadOnlyPaths=" + home + "\n"
+		}
+		if shared := supervise.DesktopSharedDir(comfyDir); shared != "" {
+			bind += "BindPaths=" + shared + "\n"
+		}
 	}
 	return fmt.Sprintf(`[Unit]
 Description=gpu-turnstile GPU arbitration proxy for Ollama and ComfyUI

internal/service/service_windows.go

@@ -24,6 +24,8 @@ import (
 	"golang.org/x/sys/windows"
 	"golang.org/x/sys/windows/svc"
 	"golang.org/x/sys/windows/svc/mgr"
+
+	"gpu-turnstile/internal/supervise"
 )
 
 // Name is the Windows service name.
@@ -375,6 +377,20 @@ func grantAll(exe, configPath string) error {
 			if err := grantAccessTree(comfyDir, "(OI)(CI)(M)"); err != nil {
 				return err
 			}
+			// uv venvs (Comfy-Desktop) redirect to a base interpreter that
+			// can live outside COMFY_DIR; read+execute suffices for it.
+			if home := comfyVenvHome(comfyDir); home != "" {
+				if err := grantAccessTree(home, "(OI)(CI)(RX)"); err != nil {
+					return err
+				}
+			}
+			// Comfy-Desktop keeps models/input/output in a shared dir next
+			// to the install; the managed instance writes output there.
+			if shared := supervise.DesktopSharedDir(comfyDir); shared != "" {
+				if err := grantAccessTree(shared, "(OI)(CI)(M)"); err != nil {
+					return err
+				}
+			}
 		}
 	}
 	return nil
@@ -496,7 +512,7 @@ func grantAccessTree(path, perms string) error {
 func runIcacls(path, perms string, recursive bool) error {
 	args := []string{path, "/grant", virtualAccount + ":" + perms}
 	if recursive {
-		fmt.Printf("granting %s modify access to %s (large trees can take minutes)\n", virtualAccount, path)
+		fmt.Printf("granting %s %s access to %s (large trees can take minutes)\n", virtualAccount, perms, path)
 		args = append(args, "/T")
 	}
 	start := time.Now()

internal/service/venv.go

@@ -0,0 +1,38 @@
+package service
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// comfyVenvHome returns the base interpreter directory of the Python venv at
+// <comfyDir>/.venv when that directory lives outside comfyDir, "" otherwise.
+// uv-created venvs (Comfy-Desktop) ship a redirector python.exe whose real
+// interpreter is the pyvenv.cfg "home" tree — typically a sibling of
+// COMFY_DIR, which a sandbox/ACL covering COMFY_DIR alone does not reach.
+func comfyVenvHome(comfyDir string) string {
+	data, err := os.ReadFile(filepath.Join(comfyDir, ".venv", "pyvenv.cfg"))
+	if err != nil {
+		return ""
+	}
+	for _, line := range strings.Split(string(data), "\n") {
+		k, v, ok := strings.Cut(line, "=")
+		if !ok || strings.TrimSpace(k) != "home" {
+			continue
+		}
+		home := strings.TrimSpace(v)
+		if home == "" {
+			return ""
+		}
+		if st, err := os.Stat(home); err != nil || !st.IsDir() {
+			return ""
+		}
+		rel, err := filepath.Rel(comfyDir, home)
+		if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+			return home
+		}
+		return "" // inside comfyDir: already covered by the COMFY_DIR grant
+	}
+	return ""
+}

internal/service/venv_test.go

@@ -0,0 +1,45 @@
+package service
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestComfyVenvHome(t *testing.T) {
+	root := t.TempDir()
+	comfy := filepath.Join(root, "ComfyUI")
+	outside := filepath.Join(root, "standalone-env")
+	inside := filepath.Join(comfy, "runtime")
+	for _, d := range []string{filepath.Join(comfy, ".venv"), outside, inside} {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cfg := filepath.Join(comfy, ".venv", "pyvenv.cfg")
+
+	write := func(home string) {
+		if err := os.WriteFile(cfg, []byte("home = "+home+"\nversion_info = 3.13.0\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	write(outside)
+	if got := comfyVenvHome(comfy); got != outside {
+		t.Fatalf("outside home: got %q, want %q", got, outside)
+	}
+
+	write(inside)
+	if got := comfyVenvHome(comfy); got != "" {
+		t.Fatalf("inside home: got %q, want empty", got)
+	}
+
+	write(filepath.Join(root, "does-not-exist"))
+	if got := comfyVenvHome(comfy); got != "" {
+		t.Fatalf("missing home: got %q, want empty", got)
+	}
+
+	if got := comfyVenvHome(filepath.Join(root, "no-venv")); got != "" {
+		t.Fatalf("no pyvenv.cfg: got %q, want empty", got)
+	}
+}

internal/supervise/supervise.go

@@ -13,6 +13,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"sync"
@@ -43,7 +44,9 @@ func ComfyLayout(goos, dir string) (python, script string) {
 // DefaultComfyCommand builds the launch command for the standard venv
 // layout (see ComfyLayout): the script is passed relative to dir so dir
 // stays the working directory, and --port is taken from comfyURL when the
-// URL carries one.
+// URL carries one. On a Comfy-Desktop standalone install the shared data
+// directory (models, input, output) is added as --*-directory flags so the
+// managed instance sees the desktop app's models.
 func DefaultComfyCommand(goos, dir, comfyURL string) string {
 	python, script := ComfyLayout(goos, dir)
 	rel, err := filepath.Rel(dir, script)
@@ -54,9 +57,34 @@ func DefaultComfyCommand(goos, dir, comfyURL string) string {
 	if u, err := url.Parse(comfyURL); err == nil && u.Port() != "" {
 		cmd += " --port " + u.Port()
 	}
+	if shared := DesktopSharedDir(dir); shared != "" {
+		for _, sub := range []string{"models", "input", "output"} {
+			p := filepath.Join(shared, sub)
+			if st, err := os.Stat(p); err == nil && st.IsDir() {
+				cmd += ` --` + sub + `-directory "` + p + `"`
+			}
+		}
+	}
 	return cmd
 }
 
+// DesktopSharedDir returns the Comfy-Desktop shared data directory
+// (<root>/ComfyUI-Shared) when dir looks like a desktop standalone install
+// (<root>/ComfyUI-Installs/<name>/ComfyUI) and the shared models directory
+// exists; "" otherwise. The desktop app keeps models, input and output
+// there rather than inside the ComfyUI tree.
+func DesktopSharedDir(dir string) string {
+	installs := filepath.Dir(filepath.Dir(dir))
+	if filepath.Base(installs) != "ComfyUI-Installs" {
+		return ""
+	}
+	shared := filepath.Join(filepath.Dir(installs), "ComfyUI-Shared")
+	if st, err := os.Stat(filepath.Join(shared, "models")); err == nil && st.IsDir() {
+		return shared
+	}
+	return ""
+}
+
 // Process is one managed child process.
 type Process struct {
 	name         string
@@ -185,6 +213,9 @@ func (p *Process) EnsureRunning() error {
 	p.external = false
 	cmd := exec.Command(p.argv[0], p.argv[1:]...)
 	cmd.Dir = p.dir
+	// Ask the child not to colorize (ComfyUI ignores this and colors
+	// anyway, so pipeLog also strips escape sequences).
+	cmd.Env = append(os.Environ(), "NO_COLOR=1", "TERM=dumb")
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return err
@@ -278,7 +309,9 @@ func (p *Process) WatchIdle(ctx context.Context, idleTimeout time.Duration, gpuI
 }
 
 // pipeLog forwards one child output stream to the log at INFO, line by
-// line, prefixed with the process name.
+// line, prefixed with the process name. ANSI escape sequences are
+// stripped: ComfyUI colorizes unconditionally, and the escapes only
+// render as garbage in a log file.
 func (p *Process) pipeLog(r io.Reader) {
 	buf := make([]byte, 4096)
 	var line string
@@ -290,18 +323,25 @@ func (p *Process) pipeLog(r io.Reader) {
 			if i < 0 {
 				break
 			}
-			p.log.Info(p.name + ": " + strings.TrimRight(line[:i], "\r"))
+			p.log.Info(p.name + ": " + stripANSI(strings.TrimRight(line[:i], "\r")))
 			line = line[i+1:]
 		}
 		if err != nil {
 			if strings.TrimSpace(line) != "" {
-				p.log.Info(p.name + ": " + line)
+				p.log.Info(p.name + ": " + stripANSI(line))
 			}
 			return
 		}
 	}
 }
 
+// ansiPattern matches CSI escape sequences (colors, cursor moves, …).
+var ansiPattern = regexp.MustCompile("\x1b\\[[0-9;?]*[a-zA-Z]")
+
+func stripANSI(s string) string {
+	return ansiPattern.ReplaceAllString(s, "")
+}
+
 // stopTree kills cmd's process, including its children on Windows (python
 // launchers tend to spawn some). The Wait goroutine reaps it.
 func stopTree(cmd *exec.Cmd) {

internal/supervise/supervise_test.go

@@ -239,3 +239,38 @@ func TestComfyLayoutAndDefaultCommand(t *testing.T) {
 		t.Errorf("missing-layout script = %s", script)
 	}
 }
+
+func TestStripANSI(t *testing.T) {
+	cases := map[string]string{
+		"\x1b[32m[INFO]\x1b[0m Starting server":   "[INFO] Starting server",
+		"\x1b[1m\x1b[31m[ERROR]\x1b[0m boom":      "[ERROR] boom",
+		"plain line":                              "plain line",
+		"\x1b[33mWARN\x1b[0m: \x1b[1mbold\x1b[0m": "WARN: bold",
+	}
+	for in, want := range cases {
+		if got := stripANSI(in); got != want {
+			t.Errorf("stripANSI(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestDesktopSharedDir(t *testing.T) {
+	root := t.TempDir()
+	comfy := filepath.Join(root, "ComfyUI-Installs", "rtx5080", "ComfyUI")
+	if err := os.MkdirAll(comfy, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if got := DesktopSharedDir(comfy); got != "" {
+		t.Fatalf("no shared dir yet: got %q, want empty", got)
+	}
+	shared := filepath.Join(root, "ComfyUI-Shared")
+	if err := os.MkdirAll(filepath.Join(shared, "models"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if got := DesktopSharedDir(comfy); got != shared {
+		t.Fatalf("got %q, want %q", got, shared)
+	}
+	if got := DesktopSharedDir(filepath.Join(root, "plain", "ComfyUI")); got != "" {
+		t.Fatalf("non-desktop layout: got %q, want empty", got)
+	}
+}

internal/update/update.go

@@ -173,11 +173,13 @@ func CleanupOld(exePath string) {
 
 // Check performs a single update check. staged is true when a
 // signature-verified binary has been swapped into place at exePath; the
-// caller should then restart the process. A nil error with staged=false
-// means "no action" (up to date, APP_VER=dev, or no embedded public key);
-// a non-nil error means the check failed and the running binary is
-// untouched.
-func (u *Updater) Check(ctx context.Context, exePath string) (staged bool, err error) {
+// caller should then restart the process. to is the release tag the check
+// resolved (the latest release or the pinned tag), set once the release
+// fetch succeeded — even when staging afterwards fails. A nil error with
+// staged=false means "no action" (up to date, APP_VER=dev, or no embedded
+// public key); a non-nil error means the check failed and the running
+// binary is untouched.
+func (u *Updater) Check(ctx context.Context, exePath string) (staged bool, to string, err error) {
 	log := u.logger()
 	desired := u.Desired
 	if desired == "" {
@@ -185,15 +187,15 @@ func (u *Updater) Check(ctx context.Context, exePath string) (staged bool, err e
 	}
 	if desired == "dev" {
 		log.Debug("auto-update: APP_VER=dev, skipping")
-		return false, nil
+		return false, "", nil
 	}
 	if publicKeyPEM == "" {
 		log.Debug("auto-update: no public key embedded, skipping")
-		return false, nil
+		return false, "", nil
 	}
 	api, err := u.apiURL()
 	if err != nil {
-		return false, err
+		return false, "", err
 	}
 
 	pinned := desired != "stable"
@@ -203,29 +205,30 @@ func (u *Updater) Check(ctx context.Context, exePath string) (staged bool, err e
 	}
 	body, err := u.get(ctx, endpoint)
 	if err != nil {
-		return false, fmt.Errorf("fetch release: %w", err)
+		return false, "", fmt.Errorf("fetch release: %w", err)
 	}
 	var rel release
 	if err := json.Unmarshal(body, &rel); err != nil {
-		return false, fmt.Errorf("parse release: %w", err)
+		return false, "", fmt.Errorf("parse release: %w", err)
 	}
+	to = rel.TagName
 	if pinned {
 		// Pin mode: any difference from the target tag means stage it —
 		// including downgrades and replacing a dev binary.
 		if u.Version == rel.TagName {
 			log.Debug("auto-update: already on pinned version", "version", u.Version)
-			return false, nil
+			return false, to, nil
 		}
 	} else if u.Version != "" && u.Version != "dev" {
 		// Stable mode: only strictly newer releases count; a dev binary
 		// cannot be compared and is always replaced by the latest release.
 		newer, err := newerVersion(u.Version, rel.TagName)
 		if err != nil {
-			return false, err
+			return false, to, err
 		}
 		if !newer {
 			log.Debug("auto-update: up to date", "version", u.Version, "latest", rel.TagName)
-			return false, nil
+			return false, to, nil
 		}
 	}
 
@@ -235,42 +238,42 @@ func (u *Updater) Check(ctx context.Context, exePath string) (staged bool, err e
 	}
 	assetURL, ok := urls[u.Asset]
 	if !ok {
-		return false, fmt.Errorf("release %s has no asset %q", rel.TagName, u.Asset)
+		return false, to, fmt.Errorf("release %s has no asset %q", rel.TagName, u.Asset)
 	}
 	sigURL, ok := urls[u.Asset+".sig"]
 	if !ok {
-		return false, fmt.Errorf("release %s has no signature asset %q", rel.TagName, u.Asset+".sig")
+		return false, to, fmt.Errorf("release %s has no signature asset %q", rel.TagName, u.Asset+".sig")
 	}
 
 	data, err := u.get(ctx, assetURL)
 	if err != nil {
-		return false, fmt.Errorf("download %s: %w", u.Asset, err)
+		return false, to, fmt.Errorf("download %s: %w", u.Asset, err)
 	}
 	sig, err := u.get(ctx, sigURL)
 	if err != nil {
-		return false, fmt.Errorf("download signature: %w", err)
+		return false, to, fmt.Errorf("download signature: %w", err)
 	}
 
 	if sumURL, ok := urls[u.Asset+".sha256"]; ok {
 		sumText, err := u.get(ctx, sumURL)
 		if err != nil {
-			return false, fmt.Errorf("download checksum: %w", err)
+			return false, to, fmt.Errorf("download checksum: %w", err)
 		}
 		want := strings.Fields(string(sumText))[0]
 		got := hex.EncodeToString(sha256Bytes(data))
 		if !strings.EqualFold(want, got) {
-			return false, fmt.Errorf("sha256 mismatch: got %s, want %s", got, want)
+			return false, to, fmt.Errorf("sha256 mismatch: got %s, want %s", got, want)
 		}
 	}
 	if err := verifySignature(publicKeyPEM, data, sig); err != nil {
-		return false, err
+		return false, to, err
 	}
 
 	if err := stage(exePath, data); err != nil {
-		return false, fmt.Errorf("stage update: %w", err)
+		return false, to, fmt.Errorf("stage update: %w", err)
 	}
 	log.Info("auto-update: new version staged", "from", u.Version, "to", rel.TagName)
-	return true, nil
+	return true, to, nil
 }
 
 func sha256Bytes(data []byte) []byte {

internal/update/update_test.go

@@ -102,13 +102,16 @@ func TestCheckStagesUpdate(t *testing.T) {
 	withPublicKey(t, f.pubPEM)
 	exe := fakeExe(t)
 
-	staged, err := f.updater("v0.1.2").Check(context.Background(), exe)
+	staged, to, err := f.updater("v0.1.2").Check(context.Background(), exe)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !staged {
 		t.Fatal("expected staged update")
 	}
+	if to != "v9.9.9" {
+		t.Fatalf("to = %q, want v9.9.9", to)
+	}
 	content, _ := os.ReadFile(exe)
 	if string(content) != "new-binary" {
 		t.Fatalf("exe content = %q", content)
@@ -125,7 +128,7 @@ func TestCheckRejectsTamperedSignature(t *testing.T) {
 	withPublicKey(t, f.pubPEM)
 	exe := fakeExe(t)
 
-	staged, err := f.updater("v0.1.2").Check(context.Background(), exe)
+	staged, _, err := f.updater("v0.1.2").Check(context.Background(), exe)
 	if err == nil {
 		t.Fatal("expected signature error")
 	}
@@ -142,7 +145,7 @@ func TestCheckSkipsOlderOrEqual(t *testing.T) {
 	for _, tag := range []string{"v0.1.2", "v0.1.1", "v0.0.9"} {
 		f := newFakeGitea(t, tag, []byte("new-binary"))
 		withPublicKey(t, f.pubPEM)
-		staged, err := f.updater("v0.1.2").Check(context.Background(), fakeExe(t))
+		staged, _, err := f.updater("v0.1.2").Check(context.Background(), fakeExe(t))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -155,7 +158,7 @@ func TestCheckSkipsOlderOrEqual(t *testing.T) {
 func TestCheckSkipsWithoutPublicKey(t *testing.T) {
 	f := newFakeGitea(t, "v9.9.9", []byte("new-binary"))
 	withPublicKey(t, "")
-	staged, err := f.updater("v0.1.2").Check(context.Background(), fakeExe(t))
+	staged, _, err := f.updater("v0.1.2").Check(context.Background(), fakeExe(t))
 	if err != nil || staged {
 		t.Fatalf("staged=%v err=%v, want no action without key", staged, err)
 	}
@@ -167,7 +170,7 @@ func TestCheckDevBuildGetsStable(t *testing.T) {
 	f := newFakeGitea(t, "v9.9.9", []byte("new-binary"))
 	withPublicKey(t, f.pubPEM)
 	exe := fakeExe(t)
-	staged, err := f.updater("dev").Check(context.Background(), exe)
+	staged, _, err := f.updater("dev").Check(context.Background(), exe)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -184,7 +187,7 @@ func TestCheckDesiredDevDisables(t *testing.T) {
 	f := newFakeGitea(t, "v9.9.9", []byte("new-binary"))
 	withPublicKey(t, f.pubPEM)
 	for _, version := range []string{"dev", "v0.1.2"} {
-		staged, err := f.updaterDesired(version, "dev").Check(context.Background(), fakeExe(t))
+		staged, _, err := f.updaterDesired(version, "dev").Check(context.Background(), fakeExe(t))
 		if err != nil || staged {
 			t.Fatalf("version %s: staged=%v err=%v, want no action with APP_VER=dev", version, staged, err)
 		}
@@ -198,13 +201,16 @@ func TestCheckPinned(t *testing.T) {
 		f := newFakeGitea(t, "v0.5.0", []byte("pinned-binary"))
 		withPublicKey(t, f.pubPEM)
 		exe := fakeExe(t)
-		staged, err := f.updaterDesired(version, "v0.5.0").Check(context.Background(), exe)
+		staged, to, err := f.updaterDesired(version, "v0.5.0").Check(context.Background(), exe)
 		if err != nil {
 			t.Fatalf("version %s: %v", version, err)
 		}
 		if !staged {
 			t.Fatalf("version %s: expected pinned v0.5.0 to be staged", version)
 		}
+		if to != "v0.5.0" {
+			t.Fatalf("version %s: to = %q, want v0.5.0", version, to)
+		}
 		content, _ := os.ReadFile(exe)
 		if string(content) != "pinned-binary" {
 			t.Fatalf("version %s: exe content = %q", version, content)
@@ -213,7 +219,7 @@ func TestCheckPinned(t *testing.T) {
 
 	f := newFakeGitea(t, "v0.5.0", []byte("pinned-binary"))
 	withPublicKey(t, f.pubPEM)
-	staged, err := f.updaterDesired("v0.5.0", "v0.5.0").Check(context.Background(), fakeExe(t))
+	staged, _, err := f.updaterDesired("v0.5.0", "v0.5.0").Check(context.Background(), fakeExe(t))
 	if err != nil || staged {
 		t.Fatalf("staged=%v err=%v, want no action when already on the pinned version", staged, err)
 	}