Files
lazygit/pkg/updates/updates.go
Stefan HallerandClaude Opus 5.5 2d58a327ec Install updates without asking if update.method is "background"
The option "background" exists, but since the background check never
ran, it never did anything.

If lazygit can update itself, i.e. it was installed from one of our
release archives into a folder that we can write to, install a new
version as soon as a check finds it. The new version takes effect the
next time the user starts lazygit; until then, the note in the
bottom-right corner says so. If installing fails, we try again in an
hour, and the user gets the usual reminders in the meantime.

For all other installs, "background" works like "prompt".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 16:11:57 +01:00

406 lines
12 KiB
Go

package updates
import (
"context"
"errors"
"net/http"
"os"
"path/filepath"
"runtime"
"sync"
"sync/atomic"
"time"
"github.com/jesseduffield/lazygit/pkg/common"
"github.com/jesseduffield/lazygit/pkg/config"
"github.com/jesseduffield/lazygit/pkg/constants"
"github.com/jesseduffield/lazygit/pkg/gui/types"
)
const (
checkTimeout = 30 * time.Second
installTimeout = 10 * time.Minute
// How long we wait before showing the update menu again after the user
// responded to it
reminderInterval = 24 * time.Hour
// How long an update must have been available before we show the update
// menu at startup, if the user hasn't responded to it otherwise
startupReminderDelay = 7 * 24 * time.Hour
// How long after lazygit started we use ReminderMenuAtStartup
startupPeriod = time.Minute
)
// The ways in which lazygit reminds the user of an available update
type Reminder int
const (
// Show the update menu after the user hasn't used lazygit for a while
ReminderMenuWhenIdle Reminder = iota
// Show the update menu at startup. We only do this if the user hasn't
// responded to the menu for a long time, e.g. because they never leave
// lazygit idle.
ReminderMenuAtStartup
// Print a message to the terminal after lazygit exits
ReminderExitMessage
)
// The part of config.AppConfigurer that the updater needs
type appStateStore interface {
ReadAppState() (*config.AppState, error)
UpdateAppState(update func(state *config.AppState)) error
}
// Updater checks for new lazygit releases, and installs them if lazygit was
// installed from one of our release archives.
type Updater struct {
*common.Common
appState appStateStore
installation Installation
currentVersion *types.VersionNumber
httpClient *http.Client
repoURL string
goos string
goarch string
installing atomic.Bool
statusMutex sync.Mutex
status Status
startTime time.Time
// Replaced in tests
now func() time.Time
// Held while we replace the executable, so that lazygit doesn't exit in
// the middle of it
replaceMutex sync.Mutex
}
func NewUpdater(cmn *common.Common, config config.AppConfigurer) *Updater {
currentVersion, _ := types.ParseVersionNumber(config.GetVersion())
return &Updater{
Common: cmn,
appState: config,
installation: DetectInstallation(config.GetBuildSource(), config.GetVersion(), executablePath()),
currentVersion: currentVersion,
httpClient: &http.Client{},
repoURL: constants.Links.RepoUrl,
goos: runtime.GOOS,
goarch: runtime.GOARCH,
startTime: time.Now(),
now: time.Now,
}
}
func executablePath() string {
path, err := os.Executable()
if err != nil {
return ""
}
if resolvedPath, err := filepath.EvalSymlinks(path); err == nil {
return resolvedPath
}
return path
}
func (u *Updater) Installation() Installation {
return u.installation
}
// CurrentVersion returns nil for dev builds
func (u *Updater) CurrentVersion() *types.VersionNumber {
return u.currentVersion
}
// Status is what lazygit knows about updates
type Status struct {
// The latest release that a check found, if it is newer than the running
// lazygit
AvailableVersion *types.VersionNumber
// The version that an update installed in place of the running lazygit.
// This lazygit, or another one running from the same executable, can have
// installed it. The new version takes effect when lazygit is restarted.
InstalledVersion *types.VersionNumber
}
// ChecksEnabled returns whether lazygit checks for updates regularly. It
// doesn't for dev builds.
func (u *Updater) ChecksEnabled() bool {
return u.installation.Kind != InstallKindDevBuild
}
// CheckForUpdateIfDue checks for an update if lazygit checks regularly, and
// the last successful check is long enough ago.
func (u *Updater) CheckForUpdateIfDue() error {
if !u.ChecksEnabled() {
return nil
}
state := u.readAppState()
interval := time.Duration(u.UserConfig().Update.Days) * 24 * time.Hour
if u.now().Sub(time.Unix(state.Updates.LastCheck, 0)) < interval {
u.RefreshStatus()
return nil
}
_, err := u.CheckForUpdate()
return err
}
// CheckForUpdate returns the latest version if it is newer than the current
// one, or nil if it isn't. Don't call it for dev builds.
func (u *Updater) CheckForUpdate() (*types.VersionNumber, error) {
ctx, cancel := context.WithTimeout(context.Background(), checkTimeout)
defer cancel()
latestVersion, err := fetchLatestVersion(ctx, u.httpClient, u.repoURL)
if err != nil {
return nil, err
}
u.Log.Infof("Current version is %s, latest version is %s", u.currentVersion, latestVersion)
u.updateAppState(func(state *config.AppState) {
state.Updates.LastCheck = u.now().Unix()
if state.Updates.LatestVersion != latestVersion.String() {
state.Updates.LatestVersion = latestVersion.String()
state.Updates.LatestVersionFoundAt = u.now().Unix()
}
})
u.RefreshStatus()
if !u.currentVersion.IsOlderThan(latestVersion) {
return nil, nil
}
return latestVersion, nil
}
// CheckCanInstall returns an error if we can't install an update in place
// because we don't have write access to the folder of the executable. Only call
// it for InstallKindRelease.
func (u *Updater) CheckCanInstall() error {
return checkCanReplaceExecutable(u.installation.ExecutablePath)
}
// Install downloads the given release and installs it in place of the running
// lazygit. Only call it for InstallKindRelease.
func (u *Updater) Install(version *types.VersionNumber) error {
if !u.installing.CompareAndSwap(false, true) {
return errors.New("an update is already in progress")
}
defer u.installing.Store(false)
ctx, cancel := context.WithTimeout(context.Background(), installTimeout)
defer cancel()
url := assetURL(u.repoURL, version, u.goos, u.goarch)
u.Log.Infof("Installing %s", url)
binary, err := downloadBinary(ctx, u.httpClient, url, u.goos)
if err != nil {
return err
}
if err := u.replaceExecutable(binary); err != nil {
return err
}
u.updateAppState(func(state *config.AppState) {
state.Updates.InstalledVersion = version.String()
state.Updates.InstalledPath = u.installation.ExecutablePath
})
u.RefreshStatus()
return nil
}
func (u *Updater) replaceExecutable(binary []byte) error {
u.replaceMutex.Lock()
defer u.replaceMutex.Unlock()
return replaceExecutable(u.installation.ExecutablePath, binary, u.goos)
}
// RefreshStatus reads the status from the app state, where other lazygit
// instances can have changed it, and returns it. Don't call it on the UI
// thread, because it accesses the file system.
func (u *Updater) RefreshStatus() Status {
state := u.readAppState()
status := u.statusFromAppState(state)
u.statusMutex.Lock()
defer u.statusMutex.Unlock()
u.status = status
return status
}
func (u *Updater) statusFromAppState(state *config.AppState) Status {
status := Status{
AvailableVersion: u.newerVersion(state.Updates.LatestVersion),
}
if state.Updates.InstalledPath == u.installation.ExecutablePath {
status.InstalledVersion = u.newerVersion(state.Updates.InstalledVersion)
}
return status
}
// Status returns the status as of the last refresh
func (u *Updater) Status() Status {
u.statusMutex.Lock()
defer u.statusMutex.Unlock()
return u.status
}
// IsStartingUp returns whether lazygit started less than a minute ago
func (u *Updater) IsStartingUp() bool {
return u.now().Sub(u.startTime) < startupPeriod
}
// RemindersEnabled returns whether lazygit reminds the user of available
// updates. With update.method set to never, it only shows the note in the
// bottom-right corner.
func (u *Updater) RemindersEnabled() bool {
return u.ChecksEnabled() && u.UserConfig().Update.Method != "never"
}
// DueReminder returns the version to remind the user of, or nil if no reminder
// is due
func (u *Updater) DueReminder(reminder Reminder) *types.VersionNumber {
return u.dueReminder(u.readAppState(), reminder)
}
// ClaimExitMessage returns the version to remind the user of in a message
// after lazygit exits, or nil if no reminder is due, and records that we print
// the message. We print it at most once a day.
func (u *Updater) ClaimExitMessage() *types.VersionNumber {
var version *types.VersionNumber
u.updateAppState(func(state *config.AppState) {
version = u.dueReminder(state, ReminderExitMessage)
if version != nil {
state.Updates.LastExitMessage = u.now().Unix()
}
})
return version
}
func (u *Updater) dueReminder(state *config.AppState, reminder Reminder) *types.VersionNumber {
if !u.RemindersEnabled() || u.IsInstalling() {
return nil
}
status := u.statusFromAppState(state)
if status.AvailableVersion == nil || status.InstalledVersion != nil {
return nil
}
if state.Updates.SkippedVersion == state.Updates.LatestVersion {
return nil
}
if u.now().Sub(time.Unix(state.Updates.LastResponse, 0)) < reminderInterval {
return nil
}
if reminder == ReminderMenuAtStartup {
if state.Updates.RespondedVersion == state.Updates.LatestVersion ||
u.now().Sub(time.Unix(state.Updates.LatestVersionFoundAt, 0)) < startupReminderDelay {
return nil
}
}
if reminder == ReminderExitMessage &&
u.now().Sub(time.Unix(state.Updates.LastExitMessage, 0)) < reminderInterval {
return nil
}
return status.AvailableVersion
}
// VersionToInstallInBackground returns the version that lazygit should install
// without asking the user, or nil if there's none. This is the case if the user
// config asks for it, and lazygit can update itself.
func (u *Updater) VersionToInstallInBackground() *types.VersionNumber {
if u.installation.Kind != InstallKindRelease || u.UserConfig().Update.Method != "background" {
return nil
}
state := u.readAppState()
status := u.statusFromAppState(state)
if status.AvailableVersion == nil || status.InstalledVersion != nil ||
state.Updates.SkippedVersion == state.Updates.LatestVersion {
return nil
}
if err := u.CheckCanInstall(); err != nil {
return nil
}
return status.AvailableVersion
}
// RecordResponse records that the user responded to the update menu for the
// given version, in whatever way. lazygit doesn't show the menu again for a
// day, and the other lazygit instances close theirs.
func (u *Updater) RecordResponse(version *types.VersionNumber) {
u.updateAppState(func(state *config.AppState) {
state.Updates.LastResponse = u.now().Unix()
state.Updates.RespondedVersion = version.String()
})
}
// IsHandledAfter returns whether the user responded to the update menu in any
// lazygit instance after the given time, or the update got installed. A menu
// that was shown at that time is obsolete then.
func (u *Updater) IsHandledAfter(t time.Time) bool {
state := u.readAppState()
return state.Updates.LastResponse > t.Unix() || u.statusFromAppState(state).InstalledVersion != nil
}
// SkipVersion keeps lazygit from reminding the user of the given version
func (u *Updater) SkipVersion(version *types.VersionNumber) {
u.updateAppState(func(state *config.AppState) {
state.Updates.SkippedVersion = version.String()
})
}
// newerVersion parses the given version and returns it if it is newer than the
// running lazygit, or nil otherwise
func (u *Updater) newerVersion(versionStr string) *types.VersionNumber {
if u.currentVersion == nil {
return nil
}
version, err := types.ParseVersionNumber(versionStr)
if err != nil || !u.currentVersion.IsOlderThan(version) {
return nil
}
return version
}
func (u *Updater) readAppState() *config.AppState {
state, err := u.appState.ReadAppState()
if err != nil {
u.Log.Errorf("Error reading the app state: %v", err)
}
return state
}
// Errors from saving the update state aren't worth bothering the user with; at
// worst, we check or remind again.
func (u *Updater) updateAppState(update func(state *config.AppState)) {
if err := u.appState.UpdateAppState(update); err != nil {
u.Log.Errorf("Error saving the app state: %v", err)
}
}
func (u *Updater) IsInstalling() bool {
return u.installing.Load()
}
// WaitForInstallToFinish waits until a running install is done replacing the
// executable, and keeps later installs from starting. Call it before exiting.
func (u *Updater) WaitForInstallToFinish() {
u.replaceMutex.Lock()
}
// CleanUpAfterUpdate removes files that an earlier update left behind
func (u *Updater) CleanUpAfterUpdate() {
if u.installation.Kind == InstallKindRelease {
cleanUpAfterUpdate(u.installation.ExecutablePath)
}
}