@automattic/vip 4.1.5 → 4.1.6

package/internal/update/archive_test.go

@@ -1,132 +0,0 @@
-package update
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"context"
-	"crypto/sha256"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func tarBytes(t *testing.T, headers []*tar.Header, payloads [][]byte) []byte {
-	t.Helper()
-	var b bytes.Buffer
-	gz := gzip.NewWriter(&b)
-	tw := tar.NewWriter(gz)
-	for i, h := range headers {
-		if err := tw.WriteHeader(h); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := tw.Write(payloads[i]); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := tw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if err := gz.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return b.Bytes()
-}
-func TestExtractRejectsUnsafeArchives(t *testing.T) {
-	for _, h := range []*tar.Header{{Name: "../escaped", Size: 1}, {Name: "/absolute", Size: 1}, {Name: "vip-next", Typeflag: tar.TypeSymlink, Linkname: "/tmp/a"}, {Name: "unexpected", Size: 1}} {
-		body := []byte("x")
-		if h.Typeflag == tar.TypeSymlink {
-			body = nil
-		}
-		root := t.TempDir()
-		archive := filepath.Join(root, "a.tar.gz")
-		if err := os.WriteFile(archive, tarBytes(t, []*tar.Header{h}, [][]byte{body}), 0600); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := Extract(archive, root, Platform{"linux", "amd64"}); err == nil {
-			t.Fatal("accepted", h.Name)
-		}
-	}
-}
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
-func TestStageChecksumAndBytePreservation(t *testing.T) {
-	exe, err := os.Executable()
-	if err != nil {
-		t.Fatal(err)
-	}
-	payload, err := os.ReadFile(exe)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := Platform{runtime.GOOS, runtime.GOARCH}
-	cli, helper := p.names()
-	name, _ := p.archiveName()
-	archive := tarBytes(t, []*tar.Header{{Name: cli, Size: int64(len(payload)), Mode: 0755}, {Name: helper, Size: int64(len(payload)), Mode: 0755}}, [][]byte{payload, payload})
-	digest := fmt.Sprintf("%x", sha256.Sum256(archive))
-	base := "https://github.com/Automattic/vip-cli/releases/download/5.0.1/"
-	c := Candidate{Version: "5.0.1", Archive: Asset{Name: name, URL: base + name, Digest: "sha256:" + digest}, Checksum: Asset{Name: name + ".sha256", URL: base + name + ".sha256"}}
-	for _, bad := range []bool{true, false} {
-		client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-			data := archive
-			if strings.HasSuffix(r.URL.Path, ".sha256") {
-				d := digest
-				if bad {
-					d = strings.Repeat("0", 64)
-				}
-				data = []byte(d + " *" + name)
-			}
-			return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(bytes.NewReader(data)), ContentLength: int64(len(data)), Request: r}, nil
-		})}
-		bundle, err := (Downloader{Client: client}).Stage(context.Background(), c, p, t.TempDir())
-		if bad {
-			if err == nil {
-				t.Fatal("bad checksum accepted")
-			}
-			continue
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, path := range []string{bundle.CLI, bundle.Helper} {
-			got, err := os.ReadFile(path)
-			if err != nil || !bytes.Equal(got, payload) {
-				t.Fatal("binary bytes changed", err)
-			}
-		}
-	}
-	c.Archive.URL = "https://evil.invalid/payload"
-	if _, err := (Downloader{}).Stage(context.Background(), c, p, t.TempDir()); err == nil {
-		t.Fatal("foreign URL accepted")
-	}
-}
-
-func TestStageRejectsMultilineChecksum(t *testing.T) {
-	p := Platform{"linux", "amd64"}
-	name, _ := p.archiveName()
-	base := "https://github.com/Automattic/vip-cli/releases/download/5.0.1/"
-	emptySum := fmt.Sprintf("%x", sha256.Sum256(nil))
-	c := Candidate{Version: "5.0.1", Archive: Asset{Name: name, URL: base + name}, Checksum: Asset{Name: name + ".sha256", URL: base + name + ".sha256"}}
-	archiveRequested := false
-	d := Downloader{Client: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		body := emptySum + "\n" + name
-		if !strings.HasSuffix(r.URL.Path, ".sha256") {
-			archiveRequested = true
-			body = ""
-		}
-		return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body)), Request: r}, nil
-	})}}
-	if _, err := d.Stage(context.Background(), c, p, t.TempDir()); err == nil {
-		t.Fatal("multiline checksum accepted")
-	}
-	if archiveRequested {
-		t.Fatal("invalid checksum was accepted before fetching the archive")
-	}
-}

package/internal/update/download.go

