#!/usr/bin/env bash
# End-to-end checks of Onset's CLI (on) on a project that lives on this machine.
# Usage: tests/local.sh [path/to/on]
set -uo pipefail

VCS=${1:-$(cd "$(dirname "$0")/.." && pwd)/target/debug/on}
WORK=$(mktemp -d)
export ONSET_HOME="$WORK/home" ONSET_NAME="Test Person" ONSET_EMAIL="test@example.com" ONSET_SAVER=0
# Run from inside an agent, its own session would be kept with the tests' lands.
unset CLAUDE_CODE_SESSION_ID CLAUDECODE CLAUDE_CONFIG_DIR ONSET_SESSION_FILE ONSET_SESSIONS VCS_SESSION_FILE VCS_SESSIONS VCS_HOME VCS_TOKEN
export CODEX_HOME="$WORK/no-codex"
trap 'rm -rf "$WORK"' EXIT
cd "$WORK"

pass=0
fail=0
check() { # name, command...
  local name=$1
  shift
  if "$@" >/dev/null 2>&1; then pass=$((pass + 1)); else fail=$((fail + 1)); echo "FAIL: $name"; fi
}
code() { # expected exit code, command...
  local want=$1
  shift
  "$@" >/dev/null 2>&1
  [ "$?" = "$want" ]
}
json() { "$VCS" --json "$@" 2>/dev/null; }
# A path as on and other native programs see it: on Windows, bash's /d/a/x is D:/a/x.
native() { if command -v cygpath >/dev/null 2>&1; then cygpath -m "$1"; else printf '%s' "$1"; fi; }

# A new project with a first version.
mkdir app && cd app
printf 'hello\n' > README.md
mkdir src && printf 'a\nb\nc\nd\ne\nf\ng\n' > src/lib.txt
printf '{\n  "name": "app"\n}\n' > package.json
printf 'SECRET=1\n' > .env
check "init" "$VCS" init
check "land first version" "$VCS" land -m "First version"
check "main is version 1" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1
check ".env never landed" test -z "$(json log 1 | python3 -c 'import json,sys; print([f for f in json.load(sys.stdin)["files"] if ".env" in f] or "")')"
check "empty land refused (exit 1)" code 1 "$VCS" land -m "Nothing"

# A second workspace gets the files and the .env.
cd "$WORK"
check "get second workspace" "$VCS" get ./app app2
check "files arrived" test "$(cat app2/src/lib.txt | head -1)" = a
check ".env came along" test "$(cat app2/.env)" = "SECRET=1"

# Parallel edits to different files both land, in any order.
printf 'hello there\n' > app/README.md
printf 'a\nb\nc\nd\ne\nf\nG\n' > app2/src/lib.txt
check "land from app" "$VCS" -C app land -m "Greet better"
check "land from app2 without syncing" "$VCS" -C app2 land -m "Capital G"
check "main is version 3" test "$(json -C app log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3

# JSON files merge by key.
cd "$WORK" && "$VCS" -C app sync >/dev/null 2>&1 && "$VCS" -C app2 sync >/dev/null 2>&1
printf '{\n  "name": "app",\n  "version": "1.0.0"\n}\n' > app/package.json
printf '{\n  "name": "app",\n  "license": "MIT"\n}\n' > app2/package.json
check "land json key A" "$VCS" -C app land -m "Add version"
check "land json key B (merged by key)" "$VCS" -C app2 land -m "Add license"
"$VCS" -C app sync >/dev/null 2>&1
check "both keys on main" python3 -c 'import json; d=json.load(open("app/package.json")); assert d["version"]=="1.0.0" and d["license"]=="MIT"'

# A real conflict: land refuses, sync marks it, fixing it lands.
"$VCS" -C app2 sync >/dev/null 2>&1
perl -pi -e 's/^b$/B from app/' app/src/lib.txt
perl -pi -e 's/^b$/B from app2/' app2/src/lib.txt
check "land A" "$VCS" -C app land -m "B from app"
check "land B conflicts (exit 3)" code 3 "$VCS" -C app2 land -m "B from app2"
check "sync leaves markers (exit 3)" code 3 "$VCS" -C app2 sync
check "markers in file" grep -q '<<<<<<< main' app2/src/lib.txt
check "land refused while markers remain" code 3 "$VCS" -C app2 land
python3 - "$WORK/app2/src/lib.txt" <<'EOF'
import sys, re
p = sys.argv[1]
t = open(p).read()
t = re.sub(r"<<<<<<< [^\n]*\n(.*?)=======\n(.*?)>>>>>>> [^\n]*\n", lambda m: "B from both\n", t, flags=re.S)
open(p, "w", newline="\n").write(t)
EOF
check "land after fixing (reuses description)" "$VCS" -C app2 land
check "status clean after land" test "$(json -C app2 status | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["files"]))')" = 0

