devrites 4.6.0 → 5.0.0

package/engine/internal/install/preflight.go

@@ -0,0 +1,235 @@
+package install
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/devrites/devrites/internal/hostpack"
+	"github.com/devrites/devrites/internal/safepath"
+)
+
+func (r *runner) preflightInstall() error {
+	desired, err := r.desiredInstallPaths()
+	if err != nil {
+		return fmt.Errorf("preflight install paths: %w", err)
+	}
+	var conflicts []string
+	for rel := range desired {
+		snapshot, err := r.rememberPath(rel)
+		if err != nil {
+			return err
+		}
+		record, managed := r.prev[rel]
+		if managed && !snapshot.missing {
+			if kind := managedConflict(record, snapshot); kind != "" && !r.opts.Force {
+				conflicts = append(conflicts, fmt.Sprintf("%s: %s", kind, rel))
+			}
+		}
+	}
+	for rel, record := range r.prev {
+		if desired[rel] || hostpack.PreserveOnPrune(rel) {
+			continue
+		}
+		snapshot, err := r.rememberPath(rel)
+		if err != nil {
+			return err
+		}
+		if !snapshot.missing {
+			if kind := managedConflict(record, snapshot); kind != "" && !r.opts.Force {
+				conflicts = append(conflicts, fmt.Sprintf("%s: %s", kind, rel))
+			}
+		}
+		if merge, ok := hostpack.ManagedMergeForMarker(rel); ok {
+			if _, err := r.rememberPath(merge.TargetRel); err != nil {
+				return err
+			}
+		}
+	}
+	for _, rel := range r.installMergeTargets() {
+		if _, err := r.rememberPath(rel); err != nil {
+			return err
+		}
+	}
+	if _, err := r.rememberPath(ManifestName); err != nil {
+		return err
+	}
+	return managedConflictError(conflicts)
+}
+
+func (r *runner) preflightUninstall(entries []string) error {
+	var conflicts []string
+	for _, rel := range entries {
+		if merge, ok := hostpack.ManagedMergeForMarker(rel); ok {
+			if _, err := r.rememberPath(merge.TargetRel); err != nil {
+				return err
+			}
+		}
+		if !hostpack.ShouldRemoveOnUninstall(rel, entries) {
+			continue
+		}
+		snapshot, err := r.rememberPath(rel)
+		if err != nil {
+			return err
+		}
+		if snapshot.missing {
+			continue
+		}
+		if kind := managedConflict(r.prev[rel], snapshot); kind != "" && !r.opts.Force {
+			conflicts = append(conflicts, fmt.Sprintf("%s: %s", kind, rel))
+		}
+	}
+	if _, err := r.rememberPath(ManifestName); err != nil {
+		return err
+	}
+	return managedConflictError(conflicts)
+}
+
+func (r *runner) desiredInstallPaths() (map[string]bool, error) {
+	out := map[string]bool{".devrites/README.md": true}
+	for _, tree := range hostpack.InstallTrees(r.opts.WithSkills, r.opts.WithAgents, r.opts.WithCodex, r.opts.WithOmp) {
+		err := fs.WalkDir(r.payloadFS, tree.PayloadPrefix, func(path string, d fs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if d.IsDir() {
+				return nil
+			}
+			rel, err := filepath.Rel(tree.PayloadPrefix, path)
+			if err != nil {
+				return err
+			}
+			out[filepath.ToSlash(filepath.Join(tree.TargetPrefix, rel))] = true
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+	if r.opts.WithSkills && r.opts.AliasMode == "all" {
+		for _, alias := range hostpack.Aliases {
+			for _, rel := range hostpack.AliasTargets(alias, r.opts.WithCodex, r.opts.WithOmp) {
+				out[rel] = true
+			}
+		}
+	}
+	if r.opts.WithSkills && r.opts.WithCodex {
+		out[hostpack.CodexAgentsMerge.MarkerRel] = true
+		out[hostpack.CodexConfigMerge.MarkerRel] = true
+	}
+	if r.opts.WithSkills {
+		out[hostpack.ClaudeSettingsMerge.MarkerRel] = true
+	}
+	return out, nil
+}
+
+func (r *runner) installMergeTargets() []string {
+	var out []string
+	if r.opts.WithSkills {
+		out = append(out, hostpack.ClaudeSettingsMerge.TargetRel)
+		if r.opts.WithCodex {
+			out = append(out, hostpack.CodexAgentsMerge.TargetRel, hostpack.CodexConfigMerge.TargetRel)
+		}
+	}
+	return out
+}
+
+func (r *runner) rememberPath(rel string) (pathSnapshot, error) {
+	rel = filepath.ToSlash(rel)
+	if snapshot, ok := r.preflight[rel]; ok {
+		return snapshot, nil
+	}
+	snapshot, err := inspectManagedPath(r.target, rel)
+	if err != nil {
+		return pathSnapshot{}, err
+	}
+	r.preflight[rel] = snapshot
+	return snapshot, nil
+}
+
+func (r *runner) recheckPath(rel string) error {
+	rel = filepath.ToSlash(rel)
+	before, ok := r.preflight[rel]
+	if !ok {
+		return fmt.Errorf("path %s was not preflighted", rel)
+	}
+	now, err := inspectManagedPath(r.target, rel)
+	if err != nil {
+		return err
+	}
+	if now != before {
+		return fmt.Errorf("refusing to change %s: file changed after preflight; retry the operation", rel)
+	}
+	return nil
+}
+
+func inspectManagedPath(target, rel string) (pathSnapshot, error) {
+	native := filepath.FromSlash(rel)
+	if !filepath.IsLocal(native) {
+		return pathSnapshot{}, fmt.Errorf("refusing unsafe managed path %q", rel)
+	}
+	dest := filepath.Join(target, native)
+	if !safepath.WithinResolved(dest, target) {
+		return pathSnapshot{}, fmt.Errorf("refusing managed path outside target: %s", rel)
+	}
+	walk := target
+	parts := strings.Split(native, string(filepath.Separator))
+	for _, part := range parts {
+		walk = filepath.Join(walk, part)
+		info, err := os.Lstat(walk)
+		if os.IsNotExist(err) {
+			return pathSnapshot{missing: true}, nil
+		}
+		if err != nil {
+			return pathSnapshot{}, fmt.Errorf("inspect managed path %s: %w", rel, err)
+		}
+		if info.Mode()&os.ModeSymlink != 0 {
+			return pathSnapshot{}, fmt.Errorf("refusing symlink or junction in managed path: %s", rel)
+		}
+	}
+	info, err := os.Lstat(dest)
+	if os.IsNotExist(err) {
+		return pathSnapshot{missing: true}, nil
+	}
+	if err != nil {
+		return pathSnapshot{}, fmt.Errorf("inspect managed path %s: %w", rel, err)
+	}
+	if !info.Mode().IsRegular() {
+		return pathSnapshot{}, fmt.Errorf("refusing non-regular managed path: %s", rel)
+	}
+	// #nosec G304 -- managed path snapshot; regular-file check above
+	f, err := os.Open(dest)
+	if err != nil {
+		return pathSnapshot{}, fmt.Errorf("read managed path %s: %w", rel, err)
+	}
+	defer func() { _ = f.Close() }()
+	sum := sha256.New()
+	if _, err := io.Copy(sum, f); err != nil {
+		return pathSnapshot{}, fmt.Errorf("hash managed path %s: %w", rel, err)
+	}
+	return pathSnapshot{hash: "sha256:" + hex.EncodeToString(sum.Sum(nil))}, nil
+}
+
+func managedConflict(record managedRecord, snapshot pathSnapshot) string {
+	if record.Hash == "" {
+		return "legacy manifest entry (no hash)"
+	}
+	if record.Hash != snapshot.hash {
+		return "customized managed file"
+	}
+	return ""
+}
+
+func managedConflictError(conflicts []string) error {
+	if len(conflicts) == 0 {
+		return nil
+	}
+	sort.Strings(conflicts)
+	return fmt.Errorf("managed files differ from the install manifest:\n  %s\nrerun with --force to replace or remove these files", strings.Join(conflicts, "\n  "))
+}

package/engine/internal/install/uninstall.go

@@ -0,0 +1,119 @@
+package install
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/devrites/devrites/internal/hostpack"
+)
+
+func (r *runner) uninstall() error {
+	mf := filepath.Join(r.target, ManifestName)
+	entries, err := readManifestList(mf)
+	if err != nil {
+		return err
+	}
+	if len(entries) == 0 {
+		return fmt.Errorf("no DevRites manifest at %s - nothing to uninstall", mf)
+	}
+	fmt.Fprintln(r.opts.Stdout, "DevRites uninstaller")
+	fmt.Fprintf(r.opts.Stdout, "  target  : %s\n", r.target)
+	fmt.Fprintf(r.opts.Stdout, "  manifest: %s\n", mf)
+	if r.opts.DryRun {
+		fmt.Fprintln(r.opts.Stdout, "  (dry run - no changes)")
+	}
+	fmt.Fprintln(r.opts.Stdout)
+	if err := r.preflightUninstall(entries); err != nil {
+		return err
+	}
+
+	for _, rel := range entries {
+		merge, ok := hostpack.ManagedMergeForMarker(rel)
+		if !ok {
+			continue
+		}
+		if r.opts.DryRun {
+			fmt.Fprintf(r.opts.Stdout, "  [merge-remove] %s\n", merge.DryRun)
+			continue
+		}
+		if err := r.recheckPath(rel); err != nil {
+			return err
+		}
+		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)
+			}
+			continue
+		}
+		if err := stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End); err != nil {
+			return fmt.Errorf("strip marker block from %s: %w", merge.TargetRel, err)
+		}
+	}
+
+	var dirs []string
+	for _, rel := range entries {
+		if !hostpack.ShouldRemoveOnUninstall(rel, entries) {
+			continue
+		}
+		dest := filepath.Join(r.target, filepath.FromSlash(rel))
+		if exists(dest) {
+			action := "remove"
+			if managedConflict(r.prev[rel], r.preflight[rel]) != "" && r.opts.Force {
+				action = "remove(force-customized)"
+			}
+			if r.opts.DryRun {
+				fmt.Fprintf(r.opts.Stdout, "  [%s] %s\n", action, rel)
+			} else {
+				if err := r.recheckPath(rel); err != nil {
+					return err
+				}
+				if err := os.Remove(dest); err != nil && !os.IsNotExist(err) {
+					return fmt.Errorf("remove %s: %w", rel, err)
+				}
+			}
+			dirs = append(dirs, filepath.Dir(dest))
+			r.stats.removed++
+		} else {
+			r.stats.missing++
+		}
+	}
+	if r.opts.DryRun {
+		fmt.Fprintf(r.opts.Stdout, "  [remove] %s\n", ManifestName)
+	} else {
+		if err := r.recheckPath(ManifestName); err != nil {
+			return err
+		}
+		_ = os.Remove(mf)
+		dirs = append(dirs, filepath.Dir(mf))
+		for _, d := range dirs {
+			pruneEmptyDirs(d, r.target)
+		}
+	}
+	if err := r.removeBinary(); err != nil {
+		return fmt.Errorf("remove engine binary: %w", err)
+	}
+	fmt.Fprintln(r.opts.Stdout)
+	if r.opts.DryRun {
+		fmt.Fprintln(r.opts.Stdout, "DevRites uninstall plan complete (dry run)")
+	} else {
+		fmt.Fprintln(r.opts.Stdout, "DevRites uninstalled")
+	}
+	fmt.Fprintf(r.opts.Stdout, "  removed: %d   already-absent: %d\n", r.stats.removed, r.stats.missing)
+	if exists(filepath.Join(r.target, ".devrites", "work")) {
+		fmt.Fprintln(r.opts.Stdout, "  kept .devrites/work/ (your feature data)")
+	}
+	if exists(filepath.Join(r.target, ".devrites", "ACTIVE")) {
+		fmt.Fprintln(r.opts.Stdout, "  kept .devrites/ACTIVE (active-feature cursor)")
+	}
+	return nil
+}

