Skip to content
zit Artifact [20a8ea77e2]
Login

Artifact [20a8ea77e2]

Artifact 20a8ea77e2ed291924af5bb67d719c5d075d7dbfc23689a18f3e561b30121c21:


const std = @import("std");
const support = @import("support.zig");
const ConeTreeStore = support.ConeTreeStore;
const addManaged = support.addManaged;
const commitHashDup = support.commitHashDup;
const coneTreeServer = support.coneTreeServer;
const expectCheckoutVersion = support.expectCheckoutVersion;
const expectContains = support.expectContains;
const expectExit = support.expectExit;
const expectExitDiag = support.expectExitDiag;
const forksOfJson = support.forksOfJson;
const freeResult = support.freeResult;
const freshLoopbackPort = support.freshLoopbackPort;
const initRepo = support.initRepo;
const postXferCards = support.postXferCards;
const runCommitEnv = support.runCommitEnv;
const runZit = support.runZit;
const spawnServe = support.spawnServe;
const waitForListen = support.waitForListen;
const writeFile = support.writeFile;

test "cli autosync: pull informs the fork guard, push publishes, failure degrades, off silences" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    // Repo A — the peer. autosync OFF here, which doubles as the config-leak
    // probe: the clone below must come up with the DEFAULT (on), because the
    // setting is local and never crosses the wire.
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "one\n");
    try addManaged(gpa, io, tmp_a.dir, &.{"a.txt"});
    const c1 = try commitHashDup(gpa, io, tmp_a.dir, "c1");
    defer gpa.free(c1);
    {
        var so = try runZit(gpa, io, tmp_a.dir, &.{ "settings", "autosync", "off" });
        defer freeResult(gpa, &so);
        try expectExit(so.term, 0);
        try std.testing.expectEqualStrings("autosync off\n", so.stdout);
    }

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    var server_alive = true;
    defer if (server_alive) server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    {
        var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", url, "repo" });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
    }
    var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_dir.close(io);
    {
        var op = try runZit(gpa, io, b_dir, &.{"open"});
        defer freeResult(gpa, &op);
        try expectExit(op.term, 0);
    }
    // A's off did not cross the wire: B reads the default.
    {
        var sv = try runZit(gpa, io, b_dir, &.{"settings"});
        defer freeResult(gpa, &sv);
        try expectExit(sv.term, 0);
        // The bare listing reports the value in EFFECT for every setting, which
        // for an untouched repository is each setting's default -- including
        // pgp-command's, whose default is fossil's own command line.
        try std.testing.expectEqualStrings(
            "autosync on\nrepo-cksum off\nignore-glob \nkeep-glob \nmanifest \n" ++
                "clearsign off\npgp-command gpg --clearsign -o \nbefore-commit \n" ++
                "binary-glob \ncrlf-glob \ncrnl-glob \nencoding-glob \n" ++
                "clean-glob \nempty-dirs \ndotfiles \nmimetypes \nattachment-size-limit \neditor \nmain-branch trunk\n",
            sv.stdout,
        );
    }

    // A moves ahead while B is at c1.
    try writeFile(io, tmp_a.dir, "a.txt", "two\n");
    const c2 = try commitHashDup(gpa, io, tmp_a.dir, "c2");
    defer gpa.free(c2);

    // B commits without updating: the autosync pull fetches c2, so the fork
    // guard refuses NAMING it — divergence caught before it exists.
    try writeFile(io, b_dir, "a.txt", "b-edit\n");
    {
        var res = try runCommitEnv(gpa, io, b_dir, .{ .user = "b" }, &.{ "commit", "-m", "stale" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 1);
        try std.testing.expect(std.mem.indexOf(u8, res.stderr, c2) != null);
    }

    // Join the tip (keeping B's edit is not the point here — revert, update,
    // re-edit), then commit: success, and the push lands the check-in in A.
    {
        var rv = try runZit(gpa, io, b_dir, &.{"revert"});
        defer freeResult(gpa, &rv);
        try expectExit(rv.term, 0);
        var up = try runZit(gpa, io, b_dir, &.{ "update", "trunk" });
        defer freeResult(gpa, &up);
        try expectExit(up.term, 0);
    }
    try expectCheckoutVersion(io, b_dir, c2);
    try writeFile(io, b_dir, "a.txt", "three\n");
    {
        var res = try runCommitEnv(gpa, io, b_dir, .{ .user = "b" }, &.{ "commit", "-m", "b-third" });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    {
        var tl = try runZit(gpa, io, tmp_a.dir, &.{ "timeline", "-n", "1" });
        defer freeResult(gpa, &tl);
        try expectExit(tl.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, tl.stdout, "b-third") != null);
    }

    // Dead peer: the commit still succeeds, warning once. (`server.kill` stops
    // the listener; the port stays free of a second binder.)
    server.kill(io);
    server_alive = false;
    try writeFile(io, b_dir, "a.txt", "four\n");
    {
        var res = try runCommitEnv(gpa, io, b_dir, .{ .user = "b" }, &.{ "commit", "-m", "offline" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expect(std.mem.indexOf(u8, res.stderr, "continuing locally") != null);
    }

    // autosync off: the same dead peer draws no warning at all — inert, not
    // degraded. --no-sync would do the same for one invocation.
    {
        var so = try runZit(gpa, io, b_dir, &.{ "settings", "autosync", "off" });
        defer freeResult(gpa, &so);
        try expectExit(so.term, 0);
    }
    try writeFile(io, b_dir, "a.txt", "five\n");
    {
        var res = try runCommitEnv(gpa, io, b_dir, .{ .user = "b" }, &.{ "commit", "-m", "quiet-offline" });
        defer freeResult(gpa, &res);
        try expectExit(res.term, 0);
        try std.testing.expectEqualStrings("a.txt edited\n", res.stderr);
    }
}

fn expectLacks(hay: []const u8, needle: []const u8) !void {
    if (std.mem.indexOf(u8, hay, needle) == null) return;
    std.debug.print("unexpected {s} in:\n{s}\n", .{ needle, hay });
    return error.TestUnexpectedText;
}

fn expectJsonStrings(want: []const []const u8, got: []const std.json.Value) !void {
    try std.testing.expectEqual(want.len, got.len);
    for (want, got) |w, g| try std.testing.expectEqualStrings(w, g.string);
}

test "cli sync and pull: a fork the exchange brings exits 9 naming its leaves and paths; a stale fork is reported at 0; a merged one is gone" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;

    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "base\n");
    try writeFile(io, tmp_a.dir, "b.txt", "base\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "a.txt", "b.txt" });
    const c1 = try commitHashDup(gpa, io, tmp_a.dir, "c1");
    defer gpa.free(c1);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    var server_alive = true;
    defer if (server_alive) server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    // Two devices, each a clone of the origin, committing without autosync
    // so neither sees the other's check-in before its own sync.
    var tmp_devices = std.testing.tmpDir(.{});
    defer tmp_devices.cleanup();
    var dirs: [2]std.Io.Dir = undefined;
    for (&dirs, [_][]const u8{ "b", "c" }) |*d, name| {
        var clone = try runZit(gpa, io, tmp_devices.dir, &.{ "clone", "--no-open", url, name });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
        try expectLacks(clone.stderr, "fork on");
        d.* = try tmp_devices.dir.openDir(io, name, .{});
        var op = try runZit(gpa, io, d.*, &.{"open"});
        defer freeResult(gpa, &op);
        try expectExitDiag(op.term, 0, op);
        var so = try runZit(gpa, io, d.*, &.{ "settings", "autosync", "off" });
        defer freeResult(gpa, &so);
        try expectExitDiag(so.term, 0, so);
    }
    defer for (&dirs) |*d| d.close(io);
    const b_dir = dirs[0];
    const c_dir = dirs[1];

    try writeFile(io, b_dir, "b.txt", "b\n");
    const hb = try commitHashDup(gpa, io, b_dir, "b edits b.txt");
    defer gpa.free(hb);

    // No fork: exit 0, and the JSON's forks is empty.
    {
        var res = try runZit(gpa, io, b_dir, &.{ "sync", "-F", "json" });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
        var parsed: std.json.Parsed(std.json.Value) = undefined;
        const forks = try forksOfJson(gpa, res.stdout, &parsed);
        defer parsed.deinit();
        try std.testing.expectEqual(@as(usize, 0), forks.len);
        try std.testing.expect(parsed.value.object.get("sent").? == .integer);
        try expectLacks(res.stderr, "fork on");
    }

    try writeFile(io, c_dir, "a.txt", "c\n");
    try writeFile(io, c_dir, "c.txt", "new\n");
    try addManaged(gpa, io, c_dir, &.{"c.txt"});
    const hc = try commitHashDup(gpa, io, c_dir, "c edits a.txt, adds c.txt");
    defer gpa.free(hc);

    // C's sync brings B's check-in beside its own: a fork this sync made.
    {
        var res = try runZit(gpa, io, c_dir, &.{ "sync", "-F", "json" });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 9, res);
        try expectContains(res.stderr, "fork on trunk: 2 leaves (");
        try expectContains(res.stderr, hb[0..12]);
        try expectContains(res.stderr, hc[0..12]);
        var parsed: std.json.Parsed(std.json.Value) = undefined;
        const forks = try forksOfJson(gpa, res.stdout, &parsed);
        defer parsed.deinit();
        try std.testing.expectEqual(@as(usize, 1), forks.len);
        const fork = forks[0].object;
        try std.testing.expectEqualStrings("trunk", fork.get("branch").?.string);
        try std.testing.expect(fork.get("new").?.bool);
        const leaves = fork.get("leaves").?.array.items;
        try std.testing.expectEqual(@as(usize, 2), leaves.len);
        const hb_first = std.mem.eql(u8, leaves[0].string, hb);
        try std.testing.expectEqualStrings(if (hb_first) hb else hc, leaves[0].string);
        try std.testing.expectEqualStrings(if (hb_first) hc else hb, leaves[1].string);
        // B changed b.txt, C changed a.txt and added c.txt.
        try expectJsonStrings(&.{ "a.txt", "b.txt", "c.txt" }, fork.get("paths").?.array.items);
    }

    // Nothing new: the fork is still reported, but it is not this sync's.
    {
        var res = try runZit(gpa, io, c_dir, &.{"sync"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
        try expectContains(res.stdout, "already in sync");
        try expectContains(res.stderr, "fork on trunk: 2 leaves (");
    }

    // A fresh clone of the forked origin is told, and succeeds.
    {
        var clone = try runZit(gpa, io, tmp_devices.dir, &.{ "clone", "--no-open", url, "d" });
        defer freeResult(gpa, &clone);
        try expectExitDiag(clone.term, 0, clone);
        try expectContains(clone.stderr, "fork on trunk: 2 leaves (");
    }

    // B's pull brings C's check-in: the same fork, new to B.
    {
        var res = try runZit(gpa, io, b_dir, &.{"pull"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 9, res);
        try expectContains(res.stderr, "fork on trunk: 2 leaves (");
    }
    {
        var res = try runZit(gpa, io, b_dir, &.{ "pull", "-F", "json" });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
        var parsed: std.json.Parsed(std.json.Value) = undefined;
        const forks = try forksOfJson(gpa, res.stdout, &parsed);
        defer parsed.deinit();
        try std.testing.expectEqual(@as(usize, 1), forks.len);
        try std.testing.expect(!forks[0].object.get("new").?.bool);
    }

    // C merges B's leaf and syncs: the fork is gone on both sides.
    {
        var res = try runZit(gpa, io, c_dir, &.{ "merge", hb });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    const hm = try commitHashDup(gpa, io, c_dir, "merge b");
    defer gpa.free(hm);
    {
        var res = try runZit(gpa, io, c_dir, &.{"sync"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
        try expectLacks(res.stderr, "fork on");
    }
    {
        var res = try runZit(gpa, io, b_dir, &.{ "sync", "-F", "json" });
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
        var parsed: std.json.Parsed(std.json.Value) = undefined;
        const forks = try forksOfJson(gpa, res.stdout, &parsed);
        defer parsed.deinit();
        try std.testing.expectEqual(@as(usize, 0), forks.len);
    }

    // A fork that arrives by autosync leaves the hosting verb as it was:
    // no fork report, and no autosync failure.
    {
        var res = try runZit(gpa, io, b_dir, &.{"update"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    try writeFile(io, b_dir, "b.txt", "b2\n");
    const hb2 = try commitHashDup(gpa, io, b_dir, "b2");
    defer gpa.free(hb2);
    try writeFile(io, c_dir, "a.txt", "c2\n");
    const hc2 = try commitHashDup(gpa, io, c_dir, "c2");
    defer gpa.free(hc2);
    {
        var res = try runZit(gpa, io, c_dir, &.{"push"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 0, res);
    }
    {
        var so = try runZit(gpa, io, b_dir, &.{ "settings", "autosync", "on" });
        defer freeResult(gpa, &so);
        try expectExitDiag(so.term, 0, so);
    }
    {
        var res = try runZit(gpa, io, b_dir, &.{"update"});
        defer freeResult(gpa, &res);
        try expectLacks(res.stderr, "autosync pull failed");
        try expectLacks(res.stderr, "fork on");
    }
    {
        var lv = try runZit(gpa, io, b_dir, &.{"leaves"});
        defer freeResult(gpa, &lv);
        try expectExitDiag(lv.term, 0, lv);
        try expectContains(lv.stdout, hc2[0..10]);
    }

    // Offline: a failed sync stays a failure though a fork is present.
    server.kill(io);
    server_alive = false;
    {
        var res = try runZit(gpa, io, b_dir, &.{"sync"});
        defer freeResult(gpa, &res);
        try expectExitDiag(res.term, 1, res);
        try expectLacks(res.stderr, "fork on");
    }
}

test "cli sync keeps reporting a sub-manifest gap until the withheld node arrives" {
    // Goal: sync persists only what arrived, yet a tree it holds that names a
    // node nobody sent stays reported, and fails the run, on every later sync
    // until the node comes. Method: a hand-built origin that holds a check-in
    // whose second leaf it lacks; a clone syncs it twice, then once more after
    // the origin gains the leaf.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var src_tmp = std.testing.tmpDir(.{});
    defer src_tmp.cleanup();
    try initRepo(gpa, io, src_tmp.dir);
    var en = try runZit(gpa, io, src_tmp.dir, &.{ "submanifest", "enable", "--k", "1" });
    defer freeResult(gpa, &en);
    try expectExitDiag(en.term, 0, en);
    var t: ConeTreeStore = .{ .gpa = gpa, .io = io, .dir = src_tmp.dir };
    defer t.deinit();
    const first = try t.leaf(&.{"a/x"}, true);
    const tip = try t.checkin("C one\nD 2026-10-21T12:00:00.000\n", &.{.{ "a/x", first }});
    var server = try coneTreeServer(gpa, io, src_tmp.dir);
    defer gpa.free(server.url);
    defer server.child.kill(io);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", server.url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_dir.close(io);

    const late = try t.leaf(&.{"b/y"}, false);
    const head2 = try std.fmt.allocPrint(gpa, "C two\nD 2026-10-21T12:00:01.000\nP {s}\n", .{tip});
    defer gpa.free(head2);
    _ = try t.checkin(head2, &.{ .{ "a/x", first }, .{ "b/y", late } });

    for (0..2) |_| {
        var again = try runZit(gpa, io, b_dir, &.{ "sync", server.url });
        defer freeResult(gpa, &again);
        try expectExitDiag(again.term, 1, again);
        try expectContains(again.stderr, "1 sub-manifest references are missing");
    }

    t.dense = true;
    _ = try t.leaf(&.{"b/y"}, true);
    var healed = try runZit(gpa, io, b_dir, &.{ "sync", server.url });
    defer freeResult(gpa, &healed);
    try expectExitDiag(healed.term, 0, healed);
    try expectLacks(healed.stderr, "sub-manifest references are missing");
}

test "cli sync and pull heal a torn store tail and rebuild torn caches beside it" {
    // Goal: the caches beside a store are advisory and a torn final frame is
    // an interrupted write, so neither may fail a sync or a pull, including
    // the leaf read the fork report makes before the exchange. Method: a clone
    // whose store tail and each cache are torn in turn, then pull and sync.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var src_tmp = std.testing.tmpDir(.{});
    defer src_tmp.cleanup();
    try initRepo(gpa, io, src_tmp.dir);
    var en = try runZit(gpa, io, src_tmp.dir, &.{ "submanifest", "enable", "--k", "1" });
    defer freeResult(gpa, &en);
    try expectExitDiag(en.term, 0, en);
    var t: ConeTreeStore = .{ .gpa = gpa, .io = io, .dir = src_tmp.dir };
    defer t.deinit();
    const first = try t.leaf(&.{"a/x"}, true);
    const tip = try t.checkin("C one\nD 2026-10-21T12:00:00.000\n", &.{.{ "a/x", first }});
    var server = try coneTreeServer(gpa, io, src_tmp.dir);
    defer gpa.free(server.url);
    defer server.child.kill(io);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--no-open", server.url, "repo" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var b_dir = try tmp_b.dir.openDir(io, "repo", .{});
    defer b_dir.close(io);
    // A check-in the clone lacks, so the first sync below appends a frame and
    // the torn tail is that interrupted pull. Tearing the clone's own frame
    // instead would take the project code with it, and the peer would rightly
    // refuse a repository with no identity (sync §8.5).
    const head2 = try std.fmt.allocPrint(gpa, "C two\nD 2026-10-21T12:00:01.000\nP {s}\n", .{tip});
    defer gpa.free(head2);
    _ = try t.checkin(head2, &.{.{ "a/x", first }});

    const torn = [_][]const u8{
        ".zit",
        ".zit-cache/repo",
        ".zit-cache/index",
        ".zit-cache/clusters",
        ".zit-cache/clusters-resolved",
        ".zit-cache/submanifest-gaps",
    };
    for (torn) |path| {
        // A sync first, so every cache exists to be torn.
        var warm = try runZit(gpa, io, b_dir, &.{ "sync", server.url });
        defer freeResult(gpa, &warm);
        try expectExitDiag(warm.term, 0, warm);
        {
            var file = try b_dir.openFile(io, path, .{ .mode = .read_write });
            defer file.close(io);
            const st = try file.stat(io);
            try file.setLength(io, st.size - @min(st.size, 4));
        }
        inline for (.{ "pull", "sync" }) |verb| {
            var res = try runZit(gpa, io, b_dir, &.{ verb, server.url });
            defer freeResult(gpa, &res);
            expectExitDiag(res.term, 0, res) catch |e| {
                std.debug.print("after tearing {s}, {s}:\n", .{ path, verb });
                return e;
            };
        }
    }
}

test "cli sync §4/§6: an omitted URL with no saved remote is a usage error for pull, push, and sync" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);

    // No remote saved: each sync-family verb with no URL is a usage error (exit 2),
    // diagnostic on stderr, nothing on stdout.
    for ([_][]const u8{ "pull", "push", "sync" }) |verb| {
        var r = try runZit(gpa, io, tmp.dir, &.{verb});
        defer freeResult(gpa, &r);
        try expectExit(r.term, 2);
        try std.testing.expectEqualStrings("", r.stdout);
        try std.testing.expect(std.mem.indexOf(u8, r.stderr, "no saved remote") != null);
    }
}

test "sync §9.3 r28: the /shun config group carries the shun table to a clone" {
    // The gap the round-trip run found, and the reason it is a SAFETY gap
    // rather than a cosmetic one: fossil's shun table is its takedown
    // mechanism. A clone that arrives without it will, on its next sync with
    // any third party, re-accept exactly the content an operator was ordered to
    // remove — and the scale run showed the loss produced 12 spurious phantoms
    // as well, every one of them a shunned artifact.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDir(io, "origin", .default_dir);
    var origin = try tmp.dir.openDir(io, "origin", .{});
    defer origin.close(io);
    try initRepo(gpa, io, origin);

    // Three check-ins so there is content to suppress that is not the tip:
    // `shun` refuses the check-in the working tree sits on.
    inline for (.{ "a", "b", "c" }) |name| {
        try writeFile(io, origin, name ++ ".txt", "content " ++ name ++ "\n");
        try addManaged(gpa, io, origin, &.{name ++ ".txt"});
        var c = try runCommitEnv(gpa, io, origin, .{ .user = "alice" }, &.{ "commit", "-m", name });
        defer freeResult(gpa, &c);
        try expectExitDiag(c.term, 0, c);
    }

    var ls = try runZit(gpa, io, origin, &.{ "ls", "--long" }); // the blob-id leads a --long line
    defer freeResult(gpa, &ls);
    try expectExitDiag(ls.term, 0, ls);
    const first_line_end = std.mem.indexOfScalar(u8, ls.stdout, '\n').?;
    const blob = ls.stdout[0..std.mem.indexOfScalar(u8, ls.stdout[0..first_line_end], ' ').?];

    const reason = "DMCA takedown 2026-08";
    var sh = try runZit(gpa, io, origin, &.{ "shun", "--force", "--reason", reason, blob });
    defer freeResult(gpa, &sh);
    try expectExitDiag(sh.term, 0, sh);

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, origin, port);
    defer server.kill(io);
    try waitForListen(io, port);

    // The wire itself, before any clone: one `config /shun` card carrying
    // fossil's `configure_send_group` row shape.
    const cards = try postXferCards(gpa, io, port, "pragma client-version 20000\nreqconfig /shun\n");
    defer gpa.free(cards);
    try std.testing.expect(std.mem.indexOf(u8, cards, "config /shun ") != null);
    try std.testing.expect(std.mem.indexOf(u8, cards, blob) != null);
    try std.testing.expect(std.mem.indexOf(u8, cards, " scom '") != null);
    try std.testing.expect(std.mem.indexOf(u8, cards, reason) != null);
    try std.testing.expect(std.mem.indexOf(u8, cards, "error") == null);

    // And end to end: the clone comes up holding the tombstone, reason intact.
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);
    var cl = try runZit(gpa, io, tmp.dir, &.{ "clone", "--no-open", url, "clone" });
    defer freeResult(gpa, &cl);
    try expectExitDiag(cl.term, 0, cl);
    try std.testing.expect(std.mem.indexOf(u8, cl.stdout, "adopted 1 shun row") != null);

    var clone_dir = try tmp.dir.openDir(io, "clone", .{});
    defer clone_dir.close(io);
    var list = try runZit(gpa, io, clone_dir, &.{ "shun", "--list" });
    defer freeResult(gpa, &list);
    try expectExitDiag(list.term, 0, list);
    try std.testing.expect(std.mem.indexOf(u8, list.stdout, blob) != null);
    try std.testing.expect(std.mem.indexOf(u8, list.stdout, reason) != null);
}

test "cli sync --horizon: every check-in committed in a horizon clone reaches the origin, sync after sync" {
    // The delivered cursor is a log position. A sync that recorded more than
    // the log held put every later check-in below it, and sync and push both
    // said "already in sync" while the origin never received them.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "a0\n");
    try writeFile(io, tmp_a.dir, "b.txt", "b0\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "a.txt", "b.txt" });
    for ([_][]const u8{ "one", "two" }, 0..) |msg, i| {
        if (i != 0) try writeFile(io, tmp_a.dir, "a.txt", msg);
        var c = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", msg });
        defer freeResult(gpa, &c);
        try expectExitDiag(c.term, 0, c);
    }

    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--horizon=tip", url, "hz" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var hz = try tmp_b.dir.openDir(io, "hz", .{});
    defer hz.close(io);

    const probes = [_]struct { file: []const u8, msg: []const u8 }{
        .{ .file = "a.txt", .msg = "probe one" },
        .{ .file = "b.txt", .msg = "probe two" },
        .{ .file = "a.txt", .msg = "probe three" },
    };
    for (probes) |probe| {
        errdefer std.debug.print("probe: {s}\n", .{probe.msg});
        try writeFile(io, hz, probe.file, probe.msg);
        var c = try runCommitEnv(gpa, io, hz, .{ .user = "h" }, &.{ "commit", "-m", probe.msg, "--no-sync" });
        defer freeResult(gpa, &c);
        try expectExitDiag(c.term, 0, c);
        var sy = try runZit(gpa, io, hz, &.{ "sync", url });
        defer freeResult(gpa, &sy);
        try expectExitDiag(sy.term, 0, sy);
        try std.testing.expect(std.mem.indexOf(u8, sy.stdout, "already in sync") == null);
        var tl = try runZit(gpa, io, tmp_a.dir, &.{ "timeline", "-n", "10" });
        defer freeResult(gpa, &tl);
        try std.testing.expect(std.mem.indexOf(u8, tl.stdout, probe.msg) != null);
    }
    // A push after the syncs has nothing left to send, and the origin's
    // trunk is the last probe, with every parent present.
    var push = try runZit(gpa, io, hz, &.{ "push", url });
    defer freeResult(gpa, &push);
    try expectExitDiag(push.term, 0, push);
    var lv = try runZit(gpa, io, tmp_a.dir, &.{"leaves"});
    defer freeResult(gpa, &lv);
    try std.testing.expect(std.mem.indexOf(u8, lv.stdout, "probe three") != null);
    try std.testing.expect(std.mem.indexOf(u8, lv.stdout, "(2)") == null);
    var v = try runZit(gpa, io, tmp_a.dir, &.{"verify"});
    defer freeResult(gpa, &v);
    try expectExitDiag(v.term, 0, v);
}

test "cli sync --horizon: a no-op sync saves the horizon classification, and the next one reads it instead of classifying again" {
    // Every kept manifest below the horizon cites file versions the clone
    // never fetched. The classification has to persist with them, or every
    // sync re-reads every manifest in the store.
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp_a = std.testing.tmpDir(.{});
    defer tmp_a.cleanup();
    try initRepo(gpa, io, tmp_a.dir);
    try writeFile(io, tmp_a.dir, "a.txt", "a0\n");
    try writeFile(io, tmp_a.dir, "b.txt", "b0\n");
    try addManaged(gpa, io, tmp_a.dir, &.{ "a.txt", "b.txt" });
    for ([_][]const u8{ "one", "two", "three" }, 0..) |msg, i| {
        if (i != 0) try writeFile(io, tmp_a.dir, "a.txt", msg);
        var c = try runCommitEnv(gpa, io, tmp_a.dir, .{ .user = "u" }, &.{ "commit", "-m", msg });
        defer freeResult(gpa, &c);
        try expectExitDiag(c.term, 0, c);
    }
    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp_a.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}/", .{port});
    defer gpa.free(url);

    var tmp_b = std.testing.tmpDir(.{});
    defer tmp_b.cleanup();
    var clone = try runZit(gpa, io, tmp_b.dir, &.{ "clone", "--horizon=tip", url, "hz" });
    defer freeResult(gpa, &clone);
    try expectExitDiag(clone.term, 0, clone);
    var hz = try tmp_b.dir.openDir(io, "hz", .{});
    defer hz.close(io);

    var first = try runZit(gpa, io, hz, &.{ "sync", url });
    defer freeResult(gpa, &first);
    try expectExitDiag(first.term, 0, first);
    const saved = try readConeSidecar(gpa, io, hz);
    defer gpa.free(saved);

    var second = try runZit(gpa, io, hz, &.{ "sync", url });
    defer freeResult(gpa, &second);
    try expectExitDiag(second.term, 0, second);
    try std.testing.expect(std.mem.indexOf(u8, second.stdout, "already in sync") != null);
    const again = try readConeSidecar(gpa, io, hz);
    defer gpa.free(again);
    try std.testing.expectEqualSlices(u8, saved, again);
}

/// The one horizon classification sidecar (`.zit-cache/cone-*`) in `dir`.
fn readConeSidecar(gpa: std.mem.Allocator, io: std.Io, dir: std.Io.Dir) ![]u8 {
    var cache = try dir.openDir(io, ".zit-cache", .{ .iterate = true });
    defer cache.close(io);
    var it = cache.iterate();
    var found: ?[]u8 = null;
    errdefer if (found) |f| gpa.free(f);
    while (try it.next(io)) |e| {
        if (!std.mem.startsWith(u8, e.name, "cone-")) continue;
        if (found != null) return error.TestUnexpectedResult; // exactly one
        found = try cache.readFileAlloc(io, e.name, gpa, .limited(1 << 24));
    }
    return found orelse error.TestUnexpectedResult;
}

test "cli sync family: every network line names the peer, no-ops share one phrase, clone prints the project code, a dead peer is named" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try initRepo(gpa, io, tmp.dir);
    try writeFile(io, tmp.dir, "a.txt", "one\n");
    try addManaged(gpa, io, tmp.dir, &.{"a.txt"});
    var c1 = try runCommitEnv(gpa, io, tmp.dir, .{ .user = "u" }, &.{ "commit", "-m", "base" });
    defer freeResult(gpa, &c1);
    try expectExitDiag(c1.term, 0, c1);
    const port = try freshLoopbackPort(io);
    var server = try spawnServe(gpa, io, tmp.dir, port);
    defer server.kill(io);
    try waitForListen(io, port);
    const url = try std.fmt.allocPrint(gpa, "http://127.0.0.1:{d}", .{port});
    defer gpa.free(url);
    var away = std.testing.tmpDir(.{});
    defer away.cleanup();

    var cl = try runZit(gpa, io, away.dir, &.{ "clone", "--no-open", url, "work" });
    defer freeResult(gpa, &cl);
    try expectExitDiag(cl.term, 0, cl);
    try std.testing.expect(std.mem.indexOf(u8, cl.stdout, "clone from http://127.0.0.1:") != null);
    try std.testing.expect(std.mem.indexOf(u8, cl.stdout, "project-code: ") != null);
    var work = try away.dir.openDir(io, "work", .{});
    defer work.close(io);
    var op = try runZit(gpa, io, work, &.{"open"});
    defer freeResult(gpa, &op);
    try expectExitDiag(op.term, 0, op);

    inline for (.{ "sync", "pull", "push" }, .{ "sync with ", "pull from ", "push to " }) |verb, lead| {
        var r = try runZit(gpa, io, work, &.{verb});
        defer freeResult(gpa, &r);
        try expectExitDiag(r.term, 0, r);
        try std.testing.expect(std.mem.startsWith(u8, r.stdout, lead ++ "http://127.0.0.1:"));
        try std.testing.expect(std.mem.indexOf(u8, r.stdout, ": already in sync\n") != null);
    }
    // A transfer names the peer too, and the autosync inside commit does.
    try writeFile(io, work, "a.txt", "two\n");
    var c2 = try runCommitEnv(gpa, io, work, .{ .user = "u" }, &.{ "commit", "-m", "c2" });
    defer freeResult(gpa, &c2);
    try expectExitDiag(c2.term, 0, c2);
    try std.testing.expect(std.mem.indexOf(u8, c2.stderr, "push to http://127.0.0.1:") != null);
    try std.testing.expect(std.mem.indexOf(u8, c2.stderr, ": sent ") != null);
    // A dead peer: the host is named, exit 1.
    var dead = try runZit(gpa, io, work, &.{ "sync", "http://127.0.0.1:1" });
    defer freeResult(gpa, &dead);
    try expectExit(dead.term, 1);
    try std.testing.expect(std.mem.indexOf(u8, dead.stderr, "zit sync: cannot connect to http://127.0.0.1:1") != null);
}