Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

35.6 KB
Raw Blame
// Package update keeps magpie current. Builds are published as GitHub
// releases of yetone/magpie-releases; usemagpie.ai/api/latest describes the
// newest one: its version, notes, and every file with its SHA-256.
//
// The macOS app replaces its own bundle: the new zip is downloaded, checked
// against its hash, unpacked, and accepted only if it is signed by the same
// team as the app already installed. A bare binary (the terminal build,
// and the desktop app on Windows and Linux) replaces itself the same way,
// minus the signature.
package update

import (
	"cmp"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/yetone/magpie/internal/appdir"
	"github.com/yetone/magpie/internal/netproxy"
	"github.com/yetone/magpie/internal/proc"
	"github.com/yetone/magpie/internal/source"
)

// Site is magpie's home; its /api/latest is the update feed.
const Site = "https://usemagpie.ai"

// Feed is where the newest release is described. MAGPIE_UPDATE_FEED points
// it elsewhere, for testing an update against a local server.
func Feed() string {
	if f := os.Getenv("MAGPIE_UPDATE_FEED"); f != "" {
		return f
	}
	return Site + "/api/latest"
}

// Release is one published version.
type Release struct {
	Version string           `json:"version"` // "0.2.0", no v
	Notes   string           `json:"notes"`   // markdown
	URL     string           `json:"url"`     // the release page
	Assets  map[string]Asset `json:"assets"`  // by file name
}

// Asset is one downloadable file of a release.
type Asset struct {
	URL    string `json:"url"`
	Size   int64  `json:"size"`
	SHA256 string `json:"sha256"`
}

// client asks the feed and downloads a release through the proxy the rest
// of magpie's requests take — Settings' Proxy, else the environment's, else
// the system's (#294) — on a transport of its own, whatever the process has
// done to http.DefaultTransport.
var client = &http.Client{Timeout: 10 * time.Minute, Transport: proxied()}

func proxied() http.RoundTripper {
	t := http.DefaultTransport.(*http.Transport).Clone()
	t.Proxy = netproxy.Func
	return netproxy.Dispatch(t)
}

// Latest asks the feed for the newest release, its notes in English.
func Latest(ctx context.Context) (*Release, error) { return LatestIn(ctx, "") }

// LatestIn asks the feed for the newest release, its notes in lang (see
// InLang): the app's language, which What's new follows. On Settings'
// Stable channel it is Stable's release (see Stable).
func LatestIn(ctx context.Context, lang string) (*Release, error) {
	req, err := http.NewRequestWithContext(ctx, "GET", withChannel(withLang(Feed(), lang)), nil)
	if err != nil {
		return nil, err
	}
	res, err := source.Do(client, req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode != 200 {
		return nil, fmt.Errorf("update feed: %s", res.Status)
	}
	var r Release
	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
		return nil, fmt.Errorf("update feed: %w", err)
	}
	if parse(r.Version) == nil {
		return nil, fmt.Errorf("update feed: no version")
	}
	r.Notes = InLang(r.Notes, lang)
	return &r, nil
}

// Released reports whether v is a release version rather than a build from
// source ("dev", "0bcb2cc-dirty", git describe's "v0.1.0-3-g0bcb2cc");
// only releases update themselves.
func Released(v string) bool {
	s := parse(v)
	return s != nil && !describe.MatchString(s.pre) && !strings.Contains(s.pre, "dirty")
}

// describe matches what git describe adds after a tag: commits since, hash.
var describe = regexp.MustCompile(`^\d+-g[0-9a-f]+`)

// Newer reports whether version a comes after b. A pre-release comes before
// the release it leads up to.
func Newer(a, b string) bool {
	x, y := parse(a), parse(b)
	if x == nil || y == nil {
		return false
	}
	for i := range 3 {
		if x.n[i] != y.n[i] {
			return x.n[i] > y.n[i]
		}
	}
	return comparePre(x.pre, y.pre) > 0
}

// comparePre orders two pre-releases the way semver does (§11): no
// pre-release comes after any; otherwise identifier by identifier, numbers
// as numbers ("beta.10" after "beta.9"), a number before a word, and a
// shorter list before a longer one it starts.
func comparePre(a, b string) int {
	switch {
	case a == b:
		return 0
	case a == "":
		return 1
	case b == "":
		return -1
	}
	x, y := strings.Split(a, "."), strings.Split(b, ".")
	for i := 0; i < len(x) && i < len(y); i++ {
		m, errM := strconv.ParseUint(x[i], 10, 64)
		n, errN := strconv.ParseUint(y[i], 10, 64)
		switch {
		case errM == nil && errN == nil:
			if m != n {
				return cmp.Compare(m, n)
			}
		case errM == nil:
			return -1
		case errN == nil:
			return 1
		default:
			if c := strings.Compare(x[i], y[i]); c != 0 {
				return c
			}
		}
	}
	return cmp.Compare(len(x), len(y))
}

