fix(updater): use commit SHA, not BuildTime, to detect republish

published_at is always slightly later than BuildTime for the same
artifact (goreleaser publishes the release seconds after building),
so the time-based comparison always fired -> false "update available"
for the very release the user just installed.

Switch to comparing constant.GitRevision against the commit SHA the
release tag points at (GET /commits/{tag}). Bare `go build` (no
revision injected) and GitHub fetch failures stay conservative -> no
spurious prompts; user can --force.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Ehco1996

internal/cli/update.go

@@ -24,6 +24,6 @@ var UpdateCMD = &cli.Command{
 			Channel: c.String("channel"),
 			Force:   c.Bool("force"),
 			Restart: !c.Bool("no-restart"),
-		}, constant.Version, constant.BuildTime, cliLogger, nil)
+		}, constant.Version, constant.GitRevision, cliLogger, nil)
 	},
 }

internal/updater/updater.go

@@ -80,8 +80,9 @@ type ghRelease struct {
 }
 
 // Check resolves channel against currentVersion and queries GitHub.
-// currentBuildTime is the ldflag-injected constant.BuildTime; empty is fine.
-func Check(ctx context.Context, channel, currentVersion, currentBuildTime string) (*CheckResult, error) {
+// currentRevision is the ldflag-injected constant.GitRevision; empty is
+// tolerated (we'll just trust version-string equality in that case).
+func Check(ctx context.Context, channel, currentVersion, currentRevision string) (*CheckResult, error) {
 	resolved, rel, err := pickRelease(ctx, channel, currentVersion)
 	if err != nil {
 		return nil, err
@@ -98,7 +99,7 @@ func Check(ctx context.Context, channel, currentVersion, currentBuildTime string
 		PublishedAt:    rel.PublishedAt,
 	}
 	if latest == currentVersion {
-		res.UpdateAvailable = nightlyRepublished(rel, currentBuildTime)
+		res.UpdateAvailable = nightlyRepublished(ctx, rel, currentRevision)
 	} else {
 		res.UpdateAvailable = compareVersions(latest, currentVersion) > 0
 	}
@@ -111,7 +112,7 @@ func Check(ctx context.Context, channel, currentVersion, currentBuildTime string
 
 // Apply downloads + swaps + (optionally) restarts. Each phase is reported
 // to onState so the dashboard can render progress; CLI passes nil.
-func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentBuildTime string, log *zap.SugaredLogger, onState func(State)) error {
+func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevision string, log *zap.SugaredLogger, onState func(State)) error {
 	emit := func(s State) {
 		if onState != nil {
 			onState(s)
@@ -128,9 +129,9 @@ func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentBuildT
 
 	if !opts.Force {
 		if latest == currentVersion {
-			if nightlyRepublished(rel, currentBuildTime) {
-				log.Infof("nightly tag %s republished after local build (%s); reinstalling",
-					rel.TagName, currentBuildTime)
+			if nightlyRepublished(ctx, rel, currentRevision) {
+				log.Infof("nightly tag %s now points at a different commit than local %s; reinstalling",
+					rel.TagName, currentRevision)
 			} else {
 				log.Info("already up to date")
 				emit(StateDone)
@@ -269,30 +270,49 @@ func getJSON(ctx context.Context, url string, out any) error {
 }
 
 // nightlyRepublished reports whether a release whose tag matches the
-// running version is actually newer than the current binary. Nightly
-// uses a rolling tag (v1.1.7-next), so version-string equality alone
-// would mask republished builds. Only meaningful for prereleases; stable
-// tags don't roll.
-func nightlyRepublished(rel *ghRelease, currentBuildTime string) bool {
-	if !rel.Prerelease || currentBuildTime == "" {
+// running version actually points at a different commit than the
+// running binary. Nightly uses a rolling tag (v1.1.7-next), so
+// version-string equality alone would mask republished builds.
+//
+// We can't time-compare published_at vs BuildTime: goreleaser publishes
+// the release a few seconds after building the artifact, so the same
+// artifact would always look "older" than its own release. SHA is the
+// only reliable signal.
+//
+// Conservative on uncertainty: empty currentRevision (bare `go build`)
+// or GitHub fetch failure -> false (no spurious update prompts; user
+// can --force).
+func nightlyRepublished(ctx context.Context, rel *ghRelease, currentRevision string) bool {
+	if !rel.Prerelease || currentRevision == "" {
 		return false
 	}
-	built, ok := parseBuildTime(currentBuildTime)
-	if !ok {
+	sha, err := fetchTagCommitSHA(ctx, rel.TagName)
+	if err != nil || sha == "" {
 		return false
 	}
-	return rel.PublishedAt.After(built)
+	return !shaMatchesRevision(sha, currentRevision)
 }
 
-// parseBuildTime accepts both ldflag formats: goreleaser's RFC3339
-// ({{.Date}}) and the Makefile's "2006-01-02-15:04:05".
-func parseBuildTime(s string) (time.Time, bool) {
-	for _, layout := range []string{time.RFC3339, "2006-01-02-15:04:05"} {
-		if t, err := time.Parse(layout, s); err == nil {
-			return t, true
-		}
+// shaMatchesRevision compares the short revision baked into the binary
+// (goreleaser uses {{.ShortCommit}}, 7 chars; Makefile uses full SHA)
+// against the full SHA returned by GitHub. Prefix-match is enough.
+func shaMatchesRevision(fullSHA, currentRevision string) bool {
+	n := len(currentRevision)
+	if n == 0 || n > len(fullSHA) {
+		return false
+	}
+	return strings.EqualFold(fullSHA[:n], currentRevision)
+}
+
+func fetchTagCommitSHA(ctx context.Context, tag string) (string, error) {
+	var c struct {
+		SHA string `json:"sha"`
+	}
+	url := "https://api.github.com/repos/Ehco1996/ehco/commits/" + tag
+	if err := getJSON(ctx, url, &c); err != nil {
+		return "", err
 	}
-	return time.Time{}, false
+	return c.SHA, nil
 }
 
 // compareVersions returns -1/0/1 like semver.Compare. Falls back to

internal/updater/updater_test.go

@@ -2,7 +2,6 @@ package updater
 
 import (
 	"testing"
-	"time"
 )
 
 func TestResolveChannel(t *testing.T) {
@@ -48,45 +47,23 @@ func TestCompareVersions(t *testing.T) {
 	}
 }
 
-func TestParseBuildTime(t *testing.T) {
+func TestShaMatchesRevision(t *testing.T) {
+	full := "1e0e74cabcdef0123456789abcdef0123456789a"
 	cases := []struct {
-		in   string
-		want bool
+		fullSHA, revision string
+		want              bool
 	}{
-		{"2026-05-04T23:10:16Z", true},                   // goreleaser
-		{"2026-05-04T23:10:16+08:00", true},              // RFC3339 w/ offset
-		{"2026-05-04-23:10:16", true},                    // Makefile
-		{"", false},
-		{"not-a-time", false},
+		{full, "1e0e74c", true},                    // goreleaser short
+		{full, "1E0E74C", true},                    // case-insensitive
+		{full, full, true},                         // Makefile full SHA
+		{full, "deadbee", false},                   // different commit
+		{full, "", false},                          // empty -> false (caller already guards)
+		{full, full + "x", false},                  // longer than full SHA
+		{"short", "shortish", false},               // revision longer than fullSHA
 	}
 	for _, c := range cases {
-		_, ok := parseBuildTime(c.in)
-		if ok != c.want {
-			t.Errorf("parseBuildTime(%q) ok=%v want %v", c.in, ok, c.want)
-		}
-	}
-}
-
-func TestNightlyRepublished(t *testing.T) {
-	built := "2026-05-04T23:10:16Z"
-	older := time.Date(2026, 5, 4, 22, 0, 0, 0, time.UTC)
-	newer := time.Date(2026, 5, 5, 6, 0, 0, 0, time.UTC)
-
-	cases := []struct {
-		name       string
-		rel        ghRelease
-		buildTime  string
-		want       bool
-	}{
-		{"prerelease republished after build", ghRelease{Prerelease: true, PublishedAt: newer}, built, true},
-		{"prerelease same/older than build", ghRelease{Prerelease: true, PublishedAt: older}, built, false},
-		{"stable release ignored", ghRelease{Prerelease: false, PublishedAt: newer}, built, false},
-		{"empty build time -> conservative false", ghRelease{Prerelease: true, PublishedAt: newer}, "", false},
-		{"unparseable build time -> false", ghRelease{Prerelease: true, PublishedAt: newer}, "garbage", false},
-	}
-	for _, c := range cases {
-		if got := nightlyRepublished(&c.rel, c.buildTime); got != c.want {
-			t.Errorf("%s: got %v want %v", c.name, got, c.want)
+		if got := shaMatchesRevision(c.fullSHA, c.revision); got != c.want {
+			t.Errorf("shaMatchesRevision(%q,%q)=%v want %v", c.fullSHA, c.revision, got, c.want)
 		}
 	}
 }

internal/web/handler_update.go

@@ -54,7 +54,7 @@ func (s *Server) UpdateCheck(c echo.Context) error {
 	}
 	ctx, cancel := context.WithTimeout(c.Request().Context(), 30*time.Second)
 	defer cancel()
-	res, err := updater.Check(ctx, channel, constant.Version, constant.BuildTime)
+	res, err := updater.Check(ctx, channel, constant.Version, constant.GitRevision)
 	if err != nil {
 		return echo.NewHTTPError(http.StatusBadGateway, err.Error())
 	}
@@ -105,7 +105,7 @@ func (s *Server) runUpdate(opts updater.ApplyOptions, job *JobStatus) {
 		*job = next
 	}
 
-	if err := updater.Apply(ctx, opts, constant.Version, constant.BuildTime, s.l, onState); err != nil {
+	if err := updater.Apply(ctx, opts, constant.Version, constant.GitRevision, s.l, onState); err != nil {
 		next := *job
 		next.State = updater.StateFailed
 		next.Error = err.Error()