# A file's history, and the version behind each line.
check "log of a file" test "$(json -C app log src/lib.txt | python3 -c 'import json,sys; print(",".join(str(v["n"]) for v in json.load(sys.stdin)["versions"]))')" = 7,6,3,1
check "log of a folder" sh -c "\"$VCS\" -C app log src | grep -q 'Capital G'"
check "log of a file from inside its folder" sh -c "cd app/src && \"$VCS\" log lib.txt | grep -q 'First version'"
check "blame" test "$(json -C app2 blame src/lib.txt | python3 -c 'import json,sys; print(",".join(str(l["version"]) for l in json.load(sys.stdin)["lines"]))')" = 1,7,1,1,1,1,3
check "blame of a missing file fails" sh -c "! \"$VCS\" -C app blame nope.txt"
check "show a file in main" sh -c "\"$VCS\" -C app show src/lib.txt | grep -q 'B from both'"
check "show a file at a version" test "$("$VCS" -C app show src/lib.txt --from 1 | tail -1)" = g
check "show a missing file fails" sh -c "! \"$VCS\" -C app show nope.txt"
check "completions" sh -c "\"$VCS\" completions bash | grep -q _on"

# Tags: names for versions.
check "tag main's latest" "$VCS" -C app tag v1.0
check "tag an older version" "$VCS" -C app tag first 1
check "the list has them" sh -c "\"$VCS\" -C app tag | grep -q 'v1.0' && \"$VCS\" -C app tag | grep -q first"
check "show at a tag" test "$("$VCS" -C app show src/lib.txt --from first | tail -1)" = g
check "log of a tag" sh -c "\"$VCS\" -C app log first | grep -q 'First version'"
check "a tag stays on its version (exit 3)" code 3 "$VCS" -C app tag first 2
check "a number can't be a tag (exit 2)" code 2 "$VCS" -C app tag 12
check "remove a tag" "$VCS" -C app tag first --remove
check "it's gone" sh -c "! \"$VCS\" -C app tag | grep -q first"

# Cleaning up: a dropped change's saves and objects go; what's kept still works.
cd "$WORK/app"
"$VCS" sync >/dev/null 2>&1
head -c 200000 /dev/urandom > scratch.bin
"$VCS" status >/dev/null 2>&1
"$VCS" drop >/dev/null 2>&1
check "gc --dry-run says what would go" sh -c "ONSET_GC_FRESH=0 '$VCS' gc --older 0s --dry-run | grep -q 'would remove'"
check "gc removes the dropped change's objects" test "$(ONSET_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"] > 0)')" = True
check "main still reads" sh -c "\"$VCS\" show src/lib.txt | grep -q 'B from both'"
check "history still reads" sh -c "\"$VCS\" log src/lib.txt | grep -q 'First version'"
check "nothing is damaged" "$VCS" check
check "a second gc has nothing left" test "$(ONSET_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"])')" = 0
# Packs: gc moves loose objects into one file, and everything still reads.
LOOSE_BEFORE=$(find "$ONSET_HOME/objects" -path '*/packs' -prune -o -type f -print | wc -l | tr -d ' ')
ONSET_GC_FRESH=0 ONSET_PACK_AT=1 "$VCS" gc >/dev/null 2>&1
check "gc packs loose objects" test "$(find "$ONSET_HOME/objects" -path '*/packs' -prune -o -type f -print | wc -l | tr -d ' ')" -lt "$LOOSE_BEFORE"
check "into a pack and its index" sh -c "ls '$ONSET_HOME/objects/packs/' | grep -q '\.idx$'"
check "packed files read" sh -c "\"$VCS\" show src/lib.txt | grep -q 'B from both'"
check "packed history reads" sh -c "\"$VCS\" log src/lib.txt | grep -q 'First version'"
check "packed objects check out" sh -c "\"$VCS\" check | grep -q 'each matching its ID'"
check "a new workspace comes from packed objects" sh -c "cd '$WORK' && '$VCS' get ./app app-packed >/dev/null && grep -q 'B from both' app-packed/src/lib.txt"
# A packed object nothing needs goes (its pack is written again without it).
head -c 100000 /dev/urandom > scratch2.bin
"$VCS" status >/dev/null 2>&1
ONSET_GC_FRESH=0 ONSET_PACK_AT=1 "$VCS" gc >/dev/null 2>&1
"$VCS" drop >/dev/null 2>&1
check "gc removes packed objects nothing needs" test "$(ONSET_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"] > 0)')" = True
check "and what's kept still checks out" sh -c "\"$VCS\" check | grep -q 'each matching its ID'"
cd "$WORK"

# Undo a land: main gets a version that takes it back out.
cd "$WORK/app"
"$VCS" sync >/dev/null 2>&1
printf 'oops\n' > oops.txt
check "land oops" "$VCS" land -m "Oops"
check "undo the land" "$VCS" undo
check "oops is open again" test "$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["state"])')" = open
check "main took it back" test "$(json log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["title"][:13])')" = "Take back mai"
check "drop it" "$VCS" drop
check "undo the drop" "$VCS" undo
check "drop again" "$VCS" drop