@@ -1,138 +0,0 @@
-package update
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/Automattic/vip/internal/httpproxy"
-)
-
-type Downloader struct{ Client *http.Client }
-
-func (d Downloader) Stage(ctx context.Context, c Candidate, p Platform, parent string) (bundle Bundle, err error) {
-	name, err := p.archiveName()
-	if err != nil {
-		return bundle, err
-	}
-	if !validVersion(c.Version) || c.Archive.Name != name || c.Checksum.Name != name+".sha256" {
-		return bundle, fmt.Errorf("invalid release assets")
-	}
-	for _, a := range []Asset{c.Archive, c.Checksum} {
-		u, e := url.Parse(a.URL)
-		if e != nil || u.Scheme != "https" || u.Host != "github.com" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || u.Path != "/"+Repository+"/releases/download/"+c.Version+"/"+a.Name {
-			return bundle, fmt.Errorf("invalid official release asset URL")
-		}
-	}
-	dir, err := os.MkdirTemp(parent, ".vip-update-stage-")
-	if err != nil {
-		return bundle, err
-	}
-	defer func() {
-		if err != nil {
-			os.RemoveAll(dir)
-		}
-	}()
-	checksum, err := d.fetch(ctx, c.Checksum, 4096)
-	if err != nil {
-		return bundle, err
-	}
-	line := strings.TrimSpace(string(checksum))
-	if strings.ContainsAny(line, "\r\n") {
-		return bundle, fmt.Errorf("checksum file must contain one non-empty line")
-	}
-	fields := strings.Fields(line)
-	if len(fields) != 2 || strings.TrimPrefix(strings.TrimPrefix(fields[1], "*"), "dist/") != name {
-		return bundle, fmt.Errorf("invalid release checksum file")
-	}
-	want, err := hex.DecodeString(fields[0])
-	if err != nil || len(want) != sha256.Size {
-		return bundle, fmt.Errorf("invalid SHA-256 checksum")
-	}
-	archive, err := d.fetch(ctx, c.Archive, maxArchive)
-	if err != nil {
-		return bundle, err
-	}
-	sum := sha256.Sum256(archive)
-	if !strings.EqualFold(hex.EncodeToString(sum[:]), fields[0]) {
-		return bundle, fmt.Errorf("release checksum mismatch")
-	}
-	archivePath := filepath.Join(dir, "release.tar.gz")
-	if err = os.WriteFile(archivePath, archive, 0600); err != nil {
-		return bundle, err
-	}
-	bundle, err = Extract(archivePath, dir, p)
-	return bundle, err
-}
-func (d Downloader) fetch(ctx context.Context, a Asset, limit int64) ([]byte, error) {
-	if a.Size < 0 || a.Size > limit {
-		return nil, fmt.Errorf("release asset exceeds size limit")
-	}
-	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
-	defer cancel()
-	client := d.Client
-	if client == nil {
-		client = httpproxy.Client()
-	}
-	copyClient := *client
-	copyClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-		if len(via) > 5 || req.URL.Scheme != "https" || req.URL.User != nil {
-			return fmt.Errorf("invalid release redirect")
-		}
-		req.Header.Del("Authorization")
-		req.Header.Del("Cookie")
-		return nil
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, a.URL, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("User-Agent", "vip-next-updater")
-	resp, err := copyClient.Do(req)
-	if err != nil {
-		if ctx.Err() != nil {
-			return nil, ctx.Err()
-		}
-		// Client.Do wraps transport failures with a URL that may contain a
-		// signed CDN query. Retain the cause without that URL wrapper.
-		for {
-			urlErr, ok := err.(*url.Error)
-			if !ok {
-				break
-			}
-			err = urlErr.Err
-		}
-		return nil, fmt.Errorf("download %s failed: %w", a.Name, err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("download %s: HTTP %d", a.Name, resp.StatusCode)
-	}
-	if resp.ContentLength > limit {
-		return nil, fmt.Errorf("release asset exceeds size limit")
-	}
-	b, err := readBounded(resp.Body, limit)
-	if err != nil {
-		return nil, err
-	}
-	if a.Size > 0 && int64(len(b)) != a.Size {
-		return nil, fmt.Errorf("release asset size mismatch")
-	}
-	if a.Digest != "" {
-		if !strings.HasPrefix(a.Digest, "sha256:") {
-			return nil, fmt.Errorf("unsupported release asset digest")
-		}
-		sum := sha256.Sum256(b)
-		if !strings.EqualFold(a.Digest, "sha256:"+hex.EncodeToString(sum[:])) {
-			return nil, fmt.Errorf("release asset digest mismatch")
-		}
-	}
-	return b, nil
-}

package/internal/update/download_test.go

@@ -1,32 +0,0 @@
-package update
-
-import (
-	"context"
-	"errors"
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-	"testing"
-)
-
-func TestDownloadReportsCauseWithoutRedirectURL(t *testing.T) {
-	cause := &net.DNSError{Err: "no such host", Name: "release-assets.githubusercontent.com", IsNotFound: true}
-	d := Downloader{Client: &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-		if req.URL.Host == "github.com" {
-			return &http.Response{StatusCode: http.StatusFound, Header: http.Header{"Location": {"https://release-assets.githubusercontent.com/archive?sig=secret"}}, Body: http.NoBody}, nil
-		}
-		return nil, cause
-	})}}
-	_, err := d.fetch(context.Background(), Asset{Name: "release.tar.gz", URL: "https://github.com/Automattic/vip-cli/releases/download/5.0.1/release.tar.gz"}, 1024)
-	if err == nil || !strings.Contains(err.Error(), "no such host") || !errors.Is(err, cause) {
-		t.Fatalf("network cause lost: %v", err)
-	}
-	if strings.Contains(err.Error(), "sig=") || strings.Contains(err.Error(), "secret") {
-		t.Fatalf("redirect credentials leaked: %v", err)
-	}
-	var urlErr *url.Error
-	if errors.As(err, &urlErr) {
-		t.Fatalf("redirect URL retained in error chain: %v", err)
-	}
-}