type semver struct {
	n   [3]int
	pre string
}

func parse(v string) *semver {
	v = strings.TrimPrefix(strings.TrimSpace(v), "v")
	// build metadata ("+sha.5d0c1dc") plays no part in the order
	v, _, _ = strings.Cut(v, "+")
	v, pre, _ := strings.Cut(v, "-")
	parts := strings.Split(v, ".")
	if len(parts) != 3 {
		return nil
	}
	var s semver
	for i, p := range parts {
		n, err := strconv.Atoi(p)
		if err != nil || n < 0 {
			return nil
		}
		s.n[i] = n
	}
	s.pre = pre
	return &s
}

// GUI says this binary has the desktop app in it. Off the Mac that app is a
// single binary too, and it updates from its own build, not the terminal
// one.
var GUI bool

// AppAsset and BinaryAsset name the files this machine would install.
func AppAsset() string { return "magpie-darwin-" + runtime.GOARCH + ".zip" }
func BinaryAsset() string {
	name := "magpie-cli-" + runtime.GOOS + "-" + runtime.GOARCH
	if GUI && runtime.GOOS != "darwin" {
		name = "magpie-" + runtime.GOOS + "-" + runtime.GOARCH
	}
	if runtime.GOOS == "windows" {
		name += ".exe"
	}
	return name
}

// Bundle is the .app the running binary lives in, or "" when it is not in
// one.
func Bundle() string {
	if runtime.GOOS != "darwin" {
		return ""
	}
	exe, err := Executable()
	if err != nil {
		return ""
	}
	// …/magpie.app/Contents/MacOS/magpie
	app := filepath.Dir(filepath.Dir(filepath.Dir(exe)))
	if filepath.Ext(app) != ".app" || filepath.Base(filepath.Dir(exe)) != "MacOS" {
		return ""
	}
	return app
}

// Homebrew is whether exe was installed by Homebrew (brew install magpie),
// which keeps it in its Cellar and has to be the one to upgrade it: a
// binary replaced under it leaves brew thinking the old version is there.
func Homebrew(exe string) bool {
	return strings.Contains(filepath.ToSlash(exe), "/Cellar/magpie/")
}

// Executable is the running binary, symlinks resolved.
func Executable() (string, error) {
	exe, err := os.Executable()
	if err != nil {
		return "", err
	}
	return filepath.EvalSymlinks(exe)
}

// Writable reports whether magpie may replace what lives in dir.
func Writable(dir string) bool {
	f, err := os.CreateTemp(dir, ".magpie-update-*")
	if err != nil {
		return false
	}
	f.Close()
	os.Remove(f.Name())
	return true
}

// Stage downloads the app in rel and unpacks it next to the installed
// bundle, ready for Install. It returns the unpacked app, a bundle whose
// folder is named stagedName.
func Stage(ctx context.Context, rel *Release, bundle string) (string, error) {
	a, ok := rel.Assets[AppAsset()]
	if !ok {
		return "", fmt.Errorf("release %s has no %s", rel.Version, AppAsset())
	}
	dir := stageDir(filepath.Dir(bundle))
	os.RemoveAll(dir)
	if err := os.MkdirAll(dir, 0o755); err != nil {
		return "", err
	}
	zip := filepath.Join(dir, AppAsset())
	if err := download(ctx, a, zip); err != nil {
		os.RemoveAll(dir)
		return "", err
	}
	out := filepath.Join(dir, "unzip")
	if b, err := proc.CommandContext(ctx, "ditto", "-x", "-k", zip, out).CombinedOutput(); err != nil {
		os.RemoveAll(dir)
		return "", fmt.Errorf("unzip: %v: %s", err, b)
	}
	os.Remove(zip)
	// the zip holds magpie.app, which leaves that name at once: a folder
	// ending in .app beside the installed one is taken by LaunchServices
	// for a second magpie, and Spotlight lists it after it is gone (#3965)
	unzipped := filepath.Join(out, "magpie.app")
	app := filepath.Join(dir, stagedName)
	if err := os.Rename(unzipped, app); err != nil {
		os.RemoveAll(dir)
		return "", err
	}
	os.Remove(out)
	unregister(unzipped) // in case it looked in that moment
	if err := sameSigner(ctx, bundle, app); err != nil {
		os.RemoveAll(dir)
		return "", err
	}
	return app, nil
}