# Restore a file from an earlier save.
printf 'v1\n' > notes.txt
"$VCS" status >/dev/null 2>&1
sleep 3
printf 'broken\n' > notes.txt
"$VCS" status >/dev/null 2>&1
check "restore --at" "$VCS" restore notes.txt --at "2s ago"
check "notes is v1" test "$(cat notes.txt)" = v1
check "undo the restore" "$VCS" undo
check "notes is broken again" test "$(cat notes.txt)" = broken
check "restore to base (removes the new file)" "$VCS" restore notes.txt
check "notes gone" test ! -e notes.txt

# New, switch, stacks.
printf 'feature a\n' > a.txt
check "describe" "$VCS" describe "Feature A"
A=$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["id"])')
check "new stacked on A" "$VCS" new "Feature B" --on "$A"
printf 'feature b\n' > b.txt
check "a.txt visible in B" test -e a.txt
check "switch back to A" "$VCS" switch "${A:0:6}"
check "b.txt gone in A" test ! -e b.txt
check "undo switch" "$VCS" undo
check "b.txt back" test -e b.txt
check "land B lands A then B" "$VCS" land
check "main has both" test "$(json log -n 2 | python3 -c 'import json,sys; print(",".join(v["title"] for v in json.load(sys.stdin)["versions"]))')" = "Feature B,Feature A"

# Secrets don't land.
printf 'const key = "sk_live_%s";\n' "$(printf 'x%.0s' {1..24})" > pay.js
check "secret refused (exit 8)" code 8 "$VCS" land -m "Payments"
rm pay.js
printf 'const key = process.env.STRIPE_KEY;\n' > pay.js
check "lands without the secret" "$VCS" land -m "Payments"

# onset.toml [land] run: the workspace's own checks before it lands.
printf '[land]\nrun = ["exit 1"]\n' > onset.toml
check "a failing [land] run stops the land (exit 4)" code 4 "$VCS" land -m "Checks"
check "--no-run lands anyway" "$VCS" land -m "Checks" --no-run
printf '[land]\nrun = ["exit 0"]\n' > onset.toml
check "a passing [land] run lands" "$VCS" land -m "Checks pass"

# No description.
printf 'x\n' > x.txt
check "no description (exit 2)" code 2 "$VCS" land
check "describe then land" "$VCS" land -m "Add x"

# Diff and log output.
printf 'y\n' > x.txt
check "diff shows the edit" sh -c "\"$VCS\" diff | grep -q '^+y'"
check "log --saves" "$VCS" log --saves
check "log --ops" "$VCS" log --ops
check "log --changes" "$VCS" log --changes
check "guide" sh -c "\"$VCS\" guide | grep -q 'on land'"

# Deleting a workspace is deleting its folder; a new one can take its place.
cd "$WORK"
check "get a third workspace" "$VCS" get ./app app3
rm -rf app3
check "get again at the same path" "$VCS" get ./app app3
cd "$WORK/app"

# Mine: vcs access <path> me.
printf 'token\n' > secrets.local
check "access me" "$VCS" access secrets.local me
check "mine stays out of the change" sh -c "! \"$VCS\" --json status | grep -q secrets.local"

# An agent each: workspaces added next to this one, and cleaned up once done.
check "add a workspace" "$VCS" workspaces add ../agent1
check "it has main's files" test -f ../agent1/README.md
printf 'parent work\n' > parent.txt
check "add one on this change" "$VCS" workspaces add ../sub1 --on .
check "it starts from this change's work" test -f ../sub1/parent.txt
check "the list has them" sh -c "'$VCS' workspaces | grep -q agent1 && '$VCS' workspaces | grep -q sub1"
printf 'agent work\n' > ../agent1/agent.txt && printf 'sub work\n' > ../sub1/sub.txt
check "clean (nothing idle long enough)" "$VCS" workspaces clean
check "keeps them all" test -d ../agent1 -a -d ../sub1 -a -d ../app2
check "clean, no idle time" "$VCS" workspaces clean --idle 0s
check "keeps work that hasn't landed" test -f ../agent1/agent.txt -a -f ../sub1/sub.txt
check "removes a workspace whose change was empty" test ! -e ../app3
check "never this one" test -d .onset
check "agent1 lands" "$VCS" -C ../agent1 land -m "Agent work"
check "clean again" "$VCS" workspaces clean --idle 0s
check "removes it once its work landed" test ! -e ../agent1
check "and forgets it" sh -c "! '$VCS' workspaces | grep -q agent1"
check "main has its work" sh -c "'$VCS' sync >/dev/null && test -f agent.txt"