package/internal/update/github.go

@@ -1,121 +0,0 @@
-package update
-
-import (
-	"context"
-	json "encoding/json/v2"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Automattic/vip/internal/httpproxy"
-)
-
-type GitHub struct {
-	Client  *http.Client
-	BaseURL string
-}
-
-func (g GitHub) Releases(ctx context.Context) ([]Release, error) {
-	ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
-	defer cancel()
-	base := g.BaseURL
-	if base == "" {
-		base = "https://api.github.com"
-	}
-	origin, err := url.Parse(base)
-	if err != nil {
-		return nil, err
-	}
-	endpoint := strings.TrimRight(base, "/") + "/repos/" + Repository + "/releases"
-	client := g.Client
-	if client == nil {
-		client = httpproxy.Client()
-	}
-	// API pagination must never redirect to another source or forward credentials.
-	copyClient := *client
-	copyClient.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
-	var releases []Release
-	for page := 1; page <= 100; {
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint+"?per_page=100&page="+strconv.Itoa(page), nil)
-		if err != nil {
-			return nil, err
-		}
-		req.Header.Set("User-Agent", "vip-next-updater")
-		req.Header.Set("Accept", "application/vnd.github+json")
-		resp, err := copyClient.Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("check GitHub releases: %w", err)
-		}
-		body, readErr := readBounded(resp.Body, 2<<20)
-		resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			return nil, fmt.Errorf("check GitHub releases: HTTP %d", resp.StatusCode)
-		}
-		if readErr != nil {
-			return nil, readErr
-		}
-		var batch []Release
-		if err := json.Unmarshal(body, &batch); err != nil {
-			return nil, fmt.Errorf("invalid GitHub release metadata: %w", err)
-		}
-		releases = append(releases, batch...)
-		next := 0
-		for _, value := range resp.Header.Values("Link") {
-			for _, part := range strings.Split(value, ",") {
-				if !strings.Contains(part, `rel="next"`) {
-					continue
-				}
-				left, right := strings.Index(part, "<"), strings.Index(part, ">")
-				if left < 0 || right <= left {
-					return nil, fmt.Errorf("invalid release pagination")
-				}
-				u, err := url.Parse(part[left+1 : right])
-				if err != nil {
-					return nil, fmt.Errorf("invalid release pagination")
-				}
-				u = origin.ResolveReference(u)
-				n, err := strconv.Atoi(u.Query().Get("page"))
-				if err != nil || n <= page || u.Scheme != origin.Scheme || u.Host != origin.Host || !isReleasePaginationPath(u.EscapedPath()) || u.User != nil || next != 0 {
-					return nil, fmt.Errorf("invalid release pagination")
-				}
-				next = n
-			}
-		}
-		if next == 0 {
-			return releases, nil
-		}
-		page = next
-	}
-	return nil, fmt.Errorf("GitHub release pagination limit exceeded")
-}
-
-func isReleasePaginationPath(path string) bool {
-	if path == "/repos/"+Repository+"/releases" {
-		return true
-	}
-	repositoryID, ok := strings.CutPrefix(path, "/repositories/")
-	if !ok {
-		return false
-	}
-	repositoryID, ok = strings.CutSuffix(repositoryID, "/releases")
-	if !ok {
-		return false
-	}
-	id, err := strconv.ParseUint(repositoryID, 10, 64)
-	return err == nil && id > 0
-}
-
-func readBounded(r io.Reader, max int64) ([]byte, error) {
-	b, err := io.ReadAll(io.LimitReader(r, max+1))
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(b)) > max {
-		return nil, fmt.Errorf("response exceeds size limit")
-	}
-	return b, nil
-}