package/engine/internal/install/update.go

@@ -0,0 +1,185 @@
+package install
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/devrites/devrites/internal/hostpack"
+	"github.com/devrites/devrites/internal/release"
+)
+
+func runUpdate(opts Options) error {
+	target, err := filepath.Abs(opts.Target)
+	if err != nil {
+		return fmt.Errorf("resolve target %s: %w", opts.Target, err)
+	}
+	mf := filepath.Join(target, ManifestName)
+	if !exists(mf) {
+		return fmt.Errorf("no DevRites install found at %s (missing %s)", target, ManifestName)
+	}
+	installed := manifestHeader(mf, "devrites-version")
+	if installed == "" {
+		installed = "unknown"
+	}
+	if opts.SourceDir == "" {
+		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 {
+		return fmt.Errorf("resolve source %s: %w", opts.SourceDir, err)
+	}
+	candidate := installedVersion(source)
+	if candidate == "" || candidate == "unknown" {
+		return fmt.Errorf("derive update version from local source %s: package.json has no version", source)
+	}
+	candidate = strings.TrimPrefix(candidate, "v")
+	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.")
+			return nil
+		}
+		return fmt.Errorf("update available: %s -> %s", installed, candidate)
+	}
+	if !opts.Force && (installed == candidate || strings.TrimPrefix(installed, "v") == candidate) {
+		fmt.Fprintln(opts.Stdout, "already up to date (use --force to reinstall).")
+		return nil
+	}
+	if opts.PayloadDir == "" {
+		return fmt.Errorf("update requires --payload-dir with the locally prepared host payload")
+	}
+	payload, err := filepath.Abs(opts.PayloadDir)
+	if err != nil {
+		return fmt.Errorf("resolve payload %s: %w", opts.PayloadDir, err)
+	}
+	if err := hostpack.ValidatePayload(os.DirFS(payload), true, true); err != nil {
+		return fmt.Errorf("local update payload under %s is invalid: %w", payload, err)
+	}
+	installFlags := manifestHeader(mf, "devrites-flags")
+	next := DefaultOptions(ModeInstall)
+	next.Stdout = opts.Stdout
+	next.Stderr = opts.Stderr
+	if installFlags != "" {
+		if err := parseArgs(strings.Fields(installFlags), &next); err != nil {
+			return fmt.Errorf("parse manifest install flags: %w", err)
+		}
+	}
+	next.Target = target
+	next.PayloadDir = payload
+	next.SourceDir = source
+	next.Force = opts.Force
+	if opts.DryRun {
+		next.DryRun = true
+	}
+	r, err := newRunner(next)
+	if err != nil {
+		return fmt.Errorf("prepare installer: %w", err)
+	}
+	r.requiredBinaryTag = "v" + candidate
+	if next.WithBinary && os.Getenv("DEVRITES_NO_BINARY") != "1" && !next.DryRun {
+		staged, cleanup, err := r.acquireBinary(r.requiredBinaryTag)
+		if err != nil {
+			return fmt.Errorf("prepare engine binary: %w", err)
+		}
+		defer cleanup()
+		r.preparedBinary = staged
+	}
+	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")
+	}
+	// #nosec G204 -- re-execs the located engine binary with fixed migration args
+	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
+}