# Renames: a move shows as one, an edit made elsewhere follows the file to
# its new name when it lands, and history follows it back.
cd "$WORK"
"$VCS" get ./app ren1 >/dev/null 2>&1
mkdir -p ren1/notes && for i in $(seq 1 30); do printf 'note line %s\n' "$i"; done > ren1/notes/long.txt
check "land a long file" "$VCS" -C ren1 land -m "Long notes"
"$VCS" get ./app ren2 >/dev/null 2>&1
mkdir -p ren1/docs && mv ren1/notes/long.txt ren1/docs/long.md
check "status shows the move" sh -c "'$VCS' -C ren1 status | grep -q 'R notes/long.txt -> docs/long.md'"
check "land the move" "$VCS" -C ren1 land -m "Move the notes"
perl -pi -e 's/^note line 20$/note line twenty/' ren2/notes/long.txt
check "an edit to the old name lands" "$VCS" -C ren2 land -m "Edit the notes"
"$VCS" -C ren1 sync >/dev/null 2>&1
check "the edit followed the file" grep -q 'note line twenty' ren1/docs/long.md
check "and the old name is gone" test ! -e ren1/notes/long.txt
check "log follows the move" sh -c "'$VCS' -C ren1 log docs/long.md | grep -q 'from notes/long.txt' && '$VCS' -C ren1 log docs/long.md | grep -q 'Long notes'"
LONG=$(json -C ren1 log docs/long.md | python3 -c 'import json,sys; print([v["n"] for v in json.load(sys.stdin)["versions"] if v["title"] == "Long notes"][0])')
check "blame goes back past the move" test "$(json -C ren1 blame docs/long.md | python3 -c 'import json,sys; print(json.load(sys.stdin)["lines"][0]["version"])')" = "$LONG"

# Smart merges: two new functions at the same spot both go in, and imports combine.
printf 'import { a } from "./a";\nimport { z } from "./z";\n\nexport function one() {}\n' > ren1/smart.ts
"$VCS" -C ren1 land -m "Smart base" >/dev/null 2>&1
"$VCS" -C ren2 sync >/dev/null 2>&1
printf 'import { a } from "./a";\nimport { b } from "./b";\nimport { z } from "./z";\n\nexport function one() {}\nexport function two() {}\n' > ren1/smart.ts
printf 'import { a } from "./a";\nimport { c } from "./c";\nimport { z } from "./z";\n\nexport function one() {}\nexport function three() {}\n' > ren2/smart.ts
check "one side lands" "$VCS" -C ren1 land -m "Two"
check "the other lands without a conflict" "$VCS" -C ren2 land -m "Three"
"$VCS" -C ren1 sync >/dev/null 2>&1
check "both functions and all imports, in order" test "$(cat ren1/smart.ts)" = "$(printf 'import { a } from "./a";\nimport { b } from "./b";\nimport { c } from "./c";\nimport { z } from "./z";\n\nexport function one() {}\nexport function two() {}\nexport function three() {}')"

# Bisect: the first version where a check fails, tried in a folder of its own.
mkdir "$WORK/bis" && cd "$WORK/bis"
printf 'fine\n' > state.txt
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "v1" >/dev/null 2>&1
for i in 2 3 4 5 6; do printf 'fine %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done
printf 'broken\n' > state.txt && "$VCS" land -m "Breaks it" >/dev/null 2>&1
for i in 8 9 10; do printf 'broken %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done
check "bisect finds the version that broke it" test "$(json bisect 1 10 --run 'grep -q fine state.txt' | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7
check "the workspace's files didn't change" grep -q 'broken 10' state.txt
check "with --in it keeps the folder" sh -c "'$VCS' bisect 1 main --run 'grep -q fine state.txt' --in ../bis-try >/dev/null && test -f ../bis-try/state.txt"
printf 'grep -qx "fine 6" state.txt && exit 125\ngrep -q fine state.txt\n' > "$WORK/skip-check.sh"
check "exit 125 skips a version" test "$(json bisect 1 10 --run "sh $WORK/skip-check.sh" | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7
check "a good version after the bad one is refused (exit 2)" code 2 "$VCS" bisect 10 1 --run true

