devrites 4.0.0 → 4.0.2

package/engine/internal/install/install.go

@@ -23,6 +23,7 @@ import (
 	"github.com/devrites/devrites/internal/devritespaths"
 	"github.com/devrites/devrites/internal/fsutil"
 	"github.com/devrites/devrites/internal/hostpack"
+	"github.com/devrites/devrites/internal/release"
 	"github.com/devrites/devrites/internal/safepath"
 	"github.com/devrites/devrites/internal/version"
 )
@@ -215,7 +216,7 @@ func usage(mode Mode) string {
 	case ModeUninstall:
 		return "usage: devrites-engine uninstall [--target DIR] [--dry-run] [--force] [--keep-binary]\n"
 	case ModeUpdate:
-		return "usage: devrites-engine update [--target DIR] [--source-dir DIR] [--payload-dir DIR] [--dry-run] [--force] [--check] [install flags]\n"
+		return "usage: devrites-engine update [--target DIR] [--dry-run] [--force] [--check] [install flags] [--source-dir DIR --payload-dir DIR]\n"
 	default:
 		return "usage: devrites-engine install [--target DIR] [--dry-run] [--force] [--no-codex] [--no-agents] [--no-skills] [--no-binary] [--short-aliases=all]\n"
 	}
@@ -925,7 +926,11 @@ func (r *runner) pruneDropped() error {
 				if err := r.recheckPath(merge.TargetRel); err != nil {
 					return err
 				}
-				if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
+				if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel {
+					if err := stripHooksPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))); err != nil {
+						return fmt.Errorf("strip hooks from %s: %w", merge.TargetRel, err)
+					}
+				} else if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
 					_ = r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true)
 				} else {
 					_ = stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End)