// sameSigner accepts app only if its signature is intact and made by the
// team that signed the bundle it replaces.
func sameSigner(ctx context.Context, bundle, app string) error {
	if b, err := proc.CommandContext(ctx, "codesign", "--verify", "--deep", "--strict", app).CombinedOutput(); err != nil {
		return fmt.Errorf("the downloaded app's signature is broken: %s", strings.TrimSpace(string(b)))
	}
	want, got := team(ctx, bundle), team(ctx, app)
	if want != got {
		return fmt.Errorf("the downloaded app is signed by %q, not %q", got, want)
	}
	return nil
}

func team(ctx context.Context, app string) string {
	b, _ := proc.CommandContext(ctx, "codesign", "-dv", app).CombinedOutput()
	for _, l := range strings.Split(string(b), "\n") {
		if v, ok := strings.CutPrefix(l, "TeamIdentifier="); ok && v != "not set" {
			return v
		}
	}
	return ""
}

// stagedName is what the new app is unpacked as in stageDir, and asideName
// what the installed one is moved to while they are swapped. Neither ends
// in .app, so LaunchServices never registers either as a second magpie
// (#3965); the renames don't need the name, and stay on one volume.
const (
	stagedName = "payload"
	asideName  = "old"
)

// stageDir is where an update is unpacked: beside what it replaces, so
// installing it is a rename on one volume, or, where magpie may not write,
// in its cache, to be moved in with the administrator's password.
func stageDir(dir string) string {
	if !Writable(dir) {
		if cache, err := appdir.SystemCache(); err == nil {
			return filepath.Join(cache, "update")
		}
	}
	return filepath.Join(dir, ".magpie-update")
}

// Install swaps the staged app in for bundle. The running copy keeps going
// until it quits; the next launch is the new one. Where the folder is not
// magpie's to change the error is a permission one (NeedsAdmin), and
// InstallAsAdmin can do it instead.
func Install(staged, bundle string) error {
	old := filepath.Join(filepath.Dir(staged), asideName)
	os.RemoveAll(old)
	if err := os.Rename(bundle, old); err != nil {
		return err
	}
	if err := os.Rename(staged, bundle); err != nil {
		os.Rename(old, bundle) // put it back
		return err
	}
	os.RemoveAll(filepath.Dir(staged)) // .magpie-update
	return nil
}

// InstallAsAdmin is Install with the administrator's password, asked for
// by the system.
func InstallAsAdmin(staged, bundle string) error {
	old := filepath.Join(filepath.Dir(staged), asideName)
	err := asAdmin(swapScript(staged, bundle, old))
	if err == nil {
		os.RemoveAll(filepath.Dir(staged))
	}
	return err
}

// Relaunch opens bundle again once this process (pid) has exited: with its
// window when window is set, else only its menu bar icon (`tray`, as a
// login launch), which a restart by itself uses while no window was up.
// Each try, and what it came to, is written to relaunch.log in magpie's
// own folder.
func Relaunch(bundle string, window bool) error {
	return runAfterExit(os.Getpid(), relaunchCommand(bundle, window, relaunchLog()))
}

// openWaits are the pauses, in seconds, between tries of the relaunch's
// open: about 13s in all. Just after magpie exits, LaunchServices can
// still hold it as running and send the open to the process that is gone,
// and open fails (-600, procNotFound; seen with the screen locked). Tried
// once, nothing started magpie again until the user did, nine hours later.
var openWaits = []string{"0.5", "1", "1", "2", "2", "3", "4"}

// relaunchLogName is the file in magpie's folder the relaunch writes each
// try of its open to, and the start it falls back to: the shell that runs
// them has no output anyone sees, and a magpie that never came back left
// only the system log to say why.
const relaunchLogName = "relaunch.log"

// relaunchLog is the relaunch's log file, made ready to append to; once it
// is past 64KB the last one is kept as relaunch.log.old. "" when magpie's
// folder can't be made: the tries then go unwritten.
func relaunchLog() string {
	h, err := appdir.Home()
	if err != nil || h == "" {
		return ""
	}
	dir := appdir.Config()
	if err := os.MkdirAll(dir, 0o700); err != nil {
		return ""
	}
	p := filepath.Join(dir, relaunchLogName)
	if fi, err := os.Stat(p); err == nil && fi.Size() > 64<<10 {
		os.Rename(p, p+".old")
	}
	return p
}

// relaunchCommand is the shell command Relaunch runs once magpie has
// exited: open, tried again while it fails, and, when it never worked,
// the bundle's own executable run straight, as the login launch agent
// runs it. With the screen locked, magpie stayed closed after an update
// even with the 13s of tries (molvqingtai, after fb23bca5c): LaunchServices
// can go on refusing the open for as long as the session is locked, and a
// program run by its path needs nothing from it to start.
func relaunchCommand(bundle string, window bool, log string) string {
	return relaunchScript(bundle, window, log, openWaits)
}