package/internal/update/install.go

@@ -1,265 +0,0 @@
-package update
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/google/uuid"
-)
-
-type Layout struct{ CLI, Helper string }
-type Ownership struct {
-	Managed      bool
-	Instructions string
-}
-type Step struct {
-	Name string
-	Done bool
-}
-type InstallResult struct{ Warnings []string }
-type Installer struct {
-	Rename           func(string, string) error
-	Remove           func(string) error
-	InspectOwnership func(context.Context, Layout) (Ownership, error)
-}
-type replacement struct {
-	Target, New, Backup string
-	moved, placed       bool
-}
-type installMarker struct {
-	ID       string
-	Complete bool
-	Files    []replacement
-}
-
-func markerPath(l Layout) string {
-	return filepath.Join(filepath.Dir(l.CLI), "."+filepath.Base(l.CLI)+".update.json")
-}
-func ResolveLayout(exe string, p Platform) (Layout, error) {
-	real, err := filepath.EvalSymlinks(exe)
-	if err != nil {
-		return Layout{}, err
-	}
-	real, err = filepath.Abs(real)
-	if err != nil {
-		return Layout{}, err
-	}
-	if _, err = regularFile(real); err != nil {
-		return Layout{}, err
-	}
-	_, helper := p.names()
-	for _, candidate := range []string{filepath.Join(filepath.Dir(real), "bin", helper), filepath.Join(filepath.Dir(real), helper)} {
-		if _, err := os.Lstat(candidate); os.IsNotExist(err) {
-			continue
-		}
-		if _, err := regularFile(candidate); err != nil {
-			return Layout{}, err
-		}
-		// Parent symlinks can lead outside the bundle; accept only a real bundled directory.
-		dir, err := filepath.EvalSymlinks(filepath.Dir(candidate))
-		if err != nil || dir != filepath.Dir(candidate) {
-			return Layout{}, fmt.Errorf("ambiguous bundled helper directory; install manually from %s", ReleasesURL)
-		}
-		if candidate == real {
-			return Layout{}, fmt.Errorf("CLI and helper refer to the same file")
-		}
-		return Layout{real, candidate}, nil
-	}
-	return Layout{}, fmt.Errorf("bundled go-search-replace not found; install the complete archive from %s", ReleasesURL)
-}
-func regularFile(path string) (os.FileInfo, error) {
-	s, err := os.Lstat(path)
-	if err != nil {
-		return nil, err
-	}
-	if !s.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s is not a regular file", path)
-	}
-	return s, nil
-}
-func (i Installer) Apply(ctx context.Context, l Layout, b Bundle, progress func(Step)) (res InstallResult, err error) {
-	if i.Rename == nil {
-		i.Rename = os.Rename
-	}
-	if i.Remove == nil {
-		i.Remove = os.Remove
-	}
-	if i.InspectOwnership == nil {
-		i.InspectOwnership = InspectOwnership
-	}
-	if progress == nil {
-		progress = func(Step) {}
-	}
-	if err = ctx.Err(); err != nil {
-		return res, err
-	}
-	if err = i.cleanPrevious(l); err != nil {
-		return res, err
-	}
-	owner, err := i.InspectOwnership(ctx, l)
-	if err != nil {
-		return res, err
-	}
-	if owner.Managed {
-		return res, fmt.Errorf("%s", owner.Instructions)
-	}
-	m := installMarker{ID: uuid.NewString()}
-	markerWritten := false
-	defer func() {
-		if !markerWritten {
-			for _, r := range m.Files {
-				_ = os.Remove(r.New)
-			}
-		}
-	}()
-	for idx, target := range []string{l.CLI, l.Helper} {
-		stat, e := regularFile(target)
-		if e != nil {
-			return res, e
-		}
-		source := b.CLI
-		if idx == 1 {
-			source = b.Helper
-		}
-		prefix := filepath.Join(filepath.Dir(target), "."+filepath.Base(target)+".vip-update-"+m.ID)
-		r := replacement{Target: target, New: prefix + "-new", Backup: prefix + "-old"}
-		if err = copyExclusive(source, r.New, stat.Mode().Perm()); err != nil {
-			for _, f := range m.Files {
-				os.Remove(f.New)
-			}
-			return res, err
-		}
-		m.Files = append(m.Files, r)
-	}
-	if err = writeJSON(markerPath(l), m); err != nil {
-		for _, f := range m.Files {
-			os.Remove(f.New)
-		}
-		return res, err
-	}
-	markerWritten = true
-	// Preserve this marker on abrupt termination or failed restoration.
-	for index := range m.Files {
-		r := &m.Files[index]
-		if err = ctx.Err(); err != nil {
-			break
-		}
-		progress(Step{Name: "Updating " + filepath.Base(r.Target)})
-		if err = i.Rename(r.Target, r.Backup); err != nil {
-			break
-		}
-		r.moved = true
-		if err = i.Rename(r.New, r.Target); err != nil {
-			break
-		}
-		r.placed = true
-		progress(Step{Name: "Updating " + filepath.Base(r.Target), Done: true})
-	}
-	if err != nil {
-		original := err
-		var recovery []error
-		for index := len(m.Files) - 1; index >= 0; index-- {
-			r := &m.Files[index]
-			if !r.moved {
-				continue
-			}
-			if r.placed {
-				if e := i.Rename(r.Target, r.New); e != nil {
-					recovery = append(recovery, fmt.Errorf("cannot move failed replacement %s; original at %s: %w", r.Target, r.Backup, e))
-					continue
-				}
-			}
-			if e := i.Rename(r.Backup, r.Target); e != nil {
-				recovery = append(recovery, fmt.Errorf("restore %s from %s: %w", r.Target, r.Backup, e))
-			}
-		}
-		if len(recovery) == 0 {
-			for _, r := range m.Files {
-				os.Remove(r.New)
-			}
-			os.Remove(markerPath(l))
-			return res, fmt.Errorf("update failed; original files restored: %w", original)
-		}
-		return res, errors.Join(append([]error{fmt.Errorf("update failed; manual recovery required (%s): %w", markerPath(l), original)}, recovery...)...)
-	}
-	m.Complete = true
-	if err = writeJSON(markerPath(l), m); err != nil {
-		res.Warnings = append(res.Warnings, "Files updated, but could not mark cleanup complete: "+markerPath(l))
-		return res, nil
-	}
-	if err = i.cleanPrevious(l); err != nil {
-		res.Warnings = append(res.Warnings, err.Error())
-	}
-	if err = os.RemoveAll(b.Dir); err != nil {
-		res.Warnings = append(res.Warnings, "Could not remove update staging: "+b.Dir)
-	}
-	return res, nil
-}
-func copyExclusive(source, target string, mode os.FileMode) (err error) {
-	in, err := os.Open(source)
-	if err != nil {
-		return err
-	}
-	defer in.Close()
-	out, err := os.OpenFile(target, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err != nil {
-			os.Remove(target)
-		}
-	}()
-	_, err = io.Copy(out, in)
-	closeErr := out.Close()
-	if err != nil {
-		return err
-	}
-	return closeErr
-}
-func (i Installer) cleanPrevious(l Layout) error {
-	var m installMarker
-	err := readJSON(markerPath(l), 8192, &m)
-	if os.IsNotExist(err) {
-		return nil
-	}
-	if err != nil {
-		return fmt.Errorf("unreadable update recovery record %s: %w", markerPath(l), err)
-	}
-	if !m.Complete {
-		return fmt.Errorf("incomplete update; inspect recovery record %s before retrying", markerPath(l))
-	}
-	if _, err = uuid.Parse(m.ID); err != nil || len(m.Files) != 2 {
-		return fmt.Errorf("invalid update recovery record")
-	}
-	for idx, r := range m.Files {
-		target := l.CLI
-		if idx == 1 {
-			target = l.Helper
-		}
-		prefix := filepath.Join(filepath.Dir(target), "."+filepath.Base(target)+".vip-update-"+m.ID)
-		if r.Target != target || r.Backup != prefix+"-old" || r.New != prefix+"-new" || strings.Contains(m.ID, "/") {
-			return fmt.Errorf("invalid update recovery paths")
-		}
-		for _, p := range []string{r.New, r.Backup} {
-			if _, e := regularFile(p); os.IsNotExist(e) {
-				continue
-			} else if e != nil {
-				return e
-			}
-			remove := i.Remove
-			if remove == nil {
-				remove = os.Remove
-			}
-			if e := remove(p); e != nil {
-				return fmt.Errorf("updated files are installed; cannot yet remove backup %s: %w", p, e)
-			}
-		}
-	}
-	return os.Remove(markerPath(l))
-}