@pippit-dev/cli 1.0.41 → 1.0.43

package/internal/space/store_test.go

@@ -0,0 +1,246 @@
+package space
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func testStore(t *testing.T) *Store {
+	t.Helper()
+	return &Store{Dir: t.TempDir(), Account: "account-a", Origin: "https://example.test"}
+}
+
+func TestTaskScopeSurvivesDefaultSwitchAndRejectsConflicts(t *testing.T) {
+	s := testStore(t)
+	a := Selection{TeamID: "12", Name: "A"}
+	b := Selection{TeamID: "34", Name: "B"}
+	ref := References{ThreadID: "thread", RunID: "run", AssetIDs: []string{"asset"}}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.SaveDefault(b); err != nil {
+		t.Fatal(err)
+	}
+	got, err := (&Session{Store: s}).Resolve(ref)
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("old task = %+v, %v", got, err)
+	}
+	got, err = (&Session{Store: s}).Resolve(References{})
+	if err != nil || got.TeamID != "34" {
+		t.Fatalf("new task = %+v, %v", got, err)
+	}
+	if _, err := (&Session{Store: s, Explicit: &b.TeamID}).Resolve(ref); err == nil {
+		t.Fatal("explicit conflicting team accepted")
+	}
+	if _, err := (&Session{Store: s}).Resolve(References{AssetIDs: []string{"asset"}}); err == nil {
+		t.Fatal("cross-team asset accepted")
+	}
+	zero := "0"
+	got, err = (&Session{Store: s, Explicit: &zero}).Resolve(References{})
+	if err != nil || got.TeamID != "0" {
+		t.Fatalf("personal override = %+v, %v", got, err)
+	}
+	current, _ := s.Current()
+	if current.TeamID != "34" {
+		t.Fatal("one-shot override changed saved default")
+	}
+	if err := os.Remove(s.file("thread", "thread")); err != nil {
+		t.Fatal(err)
+	}
+	got, err = (&Session{Store: s}).Resolve(ref)
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("partial task record = %+v, %v", got, err)
+	}
+}
+
+func TestCorruptRecordRequiresExplicitRecovery(t *testing.T) {
+	s := testStore(t)
+	ref := References{ThreadID: "thread", RunID: "run"}
+	a := Selection{TeamID: "12", Name: "A"}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(s.file("run", "run"), []byte("broken"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(ref); err == nil {
+		t.Fatal("corrupt record treated as missing")
+	}
+	other := "34"
+	if _, err := (&Session{Store: s, Explicit: &other}).Resolve(ref); err == nil {
+		t.Fatal("corrupt run overrode valid thread")
+	}
+	if _, err := (&Session{Store: s, Explicit: &a.TeamID}).Resolve(ref); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.Remember(ref, a); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(ref); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(s.file("default", ""), []byte("broken"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := (&Session{Store: s}).Resolve(References{}); err == nil {
+		t.Fatal("corrupt default fell back to personal")
+	}
+	zero := "0"
+	if _, err := (&Session{Store: s, Explicit: &zero}).Resolve(References{}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSpaceIdentityAndInt64Boundary(t *testing.T) {
+	for _, raw := range []string{"", "-1", "1.5", " 12", "+12", "9223372036854775808"} {
+		if _, err := ParseTeamID(raw); err == nil {
+			t.Errorf("accepted %q", raw)
+		}
+	}
+	s := testStore(t)
+	for raw, want := range map[string]string{"0": "0", "000": "0", "00012": "12", "9223372036854775807": "9223372036854775807"} {
+		if got, err := ParseTeamID(raw); err != nil || got != want {
+			t.Errorf("%q = %q, %v", raw, got, err)
+		}
+		if err := s.SaveDefault(Selection{TeamID: raw}); err != nil {
+			t.Fatalf("save %q: %v", raw, err)
+		}
+		if got, err := s.Current(); err != nil || got.TeamID != want {
+			t.Errorf("read saved %q = %+v, %v; want team_id %q", raw, got, err, want)
+		}
+	}
+	a, err := NewStore("https://EXAMPLE.test:443/path", "account-a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, _ := NewStore("https://example.test", "account-a")
+	c, _ := NewStore("https://example.test", "account-b")
+	d, _ := NewStore("https://other.test", "account-a")
+	if a.Dir != b.Dir || a.Dir == c.Dir || a.Dir == d.Dir {
+		t.Fatal("account/origin isolation failed")
+	}
+}
+
+func TestFixedSessionRequiresExplicitRecordRecovery(t *testing.T) {
+	for _, teamID := range []string{"0", "12"} {
+		for _, bindingOnly := range []bool{false, true} {
+			s := testStore(t)
+			selected := Selection{TeamID: teamID}
+			if err := s.SaveDefault(selected); err != nil {
+				t.Fatal(err)
+			}
+			session := &Session{Store: s}
+			if _, err := session.Resolve(References{}); err != nil {
+				t.Fatal(err)
+			}
+			if bindingOnly {
+				binding, err := DecodeBinding(session.Token())
+				if err != nil {
+					t.Fatal(err)
+				}
+				session = &Session{Store: s, Expected: binding}
+			}
+			if err := s.SaveDefault(Selection{TeamID: "34"}); err != nil {
+				t.Fatal(err)
+			}
+			ref := References{ThreadID: "thread", RunID: "run"}
+			if err := s.Remember(ref, selected); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(s.file("run", "run"), []byte("broken"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := session.Resolve(ref); err == nil {
+				t.Fatalf("team %s, binding=%v: fixed space bypassed corrupt record", teamID, bindingOnly)
+			}
+			session.Explicit = &teamID
+			got, err := session.Resolve(ref)
+			if err != nil || got.TeamID != teamID {
+				t.Fatalf("explicit recovery = %+v, %v", got, err)
+			}
+			if err := s.Remember(References{ThreadID: "other"}, Selection{TeamID: "34"}); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := session.Resolve(References{ThreadID: "other"}); err == nil {
+				t.Fatal("fixed space accepted a conflicting task")
+			}
+		}
+	}
+}
+
+func TestSessionWithoutStoreKeepsExplicitSpace(t *testing.T) {
+	for _, teamID := range []string{"0", "12", "34"} {
+		explicit := teamID
+		session := &Session{Explicit: &explicit}
+		selected, err := session.Resolve(References{})
+		if err != nil || selected.TeamID != teamID {
+			t.Fatalf("space = %+v, %v", selected, err)
+		}
+		explicit = "56"
+		selected, err = session.Resolve(References{ThreadID: "thread", RunID: "run"})
+		if err != nil || selected.TeamID != teamID {
+			t.Fatalf("command changed its frozen space: %+v, %v", selected, err)
+		}
+		session.Remember(References{ThreadID: "thread", RunID: "run"})
+		if session.Token() != "" {
+			t.Fatal("unknown account must not produce an identity binding")
+		}
+	}
+	session := &Session{Expected: &Binding{Selection: Personal(), Account: "account", Origin: "https://example.test"}}
+	if _, err := session.Resolve(References{}); err == nil {
+		t.Fatal("identity binding accepted without an identifiable account")
+	}
+}
+
+func TestCommandSessionFreezesScopeAndChecksIdentity(t *testing.T) {
+	s := testStore(t)
+	if err := s.SaveDefault(Selection{TeamID: "12", Name: "A"}); err != nil {
+		t.Fatal(err)
+	}
+	account := s.Account
+	var warning bytes.Buffer
+	session := &Session{Store: s, Stderr: &warning, Identity: func(context.Context) (string, error) { return account, nil }}
+	ctx := context.Background()
+	if _, err := session.Resolve(References{}); err != nil {
+		t.Fatal(err)
+	}
+	token := session.Token()
+	if err := s.SaveDefault(Selection{TeamID: "34", Name: "B"}); err != nil {
+		t.Fatal(err)
+	}
+	got, err := session.Resolve(References{})
+	if err != nil || got.TeamID != "12" {
+		t.Fatalf("session changed = %+v, %v", got, err)
+	}
+	binding, err := DecodeBinding(token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	next := &Session{Store: s, Expected: binding}
+	got, err = next.Resolve(References{})
+	if err != nil || got.TeamID != "12" || next.Token() != token {
+		t.Fatalf("cross-process binding = %+v, %v", got, err)
+	}
+	account = "account-b"
+	if err := session.CheckIdentity(ctx); err == nil {
+		t.Fatal("account switch accepted")
+	}
+	next.Store = &Store{Dir: s.Dir, Account: account, Origin: s.Origin}
+	if _, err := next.Resolve(References{}); err == nil {
+		t.Fatal("binding allowed different account")
+	}
+	// A successful request stays successful even if the record directory fails.
+	blocked := filepath.Join(t.TempDir(), "file")
+	if err := os.WriteFile(blocked, []byte("file"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	s.Dir = blocked
+	session.Remember(References{ThreadID: "created-thread", RunID: "created-run"})
+	if !strings.Contains(warning.String(), "created-run") || !strings.Contains(warning.String(), "不要重复提交") {
+		t.Fatal(warning.String())
+	}
+}

package/internal/version/version.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 	"strings"
 )
 
@@ -17,6 +18,18 @@ type packageJSON struct {
 	Version string `json:"version"`
 }
 
+// BuildVersion identifies the running binary. A local go run/build must not
+// advertise package.json's release version as a verified binary version.
+func BuildVersion() string {
+	if value := strings.TrimSpace(Version); value != "" && value != "dev" {
+		return value
+	}
+	if info, ok := debug.ReadBuildInfo(); ok && info.Main.Version != "" && info.Main.Version != "(devel)" {
+		return strings.TrimPrefix(info.Main.Version, "v")
+	}
+	return "dev"
+}
+
 func Current() string {
 	if strings.TrimSpace(Version) != "" && Version != "dev" {
 		return strings.TrimSpace(Version)

package/internal/version/version_test.go

@@ -0,0 +1,38 @@
+package version
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestBuildVersionNeverInfersAReleaseFromWorkingDirectory(t *testing.T) {
+	previous := Version
+	t.Cleanup(func() { Version = previous })
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "package.json"), []byte(`{"name":"@pippit-dev/cli","version":"99.0.0"}`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	previousDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := os.Chdir(previousDir); err != nil {
+			t.Error(err)
+		}
+	})
+	for _, value := range []string{"", "dev", " dev "} {
+		Version = value
+		if got := BuildVersion(); got != "dev" {
+			t.Fatalf("BuildVersion(%q) = %q", value, got)
+		}
+	}
+	Version = " 1.0.42-canary.1 "
+	if got := BuildVersion(); got != "1.0.42-canary.1" {
+		t.Fatalf("release BuildVersion = %q", got)
+	}
+}

package/internal/versioncheck/check.go

@@ -0,0 +1,147 @@
+// Package versioncheck reports available CLI updates without changing command results.
+package versioncheck
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+const (
+	latestURL        = "https://registry.npmjs.org/@pippit-dev%2Fcli/latest"
+	cacheTTL         = 24 * time.Hour
+	failureTTL       = 5 * time.Minute
+	requestTimeout   = time.Second
+	maxResponseBytes = 64 << 10
+)
+
+type cache struct {
+	Latest    string `json:"latest"`
+	CheckedAt int64  `json:"checkedAt"`
+}
+
+type options struct {
+	cacheFile string
+	now       func() time.Time
+	getenv    func(string) string
+	client    *http.Client
+}
+
+// Check writes notices only to stderr. Registry, cache and output failures never
+// affect the business command, and no background work outlives this call.
+func Check(ctx context.Context, stderr io.Writer, current, command string) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return
+	}
+	check(ctx, stderr, current, command, options{
+		cacheFile: filepath.Join(home, ".pippit_tool_cli", "version-check.json"),
+		now:       time.Now,
+		getenv:    os.Getenv,
+		client: &http.Client{
+			Timeout: requestTimeout,
+			CheckRedirect: func(*http.Request, []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		},
+	})
+}
+
+func check(ctx context.Context, stderr io.Writer, current, command string, opts options) {
+	if command == "" || command == "help" || command == "version" || command == "install" || command == "update" ||
+		opts.getenv("CI") != "" || opts.getenv("PIPPIT_CLI_DISABLE_UPDATE_CHECK") == "1" ||
+		opts.getenv("PIPPIT_CLI_UPDATE_CHECKED") == "1" {
+		return
+	}
+	if _, ok := parseVersion(current); !ok {
+		return
+	}
+	now := opts.now()
+	cached := readCache(opts.cacheFile)
+	ttl := cacheTTL
+	if cached.Latest == "" {
+		ttl = failureTTL
+	}
+	age := now.Sub(time.UnixMilli(cached.CheckedAt))
+	if cached.CheckedAt <= 0 || age < 0 || age >= ttl {
+		cached = cache{Latest: fetchLatest(ctx, opts.client), CheckedAt: now.UnixMilli()}
+		writeCache(opts.cacheFile, cached)
+	}
+	if !isNewer(cached.Latest, current) || stderr == nil {
+		return
+	}
+	_, _ = fmt.Fprintf(stderr, "[pippit-tool-cli] New version available: %s -> %s. Run: pippit-tool-cli update\n", current, cached.Latest)
+	if command == "login" {
+		_, _ = fmt.Fprintln(stderr, "[pippit-tool-cli] If browser authorization fails, update the CLI and run pippit-tool-cli login again.")
+	}
+}
+
+func fetchLatest(ctx context.Context, client *http.Client) string {
+	ctx, cancel := context.WithTimeout(ctx, requestTimeout)
+	defer cancel()
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, latestURL, nil)
+	if err != nil {
+		return ""
+	}
+	response, err := client.Do(request)
+	if err != nil {
+		return ""
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		return ""
+	}
+	data, err := io.ReadAll(io.LimitReader(response.Body, maxResponseBytes+1))
+	if err != nil || len(data) > maxResponseBytes {
+		return ""
+	}
+	var pkg struct {
+		Version string `json:"version"`
+	}
+	if json.Unmarshal(data, &pkg) != nil {
+		return ""
+	}
+	if _, ok := parseVersion(pkg.Version); !ok {
+		return ""
+	}
+	return pkg.Version
+}
+
+func readCache(path string) cache {
+	file, err := os.Open(path)
+	if err != nil {
+		return cache{}
+	}
+	defer file.Close()
+	var value cache
+	if json.NewDecoder(io.LimitReader(file, maxResponseBytes)).Decode(&value) != nil {
+		return cache{}
+	}
+	if value.Latest != "" {
+		if _, ok := parseVersion(value.Latest); !ok {
+			return cache{}
+		}
+	}
+	return value
+}
+
+func writeCache(path string, value cache) {
+	if os.MkdirAll(filepath.Dir(path), 0700) != nil {
+		return
+	}
+	file, err := os.CreateTemp(filepath.Dir(path), ".version-check-*")
+	if err != nil {
+		return
+	}
+	defer os.Remove(file.Name())
+	err = json.NewEncoder(file).Encode(value)
+	closeErr := file.Close()
+	if err == nil && closeErr == nil {
+		_ = os.Rename(file.Name(), path)
+	}
+}

package/internal/versioncheck/check_test.go

@@ -0,0 +1,204 @@
+package versioncheck
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(request *http.Request) (*http.Response, error) { return f(request) }
+
+func testOptions(t *testing.T, transport roundTripFunc) options {
+	t.Helper()
+	return options{
+		cacheFile: filepath.Join(t.TempDir(), "version-check.json"),
+		now:       func() time.Time { return time.UnixMilli(1_800_000_000_000) },
+		getenv:    func(string) string { return "" },
+		client:    &http.Client{Timeout: requestTimeout, Transport: transport},
+	}
+}
+
+func response(body string) *http.Response {
+	return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))}
+}
+
+func TestCheckUsesSharedCacheAndWarnsForEveryInvocation(t *testing.T) {
+	fetches := 0
+	opts := testOptions(t, func(request *http.Request) (*http.Response, error) {
+		fetches++
+		if request.Method != "GET" || request.URL.String() != latestURL || request.Header.Get("Authorization") != "" {
+			t.Fatalf("unexpected registry request: %s %s", request.Method, request.URL)
+		}
+		if deadline, ok := request.Context().Deadline(); !ok || time.Until(deadline) > requestTimeout {
+			t.Fatal("registry request has no bounded context deadline")
+		}
+		return response(`{"version":"1.0.42","unrelated_metadata":true}`), nil
+	})
+	for index := range 2 {
+		var stderr bytes.Buffer
+		check(context.Background(), &stderr, "1.0.41", "login", opts)
+		if strings.Count(stderr.String(), "New version available: 1.0.41 -> 1.0.42") != 1 ||
+			!strings.Contains(stderr.String(), "pippit-tool-cli update") || !strings.Contains(stderr.String(), "authorization fails") {
+			t.Fatalf("invocation %d notice = %q", index, stderr.String())
+		}
+	}
+	if fetches != 1 {
+		t.Fatalf("fetches = %d, want one daily lookup", fetches)
+	}
+	data, err := os.ReadFile(opts.cacheFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var shared map[string]any
+	if json.Unmarshal(data, &shared) != nil || shared["latest"] != "1.0.42" || shared["checkedAt"] != float64(opts.now().UnixMilli()) {
+		t.Fatalf("cache does not match the npm wrapper contract: %s", data)
+	}
+	if info, err := os.Stat(opts.cacheFile); err != nil || info.Mode().Perm() != 0600 {
+		t.Fatalf("cache permissions are not 0600: %v", err)
+	}
+	for _, current := range []string{"1.0.42", "1.0.43"} {
+		var stderr bytes.Buffer
+		check(context.Background(), &stderr, current, "status", opts)
+		if stderr.Len() != 0 {
+			t.Fatalf("up-to-date binary received a notice: %q", stderr.String())
+		}
+	}
+	oldNow := opts.now()
+	opts.now = func() time.Time { return oldNow.Add(cacheTTL) }
+	check(context.Background(), io.Discard, "1.0.41", "status", opts)
+	if fetches != 2 {
+		t.Fatalf("expired daily cache fetches = %d", fetches)
+	}
+}
+
+func TestCheckSkipsDisabledAndNonBusinessInvocations(t *testing.T) {
+	for _, tc := range []struct {
+		name, current, command, env string
+	}{
+		{"dev", "dev", "status", ""}, {"invalid", "1.0", "status", ""},
+		{"empty command", "1.0.41", "", ""}, {"help", "1.0.41", "help", ""},
+		{"version", "1.0.41", "version", ""}, {"install", "1.0.41", "install", ""},
+		{"update", "1.0.41", "update", ""}, {"CI", "1.0.41", "status", "CI"},
+		{"disabled", "1.0.41", "status", "PIPPIT_CLI_DISABLE_UPDATE_CHECK"},
+		{"wrapper checked", "1.0.41", "status", "PIPPIT_CLI_UPDATE_CHECKED"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			opts := testOptions(t, func(*http.Request) (*http.Response, error) {
+				t.Fatal("skipped invocation queried registry")
+				return nil, errors.New("unexpected network")
+			})
+			opts.getenv = func(key string) string {
+				if key == tc.env {
+					return "1"
+				}
+				return ""
+			}
+			var stderr bytes.Buffer
+			check(context.Background(), &stderr, tc.current, tc.command, opts)
+			if _, err := os.Stat(opts.cacheFile); !os.IsNotExist(err) || stderr.Len() != 0 {
+				t.Fatal("skipped invocation wrote cache or output")
+			}
+		})
+	}
+}
+
+func TestFailedChecksStaySilentAndShareFiveMinuteCooldown(t *testing.T) {
+	for _, failure := range []string{"network", "http", "json", "version", "oversize"} {
+		t.Run(failure, func(t *testing.T) {
+			fetches := 0
+			opts := testOptions(t, func(*http.Request) (*http.Response, error) {
+				fetches++
+				switch failure {
+				case "network":
+					return nil, errors.New("offline")
+				case "http":
+					result := response(`{}`)
+					result.StatusCode = http.StatusServiceUnavailable
+					return result, nil
+				case "json":
+					return response(`not json`), nil
+				case "version":
+					return response(`{"version":"dev"}`), nil
+				default:
+					return response(strings.Repeat(" ", maxResponseBytes+1)), nil
+				}
+			})
+			var stderr bytes.Buffer
+			check(context.Background(), &stderr, "1.0.41", "status", opts)
+			cached := readCache(opts.cacheFile)
+			if cached.Latest != "" || cached.CheckedAt != opts.now().UnixMilli() {
+				t.Fatal("failed lookup did not write the shared failure cooldown")
+			}
+			initial := opts.now()
+			opts.now = func() time.Time { return initial.Add(failureTTL - time.Millisecond) }
+			check(context.Background(), &stderr, "1.0.41", "status", opts)
+			if fetches != 1 || stderr.Len() != 0 {
+				t.Fatal("failed lookup retried during cooldown or emitted output")
+			}
+			opts.now = func() time.Time { return initial.Add(failureTTL) }
+			check(context.Background(), &stderr, "1.0.41", "status", opts)
+			if fetches != 2 || stderr.Len() != 0 {
+				t.Fatal("expired failure cooldown did not retry silently")
+			}
+		})
+	}
+}
+
+func TestRegistryLookupHasOneSecondTotalDeadline(t *testing.T) {
+	opts := testOptions(t, func(request *http.Request) (*http.Response, error) {
+		<-request.Context().Done()
+		return nil, request.Context().Err()
+	})
+	start := time.Now()
+	var stderr bytes.Buffer
+	check(context.Background(), &stderr, "1.0.41", "status", opts)
+	if elapsed := time.Since(start); elapsed > 2*time.Second || stderr.Len() != 0 {
+		t.Fatalf("deadline exceeded budget or emitted output: %v / %q", elapsed, stderr.String())
+	}
+}
+
+func TestRegistryOrCacheFailureCannotSuppressKnownNotice(t *testing.T) {
+	opts := testOptions(t, func(*http.Request) (*http.Response, error) {
+		return response(`{"version":"1.0.42"}`), nil
+	})
+	// A regular file in place of the cache directory makes cache persistence fail.
+	blocker := filepath.Join(t.TempDir(), "file")
+	if err := os.WriteFile(blocker, nil, 0600); err != nil {
+		t.Fatal(err)
+	}
+	opts.cacheFile = filepath.Join(blocker, "version-check.json")
+	var stderr bytes.Buffer
+	check(context.Background(), &stderr, "1.0.41", "status", opts)
+	if !strings.Contains(stderr.String(), "New version available") {
+		t.Fatal("cache write failure suppressed a valid update notice")
+	}
+}
+
+func TestSemanticVersionOrderingRejectsInvalidAndDevelopmentVersions(t *testing.T) {
+	for _, tc := range []struct {
+		latest, current string
+		newer           bool
+	}{
+		{"1.0.42", "1.0.41", true}, {"1.1.0", "1.0.99", true}, {"2.0.0", "1.99.99", true},
+		{"1.0.41", "1.0.42", false}, {"1.0.42", "1.0.42+build.1", false},
+		{"1.0.42", "1.0.42-canary.1", true}, {"1.0.42-canary.2", "1.0.42-canary.1", true},
+		{"1.0.42-canary.10", "1.0.42-canary.2", true}, {"1.0.42-beta", "1.0.42-alpha.1", true},
+		{"1.0.42-alpha.1", "1.0.42-alpha", true}, {"v1.0.42", "v1.0.41", true},
+		{"1.0.42", "dev", false}, {"bad", "1.0.41", false}, {"1.0.42", "1.0", false},
+		{"1.0.42", "1.00.41", false}, {"1.0.42", "1.0.41-01", false}, {"1.0.42", "1.0.41 junk", false},
+	} {
+		if got := isNewer(tc.latest, tc.current); got != tc.newer {
+			t.Errorf("isNewer(%q, %q) = %v, want %v", tc.latest, tc.current, got, tc.newer)
+		}
+	}
+}