afc8fd0 · crush · git.iko.soy

internal/app/app.go+19

compare with main

unifiedsplit

@@ -33,6 +33,8 @@ import (

33 "github.com/charmbracelet/crush/internal/term"

34 "github.com/charmbracelet/crush/internal/tui/components/anim"

35 "github.com/charmbracelet/crush/internal/tui/styles"

36+ "github.com/charmbracelet/crush/internal/update"

37+ "github.com/charmbracelet/crush/internal/version"

36 "github.com/charmbracelet/x/ansi"

38 "github.com/charmbracelet/x/ansi"

37 "github.com/charmbracelet/x/exp/charmtone"

39 "github.com/charmbracelet/x/exp/charmtone"

38)

40)

@@ -92,6 +94,9 @@ func New(ctx context.Context, conn *sql.DB, cfg *config.Config) (*App, error) {

92 // Initialize LSP clients in the background.

94 // Initialize LSP clients in the background.

93 app.initLSPClients(ctx)

95 app.initLSPClients(ctx)

94

96

97+ // Check for updates in the background.

98+ go app.checkForUpdates(ctx)

99+

95 go func() {

100 go func() {

96 slog.Info("Initializing MCP clients")

101 slog.Info("Initializing MCP clients")

97 mcp.Initialize(ctx, app.Permissions, cfg)

102 mcp.Initialize(ctx, app.Permissions, cfg)

@@ -390,3 +395,17 @@ func (app *App) Shutdown() {

390 }

395 }

391 }

396 }

392}

397}

398+

399+// checkForUpdates checks for available updates.

400+func (app *App) checkForUpdates(ctx context.Context) {

401+ checkCtx, cancel := context.WithTimeout(ctx, 30*time.Second)

402+ defer cancel()

403+ info, err := update.Check(checkCtx, version.Version, update.Default)

404+ if err != nil || !info.Available() {

405+ return

406+ }

407+ app.events <- pubsub.UpdateAvailableMsg{

408+ CurrentVersion: info.Current,

409+ LatestVersion: info.Latest,

410+ }

411+}

internal/pubsub/events.go+6

@@ -26,3 +26,9 @@ type (

26 Publish(EventType, T)

27 }

28)

29+

30+// UpdateAvailableMsg is sent when a new version is available.

31+type UpdateAvailableMsg struct {

32+ CurrentVersion string

33+ LatestVersion string

34+}

internal/tui/components/core/status/status.go+2−2

@@ -82,10 +82,10 @@ func (m *statusCmp) infoMsg() string {

82 info := ansi.Truncate(m.info.Msg, widthLeft, "…")

83 message = t.S().Base.Foreground(t.BgOverlay).Width(widthLeft+2).Background(t.Warning).Padding(0, 1).Render(info)

84 default:

85− infoType = t.S().Base.Foreground(t.BgOverlay).Background(t.Green).Padding(0, 1).Render("OKAY!")

85+ infoType = t.S().Base.Foreground(t.BgSubtle).Background(t.Green).Padding(0, 1).Bold(true).Render("HEY!")

86 widthLeft := m.width - (lipgloss.Width(infoType) + 2)

87 info := ansi.Truncate(m.info.Msg, widthLeft, "…")

88− message = t.S().Base.Background(t.Success).Width(widthLeft+2).Foreground(t.White).Padding(0, 1).Render(info)

88+ message = t.S().Base.Background(t.GreenDark).Width(widthLeft+2).Foreground(t.BgSubtle).Padding(0, 1).Render(info)

89 }

90 return ansi.Truncate(infoType+message, m.width, "…")

91}

internal/tui/tui.go+11

@@ -372,6 +372,17 @@ func (a *appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

372 cmds = append(cmds, pageCmd)

373 }

374 return a, tea.Batch(cmds...)

375+ // Update Available

376+ case pubsub.UpdateAvailableMsg:

377+ // Show update notification in status bar

378+ statusMsg := fmt.Sprintf("Crush update available: v%s → v%s.", msg.CurrentVersion, msg.LatestVersion)

379+ s, statusCmd := a.status.Update(util.InfoMsg{

380+ Type: util.InfoTypeInfo,

381+ Msg: statusMsg,

382+ TTL: 30 * time.Second,

383+ })

384+ a.status = s.(status.StatusCmp)

385+ return a, statusCmd

375 }

386 }

376 s, _ := a.status.Update(msg)

387 s, _ := a.status.Update(msg)

377 a.status = s.(status.StatusCmp)

388 a.status = s.(status.StatusCmp)

internal/tui/util/util.go+1

@@ -35,6 +35,7 @@ type InfoType int

35

36const (

37 InfoTypeInfo InfoType = iota

38+ InfoTypeSuccess

38 InfoTypeWarn

39 InfoTypeWarn

39 InfoTypeError

40 InfoTypeError

40)

41)

internal/update/update.gonew file+114

@@ -0,0 +1,114 @@

1+package update

2+

3+import (

4+ "context"

5+ "encoding/json"

6+ "fmt"

7+ "io"

8+ "net/http"

9+ "strings"

10+ "time"

11+)

12+

13+const (

14+ githubAPIURL = "https://api.github.com/repos/charmbracelet/crush/releases/latest"

15+ userAgent = "crush/1.0"

16+)

17+

18+// Default is the default [Client].

19+var Default Client = &github{}

20+

21+// Info contains information about an available update.

22+type Info struct {

23+ Current string

24+ Latest string

25+ URL string

26+}

27+

28+// Available returns true if there's an update available.

29+//

30+// If both current and latest are stable versions, returns true if versions are