package/engine/internal/lib/candidate.go

@@ -103,11 +103,12 @@ func readBoundedRegularFile(name string, limit int64) ([]byte, error) {
 	if before.Size() < 0 || before.Size() > limit {
 		return nil, fmt.Errorf("artifact exceeds %s limit", byteLimitName(limit))
 	}
+	// #nosec G304 -- candidate artifact path; size cap checked above
 	file, err := os.Open(name)
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	defer func() { _ = file.Close() }()
 	opened, err := file.Stat()
 	if err != nil {
 		return nil, err
@@ -440,11 +441,12 @@ func hashCandidateFile(digest hash.Hash, project string, row candidateRow) error
 		return errors.New("present path disappeared before reading")
 	}
 	name := filepath.Join(project, filepath.FromSlash(row.path))
+	// #nosec G304 -- row path validated against the workspace contract (validateCandidateRow)
 	file, err := os.Open(name)
 	if err != nil {
 		return err
 	}
-	defer file.Close()
+	defer func() { _ = file.Close() }()
 	opened, err := file.Stat()
 	if err != nil {
 		return err

package/engine/internal/lib/candidate_test.go

@@ -45,6 +45,9 @@ func writeCandidateTestWorkspace(t *testing.T, manifest string) (project, root s
 			t.Fatal(err)
 		}
 	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| schema | 3 |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
 	return project, root
 }
 
@@ -432,7 +435,7 @@ func TestCandidateIdentityRejectsSpecialFile(t *testing.T) {
 	if err != nil {
 		t.Skipf("Unix-domain sockets unavailable: %v", err)
 	}
-	defer listener.Close()
+	defer func() { _ = listener.Close() }()
 	if _, _, err := CandidateIdentity(root, "feature"); err == nil || !strings.Contains(err.Error(), "regular file") {
 		t.Fatalf("error=%v, want special-file rejection", err)
 	}

package/engine/internal/lib/closeout.go

@@ -37,6 +37,10 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "state close: invalid workspace for %s: %v\n", slug, err)
 		return 1
 	}
