Upgrade git-remote-entire alongside entire (#3)

* Upgrade git-remote-entire alongside entire

The go install path only built cmd/entire; install both binaries so it
matches the Homebrew and install.sh paths, which unpack both from the
release tarball.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: d95ca3cae73e

* Model release binaries as one independently-versioned set

Drive detection, gating, go-install, and verification from a single
releaseBinaries catalog instead of special-casing entire and bolting on
git-remote-entire. Each binary carries its own detected version and is
upgraded independently, so a missing or stale helper beside a current
entire is fixed on its own. Version resolution (--version then build
info) is written once in binaryVersion and shared by every binary.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 391b8dd6192d

* Authenticate release check in Homebrew smoke job

The Homebrew job's Exercise step was the only upgrade step without
GITHUB_TOKEN, so entire-upgrade's release-version check hit GitHub's
API unauthenticated and 403'd on the shared runner IP's 60/hr limit.
Set GITHUB_TOKEN like the curl and go jobs already do.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 9ac8d58d7318

* Reinstall when a binary's version can't be determined

A locally-built dev entire reports "dev" from --version and "(devel)"
build info, so neither source yields a version. That was a hard,
cryptic failure ("could not determine entire version from --version
output or Go build info"). Now an unreadable version is treated as
absent for any binary — anchor included — so the gate sees it as out of
date and reinstalls, with a clear note instead of an error. The error
that remains (when even reinstall can't proceed) names the binary and
reports both attempts.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 8f7160ecff67

* Report every managed binary in detection and completion

Now that the upgrade manages entire and git-remote-entire independently,
print a line per binary (version + path, or "not installed"/"version
unreadable") instead of only the anchor. Same per-binary listing on
completion. Makes "already up to date" verifiable — you can see
git-remote-entire's detected version, not just entire's.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 9297c7de62eb

* Column-align binary names in detection/completion output

Pad each binary name to the widest one so the version/path columns line
up across entire and git-remote-entire.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Entire-Checkpoint: 5eb342cccb6e

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: toothbrush

.github/workflows/upgrade-smoke.yml

@@ -44,6 +44,10 @@ jobs:
           brew install --cask entire
           entire --version
       - name: Exercise upgrade plugin
+        env:
+          # Authenticate the release-check API calls; the shared runner IP
+          # blows past GitHub's unauthenticated 60/hr limit otherwise.
+          GITHUB_TOKEN: ${{ github.token }}
         run: |
           set -o pipefail
           ./entire-upgrade --yes | tee stable.log
@@ -117,6 +121,7 @@ jobs:
           ./entire-upgrade --nightly --yes | tee nightly.log
           grep -F "(go install)" nightly.log
           entire --version
+          test -x "$GOBIN/git-remote-entire"
 
   go-windows:
     name: go install path (Windows)
@@ -158,3 +163,6 @@ jobs:
             throw "nightly upgrade did not detect a go install"
           }
           entire --version
+          if (-not (Test-Path (Join-Path $env:GOBIN "git-remote-entire.exe"))) {
+            throw "git-remote-entire was not installed beside entire"
+          }

README.md

@@ -24,7 +24,10 @@ entire upgrade --stable
 ```
 
 The plugin detects whether the active `entire` binary was installed through
-Homebrew, `install.sh`, or `go install`, then runs the matching updater.
+Homebrew, `install.sh`, or `go install`, then runs the matching updater. Each
+release ships both `entire` and `git-remote-entire`, and the upgrade replaces
+both. The Homebrew and `install.sh` paths unpack the two binaries together; the
+`go install` path builds and installs each one beside the existing `entire`.
 
 ## Installation
 

internal/upgrade/install.go

@@ -7,10 +7,31 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime/debug"
 	"strings"
 )
 
+// anchorBinary is the executable we discover on PATH to locate the install
+// (its directory and install method). Every other release binary is resolved
+// beside it. remoteHelperBinary is the git remote helper for entire:// URLs.
+const (
+	anchorBinary       = "entire"
+	remoteHelperBinary = "git-remote-entire"
+)
+
+// releaseBinaries is the set of executables shipped in an Entire CLI release.
+// They're versioned and (re)installed independently — even though releases
+// normally ship them in lockstep, a user's bin dir can drift. Add a binary
+// here and detection, gating, install, and verification all pick it up.
+var releaseBinaries = []struct {
+	Name  string // executable base name
+	GoPkg string // module path for `go install`
+}{
+	{Name: anchorBinary, GoPkg: "github.com/entireio/cli/cmd/entire"},
+	{Name: remoteHelperBinary, GoPkg: "github.com/entireio/cli/cmd/git-remote-entire"},
+}
+
 type Method string
 
 const (
@@ -24,7 +45,21 @@ type Installation struct {
 	BinaryPath   string
 	ResolvedPath string
 	BrewCask     string
-	Version      Version
+	// Version is the anchor (entire) version, kept for the channel/compare
+	// logic. It mirrors Binaries[0].Version.
+	Version Version
+	// Binaries are all the release executables this install manages, anchor
+	// first, each with its independently detected version (Present=false when
+	// missing or unreadable).
+	Binaries []ManagedBinary
+}
+
+// ManagedBinary is one release executable located beside the anchor.
+type ManagedBinary struct {
+	Name    string
+	GoPkg   string
+	Path    string
+	Version Version
 }
 
 type Environment struct {
@@ -58,23 +93,53 @@ func DetectInstallation(ctx context.Context) (Installation, error) {
 		return Installation{}, fmt.Errorf("unsupported Entire CLI installation at %s; supported update methods are Homebrew, install.sh, and go install", binaryPath)
 	}
 
-	versionOut, err := exec.CommandContext(ctx, binaryPath, "--version").CombinedOutput()
-	if err != nil {
-		return Installation{}, versionCommandError(err, versionOut)
+	// Resolve every release binary beside the anchor. An unreadable version —
+	// a missing binary, a local dev build (`--version` reports "dev" and the Go
+	// build info is "(devel)"), or a git-remote-entire predating --version —
+	// leaves Version absent, which callers treat as "(re)install it" rather than
+	// a hard failure. binDir is where the anchor lives, so the rest sit beside it.
+	binDir := filepath.Dir(binaryPath)
+	for _, rb := range releaseBinaries {
+		bin := ManagedBinary{Name: rb.Name, GoPkg: rb.GoPkg, Path: filepath.Join(binDir, executableName(rb.Name))}
+		if version, verr := binaryVersion(ctx, bin.Path); verr == nil {
+			bin.Version = version
+		}
+		install.Binaries = append(install.Binaries, bin)
 	}
-	version, err := ParseVersion(string(versionOut))
+	install.Version = install.Binaries[0].Version
+
+	return install, nil
+}
+
+// binaryVersion reads a binary's version the same way for every release
+// executable: its `--version` output first, then the Go build info baked into
+// the binary. It returns an error only when neither yields a version; the
+// message names the binary and reports both attempts so the failure is
+// actionable rather than cryptic.
+func binaryVersion(ctx context.Context, path string) (Version, error) {
+	resolved, err := filepath.EvalSymlinks(path)
 	if err != nil {
-		if install.Method != MethodGo {
-			return Installation{}, err
-		}
-		parseErr := err
-		version, err = versionFromGoBuildInfo(resolvedPath)
-		if err != nil {
-			return Installation{}, fmt.Errorf("%w; Go build info fallback failed: %v", parseErr, err)
+		resolved = path
+	}
+
+	out, cmdErr := exec.CommandContext(ctx, path, "--version").CombinedOutput()
+	var versionAttempt string
+	switch {
+	case cmdErr != nil:
+		versionAttempt = fmt.Sprintf("running %q failed: %v", filepath.Base(path)+" --version", cmdErr)
+	default:
+		version, parseErr := ParseVersion(string(out))
+		if parseErr == nil {
+			return version, nil
 		}
+		versionAttempt = fmt.Sprintf("could not parse %q output %q", filepath.Base(path)+" --version", strings.TrimSpace(string(out)))
 	}
-	install.Version = version
-	return install, nil
+
+	if version, buildErr := versionFromGoBuildInfo(resolved); buildErr == nil {
+		return version, nil
+	}
+	return Version{}, fmt.Errorf("could not determine %s version: %s; and reading Go build info from %s did not yield one either",
+		filepath.Base(path), versionAttempt, resolved)
 }
 
 func versionFromGoBuildInfo(binaryPath string) (Version, error) {
@@ -90,6 +155,17 @@ func versionFromBuildInfo(info *debug.BuildInfo) (Version, error) {
 		return Version{}, fmt.Errorf("missing Go build info")
 	}
 
+	// Mirror the CLI's versioninfo.resolve: a GoReleaser `-X ...Version=` stamp
+	// wins over the module version. `go build -ldflags=...` records that whole
+	// flag string in build settings (and `-s -w` doesn't strip it), so release
+	// binaries — Homebrew and install.sh — expose their version here even
+	// though buildinfo.Main.Version is "(devel)" for a `go build`.
+	if raw, ok := ldflagsVersion(info.Settings); ok {
+		if version, err := ParseVersion(raw); err == nil {
+			return version, nil
+		}
+	}
+
 	candidates := []string{}
 	if isEntireCLIModulePath(info.Main.Path) {
 		candidates = append(candidates, info.Main.Version)
@@ -115,12 +191,23 @@ func isEntireCLIModulePath(path string) bool {
 	return path == "github.com/entireio/cli" || strings.HasPrefix(path, "github.com/entireio/cli/")
 }
 
-func versionCommandError(err error, output []byte) error {
-	message := strings.TrimSpace(string(output))
-	if message == "" {
-		return fmt.Errorf("failed to read installed Entire CLI version: %w", err)
+// ldflagsVersionRE pulls the version out of the CLI's versioninfo stamp, as it
+// appears in the `-ldflags` build setting. GoReleaser emits `-X <path>=<value>`;
+// `go build` may render the linker flag as either `-X path=val` or `-X=path=val`.
+var ldflagsVersionRE = regexp.MustCompile(`-X[ =]github\.com/entireio/cli/cmd/entire/cli/versioninfo\.Version=(\S+)`)
+
+// ldflagsVersion extracts the versioninfo.Version stamp from the recorded
+// `-ldflags` build setting, if present.
+func ldflagsVersion(settings []debug.BuildSetting) (string, bool) {
+	for _, setting := range settings {
+		if setting.Key != "-ldflags" {
+			continue
+		}
+		if m := ldflagsVersionRE.FindStringSubmatch(setting.Value); m != nil {
+			return strings.Trim(m[1], `"'`), true
+		}
 	}
-	return fmt.Errorf("failed to read installed Entire CLI version: %w: %s", err, message)
+	return "", false
 }
 
 func ClassifyInstallation(binaryPath, resolvedPath string, env Environment) (Installation, bool) {

internal/upgrade/install_test.go

@@ -2,7 +2,6 @@ package upgrade
 
 import (
 	"context"
-	"errors"
 	"path/filepath"
 	"reflect"
 	"runtime/debug"
@@ -124,6 +123,40 @@ func TestVersionFromBuildInfoUsesEntireDependencyVersion(t *testing.T) {
 	}
 }
 
+func TestVersionFromBuildInfoPrefersLdflagsStamp(t *testing.T) {
+	// Release binaries (Homebrew, install.sh) carry "(devel)" as the module
+	// version but a real version in the -ldflags stamp, just like git-remote-entire.
+	got, err := versionFromBuildInfo(&debug.BuildInfo{
+		Main: debug.Module{Path: "github.com/entireio/cli/cmd/git-remote-entire", Version: "(devel)"},
+		Settings: []debug.BuildSetting{
+			{Key: "-ldflags", Value: "-s -w -X github.com/entireio/cli/cmd/entire/cli/versioninfo.Version=0.7.4 -X github.com/entireio/cli/cmd/entire/cli/versioninfo.Commit=deadbeef"},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.String() != "0.7.4" {
+		t.Fatalf("version = %s, want 0.7.4", got)
+	}
+}
+
+func TestVersionFromBuildInfoLdflagsStampWinsOverModule(t *testing.T) {
+	// The stamp is what `entire --version` reports, so it must win over the
+	// module version when they differ, matching the CLI's versioninfo.resolve.
+	got, err := versionFromBuildInfo(&debug.BuildInfo{
+		Main: debug.Module{Path: "github.com/entireio/cli/cmd/entire", Version: "v0.6.1"},
+		Settings: []debug.BuildSetting{
+			{Key: "-ldflags", Value: "-X github.com/entireio/cli/cmd/entire/cli/versioninfo.Version=0.7.4"},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.String() != "0.7.4" {
+		t.Fatalf("version = %s, want 0.7.4 (ldflags stamp should win)", got)
+	}
+}
+
 func TestVersionFromBuildInfoRejectsDevelVersion(t *testing.T) {
 	_, err := versionFromBuildInfo(&debug.BuildInfo{
 		Main: debug.Module{
@@ -258,13 +291,6 @@ func TestCommandEnvWithoutGitHubToken(t *testing.T) {
 	}
 }
 
-func TestVersionCommandErrorIncludesOutput(t *testing.T) {
-	err := versionCommandError(errors.New("exit status 1"), []byte("broken install\n"))
-	if !strings.Contains(err.Error(), "broken install") {
-		t.Fatalf("error = %q, want command output", err)
-	}
-}
-
 type recordRunner struct {
 	commands []string
 	envs     [][]string