// relaunchScript is relaunchCommand with the pauses between opens.
func relaunchScript(bundle string, window bool, log string, waits []string) string {
	if log == "" {
		log = os.DevNull
	}
	exe := filepath.Join(bundle, "Contents", "MacOS", bundleExecutable(bundle))
	run := shellQuote(exe)
	for _, a := range RelaunchArgs(window, "") {
		run += " " + shellQuote(a)
	}
	var b strings.Builder
	b.WriteString("log=" + shellQuote(log) + "; ")
	b.WriteString(`note() { echo "$(date '+%Y-%m-%d %H:%M:%S %z') $*" >> "$log" 2>/dev/null; }; `)
	// open's own exit status and what it said, on one line
	b.WriteString(`try() { n=$((n+1)); e=$(` + relaunchOpen(bundle, window) + ` 2>&1 >/dev/null); s=$?; note "open try $n: exit $s $(printf '%s' "$e" | tr '\n' ' ')"; return $s; }; `)
	b.WriteString("n=0; note " + shellQuote("magpie has exited; opening "+bundle) + "; ")
	b.WriteString(retried("try", waits))
	b.WriteString(" || { note \"open gave up after $n tries; starting \"" + shellQuote(run) + "; ")
	b.WriteString("[ -x " + shellQuote(exe) + " ] || { note \"no executable at \"" + shellQuote(exe) + "; exit 1; }; ")
	b.WriteString("exec " + run + " </dev/null >/dev/null 2>&1; }")
	return b.String()
}

// bundleExecutableKey finds the program an app's Info.plist names.
var bundleExecutableKey = regexp.MustCompile(`<key>CFBundleExecutable</key>\s*<string>([^<]+)</string>`)

// bundleExecutable is the name of the program in bundle's Contents/MacOS:
// the one its Info.plist names, else this one's own when it runs from
// that bundle, else magpie.
func bundleExecutable(bundle string) string {
	if b, err := os.ReadFile(filepath.Join(bundle, "Contents", "Info.plist")); err == nil {
		if m := bundleExecutableKey.FindSubmatch(b); m != nil {
			if name := strings.TrimSpace(html.UnescapeString(string(m[1]))); name != "" && !strings.ContainsRune(name, '/') {
				return name
			}
		}
	}
	if exe, err := Executable(); err == nil && filepath.Dir(exe) == filepath.Join(bundle, "Contents", "MacOS") {
		return filepath.Base(exe)
	}
	return "magpie"
}

// retried is a shell command that runs command until it succeeds, sleeping
// each of waits in turn after a failure; the last try's status is its own.
func retried(command string, waits []string) string {
	if len(waits) == 0 {
		return command
	}
	return fmt.Sprintf("for w in %s; do %s && exit 0; sleep $w; done; %s", strings.Join(waits, " "), command, command)
}

// runAfterExit starts a shell that runs command once pid has exited. The
// shell is in a session of its own: launchd ends the process group of a
// job whose process exits, so one left in magpie's group was killed as
// magpie quit and the new version never opened. That is the launch agent
// of Open at login without AbandonProcessGroup (ee16c657), and, on macOS
// 13 at least, the job LaunchServices runs an app in when it is opened from
// the Dock or Finder, which magpie can't set that key on (#2362).
func runAfterExit(pid int, command string) error {
	script := fmt.Sprintf(`while kill -0 %d 2>/dev/null; do sleep 0.2; done; %s`, pid, command)
	cmd := proc.Command("/bin/sh", "-c", script)
	cmd.Stdin, cmd.Stdout, cmd.Stderr = nil, nil, nil
	detach(cmd)
	return cmd.Start()
}

// relaunchOpen is the open command Relaunch runs for bundle. -n asks
// LaunchServices for a new instance: without it, open looks the app up
// among those running first, and just after magpie exits LaunchServices
// can still have the gone process registered as magpie. open then sends
// it a reopen Apple event (aevt/rapp) rather than launching the bundle,
// and fails with -600, procNotFound ("Specified target process … does
// not exist", "LAUNCH: Launch failed in CSUI"; Linka's log on Discord,
// macOS 27.0.1, v0.1.1308), as often as it is tried. A magpie that is in
// fact up still has the one instance: the new process finds the instance
// lock held and hands over to it (runningAlready in internal/gui).
func relaunchOpen(bundle string, window bool) string {
	if window {
		return fmt.Sprintf("open -n %q", bundle)
	}
	return fmt.Sprintf("open -n %q --args tray", bundle)
}

// ReplaceBinary puts the release's build for this binary where the
// running one is.
func ReplaceBinary(ctx context.Context, rel *Release) error {
	exe, err := Executable()
	if err != nil {
		return err
	}
	staged, err := StageBinary(ctx, rel)
	if err != nil {
		return err
	}
	err = InstallBinary(staged, exe)
	if NeedsAdmin(err) && CanElevate() {
		err = InstallBinaryAsAdmin(staged, exe)
	}
	return err
}