+	if err := state.RequireWorkspaceSchema(dv, slug); err != nil {
+		fmt.Fprintf(stderr, "state close: %v\n", err)
+		return 3
+	}
 	archiveDir, err := devritespaths.ArchiveDirChecked(dv)
 	if err != nil {
 		fmt.Fprintf(stderr, "state close: invalid archive directory: %v\n", err)

package/engine/internal/lib/closeout_test.go

@@ -28,7 +28,7 @@ func runCloseOut(t *testing.T, root string, args ...string) (int, string) {
 
 func TestCloseOutRejectsRootOverrideArgument(t *testing.T) {
 	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n")
+	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 3\n")
 
 	code, out := runCloseOut(t, root, "feat", t.TempDir())
 	if code != 4 || !strings.Contains(out, "usage: devrites-engine state close <slug>") {
@@ -65,7 +65,7 @@ func TestCloseOutRejectsWorkspaceSymlinkEscape(t *testing.T) {
 func TestCloseOutRejectsArchiveSymlinkEscape(t *testing.T) {
 	root := t.TempDir()
 	outside := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n")
+	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 3\n")
 	if err := os.Symlink(outside, filepath.Join(root, "archive")); err != nil {
 		t.Skipf("symlinks unavailable: %v", err)
 	}
@@ -92,7 +92,7 @@ func TestCloseOutRollsBackArchiveWhenActiveCannotBeCleared(t *testing.T) {
 		t.Skip("permission model differs on Windows")
 	}
 	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n")
+	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 3\n")
 	writeFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
 	if err := os.MkdirAll(filepath.Join(root, "archive"), 0o755); err != nil {
 		t.Fatal(err)