Skip to content

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

Add explicit Beacon update check

Cursor Agentdd6fa5e29103
diff --git a/cli/beacon/cmd/root.go b/cli/beacon/cmd/root.go
index 1064a34b..28396d6d 100644
--- a/cli/beacon/cmd/root.go
+++ b/cli/beacon/cmd/root.go
@@ -18,9 +18,14 @@ local telemetry, and writes Wazuh-compatible JSON logs without requiring an
Beacon-hosted backend.`,
Version: version.GetVersion(),
Run: func(cmd *cobra.Command, args []string) {
- printBeaconIntro(cmd)
- cmd.SetOut(cmd.OutOrStdout())
- _ = cmd.Usage()
+ fmt.Println("Beacon Endpoint Agent")
+ fmt.Println()
+ fmt.Println("Start with:")
+ fmt.Println(" beacon endpoint install")
+ fmt.Println(" beacon endpoint status")
+ fmt.Println(" beacon endpoint wazuh print-config")
+ fmt.Println()
+ cmd.Usage()
},
}
diff --git a/cli/beacon/cmd/root_banner.go b/cli/beacon/cmd/root_banner.go
deleted file mode 100644
index c96d5c4a..00000000
--- a/cli/beacon/cmd/root_banner.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package cmd
-
-import (
- "fmt"
- "io"
- "os"
- "path/filepath"
- "strings"
- "time"
-
- "github.com/spf13/cobra"
-
- "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/version"
-)
-
-const beaconIntroDelay = 45 * time.Millisecond
-
-var sleepBeaconIntro = time.Sleep
-
-func printBeaconIntro(cmd *cobra.Command) {
- out := cmd.OutOrStdout()
- lines := beaconIntroLines()
- if shouldAnimateBeaconIntro(out) {
- for _, line := range lines {
- fmt.Fprintln(out, line)
- sleepBeaconIntro(beaconIntroDelay)
- }
- } else {
- for _, line := range lines {
- fmt.Fprintln(out, line)
- }
- }
- fmt.Fprintln(out)
- fmt.Fprintln(out, "Start with:")
- fmt.Fprintln(out, " beacon endpoint install")
- fmt.Fprintln(out, " beacon endpoint status")
- fmt.Fprintln(out, " beacon endpoint wazuh print-config")
- fmt.Fprintln(out)
-}
-
-func beaconIntroLines() []string {
- return []string{
- fmt.Sprintf(" ∞∞∞ ∞∞∞ Beacon CLI %s", version.GetVersion()),
- " ∞∞ ∞∞ ∞∞ ∞∞ Local AI runtime telemetry",
- " ∞∞ ∞ ∞∞ Endpoint visibility for agentic tools",
- fmt.Sprintf(" ∞∞ ∞∞ ∞∞ ∞∞ %s", compactWorkingDir()),
- " ∞∞∞ ∞∞∞",
- }
-}
-
-func compactWorkingDir() string {
- wd, err := os.Getwd()
- if err != nil || wd == "" {
- return "beacon endpoint"
- }
- home, err := os.UserHomeDir()
- if err == nil && home != "" {
- if rel, err := filepath.Rel(home, wd); err == nil && rel != "." && !strings.HasPrefix(rel, "..") {
- return filepath.Join("~", rel)
- }
- if wd == home {
- return "~"
- }
- }
- return wd
-}
-
-func shouldAnimateBeaconIntro(out io.Writer) bool {
- if os.Getenv("BEACON_NO_ANIMATION") != "" || os.Getenv("CI") != "" || os.Getenv("TERM") == "dumb" {
- return false
- }
- file, ok := out.(*os.File)
- if !ok {
- return false
- }
- info, err := file.Stat()
- if err != nil {
- return false
- }
- return info.Mode()&os.ModeCharDevice != 0
-}
diff --git a/cli/beacon/cmd/root_banner_test.go b/cli/beacon/cmd/root_banner_test.go
deleted file mode 100644
index 2282efd5..00000000
--- a/cli/beacon/cmd/root_banner_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package cmd
-
-import (
- "bytes"
- "strings"
- "testing"
-
- "github.com/spf13/cobra"
-)
-
-func TestBeaconIntroLinesUseInfinityMark(t *testing.T) {
- lines := beaconIntroLines()
- if len(lines) == 0 {
- t.Fatal("beaconIntroLines returned no lines")
- }
- got := strings.Join(lines, "\n")
- if !strings.Contains(got, "∞") {
- t.Fatalf("beaconIntroLines() = %q, want infinity mark", got)
- }
- if !strings.Contains(got, "Beacon CLI") {
- t.Fatalf("beaconIntroLines() = %q, want Beacon CLI label", got)
- }
-}
-
-func TestPrintBeaconIntroIncludesStartingCommands(t *testing.T) {
- var out bytes.Buffer
- cmd := &cobra.Command{}
- cmd.SetOut(&out)
-
- printBeaconIntro(cmd)
-
- got := out.String()
- for _, want := range []string{
- "∞",
- "Beacon CLI",
- "beacon endpoint install",
- "beacon endpoint status",
- "beacon endpoint wazuh print-config",
- } {
- if !strings.Contains(got, want) {
- t.Fatalf("printBeaconIntro output missing %q:\n%s", want, got)
- }
- }
-}
-
-func TestShouldAnimateBeaconIntroFalseForNonFileWriter(t *testing.T) {
- var out bytes.Buffer
- if shouldAnimateBeaconIntro(&out) {
- t.Fatal("shouldAnimateBeaconIntro returned true for non-file writer")
- }
-}
diff --git a/cli/beacon/cmd/update.go b/cli/beacon/cmd/update.go
new file mode 100644
index 00000000..50a306b9
--- /dev/null
+++ b/cli/beacon/cmd/update.go
@@ -0,0 +1,63 @@
+package cmd
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/spf13/cobra"
+
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/updatecheck"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/version"
+)
+
+type updateChecker interface {
+ Check(context.Context) (updatecheck.Result, error)
+}
+
+var (
+ newUpdateChecker = func(currentVersion string) updateChecker {
+ return updatecheck.DefaultChecker(currentVersion)
+ }
+ updateCheckTimeout = 2 * time.Second
+)
+
+var updateCmd = &cobra.Command{
+ Use: "update",
+ Short: "Check for Beacon CLI updates",
+}
+
+var updateCheckCmd = &cobra.Command{
+ Use: "check",
+ Short: "Check whether a newer Beacon CLI release is available",
+ SilenceUsage: true,
+ RunE: runUpdateCheck,
+}
+
+func runUpdateCheck(cmd *cobra.Command, args []string) error {
+ ctx, cancel := context.WithTimeout(cmd.Context(), updateCheckTimeout)
+ defer cancel()
+
+ result, err := newUpdateChecker(version.GetVersion()).Check(ctx)
+ if err != nil {
+ return fmt.Errorf("unable to check for Beacon updates: %w", err)
+ }
+
+ out := cmd.OutOrStdout()
+ if result.CurrentIsDev {
+ fmt.Fprintln(out, "Beacon dev build: update checks require a released version.")
+ 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")
+ return nil
+ }
+ fmt.Fprintf(out, "Beacon %s is up to date.\n", result.CurrentVersion)
+ return nil
+}
+
+func init() {
+ updateCmd.AddCommand(updateCheckCmd)
+ rootCmd.AddCommand(updateCmd)
+}
diff --git a/cli/beacon/cmd/update_test.go b/cli/beacon/cmd/update_test.go
new file mode 100644
index 00000000..8ef16649
--- /dev/null
+++ b/cli/beacon/cmd/update_test.go
@@ -0,0 +1,122 @@
+package cmd
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "strings"
+ "testing"
+
+ "github.com/spf13/cobra"
+
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/updatecheck"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/version"
+)
+
+type stubUpdateChecker struct {
+ result updatecheck.Result
+ err error
+}
+
+func (c stubUpdateChecker) Check(context.Context) (updatecheck.Result, error) {
+ if c.err != nil {
+ return updatecheck.Result{}, c.err
+ }
+ return c.result, nil
+}
+
+func TestUpdateCheckCommandRegistered(t *testing.T) {
+ cmd, _, err := rootCmd.Find([]string{"update", "check"})
+ if err != nil {
+ t.Fatalf("Find update check returned error: %v", err)
+ }
+ if cmd == nil || cmd.Use != "check" {
+ t.Fatalf("update check command not registered: %#v", cmd)
+ }
+}
+
+func TestRunUpdateCheckReportsUpToDate(t *testing.T) {
+ got := runUpdateCheckWithStub(t, "v0.0.10", stubUpdateChecker{
+ result: updatecheck.Result{CurrentVersion: "v0.0.10", LatestVersion: "v0.0.10"},
+ })
+ if !strings.Contains(got, "Beacon v0.0.10 is up to date.") {
+ t.Fatalf("output = %q, want up-to-date message", got)
+ }
+}
+
+func TestRunUpdateCheckReportsAvailableUpdate(t *testing.T) {
+ got := runUpdateCheckWithStub(t, "v0.0.10", stubUpdateChecker{
+ result: updatecheck.Result{
+ CurrentVersion: "v0.0.10",
+ LatestVersion: "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",
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("output = %q, want %q", got, want)
+ }
+ }
+}
+
+func TestRunUpdateCheckReportsDevBuild(t *testing.T) {
+ got := runUpdateCheckWithStub(t, "dev", stubUpdateChecker{
+ result: updatecheck.Result{CurrentVersion: "dev", CurrentIsDev: true},
+ })
+ if !strings.Contains(got, "Beacon dev build: update checks require a released version.") {
+ t.Fatalf("output = %q, want dev-build message", got)
+ }
+}
+
+func TestRunUpdateCheckReturnsFriendlyError(t *testing.T) {
+ restoreVersion := setVersionForTest(t, "v0.0.10")
+ defer restoreVersion()
+ restoreChecker := setUpdateCheckerForTest(t, stubUpdateChecker{err: errors.New("rate limited")})
+ defer restoreChecker()
+
+ cmd := &cobra.Command{}
+ var out bytes.Buffer
+ cmd.SetOut(&out)
+ err := runUpdateCheck(cmd, nil)
+ if err == nil {
+ t.Fatal("runUpdateCheck error = nil, want error")
+ }
+ if !strings.Contains(err.Error(), "unable to check for Beacon updates") {
+ t.Fatalf("error = %v, want friendly update error", err)
+ }
+}
+
+func runUpdateCheckWithStub(t *testing.T, current string, checker stubUpdateChecker) string {
+ t.Helper()
+ restoreVersion := setVersionForTest(t, current)
+ defer restoreVersion()
+ restoreChecker := setUpdateCheckerForTest(t, checker)
+ defer restoreChecker()
+
+ cmd := &cobra.Command{}
+ var out bytes.Buffer
+ cmd.SetOut(&out)
+ if err := runUpdateCheck(cmd, nil); err != nil {
+ t.Fatalf("runUpdateCheck returned error: %v", err)
+ }
+ return out.String()
+}
+
+func setVersionForTest(t *testing.T, v string) func() {
+ t.Helper()
+ old := version.Version
+ version.Version = v
+ return func() { version.Version = old }
+}
+
+func setUpdateCheckerForTest(t *testing.T, checker updateChecker) func() {
+ t.Helper()
+ old := newUpdateChecker
+ newUpdateChecker = func(currentVersion string) updateChecker {
+ return checker
+ }
+ return func() { newUpdateChecker = old }
+}
diff --git a/cli/beacon/internal/updatecheck/cache.go b/cli/beacon/internal/updatecheck/cache.go
new file mode 100644
index 00000000..b5114354
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/cache.go
@@ -0,0 +1,104 @@
+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
new file mode 100644
index 00000000..f9f25c47
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/cache_test.go
@@ -0,0 +1,63 @@
+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
new file mode 100644
index 00000000..c36f5b8f
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/checker.go
@@ -0,0 +1,83 @@
+package updatecheck
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net/http"
+ "time"
+)
+
+var ErrUncomparableVersion = errors.New("latest release version could not be compared")
+
+// Result describes the outcome of an update check.
+type Result struct {
+ CurrentVersion string
+ LatestVersion string
+ ReleaseURL string
+ UpdateAvailable bool
+ CurrentIsDev bool
+ FromCache 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) {
+ result.CurrentIsDev = true
+ return result, nil
+ }
+
+ release, fromCache, err := c.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 {
+ return result, fmt.Errorf("%w: %q", ErrUncomparableVersion, release.Version)
+ }
+ 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
new file mode 100644
index 00000000..fa50bd07
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/checker_test.go
@@ -0,0 +1,124 @@
+package updatecheck
+
+import (
+ "context"
+ "errors"
+ "os"
+ "path/filepath"
+ "testing"
+ "time"
+)
+
+type fakeSource struct {
+ release Release
+ err error
+ calls int
+}
+
+func (s *fakeSource) Latest(context.Context) (Release, error) {
+ s.calls++
+ if s.err != nil {
+ return Release{}, s.err
+ }
+ 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) }
+ source := &fakeSource{release: Release{Version: "v0.0.12"}}
+ 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 fetched 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}
+
+ 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 source.calls != 1 {
+ t.Fatalf("source calls = %d, want 1", source.calls)
+ }
+}
+
+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.CurrentIsDev {
+ t.Fatalf("CurrentIsDev = false, want true")
+ }
+ if source.calls != 0 {
+ t.Fatalf("source calls = %d, want 0", source.calls)
+ }
+}
+
+func TestCheckerReturnsUncomparableVersionError(t *testing.T) {
+ checker := &Checker{
+ CurrentVersion: "v0.0.10",
+ Source: &fakeSource{release: Release{Version: "latest"}},
+ }
+
+ _, err := checker.Check(context.Background())
+ if !errors.Is(err, ErrUncomparableVersion) {
+ t.Fatalf("Check error = %v, want ErrUncomparableVersion", err)
+ }
+}
diff --git a/cli/beacon/internal/updatecheck/compare.go b/cli/beacon/internal/updatecheck/compare.go
new file mode 100644
index 00000000..4f630713
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/compare.go
@@ -0,0 +1,85 @@
+package updatecheck
+
+import (
+ "strconv"
+ "strings"
+)
+
+type releaseVersion struct {
+ major int
+ minor int
+ patch int
+}
+
+func normalizeVersion(v string) string {
+ v = strings.TrimSpace(v)
+ v = strings.TrimPrefix(v, "v")
+ return v
+}
+
+func displayVersion(v string) string {
+ trimmed := strings.TrimSpace(v)
+ if trimmed == "" {
+ return ""
+ }
+ normalized := normalizeVersion(trimmed)
+ if _, ok := parseReleaseVersion(normalized); !ok {
+ return trimmed
+ }
+ return "v" + normalized
+}
+
+func parseReleaseVersion(v string) (releaseVersion, bool) {
+ v = normalizeVersion(v)
+ parts := strings.Split(v, ".")
+ if len(parts) != 3 {
+ return releaseVersion{}, false
+ }
+ var parsed [3]int
+ for i, part := range parts {
+ if part == "" {
+ return releaseVersion{}, false
+ }
+ for _, r := range part {
+ if r < '0' || r > '9' {
+ return releaseVersion{}, false
+ }
+ }
+ n, err := strconv.Atoi(part)
+ if err != nil {
+ return releaseVersion{}, false
+ }
+ parsed[i] = n
+ }
+ return releaseVersion{major: parsed[0], minor: parsed[1], patch: parsed[2]}, true
+}
+
+func compareVersions(current, latest string) (int, bool) {
+ cur, ok := parseReleaseVersion(current)
+ if !ok {
+ return 0, false
+ }
+ next, ok := parseReleaseVersion(latest)
+ if !ok {
+ return 0, false
+ }
+ switch {
+ case cur.major != next.major:
+ return compareInts(cur.major, next.major), true
+ case cur.minor != next.minor:
+ return compareInts(cur.minor, next.minor), true
+ default:
+ return compareInts(cur.patch, next.patch), true
+ }
+}
+
+func compareInts(a, b int) int {
+ switch {
+ case a < b:
+ return -1
+ case a > b:
+ return 1
+ default:
+ return 0
+ }
+}
diff --git a/cli/beacon/internal/updatecheck/compare_test.go b/cli/beacon/internal/updatecheck/compare_test.go
new file mode 100644
index 00000000..32278a85
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/compare_test.go
@@ -0,0 +1,50 @@
+package updatecheck
+
+import "testing"
+
+func TestCompareVersions(t *testing.T) {
+ tests := []struct {
+ name string
+ current string
+ latest string
+ want int
+ wantOK bool
+ }{
+ {name: "latest newer", current: "v0.0.10", latest: "v0.0.12", want: -1, wantOK: true},
+ {name: "equal with optional v", current: "0.0.12", latest: "v0.0.12", want: 0, wantOK: true},
+ {name: "current newer", current: "v0.1.0", latest: "v0.0.12", want: 1, wantOK: true},
+ {name: "prerelease unsupported", current: "v0.0.10", latest: "v0.0.12-beta.1", wantOK: false},
+ {name: "dev unsupported", current: "dev", latest: "v0.0.12", wantOK: false},
+ {name: "unparsable unsupported", current: "v0.0.10", latest: "latest", wantOK: false},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, ok := compareVersions(tt.current, tt.latest)
+ if ok != tt.wantOK {
+ t.Fatalf("compareVersions ok = %v, want %v", ok, tt.wantOK)
+ }
+ if got != tt.want {
+ t.Fatalf("compareVersions = %d, want %d", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestCanCheckVersion(t *testing.T) {
+ tests := []struct {
+ version string
+ want bool
+ }{
+ {version: "v0.0.12", want: true},
+ {version: "0.0.12", want: true},
+ {version: "dev", want: false},
+ {version: "", want: false},
+ {version: "v0.0.12-beta.1", want: false},
+ }
+ for _, tt := range tests {
+ if got := CanCheckVersion(tt.version); got != tt.want {
+ t.Fatalf("CanCheckVersion(%q) = %v, want %v", tt.version, got, tt.want)
+ }
+ }
+}
diff --git a/cli/beacon/internal/updatecheck/policy.go b/cli/beacon/internal/updatecheck/policy.go
new file mode 100644
index 00000000..cf4728d3
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/policy.go
@@ -0,0 +1,13 @@
+package updatecheck
+
+import "strings"
+
+// CanCheckVersion reports whether a build version can be compared to releases.
+func CanCheckVersion(v string) bool {
+ v = strings.TrimSpace(v)
+ if v == "" || v == "dev" {
+ return false
+ }
+ _, ok := parseReleaseVersion(v)
+ return ok
+}
diff --git a/cli/beacon/internal/updatecheck/source.go b/cli/beacon/internal/updatecheck/source.go
new file mode 100644
index 00000000..e7cdc950
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/source.go
@@ -0,0 +1,67 @@
+package updatecheck
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+)
+
+const DefaultLatestReleaseURL = "https://api.github.com/repos/asymptote-labs/agent-beacon/releases/latest"
+
+// Release is the latest Beacon release known to an update source.
+type Release struct {
+ Version string
+ URL string
+}
+
+// Source returns the latest available Beacon release.
+type Source interface {
+ Latest(context.Context) (Release, error)
+}
+
+// GitHubSource reads release metadata from GitHub's latest-release endpoint.
+type GitHubSource struct {
+ Client *http.Client
+ Endpoint string
+}
+
+func (s GitHubSource) Latest(ctx context.Context) (Release, error) {
+ endpoint := s.Endpoint
+ if endpoint == "" {
+ endpoint = DefaultLatestReleaseURL
+ }
+ client := s.Client
+ if client == nil {
+ client = http.DefaultClient
+ }
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+ if err != nil {
+ return Release{}, err
+ }
+ req.Header.Set("Accept", "application/vnd.github+json")
+ req.Header.Set("User-Agent", "beacon-update-check")
+
+ resp, err := client.Do(req)
+ if err != nil {
+ return Release{}, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return Release{}, fmt.Errorf("release lookup returned HTTP %d", resp.StatusCode)
+ }
+
+ var payload struct {
+ TagName string `json:"tag_name"`
+ HTMLURL string `json:"html_url"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+ return Release{}, err
+ }
+ if payload.TagName == "" {
+ return Release{}, fmt.Errorf("release lookup did not include tag_name")
+ }
+ return Release{Version: payload.TagName, URL: payload.HTMLURL}, nil
+}
diff --git a/cli/beacon/internal/updatecheck/source_test.go b/cli/beacon/internal/updatecheck/source_test.go
new file mode 100644
index 00000000..3fe334c4
--- /dev/null
+++ b/cli/beacon/internal/updatecheck/source_test.go
@@ -0,0 +1,47 @@
+package updatecheck
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestGitHubSourceLatestParsesRelease(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprint(w, `{"tag_name":"v0.0.12","html_url":"https://example.test/release"}`)
+ }))
+ defer server.Close()
+
+ got, err := (GitHubSource{Client: server.Client(), Endpoint: server.URL}).Latest(context.Background())
+ if err != nil {
+ t.Fatalf("Latest returned error: %v", err)
+ }
+ want := Release{Version: "v0.0.12", URL: "https://example.test/release"}
+ if got != want {
+ t.Fatalf("Latest = %#v, want %#v", got, want)
+ }
+}
+
+func TestGitHubSourceLatestHandlesNonOK(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ http.Error(w, "rate limited", http.StatusTooManyRequests)
+ }))
+ defer server.Close()
+
+ if _, err := (GitHubSource{Client: server.Client(), Endpoint: server.URL}).Latest(context.Background()); err == nil {
+ t.Fatal("Latest error = nil, want non-200 error")
+ }
+}
+
+func TestGitHubSourceLatestHandlesMalformedJSON(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprint(w, `{bad-json`)
+ }))
+ defer server.Close()
+
+ if _, err := (GitHubSource{Client: server.Client(), Endpoint: server.URL}).Latest(context.Background()); err == nil {
+ t.Fatal("Latest error = nil, want JSON error")
+ }
+}