Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

Simplify explicit update checks

Cursor Agent71463be11ae0
diff --git a/cli/beacon/cmd/update.go b/cli/beacon/cmd/update.go
index 9a38ad3f..84ebb68d 100644
--- a/cli/beacon/cmd/update.go
+++ b/cli/beacon/cmd/update.go
@@ -52,9 +52,16 @@ func runUpdateCheck(cmd *cobra.Command, args []string) error {
fmt.Fprintln(out, "Beacon dev build: update checks require a released version.")
return nil
}
+ if result.UnsupportedCurrentVersion {
+ fmt.Fprintf(out, "Beacon version %q cannot be compared to released versions.\n", result.CurrentVersion)
+ return nil
+ }
if result.UpdateAvailable {
fmt.Fprintf(out, "Beacon %s is available. Current version: %s\n", result.LatestVersion, result.CurrentVersion)
- fmt.Fprintln(out, "Upgrade with: brew upgrade beacon")
+ fmt.Fprintln(out, "Upgrade with Homebrew: brew upgrade beacon")
+ if result.ReleaseURL != "" {
+ fmt.Fprintf(out, "Download: %s\n", result.ReleaseURL)
+ }
return nil
}
fmt.Fprintf(out, "Beacon %s is up to date.\n", result.CurrentVersion)
diff --git a/cli/beacon/cmd/update_test.go b/cli/beacon/cmd/update_test.go
index 8ef16649..99143390 100644
--- a/cli/beacon/cmd/update_test.go
+++ b/cli/beacon/cmd/update_test.go
@@ -49,12 +49,14 @@ func TestRunUpdateCheckReportsAvailableUpdate(t *testing.T) {
result: updatecheck.Result{
CurrentVersion: "v0.0.10",
LatestVersion: "v0.0.12",
+ ReleaseURL: "https://example.test/releases/v0.0.12",
UpdateAvailable: true,
},
})
for _, want := range []string{
"Beacon v0.0.12 is available. Current version: v0.0.10",
- "Upgrade with: brew upgrade beacon",
+ "Upgrade with Homebrew: brew upgrade beacon",
+ "Download: https://example.test/releases/v0.0.12",
} {
if !strings.Contains(got, want) {
t.Fatalf("output = %q, want %q", got, want)
@@ -71,6 +73,15 @@ func TestRunUpdateCheckReportsDevBuild(t *testing.T) {
}
}
+func TestRunUpdateCheckReportsUnsupportedCurrentVersion(t *testing.T) {
+ got := runUpdateCheckWithStub(t, "v0.0.12+local", stubUpdateChecker{
+ result: updatecheck.Result{CurrentVersion: "v0.0.12+local", UnsupportedCurrentVersion: true},
+ })
+ if !strings.Contains(got, `Beacon version "v0.0.12+local" cannot be compared to released versions.`) {
+ t.Fatalf("output = %q, want unsupported-version message", got)
+ }
+}
+
func TestRunUpdateCheckReturnsFriendlyError(t *testing.T) {
restoreVersion := setVersionForTest(t, "v0.0.10")
defer restoreVersion()
diff --git a/cli/beacon/internal/updatecheck/cache.go b/cli/beacon/internal/updatecheck/cache.go
deleted file mode 100644
index b5114354..00000000
--- a/cli/beacon/internal/updatecheck/cache.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package updatecheck
-
-import (
- "encoding/json"
- "os"
- "path/filepath"
- "time"
-)
-
-const DefaultCacheTTL = 24 * time.Hour
-
-// Cache stores the most recently observed latest release.
-type Cache struct {
- Path string
- TTL time.Duration
- Now func() time.Time
-}
-
-type cacheEntry struct {
- CheckedAt time.Time `json:"checked_at"`
- LatestVersion string `json:"latest_version"`
- ReleaseURL string `json:"release_url"`
-}
-
-func DefaultCache() (*Cache, error) {
- base, err := os.UserCacheDir()
- if err != nil {
- return nil, err
- }
- return &Cache{
- Path: filepath.Join(base, "beacon", "update-check.json"),
- TTL: DefaultCacheTTL,
- Now: time.Now,
- }, nil
-}
-
-func (c *Cache) LoadFresh() (Release, bool, error) {
- if c == nil || c.Path == "" {
- return Release{}, false, nil
- }
- data, err := os.ReadFile(c.Path)
- if err != nil {
- if os.IsNotExist(err) {
- return Release{}, false, nil
- }
- return Release{}, false, err
- }
- var entry cacheEntry
- if err := json.Unmarshal(data, &entry); err != nil {
- return Release{}, false, err
- }
- if entry.LatestVersion == "" {
- return Release{}, false, nil
- }
- ttl := c.TTL
- if ttl <= 0 {
- ttl = DefaultCacheTTL
- }
- now := time.Now
- if c.Now != nil {
- now = c.Now
- }
- if now().Sub(entry.CheckedAt) > ttl {
- return Release{}, false, nil
- }
- return Release{Version: entry.LatestVersion, URL: entry.ReleaseURL}, true, nil
-}
-
-func (c *Cache) Store(release Release) error {
- if c == nil || c.Path == "" || release.Version == "" {
- return nil
- }
- now := time.Now
- if c.Now != nil {
- now = c.Now
- }
- entry := cacheEntry{
- CheckedAt: now().UTC(),
- LatestVersion: release.Version,
- ReleaseURL: release.URL,
- }
- data, err := json.MarshalIndent(entry, "", " ")
- if err != nil {
- return err
- }
- dir := filepath.Dir(c.Path)
- if err := os.MkdirAll(dir, 0755); err != nil {
- return err
- }
- tmp, err := os.CreateTemp(dir, ".update-check-*.json")
- if err != nil {
- return err
- }
- tmpPath := tmp.Name()
- defer os.Remove(tmpPath)
- if _, err := tmp.Write(data); err != nil {
- _ = tmp.Close()
- return err
- }
- if err := tmp.Close(); err != nil {
- return err
- }
- return os.Rename(tmpPath, c.Path)
-}
diff --git a/cli/beacon/internal/updatecheck/cache_test.go b/cli/beacon/internal/updatecheck/cache_test.go
deleted file mode 100644
index f9f25c47..00000000
--- a/cli/beacon/internal/updatecheck/cache_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package updatecheck
-
-import (
- "os"
- "path/filepath"
- "testing"
- "time"
-)
-
-func TestCacheLoadFresh(t *testing.T) {
- now := time.Date(2026, 5, 31, 22, 0, 0, 0, time.UTC)
- cache := &Cache{
- Path: filepath.Join(t.TempDir(), "update-check.json"),
- TTL: 24 * time.Hour,
- Now: func() time.Time { return now },
- }
- release := Release{Version: "v0.0.12", URL: "https://example.test/release"}
- if err := cache.Store(release); err != nil {
- t.Fatalf("Store returned error: %v", err)
- }
-
- got, ok, err := cache.LoadFresh()
- if err != nil {
- t.Fatalf("LoadFresh returned error: %v", err)
- }
- if !ok {
- t.Fatal("LoadFresh ok = false, want true")
- }
- if got != release {
- t.Fatalf("LoadFresh = %#v, want %#v", got, release)
- }
-}
-
-func TestCacheLoadFreshReturnsFalseForStaleEntry(t *testing.T) {
- base := time.Date(2026, 5, 31, 22, 0, 0, 0, time.UTC)
- cache := &Cache{
- Path: filepath.Join(t.TempDir(), "update-check.json"),
- TTL: time.Hour,
- Now: func() time.Time { return base },
- }
- if err := cache.Store(Release{Version: "v0.0.12"}); err != nil {
- t.Fatalf("Store returned error: %v", err)
- }
- cache.Now = func() time.Time { return base.Add(2 * time.Hour) }
-
- if _, ok, err := cache.LoadFresh(); err != nil {
- t.Fatalf("LoadFresh returned error: %v", err)
- } else if ok {
- t.Fatal("LoadFresh ok = true, want false for stale entry")
- }
-}
-
-func TestCacheLoadFreshReturnsErrorForCorruptEntry(t *testing.T) {
- path := filepath.Join(t.TempDir(), "update-check.json")
- if err := os.WriteFile(path, []byte("{not-json"), 0644); err != nil {
- t.Fatalf("WriteFile returned error: %v", err)
- }
- cache := &Cache{Path: path, TTL: time.Hour}
-
- if _, _, err := cache.LoadFresh(); err == nil {
- t.Fatal("LoadFresh error = nil, want corrupt cache error")
- }
-}
diff --git a/cli/beacon/internal/updatecheck/checker.go b/cli/beacon/internal/updatecheck/checker.go
index c36f5b8f..17b657a2 100644
--- a/cli/beacon/internal/updatecheck/checker.go
+++ b/cli/beacon/internal/updatecheck/checker.go
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"net/http"
+ "strings"
"time"
)
@@ -12,47 +13,51 @@ var ErrUncomparableVersion = errors.New("latest release version could not be com
// Result describes the outcome of an update check.
type Result struct {
- CurrentVersion string
- LatestVersion string
- ReleaseURL string
- UpdateAvailable bool
- CurrentIsDev bool
- FromCache bool
+ CurrentVersion string
+ LatestVersion string
+ ReleaseURL string
+ UpdateAvailable bool
+ CurrentIsDev bool
+ UnsupportedCurrentVersion bool
}
// Checker checks whether a newer Beacon release is available.
type Checker struct {
CurrentVersion string
Source Source
- Cache *Cache
}
func DefaultChecker(currentVersion string) *Checker {
- cache, _ := DefaultCache()
return &Checker{
CurrentVersion: currentVersion,
Source: GitHubSource{
Client: &http.Client{Timeout: 1500 * time.Millisecond},
},
- Cache: cache,
}
}
func (c *Checker) Check(ctx context.Context) (Result, error) {
current := c.CurrentVersion
result := Result{CurrentVersion: displayVersion(current)}
- if !CanCheckVersion(current) {
+ if strings.TrimSpace(current) == "dev" {
result.CurrentIsDev = true
return result, nil
}
+ if !CanCheckVersion(current) {
+ result.UnsupportedCurrentVersion = true
+ return result, nil
+ }
- release, fromCache, err := c.latest(ctx)
+ source := c.Source
+ if source == nil {
+ source = GitHubSource{}
+ }
+ release, err := source.Latest(ctx)
if err != nil {
return result, err
}
result.LatestVersion = displayVersion(release.Version)
result.ReleaseURL = release.URL
- result.FromCache = fromCache
cmp, ok := compareVersions(current, release.Version)
if !ok {
@@ -61,23 +66,3 @@ func (c *Checker) Check(ctx context.Context) (Result, error) {
result.UpdateAvailable = cmp < 0
return result, nil
}
-
-func (c *Checker) latest(ctx context.Context) (Release, bool, error) {
- if c.Cache != nil {
- if release, ok, err := c.Cache.LoadFresh(); err == nil && ok {
- return release, true, nil
- }
- }
- source := c.Source
- if source == nil {
- source = GitHubSource{}
- }
- release, err := source.Latest(ctx)
- if err != nil {
- return Release{}, false, err
- }
- if c.Cache != nil {
- _ = c.Cache.Store(release)
- }
- return release, false, nil
-}
diff --git a/cli/beacon/internal/updatecheck/checker_test.go b/cli/beacon/internal/updatecheck/checker_test.go
index fa50bd07..ade4d66e 100644
--- a/cli/beacon/internal/updatecheck/checker_test.go
+++ b/cli/beacon/internal/updatecheck/checker_test.go
@@ -3,10 +3,7 @@ package updatecheck
import (
"context"
"errors"
- "os"
- "path/filepath"
"testing"
- "time"
)
type fakeSource struct {
@@ -23,88 +20,48 @@ func (s *fakeSource) Latest(context.Context) (Release, error) {
return s.release, nil
}
-func TestCheckerUsesFreshCache(t *testing.T) {
- now := time.Date(2026, 5, 31, 22, 0, 0, 0, time.UTC)
- cache := &Cache{
- Path: filepath.Join(t.TempDir(), "update-check.json"),
- TTL: 24 * time.Hour,
- Now: func() time.Time { return now },
- }
- if err := cache.Store(Release{Version: "v0.0.12"}); err != nil {
- t.Fatalf("Store returned error: %v", err)
- }
- source := &fakeSource{release: Release{Version: "v0.0.13"}}
- checker := &Checker{CurrentVersion: "v0.0.10", Source: source, Cache: cache}
-
- got, err := checker.Check(context.Background())
- if err != nil {
- t.Fatalf("Check returned error: %v", err)
- }
- if !got.UpdateAvailable || got.LatestVersion != "v0.0.12" || !got.FromCache {
- t.Fatalf("Check = %#v, want cached available update", got)
- }
- if source.calls != 0 {
- t.Fatalf("source calls = %d, want 0", source.calls)
- }
-}
-
-func TestCheckerFetchesWhenCacheIsStale(t *testing.T) {
- base := time.Date(2026, 5, 31, 22, 0, 0, 0, time.UTC)
- cache := &Cache{
- Path: filepath.Join(t.TempDir(), "update-check.json"),
- TTL: time.Hour,
- Now: func() time.Time { return base },
- }
- if err := cache.Store(Release{Version: "v0.0.11"}); err != nil {
- t.Fatalf("Store returned error: %v", err)
- }
- cache.Now = func() time.Time { return base.Add(2 * time.Hour) }
+func TestCheckerFetchesLatestRelease(t *testing.T) {
source := &fakeSource{release: Release{Version: "v0.0.12"}}
- checker := &Checker{CurrentVersion: "v0.0.10", Source: source, Cache: cache}
+ checker := &Checker{CurrentVersion: "v0.0.10", Source: source}
got, err := checker.Check(context.Background())
if err != nil {
t.Fatalf("Check returned error: %v", err)
}
- if !got.UpdateAvailable || got.LatestVersion != "v0.0.12" || got.FromCache {
- t.Fatalf("Check = %#v, want fetched available update", got)
+ if !got.UpdateAvailable || got.LatestVersion != "v0.0.12" {
+ t.Fatalf("Check = %#v, want available update", got)
}
if source.calls != 1 {
t.Fatalf("source calls = %d, want 1", source.calls)
}
}
-func TestCheckerIgnoresCorruptCacheAndFetches(t *testing.T) {
- path := filepath.Join(t.TempDir(), "update-check.json")
- if err := os.WriteFile(path, []byte("{bad-json"), 0644); err != nil {
- t.Fatalf("WriteFile returned error: %v", err)
- }
- cache := &Cache{Path: path}
- source := &fakeSource{release: Release{Version: "v0.0.10"}}
- checker := &Checker{CurrentVersion: "v0.0.10", Source: source, Cache: cache}
+func TestCheckerReturnsDevResultWithoutSourceLookup(t *testing.T) {
+ source := &fakeSource{release: Release{Version: "v0.0.12"}}
+ checker := &Checker{CurrentVersion: "dev", Source: source}
got, err := checker.Check(context.Background())
if err != nil {
t.Fatalf("Check returned error: %v", err)
}
- if got.UpdateAvailable {
- t.Fatalf("Check UpdateAvailable = true, want false")
+ if !got.CurrentIsDev {
+ t.Fatalf("CurrentIsDev = false, want true")
}
- if source.calls != 1 {
- t.Fatalf("source calls = %d, want 1", source.calls)
+ if source.calls != 0 {
+ t.Fatalf("source calls = %d, want 0", source.calls)
}
}
-func TestCheckerReturnsDevResultWithoutSourceLookup(t *testing.T) {
+func TestCheckerReturnsUnsupportedCurrentVersionWithoutSourceLookup(t *testing.T) {
source := &fakeSource{release: Release{Version: "v0.0.12"}}
- checker := &Checker{CurrentVersion: "dev", Source: source}
+ checker := &Checker{CurrentVersion: "v0.0.12+local", Source: source}
got, err := checker.Check(context.Background())
if err != nil {
t.Fatalf("Check returned error: %v", err)
}
- if !got.CurrentIsDev {
- t.Fatalf("CurrentIsDev = false, want true")
+ if !got.UnsupportedCurrentVersion || got.CurrentIsDev {
+ t.Fatalf("Check = %#v, want unsupported non-dev version", got)
}
if source.calls != 0 {
t.Fatalf("source calls = %d, want 0", source.calls)