@@ -1023,6 +1028,12 @@ func (r *runner) uninstall() error {
 		if err := r.recheckPath(merge.TargetRel); err != nil {
 			return err
 		}
+		if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel {
+			if err := stripHooksPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))); err != nil {
+				return fmt.Errorf("strip hooks from %s: %w", merge.TargetRel, err)
+			}
+			continue
+		}
 		if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
 			if err := r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true); err != nil {
 				return fmt.Errorf("strip DevRites settings from %s: %w", merge.TargetRel, err)
@@ -1092,6 +1103,26 @@ func (r *runner) uninstall() error {
 	return nil
 }
 
+func stripHooksPath(path string) error {
+	current, err := readJSON(path)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return nil
+		}
+		return fmt.Errorf("load hooks config: %w", err)
+	}
+	next := stripDevritesHooks(current)
+	if len(next) == 0 {
+		return os.Remove(path)
+	}
+	data, err := json.MarshalIndent(next, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode hooks config: %w", err)
+	}
+	data = append(data, '\n')
+	return fsutil.WriteFileAtomic(path, data, 0o644)
+}
+
 func (r *runner) stripClaudeSettings(path string, preserveEmpty bool) error {
 	current, err := readJSON(path)
 	if err != nil {
@@ -1126,7 +1157,10 @@ func runUpdate(opts Options) error {
 		installed = "unknown"
 	}
 	if opts.SourceDir == "" {
-		return fmt.Errorf("update requires --source-dir with the locally acquired source")
+		if opts.PayloadDir != "" {
+			return fmt.Errorf("local update with --payload-dir also requires --source-dir")
+		}
+		return runRemoteUpdate(opts, target, installed)
 	}
 	source, err := filepath.Abs(opts.SourceDir)
 	if err != nil {
@@ -1137,10 +1171,12 @@ func runUpdate(opts Options) error {
 		return fmt.Errorf("derive update version from local source %s: package.json has no version", source)
 	}
 	candidate = strings.TrimPrefix(candidate, "v")
-	fmt.Fprintln(opts.Stdout, "DevRites update")
-	fmt.Fprintf(opts.Stdout, "  project:   %s\n", target)
-	fmt.Fprintf(opts.Stdout, "  installed: %s\n", installed)
-	fmt.Fprintf(opts.Stdout, "  candidate: %s\n", candidate)
+	if os.Getenv("DEVRITES_UPDATE_HANDOFF") != "1" {
+		fmt.Fprintln(opts.Stdout, "DevRites update")
+		fmt.Fprintf(opts.Stdout, "  project:   %s\n", target)
+		fmt.Fprintf(opts.Stdout, "  installed: %s\n", installed)
+		fmt.Fprintf(opts.Stdout, "  candidate: %s\n", candidate)
+	}
 	if opts.UpdateCheck {
 		if installed == candidate || strings.TrimPrefix(installed, "v") == candidate {
 			fmt.Fprintln(opts.Stdout, "up to date.")
@@ -1194,6 +1230,89 @@ func runUpdate(opts Options) error {
 	return r.install()
 }
 
+var (
+	resolveLatestRelease = release.Latest
+	acquireRelease       = release.Acquire
+)
+
+func runRemoteUpdate(opts Options, target, installed string) error {
+	repository := os.Getenv("DEVRITES_REPO")
+	if repository == "" {
+		repository = release.DefaultRepository
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer cancel()
+	tag, err := resolveLatestRelease(ctx, repository)
+	if err != nil {
+		return err
+	}
+	latest := strings.TrimPrefix(tag, "v")
+	fmt.Fprintln(opts.Stdout, "DevRites update")
+	fmt.Fprintf(opts.Stdout, "  project:   %s\n", target)
+	fmt.Fprintf(opts.Stdout, "  installed: %s\n", installed)
+	fmt.Fprintf(opts.Stdout, "  latest:    %s\n", latest)
+	if opts.UpdateCheck {
+		if installed == latest || strings.TrimPrefix(installed, "v") == latest {
+			fmt.Fprintln(opts.Stdout, "up to date.")
+			return nil
+		}
+		return fmt.Errorf("update available: %s -> %s", installed, latest)
+	}
+	if !opts.Force && (installed == latest || strings.TrimPrefix(installed, "v") == latest) {
+		fmt.Fprintln(opts.Stdout, "already up to date (use --force to reinstall).")
+		return nil
+	}
+	candidate, cleanup, err := acquireRelease(ctx, repository, tag)
+	if err != nil {
+		return fmt.Errorf("acquire update %s: %w", tag, err)
+	}
+	defer cleanup()
+	fmt.Fprintf(opts.Stdout, "  bundle:   %s\n", candidate.BundleURL)
+	if _, err := verifyEngineBinary(candidate.EnginePath, tag, 30*time.Second); err != nil {
+		return fmt.Errorf("verify update engine: %w", err)
+	}
+	args := []string{
+		"update",
+		"--target", target,
+		"--source-dir", candidate.SourceDir,
+		"--payload-dir", candidate.PayloadDir,
+	}
+	if opts.DryRun {
+		args = append(args, "--dry-run")
+	}
+	if opts.Force {
+		args = append(args, "--force")
+	}
+	cmd := exec.CommandContext(ctx, candidate.EnginePath, args...)
+	cmd.Stdout = opts.Stdout
+	cmd.Stderr = opts.Stderr
+	cmd.Env = replaceEnv(os.Environ(), map[string]string{
+		"DEVRITES_ENGINE_CLI":     candidate.EnginePath,
+		"DEVRITES_UPDATE_HANDOFF": "1",
+	})
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("apply update %s: %w", tag, err)
+	}
+	return nil
+}
+
+func replaceEnv(env []string, replacements map[string]string) []string {
+	out := make([]string, 0, len(env)+len(replacements))
+	for _, entry := range env {
+		name, _, found := strings.Cut(entry, "=")
+		if found {
+			if _, replace := replacements[name]; replace {
+				continue
+			}
+		}
+		out = append(out, entry)
+	}
+	for name, value := range replacements {
+		out = append(out, name+"="+value)
+	}
+	return out
+}
+
 func stripMarkerPath(path, begin, end string) error {
 	data, err := os.ReadFile(path)
 	if err != nil {
@@ -1310,9 +1429,12 @@ func stripDevritesHooks(config map[string]any) map[string]any {
 		}
 		next[k] = v
 	}
-	rawHooks, ok := next["hooks"].(map[string]any)
+	rawHooksValue, exists := next["hooks"]
+	if !exists {
+		return next
+	}
+	rawHooks, ok := rawHooksValue.(map[string]any)
 	if !ok {
-		delete(next, "hooks")
 		return next
 	}
 	hooks := map[string]any{}

package/engine/internal/install/install_test.go

@@ -2,17 +2,20 @@ package install
 
 import (
 	"bytes"
+	"context"
 	"crypto/sha256"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/devrites/devrites/internal/hostpack"
+	"github.com/devrites/devrites/internal/release"
 	"github.com/devrites/devrites/internal/testutil"
 )
 
@@ -483,6 +486,36 @@ func buildVersionBinary(t *testing.T, version string) string {
 	return binary
 }
 
+func buildUpdateHandoffBinary(t *testing.T, version string) string {
+	t.Helper()
+	dir := t.TempDir()
+	source := filepath.Join(dir, "main.go")
+	testutil.WriteFile(t, source, fmt.Sprintf(`package main
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+func main() {
+	if len(os.Args) == 2 && os.Args[1] == "version" {
+		fmt.Println(%q)
+		return
+	}
+	output := strings.Join(os.Args[1:], "\n") + "\n" +
+		"DEVRITES_UPDATE_HANDOFF=" + os.Getenv("DEVRITES_UPDATE_HANDOFF") + "\n" +
+		"DEVRITES_ENGINE_CLI=" + os.Getenv("DEVRITES_ENGINE_CLI") + "\n"
+	if err := os.WriteFile(os.Getenv("DEVRITES_TEST_UPDATE_HANDOFF"), []byte(output), 0600); err != nil {
+		panic(err)
+	}
+}
+`, version))
+	binary := filepath.Join(dir, engineBinaryName())
+	if out, err := exec.Command("go", "build", "-o", binary, source).CombinedOutput(); err != nil {
+		t.Fatalf("build update handoff engine: %v\n%s", err, out)
+	}
+	return binary
+}
+
 func TestBinaryCandidatesSkipsUnsetBinDir(t *testing.T) {
 	t.Setenv("DEVRITES_BIN_DIR", "")
 
@@ -530,6 +563,7 @@ func TestUpdateInstallsLocalPayload(t *testing.T) {
 	opts.Stderr = &bytes.Buffer{}
 	check := opts
 	check.UpdateCheck = true
+	check.PayloadDir = ""
 	if err := Apply(check); err == nil || !strings.Contains(err.Error(), "update available: 1.0.0 -> 2.0.0") {
 		t.Fatalf("update check error = %v, want local candidate report", err)
 	}
@@ -551,6 +585,184 @@ func TestUpdateInstallsLocalPayload(t *testing.T) {
 	}
 }
 
+func TestUpdateAcquiresLatestReleaseAndHandsOff(t *testing.T) {
+	t.Setenv("DEVRITES_NO_BINARY", "1")
+	target := t.TempDir()
+	runInstall(t, target, testPayload(t), func(o *Options) {
+		o.SourceDir = testSource(t, "1.0.0")
+	})
+	source := testSource(t, "2.0.0")
+	payload := testPayload(t)
+	engine := buildUpdateHandoffBinary(t, "2.0.0")
+	marker := filepath.Join(t.TempDir(), "handoff.txt")
+	t.Setenv("DEVRITES_TEST_UPDATE_HANDOFF", marker)
+
+	oldResolve, oldAcquire := resolveLatestRelease, acquireRelease
+	resolveLatestRelease = func(context.Context, string) (string, error) { return "v2.0.0", nil }
+	cleaned := false
+	acquireRelease = func(context.Context, string, string) (release.Candidate, func(), error) {
+		return release.Candidate{
+			SourceDir:  source,
+			PayloadDir: payload,
+			EnginePath: engine,
+			BundleURL:  "https://example.invalid/devrites-v2.0.0.tar.gz",
+		}, func() { cleaned = true }, nil
+	}
+	t.Cleanup(func() {
+		resolveLatestRelease, acquireRelease = oldResolve, oldAcquire
+	})
+
+	var stdout, stderr bytes.Buffer
+	opts := DefaultOptions(ModeUpdate)
+	opts.Target = target
+	opts.Stdout = &stdout
+	opts.Stderr = &stderr
+	if err := Apply(opts); err != nil {
+		t.Fatalf("remote update: %v\n%s", err, stderr.String())
+	}
+	if !cleaned {
+		t.Fatal("remote update did not clean acquired release")
+	}
+	handoff := testutil.ReadFile(t, marker)
+	for _, want := range []string{
+		"update\n",
+		"--target\n" + target + "\n",
+		"--source-dir\n" + source + "\n",
+		"--payload-dir\n" + payload + "\n",
+		"DEVRITES_UPDATE_HANDOFF=1\n",
+		"DEVRITES_ENGINE_CLI=" + engine + "\n",
+	} {
+		if !strings.Contains(handoff, want) {
+			t.Fatalf("handoff missing %q:\n%s", want, handoff)
+		}
+	}
+	if !strings.Contains(stdout.String(), "latest:    2.0.0") || !strings.Contains(stdout.String(), "bundle:   https://example.invalid/") {
+		t.Fatalf("remote update output:\n%s", stdout.String())
+	}
+}
+
+func TestRemoteUpdateCheckDoesNotDownload(t *testing.T) {
+	target := t.TempDir()
+	testutil.WriteFile(t, filepath.Join(target, ManifestName), "# devrites-version: 1.0.0\n")
+	oldResolve, oldAcquire := resolveLatestRelease, acquireRelease
+	resolveLatestRelease = func(context.Context, string) (string, error) { return "v2.0.0", nil }
+	acquireRelease = func(context.Context, string, string) (release.Candidate, func(), error) {
+		t.Fatal("--check downloaded release assets")
+		return release.Candidate{}, func() {}, nil
+	}
+	t.Cleanup(func() {
+		resolveLatestRelease, acquireRelease = oldResolve, oldAcquire
+	})
+	opts := DefaultOptions(ModeUpdate)
+	opts.Target = target
+	opts.UpdateCheck = true
+	opts.Stdout = &bytes.Buffer{}
+	opts.Stderr = &bytes.Buffer{}
+	if err := Apply(opts); err == nil || !strings.Contains(err.Error(), "update available: 1.0.0 -> 2.0.0") {
+		t.Fatalf("remote update check error = %v", err)
+	}
+}
+
+func TestUpdateCleansLegacyCodexHooks(t *testing.T) {
+	t.Setenv("DEVRITES_NO_BINARY", "1")
+	payload := testPayload(t)
+	source := testSource(t, "4.0.0")
+
+	t.Run("preserves user hooks", func(t *testing.T) {
+		target := t.TempDir()
+		hooks := `{
+  "$comment": "DevRites hooks for Codex. Project hooks load only after trust.",
+  "hooks": {"Stop":[{"hooks":[
+    {"type":"command","command":"devrites-engine hook stop-gate --harness=codex"},
+    {"type":"command","command":"echo user"}
+  ]}]}
+}` + "\n"
+		seedLegacyCodexHooksInstall(t, target, hooks)
+
+		runLocalUpdate(t, target, source, payload)
+
+		if exists(filepath.Join(target, ".claude", "devrites.codex-hooks-merge")) {
+			t.Fatal("update kept the legacy Codex hooks marker")
+		}
+		got := testutil.ReadFile(t, filepath.Join(target, ".codex", "hooks.json"))
+		if strings.Contains(got, "devrites-engine hook") || strings.Contains(got, "DevRites hooks") || !strings.Contains(got, "echo user") {
+			t.Fatalf("legacy Codex hook cleanup mismatch:\n%s", got)
+		}
+	})
+
+	t.Run("removes empty hooks file", func(t *testing.T) {
+		target := t.TempDir()
+		hooks := `{"hooks":{"Stop":[{"hooks":[{"type":"command","command":"devrites-engine hook stop-gate --harness=codex"}]}]}}` + "\n"
+		seedLegacyCodexHooksInstall(t, target, hooks)
+
+		runLocalUpdate(t, target, source, payload)
+
+		if exists(filepath.Join(target, ".codex", "hooks.json")) {
+			t.Fatal("update kept an empty legacy Codex hooks file")
+		}
+	})
+
+	t.Run("preserves unrecognized user hook shape", func(t *testing.T) {
+		target := t.TempDir()
+		seedLegacyCodexHooksInstall(t, target, `{"hooks":"user-defined"}`+"\n")
+
+		runLocalUpdate(t, target, source, payload)
+
+		got := testutil.ReadFile(t, filepath.Join(target, ".codex", "hooks.json"))
+		if !strings.Contains(got, `"hooks": "user-defined"`) {
+			t.Fatalf("legacy cleanup removed unrecognized user hooks: %s", got)
+		}
+	})
+
+	t.Run("malformed hooks keep ownership marker", func(t *testing.T) {
+		target := t.TempDir()
+		seedLegacyCodexHooksInstall(t, target, "{\n")
+
+		err := applyUpdate(target, source, payload)
+		if err == nil || !strings.Contains(err.Error(), "load hooks config") {
+			t.Fatalf("update error = %v, want malformed legacy hooks error", err)
+		}
+		if !exists(filepath.Join(target, ".claude", "devrites.codex-hooks-merge")) {
+			t.Fatal("failed cleanup removed the legacy ownership marker")
+		}
+		if got := testutil.ReadFile(t, filepath.Join(target, ".codex", "hooks.json")); got != "{\n" {
+			t.Fatalf("failed cleanup changed hooks: %q", got)
+		}
+	})
+
+	t.Run("uninstall preserves user hooks", func(t *testing.T) {
+		target := t.TempDir()
+		hooks := `{"hooks":{"Stop":[{"hooks":[{"type":"command","command":"devrites-engine hook stop-gate"},{"type":"command","command":"echo user"}]}]}}` + "\n"
+		seedLegacyCodexHooksInstall(t, target, hooks)
+
+		runUninstall(t, target)
+
+		got := testutil.ReadFile(t, filepath.Join(target, ".codex", "hooks.json"))
+		if strings.Contains(got, "devrites-engine hook") || !strings.Contains(got, "echo user") {
+			t.Fatalf("legacy Codex hook uninstall mismatch:\n%s", got)
+		}
+	})
+}
+
+func TestLegacyCodexHooksMergeIsCleanupOnly(t *testing.T) {
+	legacy := hostpack.LegacyCodexHooksMerge
+	merge, ok := hostpack.ManagedMergeForMarker(legacy.MarkerRel)
+	if !ok || merge != legacy {
+		t.Fatalf("legacy marker lookup = %#v, %t", merge, ok)
+	}
+	if slices.Contains(hostpack.RequiredPayload(true), "codex/hooks.json") {
+		t.Fatal("legacy Codex hooks entered the required payload")
+	}
+	r := runner{opts: DefaultOptions(ModeInstall), payloadFS: os.DirFS(testPayload(t))}
+	desired, err := r.desiredInstallPaths()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if desired[legacy.MarkerRel] || desired[legacy.TargetRel] || slices.Contains(r.installMergeTargets(), legacy.TargetRel) {
+		t.Fatalf("legacy Codex hooks entered active install paths: desired=%v merge-targets=%v", desired, r.installMergeTargets())
+	}
+}
+
 func TestUpdateRejectsMissingGeneratedPayload(t *testing.T) {
 	t.Setenv("DEVRITES_NO_BINARY", "1")
 	oldPayload := testPayload(t)
@@ -939,6 +1151,33 @@ func applyInstall(target, payload string, force, dryRun bool, out *bytes.Buffer)
 	return Apply(opts)
 }
 
+func applyUpdate(target, source, payload string) error {
+	opts := DefaultOptions(ModeUpdate)
+	opts.Target = target
+	opts.SourceDir = source
+	opts.PayloadDir = payload
+	opts.Stdout = &bytes.Buffer{}
+	opts.Stderr = &bytes.Buffer{}
+	return Apply(opts)
+}
+
+func runLocalUpdate(t *testing.T, target, source, payload string) {
+	t.Helper()
+	if err := applyUpdate(target, source, payload); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func seedLegacyCodexHooksInstall(t *testing.T, target, hooks string) {
+	t.Helper()
+	markerRel := ".claude/devrites.codex-hooks-merge"
+	marker := []byte(".codex/hooks.json contains DevRites managed hook entries.\n")
+	testutil.WriteFile(t, filepath.Join(target, ".codex", "hooks.json"), hooks)
+	testutil.WriteFile(t, filepath.Join(target, filepath.FromSlash(markerRel)), string(marker))
+	testutil.WriteFile(t, filepath.Join(target, ManifestName), "# DevRites install manifest - do not edit by hand.\n# devrites-version: 3.2.27\n# devrites-flags: \n")
+	addManifestRecord(t, filepath.Join(target, ManifestName), markerRel, marker)
+}
+
 func addManifestRecord(t *testing.T, manifest, rel string, data []byte) {
 	t.Helper()
 	hash := fmt.Sprintf("sha256:%x", sha256.Sum256(data))