// StageBinary downloads the release's build for this binary next to it (or
// to the cache, where magpie may not write there), ready for InstallBinary.
func StageBinary(ctx context.Context, rel *Release) (string, error) {
	a, ok := rel.Assets[BinaryAsset()]
	if !ok {
		return "", fmt.Errorf("release %s has no %s", rel.Version, BinaryAsset())
	}
	exe, err := Executable()
	if err != nil {
		return "", err
	}
	tmp := exe + ".new"
	if !Writable(filepath.Dir(exe)) {
		dir := stageDir(filepath.Dir(exe))
		if err := os.MkdirAll(dir, 0o755); err != nil {
			return "", err
		}
		tmp = filepath.Join(dir, filepath.Base(exe)+".new")
	}
	if err := download(ctx, a, tmp); err != nil {
		return "", err
	}
	if err := os.Chmod(tmp, 0o755); err != nil {
		os.Remove(tmp)
		return "", err
	}
	return tmp, nil
}

// InstallBinary swaps a staged binary in for exe, the running one, which
// keeps going until it exits.
func InstallBinary(staged, exe string) error {
	_, err := InstallBinaryAside(staged, exe)
	return err
}

// InstallBinaryAside is InstallBinary, saying where the running exe was
// moved to on Windows ("" elsewhere), for RelaunchBinary to put it back
// should the new version not start. A download this computer won't start
// (Smart App Control, #894) isn't put in: a *BlockedError, and the
// download removed.
func InstallBinaryAside(staged, exe string) (string, error) {
	var old string
	if runtime.GOOS == "windows" {
		// tried once per download: a restart clicked again after a failed
		// one doesn't start it again, which would have an antivirus that
		// checks a program as it starts hold it again for the move below
		if !trialled.passed(staged) {
			if err := canStart(staged); err != nil {
				os.Remove(staged)
				return "", &BlockedError{Err: err}
			}
			trialled.note(staged)
		}
		// A running .exe cannot be overwritten, but it can be moved aside.
		// What the last update moved aside may still be running too (a
		// `magpie serve` started before it), and can't be removed or
		// replaced then: this one goes beside it, under a name of its own.
		// The download is kept, for another try.
		RemoveOld(exe)
		var err error
		if old, err = moveAside(exe); err != nil {
			return "", err
		}
	}
	if err := moveIn(staged, exe); err != nil {
		if heldOpen(err) {
			// the reason and what to do, shown as is in the version row
			// and the Update pill's tooltip, without the paths
			err = &saidError{fmt.Sprintf("couldn't put the new version in place of %s: another program still has the download open (often an antivirus checking it): let magpie through it and restart to update again, or download the new version and put it in place of this one", filepath.Base(exe)), err}
		}
		if old != "" {
			if restoreErr := moveIn(old, exe); restoreErr != nil {
				return "", errors.Join(err, fmt.Errorf("couldn't restore %s from %s: %w", filepath.Base(exe), old, restoreErr))
			}
		} else if !NeedsAdmin(err) { // kept for InstallBinaryAsAdmin
			os.Remove(staged)
		}
		return "", err
	}
	return old, nil
}

// saidError is err said in other words: what is shown, err what
// errors.Is and errors.As find.
type saidError struct {
	said string
	err  error
}

func (e *saidError) Error() string { return e.said }
func (e *saidError) Unwrap() error { return e.err }

// renameFile is os.Rename; tests make it fail.
var renameFile = os.Rename

// asideWaits are the pauses between tries at moving the running exe aside:
// an antivirus scanning it or a sync client (OneDrive) reading it holds it
// open, which Windows won't rename under, for a moment, and lets go.
var asideWaits = []time.Duration{100 * time.Millisecond, 200 * time.Millisecond, 400 * time.Millisecond, 800 * time.Millisecond, 1500 * time.Millisecond}

// heldFor is how long a file Windows says another program holds open is
// waited for, past asideWaits, the last pause repeated: an antivirus that
// checks a new program as it starts may hold a 50 MB download longer than
// asideWaits' three seconds, and a restart that gave up then would fail
// the same way on every click, each click's trial start having it checked
// again (白菜 on Discord). The user clicked restart and sees "Restarting…"
// meanwhile. A var for tests.
var heldFor = 30 * time.Second

// waitHeld is whether to try again after try i (from 0) failed with err,
// begun at start, sleeping first when so: through asideWaits for any error
// retry allows, then on while err is a file held open, up to heldFor.
func waitHeld(i int, err error, start time.Time, retry bool) bool {
	if !retry {
		return false
	}
	if i < len(asideWaits) {
		time.Sleep(asideWaits[i])
		return true
	}
	if !heldOpen(err) || len(asideWaits) == 0 {
		return false
	}
	pause := asideWaits[len(asideWaits)-1]
	if time.Since(start)+pause > heldFor {
		return false
	}
	time.Sleep(pause)
	return true
}

