fix: finalize durable Pi lifecycle

2026-08-04 21:34:08 +02:00
parent 5ba2821a1b
commit a368889838
20 changed files with 1016 additions and 147 deletions
@@ -2,6 +2,7 @@ package pi

 import (
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"io"
@@ -16,15 +17,36 @@ func TestDoctorRequiresExternalEndpointAuthPiStateAndHealth(t *testing.T) {
 	if err := Doctor(context.Background(), fake); err != nil {
 		t.Fatalf("Doctor() error = %v", err)
 	}
-	for _, command := range []string{"pi --version", "test -w /home/thoth/.pi", "test -r /home/thoth/.pi/agent/auth.json", "/health"} {
+	for _, command := range []string{"pi --version", "PI_VERSION", "io.thothii.pi.version", "test -w /home/thoth/.pi", "test -r /home/thoth/.pi/agent/auth.json", "/health"} {
 		assertCalled(t, fake.calls, command)
 	}
 }

+func TestDoctorRejectsActualEnvironmentAndImageLabelVersionMismatches(t *testing.T) {
+	for _, mismatch := range []string{"actual", "environment", "label"} {
+		t.Run(mismatch, func(t *testing.T) {
+			fake := newFakeRunner()
+			switch mismatch {
+			case "actual":
+				fake.version = "0.80.2"
+			case "environment":
+				fake.expectedVersion = "0.80.2"
+			case "label":
+				fake.labelVersion = "0.80.2"
+			}
+			if err := Doctor(context.Background(), fake); err == nil || !strings.Contains(err.Error(), "version") {
+				t.Fatalf("Doctor() error = %v, want expected-version mismatch", err)
+			}
+		})
+	}
+}
+
 func TestConfigureRestoresAndVerifiesOldSettingsAfterEveryPostSnapshotFailure(t *testing.T) {
 	for _, failure := range []string{"helper", "readback", "digest"} {
 		t.Run(failure, func(t *testing.T) {
-			fake := &configureRunner{failure: failure, settings: Defaults{Provider: "old", Model: "old-model", Thinking: "low"}}
+			old := Defaults{Provider: "old", Model: "old-model", Thinking: "low"}
+			raw, _ := json.Marshal(old)
+			fake := &configureRunner{failure: failure, settings: old, settingsExist: true, settingsRaw: raw}
 			err := Configure(context.Background(), fake, Defaults{Provider: "new", Model: "new-model", Thinking: "high"})
 			if err == nil {
 				t.Fatal("Configure() error = nil, want injected failure")
@@ -32,12 +54,8 @@ func TestConfigureRestoresAndVerifiesOldSettingsAfterEveryPostSnapshotFailure(t
 			if fake.settings != (Defaults{Provider: "old", Model: "old-model", Thinking: "low"}) {
 				t.Fatalf("settings after failure = %#v, want old snapshot", fake.settings)
 			}
-			minimumReads := 3
-			if failure == "helper" {
-				minimumReads = 2
-			}
-			if fake.settingsReads < minimumReads {
-				t.Fatalf("settings read count = %d, want capture/failure reads plus verified restore", fake.settingsReads)
+			if !fake.settingsExist || string(fake.settingsRaw) != string(raw) {
+				t.Fatalf("settings raw snapshot after failure = exists:%t raw:%q, want %q", fake.settingsExist, fake.settingsRaw, raw)
 			}
 		})
 	}
@@ -46,11 +64,14 @@ func TestConfigureRestoresAndVerifiesOldSettingsAfterEveryPostSnapshotFailure(t
 type configureRunner struct {
 	failure       string
 	settings      Defaults
+	settingsExist bool
+	settingsRaw   []byte
 	settingsReads int
 	configReads   int
+	writes        int
 }

-func (f *configureRunner) Run(_ context.Context, args []string, _ io.Reader) (compose.Result, error) {
+func (f *configureRunner) Run(_ context.Context, args []string, stdin io.Reader) (compose.Result, error) {
 	call := strings.Join(args, " ")
 	switch {
 	case strings.Contains(call, "config --format json"):
@@ -62,21 +83,50 @@ func (f *configureRunner) Run(_ context.Context, args []string, _ io.Reader) (co
 		return compose.Result{Stdout: `{"services":{"core":{"image":"thothii-core:local","environment":{"THT_LLM_URL":"` + endpoint + `"}}}}`}, nil
 	case strings.Contains(call, "/models"):
 		return compose.Result{Stdout: `{"models":[{"provider":"old","id":"old-model"},{"provider":"new","id":"new-model"}]}`}, nil
+	case strings.Contains(call, "settings-cli.js --snapshot"):
+		raw := f.settingsRaw
+		payload := map[string]any{"exists": f.settingsExist, "rawBase64": base64.StdEncoding.EncodeToString(raw)}
+		contents, _ := json.Marshal(payload)
+		return compose.Result{Stdout: string(contents)}, nil
+	case strings.Contains(call, "settings-cli.js --restore"):
+		var payload struct {
+			Exists    bool   `json:"exists"`
+			RawBase64 string `json:"rawBase64"`
+		}
+		contents, _ := io.ReadAll(stdin)
+		if json.Unmarshal(contents, &payload) != nil {
+			return compose.Result{ExitCode: 2}, errors.New("invalid restore payload")
+		}
+		f.settingsExist = payload.Exists
+		f.settingsRaw, _ = base64.StdEncoding.DecodeString(payload.RawBase64)
+		f.settings = Defaults{Provider: "old", Model: "old-model", Thinking: "low"}
+		if payload.Exists {
+			_ = json.Unmarshal(f.settingsRaw, &f.settings)
+		}
+		return compose.Result{}, nil
 	case strings.Contains(call, "settings-cli.js"):
 		if strings.Contains(call, "--provider new") {
 			f.settings = Defaults{Provider: "new", Model: "new-model", Thinking: "high"}
+			f.settingsExist = true
+			f.settingsRaw, _ = json.MarshalIndent(f.settings, "", "  ")
+			f.writes++
 			if f.failure == "helper" {
 				return compose.Result{ExitCode: 17}, errors.New("injected helper failure")
 			}
 		} else {
 			f.settings = Defaults{Provider: "old", Model: "old-model", Thinking: "low"}
+			f.settingsExist = true
+			f.settingsRaw, _ = json.Marshal(f.settings)
 		}
 		return compose.Result{}, nil
 	case strings.Contains(call, "/settings"):
 		f.settingsReads++
-		if f.failure == "readback" && f.settingsReads == 2 {
+		if f.failure == "readback" && f.settings.Provider == "new" {
 			return compose.Result{Stdout: `{}`}, nil
 		}
+		if !f.settingsExist {
+			return compose.Result{Stdout: `{"provider":"old","model":"old-model","thinking":"low"}`}, nil
+		}
 		contents, _ := json.Marshal(f.settings)
 		return compose.Result{Stdout: string(contents)}, nil
 	default:
@@ -84,6 +134,45 @@ func (f *configureRunner) Run(_ context.Context, args []string, _ io.Reader) (co
 	}
 }

+func TestConfigureAllowsAFirstRunWithoutAnExistingSettingsFile(t *testing.T) {
+	fake := &configureRunner{}
+	if err := Configure(context.Background(), fake, Defaults{Provider: "new", Model: "new-model", Thinking: "high"}); err != nil {
+		t.Fatalf("Configure() clean install error = %v", err)
+	}
+	if !fake.settingsExist || fake.writes != 1 || fake.settings.Provider != "new" {
+		t.Fatalf("clean settings = exists:%t writes:%d value:%#v", fake.settingsExist, fake.writes, fake.settings)
+	}
+}
+
+func TestConfigureCompensationRestoresAbsentAndExactEmptyPriorFiles(t *testing.T) {
+	for _, prior := range []struct {
+		name   string
+		exists bool
+		raw    []byte
+	}{
+		{name: "absent"},
+		{name: "empty", exists: true, raw: []byte{}},
+		{name: "exact raw", exists: true, raw: []byte("{\n  \"workspace\": \"kept\",\n  \"provider\": \"old\",\n  \"model\": \"old-model\",\n  \"thinking\": \"low\"\n}\n")},
+	} {
+		t.Run(prior.name, func(t *testing.T) {
+			fake := &configureRunner{failure: "digest", settingsExist: prior.exists, settingsRaw: append([]byte{}, prior.raw...), settings: Defaults{Provider: "old", Model: "old-model", Thinking: "low"}}
+			err := Configure(context.Background(), fake, Defaults{Provider: "new", Model: "new-model", Thinking: "high"})
+			if err == nil {
+				t.Fatal("Configure() error = nil, want compensated digest failure")
+			}
+			if fake.writes != 1 {
+				t.Fatalf("settings writes = %d, want selected values written before compensation", fake.writes)
+			}
+			if fake.settingsExist != prior.exists || string(fake.settingsRaw) != string(prior.raw) {
+				t.Fatalf("restored exists/raw = %t/%q, want %t/%q", fake.settingsExist, fake.settingsRaw, prior.exists, prior.raw)
+			}
+			if fake.settingsReads < 3 {
+				t.Fatalf("settings reads = %d, want prior effective state, requested readback, and restored default verification", fake.settingsReads)
+			}
+		})
+	}
+}
+
 func TestConfigureValidatesBackendModelOptionsWritesRealCoreSettingsAndUsesUpstreamIdentity(t *testing.T) {
 	fake := newFakeRunner()
 	if err := Configure(context.Background(), fake, Defaults{Provider: "provider", Model: "model", Thinking: "medium"}); err != nil {