35b76657

feat: the daemon can write down what only it knows

a73x 2026-08-26 15:01

Commit message

feat: the daemon can write down what only it knows

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

build.zig

Old		New
@@ -246,7 +246,7 @@ const mod_table = [_]ModSpec{
246	// it names directly (the key it loads, the idle default it falls back	246	// it names directly (the key it loads, the idle default it falls back
247	// to). xdg is for endpoint_req's lazy bind — the default key path,	247	// to). xdg is for endpoint_req's lazy bind — the default key path,
248	// resolved by the daemon itself when nobody handed it a --key.	248	// resolved by the daemon itself when nobody handed it a --key.
249	.{ .name = "server", .path = "src/server.zig", .layer = 2, .link_libc = true, .imports = &.{ "engine", "pty", "protocol", "delta", "cmd", "shellint", "sockpath", "quic", "quic_server", "xdg" }, .test_imports = &.{ "replica", "testtmp" }, .quic_tests = true },	249	.{ .name = "server", .path = "src/server.zig", .layer = 2, .link_libc = true, .imports = &.{ "engine", "pty", "protocol", "delta", "cmd", "shellint", "sockpath", "quic", "quic_server", "xdg", "upgrade" }, .test_imports = &.{ "replica", "testtmp" }, .quic_tests = true },
250	// The agent-facing client. It speaks frames and owns no terminal, which	250	// The agent-facing client. It speaks frames and owns no terminal, which
251	// is the whole point — it attaches at 0x0 and never claims the grid.	251	// is the whole point — it attaches at 0x0 and never claims the grid.
252	// The transport modules are the CLI client's, minus everything that	252	// The transport modules are the CLI client's, minus everything that

src/server.zig

@@ @@ -22,6 +22,7 @@ const sockpath = @import("sockpath"); @@
+const quic = @import("quic");
+const quic_server = @import("quic_server");
+const xdg = @import("xdg");
+const upgrade = @import("upgrade");
+const TmpDir = @import("testtmp").TmpDir;
+const max_clients = 8;
@@ @@ -504,6 +505,11 @@ pub const Server = struct { @@
+    /// shell and orphan all but the last from teardown.) Every slice points
+    /// into shellint_arena.
+    spawn_plan: SpawnPlan,
+    // Spawn inputs retained for the manifest: SpawnPlan is the computed
+    // result (argv/env after injection), not the inputs that produced it.
+    spawn_shell: [:0]const u8,
+    spawn_shell_integration: bool,
+    spawn_extra_env: []const Pty.EnvPair,
+    listener: std.net.Server,
+    sock_path: []const u8,
+    /// What the socket file was when we bound it, so teardown can tell our
@@ @@ -649,6 +655,9 @@ pub const Server = struct { @@
+        var srv: Server = .{
+            .alloc = alloc,
+            .spawn_plan = plan,
+            .spawn_shell = opts.shell,
+            .spawn_shell_integration = opts.shell_integration,
+            .spawn_extra_env = opts.extra_env,
+            .listener = listener,
+            .sock_path = opts.sock_path,
+            .path_id = path_id,
@@ @@ -3244,6 +3253,113 @@ pub const Server = struct { @@
+        try proto.writeFrame(fd, .stats_reply, try self.statsText(&buf));
+    // The manifest an exec-ing daemon leaves for its replacement. The
+    // writer's version and path are the rollback target's identity.
+    fn writeManifestTo(
+        self: *Server,
+        fd: std.posix.fd_t,
+        writer_version: []const u8,
+        writer_path: []const u8,
+    ) !void {
+        const a = self.alloc;
+        // QUIC runtime state: arm, fd, bound address, idle, key. The key
+        // crosses as bytes — the memfd is anonymous and the file may have
+        // moved. None means no QUIC at all.
+        var quic_state: upgrade.QuicState = .{};
+        switch (self.quic) {
+            .none => {},
+            .borrowed, .owned => |l| {
+                quic_state.arm = if (self.quic == .owned) .owned else .borrowed;
+                quic_state.fd = l.fd;
+                quic_state.idle_ms = l.idle_ms;
+                const addr = l.boundAddr();
+                const addr_bytes = std.mem.asBytes(&addr.any);
+                quic_state.addr_len = @intCast(addr_bytes.len);
+                @memcpy(quic_state.addr[0..addr_bytes.len], addr_bytes);
+                if (quic_server.Listener.currentKey()) |k| @memcpy(&quic_state.key, &k.bytes);
+            },
+        }
+        // extra_env: upgrade.EnvPair is { []const u8, ?[]const u8 } while
+        // Pty.EnvPair is { [:0]const u8, ?[:0]const u8 }; the manifest's
+        // shape is what crosses, so the mapping lives here.
+        const extra_env = try a.alloc(upgrade.EnvPair, self.spawn_extra_env.len);
+        defer a.free(extra_env);
+        for (self.spawn_extra_env, extra_env) |src, *dst| {
+            dst.* = .{ .key = src.key, .value = if (src.value) |v| v else null };
+        }
+        const daemon: upgrade.Daemon = .{
+            .writer_version = writer_version,
+            .writer_path = writer_path,
+            .sock_path = self.sock_path,
+            .listener_fd = self.listener.stream.handle,
+            .shellint_dir = self.shellint_dir,
+            .agent_dir = self.agent_dir,
+            .shell = self.spawn_shell,
+            .shell_integration = self.spawn_shell_integration,
+            .extra_env = extra_env,
+            .quic = quic_state,
+            .counters = .{
+                .snapshots = self.stats.snapshots,
+                .snapshot_bytes = self.stats.snapshot_bytes,
+                .deltas = self.stats.deltas,
+                .delta_bytes = self.stats.delta_bytes,
+                .snapshot_equiv_bytes = self.stats.snapshot_equiv_bytes,
+                .attaches = self.stats.attaches,
+                .agent_refused_no_offer = self.agent_refused_no_offer,
+                .agent_refused_full = self.agent_refused_full,
+            },
+        };
+        // One SessionRec per live session. dumpState is viewport-only by
+        // construction; the title is carried apart because dumpState has
+        // no title field.
+        var recs: std.ArrayList(upgrade.SessionRec) = .empty;
+        defer recs.deinit(a);
+        for (&self.sessions) |*slot| {
+            const s = slot.* orelse continue;
+            const vt = try s.eng.dumpState(a);
+            const title_bytes = s.eng.title();
+            const title: ?[]const u8 = if (title_bytes.len > 0) title_bytes else null;
+            try recs.append(a, .{
+                .name = s.name(),
+                .pty_fd = s.pty.master,
+                .child_pid = s.pty.child,
+                .cols = @intCast(s.eng.term.cols),
+                .rows = @intCast(s.eng.term.rows),
+                .vt = vt,
+                .title = title,
+                .cmd = .{
+                    .phase = @intFromEnum(s.cmd.phase),
+                    .marks_seen = s.cmd.marks_seen,
+                    .start_row = s.cmd.start_row,
+                    .end_row = s.cmd.end_row,
+                    .exit_code = s.cmd.exit_code,
+                },
+                .last_return = s.last_return,
+                .agent_fd = s.agent_listener,
+                .agent_path = if (s.agent_path) |p| p else null,
+            });
+        }
+        // Write to a buffer first, then to the fd: the manifest writer's
+        // anytype contract is an ArrayList writer (as the upgrade module's
+        // own tests use), and serializing to memory avoids coupling the
+        // manifest format to a particular fd writer's interface.
+        var manifest_buf: std.ArrayList(u8) = .empty;
+        defer manifest_buf.deinit(a);
+        try upgrade.writeManifest(manifest_buf.writer(a), a, daemon, recs.items);
+        var file = std.fs.File{ .handle = fd };
+        try file.seekTo(0);
+        try file.writeAll(manifest_buf.items);
+        // dumpState allocated each iteration; freed now that the manifest
+        // carries a copy.
+        for (recs.items) |r| a.free(r.vt);
+    }
+    pub const stats_main_fmt =
+        "snapshots={d} snapshot_bytes={d} deltas={d} delta_bytes={d}" ++
+        " snapshot_equiv_bytes={d} clients={d} attaches={d} sessions={d}" ++
+    try std.testing.expect(std.mem.indexOf(u8, got.items, "[48;30;100;0;0t") != null);
+test "writeManifestTo: what crosses is what a session cannot rebuild" {
+    const alloc = std.testing.allocator;
+    var tmp = try TmpDir.make();
+    defer tmp.cleanup();
+    const dir_path = tmp.path();
+    const sock_path = try std.fmt.allocPrint(alloc, "{s}/manif.sock", .{dir_path});
+    defer alloc.free(sock_path);
+    var srv = try Server.init(alloc, .{
+        .sock_path = sock_path,
+        .shell = "/bin/sh",
+        .shell_integration = true,
+        .extra_env = &.{.{ .key = "PS1", .value = ">>" }},
+    });
+    defer srv.deinit();
+    const s = &srv.sessions[0].?;
+    // Feed the engine a title so the manifest must carry it.
+    s.eng.feed("\x1b]0;t1\x07");
+    // Feed some content so dumpState is non-empty.
+    s.eng.feed("hello\r\n");
+    const memfd = try std.posix.memfd_create("mux-upgrade-test", 0);
+    defer std.posix.close(memfd);
+    try srv.writeManifestTo(memfd, "0.0.1-99", "/fake/muxd");
+    // Read back and parse.
+    var file = std.fs.File{ .handle = memfd };
+    try file.seekTo(0);
+    const buf = try file.readToEndAlloc(alloc, 4 * 1024 * 1024);
+    defer alloc.free(buf);
+    var parsed = try upgrade.parseManifest(alloc, buf);
+    defer parsed.deinit();
+    // Daemon section: sock_path and writer identity cross.
+    try std.testing.expectEqualStrings(sock_path, parsed.daemon.sock_path);
+    try std.testing.expectEqualStrings("0.0.1-99", parsed.daemon.writer_version);
+    try std.testing.expectEqualStrings("/fake/muxd", parsed.daemon.writer_path);
+    try std.testing.expectEqualStrings("/bin/sh", parsed.daemon.shell);
+    try std.testing.expect(parsed.daemon.shell_integration);
+    try std.testing.expectEqual(@as(usize, 1), parsed.daemon.extra_env.len);
+    try std.testing.expectEqualStrings("PS1", parsed.daemon.extra_env[0].key);
+    // Session section: name, cols/rows, title, pty fd.
+    try std.testing.expectEqual(@as(usize, 1), parsed.sessions.len);
+    try std.testing.expectEqualStrings(proto.default_session, parsed.sessions[0].name);
+    try std.testing.expectEqual(@as(u16, 80), parsed.sessions[0].cols);
+    try std.testing.expectEqual(@as(u16, 24), parsed.sessions[0].rows);
+    try std.testing.expectEqualStrings("t1", parsed.sessions[0].title.?);
+    try std.testing.expectEqual(s.pty.master, parsed.sessions[0].pty_fd);
+}