// trialled is the download canStart last let through, by path, size and
// time written, so a restart tried again on it doesn't start it again.
var trialled trialNote

type trialNote struct {
	mu   sync.Mutex
	path string
	size int64
	mod  time.Time
}

func (n *trialNote) passed(path string) bool {
	fi, err := os.Stat(path)
	if err != nil {
		return false
	}
	n.mu.Lock()
	defer n.mu.Unlock()
	return n.path == path && n.size == fi.Size() && n.mod.Equal(fi.ModTime())
}

func (n *trialNote) note(path string) {
	fi, err := os.Stat(path)
	n.mu.Lock()
	defer n.mu.Unlock()
	if err != nil {
		n.path = ""
		return
	}
	n.path, n.size, n.mod = path, fi.Size(), fi.ModTime()
}

// Windows' errors for a file another program holds open without letting
// it be renamed.
const (
	errSharingViolation syscall.Errno = 32
	errLockViolation    syscall.Errno = 33
)

// moveIn moves from to exe, trying again for a few seconds while
// something holds from open, as moveAside does for the running exe. On
// Windows that is the download just after canStart's trial: an antivirus
// that checks a program as its process starts can hold its file a moment
// after the process has ended, and a move made at once failed the first
// install of every update (#2272). Any other failure is returned at once.
func moveIn(from, exe string) error {
	start := time.Now()
	for i := 0; ; i++ {
		err := os.Rename(from, exe)
		if err == nil || !waitHeld(i, err, start, heldOpen(err)) {
			return err
		}
	}
}

// heldOpen is whether err is Windows refusing a file another program has
// open.
func heldOpen(err error) bool {
	return errors.Is(err, errSharingViolation) || errors.Is(err, errLockViolation)
}

// moveAside moves the running exe out of the way of the new version, under
// a name of its own, trying again for a few seconds while something has it
// open. What it says when it can't is the reason and what to do: the error
// is shown as is in the version row. On success it returns the actual name,
// so a failed installation can put the running exe back.
func moveAside(exe string) (string, error) {
	var err error
	start := time.Now()
	for i := 0; ; i++ {
		old := oldName(exe)
		if err = renameFile(exe, old); err == nil {
			return old, nil
		}
		if i == 0 {
			os.Chmod(exe, 0o755) // a read-only exe: the attribute off
		}
		if !waitHeld(i, err, start, !errors.Is(err, fs.ErrNotExist)) {
			break
		}
	}
	why := err.Error()
	var le *os.LinkError
	if errors.As(err, &le) {
		why = le.Err.Error() // the paths are known; the reason is what's new
	}
	var hint string
	switch {
	case heldOpen(err):
		hint = "another program has it open (often an antivirus or OneDrive): let magpie through it and restart to update again, or download the new version and put it in place of this one"
	case errors.Is(err, fs.ErrPermission):
		hint = "Windows doesn't let magpie change files in " + filepath.Dir(exe) + " (an antivirus' folder protection, or the folder's permissions): let magpie through, or download the new version and put it in place of this one"
	default:
		hint = "download the new version and put it in place of this one"
	}
	return "", fmt.Errorf("couldn't move %s aside to put the new version in: %s; %s", filepath.Base(exe), strings.TrimRight(why, ". 。"), hint)
}

// oldName is where a running exe is moved aside to: exe.old, or when
// that is still there (in use), exe.old-2, exe.old-3…
func oldName(exe string) string {
	name := exe + ".old"
	for n := 2; ; n++ {
		if _, err := os.Lstat(name); os.IsNotExist(err) {
			return name
		}
		name = fmt.Sprintf("%s.old-%d", exe, n)
	}
}

// RemoveOld removes what earlier updates moved aside of exe, those no
// longer running.
func RemoveOld(exe string) {
	os.Remove(exe + ".old")
	olds, _ := filepath.Glob(exe + ".old-*")
	for _, o := range olds {
		os.Remove(o)
	}
}

// Replaced reports whether exe is no longer the binary that was there when
// this process looked (started, from os.Stat): another magpie installed an
// update over it, and this one runs from where it was moved aside.
func Replaced(exe string, started os.FileInfo) bool {
	now, err := os.Stat(exe)
	return err == nil && started != nil && (now.Size() != started.Size() || !now.ModTime().Equal(started.ModTime()))
}

// RemoveStaleNew removes exe.new when it is exe over again: the update a
// magpie left running from before it downloaded once more.
func RemoveStaleNew(exe string) {
	staged := exe + ".new"
	a, err1 := os.Stat(exe)
	b, err2 := os.Stat(staged)
	if err1 != nil || err2 != nil || a.Size() != b.Size() {
		return
	}
	if ha, hb := fileHash(exe), fileHash(staged); ha != "" && ha == hb {
		os.Remove(staged)
	}
}

