The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
Add explicit Beacon update check
Cursor Agentdd6fa5e29103
diff --git a/cli/beacon/cmd/root.go b/cli/beacon/cmd/root.goindex 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 anBeacon-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.godeleted file mode 100644index 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.godeleted file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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")+ }+}