# Release lines: 1.x from version 2 gets fixes of its own, and a fix from
# main comes over (cleanly, or as a change on the line with conflicts marked).
mkdir "$WORK/rel" && cd "$WORK/rel"
printf 'one\ntwo\nthree\n' > app.txt && printf 'v1\n' > VERSION
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1
printf 'v2\n' > VERSION && "$VCS" land -m "Two" >/dev/null 2>&1
check "start line 1.x from version 2" "$VCS" line 1.x --from 2
check "a second line by the same name is refused" code 1 "$VCS" line 1.x
check "vcs line lists it" sh -c "'$VCS' line | grep -q 'from main 2'"
printf 'v3\n' > VERSION && printf 'ONE\ntwo\nthree\n' > app.txt && "$VCS" land -m "Three" >/dev/null 2>&1
cd "$WORK"
check "get a workspace on the line" "$VCS" get ./rel rel-1x --line 1.x
check "it has the line's files" test "$(cat rel-1x/VERSION)" = v2
printf 'v2.1\n' > rel-1x/VERSION
check "land a fix on the line" "$VCS" -C rel-1x land -m "Fix on 1.x"
check "it's 1.x/1" test "$(json -C rel-1x log --line 1.x | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1
check "main didn't move" test "$(json -C rel log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3
check "the workspace stays on the line" sh -c "'$VCS' -C rel-1x status | grep -q 'on 1.x/1\|1.x/1'"
printf 'v2.2\n' > rel-1x/VERSION
check "the next land goes on the line too" "$VCS" -C rel-1x land -m "Second fix on 1.x"
check "show reads a line" test "$("$VCS" -C rel show VERSION --from 1.x)" = v2.2
check "and a line's version" test "$("$VCS" -C rel show VERSION --from 1.x/1)" = v2.1
printf 'ONE\ntwo\nTHREE\n' > rel/app.txt
"$VCS" -C rel land -m "Fix the third line" >/dev/null 2>&1
FIX=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])')
check "bring main's fix over" "$VCS" -C rel land "$FIX" --to 1.x
check "only the fix came over" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'one\ntwo\nTHREE')"
check "as 1.x/3" test "$(json -C rel log --line 1.x | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3
"$VCS" -C rel sync >/dev/null 2>&1
printf 'UNO\ntwo\nTHREE\n' > rel/app.txt
"$VCS" -C rel land -m "Rename the first line" >/dev/null 2>&1
CLASH=$(json -C rel log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])')
check "a fix that conflicts with the line (exit 3)" code 3 "$VCS" -C rel land "$CLASH" --to 1.x
check "the workspace is on the line with it marked" sh -c "'$VCS' -C rel status | grep -q '1.x/3' && grep -q '<<<<<<<' rel/app.txt"
printf 'uno\ntwo\nTHREE\n' > rel/app.txt
check "fixed, it lands on the line" "$VCS" -C rel land
check "as 1.x/4" test "$("$VCS" -C rel show app.txt --from 1.x/4)" = "$(printf 'uno\ntwo\nTHREE')"
check "vcs new --line starts on the line's latest" sh -c "'$VCS' -C rel new --line 1.x | grep -q '1.x/4'"
printf 'uno\ntwo\nTHREE\nfour\n' > rel/app.txt
check "land 1.x/5" sh -c "'$VCS' -C rel land -m 'Add four' | grep -q '1.x/5'"
check "vcs undo takes a line's landing back" sh -c "'$VCS' -C rel undo | grep -q '1.x/6 takes 1.x/5 back out'"
check "the line is as it was" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'uno\ntwo\nTHREE')"
check "and the change is open again" sh -c "'$VCS' -C rel status | grep -q 'open'"
check "vcs undo 1.x/3 takes an older one back" sh -c "'$VCS' -C rel undo 1.x/3 | grep -q 'takes it back out'"
check "keeping what came after it" test "$("$VCS" -C rel show app.txt --from 1.x)" = "$(printf 'uno\ntwo\nthree')"

# Purge: a key that landed comes out of every version and its content is
# deleted, but not while another path still has the same bytes.
mkdir "$WORK/pur" && cd "$WORK/pur"
printf 'app\n' > app.txt
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1
mkdir keys && printf 'not-a-real-key-7f3a\n' > keys/id.pem
"$VCS" land -m "Oops, a key" --allow-secrets >/dev/null 2>&1
printf 'app 2\n' > app.txt && cp keys/id.pem copy.pem
"$VCS" land -m "More, and a copy" --allow-secrets >/dev/null 2>&1
KEYHEX=$(printf '\001not-a-real-key-7f3a\n' | sha256sum | cut -c1-64)
KEYOBJ="$ONSET_HOME/objects/${KEYHEX:0:2}/${KEYHEX:2}"
check "the key is stored" test -f "$KEYOBJ"
check "without --yes it only says what it would do" sh -c "'$VCS' purge keys/id.pem | grep -q 'would' && test -f keys/id.pem"
check "purge it" "$VCS" purge keys/id.pem --yes
check "gone from the workspace" test ! -e keys
check "and from every version" sh -c "! '$VCS' show keys/id.pem --from 2 >/dev/null 2>&1 && ! '$VCS' show keys/id.pem --from 3 >/dev/null 2>&1"
check "versions keep their numbers" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3
check "the copy still has the bytes" test -f "$KEYOBJ" -a -f copy.pem
check "purge the copy too" "$VCS" purge copy.pem --yes
check "now the bytes are gone" test ! -e "$KEYOBJ"
check "the rest is whole" "$VCS" check
check "nothing comes back on the next save" sh -c "'$VCS' status | grep -q 'no changes yet'"
printf 'app 3\n' > app.txt
check "landing goes on" "$VCS" land -m "After the purge"
check "a path no version has" sh -c "'$VCS' purge nothing/here.txt --yes | grep -q 'nothing in'"

# Agent sessions: what the agent was asked, said and ran since its last land
# is kept with the change it lands, secrets removed; off stops it, delete
# removes it.
mkdir "$WORK/ses" && cd "$WORK/ses"
printf 'x\n' > a.txt
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1
mkdir -p "$WORK/claude/projects/-elsewhere"
SES="$WORK/claude/projects/-elsewhere/abc-123.jsonl"
printf '%s\n' '{"type":"user","message":{"role":"user","content":"add b, the key is ghp_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}}' \
  '{"type":"assistant","message":{"content":[{"type":"text","text":"Adding b."},{"type":"tool_use","name":"Bash","input":{"command":"on land -m B"}}]}}' > "$SES"