func fileHash(path string) string {
	f, err := os.Open(path)
	if err != nil {
		return ""
	}
	defer f.Close()
	h := sha256.New()
	if _, err := io.Copy(h, f); err != nil {
		return ""
	}
	return hex.EncodeToString(h.Sum(nil))
}

// InstallBinaryAsAdmin is InstallBinary with the administrator's password.
func InstallBinaryAsAdmin(staged, exe string) error {
	err := asAdmin("mv -f " + shellQuote(staged) + " " + shellQuote(exe))
	if err != nil && !errors.Is(err, ErrCanceled) {
		os.Remove(staged)
	}
	return err
}

// RelaunchBinary starts exe again: with its window on view when window is
// set (the window was open), else as the tray app alone, as autostart
// starts it. The new process waits for this one to exit before it takes
// the gateway's port; see AwaitPredecessor. With old, where this one was
// moved aside to (Windows), it waits for the new one to say it is up, and
// when it can't start puts old back and says so (a *BlockedError): this
// one then runs on rather than quitting.
func RelaunchBinary(exe, old string, window bool, view string) error {
	args := RelaunchArgs(window, view)
	env := append(os.Environ(), "MAGPIE_REPLACES="+strconv.Itoa(os.Getpid()))
	if old != "" {
		return startChecked(exe, old, args, env)
	}
	_, _, err := launch(exe, args, env)
	return err
}

// RelaunchArgs is what RelaunchBinary starts magpie with: `gui [view]` for
// the window, `tray` for the tray icon alone.
func RelaunchArgs(window bool, view string) []string {
	switch {
	case !window:
		return []string{"tray"}
	case view != "":
		return []string{"gui", view}
	}
	return []string{"gui"}
}

// AwaitPredecessor blocks, for a while at most, until the magpie that
// relaunched this one has exited.
func AwaitPredecessor() {
	reportStarted() // first: the one that started this waits for it
	pid, err := strconv.Atoi(os.Getenv("MAGPIE_REPLACES"))
	os.Unsetenv("MAGPIE_REPLACES")
	if err != nil || pid <= 0 {
		return
	}
	for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline) && alive(pid); {
		time.Sleep(100 * time.Millisecond)
	}
}

type progressKey struct{}

// WithProgress has downloads made under ctx report how far along they are;
// total is 0 while the size is unknown.
func WithProgress(ctx context.Context, f func(done, total int64)) context.Context {
	return context.WithValue(ctx, progressKey{}, f)
}

// retryWaits are the pauses before each try after the first: a
// connection that drops at the start or part way (GitHub's asset host from
// some networks: AIMetaPhD on X, "EOF" at 0.1.1618) is tried again, from
// where it broke off. A var for tests.
var retryWaits = []time.Duration{2 * time.Second, 4 * time.Second, 8 * time.Second, 16 * time.Second, 30 * time.Second}

// download fetches a to path and checks its hash. A connection that drops
// is tried again after each of retryWaits, asking with Range for what is
// still missing; the hash is checked over the whole file, the bytes kept
// from the tries before included.
func download(ctx context.Context, a Asset, path string) error {
	if a.SHA256 == "" {
		return errors.New("the release lists no checksum for " + filepath.Base(path))
	}
	os.Remove(path) // a file left by an earlier run is no part of this one
	var err error
	for try := 0; try <= len(retryWaits); try++ {
		if try > 0 {
			select {
			case <-ctx.Done():
				return err
			case <-time.After(retryWaits[try-1]):
			}
		}
		if err = fetch(ctx, a, path); err == nil || ctx.Err() != nil || !Network(err) {
			break
		}
	}
	if err != nil {
		os.Remove(path)
	}
	return err
}

// NetError is a download the network broke off: the connection failed or
// dropped part way. It names the file and the cause, never the address:
// GitHub's redirect is a signed URL, hundreds of characters of signature
// and token that say nothing to the user.
type NetError struct {
	File string
	Err  error
}

func (e *NetError) Error() string {
	cause := e.Err
	var ue *url.Error
	if errors.As(cause, &ue) {
		cause = ue.Err
	}
	return fmt.Sprintf("the download of %s broke off (%v)", e.File, cause)
}

func (e *NetError) Unwrap() error { return e.Err }

// Network reports whether err is a download the network broke off, which
// trying again may get through.
func Network(err error) bool { return errors.As(err, new(*NetError)) }