31+// different.

32+// If current is a pre-release and latest isn't, returns true.

33+// If latest is a pre-release and current isn't, returns false.

34+func (i Info) Available() bool {

35+ cpr := strings.Contains(i.Current, "-")

36+ lpr := strings.Contains(i.Latest, "-")

37+ // current is pre release

38+ if cpr {

39+ // latest isn't a prerelease

40+ if !lpr {

41+ return true

42+ }

43+ }

44+ if lpr && !cpr {

45+ return false

46+ }

47+ return i.Current != i.Latest

48+}

49+

50+// Check checks if a new version is available.

51+func Check(ctx context.Context, current string, client Client) (Info, error) {

52+ info := Info{

53+ Current: current,

54+ Latest: current,

55+ }

56+

57+ if info.Current == "devel" || info.Current == "unknown" {

58+ return info, nil

59+ }

60+

61+ release, err := client.Latest(ctx)

62+ if err != nil {

63+ return info, fmt.Errorf("failed to fetch latest release: %w", err)

64+ }

65+

66+ info.Latest = strings.TrimPrefix(release.TagName, "v")

67+ info.URL = release.HTMLURL

68+ return info, nil

69+}

70+

71+// Release represents a GitHub release.

72+type Release struct {

73+ TagName string `json:"tag_name"`

74+ HTMLURL string `json:"html_url"`

75+}

76+

77+// Client is a client that can get the latest release.

78+type Client interface {

79+ Latest(ctx context.Context) (*Release, error)

80+}

81+

82+type github struct{}

83+

84+// Latest implements [Client].

85+func (c *github) Latest(ctx context.Context) (*Release, error) {

86+ client := &http.Client{

87+ Timeout: 30 * time.Second,

88+ }

89+

90+ req, err := http.NewRequestWithContext(ctx, "GET", githubAPIURL, nil)

91+ if err != nil {

92+ return nil, err

93+ }

94+ req.Header.Set("User-Agent", userAgent)

95+ req.Header.Set("Accept", "application/vnd.github.v3+json")

96+

97+ resp, err := client.Do(req)

98+ if err != nil {

99+ return nil, err

100+ }

101+ defer resp.Body.Close()

102+

103+ if resp.StatusCode != http.StatusOK {

104+ body, _ := io.ReadAll(resp.Body)

105+ return nil, fmt.Errorf("GitHub API returned status %d: %s", resp.StatusCode, string(body))

106+ }

107+

108+ var release Release

109+ if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {

110+ return nil, err

111+ }

112+

113+ return &release, nil

114+}

internal/update/update_test.gonew file+53

@@ -0,0 +1,53 @@

1+package update

2+

3+import (

4+ "context"

5+ "testing"

6+

7+ "github.com/stretchr/testify/require"

8+)

9+

10+func TestCheckForUpdate_DevelopmentVersion(t *testing.T) {

11+ info, err := Check(t.Context(), "unknown", testClient{"v0.11.0"})

12+ require.NoError(t, err)

13+ require.NotNil(t, info)

14+ require.False(t, info.Available())

15+}

16+

17+func TestCheckForUpdate_Old(t *testing.T) {

18+ info, err := Check(t.Context(), "v0.10.0", testClient{"v0.11.0"})

19+ require.NoError(t, err)

20+ require.NotNil(t, info)

21+ require.True(t, info.Available())

22+}

23+

24+func TestCheckForUpdate_Beta(t *testing.T) {

25+ t.Run("current is stable", func(t *testing.T) {

26+ info, err := Check(t.Context(), "v0.10.0", testClient{"v0.11.0-beta.1"})

27+ require.NoError(t, err)

28+ require.NotNil(t, info)

29+ require.False(t, info.Available())

30+ })

31+ t.Run("current is also beta", func(t *testing.T) {

32+ info, err := Check(t.Context(), "v0.11.0-beta.1", testClient{"v0.11.0-beta.2"})

33+ require.NoError(t, err)

34+ require.NotNil(t, info)

35+ require.True(t, info.Available())

36+ })

37+ t.Run("current is beta, latest isn't", func(t *testing.T) {

38+ info, err := Check(t.Context(), "v0.11.0-beta.1", testClient{"v0.11.0"})

39+ require.NoError(t, err)

40+ require.NotNil(t, info)

41+ require.True(t, info.Available())

42+ })

43+}

44+

45+type testClient struct{ tag string }

46+

47+// Latest implements Client.

48+func (t testClient) Latest(ctx context.Context) (*Release, error) {

49+ return &Release{

50+ TagName: t.tag,

51+ HTMLURL: "https://example.org",

52+ }, nil

53+}

internal/version/version.go+3−7

@@ -4,7 +4,7 @@ import "runtime/debug"

4

5// Build-time parameters set via -ldflags

6

7−var Version = "unknown"

7+var Version = "devel"

8

9// A user may install crush using `go install github.com/charmbracelet/crush@latest`.

10// without -ldflags, in which case the version above is unset. As a workaround

@@ -13,14 +13,10 @@ var Version = "unknown"

13func init() {

14 info, ok := debug.ReadBuildInfo()

15 if !ok {

16− // < go v1.18

17 return

16 return

18 }

17 }

19 mainVersion := info.Main.Version

18 mainVersion := info.Main.Version

20− if mainVersion == "" || mainVersion == "(devel)" {

19+ if mainVersion != "" && mainVersion != "(devel)" {

21− // bin not built using `go install`

20+ Version = mainVersion

22− return

23 }

21 }

24− // bin built using `go install`

25− Version = mainVersion

26}

22}