agent() { CLAUDE_CONFIG_DIR="$WORK/claude" CLAUDE_CODE_SESSION_ID=abc-123 "$@"; }
last() { json log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["change"])'; }
printf 'b\n' > b.txt
check "an agent's land keeps its session" sh -c "CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m B | grep -q 'Claude Code, 2 messages'"
B=$(last)
check "show prints it" sh -c "'$VCS' sessions show $B | grep -q 'agent: Adding b.' && '$VCS' sessions show $B | grep -q 'ran Bash on land'"
check "with the secret removed" sh -c "'$VCS' sessions show $B --raw | grep -q 'secret removed' && ! '$VCS' sessions show $B --raw | grep -q ghp_AAAA"
printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"Now c."}]}}' >> "$SES"
printf 'c\n' > c.txt
agent "$VCS" land -m "C" >/dev/null 2>&1
C=$(last)
check "the next land keeps only what came after" sh -c "'$VCS' sessions show $C | grep -q 'Now c.' && ! '$VCS' sessions show $C | grep -q 'Adding b.'"
check "a land by hand keeps nothing" sh -c "printf 'h\n' > h.txt && ! '$VCS' land -m Hand | grep -q '^session'"
check "vcs sessions lists them" test "$("$VCS" sessions | grep -c 'Claude Code')" = 2
check "vcs gc keeps them" sh -c "ONSET_GC_FRESH=0 '$VCS' gc >/dev/null && '$VCS' sessions show $B | grep -q 'Adding b.'"
check "off" "$VCS" sessions off
printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"Now d."}]}}' >> "$SES"
printf 'd\n' > d.txt
check "nothing is kept while it's off" sh -c "! CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m D | grep -q '^session'"
check "on again" "$VCS" sessions on
printf 'e\n' > e.txt
check "ONSET_SESSIONS=0 skips one land" sh -c "! ONSET_SESSIONS=0 CLAUDE_CONFIG_DIR=$WORK/claude CLAUDE_CODE_SESSION_ID=abc-123 '$VCS' land -m E | grep -q '^session'"
mkdir -p "$WORK/codex/sessions/2026/10/28"
printf '%s\n' "{\"type\":\"session_meta\",\"payload\":{\"id\":\"cx-1\",\"cwd\":\"$(native "$(pwd -P)")\"}}" \
  '{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"make f"}]}}' \
  '{"type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"Made f."}]}}' > "$WORK/codex/sessions/2026/10/28/rollout-cx-1.jsonl"
printf 'f\n' > f.txt
check "a Codex session in this folder is kept" sh -c "CODEX_HOME=$WORK/codex '$VCS' land -m F | grep -q 'Codex, 2 messages'"
check "delete one change's" "$VCS" sessions delete "$B"
check "it's gone" sh -c "'$VCS' sessions show $B | grep -q 'none kept'"
check "delete --all" "$VCS" sessions delete --all
check "none left" test "$("$VCS" sessions | grep -c 'Claude Code')" = 0

# Submodules: a pointer to a commit, added, pointed at another commit (or the
# one checked out in its folder), checked out with git, and removed.
cd "$WORK"
gc_() { git -c user.name=T -c user.email=t@example.com "$@"; }
git init -q sublib && (cd sublib && printf 'v1\n' > lib.txt && git add -A && gc_ commit -qm one && printf 'v2\n' > lib.txt && gc_ commit -qam two)
L1=$(git -C sublib rev-parse HEAD~1)
L2=$(git -C sublib rev-parse HEAD)
mkdir "$WORK/subs" && cd "$WORK/subs"
printf 'app\n' > app.txt
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "First" >/dev/null 2>&1
SUBURL=$(native "$WORK/sublib")
check "add a submodule" "$VCS" submodule vendor/lib "$L1" --url "$SUBURL"
check ".gitmodules names it" grep -q "url = $SUBURL" .gitmodules
check "it lands" "$VCS" land -m "Add lib"
check "vcs submodule lists it" sh -c "'$VCS' submodule | grep -q 'vendor/lib  ${L1:0:12}'"
check "check it out" "$VCS" submodule --checkout
check "at its commit" test "$(cat vendor/lib/lib.txt)" = v1
check "nothing in it is saved" sh -c "'$VCS' status | grep -q 'no changes yet'"
git -C vendor/lib checkout -q "$L2" 2>/dev/null
check "it says the checkout moved" sh -c "'$VCS' submodule | grep -q 'records it'"
check "record the commit checked out" sh -c "'$VCS' submodule vendor/lib | grep -q 'now points at ${L2:0:12}'"
check "status shows it" sh -c "'$VCS' status | grep -q 'M vendor/lib'"
check "it lands too" "$VCS" land -m "Lib two"
check "main has the new commit" sh -c "'$VCS' --json submodule | grep -q $L2"
check "a commit that isn't one (exit 2)" code 2 "$VCS" submodule vendor/lib nothex
check "removing one with a checkout in it is refused (exit 2)" code 2 "$VCS" submodule vendor/lib --remove
rm -rf vendor/lib
check "remove it" "$VCS" submodule vendor/lib --remove
check "and its .gitmodules entry" test ! -e .gitmodules
check "that lands" "$VCS" land -m "No lib"
check "none left" sh -c "'$VCS' submodule | grep -q 'none in this project'"