// fetch downloads a to path, or the rest of it when path holds the start
// already (a try before broke off): what is there is asked for no more
// (Range), and a host that sends the whole file again has it written from
// the beginning. A try the network breaks off keeps what came, for the next
// one; any other failure removes it.
func fetch(ctx context.Context, a Asset, path string) error {
	// through a mirror when one is given (mirror.go): the hash checked
	// below is still the feed's
	u := mirrored(mirrorOf(ctx), a.URL)
	mirror := strings.TrimSuffix(u, a.URL)
	name := filepath.Base(path)
	var have int64
	if fi, err := os.Stat(path); err == nil && fi.Mode().IsRegular() {
		have = fi.Size()
	}
	req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
	if err != nil {
		return err
	}
	if have > 0 {
		req.Header.Set("Range", fmt.Sprintf("bytes=%d-", have))
	}
	fail := func(err error) error {
		if !Network(err) {
			os.Remove(path)
		}
		if u != a.URL && !errors.As(err, new(*MirrorError)) {
			err = &MirrorError{Mirror: mirror, Err: err}
		}
		return err
	}
	res, err := source.Do(client, req)
	if err != nil {
		if ctx.Err() != nil {
			return fail(err)
		}
		return fail(&NetError{File: name, Err: err})
	}
	defer res.Body.Close()
	flag := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
	switch {
	case res.StatusCode == http.StatusPartialContent && have > 0 && strings.HasPrefix(res.Header.Get("Content-Range"), fmt.Sprintf("bytes %d-", have)):
		flag = os.O_WRONLY | os.O_APPEND
	case res.StatusCode == http.StatusOK:
		have = 0 // the whole file again
	default:
		if u != a.URL {
			return fail(&MirrorError{Mirror: mirror, Err: fmt.Errorf("download %s through the mirror %s: %s", name, mirror, res.Status)})
		}
		return fail(fmt.Errorf("download %s: %s", name, res.Status))
	}
	f, err := os.OpenFile(path, flag, 0o644)
	if err != nil {
		return fail(err)
	}
	// a read that fails is the network's; a write that fails (a full
	// disk) is not, and isn't tried again
	in := &readErr{r: res.Body}
	var body io.Reader = in
	if report, ok := ctx.Value(progressKey{}).(func(done, total int64)); ok {
		total := res.ContentLength
		if total > 0 {
			total += have
		} else {
			total = a.Size
		}
		body = &counter{r: in, done: have, total: max(total, 0), report: report}
		report(have, max(total, 0))
	}
	_, err = io.Copy(f, body)
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	if err != nil {
		if ctx.Err() == nil && in.err != nil {
			err = &NetError{File: name, Err: err}
		}
		return fail(err)
	}
	// the whole file, what earlier tries kept included, against the feed's
	if !strings.EqualFold(fileHash(path), a.SHA256) {
		err = fmt.Errorf("%s does not match its checksum", name)
		if u != a.URL {
			err = fmt.Errorf("%s from the mirror %s does not match its checksum from %s; not installed", name, mirror, Site)
		}
		return fail(err)
	}
	return nil
}

// readErr keeps the error its reader returned, io.EOF aside.
type readErr struct {
	r   io.Reader
	err error
}

func (r *readErr) Read(p []byte) (int, error) {
	n, err := r.r.Read(p)
	if err != nil && err != io.EOF {
		r.err = err
	}
	return n, err
}

// counter reports bytes as they are read.
type counter struct {
	r      io.Reader
	done   int64
	total  int64
	report func(done, total int64)
}

func (c *counter) Read(p []byte) (int, error) {
	n, err := c.r.Read(p)
	c.done += int64(n)
	c.report(c.done, c.total)
	return n, err
}

// Alive reports whether the process pid is still running.
func Alive(pid int) bool { return alive(pid) }

// OpenBeside opens bundle now, a new instance beside this one (open -n),
// tried again while open fails: a restart that hands the gateway over
// (internal/handoff) starts the new version before this one quits. With
// window, its window; else its menu bar icon only, as Relaunch.
func OpenBeside(bundle string, window bool) error {
	cmd := proc.Command("/bin/sh", "-c", retried(openBeside(bundle, window), openWaits))
	cmd.Stdin, cmd.Stdout, cmd.Stderr = nil, nil, nil
	detach(cmd)
	return cmd.Start()
}

// openBeside is the open command OpenBeside runs for bundle.
func openBeside(bundle string, window bool) string {
	if window {
		return fmt.Sprintf("open -n %q", bundle)
	}
	return fmt.Sprintf("open -n %q --args tray", bundle)
}

// StartBeside starts exe now, beside this process, as RelaunchBinary's
// args say: the new version of a restart that hands the gateway over. It
// isn't told to wait for this one (MAGPIE_REPLACES): it takes the gateway
// from it while it runs.
func StartBeside(exe string, window bool, view string) error {
	_, _, err := launch(exe, RelaunchArgs(window, view), os.Environ())
	return err
}