Commit 0d66096

refactor(daemon): restructure io and allocators

Because we perform a double-fork when spawning a daemon we have to be careful
about multithreading and mutex locks within io and allocators or else we could
end up with a deadlock.  I don't fully understand how this happens within the
DebugAllocator but I've hit deadlocks previously.  So I restructured the Daemon
to not store io or an allocator and made it much more clear what is going on
and why we have to create a new allocator after the double-fork.

I also extracted the daemonize logic into its own file and set of fns mainly
because that code doesn't need to change much and it is mostly fork() machinery.

 1@@ -13,7 +13,7 @@ const macos_targets: []const std.Target.Query = &.{
 2 
 3 pub fn build(b: *std.Build) void {
 4     const target = b.standardTargetOptions(.{});
 5-    const is_macos = target.result.os.tag == .macos;
 6+    // const is_macos = target.result.os.tag == .macos;
 7     const optimize = b.standardOptimizeOption(.{});
 8     const version = b.option([]const u8, "version", "Version string for release") orelse
 9         @as([]const u8, build_zig_zon.version);
10@@ -51,8 +51,8 @@ pub fn build(b: *std.Build) void {
11         const run_step = b.step("run", "Run the app");
12         const exe = b.addExecutable(.{
13             .name = "zmx",
14-            .use_llvm = true,
15-            .use_lld = !is_macos,
16+            // .use_llvm = true,
17+            // .use_lld = !is_macos,
18             .root_module = exe_mod,
19         });
20 
21@@ -85,8 +85,8 @@ pub fn build(b: *std.Build) void {
22         );
23         const exe_unit_tests = b.addTest(.{
24             .root_module = test_module,
25-            .use_llvm = true,
26-            .use_lld = !is_macos,
27+            // .use_llvm = true,
28+            // .use_lld = !is_macos,
29         });
30 
31         const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
32@@ -98,8 +98,8 @@ pub fn build(b: *std.Build) void {
33         const check = b.step("check", "Check if zmx compiles");
34         const exe_check = b.addExecutable(.{
35             .name = "zmx",
36-            .use_llvm = true,
37-            .use_lld = !is_macos,
38+            // .use_llvm = true,
39+            // .use_lld = !is_macos,
40             .root_module = exe_mod,
41         });
42 
43@@ -136,11 +136,11 @@ pub fn build(b: *std.Build) void {
44                 release_mod.addImport("ghostty-vt", release_dep.module("ghostty-vt"));
45             }
46 
47-            const is_local_macos = resolved.result.os.tag == .macos;
48+            // const is_local_macos = resolved.result.os.tag == .macos;
49             const release_exe = b.addExecutable(.{
50                 .name = "zmx",
51-                .use_llvm = true,
52-                .use_lld = !is_local_macos,
53+                // .use_llvm = true,
54+                // .use_lld = !is_local_macos,
55                 .root_module = release_mod,
56             });
57 

  1@@ -0,0 +1,133 @@
  2+/// Cfg is zmx's configuration container.
  3+///
  4+/// The purpose of this container is to hold anything that can be modified by the user.
  5+pub const Cfg = @This();
  6+
  7+const std = @import("std");
  8+const lib_posix = @import("posix.zig");
  9+const cross = @import("cross.zig");
 10+
 11+socket_dir: []const u8,
 12+log_dir: []const u8,
 13+max_scrollback: usize = 10_000_000,
 14+dir_mode: u32 = 0o750,
 15+log_mode: u32 = 0o640,
 16+
 17+pub fn init(alloc: std.mem.Allocator, io: std.Io) !Cfg {
 18+    const socket_dir = try socketDir(alloc);
 19+    errdefer alloc.free(socket_dir);
 20+    const log_dir = try logDir(alloc);
 21+    errdefer alloc.free(log_dir);
 22+
 23+    const dir_mode = if (lib_posix.getenv("ZMX_DIR_MODE")) |m|
 24+        std.fmt.parseInt(u32, m, 8) catch 0o750
 25+    else
 26+        0o750;
 27+
 28+    const log_mode = if (lib_posix.getenv("ZMX_LOG_MODE")) |m|
 29+        std.fmt.parseInt(u32, m, 8) catch 0o640
 30+    else
 31+        0o640;
 32+
 33+    var cfg = Cfg{
 34+        .socket_dir = socket_dir,
 35+        .log_dir = log_dir,
 36+        .dir_mode = dir_mode,
 37+        .log_mode = log_mode,
 38+    };
 39+
 40+    try cfg.mkdir(io);
 41+
 42+    return cfg;
 43+}
 44+
 45+fn socketDir(alloc: std.mem.Allocator) ![]const u8 {
 46+    const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
 47+    const uid = lib_posix.getuid();
 48+
 49+    const socket_dir: []const u8 = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
 50+        try alloc.dupe(u8, zmxdir)
 51+    else if (lib_posix.getenv("XDG_RUNTIME_DIR")) |xdg_runtime|
 52+        try std.fmt.allocPrint(alloc, "{s}/zmx", .{xdg_runtime})
 53+    else
 54+        try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });
 55+
 56+    return socket_dir;
 57+}
 58+
 59+fn logDir(alloc: std.mem.Allocator) ![]const u8 {
 60+    const log_dir = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
 61+        try std.fmt.allocPrint(alloc, "{s}/logs", .{zmxdir})
 62+    else if (lib_posix.getenv("XDG_STATE_HOME")) |xdg_state_home|
 63+        try std.fmt.allocPrint(alloc, "{s}/zmx/logs", .{xdg_state_home})
 64+    else if (lib_posix.getenv("HOME")) |home_dir|
 65+        try std.fmt.allocPrint(alloc, "{s}/.local/state/zmx/logs", .{home_dir})
 66+    else fallback: {
 67+        // This is the last resort: falling back to /tmp/$UID if HOME is unset.
 68+        const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
 69+        const uid = lib_posix.getuid();
 70+        break :fallback try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });
 71+    };
 72+
 73+    return log_dir;
 74+}
 75+
 76+pub fn deinit(self: *Cfg, alloc: std.mem.Allocator) void {
 77+    if (self.socket_dir.len > 0) alloc.free(self.socket_dir);
 78+    if (self.log_dir.len > 0) alloc.free(self.log_dir);
 79+}
 80+
 81+pub fn mkdir(self: *Cfg, io: std.Io) !void {
 82+    const sock_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
 83+    try mkdirAll(io, self.socket_dir, sock_perms);
 84+    const log_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
 85+    try mkdirAll(io, self.log_dir, log_perms);
 86+}
 87+
 88+fn mkdirAll(io: std.Io, sub_dir_path: []const u8, permissions: std.Io.Dir.Permissions) !void {
 89+    var it = std.fs.path.componentIterator(sub_dir_path);
 90+    var component = it.last() orelse return error.BadPathName;
 91+    while (true) {
 92+        std.Io.Dir.createDirAbsolute(io, component.path, permissions) catch |err| switch (err) {
 93+            error.PathAlreadyExists => {},
 94+            error.FileNotFound => |e| {
 95+                component = it.previous() orelse return e;
 96+                continue;
 97+            },
 98+            else => |e| return e,
 99+        };
100+        component = it.next() orelse return;
101+    }
102+}
103+
104+test "Cfg.init uses default modes when env vars are not set" {
105+    const alloc = std.testing.allocator;
106+
107+    // Ensure they are not set
108+    _ = cross.c.unsetenv("ZMX_DIR_MODE");
109+    _ = cross.c.unsetenv("ZMX_LOG_MODE");
110+
111+    var cfg = try Cfg.init(alloc, std.testing.io);
112+    defer cfg.deinit(alloc);
113+
114+    try std.testing.expectEqual(@as(u32, 0o750), cfg.dir_mode);
115+    try std.testing.expectEqual(@as(u32, 0o640), cfg.log_mode);
116+}
117+
118+test "Cfg.init uses custom modes from env vars" {
119+    const alloc = std.testing.allocator;
120+
121+    // Set custom octal values
122+    _ = cross.c.setenv("ZMX_DIR_MODE", "770", 1);
123+    _ = cross.c.setenv("ZMX_LOG_MODE", "660", 1);
124+    defer {
125+        _ = cross.c.unsetenv("ZMX_DIR_MODE");
126+        _ = cross.c.unsetenv("ZMX_LOG_MODE");
127+    }
128+
129+    var cfg = try Cfg.init(alloc, std.testing.io);
130+    defer cfg.deinit(alloc);
131+
132+    try std.testing.expectEqual(@as(u32, 0o770), cfg.dir_mode);
133+    try std.testing.expectEqual(@as(u32, 0o660), cfg.log_mode);
134+}

  1@@ -0,0 +1,211 @@
  2+const std = @import("std");
  3+const lib_posix = @import("posix.zig");
  4+const Cfg = @import("cfg.zig");
  5+const socket = @import("socket.zig");
  6+const ipc = @import("ipc.zig");
  7+const assert = std.debug.assert;
  8+const log = @import("log.zig");
  9+const cross = @import("cross.zig");
 10+
 11+const Cmd = struct {
 12+    file: [*:0]const u8,
 13+    argv_ptr: [*:null]const ?[*:0]const u8,
 14+};
 15+
 16+pub fn createCmdZ(def_shell: []const u8, is_task_mode: bool, command: ?[]const []const u8) !Cmd {
 17+    const gpa = std.heap.c_allocator;
 18+
 19+    if (command) |cmd_args| {
 20+        const argv = try gpa.allocSentinel(?[*:0]const u8, cmd_args.len, null);
 21+        for (cmd_args, 0..) |arg, i| {
 22+            argv[i] = try gpa.dupeZ(u8, arg);
 23+        }
 24+        return .{
 25+            .file = argv[0].?,
 26+            .argv_ptr = argv.ptr,
 27+        };
 28+    }
 29+
 30+    const z = try std.fmt.allocPrintSentinel(gpa, "{s}", .{def_shell}, 0);
 31+    const shell: [:0]const u8 = if (is_task_mode) "bash" else z;
 32+
 33+    // Use "-shellname" as argv[0] to signal login shell (traditional method)
 34+    const login_shell = try std.fmt.allocPrintSentinel(gpa, "-{s}", .{std.fs.path.basename(shell)}, 0);
 35+    const argv = try gpa.allocSentinel(?[*:0]const u8, 1, null);
 36+    argv[0] = login_shell.ptr;
 37+
 38+    return .{
 39+        .file = shell,
 40+        .argv_ptr = argv,
 41+    };
 42+}
 43+
 44+/// Runs in the forked child. Either execs or returns an error (caller
 45+/// must exit on error -- returning would fall through to parent code).
 46+fn exec(sesh_name: []const u8, cmd: Cmd) !noreturn {
 47+    const gpa = std.heap.c_allocator;
 48+
 49+    // main() set SIGPIPE to SIG_IGN, which (unlike handlers) survives
 50+    // exec. Restore the default so the shell and its children behave
 51+    // normally (e.g. `yes | head` should exit 141 via SIGPIPE).
 52+    const dfl: lib_posix.Sigaction = .{
 53+        .handler = .{ .handler = lib_posix.SIG.DFL },
 54+        .mask = lib_posix.sigemptyset(),
 55+        .flags = 0,
 56+    };
 57+    lib_posix.sigaction(lib_posix.SIG.PIPE, &dfl, null);
 58+
 59+    const session_env = try std.fmt.allocPrintSentinel(
 60+        gpa,
 61+        "ZMX_SESSION={s}",
 62+        .{sesh_name},
 63+        0,
 64+    );
 65+    _ = cross.c.putenv(session_env.ptr);
 66+
 67+    const err = lib_posix.execvpeZ(cmd.file, cmd.argv_ptr, std.c.environ);
 68+    std.log.err("execvpe failed: cmd={s} err={s}", .{ cmd.file, @errorName(err) });
 69+    lib_posix.exit(1);
 70+}
 71+
 72+pub const PtyInfo = struct {
 73+    master_fd: c_int = undefined,
 74+    pid: c_int = undefined,
 75+};
 76+
 77+/// spawnPty runs forkpty() and executes the shell or shell command the user
 78+/// provides.
 79+///
 80+/// This is the second fork in the double-fork technique explained in the
 81+/// daemonize() comment.
 82+pub fn spawnPty(sesh_name: []const u8, cmd: Cmd) !PtyInfo {
 83+    const size = ipc.getTerminalSize(lib_posix.STDOUT_FILENO);
 84+    var ws: cross.c.struct_winsize = .{
 85+        .ws_row = size.rows,
 86+        .ws_col = size.cols,
 87+        .ws_xpixel = size.xpixel,
 88+        .ws_ypixel = size.ypixel,
 89+    };
 90+
 91+    var master_fd: c_int = undefined;
 92+    const pid = cross.forkpty(&master_fd, null, null, &ws);
 93+    if (pid < 0) {
 94+        return error.ForkPtyFailed;
 95+    }
 96+
 97+    if (pid == 0) { // child pid code path
 98+        // In the forked child, ANY error must exit rather than propagate:
 99+        // a returned error falls through to the parent code path below,
100+        // running a second daemon on the same socket (or worse, hitting
101+        // errdefers that delete the parent's socket file).
102+        exec(sesh_name, cmd) catch |err| {
103+            std.log.err("child setup failed: {s}", .{@errorName(err)});
104+            lib_posix.exit(1);
105+        };
106+        unreachable; // exec() either execs or exits, never returns ok
107+    }
108+    // master pid code path
109+    std.log.info("pty spawned session={s} pid={d}", .{ sesh_name, pid });
110+
111+    // make pty non-blocking
112+    const flags = try lib_posix.fcntl(master_fd, lib_posix.F.GETFL, 0);
113+    _ = try lib_posix.fcntl(master_fd, lib_posix.F.SETFL, flags | lib_posix.O_NONBLOCK);
114+
115+    return .{
116+        .master_fd = master_fd,
117+        .pid = pid,
118+    };
119+}
120+
121+/// daemonize is the first fork in a double-fork technique to create a
122+/// completely disconnected session (group of processes).
123+///
124+/// When launching a daemon, you normally set the child process of the fork to
125+/// be the session leader via setsid() which creates a new session that does
126+/// *not* have a controlling terminal. This is important because we don't want
127+/// a controlling terminal for our daemon or else our daemon could receive
128+/// signals to shutdown when the controlling terminal closes.
129+///
130+/// However, if the first fork's child process is also the daemon process, then
131+/// it's technically possible for the daemon to open a terminal device
132+/// (e.g. open("/dev/console", O_RDWR)) and then it would acquire a controlling
133+/// terminal! A controlling terminal would expose the daemon to
134+/// terminal-generated signals (e.g. SIGINT) or SIGHUP from terminal disconnect
135+/// which could kill the daemon.
136+///
137+/// By forking a second time, the grandchild process (the daemon) is not the
138+/// session leader. Per POSIX, only a process that is the session leader can
139+/// acquire a controlling terminal.
140+///
141+/// Apparently this is considered "being paranoid" but appears to be a standard
142+/// practice for daemons so we're doing it anyway.
143+///
144+/// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap11.html#tag_11_01_03
145+/// https://stackoverflow.com/a/16317668
146+pub fn daemonize(sesh_name: []const u8, cmd: Cmd, keep_fds_open: []i32) !PtyInfo {
147+    // creates the daemon
148+    const pid = try lib_posix.fork();
149+    assert(pid != -1);
150+
151+    if (pid > 0) { // parent (client)
152+        // cannot use a passed-in io or alloc after a fork so we create what we need
153+        // after the fork()
154+        var threaded: std.Io.Threaded = .init_single_threaded;
155+        defer threaded.deinit();
156+        const io = threaded.io();
157+        std.Io.sleep(io, std.Io.Duration.fromMilliseconds(10), .real) catch unreachable;
158+        return error.IsClientProc;
159+    }
160+
161+    assert(pid == 0); // child (daemon's parent in double-fork)
162+    // becomes the session leader and detaches process from its controlling terminal
163+    _ = try lib_posix.setsid();
164+
165+    // Redirect stdin/stdout/stderr to /dev/null. The daemon
166+    // communicates via its unix socket, not stdio. Without
167+    // this, any pipe on FDs 0-2 (e.g. from bats' `run`
168+    // keyword) stays open for the daemon's lifetime, causing
169+    // the caller to hang waiting for EOF.
170+    {
171+        const devnull = lib_posix.open(
172+            "/dev/null",
173+            .{ .ACCMODE = .RDWR },
174+            0,
175+        ) catch |err| {
176+            std.log.warn("failed to open /dev/null: {s}", .{@errorName(err)});
177+            return err;
178+        };
179+        inline for (.{ lib_posix.STDIN_FILENO, lib_posix.STDOUT_FILENO, lib_posix.STDERR_FILENO }) |fd| {
180+            _ = lib_posix.dup2(devnull, fd) catch |err| {
181+                std.log.warn("dup2 /dev/null -> {d}: {s}", .{ fd, @errorName(err) });
182+                return err;
183+            };
184+        }
185+        var found = false;
186+        for (keep_fds_open) |fd| {
187+            if (devnull == fd) found = true;
188+        }
189+        if (devnull > 2 and !found) lib_posix.close(devnull);
190+    }
191+
192+    // Close file descriptors inherited from the parent that the
193+    // daemon doesn't need. This prevents test harnesses (like
194+    // bats) from hanging: they wait for their internal FDs (3+)
195+    // to close before exiting.
196+    //
197+    // Skip any fds that the caller wants to keep open, e.g. server_sock_fd
198+    // (needed for IPC) and dir.fd (needed to delete the socket file on
199+    // shutdown).
200+    {
201+        var fd: i32 = 3;
202+        while (fd < 64) : (fd += 1) {
203+            var found = false;
204+            for (keep_fds_open) |kfd| {
205+                if (fd == kfd) found = true;
206+            }
207+            if (!found) _ = std.c.close(fd);
208+        }
209+    }
210+
211+    return spawnPty(sesh_name, cmd);
212+}

 1@@ -94,7 +94,7 @@ pub fn send(fd: i32, tag: Tag, data: []const u8) !void {
 2 }
 3 
 4 pub fn appendMessage(
 5-    alloc: std.mem.Allocator,
 6+    gpa: std.mem.Allocator,
 7     list: *std.ArrayList(u8),
 8     tag: Tag,
 9     data: []const u8,
10@@ -105,7 +105,7 @@ pub fn appendMessage(
11     };
12     // Guarantee capacity for header + payload in one check to avoid
13     // intermediate realloc between the two appends on the hot path.
14-    try list.ensureTotalCapacity(alloc, list.items.len + @sizeOf(Header) + data.len);
15+    try list.ensureTotalCapacity(gpa, list.items.len + @sizeOf(Header) + data.len);
16     list.appendSliceAssumeCapacity(std.mem.asBytes(&header));
17     if (data.len > 0) {
18         list.appendSliceAssumeCapacity(data);

 1@@ -1,19 +1,28 @@
 2 const std = @import("std");
 3 
 4+pub var log_system = LogSystem{};
 5+
 6+pub fn zmxLogFn(
 7+    comptime level: std.log.Level,
 8+    comptime scope: anytype,
 9+    comptime format: []const u8,
10+    args: anytype,
11+) void {
12+    log_system.log(level, scope, format, args) catch {};
13+}
14+
15 pub const LogSystem = struct {
16     file: ?std.Io.File = null,
17     mutex: std.Io.Mutex = .init,
18     current_size: u64 = 0,
19-    max_size: u64 = 5 * 1024 * 1024, // 5MB
20+    max_size: u64 = 2 * 1024 * 1024, // 2MB
21     path: []const u8 = "",
22-    alloc: std.mem.Allocator = undefined,
23     io: std.Io = undefined,
24     mode: std.Io.File.Permissions = std.Io.File.Permissions.fromMode(0o640),
25 
26-    pub fn init(self: *LogSystem, alloc: std.mem.Allocator, io: std.Io, path: []const u8, mode: std.Io.File.Permissions) !void {
27-        self.alloc = alloc;
28+    pub fn init(self: *LogSystem, io: std.Io, path: []const u8, mode: std.Io.File.Permissions) !void {
29         self.io = io;
30-        self.path = try alloc.dupe(u8, path);
31+        self.path = path;
32         self.mode = mode;
33 
34         const file = std.Io.Dir.openFileAbsolute(self.io, path, .{ .mode = .read_write }) catch |err| switch (err) {
35@@ -35,7 +44,6 @@ pub const LogSystem = struct {
36 
37     pub fn deinit(self: *LogSystem) void {
38         if (self.file) |f| std.Io.File.close(f, self.io);
39-        if (self.path.len > 0) self.alloc.free(self.path);
40     }
41 
42     pub fn log(
43@@ -54,12 +62,12 @@ pub const LogSystem = struct {
44         }
45 
46         if (self.current_size >= self.max_size) {
47-            self.rotate() catch |err| {
48-                std.debug.print("Log rotation failed: {s}\n", .{@errorName(err)});
49+            self.wipe() catch |err| {
50+                std.debug.print("Log wipe failed: {s}\n", .{@errorName(err)});
51             };
52         }
53 
54-        const now: i64 = @intCast(@divTrunc(std.Io.Timestamp.now(self.io, .real).nanoseconds, std.time.ns_per_ms));
55+        const now: std.Io.Timestamp = .now(self.io, .real);
56         const prefix = "[{d}] [{s}] ({s}): ";
57         const scope_name = @tagName(scope);
58         const level_name = level.asText();
59@@ -84,20 +92,12 @@ pub const LogSystem = struct {
60         }
61     }
62 
63-    fn rotate(self: *LogSystem) !void {
64+    fn wipe(self: *LogSystem) !void {
65         if (self.file) |f| {
66             std.Io.File.close(f, self.io);
67             self.file = null;
68         }
69 
70-        const old_path = try std.fmt.allocPrint(self.alloc, "{s}.old", .{self.path});
71-        defer self.alloc.free(old_path);
72-
73-        std.Io.Dir.renameAbsolute(self.path, old_path, self.io) catch |err| switch (err) {
74-            error.FileNotFound => {},
75-            else => return err,
76-        };
77-
78         self.file = try std.Io.Dir.createFileAbsolute(
79             self.io,
80             self.path,

   1@@ -0,0 +1,1212 @@
   2+const std = @import("std");
   3+const ghostty_vt = @import("ghostty-vt");
   4+const ipc = @import("ipc.zig");
   5+const log = @import("log.zig");
   6+const util = @import("util.zig");
   7+const cross = @import("cross.zig");
   8+const socket = @import("socket.zig");
   9+const label = @import("label.zig");
  10+const lib_posix = @import("posix.zig");
  11+const Cfg = @import("cfg.zig");
  12+const signal = @import("signal.zig");
  13+const assert = std.debug.assert;
  14+const daemonize = @import("daemonize.zig");
  15+const builtin = @import("builtin");
  16+
  17+/// clientLoop sends ipc commands to its corresponding daemon.  It uses poll() as its non-blocking
  18+/// mechanism. It will send stdin to the daemon and receive stdout from the daemon.
  19+pub fn clientLoop(client_sock_fd: i32) !ClientResult {
  20+    std.log.info("client loop fd={d}", .{client_sock_fd});
  21+    const gpa: std.mem.Allocator = blk: {
  22+        if (builtin.mode == .Debug) {
  23+            const GPA = std.heap.DebugAllocator(.{});
  24+            const Static = struct {
  25+                var gpa: GPA = .{};
  26+            };
  27+            break :blk Static.gpa.allocator();
  28+        }
  29+        break :blk std.heap.c_allocator;
  30+    };
  31+    defer lib_posix.close(client_sock_fd);
  32+
  33+    try signal.openSignalPipe();
  34+    signal.installWakeHandler(@intFromEnum(lib_posix.SIG.WINCH));
  35+
  36+    // Make socket non-blocking to avoid blocking on writes
  37+    var sock_flags = try lib_posix.fcntl(client_sock_fd, lib_posix.F.GETFL, 0);
  38+    sock_flags |= lib_posix.O_NONBLOCK;
  39+    _ = try lib_posix.fcntl(client_sock_fd, lib_posix.F.SETFL, sock_flags);
  40+
  41+    // Buffer for outgoing socket writes
  42+    var sock_write_buf = try std.ArrayList(u8).initCapacity(gpa, 4096);
  43+    defer sock_write_buf.deinit(gpa);
  44+
  45+    // Send init message with terminal size (buffered)
  46+    const size = ipc.getTerminalSize(lib_posix.STDOUT_FILENO);
  47+    try ipc.appendMessage(gpa, &sock_write_buf, .Init, std.mem.asBytes(&size));
  48+
  49+    var poll_fds = try std.ArrayList(lib_posix.pollfd).initCapacity(gpa, 4);
  50+    defer poll_fds.deinit(gpa);
  51+
  52+    var read_buf = try ipc.SocketBuffer.init(gpa);
  53+    defer read_buf.deinit();
  54+
  55+    var stdout_buf = try std.ArrayList(u8).initCapacity(gpa, 4096);
  56+    defer stdout_buf.deinit(gpa);
  57+
  58+    const stdin_fd = lib_posix.STDIN_FILENO;
  59+
  60+    // Make stdin non-blocking. O_NONBLOCK is set on the open file description,
  61+    // which is shared with the parent shell; restore on exit to avoid
  62+    // corrupting the parent's stdin.
  63+    const stdin_orig_flags = try lib_posix.fcntl(stdin_fd, lib_posix.F.GETFL, 0);
  64+    _ = try lib_posix.fcntl(stdin_fd, lib_posix.F.SETFL, stdin_orig_flags | lib_posix.O_NONBLOCK);
  65+    defer _ = lib_posix.fcntl(stdin_fd, lib_posix.F.SETFL, stdin_orig_flags) catch {};
  66+
  67+    while (true) {
  68+        poll_fds.clearRetainingCapacity();
  69+
  70+        try poll_fds.append(gpa, .{
  71+            .fd = stdin_fd,
  72+            .events = lib_posix.POLL.IN,
  73+            .revents = 0,
  74+        });
  75+
  76+        // Poll socket for read, and also for write if we have pending data
  77+        var sock_events: i16 = lib_posix.POLL.IN;
  78+        if (sock_write_buf.items.len > 0) {
  79+            sock_events |= lib_posix.POLL.OUT;
  80+        }
  81+        try poll_fds.append(gpa, .{
  82+            .fd = client_sock_fd,
  83+            .events = sock_events,
  84+            .revents = 0,
  85+        });
  86+
  87+        try poll_fds.append(gpa, .{ .fd = signal.sig_pipe[0], .events = lib_posix.POLL.IN, .revents = 0 });
  88+
  89+        if (stdout_buf.items.len > 0) {
  90+            try poll_fds.append(gpa, .{
  91+                .fd = lib_posix.STDOUT_FILENO,
  92+                .events = lib_posix.POLL.OUT,
  93+                .revents = 0,
  94+            });
  95+        }
  96+
  97+        _ = try lib_posix.poll(poll_fds.items, -1);
  98+
  99+        if (poll_fds.items[2].revents & lib_posix.POLL.IN != 0) {
 100+            signal.drainSignalPipe();
 101+            const next_size = ipc.getTerminalSize(lib_posix.STDOUT_FILENO);
 102+            try ipc.appendMessage(gpa, &sock_write_buf, .Resize, std.mem.asBytes(&next_size));
 103+        }
 104+
 105+        // Handle stdin -> socket (Input)
 106+        const inp_flags = (lib_posix.POLL.IN | lib_posix.POLL.HUP | lib_posix.POLL.ERR | lib_posix.POLL.NVAL);
 107+        if (poll_fds.items[0].revents & inp_flags != 0) {
 108+            var buf: [4096]u8 = undefined;
 109+            const n_opt: ?usize = lib_posix.read(stdin_fd, &buf) catch |err| blk: {
 110+                if (err == error.WouldBlock) break :blk null;
 111+                return err;
 112+            };
 113+
 114+            if (n_opt) |n| {
 115+                if (n > 0) {
 116+                    // Check for detach sequences (ctrl+\ as first byte or Kitty escape sequence)
 117+                    if (util.isCtrlBackslash(buf[0..n])) {
 118+                        std.log.info("detach key detected", .{});
 119+                        try ipc.appendMessage(gpa, &sock_write_buf, .Detach, "");
 120+                    } else {
 121+                        try ipc.appendMessage(gpa, &sock_write_buf, .Input, buf[0..n]);
 122+                    }
 123+                } else {
 124+                    std.log.info("eof stdin", .{});
 125+                    // EOF on stdin
 126+                    return ClientResult{ .kind = .detach, .session_name = null };
 127+                }
 128+            }
 129+        }
 130+
 131+        // Handle socket read (incoming Output messages from daemon)
 132+        if (poll_fds.items[1].revents & lib_posix.POLL.IN != 0) {
 133+            const n = read_buf.read(client_sock_fd) catch |err| {
 134+                if (err == error.WouldBlock) continue;
 135+                if (err == error.ConnectionResetByPeer or err == error.BrokenPipe) {
 136+                    return ClientResult{ .kind = .detach, .session_name = null };
 137+                }
 138+                std.log.err("daemon read err={s}", .{@errorName(err)});
 139+                return err;
 140+            };
 141+            if (n == 0) {
 142+                std.log.info("server closed connection", .{});
 143+                // Server closed connection
 144+                return ClientResult{ .kind = .detach, .session_name = null };
 145+            }
 146+
 147+            while (read_buf.next()) |msg| {
 148+                switch (msg.header.tag) {
 149+                    .Output => {
 150+                        if (msg.payload.len > 0) {
 151+                            try stdout_buf.appendSlice(gpa, msg.payload);
 152+                        }
 153+                    },
 154+                    .Resize => {
 155+                        // daemon is asking for the client's window size usually in response
 156+                        // to this client being set as leader.
 157+                        const next_size = ipc.getTerminalSize(lib_posix.STDOUT_FILENO);
 158+                        try ipc.appendMessage(
 159+                            gpa,
 160+                            &sock_write_buf,
 161+                            .Resize,
 162+                            std.mem.asBytes(&next_size),
 163+                        );
 164+                    },
 165+                    .Switch => {
 166+                        std.log.info("switch session", .{});
 167+                        return ClientResult{ .kind = .switch_session, .session_name = try gpa.dupe(u8, msg.payload) };
 168+                    },
 169+                    else => {},
 170+                }
 171+            }
 172+        }
 173+
 174+        // Handle socket write (flush buffered messages to daemon)
 175+        if (poll_fds.items[1].revents & lib_posix.POLL.OUT != 0) {
 176+            if (sock_write_buf.items.len > 0) {
 177+                const n = lib_posix.write(client_sock_fd, sock_write_buf.items) catch |err| blk: {
 178+                    if (err == error.WouldBlock) break :blk 0;
 179+                    if (err == error.ConnectionResetByPeer or err == error.BrokenPipe) {
 180+                        std.log.info("connection reset or broken pipe", .{});
 181+                        return ClientResult{ .kind = .detach, .session_name = null };
 182+                    }
 183+                    return err;
 184+                };
 185+                if (n > 0) {
 186+                    try sock_write_buf.replaceRange(gpa, 0, n, &[_]u8{});
 187+                }
 188+            }
 189+        }
 190+
 191+        if (stdout_buf.items.len > 0) {
 192+            const n = lib_posix.write(lib_posix.STDOUT_FILENO, stdout_buf.items) catch |err| blk: {
 193+                if (err == error.WouldBlock) break :blk 0;
 194+                return err;
 195+            };
 196+            if (n > 0) {
 197+                try stdout_buf.replaceRange(gpa, 0, n, &[_]u8{});
 198+            }
 199+        }
 200+
 201+        if (poll_fds.items[1].revents & (lib_posix.POLL.HUP | lib_posix.POLL.ERR | lib_posix.POLL.NVAL) != 0) {
 202+            std.log.info("poll hup|err|nval", .{});
 203+            return ClientResult{ .kind = .detach, .session_name = null };
 204+        }
 205+    }
 206+}
 207+
 208+/// dameonLoop is what the daemon runs to send and receive ipc commands from its corresponding
 209+/// clients.  It uses poll() as its non-blocking mechanism.
 210+fn daemonLoop(daemon: *Daemon, gpa: std.mem.Allocator, io: std.Io, server_sock_fd: lib_posix.socket_t, pty_fd: i32) !void {
 211+    std.log.info("daemon started session={s} pty_fd={d}", .{ daemon.session_name, pty_fd });
 212+
 213+    try signal.openSignalPipe();
 214+    signal.installWakeHandler(@intFromEnum(lib_posix.SIG.TERM));
 215+    var poll_fds = try std.ArrayList(lib_posix.pollfd).initCapacity(gpa, 8);
 216+    defer poll_fds.deinit(gpa);
 217+
 218+    const init_size = ipc.getTerminalSize(pty_fd);
 219+    var term = try ghostty_vt.Terminal.init(io, gpa, .{
 220+        .cols = init_size.cols,
 221+        .rows = init_size.rows,
 222+        .max_scrollback = daemon.cfg.max_scrollback,
 223+    });
 224+    defer term.deinit(gpa);
 225+    var vt_stream = term.vtStream();
 226+    defer vt_stream.deinit();
 227+
 228+    // Carries the tail of the previous PTY read so the task-exit marker
 229+    // search below can see across a read() boundary. Sized to comfortably
 230+    // hold "ZMX_TASK_COMPLETED:" (19 bytes) plus a u8 exit code and CRLF.
 231+    var marker_carry: [32]u8 = undefined;
 232+    var marker_carry_len: usize = 0;
 233+
 234+    daemon_loop: while (daemon.running) {
 235+        poll_fds.clearRetainingCapacity();
 236+
 237+        try poll_fds.append(gpa, .{
 238+            .fd = server_sock_fd,
 239+            .events = lib_posix.POLL.IN,
 240+            .revents = 0,
 241+        });
 242+
 243+        var pty_events: i16 = lib_posix.POLL.IN;
 244+        if (daemon.pty_write_buf.items.len > 0) {
 245+            pty_events |= lib_posix.POLL.OUT;
 246+        }
 247+        try poll_fds.append(gpa, .{
 248+            .fd = pty_fd,
 249+            .events = pty_events,
 250+            .revents = 0,
 251+        });
 252+
 253+        try poll_fds.append(gpa, .{ .fd = signal.sig_pipe[0], .events = lib_posix.POLL.IN, .revents = 0 });
 254+
 255+        for (daemon.clients.items) |client| {
 256+            var events: i16 = lib_posix.POLL.IN;
 257+            if (client.has_pending_output) {
 258+                events |= lib_posix.POLL.OUT;
 259+            }
 260+            try poll_fds.append(gpa, .{
 261+                .fd = client.socket_fd,
 262+                .events = events,
 263+                .revents = 0,
 264+            });
 265+        }
 266+
 267+        _ = try lib_posix.poll(poll_fds.items, -1);
 268+
 269+        if (poll_fds.items[2].revents & lib_posix.POLL.IN != 0) {
 270+            signal.drainSignalPipe();
 271+            std.log.info(
 272+                "SIGTERM received, shutting down gracefully session={s}",
 273+                .{daemon.session_name},
 274+            );
 275+            break :daemon_loop;
 276+        }
 277+
 278+        if (poll_fds.items[0].revents & (lib_posix.POLL.ERR | lib_posix.POLL.HUP | lib_posix.POLL.NVAL) != 0) {
 279+            std.log.err("server socket error revents={d}", .{poll_fds.items[0].revents});
 280+            break :daemon_loop;
 281+        } else if (poll_fds.items[0].revents & lib_posix.POLL.IN != 0) {
 282+            const client_fd = try lib_posix.accept(
 283+                server_sock_fd,
 284+                null,
 285+                null,
 286+                lib_posix.SOCK.NONBLOCK | lib_posix.SOCK.CLOEXEC,
 287+            );
 288+            const client = try gpa.create(Client);
 289+            client.* = Client{
 290+                .alloc = gpa,
 291+                .socket_fd = client_fd,
 292+                .read_buf = try ipc.SocketBuffer.init(gpa),
 293+                .write_buf = undefined,
 294+            };
 295+            // 64KB initial capacity lets ~15 broadcast cycles (N_TTY_BUF_SIZE reads
 296+            // * header) accumulate before the first ArrayList growth. The write
 297+            // buffer is userspace-only: it drains via POLLOUT to the client socket,
 298+            // which has no corresponding kernel-imposed per-write limit.
 299+            client.write_buf = try std.ArrayList(u8).initCapacity(client.alloc, 65536);
 300+            try daemon.clients.append(gpa, client);
 301+            std.log.info(
 302+                "client connected fd={d} total={d}",
 303+                .{ client_fd, daemon.clients.items.len },
 304+            );
 305+        }
 306+
 307+        const inp_flags = lib_posix.POLL.IN | lib_posix.POLL.HUP | lib_posix.POLL.ERR | lib_posix.POLL.NVAL;
 308+        if (poll_fds.items[1].revents & inp_flags != 0) {
 309+            // Read from PTY. Buffer is sized to N_TTY_BUF_SIZE (4096): the hard
 310+            // kernel limit for the N_TTY line discipline. A larger buffer doesn't
 311+            // help: each read() from a PTY master returns at most 4096 bytes
 312+            // regardless of the userspace buffer size.
 313+            var buf: [4096]u8 = undefined;
 314+            const n_opt: ?usize = lib_posix.read(pty_fd, &buf) catch |err| blk: {
 315+                if (err == error.WouldBlock) break :blk null;
 316+                break :blk 0;
 317+            };
 318+
 319+            if (n_opt) |n| {
 320+                if (n == 0) {
 321+                    // EOF: Shell exited
 322+                    std.log.info("shell exited pty_fd={d}", .{pty_fd});
 323+                    // Let the rest of this poll iteration complete so client
 324+                    // write buffers are flushed via the normal POLLOUT path.
 325+                    // On the next iteration, daemon.running will be false.
 326+                    daemon.running = false;
 327+                } else {
 328+                    // Feed PTY output to terminal emulator for state tracking
 329+                    vt_stream.nextSlice(buf[0..n]);
 330+                    daemon.has_pty_output = true;
 331+
 332+                    // When no real terminal client has attached yet, respond to
 333+                    // terminal queries (e.g. DA1/DA2) on behalf of the terminal.
 334+                    // This prevents fish from waiting 10s for unanswered queries.
 335+                    // `has_terminal_client` is only set when a client sends .Init
 336+                    // (a real zmx attach), not when a `zmx run` tail-only client
 337+                    // connects.
 338+                    if (!daemon.has_terminal_client and
 339+                        daemon.pty_write_buf.items.len < Daemon.PTY_WRITE_BUF_MAX)
 340+                    {
 341+                        util.respondToDeviceAttributes(gpa, &daemon.pty_write_buf, buf[0..n]);
 342+                    }
 343+
 344+                    // In run mode, scan output for exit code marker. The marker
 345+                    // can straddle two PTY reads (more likely under a throttled
 346+                    // scheduler, e.g. containers), so prepend the tail carried
 347+                    // over from the previous read before searching.
 348+                    if (daemon.is_task_mode and daemon.task_exit_code == null) {
 349+                        var scan_buf: [marker_carry.len + buf.len]u8 = undefined;
 350+                        @memcpy(scan_buf[0..marker_carry_len], marker_carry[0..marker_carry_len]);
 351+                        @memcpy(scan_buf[marker_carry_len..][0..n], buf[0..n]);
 352+                        const scan_len = marker_carry_len + n;
 353+
 354+                        if (util.findTaskExitMarker(scan_buf[0..scan_len])) |exit_code| {
 355+                            daemon.task_exit_code = exit_code;
 356+                            daemon.task_ended_at = @intCast(std.Io.Timestamp.now(io, .real).toSeconds());
 357+
 358+                            std.log.info("task completed exit_code={d}", .{exit_code});
 359+
 360+                            // Notify connected clients
 361+                            for (daemon.clients.items) |c| {
 362+                                ipc.appendMessage(gpa, &c.write_buf, .TaskComplete, &[_]u8{exit_code}) catch {};
 363+                                c.has_pending_output = true;
 364+                            }
 365+                        }
 366+
 367+                        marker_carry_len = @min(marker_carry.len, scan_len);
 368+                        @memcpy(
 369+                            marker_carry[0..marker_carry_len],
 370+                            scan_buf[scan_len - marker_carry_len .. scan_len],
 371+                        );
 372+                    }
 373+
 374+                    // Broadcast data to all clients.
 375+                    // Rewrite OSC 133;A to include redraw=0 so the outer terminal
 376+                    // does not clear prompt lines on resize (issue #111).
 377+                    const broadcast_data = util.rewritePromptRedraw(gpa, buf[0..n]) orelse buf[0..n];
 378+                    defer if (broadcast_data.ptr != buf[0..n].ptr) gpa.free(broadcast_data);
 379+                    for (daemon.clients.items) |client| {
 380+                        ipc.appendMessage(gpa, &client.write_buf, .Output, broadcast_data) catch |err| {
 381+                            std.log.warn(
 382+                                "failed to buffer output for client err={s}",
 383+                                .{@errorName(err)},
 384+                            );
 385+                            continue;
 386+                        };
 387+                        client.has_pending_output = true;
 388+                    }
 389+                }
 390+            }
 391+        }
 392+
 393+        if (poll_fds.items[1].revents & lib_posix.POLL.OUT != 0) {
 394+            while (daemon.pty_write_buf.items.len > 0) {
 395+                const n = lib_posix.write(pty_fd, daemon.pty_write_buf.items) catch |err| {
 396+                    if (err != error.WouldBlock) {
 397+                        std.log.warn("pty write failed: {s}", .{@errorName(err)});
 398+                        daemon.pty_write_buf.clearRetainingCapacity();
 399+                    }
 400+                    break;
 401+                };
 402+                if (n == 0) break;
 403+                daemon.pty_write_buf.replaceRange(gpa, 0, n, &[_]u8{}) catch unreachable;
 404+            }
 405+        }
 406+
 407+        var i: usize = daemon.clients.items.len;
 408+        // Only iterate over clients that were present when poll_fds was constructed
 409+        // poll_fds contains [server, pty, sig_pipe, client0, client1, ...]
 410+        // So number of clients in poll_fds is poll_fds.items.len - 3
 411+        const num_polled_clients = poll_fds.items.len - 3;
 412+        if (i > num_polled_clients) {
 413+            // If we have more clients than polled (i.e. we just accepted one), start from the
 414+            // polled ones
 415+            i = num_polled_clients;
 416+        }
 417+
 418+        clients_loop: while (i > 0) {
 419+            i -= 1;
 420+            const client = daemon.clients.items[i];
 421+            const revents = poll_fds.items[i + 3].revents;
 422+
 423+            if (revents & lib_posix.POLL.IN != 0) {
 424+                const n = client.read_buf.read(client.socket_fd) catch |err| {
 425+                    if (err == error.WouldBlock) continue;
 426+                    std.log.debug(
 427+                        "client read err={s} fd={d}",
 428+                        .{ @errorName(err), client.socket_fd },
 429+                    );
 430+                    const last = daemon.closeClient(gpa, client, i, false);
 431+                    if (last) break :daemon_loop;
 432+                    continue;
 433+                };
 434+
 435+                if (n == 0) {
 436+                    // Client closed connection
 437+                    const last = daemon.closeClient(gpa, client, i, false);
 438+                    if (last) break :daemon_loop;
 439+                    continue;
 440+                }
 441+
 442+                while (client.read_buf.next()) |msg| {
 443+                    switch (msg.header.tag) {
 444+                        .Input => try daemon.handleInput(gpa, client, msg.payload),
 445+                        .Send => daemon.handleSend(gpa, msg.payload),
 446+                        .Output => try daemon.handleOutput(gpa, msg.payload, &vt_stream),
 447+                        .Init => try daemon.handleInit(gpa, client, pty_fd, &term, msg.payload),
 448+                        .Switch => try daemon.handleSwitch(gpa, msg.payload),
 449+                        .Resize => try daemon.handleResize(gpa, client, pty_fd, &term, msg.payload),
 450+                        .Detach => {
 451+                            daemon.handleDetach(gpa, client, i);
 452+                            break :clients_loop;
 453+                        },
 454+                        .DetachAll => {
 455+                            daemon.handleDetachAll(gpa);
 456+                            break :clients_loop;
 457+                        },
 458+                        .Kill => {
 459+                            break :daemon_loop;
 460+                        },
 461+                        .Info => try daemon.handleInfo(gpa, client),
 462+                        .LabelGet => try daemon.handleLabelGet(gpa, client),
 463+                        .LabelSet => try daemon.handleLabelSet(gpa, client, msg.payload),
 464+                        .LabelClear => try daemon.handleLabelClear(gpa, client),
 465+                        .History => try daemon.handleHistory(gpa, client, &term, msg.payload),
 466+                        .Run => try daemon.handleRun(gpa, client, msg.payload),
 467+                        .Ack, .TaskComplete, .LabelData => {},
 468+                        .Write => try daemon.handleWrite(gpa, client, msg.payload),
 469+                        _ => std.log.warn(
 470+                            "ignoring unknown IPC tag={d}",
 471+                            .{@intFromEnum(msg.header.tag)},
 472+                        ),
 473+                    }
 474+                }
 475+            }
 476+
 477+            if (revents & lib_posix.POLL.OUT != 0) {
 478+                // Flush pending output buffers
 479+                const n = lib_posix.write(client.socket_fd, client.write_buf.items) catch |err| blk: {
 480+                    if (err == error.WouldBlock) break :blk 0;
 481+                    // Error on write, close client
 482+                    const last = daemon.closeClient(gpa, client, i, false);
 483+                    if (last) break :daemon_loop;
 484+                    continue;
 485+                };
 486+
 487+                if (n > 0) {
 488+                    client.write_buf.replaceRange(gpa, 0, n, &[_]u8{}) catch unreachable;
 489+                }
 490+
 491+                if (client.write_buf.items.len == 0) {
 492+                    client.has_pending_output = false;
 493+                }
 494+            }
 495+
 496+            if (revents & (lib_posix.POLL.HUP | lib_posix.POLL.ERR | lib_posix.POLL.NVAL) != 0) {
 497+                const last = daemon.closeClient(gpa, client, i, false);
 498+                if (last) break :daemon_loop;
 499+            }
 500+        }
 501+    }
 502+}
 503+
 504+const ClientResult = struct {
 505+    kind: enum {
 506+        detach,
 507+        switch_session,
 508+    },
 509+    session_name: ?[]const u8,
 510+};
 511+
 512+/// Client represents each terminal that has connected to a session.
 513+///
 514+/// Multiple Clients can connect to a single session.
 515+pub const Client = struct {
 516+    alloc: std.mem.Allocator,
 517+    socket_fd: i32,
 518+    has_pending_output: bool = false,
 519+    read_buf: ipc.SocketBuffer,
 520+    write_buf: std.ArrayList(u8),
 521+
 522+    pub fn deinit(self: *Client) void {
 523+        lib_posix.close(self.socket_fd);
 524+        self.read_buf.deinit();
 525+        self.write_buf.deinit(self.alloc);
 526+    }
 527+};
 528+
 529+/// Daemon is responsible for managing a zmx session.
 530+///
 531+/// It holds all the state for a running session.  Instead of a single daemon for all sessions, we
 532+/// create a daemon for every session.  This has some benefits. The ipc communication between
 533+/// session clients and the daemon doesn't need to be tagged with the session name.  If a daemon
 534+/// crashes for one session won't crash all the other sessions.
 535+///
 536+/// Conceptually it's also much simpler to reason about.
 537+pub const Daemon = struct {
 538+    cfg: *Cfg,
 539+    session_name: []const u8,
 540+    socket_path: []const u8,
 541+    // === opt ===
 542+    pty_write_buf: std.ArrayList(u8) = .empty,
 543+    clients: std.ArrayList(*Client) = .empty,
 544+    labels: std.StringHashMapUnmanaged([]u8) = .empty,
 545+    // This control which client is the leader.  The leader controls terminal state and
 546+    // cols/rows of session.
 547+    leader_client_fd: ?i32 = null,
 548+    running: bool = true,
 549+    pid: i32 = undefined,
 550+    command: ?[]const []const u8 = null,
 551+    cwd: []const u8 = "",
 552+    has_pty_output: bool = false,
 553+    has_had_client: bool = false,
 554+    has_terminal_client: bool = false, // true only after a real attach (.Init received)
 555+    created_at: u64, // unix timestamp (ns)
 556+    is_task_mode: bool = false, // flag for when session is run as a task
 557+    task_exit_code: ?u8 = null, // null = running or n/a, set when task completes
 558+    task_ended_at: ?u64 = null, // timestamp when task exited
 559+    pty_fd: i32 = -1, // set by daemonLoop so handleRun can probe the foreground process
 560+    shell: []const u8 = "/bin/sh",
 561+
 562+    /// Create a Daemon. Caller is responsible for freeing all variables passed
 563+    /// into the init fn.
 564+    pub fn init(io: std.Io, cfg: *Cfg, sesh_name: []const u8, socket_path: []const u8) Daemon {
 565+        return .{
 566+            .cfg = cfg,
 567+            .session_name = sesh_name,
 568+            .socket_path = socket_path,
 569+            .created_at = @intCast(std.Io.Timestamp.now(io, .real).toSeconds()),
 570+        };
 571+    }
 572+
 573+    pub fn deinit(self: *Daemon, gpa: std.mem.Allocator) void {
 574+        self.clients.deinit(gpa);
 575+        var it = self.labels.iterator();
 576+        while (it.next()) |entry| {
 577+            gpa.free(entry.key_ptr.*);
 578+            gpa.free(entry.value_ptr.*);
 579+        }
 580+        self.labels.deinit(gpa);
 581+        self.pty_write_buf.deinit(gpa);
 582+        gpa.free(self.socket_path);
 583+    }
 584+
 585+    pub fn shutdown(self: *Daemon, gpa: std.mem.Allocator) void {
 586+        std.log.info("shutting down daemon session={s}", .{self.session_name});
 587+        self.running = false;
 588+
 589+        for (self.clients.items) |client| {
 590+            client.deinit();
 591+            gpa.destroy(client);
 592+        }
 593+        self.clients.clearRetainingCapacity();
 594+    }
 595+
 596+    pub fn closeClient(self: *Daemon, gpa: std.mem.Allocator, client: *Client, i: usize, shutdown_on_last: bool) bool {
 597+        const fd = client.socket_fd;
 598+        // leader is disconnected, remove ref and let another client claim leader on input
 599+        if (self.leader_client_fd == client.socket_fd) {
 600+            std.log.info(
 601+                "unsetting leader session={s} fd={d}",
 602+                .{ self.session_name, client.socket_fd },
 603+            );
 604+            self.leader_client_fd = null;
 605+        }
 606+        client.deinit();
 607+        gpa.destroy(client);
 608+        _ = self.clients.orderedRemove(i);
 609+        std.log.info("client disconnected fd={d} remaining={d}", .{ fd, self.clients.items.len });
 610+        if (shutdown_on_last and self.clients.items.len == 0) {
 611+            self.shutdown(gpa);
 612+            return true;
 613+        }
 614+        return false;
 615+    }
 616+
 617+    /// ensureSession will either create or re-use the daemon used for a session.
 618+    /// It will spin up a unix socket, double-fork the process (so it survives
 619+    /// the terminal dying), and automatically attach the client to the ipc unix
 620+    /// socket.
 621+    ///
 622+    /// The return bool value indicates if the current process is the daemon
 623+    /// or the client since they have different behaviors post-fork.
 624+    ///
 625+    /// E.g. If it's the client process then we need to connect to the unix socket
 626+    /// and run the clientLoop.  If it's the daemon then we need to bail since
 627+    /// the daemonLoop is created inside this fn and when it returns that means
 628+    /// the daemon stopped and needs to exit.
 629+    pub fn ensureSession(self: *Daemon, io: std.Io) !bool {
 630+        const sesh_name = self.session_name;
 631+        std.log.info("ensure session session={s}", .{sesh_name});
 632+        var dir = try std.Io.Dir.openDirAbsolute(io, self.cfg.socket_dir, .{});
 633+        defer dir.close(io);
 634+
 635+        const exists = try socket.sessionExists(io, dir, sesh_name);
 636+        // if daemon is gone then we flip this to true
 637+        var should_create = !exists;
 638+
 639+        if (exists) {
 640+            if (ipc.connectSession(self.socket_path)) |fd| {
 641+                lib_posix.close(fd);
 642+                if (self.command != null) {
 643+                    std.log.warn(
 644+                        "session already exists, ignoring command session={s}",
 645+                        .{sesh_name},
 646+                    );
 647+                }
 648+            } else |err| switch (err) {
 649+                // Daemon is definitively gone: safe to replace.
 650+                error.ConnectionRefused => {
 651+                    socket.cleanupStaleSocket(io, dir, sesh_name);
 652+                    should_create = true;
 653+                },
 654+                // Connect failed for an unusual reason. The check is only to
 655+                // decide create-vs-attach; the socket file exists, so proceed
 656+                // to attach rather than fail or orphan.
 657+                else => {
 658+                    std.log.warn(
 659+                        "connect failed ({s}), proceeding to attach session={s}",
 660+                        .{ @errorName(err), sesh_name },
 661+                    );
 662+                },
 663+            }
 664+        }
 665+
 666+        if (!should_create) {
 667+            return false;
 668+        }
 669+
 670+        return self.run(io, dir, sesh_name);
 671+    }
 672+
 673+    fn run(self: *Daemon, io: std.Io, dir: std.Io.Dir, sesh_name: []const u8) !bool {
 674+        std.log.info("creating session={s}", .{sesh_name});
 675+        const server_sock_fd: lib_posix.socket_t = try socket.createSocket(self.socket_path);
 676+        const log_fd = log.log_system.file.?.handle;
 677+
 678+        var keep_fds_open = [_]i32{ server_sock_fd, dir.handle, log_fd };
 679+        const cmd = try daemonize.createCmdZ(self.shell, self.is_task_mode, self.command);
 680+        const pty_info = daemonize.daemonize(
 681+            sesh_name,
 682+            cmd,
 683+            &keep_fds_open,
 684+        ) catch |err| {
 685+            switch (err) {
 686+                error.IsClientProc => {
 687+                    // send a msg to the client that the session was created.
 688+                    var w_buf: [2048]u8 = undefined;
 689+                    var w = std.Io.File.stdout().writer(io, &w_buf);
 690+                    try w.interface.print("session \"{s}\" created\n", .{sesh_name});
 691+                    try w.interface.flush();
 692+                    lib_posix.close(server_sock_fd);
 693+                    return false;
 694+                },
 695+                else => {
 696+                    lib_posix.close(server_sock_fd);
 697+                    dir.deleteFile(io, self.session_name) catch {};
 698+                    return err;
 699+                },
 700+            }
 701+        };
 702+        // =======
 703+        // WARNING: cannot use upstream allocator or io after this point since
 704+        // we forked the process and there's a risk of a mutex (e.g. thread-safe
 705+        // allocator) being locked by a thread prior to fork which can cause a
 706+        // deadlock.
 707+        // =======
 708+
 709+        self.pid = pty_info.pid;
 710+
 711+        var threaded: std.Io.Threaded = .init_single_threaded;
 712+        defer threaded.deinit();
 713+        const new_io = threaded.io();
 714+
 715+        { // re-initialize logs with the session name as the filename
 716+            log.log_system.deinit();
 717+            var log_buf: [4096]u8 = undefined;
 718+            const session_log_name = try std.fmt.bufPrint(
 719+                &log_buf,
 720+                "{s}.log",
 721+                .{sesh_name},
 722+            );
 723+            var fba_buf: [4096]u8 = undefined;
 724+            var fba = std.heap.FixedBufferAllocator.init(&fba_buf);
 725+            const session_log_path = try std.fs.path.join(
 726+                fba.allocator(),
 727+                &.{ self.cfg.log_dir, session_log_name },
 728+            );
 729+            const log_mode = std.Io.File.Permissions.fromMode(self.cfg.log_mode);
 730+            log.log_system.init(new_io, session_log_path, log_mode) catch {};
 731+        }
 732+
 733+        const gpa: std.mem.Allocator = blk: {
 734+            if (builtin.mode == .Debug) {
 735+                const GPA = std.heap.DebugAllocator(.{});
 736+                const Static = struct {
 737+                    var gpa: GPA = .{};
 738+                };
 739+                break :blk Static.gpa.allocator();
 740+            }
 741+            break :blk std.heap.c_allocator;
 742+        };
 743+
 744+        defer {
 745+            // Close and unlink the listen socket BEFORE handleKill()'s
 746+            // 500ms SIGHUP->SIGKILL grace sleep. Otherwise a `zmx run`
 747+            // for the same name issued in that window will hang waiting
 748+            // for a connect.
 749+            lib_posix.close(server_sock_fd);
 750+            std.log.info("deleting socket file session={s}", .{sesh_name});
 751+            dir.deleteFile(new_io, sesh_name) catch |err| {
 752+                std.log.warn("failed to delete socket file err={s}", .{@errorName(err)});
 753+            };
 754+            self.handleKill(gpa, new_io);
 755+            self.deinit(gpa);
 756+            lib_posix.close(pty_info.master_fd);
 757+            _ = lib_posix.waitpid(self.pid, 0);
 758+        }
 759+
 760+        try daemonLoop(self, gpa, new_io, server_sock_fd, pty_info.master_fd);
 761+        std.log.info("daemon loop shutdown", .{});
 762+        return true;
 763+    }
 764+
 765+    fn setLeader(self: *Daemon, gpa: std.mem.Allocator, client: *Client) !void {
 766+        std.log.info("setting new leader client_fd={d}", .{client.socket_fd});
 767+        self.leader_client_fd = client.socket_fd;
 768+        // Send a resize message to the client so it can send us back their window size
 769+        // so we can resize the pty and ghostty state.
 770+        try ipc.appendMessage(gpa, &client.write_buf, .Resize, "");
 771+        client.has_pending_output = true;
 772+    }
 773+
 774+    const PTY_WRITE_BUF_MAX = 256 * 1024;
 775+
 776+    /// Queue bytes for the PTY's stdin. Flushed by daemonLoop on POLLOUT.
 777+    /// Drops the payload if the buffer is over cap -- same failure mode as
 778+    /// the old direct-write ptyWrite (drop on EAGAIN), just at a 64x higher
 779+    /// threshold. Capping avoids OOM when the shell stops reading; dropping
 780+    /// new (not old) bytes avoids tearing a partially-accepted sequence.
 781+    fn queuePtyInput(self: *Daemon, gpa: std.mem.Allocator, data: []const u8) void {
 782+        if (data.len == 0) return;
 783+        if (self.pty_write_buf.items.len + data.len > PTY_WRITE_BUF_MAX) {
 784+            std.log.warn(
 785+                "pty input dropped {d} bytes (buffer full, shell not reading)",
 786+                .{data.len},
 787+            );
 788+            return;
 789+        }
 790+        std.log.debug("buffering pty input data={x}", .{data});
 791+        self.pty_write_buf.appendSlice(gpa, data) catch |err| {
 792+            std.log.warn(
 793+                "pty input dropped {d} bytes: {s}",
 794+                .{ data.len, @errorName(err) },
 795+            );
 796+        };
 797+    }
 798+
 799+    pub fn handleInput(self: *Daemon, gpa: std.mem.Allocator, client: *Client, payload: []const u8) !void {
 800+        std.log.debug("buffering pty input data={x}", .{payload});
 801+        // client is leader, send entire payload (ansi escape codes + text)
 802+        if (self.leader_client_fd == client.socket_fd) {
 803+            self.queuePtyInput(gpa, payload);
 804+            return;
 805+        }
 806+
 807+        // check if leader needs to be updated by detecting any user input
 808+        if (util.isUserInput(payload)) {
 809+            try self.setLeader(gpa, client);
 810+            self.queuePtyInput(gpa, payload);
 811+        }
 812+    }
 813+
 814+    /// Queue input from `zmx send` without changing interactive client leadership.
 815+    pub fn handleSend(self: *Daemon, gpa: std.mem.Allocator, payload: []const u8) void {
 816+        self.queuePtyInput(gpa, payload);
 817+    }
 818+
 819+    pub fn handleSwitch(self: *Daemon, gpa: std.mem.Allocator, session_name: []const u8) !void {
 820+        for (self.clients.items) |client| {
 821+            if (self.leader_client_fd == client.socket_fd) {
 822+                ipc.appendMessage(
 823+                    gpa,
 824+                    &client.write_buf,
 825+                    .Switch,
 826+                    session_name,
 827+                ) catch |err| {
 828+                    std.log.warn(
 829+                        "failed to buffer terminal state for client err={s}",
 830+                        .{@errorName(err)},
 831+                    );
 832+                };
 833+                client.has_pending_output = true;
 834+                return;
 835+            }
 836+        }
 837+        return error.NoLeaderFound;
 838+    }
 839+
 840+    pub fn handleInit(
 841+        self: *Daemon,
 842+        gpa: std.mem.Allocator,
 843+        client: *Client,
 844+        pty_fd: i32,
 845+        term: *ghostty_vt.Terminal,
 846+        payload: []const u8,
 847+    ) !void {
 848+        if (payload.len != @sizeOf(ipc.Resize)) return;
 849+
 850+        // Serialize terminal state BEFORE resize to capture correct cursor position.
 851+        // Resizing triggers reflow which can move the cursor, and the shell's
 852+        // SIGWINCH-triggered redraw will run after our snapshot is sent.
 853+        // Only serialize on re-attach (has_had_client), not first attach, to avoid
 854+        // interfering with shell initialization (DA1 queries, etc.)
 855+        if (self.has_pty_output and self.has_had_client) {
 856+            const cursor = &term.screens.active.cursor;
 857+            std.log.debug(
 858+                "cursor before serialize: x={d} y={d} pending_wrap={}",
 859+                .{ cursor.x, cursor.y, cursor.pending_wrap },
 860+            );
 861+            if (util.serializeTerminalState(gpa, term)) |term_output| {
 862+                std.log.debug("serialize terminal state", .{});
 863+                // Rewrite OSC 133;A to include redraw=0 so the outer terminal
 864+                // does not clear prompt lines on resize (issue #111).
 865+                const restore_data = util.rewritePromptRedraw(gpa, term_output) orelse term_output;
 866+                defer gpa.free(term_output);
 867+                defer if (restore_data.ptr != term_output.ptr) gpa.free(restore_data);
 868+                ipc.appendMessage(gpa, &client.write_buf, .Output, restore_data) catch |err| {
 869+                    std.log.warn(
 870+                        "failed to buffer terminal state for client err={s}",
 871+                        .{@errorName(err)},
 872+                    );
 873+                };
 874+                client.has_pending_output = true;
 875+            }
 876+        }
 877+
 878+        // no leader is set so set one
 879+        if (self.leader_client_fd == null) {
 880+            try self.setLeader(gpa, client);
 881+        }
 882+
 883+        // only resize if leader
 884+        if (self.leader_client_fd == client.socket_fd) {
 885+            const resize = std.mem.bytesToValue(ipc.Resize, payload);
 886+            var ws: cross.c.struct_winsize = .{
 887+                .ws_row = resize.rows,
 888+                .ws_col = resize.cols,
 889+                .ws_xpixel = resize.xpixel,
 890+                .ws_ypixel = resize.ypixel,
 891+            };
 892+            _ = cross.c.ioctl(pty_fd, cross.c.TIOCSWINSZ, &ws);
 893+            // Disable prompt_redraw before resize. The daemon's internal terminal
 894+            // would otherwise clear prompt lines expecting the shell to redraw them,
 895+            // but the shell's redraw goes to the PTY (forwarded to clients), not to
 896+            // this daemon terminal. The clearing corrupts the daemon's snapshot state.
 897+            const saved_prompt_redraw = term.flags.shell_redraws_prompt;
 898+            term.flags.shell_redraws_prompt = .false;
 899+            defer term.flags.shell_redraws_prompt = saved_prompt_redraw;
 900+            const opts = ghostty_vt.Terminal.Resize{
 901+                .cols = resize.cols,
 902+                .rows = resize.rows,
 903+            };
 904+            try term.resize(gpa, opts);
 905+
 906+            // Mark that we've had a client init, so subsequent clients get terminal state
 907+            self.has_had_client = true;
 908+            self.has_terminal_client = true;
 909+
 910+            std.log.debug("init resize rows={d} cols={d}", .{ resize.rows, resize.cols });
 911+        }
 912+    }
 913+
 914+    pub fn handleResize(
 915+        self: *Daemon,
 916+        gpa: std.mem.Allocator,
 917+        client: *Client,
 918+        pty_fd: i32,
 919+        term: *ghostty_vt.Terminal,
 920+        payload: []const u8,
 921+    ) !void {
 922+        if (payload.len != @sizeOf(ipc.Resize)) return;
 923+        if (self.leader_client_fd == null) {
 924+            try self.setLeader(gpa, client);
 925+        }
 926+        // only leader can resize
 927+        if (self.leader_client_fd != client.socket_fd) return;
 928+
 929+        const resize = std.mem.bytesToValue(ipc.Resize, payload);
 930+        var ws: cross.c.struct_winsize = .{
 931+            .ws_row = resize.rows,
 932+            .ws_col = resize.cols,
 933+            .ws_xpixel = resize.xpixel,
 934+            .ws_ypixel = resize.ypixel,
 935+        };
 936+        _ = cross.c.ioctl(pty_fd, cross.c.TIOCSWINSZ, &ws);
 937+        // Disable prompt_redraw before resize (same rationale as handleInit).
 938+        const saved_prompt_redraw = term.flags.shell_redraws_prompt;
 939+        term.flags.shell_redraws_prompt = .false;
 940+        defer term.flags.shell_redraws_prompt = saved_prompt_redraw;
 941+        const opts = ghostty_vt.Terminal.Resize{
 942+            .cols = resize.cols,
 943+            .rows = resize.rows,
 944+        };
 945+        try term.resize(gpa, opts);
 946+        std.log.debug("resize rows={d} cols={d}", .{ resize.rows, resize.cols });
 947+    }
 948+
 949+    pub fn handleDetach(self: *Daemon, gpa: std.mem.Allocator, client: *Client, i: usize) void {
 950+        std.log.info("client detach session={s} fd={d}", .{ self.session_name, client.socket_fd });
 951+        _ = self.closeClient(gpa, client, i, false);
 952+    }
 953+
 954+    pub fn handleDetachAll(self: *Daemon, gpa: std.mem.Allocator) void {
 955+        std.log.info("detach all clients={d}", .{self.clients.items.len});
 956+        for (self.clients.items) |client_to_close| {
 957+            client_to_close.deinit();
 958+            gpa.destroy(client_to_close);
 959+        }
 960+        self.clients.clearRetainingCapacity();
 961+    }
 962+
 963+    pub fn handleKill(self: *Daemon, gpa: std.mem.Allocator, io: std.Io) void {
 964+        std.log.info("kill received session={s}", .{self.session_name});
 965+        self.shutdown(gpa);
 966+        // gracefully shutdown shell processes, shells tend to ignore SIGTERM so we send SIGHUP
 967+        // instead
 968+        //   https://www.gnu.org/software/bash/manual/html_node/Signals.html
 969+        // negative pid means kill process and children
 970+        std.log.info("sending SIGHUP session={s} pid={d}", .{ self.session_name, self.pid });
 971+        lib_posix.kill(-self.pid, lib_posix.SIG.HUP) catch |err| {
 972+            std.log.warn("failed to send SIGHUP to pty child err={s}", .{@errorName(err)});
 973+        };
 974+        std.Io.sleep(io, std.Io.Duration.fromMilliseconds(500), .real) catch unreachable;
 975+        lib_posix.kill(-self.pid, lib_posix.SIG.KILL) catch |err| {
 976+            std.log.warn("failed to send SIGKILL to pty child err={s}", .{@errorName(err)});
 977+        };
 978+    }
 979+
 980+    pub fn handleInfo(self: *Daemon, gpa: std.mem.Allocator, client: *Client) !void {
 981+        // zeroes() so asBytes() doesn't ship struct padding + unused cmd/cwd
 982+        // tail bytes (daemon stack contents) to clients.
 983+        var info = std.mem.zeroes(ipc.Info);
 984+        info.clients_len = self.clients.items.len - 1;
 985+        info.pid = self.pid;
 986+        info.created_at = self.created_at;
 987+        info.task_ended_at = self.task_ended_at orelse 0;
 988+        info.task_exit_code = self.task_exit_code orelse 0;
 989+
 990+        // Build command string from args, re-quoting args that contain
 991+        // shell-special characters so the displayed command is copy-pasteable.
 992+        const cur_cmd = self.command;
 993+        if (cur_cmd) |args| {
 994+            for (args, 0..) |arg, i| {
 995+                const quoted = if (util.shellNeedsQuoting(arg))
 996+                    util.shellQuote(gpa, arg) catch null
 997+                else
 998+                    null;
 999+                defer if (quoted) |q| gpa.free(q);
1000+                const src = quoted orelse arg;
1001+
1002+                const need = src.len + @as(usize, if (i > 0) 1 else 0);
1003+                if (info.cmd_len + need > ipc.MAX_CMD_LEN) {
1004+                    const ellipsis = "...";
1005+                    if (info.cmd_len + ellipsis.len <= ipc.MAX_CMD_LEN) {
1006+                        @memcpy(info.cmd[info.cmd_len..][0..ellipsis.len], ellipsis);
1007+                        info.cmd_len += ellipsis.len;
1008+                    }
1009+                    break;
1010+                }
1011+
1012+                if (i > 0) {
1013+                    info.cmd[info.cmd_len] = ' ';
1014+                    info.cmd_len += 1;
1015+                }
1016+                @memcpy(info.cmd[info.cmd_len..][0..src.len], src);
1017+                info.cmd_len += @intCast(src.len);
1018+            }
1019+        }
1020+
1021+        info.cwd_len = @intCast(@min(self.cwd.len, ipc.MAX_CWD_LEN));
1022+        @memcpy(info.cwd[0..info.cwd_len], self.cwd[0..info.cwd_len]);
1023+
1024+        try ipc.appendMessage(gpa, &client.write_buf, .Info, std.mem.asBytes(&info));
1025+        client.has_pending_output = true;
1026+    }
1027+
1028+    pub fn handleHistory(
1029+        _: *Daemon,
1030+        gpa: std.mem.Allocator,
1031+        client: *Client,
1032+        term: *ghostty_vt.Terminal,
1033+        payload: []const u8,
1034+    ) !void {
1035+        const format: util.HistoryFormat = if (payload.len > 0)
1036+            @enumFromInt(payload[0])
1037+        else
1038+            .plain;
1039+        if (util.serializeTerminal(gpa, term, format)) |output| {
1040+            defer gpa.free(output);
1041+            try ipc.appendMessage(gpa, &client.write_buf, .History, output);
1042+            client.has_pending_output = true;
1043+        } else {
1044+            try ipc.appendMessage(gpa, &client.write_buf, .History, "");
1045+            client.has_pending_output = true;
1046+        }
1047+    }
1048+
1049+    pub fn handleRun(self: *Daemon, gpa: std.mem.Allocator, client: *Client, payload: []const u8) !void {
1050+        // Reset task tracking so the new command's exit marker is detected.
1051+        // Without this, a second `zmx run` on the same session is ignored
1052+        // because task_exit_code is still set from the first run.
1053+        self.task_exit_code = null;
1054+        self.task_ended_at = null;
1055+        self.is_task_mode = true;
1056+
1057+        if (payload.len == 0) return;
1058+
1059+        const cmd = payload;
1060+
1061+        // Chain the exit marker with `;` on the same line. `$?` captures the
1062+        // exit code of the command (not the `;`). The sole exception is when
1063+        // the command contains a heredoc (`<<`), the delimiter must be alone
1064+        // on its line, so the marker goes on the next line instead.
1065+        const single_line_marker = "; echo ZMX_TASK_COMPLETED:$?\r";
1066+        const heredoc_marker = "\r\necho ZMX_TASK_COMPLETED:$?\r";
1067+        const uses_heredoc = std.mem.indexOf(u8, cmd, "<<") != null;
1068+
1069+        if (cmd.len > 0 and cmd[cmd.len - 1] == '\r') {
1070+            self.queuePtyInput(gpa, cmd[0 .. cmd.len - 1]);
1071+        } else {
1072+            self.queuePtyInput(gpa, cmd);
1073+        }
1074+        self.queuePtyInput(gpa, if (uses_heredoc) heredoc_marker else single_line_marker);
1075+
1076+        try ipc.appendMessage(gpa, &client.write_buf, .Ack, "");
1077+        client.has_pending_output = true;
1078+        self.has_had_client = true;
1079+        std.log.debug("run command len={d}", .{payload.len});
1080+    }
1081+
1082+    pub fn handleOutput(self: *Daemon, gpa: std.mem.Allocator, payload: []const u8, vt_stream: anytype) !void {
1083+        vt_stream.nextSlice(payload);
1084+        self.has_pty_output = true;
1085+        for (self.clients.items) |client| {
1086+            try ipc.appendMessage(gpa, &client.write_buf, .Output, payload);
1087+            client.has_pending_output = true;
1088+        }
1089+        if (self.clients.items.len > 0) {
1090+            lib_posix.kill(self.pid, lib_posix.SIG.WINCH) catch |err| {
1091+                std.log.warn("failed to send SIGWINCH err={s}", .{@errorName(err)});
1092+            };
1093+        }
1094+    }
1095+
1096+    pub fn handleWrite(self: *Daemon, gpa: std.mem.Allocator, client: *Client, payload: []const u8) !void {
1097+        // Wire format: [u32 path len][path bytes][file content]
1098+        if (payload.len < @sizeOf(u32)) return error.InvalidPayload;
1099+        const path_len = std.mem.bytesToValue(u32, payload[0..@sizeOf(u32)]);
1100+        if (payload.len < @sizeOf(u32) + path_len) return error.InvalidPayload;
1101+        const file_path = payload[@sizeOf(u32)..][0..path_len];
1102+        const file_content = payload[@sizeOf(u32) + path_len ..];
1103+
1104+        // Inject file creation through the PTY so it works over SSH.
1105+        // Base64-encode content and pipe through printf | base64 -d > file.
1106+        // Chunk large files to stay under command-line length limits.
1107+        // 48000 is divisible by 3 (clean base64 boundaries) and encodes
1108+        // to ~64KB, well under typical ARG_MAX.
1109+        const chunk_size = 48000;
1110+        var offset: usize = 0;
1111+        var is_first = true;
1112+
1113+        while (offset < file_content.len or is_first) {
1114+            const end = @min(offset + chunk_size, file_content.len);
1115+            const chunk = file_content[offset..end];
1116+
1117+            const encoded_len = std.base64.standard.Encoder.calcSize(chunk.len);
1118+            const encoded = try gpa.alloc(u8, encoded_len);
1119+            defer gpa.free(encoded);
1120+            _ = std.base64.standard.Encoder.encode(encoded, chunk);
1121+
1122+            self.queuePtyInput(gpa, "printf '%s' '");
1123+            self.queuePtyInput(gpa, encoded);
1124+            if (is_first) {
1125+                self.queuePtyInput(gpa, "' | base64 -d > '");
1126+            } else {
1127+                self.queuePtyInput(gpa, "' | base64 -d >> '");
1128+            }
1129+            self.queuePtyInput(gpa, file_path);
1130+            self.queuePtyInput(gpa, "'");
1131+            self.queuePtyInput(gpa, "\r");
1132+
1133+            offset = end;
1134+            is_first = false;
1135+        }
1136+
1137+        try ipc.appendMessage(gpa, &client.write_buf, .Ack, "");
1138+        client.has_pending_output = true;
1139+        self.has_had_client = true;
1140+        std.log.debug(
1141+            "write command len={d} file_path={s}",
1142+            .{ file_content.len, file_path },
1143+        );
1144+    }
1145+
1146+    fn handleLabelGet(self: *Daemon, gpa: std.mem.Allocator, client: *Client) !void {
1147+        const out = try label.labelsToU8(gpa, self.labels);
1148+        defer gpa.free(out);
1149+        try ipc.appendMessage(gpa, &client.write_buf, .LabelData, out);
1150+        client.has_pending_output = true;
1151+    }
1152+
1153+    fn handleLabelSet(self: *Daemon, gpa: std.mem.Allocator, client: *Client, labels: []const u8) !void {
1154+        std.log.info("handle label set payload={s}", .{labels});
1155+
1156+        var kvs = label.LabelIterator.init(labels);
1157+        while (kvs.next()) |kv| {
1158+            if (kv.value.len == 0) {
1159+                if (self.labels.fetchRemove(kv.key)) |existing| {
1160+                    gpa.free(existing.key);
1161+                    gpa.free(existing.value);
1162+                }
1163+                continue;
1164+            }
1165+
1166+            const owned_key = try gpa.dupe(u8, kv.key);
1167+            errdefer gpa.free(owned_key);
1168+            const owned_value = try gpa.dupe(u8, kv.value);
1169+            errdefer gpa.free(owned_value);
1170+            if (try self.labels.fetchPut(gpa, owned_key, owned_value)) |existing| {
1171+                // fetchPut does NOT replace the key in the map, the old
1172+                // key pointer stays. So free the new (unused) key and the
1173+                // old value.
1174+                gpa.free(owned_key);
1175+                gpa.free(existing.value);
1176+            }
1177+        }
1178+
1179+        try ipc.appendMessage(gpa, &client.write_buf, .Ack, "");
1180+        client.has_pending_output = true;
1181+    }
1182+
1183+    fn handleLabelClear(self: *Daemon, gpa: std.mem.Allocator, client: *Client) !void {
1184+        var it = self.labels.iterator();
1185+        while (it.next()) |entry| {
1186+            gpa.free(entry.key_ptr.*);
1187+            gpa.free(entry.value_ptr.*);
1188+        }
1189+        self.labels.clearRetainingCapacity();
1190+        try ipc.appendMessage(gpa, &client.write_buf, .Ack, "");
1191+        client.has_pending_output = true;
1192+    }
1193+};
1194+
1195+test "send queues PTY input without changing leader" {
1196+    const alloc = std.testing.allocator;
1197+    var daemon = Daemon{
1198+        .cfg = undefined,
1199+        .clients = .empty,
1200+        .leader_client_fd = 42,
1201+        .session_name = "test",
1202+        .socket_path = "",
1203+        .running = true,
1204+        .pid = 0,
1205+        .created_at = 0,
1206+    };
1207+    defer daemon.pty_write_buf.deinit(alloc);
1208+
1209+    daemon.handleSend(alloc, "hello");
1210+
1211+    try std.testing.expectEqual(@as(?i32, 42), daemon.leader_client_fd);
1212+    try std.testing.expectEqualStrings("hello", daemon.pty_write_buf.items);
1213+}