jschoubben
e46eeb8298
mesh/merge-gate head e46eeb829853 merged into trunk 4d15a155e634 — pass: builds claude-code → ace, g14, novox, shanks; no bus step; every machine composes …
mesh/repo-check head e46eeb829853 merged into trunk 4d15a155e634 — pass: its merge-check.sh passed, each part in its toolchain: merge-check.sh (go), merge-…
mesh/delivery delivered
The runtime hands a watch its current values one at a time and gives them ten seconds. The handler read the state, waited for a running look and wrote files for each value, so with about 450 memory values the watch never started on g14 or shanks, and a file written on g14 never reached shanks. The handler now notes each key's newest revision and returns; a worker applies what was noted at the state's current version.
969 lines
34 KiB
Go
969 lines
34 KiB
Go
package main
|
|
|
|
// A session's memory follows the operator (novox/hq ADR 0343, issue 367). Every test runs against temporary homes
|
|
// and a state in memory with the bus's watch semantics: never the live memory folders.
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// memState is the `memory` state in memory: revisions, create and compare-and-set, and every change handed to every
|
|
// watcher, the writer included, as the bus does.
|
|
type memState struct {
|
|
mu sync.Mutex
|
|
values map[string]json.RawMessage
|
|
revs map[string]uint64
|
|
rev uint64
|
|
pending []change
|
|
watchers []*MemoryCarrier
|
|
}
|
|
|
|
type change struct {
|
|
key, op string
|
|
value json.RawMessage
|
|
rev uint64
|
|
}
|
|
|
|
func newMemState() *memState {
|
|
return &memState{values: map[string]json.RawMessage{}, revs: map[string]uint64{}}
|
|
}
|
|
|
|
var errChanged = errors.New("wrong last revision")
|
|
|
|
func (s *memState) Get(key string) (json.RawMessage, uint64, bool, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
v, ok := s.values[key]
|
|
return v, s.revs[key], ok, nil
|
|
}
|
|
|
|
func (s *memState) write(key string, value any) {
|
|
raw, _ := json.Marshal(value)
|
|
s.rev++
|
|
s.values[key], s.revs[key] = raw, s.rev
|
|
s.pending = append(s.pending, change{key, "put", raw, s.rev})
|
|
}
|
|
|
|
func (s *memState) Create(key string, value any) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if _, ok := s.values[key]; ok {
|
|
return errChanged
|
|
}
|
|
s.write(key, value)
|
|
return nil
|
|
}
|
|
|
|
func (s *memState) Update(key string, value any, revision uint64) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.revs[key] != revision {
|
|
return errChanged
|
|
}
|
|
s.write(key, value)
|
|
return nil
|
|
}
|
|
|
|
func (s *memState) Keys() ([]string, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
var keys []string
|
|
for k := range s.values {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
return keys, nil
|
|
}
|
|
|
|
func (s *memState) Delete(key string) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
delete(s.values, key)
|
|
delete(s.revs, key)
|
|
s.rev++
|
|
s.pending = append(s.pending, change{key, "delete", nil, s.rev})
|
|
return nil
|
|
}
|
|
|
|
// pump hands every change so far to every watcher, until none is left.
|
|
func (s *memState) pump(t *testing.T) {
|
|
t.Helper()
|
|
for i := 0; i < 50; i++ {
|
|
s.mu.Lock()
|
|
todo := s.pending
|
|
s.pending = nil
|
|
s.mu.Unlock()
|
|
if len(todo) == 0 {
|
|
return
|
|
}
|
|
for _, c := range todo {
|
|
for _, w := range s.watchers {
|
|
if err := w.Take(c.key, c.op, c.value, c.rev); err != nil {
|
|
t.Logf("%s taking %s: %v", w.Node, c.key, err)
|
|
}
|
|
}
|
|
}
|
|
for _, w := range s.watchers {
|
|
if err := w.Drain(); err != nil && !errors.Is(err, errChanged) {
|
|
t.Logf("%s applying: %v", w.Node, err)
|
|
}
|
|
}
|
|
}
|
|
t.Fatal("the state never settled")
|
|
}
|
|
|
|
// clock is a clock a test moves.
|
|
type clock struct{ now time.Time }
|
|
|
|
func (c *clock) Now() time.Time { return c.now }
|
|
|
|
// memNode is one node's carrier over its own temporary home and state directory.
|
|
type memNode struct {
|
|
*MemoryCarrier
|
|
notices []map[string]any
|
|
}
|
|
|
|
func newMemNode(t *testing.T, root, name, kind string, state *memState, c *clock) *memNode {
|
|
t.Helper()
|
|
n := &memNode{}
|
|
home := filepath.Join(root, name, "home")
|
|
stateDir := filepath.Join(root, name, "state")
|
|
for _, d := range []string{filepath.Join(home, ".claude", "projects"), stateDir} {
|
|
if err := os.MkdirAll(d, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
n.MemoryCarrier = &MemoryCarrier{Home: home, Node: name, State: stateDir, Kind: kind, Store: state, Now: c.Now,
|
|
wake: make(chan struct{}, 1),
|
|
Notify: func(a map[string]any) error { n.notices = append(n.notices, a); return nil }}
|
|
state.watchers = append(state.watchers, n.MemoryCarrier)
|
|
return n
|
|
}
|
|
|
|
func (n *memNode) path(project, file string) string {
|
|
return filepath.Join(n.Home, ".claude", "projects", project, "memory", filepath.FromSlash(file))
|
|
}
|
|
|
|
func (n *memNode) write(t *testing.T, project, file, text string, at time.Time) {
|
|
t.Helper()
|
|
p := n.path(project, file)
|
|
if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(p, []byte(text), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_ = os.Chtimes(p, at, at)
|
|
}
|
|
|
|
func (n *memNode) read(t *testing.T, project, file string) (string, bool) {
|
|
t.Helper()
|
|
raw, err := os.ReadFile(n.path(project, file))
|
|
if os.IsNotExist(err) {
|
|
return "", false
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return string(raw), true
|
|
}
|
|
|
|
func (n *memNode) look(t *testing.T) {
|
|
t.Helper()
|
|
if err := n.Look(); err != nil && !errors.Is(err, errChanged) {
|
|
t.Fatalf("%s's look: %v", n.Node, err)
|
|
}
|
|
}
|
|
|
|
// copies is every text kept in the node's copies.
|
|
func (n *memNode) copies(t *testing.T) []string {
|
|
t.Helper()
|
|
var out []string
|
|
_ = filepath.WalkDir(n.MemoryCarrier.copies(), func(p string, d os.DirEntry, err error) error {
|
|
if err == nil && !d.IsDir() {
|
|
raw, _ := os.ReadFile(p)
|
|
out = append(out, string(raw))
|
|
}
|
|
return nil
|
|
})
|
|
return out
|
|
}
|
|
|
|
func holdsText(list []string, s string) bool {
|
|
for _, x := range list {
|
|
if x == s {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
const project = "-home-op-projects-novox-hq"
|
|
|
|
func twoNodes(t *testing.T) (*memState, *clock, *memNode, *memNode) {
|
|
state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
|
|
root := t.TempDir()
|
|
return state, c, newMemNode(t, root, "g14", HomeOperator, state, c), newMemNode(t, root, "shanks", HomeOperator, state, c)
|
|
}
|
|
|
|
// carried writes a file on g14 and carries it to shanks.
|
|
func carriedOnBoth(t *testing.T, state *memState, c *clock, a, b *memNode, file, text string) {
|
|
t.Helper()
|
|
a.write(t, project, file, text, c.now)
|
|
a.look(t)
|
|
state.pump(t)
|
|
b.look(t)
|
|
state.pump(t)
|
|
if got, _ := b.read(t, project, file); got != text {
|
|
t.Fatalf("not carried to %s: %q", b.Node, got)
|
|
}
|
|
}
|
|
|
|
// §5, §6: a memory file written on one node appears unchanged on another, at any depth, and is carried once.
|
|
func TestAMemoryFileWrittenOnOneNodeAppearsUnchangedOnAnother(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
g14.write(t, project, "MEMORY.md", "- [state](state.md) — where things stand\n", c.now)
|
|
g14.write(t, project, "notes/state.md", "ADR 0343 proposed.\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for file, want := range map[string]string{"MEMORY.md": "- [state](state.md) — where things stand\n", "notes/state.md": "ADR 0343 proposed.\n"} {
|
|
if got, ok := shanks.read(t, project, file); !ok || got != want {
|
|
t.Fatalf("%s on shanks: %q, %v", file, got, ok)
|
|
}
|
|
}
|
|
before := state.rev
|
|
shanks.look(t)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if state.rev != before {
|
|
t.Fatalf("a carried file was carried again: %d changes", state.rev-before)
|
|
}
|
|
// A change on shanks comes back to g14, over the version it replaced, which g14 keeps.
|
|
c.now = c.now.Add(time.Minute)
|
|
shanks.write(t, project, "notes/state.md", "ADR 0343 accepted.\n", c.now)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
if got, _ := g14.read(t, project, "notes/state.md"); got != "ADR 0343 accepted.\n" {
|
|
t.Fatalf("the change did not reach g14: %q", got)
|
|
}
|
|
if !holdsText(g14.copies(t), "ADR 0343 proposed.\n") {
|
|
t.Fatal("the version replaced on g14 was not kept")
|
|
}
|
|
if len(g14.notices)+len(shanks.notices) != 0 {
|
|
t.Fatalf("a plain change warned: %v %v", g14.notices, shanks.notices)
|
|
}
|
|
// No value in the state is anything but a version of a memory file, and no tool answer carries the text.
|
|
raw, _ := json.Marshal(g14.Status())
|
|
if strings.Contains(string(raw), "accepted") {
|
|
t.Fatalf("the memory tool answered the text: %s", raw)
|
|
}
|
|
}
|
|
|
|
// §1, §2: only the memory folders are carried; a symbolic link, an oversized file and a secret's shape are not, and are
|
|
// listed with why.
|
|
func TestOnlyTheMemoryFoldersAreCarried(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
projectDir := filepath.Join(g14.Home, ".claude", "projects", project)
|
|
g14.write(t, project, "MEMORY.md", "index\n", c.now)
|
|
for path, text := range map[string]string{
|
|
filepath.Join(projectDir, "session.jsonl"): "{}\n",
|
|
filepath.Join(g14.Home, ".claude", "settings.json"): "{}\n",
|
|
filepath.Join(g14.Home, ".claude", "history.jsonl"): "{}\n",
|
|
} {
|
|
if err := os.WriteFile(path, []byte(text), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
g14.write(t, project, "key.md", "-----BEGIN OPENSSH PRIVATE KEY-----\nabc\n", c.now)
|
|
g14.write(t, project, "url.md", "https://op:hunter2@git.example.org/x\n", c.now)
|
|
g14.write(t, project, "big.md", strings.Repeat("x", MemoryMostBytes+1), c.now)
|
|
g14.write(t, project, "hash.md", "head 1fe6ea4ee47379007598e163784dbd7ac50b7f79\n", c.now)
|
|
outside := filepath.Join(t.TempDir(), "elsewhere.md")
|
|
_ = os.WriteFile(outside, []byte("not memory\n"), 0o600)
|
|
if err := os.Symlink(outside, g14.path(project, "link.md")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
|
|
if _, ok := shanks.read(t, project, file); ok {
|
|
t.Errorf("%s was carried", file)
|
|
}
|
|
}
|
|
for _, file := range []string{"MEMORY.md", "hash.md"} {
|
|
if _, ok := shanks.read(t, project, file); !ok {
|
|
t.Errorf("%s was not carried", file)
|
|
}
|
|
}
|
|
if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", "projects", project, "session.jsonl")); err == nil {
|
|
t.Error("a session was carried")
|
|
}
|
|
for _, f := range []string{"settings.json", "history.jsonl"} {
|
|
if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", f)); err == nil {
|
|
t.Errorf("%s was carried", f)
|
|
}
|
|
}
|
|
keys, _ := state.Keys()
|
|
if len(keys) != 2 {
|
|
t.Fatalf("the state holds %d keys, not the two memory files: %v", len(keys), keys)
|
|
}
|
|
not, _ := g14.Status()["not carried"].(map[string]string)
|
|
for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
|
|
if not[project+"/"+file] == "" {
|
|
t.Errorf("%s is not listed as not carried: %v", file, not)
|
|
}
|
|
}
|
|
}
|
|
|
|
// §4: the operator's homes and an agent account's homes never take each other's memory.
|
|
func TestHomesOfTheTwoKindsNeverTakeEachOthersMemory(t *testing.T) {
|
|
state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
|
|
root := t.TempDir()
|
|
laptop := newMemNode(t, root, "g14", HomeOperator, state, c)
|
|
control := newMemNode(t, root, "novox", HomeAgent, state, c)
|
|
control.write(t, project, "MEMORY.md", "from a confined agent\n", c.now)
|
|
control.look(t)
|
|
state.pump(t)
|
|
if _, ok := laptop.read(t, project, "MEMORY.md"); ok {
|
|
t.Fatal("a confined agent's memory reached the operator's home")
|
|
}
|
|
laptop.write(t, project, "MEMORY.md", "the operator's\n", c.now)
|
|
laptop.look(t)
|
|
state.pump(t)
|
|
if got, _ := control.read(t, project, "MEMORY.md"); got != "from a confined agent\n" {
|
|
t.Fatalf("the operator's memory reached the agent account's home: %q", got)
|
|
}
|
|
// A value of the other kind put under this kind's key is refused too.
|
|
key := MemoryKey(HomeOperator, project, "x.md")
|
|
raw, _ := json.Marshal(MemoryVersion{Kind: HomeAgent, Project: project, Path: "x.md", Text: "x", Digest: digestOf([]byte("x")), Node: "novox"})
|
|
if err := laptop.Take(key, "put", raw, 99); err == nil {
|
|
t.Fatal("a value of another kind was taken")
|
|
}
|
|
// Which kind a node carries for.
|
|
if k, _ := HomeKind(Paths{Agent: "jochen", Operator: "jochen", Home: "/home/jochen"}); k != HomeOperator {
|
|
t.Fatalf("the operator's own home is %q", k)
|
|
}
|
|
if k, _ := HomeKind(Paths{Agent: "agent", Operator: "jochen", Home: "/home/agent", AgentHome: "/home/agent", OperatorHome: "/home/jochen"}); k != HomeAgent {
|
|
t.Fatalf("an agent account's home is %q", k)
|
|
}
|
|
if k, why := HomeKind(Paths{Agent: "agent", Operator: "jochen", Home: "/home/jochen", AgentHome: "/home/agent", OperatorHome: "/home/jochen"}); k != "" || why == "" {
|
|
t.Fatalf("a confined agent in the operator's home carries %q", k)
|
|
}
|
|
}
|
|
|
|
// §7, §8: a file changed on two nodes since it was carried is kept twice in one file on both, the newer first, with
|
|
// one warning; it clears once the file is tidied.
|
|
func TestAFileChangedOnTwoNodesIsKeptTwiceTheNewerFirstWithAWarning(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "- base\n")
|
|
g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n", c.now.Add(time.Minute))
|
|
shanks.write(t, project, "MEMORY.md", "- base\n- learned on shanks\n", c.now.Add(2*time.Minute))
|
|
c.now = c.now.Add(3 * time.Minute)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
a, _ := g14.read(t, project, "MEMORY.md")
|
|
b, _ := shanks.read(t, project, "MEMORY.md")
|
|
if a != b {
|
|
t.Fatalf("the nodes did not end on one text:\n%s\n----\n%s", a, b)
|
|
}
|
|
newer, older := strings.Index(a, "learned on shanks"), strings.Index(a, "learned on g14")
|
|
marker := strings.Index(a, "<!-- novox mesh: this file was changed on two nodes")
|
|
if newer < 0 || older < 0 || marker < 0 || !(newer < marker && marker < older) {
|
|
t.Fatalf("not both versions, the newer first, with the line between:\n%s", a)
|
|
}
|
|
if !strings.Contains(a[marker:], "changed on shanks") || !strings.Contains(a[marker:], "changed on g14") {
|
|
t.Fatalf("the line does not name both nodes:\n%s", a)
|
|
}
|
|
notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
|
|
if len(notices) != 1 || notices[0]["severity"] != "warning" || notices[0]["clear"] != nil {
|
|
t.Fatalf("not one warning: %v", notices)
|
|
}
|
|
for _, field := range []string{"headline", "explanation", "summary", "resolved"} {
|
|
s, _ := notices[0][field].(string)
|
|
if s == "" || strings.ContainsAny(s, "/~:") && field != "explanation" || strings.Contains(s, ".md") {
|
|
t.Errorf("the warning's %s is empty or names a path: %q", field, s)
|
|
}
|
|
// The plain rule (ADR 0253 §3): it never sends the operator elsewhere.
|
|
if field != "summary" && (strings.Contains(strings.ToLower(s), "agent") || strings.Contains(strings.ToLower(s), "session")) {
|
|
t.Errorf("the warning's %s sends the operator elsewhere: %q", field, s)
|
|
}
|
|
}
|
|
if e, _ := notices[0]["explanation"].(string); !strings.HasPrefix(e, "Needs you: ") {
|
|
t.Errorf("the explanation does not open with its verdict: %q", e)
|
|
}
|
|
if h, _ := notices[0]["headline"].(string); len([]rune(h)) > 60 {
|
|
t.Errorf("the headline is longer than sixty characters: %q", h)
|
|
}
|
|
all := append(g14.copies(t), shanks.copies(t)...)
|
|
for _, v := range []string{"- base\n- learned on g14\n", "- base\n- learned on shanks\n"} {
|
|
if !holdsText(all, v) {
|
|
t.Errorf("the version %q was not kept", v)
|
|
}
|
|
}
|
|
if st := g14.Status(); len(st["conflicts"].([]conflict))+len(shanks.Status()["conflicts"].([]conflict)) != 1 {
|
|
t.Fatalf("the conflict is not listed: %v", st)
|
|
}
|
|
// Tidied on either node, the warning clears.
|
|
c.now = c.now.Add(time.Minute)
|
|
g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n- learned on shanks\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
cleared := false
|
|
for _, n := range append(g14.notices, shanks.notices...) {
|
|
if n["clear"] == true {
|
|
cleared = true
|
|
}
|
|
}
|
|
if !cleared {
|
|
t.Fatal("the warning did not clear once the file was tidied")
|
|
}
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "- base\n- learned on g14\n- learned on shanks\n" {
|
|
t.Fatalf("the tidied file did not reach shanks: %q", got)
|
|
}
|
|
}
|
|
|
|
// The order of the two versions: the later change first, equal times by node name.
|
|
func TestMergeVersionsPutsTheNewerFirst(t *testing.T) {
|
|
at := time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)
|
|
m := string(MergeVersions([]byte("old\n"), "g14", at, []byte("new\n"), "shanks", at.Add(time.Second)))
|
|
if strings.Index(m, "new") > strings.Index(m, "old") {
|
|
t.Fatalf("the newer is not first: %s", m)
|
|
}
|
|
m = string(MergeVersions([]byte("from shanks\n"), "shanks", at, []byte("from ace\n"), "ace", at))
|
|
if strings.Index(m, "from ace") > strings.Index(m, "from shanks") {
|
|
t.Fatalf("equal times are not ordered by node name: %s", m)
|
|
}
|
|
}
|
|
|
|
// §9: a removal moves the other node's unchanged file into the copies.
|
|
func TestARemovalMovesTheUnchangedFileIntoTheCopies(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "old.md", "an old note\n")
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
|
|
if err := os.Remove(g14.path(project, "old.md")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if _, ok := shanks.read(t, project, "old.md"); ok {
|
|
t.Fatal("the removal did not reach shanks")
|
|
}
|
|
if !holdsText(shanks.copies(t), "an old note\n") {
|
|
t.Fatal("the removed version was not kept on shanks")
|
|
}
|
|
raw, _, ok, _ := state.Get(MemoryKey(HomeOperator, project, "old.md"))
|
|
var v MemoryVersion
|
|
_ = json.Unmarshal(raw, &v)
|
|
if !ok || !v.Removed || v.Text != "" {
|
|
t.Fatalf("the removal is not a marker in the state: %s", raw)
|
|
}
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
|
|
t.Fatal("another file was touched")
|
|
}
|
|
}
|
|
|
|
// §9: a change outlives a removal, whichever reaches the state first.
|
|
func TestAChangeOutlivesARemoval(t *testing.T) {
|
|
for _, removalFirst := range []bool{true, false} {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
|
|
_ = os.Remove(g14.path(project, "note.md"))
|
|
shanks.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
|
|
if removalFirst {
|
|
g14.look(t)
|
|
state.pump(t)
|
|
shanks.look(t)
|
|
} else {
|
|
shanks.look(t)
|
|
g14.look(t)
|
|
}
|
|
state.pump(t)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
for _, n := range []*memNode{g14, shanks} {
|
|
if got, _ := n.read(t, project, "note.md"); got != "v2\n" {
|
|
t.Fatalf("removal first %v: the change did not outlive the removal on %s: %q", removalFirst, n.Node, got)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// §9: a missing folder, a state that lost its keys and a deleted key remove nothing.
|
|
func TestAMissingFolderOrAnAbsentKeyRemovesNothing(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
|
|
key := MemoryKey(HomeOperator, project, "MEMORY.md")
|
|
// The folder gone on g14.
|
|
if err := os.RemoveAll(filepath.Join(g14.Home, ".claude", "projects", project, "memory")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
|
|
t.Fatal("a missing folder removed the file elsewhere")
|
|
}
|
|
// A deleted key.
|
|
_ = state.Delete(key)
|
|
state.pump(t)
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
|
|
t.Fatal("a deleted key removed the file")
|
|
}
|
|
// The state lost: the file is carried again, not removed.
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
if _, _, ok, _ := state.Get(key); !ok {
|
|
t.Fatal("a file whose key the state lost was not carried again")
|
|
}
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
|
|
t.Fatalf("the file was touched on shanks: %q", got)
|
|
}
|
|
}
|
|
|
|
// §10: on a first carrying, two nodes' different versions are both kept, and each node's own files reach the other.
|
|
func TestTheFirstCarryingKeepsEveryVersion(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
g14.write(t, project, "MEMORY.md", "- laptop's index\n", c.now)
|
|
g14.write(t, project, "laptop.md", "only on the laptop\n", c.now)
|
|
shanks.write(t, project, "MEMORY.md", "- workstation's index\n", c.now.Add(time.Hour))
|
|
shanks.write(t, project, "workstation.md", "only on the workstation\n", c.now)
|
|
shanks.write(t, project, "same.md", "same\n", c.now)
|
|
g14.write(t, project, "same.md", "same\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for _, n := range []*memNode{g14, shanks} {
|
|
index, _ := n.read(t, project, "MEMORY.md")
|
|
if !strings.Contains(index, "laptop's index") || !strings.Contains(index, "workstation's index") ||
|
|
strings.Index(index, "workstation's index") > strings.Index(index, "laptop's index") {
|
|
t.Fatalf("%s's index does not hold both, the newer first:\n%s", n.Node, index)
|
|
}
|
|
for file, want := range map[string]string{"laptop.md": "only on the laptop\n", "workstation.md": "only on the workstation\n", "same.md": "same\n"} {
|
|
if got, _ := n.read(t, project, file); got != want {
|
|
t.Fatalf("%s's %s: %q", n.Node, file, got)
|
|
}
|
|
}
|
|
}
|
|
if n := len(g14.notices) + len(shanks.notices); n != 1 {
|
|
t.Fatalf("%d warnings for one conflict", n)
|
|
}
|
|
}
|
|
|
|
// Nothing is written through a symbolic link: a memory folder that is one is neither read nor written.
|
|
func TestNothingIsWrittenThroughASymbolicLink(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
elsewhere := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(shanks.Home, ".claude", "projects", project), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(elsewhere, filepath.Join(shanks.Home, ".claude", "projects", project, "memory")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
g14.write(t, project, "MEMORY.md", "index\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if entries, _ := os.ReadDir(elsewhere); len(entries) != 0 {
|
|
t.Fatalf("written through a symbolic link: %v", entries)
|
|
}
|
|
}
|
|
|
|
// The manifest declares the state and the tool; the tool reads and never writes.
|
|
func TestTheManifestDeclaresTheMemoryState(t *testing.T) {
|
|
raw, err := os.ReadFile("../../module.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var m struct {
|
|
State []string `json:"state"`
|
|
}
|
|
_ = json.Unmarshal(raw, &m)
|
|
if !holdsText(m.State, MemoryState) {
|
|
t.Fatalf("the manifest does not declare the %q state: %v", MemoryState, m.State)
|
|
}
|
|
var carrier *MemoryCarrier
|
|
if st := carrier.Status(); st["carrying"] != false {
|
|
t.Fatalf("a carrier not started says it carries: %v", st)
|
|
}
|
|
}
|
|
|
|
// replay hands one node the whole current set, as a watch begins when the node comes back.
|
|
func (s *memState) replay(t *testing.T, n *memNode) {
|
|
t.Helper()
|
|
keys, _ := s.Keys()
|
|
for _, k := range keys {
|
|
raw, rev, _, _ := s.Get(k)
|
|
if err := n.Take(k, "put", raw, rev); err != nil {
|
|
t.Logf("%s taking %s: %v", n.Node, k, err)
|
|
}
|
|
}
|
|
if err := n.Drain(); err != nil && !errors.Is(err, errChanged) {
|
|
t.Logf("%s applying: %v", n.Node, err)
|
|
}
|
|
}
|
|
|
|
// §6: a node that was away while a file changed twice takes the newest version, whose base it never saw, because
|
|
// its own file holds no change it did not carry; the version replaced is kept.
|
|
func TestANodeThatWasAwayTakesTheNewestVersion(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "v1\n")
|
|
state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
|
|
for _, v := range []string{"v2\n", "v3\n"} {
|
|
c.now = c.now.Add(time.Minute)
|
|
g14.write(t, project, "MEMORY.md", v, c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
}
|
|
state.watchers = append(state.watchers, shanks.MemoryCarrier)
|
|
state.replay(t, shanks)
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "v3\n" {
|
|
t.Fatalf("the node that was away holds %q", got)
|
|
}
|
|
if !holdsText(shanks.copies(t), "v1\n") {
|
|
t.Fatal("the version replaced was not kept")
|
|
}
|
|
if len(g14.notices)+len(shanks.notices) != 0 {
|
|
t.Fatal("taking a newer version warned")
|
|
}
|
|
}
|
|
|
|
// §2, §7: two versions too large to share one file are kept in two: the newer in the file, the older beside it,
|
|
// both carried; and a text that would not fit in one value of the state is not carried.
|
|
func TestTwoVersionsTooLargeForOneFileAreKeptInTwo(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "big.md", "base\n")
|
|
older := strings.Repeat("from g14 ", MemoryMostBytes/9-100) + "\n"
|
|
newer := strings.Repeat("from shanks ", MemoryMostBytes/12-100) + "\n"
|
|
g14.write(t, project, "big.md", older, c.now.Add(time.Minute))
|
|
shanks.write(t, project, "big.md", newer, c.now.Add(2*time.Minute))
|
|
c.now = c.now.Add(3 * time.Minute)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
beside := OlderBeside("big.md", "g14")
|
|
if beside != "big.older-from-g14.md" {
|
|
t.Fatalf("the older is named %q", beside)
|
|
}
|
|
for _, n := range []*memNode{g14, shanks} {
|
|
if got, _ := n.read(t, project, "big.md"); got != newer {
|
|
t.Fatalf("%s's file does not hold the newer version", n.Node)
|
|
}
|
|
if got, _ := n.read(t, project, beside); got != older {
|
|
t.Fatalf("%s does not hold the older version beside it", n.Node)
|
|
}
|
|
}
|
|
notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
|
|
if len(notices) != 1 || !strings.Contains(notices[0]["explanation"].(string), "second file beside it") {
|
|
t.Fatalf("not one warning saying the older is beside it: %v", notices)
|
|
}
|
|
// Under the size limit, but too large once encoded: not carried, and said.
|
|
g14.write(t, project, "angles.md", strings.Repeat("<", MemoryMostBytes-10), c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if _, ok := shanks.read(t, project, "angles.md"); ok {
|
|
t.Fatal("a text too large for one value was carried")
|
|
}
|
|
not, _ := g14.Status()["not carried"].(map[string]string)
|
|
if not[project+"/angles.md"] == "" {
|
|
t.Fatalf("it is not listed as not carried: %v", not)
|
|
}
|
|
}
|
|
|
|
// stateHolds says whether any value of the state holds s.
|
|
func (s *memState) holds(sub string) bool {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
for _, v := range s.values {
|
|
var mv MemoryVersion
|
|
_ = json.Unmarshal(v, &mv)
|
|
if strings.Contains(mv.Text, sub) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// putRaw puts a value straight into the state, as a holder of a tool runner's credential could.
|
|
func (s *memState) putRaw(t *testing.T, v MemoryVersion) string {
|
|
t.Helper()
|
|
key := MemoryKey(v.Kind, v.Project, v.Path)
|
|
s.mu.Lock()
|
|
s.write(key, v)
|
|
s.mu.Unlock()
|
|
return key
|
|
}
|
|
|
|
// Review of #276, 1: a value whose project or path leads out of a memory folder is never taken, and nothing is
|
|
// written for it.
|
|
func TestAValueLeadingOutOfAMemoryFolderIsNeverTaken(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
root := filepath.Dir(filepath.Dir(shanks.Home))
|
|
for _, bad := range []struct{ project, path string }{
|
|
{"../../../escaped", "x.md"}, {"..", "x.md"}, {"a/b", "x.md"}, {"", "x.md"},
|
|
{project, "../x.md"}, {project, "/abs.md"}, {project, "a//x.md"}, {project, "./x.md"}, {project, "a/../../x.md"},
|
|
} {
|
|
text := "planted\n"
|
|
state.putRaw(t, MemoryVersion{Kind: HomeOperator, Project: bad.project, Path: bad.path, Text: text,
|
|
Digest: digestOf([]byte(text)), Node: "elsewhere", Changed: c.now})
|
|
if NameProblem(bad.project, bad.path) == "" {
|
|
t.Errorf("%q %q is taken as a name", bad.project, bad.path)
|
|
}
|
|
}
|
|
state.pump(t)
|
|
g14.look(t)
|
|
shanks.look(t)
|
|
_ = filepath.WalkDir(root, func(p string, d os.DirEntry, err error) error {
|
|
if err == nil && !d.IsDir() {
|
|
if raw, _ := os.ReadFile(p); string(raw) == "planted\n" {
|
|
t.Errorf("a planted value was written at %s", p)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if NameProblem(project, "notes/a.md") != "" || NameProblem(project, "MEMORY.md") != "" {
|
|
t.Fatal("a memory file's own name is refused")
|
|
}
|
|
}
|
|
|
|
// Review of #276, 2: a file or a folder that cannot be read is kept everywhere, never carried as a removal, and is
|
|
// said as not carried.
|
|
func TestWhatCannotBeReadIsNeverTakenForGone(t *testing.T) {
|
|
if os.Geteuid() == 0 {
|
|
t.Skip("root reads a file whatever its mode")
|
|
}
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
|
|
carriedOnBoth(t, state, c, g14, shanks, "notes/deep.md", "deep\n")
|
|
file, folder := g14.path(project, "MEMORY.md"), filepath.Dir(g14.path(project, "notes/deep.md"))
|
|
_ = os.Chmod(file, 0)
|
|
_ = os.Chmod(folder, 0)
|
|
t.Cleanup(func() { _ = os.Chmod(file, 0o644); _ = os.Chmod(folder, 0o755) })
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for _, f := range []string{"MEMORY.md", "notes/deep.md"} {
|
|
if _, ok := shanks.read(t, project, f); !ok {
|
|
t.Errorf("%s, unreadable on g14, was removed on shanks", f)
|
|
}
|
|
}
|
|
not, _ := g14.Status()["not carried"].(map[string]string)
|
|
if len(not) == 0 {
|
|
t.Fatalf("nothing is said as not carried: %v", not)
|
|
}
|
|
keys, _ := state.Keys()
|
|
for _, k := range keys {
|
|
raw, _, _, _ := state.Get(k)
|
|
var v MemoryVersion
|
|
_ = json.Unmarshal(raw, &v)
|
|
if v.Removed {
|
|
t.Errorf("%s/%s was carried as a removal", v.Project, v.Path)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Review of #276, 3: no text reaches the state without being screened, on the removal and the conflict paths too.
|
|
func TestNoUnscreenedTextReachesTheState(t *testing.T) {
|
|
token := "ghp_" + strings.Repeat("A1b2C3d4", 5) + "\n"
|
|
big := strings.Repeat("x", MemoryMostBytes+10) + "\n"
|
|
for _, text := range []string{token, big} {
|
|
// The removal path: removed on g14, changed on shanks to what is never carried.
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
|
|
_ = os.Remove(g14.path(project, "note.md"))
|
|
shanks.write(t, project, "note.md", text, c.now.Add(time.Minute))
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if state.holds(text[:20]) {
|
|
t.Errorf("the removal path put text that is never carried into the state")
|
|
}
|
|
if got, _ := shanks.read(t, project, "note.md"); got != text {
|
|
t.Errorf("the change on shanks was not kept")
|
|
}
|
|
// The conflict path: changed on g14, and on shanks to what is never carried.
|
|
state, c, g14, shanks = twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
|
|
g14.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
|
|
shanks.write(t, project, "note.md", text, c.now.Add(2*time.Minute))
|
|
g14.look(t)
|
|
state.pump(t)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
if state.holds(text[:20]) {
|
|
t.Errorf("the conflict path put text that is never carried into the state")
|
|
}
|
|
if got, _ := shanks.read(t, project, "note.md"); got != text {
|
|
t.Errorf("shanks's own version was not kept as it was")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Review of #276, 4: a conflict whose file cannot be written leaves the state as it was, says so once, and merges
|
|
// once when the folder is writable again.
|
|
func TestAConflictThatCannotBeWrittenIsNotMergedAgainAndAgain(t *testing.T) {
|
|
if os.Geteuid() == 0 {
|
|
t.Skip("root writes a folder whatever its mode")
|
|
}
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "base\n")
|
|
g14.write(t, project, "MEMORY.md", "base\nfrom g14\n", c.now.Add(time.Minute))
|
|
shanks.write(t, project, "MEMORY.md", "base\nfrom shanks\n", c.now.Add(2*time.Minute))
|
|
folder := filepath.Dir(shanks.path(project, "MEMORY.md"))
|
|
_ = os.Chmod(folder, 0o500)
|
|
t.Cleanup(func() { _ = os.Chmod(folder, 0o700) })
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for i := 0; i < 5; i++ {
|
|
_ = shanks.Look()
|
|
state.pump(t)
|
|
}
|
|
if state.holds("<!-- novox mesh") {
|
|
t.Fatal("a merge that could not be written here reached the state")
|
|
}
|
|
unwritten := 0
|
|
for _, n := range shanks.notices {
|
|
if strings.HasSuffix(n["key"].(string), ".unwritten") {
|
|
unwritten++
|
|
}
|
|
}
|
|
if unwritten != 1 {
|
|
t.Fatalf("%d warnings that the file could not be written", unwritten)
|
|
}
|
|
_ = os.Chmod(folder, 0o700)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
for _, n := range []*memNode{g14, shanks} {
|
|
got, _ := n.read(t, project, "MEMORY.md")
|
|
if strings.Count(got, "<!-- novox mesh") != 1 || !strings.Contains(got, "from g14") || !strings.Contains(got, "from shanks") {
|
|
t.Fatalf("%s does not hold both versions once:\n%s", n.Node, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Review of #276, minor: a file that changed between its reading and its writing is not written over; text that is
|
|
// not UTF-8 is not carried.
|
|
func TestAFileChangedBeforeItsWritingIsNotWrittenOver(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
_ = state
|
|
g14.write(t, project, "a.md", "read\n", c.now)
|
|
g14.write(t, project, "a.md", "changed meanwhile\n", c.now)
|
|
err := g14.writeLocal(project, "a.md", []byte("incoming\n"), "replaced", digestOf([]byte("read\n")))
|
|
if !errors.Is(err, errChangedHere) {
|
|
t.Fatalf("written over a change: %v", err)
|
|
}
|
|
if got, _ := g14.read(t, project, "a.md"); got != "changed meanwhile\n" {
|
|
t.Fatalf("the change was replaced: %q", got)
|
|
}
|
|
g14.write(t, project, "latin1.md", "caf\xe9\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
if _, ok := shanks.read(t, project, "latin1.md"); ok {
|
|
t.Fatal("text that is not UTF-8 was carried")
|
|
}
|
|
not, _ := g14.Status()["not carried"].(map[string]string)
|
|
if !strings.Contains(not[project+"/latin1.md"], "UTF-8") {
|
|
t.Fatalf("it is not said why: %v", not)
|
|
}
|
|
}
|
|
|
|
// §9: a node that was away takes a removal of a version newer than the one it holds, when it holds no change of
|
|
// its own: the removed file does not come back.
|
|
func TestARemovalReachesANodeThatWasAway(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
carriedOnBoth(t, state, c, g14, shanks, "old.md", "v1\n")
|
|
state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
|
|
c.now = c.now.Add(time.Minute)
|
|
g14.write(t, project, "old.md", "v2\n", c.now)
|
|
g14.look(t)
|
|
state.pump(t)
|
|
_ = os.Remove(g14.path(project, "old.md"))
|
|
g14.look(t)
|
|
state.pump(t)
|
|
state.watchers = append(state.watchers, shanks.MemoryCarrier)
|
|
state.replay(t, shanks)
|
|
shanks.look(t)
|
|
state.pump(t)
|
|
g14.look(t)
|
|
if _, ok := shanks.read(t, project, "old.md"); ok {
|
|
t.Fatal("the removal did not reach the node that was away")
|
|
}
|
|
if _, ok := g14.read(t, project, "old.md"); ok {
|
|
t.Fatal("the removed file came back")
|
|
}
|
|
if !holdsText(shanks.copies(t), "v1\n") {
|
|
t.Fatal("the version removed on the node that was away was not kept")
|
|
}
|
|
}
|
|
|
|
// slowState answers every read only once it is let go, as a state a whole bus away does under load.
|
|
type slowState struct {
|
|
*memState
|
|
gate chan struct{}
|
|
}
|
|
|
|
func (s slowState) Get(key string) (json.RawMessage, uint64, bool, error) {
|
|
<-s.gate
|
|
return s.memState.Get(key)
|
|
}
|
|
|
|
// Issue 367, seen live: the runtime hands a watch its current values one at a time and gives them all ten seconds;
|
|
// shanks's handler read the state and waited for its look for each of a few hundred values, so the watch never
|
|
// started and nothing written on g14 reached it. The handler now only notes a change: it returns at once while a
|
|
// look holds the carrier and while the state is slow to answer, and Drain applies what it noted.
|
|
func TestTheWatchHandlerReturnsAtOnceAndDrainAppliesWhatItNoted(t *testing.T) {
|
|
state, c, g14, shanks := twoNodes(t)
|
|
g14.write(t, project, "MEMORY.md", "index\n", c.now)
|
|
g14.look(t)
|
|
state.mu.Lock()
|
|
state.pending = nil
|
|
state.mu.Unlock()
|
|
slow := slowState{memState: state, gate: make(chan struct{})}
|
|
shanks.Store = slow
|
|
key := MemoryKey(HomeOperator, project, "MEMORY.md")
|
|
raw, rev, _, _ := state.Get(key)
|
|
shanks.mu.Lock() // a look running
|
|
done := make(chan error, 1)
|
|
start := time.Now()
|
|
for i := 0; i < 400; i++ {
|
|
go func() { done <- shanks.Take(key, "put", raw, rev) }()
|
|
}
|
|
for i := 0; i < 400; i++ {
|
|
select {
|
|
case err := <-done:
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatalf("the watch handler waited for the look or the state (%d of 400 returned)", i)
|
|
}
|
|
}
|
|
if took := time.Since(start); took > time.Second {
|
|
t.Fatalf("400 values took %s to hand over", took)
|
|
}
|
|
shanks.mu.Unlock()
|
|
close(slow.gate)
|
|
if err := shanks.Drain(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
|
|
t.Fatalf("what the watch noted was not applied: %q", got)
|
|
}
|
|
}
|