# A SHA-256 git repository imports like any other, and its branches come in as changes.
cd "$WORK"
git init -q --object-format=sha256 sha256repo
(cd sha256repo && printf 'one\n' > a.txt && git add -A && gc_ commit -qm "First" && printf 'two\n' > a.txt && gc_ commit -qam "Second")
check "import a SHA-256 repository" "$VCS" import sha256repo sha256proj
check "with its history" test "$(json -C sha256proj log | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["versions"]))')" = 2
check "and its files" test "$(cat sha256proj/a.txt)" = two
check "its versions name their 64-digit commits" sh -c "'$VCS' --json -C sha256proj log -n 1 | grep -q \"$(git -C sha256repo rev-parse HEAD)\""
(cd sha256repo && git checkout -qb feature && printf 'three\n' > b.txt && git add -A && gc_ commit -qm "Feature")
check "a branch of it comes in as a change" "$VCS" -C sha256proj import ../sha256repo --change feature
check "and lands" "$VCS" -C sha256proj land
check "with the branch's file" test "$(cat sha256proj/b.txt)" = three
check "a SHA-256 submodule commit" "$VCS" -C sha256proj submodule lib "$(git -C sha256repo rev-parse HEAD)" --url https://example.com/lib.git

# Onset was called vcs before it had its name: what a machine set up then
# has keeps working. A workspace's .vcs folder becomes .onset, a project's
# vcs.toml is read, VCS_* settings count, and the data folder stays.
cd "$WORK"
"$VCS" init oldname >/dev/null 2>&1 && printf 'old\n' > oldname/a.txt && "$VCS" -C oldname land -m "Before the name" >/dev/null 2>&1
mv oldname/.onset oldname/.vcs
check "a .vcs workspace is still one" sh -c "'$VCS' -C oldname status | grep -q 'no changes yet'"
check "and its folder is .onset now" test -d oldname/.onset -a ! -e oldname/.vcs
printf '[land]\nrun = ["exit 3"]\n' > oldname/vcs.toml
printf 'more\n' >> oldname/a.txt
check "vcs.toml is read" code 4 "$VCS" -C oldname land -m "Checked"
rm oldname/vcs.toml
check "VCS_ settings count" sh -c "VCS_JSON=1 '$VCS' -C oldname status | grep -q '\"ok\"'"
check "and it lands" "$VCS" -C oldname land -m "By the old name"
# Where each system keeps app data; the folder from then is named vcs.
case "$(uname -s)" in
  Darwin) OLDDATA="$WORK/fakehome/Library/Application Support" ;;
  MINGW* | MSYS* | CYGWIN*) OLDDATA="$WORK/fakelocal" ;;
  *) OLDDATA="$WORK/fakehome/.local/share" ;;
esac
mkdir -p "$OLDDATA/vcs"
cp -R "$ONSET_HOME/." "$OLDDATA/vcs/"
check "a data folder named vcs is used" sh -c "env -u ONSET_HOME -u XDG_DATA_HOME HOME='$WORK/fakehome' LOCALAPPDATA='$(native "$WORK/fakelocal")' '$VCS' --json -C oldname log -n 1 | grep -q 'By the old name' && test ! -e '$OLDDATA/onset'"

# A .git in each workspace, for editors and tools: at the change's base, so
# git shows the change's own edits; git's commit and push say what to run.
if command -v git >/dev/null 2>&1; then
  cd "$WORK"
  mkdir gv && cd gv
  printf 'one\n' > a.txt
  printf 'SECRET=2\n' > .env
  export ONSET_GIT_WAIT=1
  "$VCS" init >/dev/null 2>&1
  "$VCS" land -m "Git view one" >/dev/null 2>&1
  check "a workspace has a .git" test -f .git
  check "git sees no changes" test -z "$(git status --porcelain)"
  printf 'two\n' >> a.txt
  check "git sees the edit" sh -c "git status --porcelain | grep -q ' M a.txt'"
  check "git diff shows it" sh -c "git diff | grep -q '^+two'"
  check "git commit says to land" sh -c "git -c user.name=T -c user.email=t@example.com commit -qam x 2>&1 | grep -q 'on land'"
  "$VCS" land -m "Git view two" >/dev/null 2>&1
  check "after a land, git is at main's latest" sh -c "git log -1 --format=%s | grep -q 'main [0-9]*: Git view two'"
  check "and git log reads as main's versions" sh -c "git log --format=%s | sed -n 2p | grep -q 'Git view one'"
  check "git sees no changes again" test -z "$(git status --porcelain)"
  check "Onset's own folder and .env aren't changes to git" sh -c "! git status --porcelain --untracked-files=all | grep -q -e '.onset' -e '.env'"
  check "a second workspace shares the objects" sh -c "cd '$WORK' && '$VCS' get ./gv gv2 >/dev/null 2>&1 && test \"\$(git -C gv2 rev-parse HEAD)\" = \"\$(git -C gv rev-parse HEAD)\""
  check "ONSET_GIT=0 makes none" sh -c "cd '$WORK' && ONSET_GIT=0 '$VCS' get ./gv gv3 >/dev/null 2>&1 && test ! -e gv3/.git"
  unset ONSET_GIT_WAIT
  cd "$WORK"
