jochen
a0deb90741
A removal kept its copy but nothing could put it back without a shell on the machine. claude_code_home_restore puts a kept copy back when nothing is at its path and the copy matches the digests recorded at removal; claude_code_home_removed lists what is kept.
320 lines
12 KiB
Go
320 lines
12 KiB
Go
package main
|
|
|
|
// The person's own items in the home, read and removed on their word (novox/hq ADR 0216 rule 6: removing the
|
|
// original is the person's act — the remove tool is that act made explicit).
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var at = time.Date(2026, 10, 7, 9, 30, 0, 0, time.UTC)
|
|
|
|
func TestEveryKindIsShownInFull(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
_ = os.MkdirAll(filepath.Join(dir, "skills", "old", "scripts"), 0o755)
|
|
writeFile(t, filepath.Join(dir, "rules", "hal-era.md"), "# old rule\n")
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "SKILL.md"), "---\nname: old\n---\n")
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "scripts", "a.sh"), "#!/bin/sh\n")
|
|
writeFile(t, filepath.Join(dir, "CLAUDE.md"), "# my memory\n")
|
|
|
|
rule, err := ShowHome(p, "instructions", "hal-era")
|
|
if err != nil || rule["content"] != "# old rule\n" || rule["placedByTheMesh"] != false {
|
|
t.Fatalf("%v %v", rule, err)
|
|
}
|
|
if again, err := ShowHome(p, "rule", "hal-era.md"); err != nil || again["content"] != "# old rule\n" {
|
|
t.Fatalf("a rule named as a person writes it: %v %v", again, err)
|
|
}
|
|
skill, err := ShowHome(p, KindSkill, "old")
|
|
if files, _ := skill["files"].(map[string]string); err != nil || len(files) != 2 || files["scripts/a.sh"] != "#!/bin/sh\n" {
|
|
t.Fatalf("%v %v", skill, err)
|
|
}
|
|
memory, err := ShowHome(p, KindMemory, "")
|
|
if err != nil || memory["content"] != "# my memory\n" {
|
|
t.Fatalf("%v %v", memory, err)
|
|
}
|
|
if _, err := ShowHome(p, KindAgent, "absent"); err == nil {
|
|
t.Fatal("an absent item was shown")
|
|
}
|
|
for _, name := range []string{"../../etc/passwd", "..", ".credentials", "a/b"} {
|
|
if _, err := ShowHome(p, KindInstructions, name); err == nil {
|
|
t.Errorf("%q reached outside its kind's folder", name)
|
|
}
|
|
}
|
|
if _, err := ShowHome(p, KindHook, "x"); err == nil {
|
|
t.Fatal("a kind the home does not hold was taken")
|
|
}
|
|
// The status tool lists the memory beside the rest.
|
|
found := false
|
|
for _, it := range HomeItems(p, Config{}, Servers{}) {
|
|
found = found || (it.Kind == KindMemory && it.Name == memoryName && !it.Placed)
|
|
}
|
|
if !found {
|
|
t.Fatal("the status does not list the home's memory")
|
|
}
|
|
}
|
|
|
|
func TestARemovalNeedsItsReason(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
writeFile(t, filepath.Join(dir, "rules", "keep.md"), "x")
|
|
if _, err := RemoveHome(p, KindInstructions, "keep", " ", at); err == nil {
|
|
t.Fatal("removed without a reason")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "rules", "keep.md")); err != nil {
|
|
t.Fatal("the file went although the removal was refused")
|
|
}
|
|
}
|
|
|
|
func TestARemovalKeepsACopyAndLogsWhy(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
_ = os.MkdirAll(filepath.Join(dir, "skills", "old", "scripts"), 0o755)
|
|
writeFile(t, filepath.Join(dir, "rules", "hal-era.md"), "# old rule\n")
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "SKILL.md"), "---\nname: old\n---\n")
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "scripts", "a.sh"), "#!/bin/sh\n")
|
|
_ = os.Chmod(filepath.Join(dir, "skills", "old", "scripts", "a.sh"), 0o755)
|
|
|
|
answer, err := RemoveHome(p, KindInstructions, "hal-era", "HAL is retired", at)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "rules", "hal-era.md")); !os.IsNotExist(err) {
|
|
t.Fatal("the rule file is still there")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "rules")); err != nil {
|
|
t.Fatal("the kind's own folder went with it")
|
|
}
|
|
kept, _ := answer["keptAt"].(string)
|
|
want := filepath.Join(p.State, RemovedDir, "2026-10-07", "093000-instructions-hal-era", "rules", "hal-era.md")
|
|
if kept != want {
|
|
t.Fatalf("kept at %s, not %s", kept, want)
|
|
}
|
|
if !strings.HasPrefix(kept, p.State) || strings.HasPrefix(kept, dir) {
|
|
t.Fatal("the copy is inside the agent directory")
|
|
}
|
|
if raw, _ := os.ReadFile(kept); string(raw) != "# old rule\n" {
|
|
t.Fatalf("the copy holds %q", raw)
|
|
}
|
|
|
|
// A second removal in the same second does not overwrite the first's copy.
|
|
writeFile(t, filepath.Join(dir, "rules", "hal-era.md"), "# made again\n")
|
|
second, err := RemoveHome(p, KindInstructions, "hal-era", "again", at)
|
|
if err != nil || second["keptAt"] == kept {
|
|
t.Fatalf("%v %v", second, err)
|
|
}
|
|
if raw, _ := os.ReadFile(kept); string(raw) != "# old rule\n" {
|
|
t.Fatal("the first copy was overwritten")
|
|
}
|
|
|
|
// A skill goes as its whole folder, kept with its modes.
|
|
skill, err := RemoveHome(p, KindSkill, "old", "superseded by the plugin's", at)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "skills", "old")); !os.IsNotExist(err) {
|
|
t.Fatal("the skill's folder is still there")
|
|
}
|
|
script := filepath.Join(skill["keptAt"].(string), "scripts", "a.sh")
|
|
if info, err := os.Stat(script); err != nil || info.Mode().Perm()&0o100 == 0 {
|
|
t.Fatalf("the script's copy lost its executable bit: %v", err)
|
|
}
|
|
|
|
// The log holds every removal, each with its reason.
|
|
raw, err := os.ReadFile(p.removedLog())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
lines := strings.Split(strings.TrimSpace(string(raw)), "\n")
|
|
if len(lines) != 3 {
|
|
t.Fatalf("%d lines logged", len(lines))
|
|
}
|
|
var r Removal
|
|
if err := json.Unmarshal([]byte(lines[0]), &r); err != nil || r.Why != "HAL is retired" || r.Node != "laptop" || r.Kept != kept {
|
|
t.Fatalf("%+v %v", r, err)
|
|
}
|
|
}
|
|
|
|
func TestTheMemoryIsRemovedAndKept(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
writeFile(t, filepath.Join(dir, "CLAUDE.md"), "# HAL era\n")
|
|
answer, err := RemoveHome(p, KindMemory, "", "the managed file says it now", at)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "CLAUDE.md")); !os.IsNotExist(err) {
|
|
t.Fatal("the memory is still there")
|
|
}
|
|
if raw, _ := os.ReadFile(answer["keptAt"].(string)); string(raw) != "# HAL era\n" {
|
|
t.Fatal("the memory was not kept")
|
|
}
|
|
}
|
|
|
|
func TestWhatTheMeshPlacedIsRefused(t *testing.T) {
|
|
p, w := node(t, "laptop")
|
|
state, view := memConfig{}, NewConfigView(p)
|
|
if _, err := Register(p, Item{Kind: KindAgent, Name: "placed", Scope: ScopeHome, Files: one("placed", "v1")}, nil, false, state, view, writer(w)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
full := filepath.Join(p.Home, ".claude", "agents", "placed.md")
|
|
if _, err := os.Stat(full); err != nil {
|
|
t.Fatal("the home item was not placed")
|
|
}
|
|
shown, err := ShowHome(p, KindAgent, "placed")
|
|
if err != nil || shown["placedByTheMesh"] != true {
|
|
t.Fatalf("%v %v", shown, err)
|
|
}
|
|
if _, err := RemoveHome(p, KindAgent, "placed", "tidy", at); err == nil || !strings.Contains(err.Error(), "claude_code_agent_unregister") {
|
|
t.Fatalf("what the mesh placed was not refused: %v", err)
|
|
}
|
|
if _, err := os.Stat(full); err != nil {
|
|
t.Fatal("the mesh's item was removed")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(p.State, RemovedDir)); !os.IsNotExist(err) {
|
|
t.Fatal("a refused removal left a copy")
|
|
}
|
|
}
|
|
|
|
func TestASymbolicLinkIsLeftAlone(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
elsewhere := t.TempDir()
|
|
writeFile(t, filepath.Join(elsewhere, "target.md"), "not the home's")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
if err := os.Symlink(filepath.Join(elsewhere, "target.md"), filepath.Join(dir, "rules", "linked.md")); err != nil {
|
|
t.Skip(err)
|
|
}
|
|
if _, err := RemoveHome(p, KindInstructions, "linked", "x", at); err == nil {
|
|
t.Fatal("a symbolic link was removed")
|
|
}
|
|
if err := os.Symlink(elsewhere, filepath.Join(dir, "skills")); err != nil {
|
|
t.Skip(err)
|
|
}
|
|
_ = os.MkdirAll(filepath.Join(elsewhere, "s"), 0o755)
|
|
writeFile(t, filepath.Join(elsewhere, "s", "SKILL.md"), "x")
|
|
if _, err := RemoveHome(p, KindSkill, "s", "x", at); err == nil {
|
|
t.Fatal("a skill was removed through a linked folder")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(elsewhere, "s", "SKILL.md")); err != nil {
|
|
t.Fatal("what the link points at was removed")
|
|
}
|
|
}
|
|
|
|
func TestARemovalIsListedAndPutBack(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
_ = os.MkdirAll(filepath.Join(dir, "skills", "old", "scripts"), 0o755)
|
|
writeFile(t, filepath.Join(dir, "rules", "hal-era.md"), "# old rule\n")
|
|
_ = os.Chmod(filepath.Join(dir, "rules", "hal-era.md"), 0o644)
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "SKILL.md"), "---\nname: old\n---\n")
|
|
writeFile(t, filepath.Join(dir, "skills", "old", "scripts", "a.sh"), "#!/bin/sh\n")
|
|
_ = os.Chmod(filepath.Join(dir, "skills", "old", "scripts", "a.sh"), 0o755)
|
|
|
|
rule, err := RemoveHome(p, KindInstructions, "hal-era", "HAL is retired", at)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
skill, err := RemoveHome(p, KindSkill, "old", "superseded", at.Add(time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
kept, err := KeptRemovals(p)
|
|
if err != nil || len(kept) != 2 || kept[0].Name != "old" || kept[1].Kept != rule["keptAt"] || kept[1].Restored != "" {
|
|
t.Fatalf("%+v %v", kept, err)
|
|
}
|
|
|
|
back, err := RestoreHome(p, rule["keptAt"].(string), at.Add(time.Hour))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
full := filepath.Join(dir, "rules", "hal-era.md")
|
|
if raw, _ := os.ReadFile(full); string(raw) != "# old rule\n" || back["restored"] != full {
|
|
t.Fatalf("%v: %q", back, raw)
|
|
}
|
|
if info, _ := os.Stat(full); info.Mode().Perm() != 0o644 {
|
|
t.Fatalf("restored as %v, removed as 0644", info.Mode().Perm())
|
|
}
|
|
if _, err := RestoreHome(p, skill["keptAt"].(string), at.Add(time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if info, err := os.Stat(filepath.Join(dir, "skills", "old", "scripts", "a.sh")); err != nil || info.Mode().Perm()&0o100 == 0 {
|
|
t.Fatalf("the skill's script came back without its executable bit: %v", err)
|
|
}
|
|
|
|
// Listed as put back; logged with the removals.
|
|
kept, _ = KeptRemovals(p)
|
|
for _, k := range kept {
|
|
if k.Restored == "" {
|
|
t.Errorf("%s is not listed as put back", k.Kept)
|
|
}
|
|
}
|
|
raw, _ := os.ReadFile(p.removedLog())
|
|
lines := strings.Split(strings.TrimSpace(string(raw)), "\n")
|
|
var last Removal
|
|
if len(lines) != 4 || json.Unmarshal([]byte(lines[2]), &last) != nil || last.Action != "restored" || last.Path != full {
|
|
t.Fatalf("%d lines, %+v", len(lines), last)
|
|
}
|
|
|
|
// Something at the path now: refused, and left as it is.
|
|
if _, err := RestoreHome(p, rule["keptAt"].(string), at); err == nil {
|
|
t.Fatal("restored over what is there now")
|
|
}
|
|
if raw, _ := os.ReadFile(full); string(raw) != "# old rule\n" {
|
|
t.Fatal("what was there was changed")
|
|
}
|
|
}
|
|
|
|
func TestACopyThatChangedIsNotPutBack(t *testing.T) {
|
|
p, _ := node(t, "laptop")
|
|
dir := filepath.Join(p.Home, ".claude")
|
|
_ = os.MkdirAll(filepath.Join(dir, "rules"), 0o755)
|
|
_ = os.MkdirAll(filepath.Join(dir, "skills", "s"), 0o755)
|
|
writeFile(t, filepath.Join(dir, "rules", "r.md"), "original")
|
|
writeFile(t, filepath.Join(dir, "skills", "s", "SKILL.md"), "x")
|
|
rule, _ := RemoveHome(p, KindInstructions, "r", "why", at)
|
|
skill, _ := RemoveHome(p, KindSkill, "s", "why", at)
|
|
|
|
writeFile(t, rule["keptAt"].(string), "tampered")
|
|
if _, err := RestoreHome(p, rule["keptAt"].(string), at); err == nil {
|
|
t.Fatal("a changed copy was put back")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "rules", "r.md")); !os.IsNotExist(err) {
|
|
t.Fatal("something was written from a changed copy")
|
|
}
|
|
// A file added to a kept skill: not what was removed.
|
|
writeFile(t, filepath.Join(skill["keptAt"].(string), "extra.md"), "x")
|
|
if _, err := RestoreHome(p, skill["keptAt"].(string), at); err == nil {
|
|
t.Fatal("a copy with an extra file was put back")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "skills", "s")); !os.IsNotExist(err) {
|
|
t.Fatal("the skill's folder was made from a changed copy")
|
|
}
|
|
// A note pointing elsewhere than its own kind and name: refused.
|
|
note := filepath.Join(filepath.Dir(filepath.Dir(rule["keptAt"].(string))), "removal.json")
|
|
var r Removal
|
|
_ = readJSON(note, &r)
|
|
writeFile(t, rule["keptAt"].(string), "original")
|
|
r.Path = "/etc/passwd"
|
|
raw, _ := json.Marshal(r)
|
|
writeFile(t, note, string(raw))
|
|
if _, err := RestoreHome(p, rule["keptAt"].(string), at); err == nil {
|
|
t.Fatal("a note naming another path was followed")
|
|
}
|
|
// Nothing outside the module's kept copies.
|
|
for _, kept := range []string{"", "/etc/passwd", filepath.Join(p.State, RemovedDir), filepath.Join(p.State, RemovedDir, "..", "config.json")} {
|
|
if _, err := RestoreHome(p, kept, at); err == nil {
|
|
t.Errorf("%q was taken as a kept copy", kept)
|
|
}
|
|
}
|
|
}
|