fi

# on watch: a check on each new version of main; the version that breaks it
# is found by bisecting and taken back, and its change is open again.
cd "$WORK"
mkdir wt && cd wt
printf 'test ! -e broken\n' > check.sh
printf 'one\n' > a.txt
"$VCS" init >/dev/null 2>&1
"$VCS" land -m "Watch one" >/dev/null 2>&1
latest() { json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])'; }
GOOD=$(latest)
for i in 2 3; do printf '%s\n' "$i" >> a.txt; "$VCS" land -m "Fine $i" >/dev/null 2>&1; done
printf 'x\n' > broken
"$VCS" land -m "Breaks it" >/dev/null 2>&1
BROKE=$(latest)
BROKE_CHANGE=$(json log "$BROKE" | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"])')
printf '5\n' >> a.txt
"$VCS" land -m "Fine after" >/dev/null 2>&1
check "watch takes back the version that broke the check" sh -c "'$VCS' watch --run 'sh check.sh' --from $GOOD --once | grep -q 'main $BROKE (\"Breaks it\"'"
check "main passes the check again" sh -c "! '$VCS' show broken >/dev/null 2>&1"
check "what landed after it stays" sh -c "'$VCS' show a.txt | grep -q '^5$'"
check "its change is open again" sh -c "'$VCS' --json status $BROKE_CHANGE | grep -q '\"state\": *\"open\"'"
check "the take-back says what failed" sh -c "'$VCS' log \$('$VCS' --json log | python3 -c 'import json,sys; print(json.load(sys.stdin)[\"versions\"][0][\"n\"])') | grep -q 'failed on it'"
check "a second watch has nothing new to check" test -z "$("$VCS" watch --run 'sh check.sh' --once 2>/dev/null | grep -v '^$')"
printf '6\n' >> a.txt
rm -f broken
"$VCS" land -m "Fine later" >/dev/null 2>&1
check "and checks only what landed since" sh -c "'$VCS' watch --run 'sh check.sh' --once | grep -q 'passed *main $((BROKE + 3))'"
check "a check that fails with nothing known to pass says so (exit 4)" code 4 sh -c "cd '$WORK/wt' && '$VCS' watch --run 'false' --once"
cd "$WORK"

# on git mirror: main to a branch of any git repository and back (a bare
# repository stands in for GitHub here).
if command -v git >/dev/null 2>&1; then
  cd "$WORK"
  mkdir mir && cd mir
  printf 'a1\n' > a.txt
  printf 'b1\n' > b.txt
  "$VCS" init >/dev/null 2>&1
  "$VCS" land -m "Mirror one" >/dev/null 2>&1
  printf 'a2\n' >> a.txt
  "$VCS" land -m "Mirror two" >/dev/null 2>&1
  git init -q --bare -b main "$WORK/gh.git"
  check "mirror writes main to the branch" sh -c "'$VCS' git mirror '$(native "$WORK/gh.git")' --once | grep -q 'mirrored *main 2'"
  git clone -q "$WORK/gh.git" "$WORK/ghc"
  check "each version is a commit, with its trailers" sh -c "git -C '$WORK/ghc' log -1 --format=%B | grep -q 'Onset-Version: 2'"
  check "with its author" test "$(git -C "$WORK/ghc" log -1 --format=%an)" = "Test Person"
  # A pull request merged there, and a land here meanwhile.
  printf 'b2 from git\n' >> "$WORK/ghc/b.txt"
  git -C "$WORK/ghc" -c user.name=Gitty -c user.email=g@example.com commit -qam "Fixed on the git side"
  git -C "$WORK/ghc" push -q
  printf 'a3\n' >> a.txt
  "$VCS" land -m "Mirror three" >/dev/null 2>&1
  check "commits made there come into main" sh -c "'$VCS' git mirror '$(native "$WORK/gh.git")' --once | grep -q 'came in *1 commit from git'"
  check "main has both" sh -c "'$VCS' show b.txt | grep -q 'b2 from git' && '$VCS' show a.txt | grep -q a3"
  git -C "$WORK/ghc" pull -q
  check "and the branch has both, joined by a merge" sh -c "grep -q a3 '$WORK/ghc/a.txt' && grep -q 'b2 from git' '$WORK/ghc/b.txt' && test \"\$(git -C '$WORK/ghc' log -1 --format=%p | wc -w | tr -d ' ')\" = 2"
  check "a mirror with nothing new does nothing" test -z "$("$VCS" git mirror "$(native "$WORK/gh.git")" --once 2>/dev/null)"
  git -C "$WORK/ghc" -c user.name=Gitty -c user.email=g@example.com commit -q --allow-empty -m x
  git -C "$WORK/ghc" push -q -f origin HEAD~2:main 2>/dev/null
  check "a branch rewritten there stops the mirror (exit 3)" code 3 "$VCS" git mirror "$(native "$WORK/gh.git")" --once
  cd "$WORK"
fi

echo "local: $pass passed, $fail failed"
[ "$fail" = 0 ]