refactor: upgrade to zig v0.16.0

Commit `4232d74`

Eric Bower · 2026-07-23 11:42:37 -0400 EDT

parent 93cd148

refactor: upgrade to zig v0.16.0

The biggest challenge was the deprecation of std.posix.  In an effort to upgrade
to 0.16 without a major rewrite I decided to port the functions from std.posix
that we were heavily using.  We can continue to chip away at some of the posix
functions but it's likely many will remain until std.Io matures and we can migrate
off of using `poll(2)` directly.

Build is passing, tests are passing.

10 files changed, +1640, -433

M Dockerfile

M README.md

M build.zig

M build.zig.zon

M src/ipc.zig

M src/log.zig

M src/main.zig

A src/posix.zig

M src/socket.zig

M src/util.zig

M Dockerfile

+1, -1

......@@ -2,7 +2,7 @@ FROM debian:12

RUN apt-get update && apt-get install -y curl git bats coreutils && rm -rf /var/lib/apt/lists/*

ARG ZIG_VERSION=0.15.2
ARG ZIG_VERSION=0.16.0
RUN curl -L -o /tmp/zig.tar.xz https://ziglang.org/download/${ZIG_VERSION}/zig-x86_64-linux-${ZIG_VERSION}.tar.xz && \
	cd /tmp && \
	tar -xvf zig.tar.xz && \

M README.md

+1, -1

......@@ -80,7 +80,7 @@ nix run github:neurosnap/zmx

### src

- Requires zig `v0.15`
- Requires zig `v0.16`
- Clone the repo
- Run build cmd

M build.zig

+6, -5

......@@ -27,6 +27,7 @@ pub fn build(b: *std.Build) void {
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
        .link_libc = true,
    });
    exe_mod.addOptions("build_options", options);

......@@ -54,7 +55,7 @@ pub fn build(b: *std.Build) void {
            .use_lld = !is_macos,
            .root_module = exe_mod,
        });
        exe.linkLibC();

        b.installArtifact(exe);
        const run_cmd = b.addRunArtifact(exe);
        run_cmd.step.dependOn(b.getInstallStep());

......@@ -69,6 +70,7 @@ pub fn build(b: *std.Build) void {
            .root_source_file = b.path("src/test.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        });
        const test_dep = b.dependency("ghostty", .{
            .target = target,

......@@ -86,7 +88,7 @@ pub fn build(b: *std.Build) void {
            .use_llvm = true,
            .use_lld = !is_macos,
        });
        exe_unit_tests.linkLibC();

        const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
        test_step.dependOn(&run_exe_unit_tests.step);
    }

......@@ -100,7 +102,6 @@ pub fn build(b: *std.Build) void {
            .use_lld = !is_macos,
            .root_module = exe_mod,
        });
        exe_check.linkLibC();

        // Finally we add the "check" step which will be detected
        // by ZLS and automatically enable Build-On-Save.

......@@ -121,6 +122,7 @@ pub fn build(b: *std.Build) void {
                .root_source_file = b.path("src/main.zig"),
                .target = resolved,
                .optimize = .ReleaseSafe,
                .link_libc = true,
            });
            release_mod.addOptions("build_options", options);

......@@ -141,7 +143,6 @@ pub fn build(b: *std.Build) void {
                .use_lld = !is_local_macos,
                .root_module = release_mod,
            });
            release_exe.linkLibC();

            const os_name = @tagName(release_target.os_tag orelse .linux);
            const arch_name = @tagName(release_target.cpu_arch orelse .x86_64);

......@@ -156,7 +157,7 @@ pub fn build(b: *std.Build) void {

            const shasum = b.addSystemCommand(&.{"sha256sum"});
            shasum.addFileArg(tarball);
            const shasum_output = shasum.captureStdOut();
            const shasum_output = shasum.captureStdOut(.{});

            const install_tar = b.addInstallFile(tarball, b.fmt("dist/{s}", .{tarball_name}));
            const install_sha = b.addInstallFile(

M build.zig.zon

+3, -3

...	...		@@ -2,11 +2,11 @@
2	2		.name = .zmx,
3	3		.version = "0.7.0",
4	4		.fingerprint = 0x28aad87005052b4e, // Changing this has security and trust implications.
5		-	.minimum_zig_version = "0.15.2",
	5	+	.minimum_zig_version = "0.16.0",
6	6		.dependencies = .{
7	7		.ghostty = .{
8		-	.url = "git+https://github.com/ghostty-org/ghostty#30e1f3bb8c3d2949e9ae4aefc1c2b76142569cfb",
9		-	.hash = "ghostty-1.3.2-dev-5UdBC5gHIgWG-_Voonf5F76Vt2I2KljI5lIuvI-7eyBI",
	8	+	.url = "git+https://github.com/ghostty-org/ghostty.git/#15484b607eb5a518dedf1548247c923b8abaae7c",
	9	+	.hash = "ghostty-1.3.2-dev-5UdBCwfRJAX2W3lpOWUOrkLvsqJckxucSrjECoDjq9kL",
10	10		},
11	11		},
12	12		.paths = .{

M src/ipc.zig

+5, -4

......@@ -2,6 +2,7 @@ const std = @import("std");
const posix = std.posix;
const cross = @import("cross.zig");
const socket = @import("socket.zig");
const lib_posix = @import("posix.zig");

pub const Tag = enum(u8) {
    Input = 0,

......@@ -115,7 +116,7 @@ pub fn appendMessage(
fn writeAll(fd: i32, data: []const u8) !void {
    var index: usize = 0;
    while (index < data.len) {
        const n = try posix.write(fd, data[index..]);
        const n = try lib_posix.write(fd, data[index..]);
        if (n == 0) return error.DiskQuota;
        index += n;
    }

......@@ -223,7 +224,7 @@ const SessionProbeResult = struct {

    pub fn deinit(self: *const SessionProbeResult) void {
        if (self.labels) |lbl| self.alloc.free(lbl);
        posix.close(self.fd);
        lib_posix.close(self.fd);
    }
};

......@@ -233,7 +234,7 @@ pub fn probeSession(
) SessionProbeError!SessionProbeResult {
    const timeout_ms = 1000;
    const fd = try connectSession(socket_path);
    errdefer posix.close(fd);
    errdefer lib_posix.close(fd);

    send(fd, .Info, "") catch return error.Unexpected;
    send(fd, .LabelGet, "") catch {};

......@@ -320,7 +321,7 @@ pub fn roundTripForTag(
) SessionProbeError![]u8 {
    const timeout_ms = 1000;
    const fd = try connectSession(socket_path);
    defer posix.close(fd);
    defer lib_posix.close(fd);

    send(fd, request_tag, payload) catch return error.Unexpected;

M src/log.zig

+31, -24

......@@ -1,50 +1,52 @@
const std = @import("std");
const posix = std.posix;

pub const LogSystem = struct {
    file: ?std.fs.File = null,
    mutex: std.Thread.Mutex = .{},
    file: ?std.Io.File = null,
    mutex: std.Io.Mutex = .init,
    current_size: u64 = 0,
    max_size: u64 = 5 * 1024 * 1024, // 5MB
    path: []const u8 = "",
    alloc: std.mem.Allocator = undefined,
    mode: u32 = 0o640,
    io: std.Io = undefined,
    mode: std.Io.File.Permissions = std.Io.File.Permissions.fromMode(0o640),

    pub fn init(self: *LogSystem, alloc: std.mem.Allocator, path: []const u8, mode: u32) !void {
    pub fn init(self: *LogSystem, alloc: std.mem.Allocator, io: std.Io, path: []const u8, mode: std.Io.File.Permissions) !void {
        self.alloc = alloc;
        self.io = io;
        self.path = try alloc.dupe(u8, path);
        self.mode = mode;

        const file = std.fs.openFileAbsolute(path, .{ .mode = .read_write }) catch |err| switch (err) {
            error.FileNotFound => try std.fs.createFileAbsolute(
        const file = std.Io.Dir.openFileAbsolute(self.io, path, .{ .mode = .read_write }) catch |err| switch (err) {
            error.FileNotFound => try std.Io.Dir.createFileAbsolute(
                self.io,
                path,
                .{ .read = true, .mode = @intCast(self.mode) },
                .{ .read = true, .permissions = self.mode },
            ),
            else => return err,
        };

        // fstat (not getEndPos) to avoid the statx syscall; see #186.
        const st = try posix.fstat(file.handle);
        const end_pos: u64 = @intCast(st.size);
        try file.seekTo(end_pos);
        const end_pos = try std.Io.File.length(file, self.io);
        var buf: [1]u8 = undefined;
        var w = std.Io.File.writer(file, self.io, &buf);
        try w.seekTo(end_pos);
        self.current_size = end_pos;
        self.file = file;
    }

    pub fn deinit(self: *LogSystem) void {
        if (self.file) |f| f.close();
        if (self.file) |f| std.Io.File.close(f, self.io);
        if (self.path.len > 0) self.alloc.free(self.path);
    }

    pub fn log(
        self: *LogSystem,
        comptime level: std.log.Level,
        comptime scope: @Type(.enum_literal),
        comptime scope: anytype,
        comptime format: []const u8,
        args: anytype,
    ) void {
        self.mutex.lock();
        defer self.mutex.unlock();
    ) !void {
        try self.mutex.lock(self.io);
        defer self.mutex.unlock(self.io);

        if (self.file == null) {
            std.log.defaultLog(level, scope, format, args);

......@@ -57,7 +59,7 @@ pub const LogSystem = struct {
            };
        }

        const now = std.time.milliTimestamp();
        const now: i64 = @intCast(@divTrunc(std.Io.Timestamp.now(self.io, .real).nanoseconds, std.time.ns_per_ms));
        const prefix = "[{d}] [{s}] ({s}): ";
        const scope_name = @tagName(scope);
        const level_name = level.asText();

......@@ -76,29 +78,34 @@ pub const LogSystem = struct {
            self.current_size += total_len;

            var buf: [4096]u8 = undefined;
            var w = f.writerStreaming(&buf);
            w.interface.print(prefix ++ format ++ "\n", prefix_args ++ args) catch {};
            var w = f.writerStreaming(self.io, &buf);
            std.Io.Writer.print(&w.interface, prefix ++ format ++ "\n", prefix_args ++ args) catch {};
            w.interface.flush() catch {};
        }
    }

    fn rotate(self: *LogSystem) !void {
        if (self.file) |f| {
            f.close();
            std.Io.File.close(f, self.io);
            self.file = null;
        }

        const old_path = try std.fmt.allocPrint(self.alloc, "{s}.old", .{self.path});
        defer self.alloc.free(old_path);

        std.fs.renameAbsolute(self.path, old_path) catch |err| switch (err) {
        std.Io.Dir.renameAbsolute(self.path, old_path, self.io) catch |err| switch (err) {
            error.FileNotFound => {},
            else => return err,
        };

        self.file = try std.fs.createFileAbsolute(
        self.file = try std.Io.Dir.createFileAbsolute(
            self.io,
            self.path,
            .{ .truncate = true, .read = true, .mode = @intCast(self.mode) },
            .{
                .truncate = true,
                .read = true,
                .permissions = self.mode,
            },
        );
        self.current_size = 0;
    }

M src/main.zig

+363, -340

......@@ -9,6 +9,7 @@ const util = @import("util.zig");
const cross = @import("cross.zig");
const socket = @import("socket.zig");
const label = @import("label.zig");
const lib_posix = @import("posix.zig");

pub const version = build_options.version;
pub const ghostty_version = build_options.ghostty_version;

......@@ -22,11 +23,11 @@ pub const std_options: std.Options = .{

fn zmxLogFn(
    comptime level: std.log.Level,
    comptime scope: @Type(.enum_literal),
    comptime scope: anytype,
    comptime format: []const u8,
    args: anytype,
) void {
    log_system.log(level, scope, format, args);
    log_system.log(level, scope, format, args) catch {};
}

/// Self-pipe woken by signal handlers. std.posix.poll loops on .INTR internally

......@@ -47,13 +48,13 @@ const SessionMatch = struct {
    }
};

fn resolveSessionOrEnv(alloc: std.mem.Allocator, session_name: ?[]const u8) ![]const u8 {
fn resolveSessionOrEnv(alloc: std.mem.Allocator, io: std.Io, session_name: ?[]const u8) ![]const u8 {
    const sesh_env = socket.getSeshNameFromEnv();
    const raw = if (session_name) |name|
        if (std.mem.eql(u8, name, ".")) blk: {
            if (sesh_env.len > 0) break :blk sesh_env;
            var buf: [4096]u8 = undefined;
            var w = std.fs.File.stderr().writer(&buf);
            var w = std.Io.File.stderr().writer(io, &buf);
            w.interface.print("error: \".\" requires ZMX_SESSION (are you inside a zmx session?)\n", .{}) catch {};
            w.interface.flush() catch {};
            return error.SessionNameRequired;

......@@ -76,7 +77,7 @@ fn parseSessionArg(alloc: std.mem.Allocator, raw: []const u8) !SessionMatch {
}

fn openSignalPipe() !void {
    sig_pipe = try posix.pipe2(.{ .CLOEXEC = true, .NONBLOCK = true });
    sig_pipe = try lib_posix.pipe2(.{ .CLOEXEC = true, .NONBLOCK = true });
}

fn drainSignalPipe() void {

......@@ -91,9 +92,9 @@ fn detectHelp(arg: []const u8) bool {
    return (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h"));
}

pub fn main() !void {
    // use c_allocator to avoid "reached unreachable code" panic in DebugAllocator when forking
    const alloc = std.heap.c_allocator;
pub fn main(init: std.process.Init) !void {
    const gpa = init.gpa;
    const io = init.io;

    // Every subcommand may write to a Unix-domain socket; a peer that
    // disappears between probe and send would otherwise kill us before

......@@ -101,76 +102,79 @@ pub fn main() !void {
    // covers the daemon.
    ignoreSigpipe();

    var args = try std.process.argsWithAllocator(alloc);
    var args = init.minimal.args.iterate();
    defer args.deinit();
    _ = args.skip(); // skip program name
    _ = args.next(); // skip program name

    var cfg = try Cfg.init(alloc);
    defer cfg.deinit(alloc);
    var cfg = try Cfg.init(gpa, io);
    defer cfg.deinit(gpa);

    const log_path = try std.fs.path.join(alloc, &.{ cfg.log_dir, "zmx.log" });
    defer alloc.free(log_path);
    try log_system.init(alloc, log_path, cfg.log_mode);
    const log_path = try std.fs.path.join(gpa, &.{ cfg.log_dir, "zmx.log" });
    defer gpa.free(log_path);
    const log_mode = std.Io.File.Permissions.fromMode(cfg.log_mode);
    try log_system.init(gpa, io, log_path, log_mode);
    defer log_system.deinit();

    const shell_env = init.environ_map.get("SHELL") orelse "/bin/sh";

    const cmd = args.next() orelse {
        return list(&cfg, false);
        return list(gpa, io, &cfg, false);
    };

    if (std.mem.eql(u8, cmd, "version") or std.mem.eql(u8, cmd, "v") or std.mem.eql(u8, cmd, "-v") or std.mem.eql(u8, cmd, "--version")) {
        return printVersion(&cfg);
        return printVersion(io, &cfg);
    } else if (std.mem.eql(u8, cmd, "help") or std.mem.eql(u8, cmd, "h") or std.mem.eql(u8, cmd, "-h")) {
        return help();
        return help(io);
    } else if (std.mem.eql(u8, cmd, "list") or std.mem.eql(u8, cmd, "l") or std.mem.eql(u8, cmd, "ls")) {
        var short = false;
        while (args.next()) |arg| {
            if (detectHelp(arg)) return help();
            if (detectHelp(arg)) return help(io);
            if (std.mem.eql(u8, arg, "--short")) short = true;
        }
        return list(&cfg, short);
        return list(gpa, io, &cfg, short);
    } else if (std.mem.eql(u8, cmd, "get") or std.mem.eql(u8, cmd, "g")) {
        const sesh_name = args.next() orelse return error.SessionNameRequired;
        if (detectHelp(sesh_name)) return help();
        const sesh = try resolveSessionOrEnv(alloc, sesh_name);
        defer alloc.free(sesh);
        if (detectHelp(sesh_name)) return help(io);
        const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
        defer gpa.free(sesh);
        const single_kv = args.next() orelse "";
        return labelGet(&cfg, sesh, single_kv);
        return labelGet(gpa, io, &cfg, sesh, single_kv);
    } else if (std.mem.eql(u8, cmd, "set")) {
        const sesh_name = args.next() orelse return error.SessionNameRequired;
        if (detectHelp(sesh_name)) return help();
        const sesh = try resolveSessionOrEnv(alloc, sesh_name);
        defer alloc.free(sesh);
        if (detectHelp(sesh_name)) return help(io);
        const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
        defer gpa.free(sesh);

        var kvs = std.ArrayList(u8).empty;
        defer kvs.deinit(alloc);
        defer kvs.deinit(gpa);
        var first = true;
        while (args.next()) |arg| {
            if (!first) try kvs.append(alloc, ' ');
            try kvs.appendSlice(alloc, arg);
            if (!first) try kvs.append(gpa, ' ');
            try kvs.appendSlice(gpa, arg);
            first = false;
        }
        return labelSet(&cfg, sesh, kvs.items);
        return labelSet(gpa, io, &cfg, sesh, kvs.items);
    } else if (std.mem.eql(u8, cmd, "clear")) {
        const sesh_name = args.next() orelse return error.SessionNameRequired;
        if (detectHelp(sesh_name)) return help();
        const sesh = try resolveSessionOrEnv(alloc, sesh_name);
        defer alloc.free(sesh);
        return labelClear(&cfg, sesh);
        if (detectHelp(sesh_name)) return help(io);
        const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
        defer gpa.free(sesh);
        return labelClear(gpa, io, &cfg, sesh);
    } else if (std.mem.eql(u8, cmd, "completions") or std.mem.eql(u8, cmd, "c")) {
        const arg = args.next() orelse return;
        if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
            return help();
            return help(io);
        }
        const shell = completions.Shell.fromString(arg) orelse return;
        return printCompletions(shell);
        return printCompletions(io, shell);
    } else if (std.mem.eql(u8, cmd, "detach") or std.mem.eql(u8, cmd, "d")) {
        return detachAll(&cfg);
        return detachAll(gpa, io, &cfg);
    } else if (std.mem.eql(u8, cmd, "history") or std.mem.eql(u8, cmd, "hi")) {
        var session_name: ?[]const u8 = null;
        var format: util.HistoryFormat = .plain;
        while (args.next()) |arg| {
            if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
                return help();
                return help(io);
            } else if (std.mem.eql(u8, arg, "--vt")) {
                format = .vt;
            } else if (std.mem.eql(u8, arg, "--html")) {

......@@ -180,47 +184,50 @@ pub fn main() !void {
            }
        }
        const sesh_env = socket.getSeshNameFromEnv();
        const sesh = try socket.getSeshName(alloc, session_name orelse sesh_env);
        defer alloc.free(sesh);
        return history(&cfg, sesh, format);
        const sesh = try socket.getSeshName(gpa, session_name orelse sesh_env);
        defer gpa.free(sesh);
        return history(gpa, io, &cfg, sesh, format);
    } else if (std.mem.eql(u8, cmd, "attach") or std.mem.eql(u8, cmd, "a")) {
        const session_name = args.next() orelse "";
        if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
            return help();
            return help(io);
        }

        var command_args: std.ArrayList([]const u8) = .empty;
        defer command_args.deinit(alloc);
        defer command_args.deinit(gpa);
        while (args.next()) |arg| {
            try command_args.append(alloc, arg);
            try command_args.append(gpa, arg);
        }

        const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
        const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);
        var command: ?[][]const u8 = null;
        if (command_args.items.len > 0) {
            command = command_args.items;
        }

        var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
        const cwd = std.posix.getcwd(&cwd_buf) catch "";
        const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
        const cwd = cwd_buf[0..cwd_len];

        const sesh = try socket.getSeshName(alloc, session_name);
        defer alloc.free(sesh);
        const sesh = try socket.getSeshName(gpa, session_name);
        defer gpa.free(sesh);
        var daemon = Daemon{
            .io = io,
            .running = true,
            .cfg = &cfg,
            .alloc = alloc,
            .alloc = std.heap.c_allocator,
            .clients = clients,
            .session_name = sesh,
            .socket_path = undefined,
            .pid = undefined,
            .command = command,
            .cwd = cwd,
            .created_at = @intCast(std.time.timestamp()),
            .created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
            .leader_client_fd = null,
            .shell = shell_env,
        };
        daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
        daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
            error.OutOfMemory => return err,
        };
        std.log.info("socket path={s}", .{daemon.socket_path});

......@@ -228,42 +235,45 @@ pub fn main() !void {
    } else if (std.mem.eql(u8, cmd, "run") or std.mem.eql(u8, cmd, "r")) {
        const session_name = args.next() orelse "";
        if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
            return help();
            return help(io);
        }

        var cmd_args_raw: std.ArrayList([]const u8) = .empty;
        defer cmd_args_raw.deinit(alloc);
        defer cmd_args_raw.deinit(gpa);
        var detached = false;
        while (args.next()) |arg| {
            if (std.mem.startsWith(u8, arg, "-d")) {
                detached = true;
            } else {
                try cmd_args_raw.append(alloc, arg);
                try cmd_args_raw.append(gpa, arg);
            }
        }
        const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
        const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);

        var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
        const cwd = std.posix.getcwd(&cwd_buf) catch "";
        const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
        const cwd = cwd_buf[0..cwd_len];

        const sesh = try socket.getSeshName(alloc, session_name);
        defer alloc.free(sesh);
        const sesh = try socket.getSeshName(gpa, session_name);
        defer gpa.free(sesh);
        var daemon = Daemon{
            .io = io,
            .running = true,
            .cfg = &cfg,
            .alloc = alloc,
            .alloc = std.heap.c_allocator,
            .clients = clients,
            .session_name = sesh,
            .socket_path = undefined,
            .pid = undefined,
            .command = null,
            .cwd = cwd,
            .created_at = @intCast(std.time.timestamp()),
            .created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
            .is_task_mode = true,
            .leader_client_fd = null,
            .shell = shell_env,
        };
        daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
        daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
            error.OutOfMemory => return err,
        };
        std.log.info("socket path={s}", .{daemon.socket_path});

......@@ -271,76 +281,76 @@ pub fn main() !void {
    } else if (std.mem.eql(u8, cmd, "send") or std.mem.eql(u8, cmd, "s")) {
        const session_name = args.next() orelse "";
        if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
            return help();
            return help(io);
        }
        if (session_name.len == 0) return error.SessionNameRequired;

        var text_parts: std.ArrayList([]const u8) = .empty;
        defer text_parts.deinit(alloc);
        defer text_parts.deinit(gpa);
        while (args.next()) |arg| {
            try text_parts.append(alloc, arg);
            try text_parts.append(gpa, arg);
        }

        const sesh = try socket.getSeshName(alloc, session_name);
        defer alloc.free(sesh);
        const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
        const sesh = try socket.getSeshName(gpa, session_name);
        defer gpa.free(sesh);
        const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(io, sesh, cfg.socket_dir),
            error.OutOfMemory => return err,
        };
        return send(&cfg, sesh, socket_path, text_parts.items, .Send);
        return send(gpa, io, &cfg, sesh, socket_path, text_parts.items, .Send);
    } else if (std.mem.eql(u8, cmd, "print") or std.mem.eql(u8, cmd, "p")) {
        const session_name = args.next() orelse "";
        if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
            return help();
            return help(io);
        }
        if (session_name.len == 0) return error.SessionNameRequired;

        var text_parts: std.ArrayList([]const u8) = .empty;
        defer text_parts.deinit(alloc);
        defer text_parts.deinit(gpa);
        while (args.next()) |arg| {
            try text_parts.append(alloc, arg);
            try text_parts.append(gpa, arg);
        }

        const sesh = try socket.getSeshName(alloc, session_name);
        defer alloc.free(sesh);
        const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
        const sesh = try socket.getSeshName(gpa, session_name);
        defer gpa.free(sesh);
        const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(io, sesh, cfg.socket_dir),
            error.OutOfMemory => return err,
        };
        return send(&cfg, sesh, socket_path, text_parts.items, .Output);
        return send(gpa, io, &cfg, sesh, socket_path, text_parts.items, .Output);
    } else if (std.mem.eql(u8, cmd, "kill") or std.mem.eql(u8, cmd, "k")) {
        var stderr_buffer: [1024]u8 = undefined;
        var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
        var stderr_writer = std.Io.File.stderr().writer(io, &stderr_buffer);
        const stderr = &stderr_writer.interface;

        var matchers: std.ArrayList(SessionMatch) = .empty;
        defer {
            for (matchers.items) |m| {
                alloc.free(m.name);
                gpa.free(m.name);
            }
            matchers.deinit(alloc);
            matchers.deinit(gpa);
        }
        var force = false;
        while (args.next()) |session_name| {
            if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
                return help();
                return help(io);
            }
            if (std.mem.eql(u8, session_name, "--force")) {
                force = true;
                continue;
            }
            const m = try parseSessionArg(alloc, session_name);
            try matchers.append(alloc, m);
            const m = try parseSessionArg(gpa, session_name);
            try matchers.append(gpa, m);
        }
        if (matchers.items.len == 0) {
            return error.SessionNameRequired;
        }
        var sessions = try util.get_session_entries(alloc, cfg.socket_dir);
        var sessions = try util.get_session_entries(gpa, io, cfg.socket_dir);
        defer {
            for (sessions.items) |session| {
                session.deinit(alloc);
                session.deinit(gpa);
            }
            sessions.deinit(alloc);
            sessions.deinit(gpa);
        }

        for (sessions.items) |session| {

......@@ -349,7 +359,7 @@ pub fn main() !void {
                    continue;
                }

                kill(&cfg, session.name, force) catch |err| {
                kill(gpa, io, &cfg, session.name, force) catch |err| {
                    try stderr.print(
                        "failed to kill session={s}: {s}\n",
                        .{ session.name, @errorName(err) },

......@@ -363,35 +373,35 @@ pub fn main() !void {
        var matchers: std.ArrayList(SessionMatch) = .empty;
        defer {
            for (matchers.items) |m| {
                alloc.free(m.name);
                gpa.free(m.name);
            }
            matchers.deinit(alloc);
            matchers.deinit(gpa);
        }
        while (args.next()) |session_name| {
            if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
                return help();
                return help(io);
            }
            const m = try parseSessionArg(alloc, session_name);
            try matchers.append(alloc, m);
            const m = try parseSessionArg(gpa, session_name);
            try matchers.append(gpa, m);
        }
        if (matchers.items.len == 0) {
            return error.SessionNameRequired;
        }
        return wait(&cfg, matchers);
        return wait(gpa, io, &cfg, matchers);
    } else if (std.mem.eql(u8, cmd, "tail") or std.mem.eql(u8, cmd, "t")) {
        var matchers: std.ArrayList(SessionMatch) = .empty;
        defer {
            for (matchers.items) |m| {
                alloc.free(m.name);
                gpa.free(m.name);
            }
            matchers.deinit(alloc);
            matchers.deinit(gpa);
        }
        while (args.next()) |session_name| {
            if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
                return help();
                return help(io);
            }
            const m = try parseSessionArg(alloc, session_name);
            try matchers.append(alloc, m);
            const m = try parseSessionArg(gpa, session_name);
            try matchers.append(gpa, m);
        }
        if (matchers.items.len == 0) {
            return error.SessionNameRequired;

......@@ -401,9 +411,9 @@ pub fn main() !void {
        var resolved_names: std.ArrayList([]const u8) = .empty;
        defer {
            for (resolved_names.items) |name| {
                alloc.free(name);
                gpa.free(name);
            }
            resolved_names.deinit(alloc);
            resolved_names.deinit(gpa);
        }

        var any_prefix = false;

......@@ -415,17 +425,17 @@ pub fn main() !void {
        }

        if (any_prefix) {
            var sessions = try util.get_session_entries(alloc, cfg.socket_dir);
            var sessions = try util.get_session_entries(gpa, io, cfg.socket_dir);
            defer {
                for (sessions.items) |session| {
                    session.deinit(alloc);
                    session.deinit(gpa);
                }
                sessions.deinit(alloc);
                sessions.deinit(gpa);
            }
            for (sessions.items) |session| {
                for (matchers.items) |m| {
                    if (m.matches(session.name)) {
                        try resolved_names.append(alloc, try alloc.dupe(u8, session.name));
                        try resolved_names.append(gpa, try gpa.dupe(u8, session.name));
                        break;
                    }
                }

......@@ -434,66 +444,69 @@ pub fn main() !void {
        // Add exact-match names directly.
        for (matchers.items) |m| {
            if (!m.is_prefix) {
                try resolved_names.append(alloc, try alloc.dupe(u8, m.name));
                try resolved_names.append(gpa, try gpa.dupe(u8, m.name));
            }
        }

        var client_socket_fds = try std.ArrayList(i32).initCapacity(alloc, resolved_names.items.len);
        var client_socket_fds = try std.ArrayList(i32).initCapacity(gpa, resolved_names.items.len);
        defer {
            for (client_socket_fds.items) |client_fd| {
                posix.close(client_fd);
                lib_posix.close(client_fd);
            }
            client_socket_fds.deinit(alloc);
            client_socket_fds.deinit(gpa);
        }

        for (resolved_names.items) |session_name| {
            const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
                error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
            const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, session_name) catch |err| switch (err) {
                error.NameTooLong => return socket.printSessionNameTooLong(init.io, session_name, cfg.socket_dir),
                error.OutOfMemory => return err,
            };
            const client_sock = try socket.sessionConnect(socket_path);
            try client_socket_fds.append(alloc, client_sock);
            try client_socket_fds.append(gpa, client_sock);
        }
        _ = try tail(client_socket_fds, false, false);
        _ = try tail(gpa, client_socket_fds, false, false);
    } else if (std.mem.eql(u8, cmd, "write") or std.mem.eql(u8, cmd, "wr")) {
        const session_name = args.next() orelse "";
        if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
            return help();
            return help(io);
        }
        if (session_name.len == 0) return error.SessionNameRequired;
        const file_path = args.next() orelse "";
        if (std.mem.eql(u8, file_path, "--help") or std.mem.eql(u8, file_path, "-h")) {
            return help();
            return help(io);
        }
        if (file_path.len == 0) return error.FilePathRequired;

        var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
        const cwd = std.posix.getcwd(&cwd_buf) catch "";
        const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
        const sesh = try socket.getSeshName(alloc, session_name);
        defer alloc.free(sesh);
        const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
        const cwd = cwd_buf[0..cwd_len];
        const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);
        const sesh = try socket.getSeshName(gpa, session_name);
        defer gpa.free(sesh);
        var daemon = Daemon{
            .io = io,
            .running = true,
            .cfg = &cfg,
            .alloc = alloc,
            .alloc = std.heap.c_allocator,
            .clients = clients,
            .session_name = sesh,
            .socket_path = undefined,
            .pid = undefined,
            .command = null,
            .cwd = cwd,
            .created_at = @intCast(std.time.timestamp()),
            .created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
            .is_task_mode = true,
            .leader_client_fd = null,
            .shell = shell_env,
        };
        daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
        daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch |err| switch (err) {
            error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
            error.OutOfMemory => return err,
        };
        std.log.info("socket path={s}", .{daemon.socket_path});
        try writeFile(&daemon, file_path);
    } else {
        return help();
        return help(io);
    }
}

......@@ -508,7 +521,7 @@ const Client = struct {
    write_buf: std.ArrayList(u8),

    pub fn deinit(self: *Client) void {
        posix.close(self.socket_fd);
        lib_posix.close(self.socket_fd);
        self.read_buf.deinit();
        self.write_buf.deinit(self.alloc);
    }

......@@ -524,18 +537,18 @@ const Cfg = struct {
    dir_mode: u32 = 0o750,
    log_mode: u32 = 0o640,

    pub fn init(alloc: std.mem.Allocator) !Cfg {
    pub fn init(alloc: std.mem.Allocator, io: std.Io) !Cfg {
        const socket_dir = try socketDir(alloc);
        errdefer alloc.free(socket_dir);
        const log_dir = try logDir(alloc);
        errdefer alloc.free(log_dir);

        const dir_mode = if (std.posix.getenv("ZMX_DIR_MODE")) |m|
        const dir_mode = if (lib_posix.getenv("ZMX_DIR_MODE")) |m|
            std.fmt.parseInt(u32, m, 8) catch 0o750
        else
            0o750;

        const log_mode = if (std.posix.getenv("ZMX_LOG_MODE")) |m|
        const log_mode = if (lib_posix.getenv("ZMX_LOG_MODE")) |m|
            std.fmt.parseInt(u32, m, 8) catch 0o640
        else
            0o640;

......@@ -547,18 +560,18 @@ const Cfg = struct {
            .log_mode = log_mode,
        };

        try cfg.mkdir();
        try cfg.mkdir(io);

        return cfg;
    }

    fn socketDir(alloc: std.mem.Allocator) ![]const u8 {
        const tmpdir = std.mem.trimRight(u8, posix.getenv("TMPDIR") orelse "/tmp", "/");
        const uid = posix.getuid();
        const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
        const uid = lib_posix.getuid();

        const socket_dir: []const u8 = if (posix.getenv("ZMX_DIR")) |zmxdir|
        const socket_dir: []const u8 = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
            try alloc.dupe(u8, zmxdir)
        else if (posix.getenv("XDG_RUNTIME_DIR")) |xdg_runtime|
        else if (lib_posix.getenv("XDG_RUNTIME_DIR")) |xdg_runtime|
            try std.fmt.allocPrint(alloc, "{s}/zmx", .{xdg_runtime})
        else
            try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });

......@@ -567,16 +580,16 @@ const Cfg = struct {
    }

    fn logDir(alloc: std.mem.Allocator) ![]const u8 {
        const log_dir = if (posix.getenv("ZMX_DIR")) |zmxdir|
        const log_dir = if (lib_posix.getenv("ZMX_DIR")) |zmxdir|
            try std.fmt.allocPrint(alloc, "{s}/logs", .{zmxdir})
        else if (posix.getenv("XDG_STATE_HOME")) |xdg_state_home|
        else if (lib_posix.getenv("XDG_STATE_HOME")) |xdg_state_home|
            try std.fmt.allocPrint(alloc, "{s}/zmx/logs", .{xdg_state_home})
        else if (posix.getenv("HOME")) |home_dir|
        else if (lib_posix.getenv("HOME")) |home_dir|
            try std.fmt.allocPrint(alloc, "{s}/.local/state/zmx/logs", .{home_dir})
        else fallback: {
            // This is the last resort: falling back to /tmp/$UID if HOME is unset.
            const tmpdir = std.mem.trimRight(u8, posix.getenv("TMPDIR") orelse "/tmp", "/");
            const uid = posix.getuid();
            const tmpdir = std.mem.trimEnd(u8, lib_posix.getenv("TMPDIR") orelse "/tmp", "/");
            const uid = lib_posix.getuid();
            break :fallback try std.fmt.allocPrint(alloc, "{s}/zmx-{d}", .{ tmpdir, uid });
        };

......@@ -588,16 +601,18 @@ const Cfg = struct {
        if (self.log_dir.len > 0) alloc.free(self.log_dir);
    }

    pub fn mkdir(self: *Cfg) !void {
        try mkdirAll(self.socket_dir, @intCast(self.dir_mode));
        try mkdirAll(self.log_dir, @intCast(self.dir_mode));
    pub fn mkdir(self: *Cfg, io: std.Io) !void {
        const sock_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
        try mkdirAll(io, self.socket_dir, sock_perms);
        const log_perms = std.Io.Dir.Permissions.fromMode(@intCast(self.dir_mode));
        try mkdirAll(io, self.log_dir, log_perms);
    }

    fn mkdirAll(sub_dir_path: []const u8, mode: posix.mode_t) !void {
        var it = try std.fs.path.componentIterator(sub_dir_path);
    fn mkdirAll(io: std.Io, sub_dir_path: []const u8, permissions: std.Io.Dir.Permissions) !void {
        var it = std.fs.path.componentIterator(sub_dir_path);
        var component = it.last() orelse return error.BadPathName;
        while (true) {
            posix.mkdirat(posix.AT.FDCWD, component.path, mode) catch |err| switch (err) {
            std.Io.Dir.createDirAbsolute(io, component.path, permissions) catch |err| switch (err) {
                error.PathAlreadyExists => {},
                error.FileNotFound => |e| {
                    component = it.previous() orelse return e;

......@@ -617,7 +632,7 @@ test "Cfg.init uses default modes when env vars are not set" {
    _ = cross.c.unsetenv("ZMX_DIR_MODE");
    _ = cross.c.unsetenv("ZMX_LOG_MODE");

    var cfg = try Cfg.init(alloc);
    var cfg = try Cfg.init(alloc, std.testing.io);
    defer cfg.deinit(alloc);

    try std.testing.expectEqual(@as(u32, 0o750), cfg.dir_mode);

......@@ -635,7 +650,7 @@ test "Cfg.init uses custom modes from env vars" {
        _ = cross.c.unsetenv("ZMX_LOG_MODE");
    }

    var cfg = try Cfg.init(alloc);
    var cfg = try Cfg.init(alloc, std.testing.io);
    defer cfg.deinit(alloc);

    try std.testing.expectEqual(@as(u32, 0o770), cfg.dir_mode);

......@@ -651,6 +666,7 @@ test "Cfg.init uses custom modes from env vars" {
///
/// Conceptually it's also much simpler to reason about.
const Daemon = struct {
    io: std.Io,
    cfg: *Cfg,
    alloc: std.mem.Allocator,
    clients: std.ArrayList(*Client),

......@@ -673,6 +689,7 @@ const Daemon = struct {
    task_ended_at: ?u64 = null, // timestamp when task exited
    pty_fd: i32 = -1, // set by daemonLoop so handleRun can probe the foreground process
    pty_write_buf: std.ArrayList(u8) = .empty,
    shell: []const u8 = "/bin/sh",

    const EnsureSessionResult = struct {
        created: bool,

......@@ -808,12 +825,14 @@ const Daemon = struct {
            for (cmd_args, 0..) |arg, i| {
                argv[i] = try alloc.dupeZ(u8, arg);
            }
            const err = std.posix.execvpeZ(argv[0].?, argv.ptr, std.c.environ);
            const err = lib_posix.execvpeZ(argv[0].?, argv.ptr, std.c.environ);
            std.log.err("execvpe failed: cmd={s} err={s}", .{ cmd_args[0], @errorName(err) });
            std.posix.exit(1);
            lib_posix.exit(1);
        }

        const shell: [:0]const u8 = if (self.is_task_mode) "bash" else util.detectShell();
        var buf: [256]u8 = undefined;
        const z = try std.fmt.bufPrintZ(&buf, "{s}", .{self.shell});
        const shell: [:0]const u8 = if (self.is_task_mode) "bash" else z;
        // Use "-shellname" as argv[0] to signal login shell (traditional method)
        const login_shell = try std.fmt.allocPrintSentinel(
            alloc,

......@@ -822,9 +841,9 @@ const Daemon = struct {
            0,
        );
        const argv = [_:null]?[*:0]const u8{ login_shell, null };
        const err = std.posix.execvpeZ(shell, &argv, std.c.environ);
        const err = lib_posix.execvpeZ(shell, &argv, std.c.environ);
        std.log.err("execvpe failed: shell={s} err={s}", .{ shell, @errorName(err) });
        std.posix.exit(1);
        lib_posix.exit(1);
    }

    /// spawnPty runs forkpty() and executes the shell or shell command the user provides.

......@@ -850,7 +869,7 @@ const Daemon = struct {
            // errdefers that delete the parent's socket file).
            execChild(self) catch |err| {
                std.log.err("child setup failed: {s}", .{@errorName(err)});
                std.posix.exit(1);
                lib_posix.exit(1);
            };
            unreachable; // execChild either execs or exits, never returns ok
        }

......@@ -859,8 +878,8 @@ const Daemon = struct {
        std.log.info("pty spawned session={s} pid={d}", .{ self.session_name, pid });

        // make pty non-blocking
        const flags = try posix.fcntl(master_fd, posix.F.GETFL, 0);
        _ = try posix.fcntl(master_fd, posix.F.SETFL, flags | O_NONBLOCK);
        const flags = try lib_posix.fcntl(master_fd, posix.F.GETFL, 0);
        _ = try lib_posix.fcntl(master_fd, posix.F.SETFL, flags | O_NONBLOCK);
        return master_fd;
    }

......@@ -868,15 +887,15 @@ const Daemon = struct {
    /// If not it creates one and spawns the daemon.
    fn ensureSession(self: *Daemon) !EnsureSessionResult {
        std.log.info("ensure session session={s}", .{self.session_name});
        var dir = try std.fs.openDirAbsolute(self.cfg.socket_dir, .{});
        defer dir.close();
        var dir = try std.Io.Dir.openDirAbsolute(self.io, self.cfg.socket_dir, .{});
        defer dir.close(self.io);

        const exists = try socket.sessionExists(dir, self.session_name);
        const exists = try socket.sessionExists(self.io, dir, self.session_name);
        var should_create = !exists;

        if (exists) {
            if (ipc.connectSession(self.socket_path)) |fd| {
                posix.close(fd);
                lib_posix.close(fd);
                if (self.command != null) {
                    std.log.warn(
                        "session already exists, ignoring command session={s}",

......@@ -886,7 +905,7 @@ const Daemon = struct {
            } else |err| switch (err) {
                // Daemon is definitively gone: safe to replace.
                error.ConnectionRefused => {
                    socket.cleanupStaleSocket(dir, self.session_name);
                    socket.cleanupStaleSocket(self.io, dir, self.session_name);
                    should_create = true;
                },
                // Connect failed for an unusual reason. The check is only to

......@@ -906,10 +925,10 @@ const Daemon = struct {
            const server_sock_fd = try socket.createSocket(self.socket_path);

            // creates the daemon
            const pid = try posix.fork();
            const pid = try lib_posix.fork();
            if (pid == 0) { // child (daemon)
                // becomes the session leader and detaches process from its controlling terminal
                _ = try posix.setsid();
                _ = try lib_posix.setsid();

                log_system.deinit();

......@@ -919,7 +938,7 @@ const Daemon = struct {
                // keyword) stays open for the daemon's lifetime, causing
                // the caller to hang waiting for EOF.
                {
                    const devnull = std.posix.open(
                    const devnull = lib_posix.open(
                        "/dev/null",
                        .{ .ACCMODE = .RDWR },
                        0,

......@@ -928,12 +947,12 @@ const Daemon = struct {
                        return err;
                    };
                    inline for (.{ posix.STDIN_FILENO, posix.STDOUT_FILENO, posix.STDERR_FILENO }) |fd| {
                        _ = posix.dup2(devnull, fd) catch |err| {
                        _ = lib_posix.dup2(devnull, fd) catch |err| {
                            std.log.warn("dup2 /dev/null -> {d}: {s}", .{ fd, @errorName(err) });
                            return err;
                        };
                    }
                    if (devnull > 2) posix.close(devnull);
                    if (devnull > 2) lib_posix.close(devnull);
                }

                // Close file descriptors inherited from the parent that the

......@@ -948,7 +967,7 @@ const Daemon = struct {
                // Skip server_sock_fd (needed for IPC) and dir.fd (needed to
                // delete the socket file on shutdown).
                {
                    const dir_fd = @as(i32, @intCast(dir.fd));
                    const dir_fd = @as(i32, @intCast(dir.handle));
                    var fd: i32 = 3;
                    while (fd < 64) : (fd += 1) {
                        if (fd == server_sock_fd or fd == dir_fd) continue;

......@@ -967,14 +986,15 @@ const Daemon = struct {
                    &.{ self.cfg.log_dir, session_log_name },
                );
                defer self.alloc.free(session_log_path);
                try log_system.init(self.alloc, session_log_path, self.cfg.log_mode);
                const log_mode = std.Io.File.Permissions.fromMode(self.cfg.log_mode);
                try log_system.init(self.alloc, self.io, session_log_path, log_mode);

                // If spawnPty fails, clean up here. Once it succeeds,
                // the inner block's defer takes ownership of cleanup to
                // avoid double-closing server_sock_fd on daemonLoop error.
                const pty_fd = self.spawnPty() catch |err| {
                    posix.close(server_sock_fd);
                    dir.deleteFile(self.session_name) catch {};
                    lib_posix.close(server_sock_fd);
                    dir.deleteFile(self.io, self.session_name) catch {};
                    return err;
                };

......@@ -983,23 +1003,23 @@ const Daemon = struct {
                    // 500ms SIGHUP->SIGKILL grace sleep. Otherwise a `zmx run`
                    // for the same name issued in that window will hang waiting
                    // for a connect.
                    posix.close(server_sock_fd);
                    lib_posix.close(server_sock_fd);
                    std.log.info("deleting socket file session={s}", .{self.session_name});
                    dir.deleteFile(self.session_name) catch |err| {
                    dir.deleteFile(self.io, self.session_name) catch |err| {
                        std.log.warn("failed to delete socket file err={s}", .{@errorName(err)});
                    };
                    self.handleKill();
                    self.deinit();
                    posix.close(pty_fd);
                    _ = posix.waitpid(self.pid, 0);
                    lib_posix.close(pty_fd);
                    _ = lib_posix.waitpid(self.pid, 0);
                }

                try daemonLoop(self, server_sock_fd, pty_fd);
                std.log.info("daemon loop shutdown", .{});
                return .{ .created = true, .is_daemon = true };
            }
            posix.close(server_sock_fd);
            std.Thread.sleep(10 * std.time.ns_per_ms);
            lib_posix.close(server_sock_fd);
            std.Io.sleep(self.io, std.Io.Duration.fromMilliseconds(10), .real) catch unreachable;
            return .{ .created = true, .is_daemon = false };
        }

......@@ -1204,7 +1224,7 @@ const Daemon = struct {
        posix.kill(-self.pid, posix.SIG.HUP) catch |err| {
            std.log.warn("failed to send SIGHUP to pty child err={s}", .{@errorName(err)});
        };
        std.Thread.sleep(500 * std.time.ns_per_ms);
        std.Io.sleep(self.io, std.Io.Duration.fromMilliseconds(500), .real) catch unreachable;
        posix.kill(-self.pid, posix.SIG.KILL) catch |err| {
            std.log.warn("failed to send SIGKILL to pty child err={s}", .{@errorName(err)});
        };

......@@ -1265,7 +1285,7 @@ const Daemon = struct {
        payload: []const u8,
    ) !void {
        const format: util.HistoryFormat = if (payload.len > 0)
            std.meta.intToEnum(util.HistoryFormat, payload[0]) catch .plain
            @enumFromInt(payload[0])
        else
            .plain;
        if (util.serializeTerminal(self.alloc, term, format)) |output| {

......@@ -1385,6 +1405,7 @@ test "send queues PTY input without changing leader" {
        .leader_client_fd = 42,
        .session_name = "test",
        .socket_path = "",
        .io = std.testing.io,
        .running = true,
        .pid = 0,
        .created_at = 0,

......@@ -1397,9 +1418,9 @@ test "send queues PTY input without changing leader" {
    try std.testing.expectEqualStrings("hello", daemon.pty_write_buf.items);
}

fn printVersion(cfg: *Cfg) !void {
fn printVersion(io: std.Io, cfg: *Cfg) !void {
    var buf: [256]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(io, &buf);
    try w.interface.print(
        "zmx\t\t{s}\nghostty_vt\t{s}\nsocket_dir\t{s}\nlog_dir\t\t{s}\n",
        .{ version, ghostty_version, cfg.socket_dir, cfg.log_dir },

......@@ -1407,15 +1428,15 @@ fn printVersion(cfg: *Cfg) !void {
    try w.interface.flush();
}

fn printCompletions(shell: completions.Shell) !void {
fn printCompletions(io: std.Io, shell: completions.Shell) !void {
    const script = shell.getCompletionScript();
    var buf: [8192]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(io, &buf);
    try w.interface.print("{s}\n", .{script});
    try w.interface.flush();
}

fn help() !void {
fn help(io: std.Io) !void {
    const help_text =
        \\zmx - session persistence for terminal processes
        \\

......@@ -1553,16 +1574,12 @@ fn help() !void {
        \\
    ;
    var buf: [8192]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(io, &buf);
    try w.interface.print(help_text, .{});
    try w.interface.flush();
}

fn tail(client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool) !u8 {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

fn tail(alloc: std.mem.Allocator, client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool) !u8 {
    var poll_fds = try std.ArrayList(posix.pollfd).initCapacity(alloc, 4);
    defer poll_fds.deinit(alloc);

......@@ -1625,7 +1642,7 @@ fn tail(client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool)
                    switch (msg.header.tag) {
                        .Ack => {
                            if (detached) {
                                _ = posix.write(posix.STDOUT_FILENO, "command sent!\n") catch |err| blk: {
                                _ = lib_posix.write(posix.STDOUT_FILENO, "command sent!\n") catch |err| blk: {
                                    if (err == error.WouldBlock) break :blk 0;
                                    return err;
                                };

......@@ -1687,7 +1704,7 @@ fn tail(client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool)
        if (task_complete_code) |exit_code| {
            // Flush any remaining output before returning
            flush_loop: while (stdout_buf.items.len > 0) {
                const n = posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| {
                const n = lib_posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| {
                    if (err == error.WouldBlock) break :flush_loop;
                    return err;
                };

......@@ -1697,7 +1714,7 @@ fn tail(client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool)
        }

        if (stdout_buf.items.len > 0) {
            const n = posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| blk: {
            const n = lib_posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| blk: {
                if (err == error.WouldBlock) break :blk 0;
                return err;
            };

......@@ -1715,17 +1732,13 @@ fn tail(client_socket_fds: std.ArrayList(i32), detached: bool, is_run_cmd: bool)
    }
}

fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

fn wait(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    var stdout_writer = std.Io.File.stdout().writer(io, &stdout_buffer);
    const stdout = &stdout_writer.interface;

    var stderr_buffer: [1024]u8 = undefined;
    var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
    var stderr_writer = std.Io.File.stderr().writer(io, &stderr_buffer);
    const stderr = &stderr_writer.interface;

    // Highest match count seen so far. Lets us distinguish "sessions haven't

......@@ -1735,11 +1748,11 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
    var zero_match_iters: u32 = 0;

    var agg_exit_code: u8 = 0;
    var last_print: i64 = 0;
    var last_print: i96 = 0;
    var prev_done: i32 = 0;
    while (true) {
        agg_exit_code = 0;
        var sessions = try util.get_session_entries(alloc, cfg.socket_dir);
        var sessions = try util.get_session_entries(alloc, io, cfg.socket_dir);
        var total: i32 = 0;
        var done: i32 = 0;

......@@ -1763,7 +1776,7 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
                // waiting". Count it as done+failed so wait terminates.
                try stderr.print(
                    "[{d}] task unreachable: {s} ({s})\n",
                    .{ std.time.timestamp(), session.name, session.error_name orelse "unknown" },
                    .{ std.Io.Timestamp.now(io, .real).nanoseconds, session.name, session.error_name orelse "unknown" },
                );
                try stderr.flush();
                agg_exit_code = 1;

......@@ -1771,7 +1784,7 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
                continue;
            }
            if (session.task_ended_at == 0) {
                const now = std.time.timestamp();
                const now = std.Io.Timestamp.now(io, .real).nanoseconds;
                if (now - last_print >= 5) {
                    try stdout.print(
                        "[{d}] waiting task={s}\n",

......@@ -1834,7 +1847,7 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
        }

        prev_done = done;
        std.Thread.sleep(1000 * std.time.ns_per_ms);
        std.Io.sleep(io, std.Io.Duration.fromMilliseconds(1000), .real) catch unreachable;
    }

    if (agg_exit_code == 0) {

......@@ -1844,7 +1857,7 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
    }
    try stdout.flush();

    const sessions = try util.get_session_entries(alloc, cfg.socket_dir);
    const sessions = try util.get_session_entries(alloc, io, cfg.socket_dir);
    for (sessions.items) |session| {
        var found = false;
        for (matchers.items) |m| {

......@@ -1866,7 +1879,7 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {

            // Fetch and print the last 20 lines of history for debugging
            const history_lines: usize = 20;
            const history_text = fetchHistory(alloc, cfg, session.name) catch null;
            const history_text = fetchHistory(alloc, io, cfg, session.name) catch null;
            if (history_text) |text| {
                defer alloc.free(text);
                try stdout.print("\nLast {d} lines of {s} history:\n", .{ history_lines, session.name });

......@@ -1897,15 +1910,11 @@ fn wait(cfg: *Cfg, matchers: std.ArrayList(SessionMatch)) !void {
    std.process.exit(agg_exit_code);
}

fn list(cfg: *Cfg, short: bool) !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

fn list(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, short: bool) !void {
    const current_session = socket.getSeshNameFromEnv();
    var buf: [4096]u8 = undefined;
    var stdout = std.fs.File.stdout().writer(&buf);
    var sessions = try util.get_session_entries(alloc, cfg.socket_dir);
    var stdout = std.Io.File.stdout().writer(io, &buf);
    var sessions = try util.get_session_entries(alloc, io, cfg.socket_dir);
    defer {
        for (sessions.items) |session| {
            session.deinit(alloc);

......@@ -1916,7 +1925,7 @@ fn list(cfg: *Cfg, short: bool) !void {
    if (sessions.items.len == 0) {
        if (short) return;
        var errbuf: [4096]u8 = undefined;
        var stderr = std.fs.File.stderr().writer(&errbuf);
        var stderr = std.Io.File.stderr().writer(io, &errbuf);
        try stderr.interface.print("no sessions found in {s}\n", .{cfg.socket_dir});
        try stderr.interface.flush();
        return;

......@@ -1936,10 +1945,7 @@ fn list(cfg: *Cfg, short: bool) !void {
    }
}

fn detachAll(cfg: *Cfg) !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();
fn detachAll(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg) !void {
    const session_name = socket.getSeshNameFromEnv();
    if (session_name.len == 0) {
        std.log.err("ZMX_SESSION env var not found: are you inside a zmx session?", .{});

......@@ -1947,45 +1953,41 @@ fn detachAll(cfg: *Cfg) !void {
    }
    std.log.info("detach all session={s}", .{session_name});

    var dir = try std.fs.openDirAbsolute(cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, cfg.socket_dir, .{});
    defer dir.close(io);

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);
    const fd = ipc.connectSession(socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(dir, session_name);
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(io, dir, session_name);
        return;
    };
    defer posix.close(fd);
    defer lib_posix.close(fd);
    ipc.send(fd, .DetachAll, "") catch |err| switch (err) {
        error.BrokenPipe, error.ConnectionResetByPeer => return,
        else => return err,
    };
}

fn kill(cfg: *Cfg, session_name: []const u8, force: bool) !void {
fn kill(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8, force: bool) !void {
    std.log.info("kill session={s}", .{session_name});
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    var dir = try std.fs.openDirAbsolute(cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, cfg.socket_dir, .{});
    defer dir.close(io);

    const exists = try socket.sessionExists(dir, session_name);
    const exists = try socket.sessionExists(io, dir, session_name);
    if (!exists) {
        var buf: [4096]u8 = undefined;
        var w = std.fs.File.stderr().writer(&buf);
        var w = std.Io.File.stderr().writer(io, &buf);
        w.interface.print("error: session \"{s}\" does not exist\n", .{session_name}) catch {};
        w.interface.flush() catch {};
        return error.SessionNotFound;

......@@ -1993,9 +1995,9 @@ fn kill(cfg: *Cfg, session_name: []const u8, force: bool) !void {
    const fd = ipc.connectSession(socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        var buf: [4096]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
        var w = std.Io.File.stdout().writer(io, &buf);
        if (force or err == error.ConnectionRefused) {
            socket.cleanupStaleSocket(dir, session_name);
            socket.cleanupStaleSocket(io, dir, session_name);
            w.interface.print("cleaned up stale session {s}\n", .{session_name}) catch {};
        } else {
            w.interface.print(

......@@ -2007,7 +2009,7 @@ fn kill(cfg: *Cfg, session_name: []const u8, force: bool) !void {
        return;
    };

    defer posix.close(fd);
    defer lib_posix.close(fd);
    ipc.send(fd, .Kill, "") catch |err| switch (err) {
        error.BrokenPipe, error.ConnectionResetByPeer => return,
        else => return err,

......@@ -2025,14 +2027,14 @@ fn kill(cfg: *Cfg, session_name: []const u8, force: bool) !void {
    }

    var buf: [100]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(io, &buf);
    try w.interface.print("killed session {s}\n", .{session_name});
    try w.interface.flush();
}

fn printLabelError(session_name: []const u8, err: anyerror) noreturn {
fn printLabelError(io: std.Io, session_name: []const u8, err: anyerror) noreturn {
    var buf: [4096]u8 = undefined;
    var w = std.fs.File.stderr().writer(&buf);
    var w = std.Io.File.stderr().writer(io, &buf);
    switch (err) {
        error.Timeout => w.interface.print(
            "error: session \"{s}\" does not support labels (daemon too old?)\n",

......@@ -2051,25 +2053,22 @@ fn printLabelError(session_name: []const u8, err: anyerror) noreturn {
    std.process.exit(1);
}

fn labelGet(cfg: *Cfg, session_name: []const u8, single_kv: []const u8) !void {
fn labelGet(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8, single_kv: []const u8) !void {
    std.log.info("label get session={s}", .{session_name});
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    const payload = ipc.roundTripForTag(alloc, socket_path, .LabelGet, "", .LabelData) catch |err| {
        printLabelError(session_name, err);
        printLabelError(io, session_name, err);
    };
    defer alloc.free(payload);

    var buf: [4096]u8 = undefined;
    var stdout = std.fs.File.stdout().writer(&buf);
    var stdout = std.Io.File.stdout().writer(io, &buf);
    if (single_kv.len == 0) {
        try stdout.interface.print("{s}", .{payload});
        try stdout.interface.flush();

......@@ -2081,17 +2080,14 @@ fn labelGet(cfg: *Cfg, session_name: []const u8, single_kv: []const u8) !void {
    try stdout.interface.flush();
}

fn labelSet(cfg: *Cfg, session_name: []const u8, labels: []const u8) !void {
fn labelSet(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8, labels: []const u8) !void {
    std.log.info("label set session={s}", .{session_name});
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    var kvs = label.LabelIterator.init(labels);
    while (kvs.next()) |kv| {
        label.assertLabel(kv.key, kv.value) catch |err| {
            var buf: [4096]u8 = undefined;
            var w = std.fs.File.stderr().writer(&buf);
            var w = std.Io.File.stderr().writer(io, &buf);
            const msg = "error: key-value kvs can only contain [a-z, A-Z, 0-9, -_.] characters";
            switch (err) {
                error.LabelKeyEmpty => {

......@@ -2113,30 +2109,27 @@ fn labelSet(cfg: *Cfg, session_name: []const u8, labels: []const u8) !void {
    }

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    _ = ipc.roundTripForTag(alloc, socket_path, .LabelSet, labels, .Ack) catch |err| {
        printLabelError(session_name, err);
        printLabelError(io, session_name, err);
    };
}

fn labelClear(cfg: *Cfg, session_name: []const u8) !void {
fn labelClear(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8) !void {
    std.log.info("label clear session={s}", .{session_name});
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    _ = ipc.roundTripForTag(alloc, socket_path, .LabelClear, "", .Ack) catch |err| {
        printLabelError(session_name, err);
        printLabelError(io, session_name, err);
    };
}

......@@ -2144,32 +2137,33 @@ fn labelClear(cfg: *Cfg, session_name: []const u8) !void {
/// string. Caller owns the returned memory and must free it.
fn fetchHistory(
    alloc: std.mem.Allocator,
    io: std.Io,
    cfg: *Cfg,
    session_name: []const u8,
) ![]const u8 {
    std.log.info("fetch history session={s}", .{session_name});
    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => {
            socket.printSessionNameTooLong(session_name, cfg.socket_dir);
            socket.printSessionNameTooLong(io, session_name, cfg.socket_dir);
            return error.NameTooLong;
        },
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    var dir = try std.fs.openDirAbsolute(cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, cfg.socket_dir, .{});
    defer dir.close(io);

    const exists = try socket.sessionExists(dir, session_name);
    const exists = try socket.sessionExists(io, dir, session_name);
    if (!exists) {
        return error.SessionNotFound;
    }

    const fd = ipc.connectSession(socket_path) catch |err| {
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(dir, session_name);
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(io, dir, session_name);
        return err;
    };
    defer posix.close(fd);
    defer lib_posix.close(fd);

    const format_byte: u8 = @intFromEnum(util.HistoryFormat.plain);
    const payload = [_]u8{format_byte};

......@@ -2205,35 +2199,32 @@ fn fetchHistory(
    return error.NoHistoryResponse;
}

fn history(cfg: *Cfg, session_name: []const u8, format: util.HistoryFormat) !void {
fn history(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8, format: util.HistoryFormat) !void {
    std.log.info("history session={s}", .{session_name});
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const alloc = gpa.allocator();

    const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(io, session_name, cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer alloc.free(socket_path);

    var dir = try std.fs.openDirAbsolute(cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, cfg.socket_dir, .{});
    defer dir.close(io);

    const exists = try socket.sessionExists(dir, session_name);
    const exists = try socket.sessionExists(io, dir, session_name);
    if (!exists) {
        var buf: [4096]u8 = undefined;
        var w = std.fs.File.stderr().writer(&buf);
        var w = std.Io.File.stderr().writer(io, &buf);
        w.interface.print("error: session \"{s}\" does not exist\n", .{session_name}) catch {};
        w.interface.flush() catch {};
        return error.SessionNotFound;
    }
    const fd = ipc.connectSession(socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(dir, session_name);
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(io, dir, session_name);
        return;
    };
    defer posix.close(fd);
    defer lib_posix.close(fd);

    const format_byte = [_]u8{@intFromEnum(format)};
    ipc.send(fd, .History, &format_byte) catch |err| switch (err) {

......@@ -2257,7 +2248,7 @@ fn history(cfg: *Cfg, session_name: []const u8, format: util.HistoryFormat) !voi

        while (sb.next()) |msg| {
            if (msg.header.tag == .History) {
                _ = posix.write(posix.STDOUT_FILENO, msg.payload) catch return;
                _ = lib_posix.write(posix.STDOUT_FILENO, msg.payload) catch return;
                return;
            }
        }

......@@ -2271,28 +2262,28 @@ fn switchSesh(daemon: *Daemon, current_sesh: []const u8) !void {
    std.log.info("switch session cur={s} next={s}", .{ current_sesh, next_session });

    const socket_path = socket.getSocketPath(daemon.alloc, daemon.cfg.socket_dir, current_sesh) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(current_sesh, daemon.cfg.socket_dir),
        error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, current_sesh, daemon.cfg.socket_dir),
        error.OutOfMemory => return err,
    };
    defer daemon.alloc.free(socket_path);

    var dir = try std.fs.openDirAbsolute(daemon.cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(daemon.io, daemon.cfg.socket_dir, .{});
    defer dir.close(daemon.io);

    const exists = try socket.sessionExists(dir, current_sesh);
    const exists = try socket.sessionExists(daemon.io, dir, current_sesh);
    if (!exists) {
        var buf: [4096]u8 = undefined;
        var w = std.fs.File.stderr().writer(&buf);
        var w = std.Io.File.stderr().writer(daemon.io, &buf);
        w.interface.print("error: session \"{s}\" does not exist\n", .{current_sesh}) catch {};
        w.interface.flush() catch {};
        return error.SessionNotFound;
    }
    const fd = ipc.connectSession(socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(dir, current_sesh);
        if (err == error.ConnectionRefused) socket.cleanupStaleSocket(daemon.io, dir, current_sesh);
        return;
    };
    defer posix.close(fd);
    defer lib_posix.close(fd);

    ipc.send(fd, .Switch, next_session) catch |err| switch (err) {
        error.BrokenPipe, error.ConnectionResetByPeer => return,

......@@ -2331,7 +2322,7 @@ fn attach(daemon: *Daemon) !void {
        }
        // Reset terminal modes on detach
        const restore_seq = "\x1bc";
        _ = posix.write(posix.STDOUT_FILENO, restore_seq) catch {};
        _ = lib_posix.write(posix.STDOUT_FILENO, restore_seq) catch {};
    }

    if (stdin_is_tty) {

......@@ -2355,7 +2346,7 @@ fn attach(daemon: *Daemon) !void {
    // Clear screen before attaching. This provides a clean slate before
    // the session restore.
    const clear_seq = "\x1b[2J\x1b[H";
    _ = try posix.write(posix.STDOUT_FILENO, clear_seq);
    _ = try lib_posix.write(posix.STDOUT_FILENO, clear_seq);

    const looper = try clientLoop(client_sock);
    switch (looper.kind) {

......@@ -2363,13 +2354,15 @@ fn attach(daemon: *Daemon) !void {
        .switch_session => {
            if (looper.session_name) |session_name| {
                var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
                const cwd = std.posix.getcwd(&cwd_buf) catch "";
                const cwd_len = std.process.currentPath(daemon.io, &cwd_buf) catch 0;
                const cwd = cwd_buf[0..cwd_len];
                const target_path = socket.getSocketPath(
                    daemon.alloc,
                    daemon.cfg.socket_dir,
                    session_name,
                ) catch |err| switch (err) {
                    error.NameTooLong => return socket.printSessionNameTooLong(
                        daemon.io,
                        session_name,
                        daemon.cfg.socket_dir,
                    ),

......@@ -2378,6 +2371,7 @@ fn attach(daemon: *Daemon) !void {

                const clients = try std.ArrayList(*Client).initCapacity(daemon.alloc, 10);
                var target_daemon = Daemon{
                    .io = daemon.io,
                    .running = true,
                    .cfg = daemon.cfg,
                    .alloc = daemon.alloc,

......@@ -2386,7 +2380,7 @@ fn attach(daemon: *Daemon) !void {
                    .socket_path = target_path,
                    .pid = undefined,
                    .cwd = cwd,
                    .created_at = @intCast(std.time.timestamp()),
                    .created_at = @intCast(std.Io.Timestamp.now(daemon.io, .real).nanoseconds),
                    .leader_client_fd = null,
                };
                return attach(&target_daemon);

......@@ -2397,7 +2391,7 @@ fn attach(daemon: *Daemon) !void {

fn writeFile(daemon: *Daemon, file_path: []const u8) !void {
    var buf: [4096]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(daemon.io, &buf);
    const sesh_result = try daemon.ensureSession();
    if (sesh_result.is_daemon) return;

......@@ -2425,18 +2419,19 @@ fn writeFile(daemon: *Daemon, file_path: []const u8) !void {
        daemon.session_name,
    ) catch |err| switch (err) {
        error.NameTooLong => return socket.printSessionNameTooLong(
            daemon.io,
            daemon.session_name,
            daemon.cfg.socket_dir,
        ),
        error.OutOfMemory => return err,
    };
    var dir = try std.fs.openDirAbsolute(daemon.cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(daemon.io, daemon.cfg.socket_dir, .{});
    defer dir.close(daemon.io);

    const result = ipc.probeSession(daemon.alloc, socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        if (err == error.ConnectionRefused) {
            socket.cleanupStaleSocket(dir, daemon.session_name);
            socket.cleanupStaleSocket(daemon.io, dir, daemon.session_name);
            w.interface.print("cleaned up stale session {s}\n", .{daemon.session_name}) catch {};
        } else {
            w.interface.print(

......@@ -2483,11 +2478,10 @@ fn writeFile(daemon: *Daemon, file_path: []const u8) !void {
    return error.NoAckReceived;
}

fn send(cfg: *Cfg, session_name: []const u8, socket_path: []const u8, text_parts: [][]const u8, tag: ipc.Tag) !void {
fn send(alloc: std.mem.Allocator, io: std.Io, cfg: *Cfg, session_name: []const u8, socket_path: []const u8, text_parts: [][]const u8, tag: ipc.Tag) !void {
    std.log.info("send session={s}", .{session_name});
    const alloc = std.heap.c_allocator;
    var buf: [4096]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(io, &buf);

    var payload = std.ArrayList(u8).empty;
    defer payload.deinit(alloc);

......@@ -2499,16 +2493,16 @@ fn send(cfg: *Cfg, session_name: []const u8, socket_path: []const u8, text_parts
        }
    } else {
        // Read from stdin when no text arguments provided.
        const stdin_fd = posix.STDIN_FILENO;
        if (!std.posix.isatty(stdin_fd)) {
        const stdin_file = std.Io.File.stdin();
        defer stdin_file.close(io);
        var stdin_buf: [4096]u8 = undefined;
        var reader = stdin_file.reader(io, &stdin_buf);
        if (!try stdin_file.isTty(io)) {
            while (true) {
                var tmp: [4096]u8 = undefined;
                const n = posix.read(stdin_fd, &tmp) catch |err| {
                    if (err == error.WouldBlock) break;
                    return err;
                };
                if (n == 0) break;
                try payload.appendSlice(alloc, tmp[0..n]);
                var dest: [1024]u8 = undefined;
                const n = try reader.interface.readSliceShort(&dest);
                if (n == 0) break; // EOF
                try payload.appendSlice(alloc, dest[0..n]);
            }
            // Strip trailing newline from piped input; the caller is
            // responsible for including \r when submission is desired.

......@@ -2521,13 +2515,13 @@ fn send(cfg: *Cfg, session_name: []const u8, socket_path: []const u8, text_parts

    if (payload.items.len == 0) return error.TextRequired;

    var dir = try std.fs.openDirAbsolute(cfg.socket_dir, .{});
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, cfg.socket_dir, .{});
    defer dir.close(io);

    const probe_result = ipc.probeSession(alloc, socket_path) catch |err| {
        std.log.err("session unresponsive: {s}", .{@errorName(err)});
        if (err == error.ConnectionRefused) {
            socket.cleanupStaleSocket(dir, session_name);
            socket.cleanupStaleSocket(io, dir, session_name);
            try w.interface.print("cleaned up stale session {s}\n", .{session_name});
        } else {
            try w.interface.print(

......@@ -2549,7 +2543,7 @@ fn send(cfg: *Cfg, session_name: []const u8, socket_path: []const u8, text_parts
fn run(daemon: *Daemon, detached: bool, command_args: [][]const u8) !void {
    const alloc = daemon.alloc;
    var buf: [4096]u8 = undefined;
    var w = std.fs.File.stdout().writer(&buf);
    var w = std.Io.File.stdout().writer(daemon.io, &buf);

    var cmd_to_send: ?[]const u8 = null;
    var allocated_cmd: ?[]u8 = null;

......@@ -2587,19 +2581,19 @@ fn run(daemon: *Daemon, detached: bool, command_args: [][]const u8) !void {
        cmd_to_send = try cmd_list.toOwnedSlice(alloc);
        allocated_cmd = @constCast(cmd_to_send.?);
    } else {
        const stdin_fd = posix.STDIN_FILENO;
        if (!std.posix.isatty(stdin_fd)) {
            var stdin_buf = try std.ArrayList(u8).initCapacity(alloc, 4096);
            defer stdin_buf.deinit(alloc);

        // Read from stdin when no text arguments provided.
        const stdin_file = std.Io.File.stdin();
        defer stdin_file.close(daemon.io);
        var stdin_buf = try std.ArrayList(u8).initCapacity(alloc, 4096);
        defer stdin_buf.deinit(alloc);
        var stdbuf: [4096]u8 = undefined;
        var reader = stdin_file.reader(daemon.io, &stdbuf);
        if (!try stdin_file.isTty(daemon.io)) {
            while (true) {
                var tmp: [4096]u8 = undefined;
                const n = posix.read(stdin_fd, &tmp) catch |err| {
                    if (err == error.WouldBlock) break;
                    return err;
                };
                if (n == 0) break;
                try stdin_buf.appendSlice(alloc, tmp[0..n]);
                var dest: [1024]u8 = undefined;
                const n = try reader.interface.readSliceShort(&dest);
                if (n == 0) break; // EOF
                try stdin_buf.appendSlice(alloc, dest[0..n]);
            }

            if (stdin_buf.items.len > 0) {

......@@ -2615,6 +2609,35 @@ fn run(daemon: *Daemon, detached: bool, command_args: [][]const u8) !void {
                allocated_cmd = @constCast(cmd_to_send.?);
            }
        }

        // const stdin_fd = posix.STDIN_FILENO;
        // if (!lib_posix.isatty(stdin_fd)) {
        //     var stdin_buf = try std.ArrayList(u8).initCapacity(alloc, 4096);
        //     defer stdin_buf.deinit(alloc);

        //     while (true) {
        //         var tmp: [4096]u8 = undefined;
        //         const n = posix.read(stdin_fd, &tmp) catch |err| {
        //             if (err == error.WouldBlock) break;
        //             return err;
        //         };
        //         if (n == 0) break;
        //         try stdin_buf.appendSlice(alloc, tmp[0..n]);
        //     }

        //     if (stdin_buf.items.len > 0) {
        //         // Normalize any trailing newline to CR so readline (raw mode)
        //         // accepts each line.
        //         if (stdin_buf.items[stdin_buf.items.len - 1] == '\n') {
        //             stdin_buf.items[stdin_buf.items.len - 1] = '\r';
        //         } else {
        //             try stdin_buf.append(alloc, '\r');
        //         }

        //         cmd_to_send = try alloc.dupe(u8, stdin_buf.items);
        //         allocated_cmd = @constCast(cmd_to_send.?);
        //     }
        // }
    }

    if (cmd_to_send == null) {

......@@ -2625,7 +2648,7 @@ fn run(daemon: *Daemon, detached: bool, command_args: [][]const u8) !void {
        std.log.err("session not ready: {s}", .{@errorName(err)});
        return error.SessionNotReady;
    };
    defer posix.close(client_sock);
    defer lib_posix.close(client_sock);

    var fds = try std.ArrayList(i32).initCapacity(alloc, 1);
    defer fds.deinit(alloc);

......@@ -2636,8 +2659,8 @@ fn run(daemon: *Daemon, detached: bool, command_args: [][]const u8) !void {
        else => return err,
    };

    const exit_code = try tail(fds, detached, true);
    posix.exit(exit_code);
    const exit_code = try tail(daemon.alloc, fds, detached, true);
    lib_posix.exit(exit_code);
}

const ClientResult = struct {

......@@ -2654,15 +2677,15 @@ fn clientLoop(client_sock_fd: i32) !ClientResult {
    std.log.info("client loop fd={d}", .{client_sock_fd});
    // use c_allocator to avoid "reached unreachable code" panic in DebugAllocator when forking
    const alloc = std.heap.c_allocator;
    defer posix.close(client_sock_fd);
    defer lib_posix.close(client_sock_fd);

    try openSignalPipe();
    installWakeHandler(posix.SIG.WINCH);
    installWakeHandler(@intFromEnum(posix.SIG.WINCH));

    // Make socket non-blocking to avoid blocking on writes
    var sock_flags = try posix.fcntl(client_sock_fd, posix.F.GETFL, 0);
    var sock_flags = try lib_posix.fcntl(client_sock_fd, posix.F.GETFL, 0);
    sock_flags |= O_NONBLOCK;
    _ = try posix.fcntl(client_sock_fd, posix.F.SETFL, sock_flags);
    _ = try lib_posix.fcntl(client_sock_fd, posix.F.SETFL, sock_flags);

    // Buffer for outgoing socket writes
    var sock_write_buf = try std.ArrayList(u8).initCapacity(alloc, 4096);

......@@ -2686,9 +2709,9 @@ fn clientLoop(client_sock_fd: i32) !ClientResult {
    // Make stdin non-blocking. O_NONBLOCK is set on the open file description,
    // which is shared with the parent shell; restore on exit to avoid
    // corrupting the parent's stdin.
    const stdin_orig_flags = try posix.fcntl(stdin_fd, posix.F.GETFL, 0);
    _ = try posix.fcntl(stdin_fd, posix.F.SETFL, stdin_orig_flags | O_NONBLOCK);
    defer _ = posix.fcntl(stdin_fd, posix.F.SETFL, stdin_orig_flags) catch {};
    const stdin_orig_flags = try lib_posix.fcntl(stdin_fd, posix.F.GETFL, 0);
    _ = try lib_posix.fcntl(stdin_fd, posix.F.SETFL, stdin_orig_flags | O_NONBLOCK);
    defer _ = lib_posix.fcntl(stdin_fd, posix.F.SETFL, stdin_orig_flags) catch {};

    while (true) {
        poll_fds.clearRetainingCapacity();

......@@ -2800,7 +2823,7 @@ fn clientLoop(client_sock_fd: i32) !ClientResult {
        // Handle socket write (flush buffered messages to daemon)
        if (poll_fds.items[1].revents & posix.POLL.OUT != 0) {
            if (sock_write_buf.items.len > 0) {
                const n = posix.write(client_sock_fd, sock_write_buf.items) catch |err| blk: {
                const n = lib_posix.write(client_sock_fd, sock_write_buf.items) catch |err| blk: {
                    if (err == error.WouldBlock) break :blk 0;
                    if (err == error.ConnectionResetByPeer or err == error.BrokenPipe) {
                        std.log.info("connection reset or broken pipe", .{});

......@@ -2815,7 +2838,7 @@ fn clientLoop(client_sock_fd: i32) !ClientResult {
        }

        if (stdout_buf.items.len > 0) {
            const n = posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| blk: {
            const n = lib_posix.write(posix.STDOUT_FILENO, stdout_buf.items) catch |err| blk: {
                if (err == error.WouldBlock) break :blk 0;
                return err;
            };

......@@ -2837,12 +2860,12 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {
    std.log.info("daemon started session={s} pty_fd={d}", .{ daemon.session_name, pty_fd });
    daemon.pty_fd = pty_fd;
    try openSignalPipe();
    installWakeHandler(posix.SIG.TERM);
    installWakeHandler(@intFromEnum(lib_posix.SIG.TERM));
    var poll_fds = try std.ArrayList(posix.pollfd).initCapacity(daemon.alloc, 8);
    defer poll_fds.deinit(daemon.alloc);

    const init_size = ipc.getTerminalSize(pty_fd);
    var term = try ghostty_vt.Terminal.init(daemon.alloc, .{
    var term = try ghostty_vt.Terminal.init(daemon.io, daemon.alloc, .{
        .cols = init_size.cols,
        .rows = init_size.rows,
        .max_scrollback = daemon.cfg.max_scrollback,

......@@ -2905,7 +2928,7 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {
            std.log.err("server socket error revents={d}", .{poll_fds.items[0].revents});
            break :daemon_loop;
        } else if (poll_fds.items[0].revents & posix.POLL.IN != 0) {
            const client_fd = try posix.accept(
            const client_fd = try lib_posix.accept(
                server_sock_fd,
                null,
                null,

......@@ -2979,7 +3002,7 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {

                        if (util.findTaskExitMarker(scan_buf[0..scan_len])) |exit_code| {
                            daemon.task_exit_code = exit_code;
                            daemon.task_ended_at = @intCast(std.time.timestamp());
                            daemon.task_ended_at = @intCast(std.Io.Timestamp.now(daemon.io, .real).nanoseconds);

                            std.log.info("task completed exit_code={d}", .{exit_code});

......@@ -3018,7 +3041,7 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {

        if (poll_fds.items[1].revents & posix.POLL.OUT != 0) {
            while (daemon.pty_write_buf.items.len > 0) {
                const n = posix.write(pty_fd, daemon.pty_write_buf.items) catch |err| {
                const n = lib_posix.write(pty_fd, daemon.pty_write_buf.items) catch |err| {
                    if (err != error.WouldBlock) {
                        std.log.warn("pty write failed: {s}", .{@errorName(err)});
                        daemon.pty_write_buf.clearRetainingCapacity();

......@@ -3102,7 +3125,7 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {

            if (revents & posix.POLL.OUT != 0) {
                // Flush pending output buffers
                const n = posix.write(client.socket_fd, client.write_buf.items) catch |err| blk: {
                const n = lib_posix.write(client.socket_fd, client.write_buf.items) catch |err| blk: {
                    if (err == error.WouldBlock) break :blk 0;
                    // Error on write, close client
                    const last = daemon.closeClient(client, i, false);

......@@ -3127,7 +3150,7 @@ fn daemonLoop(daemon: *Daemon, server_sock_fd: i32, pty_fd: i32) !void {
    }
}

fn wakeSignalPipe(_: i32, _: *const posix.siginfo_t, _: ?*anyopaque) callconv(.c) void {
fn wakeSignalPipe(_: std.os.linux.SIG, _: *const posix.siginfo_t, _: ?*anyopaque) callconv(.c) void {
    const saved = std.c._errno().*;
    _ = std.c.write(sig_pipe[1], "x", 1);
    std.c._errno().* = saved;

......@@ -3142,7 +3165,7 @@ fn installWakeHandler(sig: u6) void {
        .mask = posix.sigemptyset(),
        .flags = posix.SA.SIGINFO,
    };
    posix.sigaction(sig, &act, null);
    posix.sigaction(@as(posix.SIG, @enumFromInt(sig)), &act, null);
}

fn ignoreSigpipe() void {

A src/posix.zig

+1170, -0

......@@ -0,0 +1,1170 @@
const builtin = @import("builtin");
const std = @import("std");
const maxInt = std.math.maxInt;
const assert = std.debug.assert;
const mem = std.mem;
const native_os = builtin.os.tag;
const use_libc = builtin.link_libc;
const linux = std.os.linux;

/// A libc-compatible API layer.
const system = if (use_libc)
    std.c
else switch (native_os) {
    .linux => linux,
    .plan9 => std.os.plan9,
    else => struct {
        pub const ucontext_t = void;
        pub const pid_t = void;
        pub const pollfd = void;
        pub const fd_t = void;
        pub const uid_t = void;
        pub const gid_t = void;
    },
};

pub const SIG = system.SIG;
const E = system.E;
const PATH_MAX = system.PATH_MAX;
const pid_t = system.pid_t;
const AT = system.AT;
const lfs64_abi = native_os == .linux and builtin.link_libc and (builtin.abi.isGnu() or builtin.abi.isAndroid());
const uid_t = system.uid_t;
const fd_t = system.fd_t;
const mode_t = system.mode_t;
const socket_t = fd_t;
const SOCK = system.SOCK;
const F = system.F;
const O = system.O;
const AF = system.AF;
const FD_CLOEXEC = system.FD_CLOEXEC;
const sockaddr = system.sockaddr;
pub const socklen_t = system.socklen_t;

pub fn getuid() uid_t {
    return system.getuid();
}

/// Get an environment variable.
/// See also `getenvZ`.
pub fn getenv(key: []const u8) ?[:0]const u8 {
    if (mem.indexOfScalar(u8, key, '=') != null) {
        return null;
    }
    if (builtin.link_libc) {
        var ptr = std.c.environ;
        while (ptr[0]) |line| : (ptr += 1) {
            var line_i: usize = 0;
            while (line[line_i] != 0) : (line_i += 1) {
                if (line_i == key.len) break;
                if (line[line_i] != key[line_i]) break;
            }
            if ((line_i != key.len) or (line[line_i] != '=')) continue;

            return mem.sliceTo(line + line_i + 1, 0);
        }
        return null;
    }
    // The simplified start logic doesn't populate environ.
    if (std.start.simplified_logic) return null;
    // TODO see https://github.com/ziglang/zig/issues/4524
    for (std.os.environ) |ptr| {
        var line_i: usize = 0;
        while (ptr[line_i] != 0) : (line_i += 1) {
            if (line_i == key.len) break;
            if (ptr[line_i] != key[line_i]) break;
        }
        if ((line_i != key.len) or (ptr[line_i] != '=')) continue;

        return mem.sliceTo(ptr + line_i + 1, 0);
    }
    return null;
}

const UnexpectedError = error{
    /// The Operating System returned an undocumented error code.
    ///
    /// This error is in theory not possible, but it would be better
    /// to handle this error than to invoke undefined behavior.
    ///
    /// When this error code is observed, it usually means the Zig Standard
    /// Library needs a small patch to add the error code to the error set for
    /// the respective function.
    Unexpected,
};

const SocketError = error{
    /// Permission to create a socket of the specified type and/or
    /// pro‐tocol is denied.
    AccessDenied,

    /// The implementation does not support the specified address family.
    AddressFamilyNotSupported,

    /// Unknown protocol, or protocol family not available.
    ProtocolFamilyNotAvailable,

    /// The per-process limit on the number of open file descriptors has been reached.
    ProcessFdQuotaExceeded,

    /// The system-wide limit on the total number of open files has been reached.
    SystemFdQuotaExceeded,

    /// Insufficient memory is available. The socket cannot be created until sufficient
    /// resources are freed.
    SystemResources,

    /// The protocol type or the specified protocol is not supported within this domain.
    ProtocolNotSupported,

    /// The socket type is not supported by the protocol.
    SocketTypeNotSupported,
} || UnexpectedError;

pub fn socket(domain: u32, socket_type: u32, protocol: u32) SocketError!socket_t {
    const have_sock_flags = !builtin.target.os.tag.isDarwin() and native_os != .haiku;
    const filtered_sock_type = if (!have_sock_flags)
        socket_type & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC)
    else
        socket_type;
    const rc = system.socket(domain, filtered_sock_type, protocol);
    switch (errno(rc)) {
        .SUCCESS => {
            const fd: fd_t = @intCast(rc);
            errdefer close(fd);
            if (!have_sock_flags) {
                try setSockFlags(fd, socket_type);
            }
            return fd;
        },
        .ACCES => return error.AccessDenied,
        .AFNOSUPPORT => return error.AddressFamilyNotSupported,
        .INVAL => return error.ProtocolFamilyNotAvailable,
        .MFILE => return error.ProcessFdQuotaExceeded,
        .NFILE => return error.SystemFdQuotaExceeded,
        .NOBUFS => return error.SystemResources,
        .NOMEM => return error.SystemResources,
        .PROTONOSUPPORT => return error.ProtocolNotSupported,
        .PROTOTYPE => return error.SocketTypeNotSupported,
        else => |err| return unexpectedErrno(err),
    }
}

pub fn close(fd: fd_t) void {
    return std.Io.Threaded.closeFd(fd);
    // switch (errno(system.close(fd))) {
    //     .BADF => unreachable, // Always a race condition.
    //     .SUCCESS, .INTR => return, // This is still a success. See https://github.com/ziglang/zig/issues/2425
    //     else => return,
    // }
}

const ConnectError = error{
    /// For UNIX domain sockets, which are identified by pathname: Write permission is denied on  the  socket
    /// file,  or  search  permission  is  denied  for  one of the directories in the path prefix.
    /// or
    /// The user tried to connect to a broadcast address without having the socket broadcast flag enabled  or
    /// the connection request failed because of a local firewall rule.
    AccessDenied,

    /// See AccessDenied
    PermissionDenied,

    /// Local address is already in use.
    AddressInUse,

    /// (Internet  domain  sockets)  The  socket  referred  to  by sockfd had not previously been bound to an
    /// address and, upon attempting to bind it to an ephemeral port, it was determined that all port numbers
    /// in    the    ephemeral    port    range    are   currently   in   use.    See   the   discussion   of
    /// /proc/sys/net/ipv4/ip_local_port_range in ip(7).
    AddressNotAvailable,

    /// The passed address didn't have the correct address family in its sa_family field.
    AddressFamilyNotSupported,

    /// Insufficient entries in the routing cache.
    SystemResources,

    /// A connect() on a stream socket found no one listening on the remote address.
    ConnectionRefused,

    /// Network is unreachable.
    NetworkUnreachable,

    /// Timeout  while  attempting  connection.   The server may be too busy to accept new connections.  Note
    /// that for IP sockets the timeout may be very long when syncookies are enabled on the server.
    ConnectionTimedOut,

    /// This error occurs when no global event loop is configured,
    /// and connecting to the socket would block.
    WouldBlock,

    /// The given path for the unix socket does not exist.
    FileNotFound,

    /// Connection was reset by peer before connect could complete.
    ConnectionResetByPeer,

    /// Socket is non-blocking and already has a pending connection in progress.
    ConnectionPending,
} || UnexpectedError;

/// Initiate a connection on a socket.
/// If `sockfd` is opened in non blocking mode, the function will
/// return error.WouldBlock when EAGAIN or EINPROGRESS is received.
pub fn connect(sock: socket_t, sock_addr: *const sockaddr, len: socklen_t) ConnectError!void {
    while (true) {
        switch (errno(system.connect(sock, sock_addr, len))) {
            .SUCCESS => return,
            .ACCES => return error.AccessDenied,
            .PERM => return error.PermissionDenied,
            .ADDRINUSE => return error.AddressInUse,
            .ADDRNOTAVAIL => return error.AddressNotAvailable,
            .AFNOSUPPORT => return error.AddressFamilyNotSupported,
            .AGAIN, .INPROGRESS => return error.WouldBlock,
            .ALREADY => return error.ConnectionPending,
            .BADF => unreachable, // sockfd is not a valid open file descriptor.
            .CONNREFUSED => return error.ConnectionRefused,
            .CONNRESET => return error.ConnectionResetByPeer,
            .FAULT => unreachable, // The socket structure address is outside the user's address space.
            .INTR => continue,
            .ISCONN => unreachable, // The socket is already connected.
            .HOSTUNREACH => return error.NetworkUnreachable,
            .NETUNREACH => return error.NetworkUnreachable,
            .NOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
            .PROTOTYPE => unreachable, // The socket type does not support the requested communications protocol.
            .TIMEDOUT => return error.ConnectionTimedOut,
            .NOENT => return error.FileNotFound, // Returned when socket is AF.UNIX and the given path does not exist.
            .CONNABORTED => unreachable, // Tried to reuse socket that previously received error.ConnectionRefused.
            else => |err| return unexpectedErrno(err),
        }
    }
}

const BindError = error{
    /// The address is protected, and the user is not the superuser.
    /// For UNIX domain sockets: Search permission is denied on  a  component
    /// of  the  path  prefix.
    AccessDenied,

    /// The given address is already in use, or in the case of Internet domain sockets,
    /// The  port number was specified as zero in the socket
    /// address structure, but, upon attempting to bind to  an  ephemeral  port,  it  was
    /// determined  that  all  port  numbers in the ephemeral port range are currently in
    /// use.  See the discussion of /proc/sys/net/ipv4/ip_local_port_range ip(7).
    AddressInUse,

    /// A nonexistent interface was requested or the requested address was not local.
    AddressNotAvailable,

    /// The address is not valid for the address family of socket.
    AddressFamilyNotSupported,

    /// Too many symbolic links were encountered in resolving addr.
    SymLinkLoop,

    /// addr is too long.
    NameTooLong,

    /// A component in the directory prefix of the socket pathname does not exist.
    FileNotFound,

    /// Insufficient kernel memory was available.
    SystemResources,

    /// A component of the path prefix is not a directory.
    NotDir,

    /// The socket inode would reside on a read-only filesystem.
    ReadOnlyFileSystem,

    /// The network subsystem has failed.
    NetworkSubsystemFailed,

    FileDescriptorNotASocket,

    AlreadyBound,
} || UnexpectedError;

/// addr is `*const T` where T is one of the sockaddr
pub fn bind(sock: socket_t, addr: *const sockaddr, len: socklen_t) BindError!void {
    const rc = system.bind(sock, addr, len);
    switch (errno(rc)) {
        .SUCCESS => return,
        .ACCES, .PERM => return error.AccessDenied,
        .ADDRINUSE => return error.AddressInUse,
        .BADF => unreachable, // always a race condition if this error is returned
        .INVAL => unreachable, // invalid parameters
        .NOTSOCK => unreachable, // invalid `sockfd`
        .AFNOSUPPORT => return error.AddressFamilyNotSupported,
        .ADDRNOTAVAIL => return error.AddressNotAvailable,
        .FAULT => unreachable, // invalid `addr` pointer
        .LOOP => return error.SymLinkLoop,
        .NAMETOOLONG => return error.NameTooLong,
        .NOENT => return error.FileNotFound,
        .NOMEM => return error.SystemResources,
        .NOTDIR => return error.NotDir,
        .ROFS => return error.ReadOnlyFileSystem,
        else => |err| return unexpectedErrno(err),
    }
}

const ListenError = error{
    /// Another socket is already listening on the same port.
    /// For Internet domain sockets, the  socket referred to by sockfd had not previously
    /// been bound to an address and, upon attempting to bind it to an ephemeral port, it
    /// was determined that all port numbers in the ephemeral port range are currently in
    /// use.  See the discussion of /proc/sys/net/ipv4/ip_local_port_range in ip(7).
    AddressInUse,

    /// The file descriptor sockfd does not refer to a socket.
    FileDescriptorNotASocket,

    /// The socket is not of a type that supports the listen() operation.
    OperationNotSupported,

    /// The network subsystem has failed.
    NetworkSubsystemFailed,

    /// Ran out of system resources
    /// On Windows it can either run out of socket descriptors or buffer space
    SystemResources,

    /// Already connected
    AlreadyConnected,

    /// Socket has not been bound yet
    SocketNotBound,
} || UnexpectedError;

pub fn listen(sock: socket_t, backlog: u31) ListenError!void {
    const rc = system.listen(sock, backlog);
    switch (errno(rc)) {
        .SUCCESS => return,
        .ADDRINUSE => return error.AddressInUse,
        .BADF => unreachable,
        .NOTSOCK => return error.FileDescriptorNotASocket,
        .OPNOTSUPP => return error.OperationNotSupported,
        else => |err| return unexpectedErrno(err),
    }
}

/// Obtains errno from the return value of a system function call.
///
/// For some systems this will obtain the value directly from the syscall return value;
/// for others it will use a thread-local errno variable. Therefore, this
/// function only returns a well-defined value when it is called directly after
/// the system function call whose errno value is intended to be observed.
fn errno(rc: anytype) E {
    if (use_libc) {
        return if (rc == -1) @enumFromInt(std.c._errno().*) else .SUCCESS;
    }
    const signed: isize = @bitCast(rc);
    const int = if (signed > -4096 and signed < 0) -signed else 0;
    return @enumFromInt(int);
}

fn setSockFlags(sock: socket_t, flags: u32) !void {
    if ((flags & SOCK.CLOEXEC) != 0) {
        var fd_flags = fcntl(sock, F.GETFD, 0) catch |err| switch (err) {
            error.FileBusy => unreachable,
            error.Locked => unreachable,
            error.PermissionDenied => unreachable,
            error.DeadLock => unreachable,
            error.LockedRegionLimitExceeded => unreachable,
            else => |e| return e,
        };
        fd_flags |= FD_CLOEXEC;
        _ = fcntl(sock, F.SETFD, fd_flags) catch |err| switch (err) {
            error.FileBusy => unreachable,
            error.Locked => unreachable,
            error.PermissionDenied => unreachable,
            error.DeadLock => unreachable,
            error.LockedRegionLimitExceeded => unreachable,
            else => |e| return e,
        };
    }
    if ((flags & SOCK.NONBLOCK) != 0) {
        var fl_flags = fcntl(sock, F.GETFL, 0) catch |err| switch (err) {
            error.FileBusy => unreachable,
            error.Locked => unreachable,
            error.PermissionDenied => unreachable,
            error.DeadLock => unreachable,
            error.LockedRegionLimitExceeded => unreachable,
            else => |e| return e,
        };
        fl_flags |= 1 << @bitOffsetOf(O, "NONBLOCK");
        _ = fcntl(sock, F.SETFL, fl_flags) catch |err| switch (err) {
            error.FileBusy => unreachable,
            error.Locked => unreachable,
            error.PermissionDenied => unreachable,
            error.DeadLock => unreachable,
            error.LockedRegionLimitExceeded => unreachable,
            else => |e| return e,
        };
    }
}

const FcntlError = error{
    PermissionDenied,
    FileBusy,
    ProcessFdQuotaExceeded,
    Locked,
    DeadLock,
    LockedRegionLimitExceeded,
} || UnexpectedError;

pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) FcntlError!usize {
    while (true) {
        const rc = system.fcntl(fd, cmd, arg);
        switch (errno(rc)) {
            .SUCCESS => return @intCast(rc),
            .INTR => continue,
            .AGAIN, .ACCES => return error.Locked,
            .BADF => unreachable,
            .BUSY => return error.FileBusy,
            .INVAL => unreachable, // invalid parameters
            .PERM => return error.PermissionDenied,
            .MFILE => return error.ProcessFdQuotaExceeded,
            .NOTDIR => unreachable, // invalid parameter
            .DEADLK => return error.DeadLock,
            .NOLCK => return error.LockedRegionLimitExceeded,
            else => |err| return unexpectedErrno(err),
        }
    }
}

const WriteError = error{
    DiskQuota,
    FileTooBig,
    InputOutput,
    NoSpaceLeft,
    DeviceBusy,
    InvalidArgument,

    /// File descriptor does not hold the required rights to write to it.
    AccessDenied,
    PermissionDenied,
    BrokenPipe,
    SystemResources,
    OperationAborted,
    NotOpenForWriting,

    /// The process cannot access the file because another process has locked
    /// a portion of the file. Windows-only.
    LockViolation,

    /// This error occurs when no global event loop is configured,
    /// and reading from the file descriptor would block.
    WouldBlock,

    /// Connection reset by peer.
    ConnectionResetByPeer,

    /// This error occurs in Linux if the process being written to
    /// no longer exists.
    ProcessNotFound,
    /// This error occurs when a device gets disconnected before or mid-flush
    /// while it's being written to - errno(6): No such device or address.
    NoDevice,

    /// The socket type requires that message be sent atomically, and the size of the message
    /// to be sent made this impossible. The message is not transmitted.
    MessageTooBig,
} || UnexpectedError;

/// Write to a file descriptor.
/// Retries when interrupted by a signal.
/// Returns the number of bytes written. If nonzero bytes were supplied, this will be nonzero.
///
/// Note that a successful write() may transfer fewer than count bytes.  Such partial  writes  can
/// occur  for  various reasons; for example, because there was insufficient space on the disk
/// device to write all of the requested bytes, or because a blocked write() to a socket,  pipe,  or
/// similar  was  interrupted by a signal handler after it had transferred some, but before it had
/// transferred all of the requested bytes.  In the event of a partial write, the caller can  make
/// another  write() call to transfer the remaining bytes.  The subsequent call will either
/// transfer further bytes or may result in an error (e.g., if the disk is now full).
///
/// For POSIX systems, if `fd` is opened in non blocking mode, the function will
/// return error.WouldBlock when EAGAIN is received.
/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are
/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.
///
/// Linux has a limit on how many bytes may be transferred in one `write` call, which is `0x7ffff000`
/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as
/// well as stuffing the errno codes into the last `4096` values. This is noted on the `write` man page.
/// The limit on Darwin is `0x7fffffff`, trying to read more than that returns EINVAL.
/// The corresponding POSIX limit is `maxInt(isize)`.
pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {
    if (bytes.len == 0) return 0;
    const max_count = switch (native_os) {
        .linux => 0x7ffff000,
        .macos, .ios, .watchos, .tvos, .visionos => maxInt(i32),
        else => maxInt(isize),
    };
    while (true) {
        const rc = system.write(fd, bytes.ptr, @min(bytes.len, max_count));
        switch (errno(rc)) {
            .SUCCESS => return @intCast(rc),
            .INTR => continue,
            .INVAL => return error.InvalidArgument,
            .FAULT => unreachable,
            .SRCH => return error.ProcessNotFound,
            .AGAIN => return error.WouldBlock,
            .BADF => return error.NotOpenForWriting, // can be a race condition.
            .DESTADDRREQ => unreachable, // `connect` was never called.
            .DQUOT => return error.DiskQuota,
            .FBIG => return error.FileTooBig,
            .IO => return error.InputOutput,
            .NOSPC => return error.NoSpaceLeft,
            .ACCES => return error.AccessDenied,
            .PERM => return error.PermissionDenied,
            .PIPE => return error.BrokenPipe,
            .CONNRESET => return error.ConnectionResetByPeer,
            .BUSY => return error.DeviceBusy,
            .NXIO => return error.NoDevice,
            .MSGSIZE => return error.MessageTooBig,
            else => |err| return unexpectedErrno(err),
        }
    }
}

pub const ForkError = error{SystemResources} || UnexpectedError;

pub fn fork() ForkError!pid_t {
    const rc = system.fork();
    switch (errno(rc)) {
        .SUCCESS => return @intCast(rc),
        .AGAIN => return error.SystemResources,
        .NOMEM => return error.SystemResources,
        else => |err| return unexpectedErrno(err),
    }
}

const SetSidError = error{
    /// The calling process is already a process group leader, or the process group ID of a process other than the calling process matches the process ID of the calling process.
    PermissionDenied,
} || UnexpectedError;

pub fn setsid() SetSidError!pid_t {
    const rc = system.setsid();
    switch (errno(rc)) {
        .SUCCESS => return rc,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
/// On WASI, `file_path` should be encoded as valid UTF-8.
/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
/// See also `open`.
fn openZ(file_path: [*:0]const u8, flags: O, perm: mode_t) OpenError!fd_t {
    const open_sym = if (lfs64_abi) system.open64 else system.open;
    while (true) {
        const rc = open_sym(file_path, flags, perm);
        switch (errno(rc)) {
            .SUCCESS => return @intCast(rc),
            .INTR => continue,

            .FAULT => unreachable,
            .INVAL => return error.BadPathName,
            .ACCES => return error.AccessDenied,
            .FBIG => return error.FileTooBig,
            .OVERFLOW => return error.FileTooBig,
            .ISDIR => return error.IsDir,
            .LOOP => return error.SymLinkLoop,
            .MFILE => return error.ProcessFdQuotaExceeded,
            .NAMETOOLONG => return error.NameTooLong,
            .NFILE => return error.SystemFdQuotaExceeded,
            .NODEV => return error.NoDevice,
            .NOENT => return error.FileNotFound,
            .SRCH => return error.ProcessNotFound,
            .NOMEM => return error.SystemResources,
            .NOSPC => return error.NoSpaceLeft,
            .NOTDIR => return error.NotDir,
            .PERM => return error.PermissionDenied,
            .EXIST => return error.PathAlreadyExists,
            .BUSY => return error.DeviceBusy,
            .ILSEQ => |err| if (native_os == .wasi)
                return error.InvalidUtf8
            else
                return unexpectedErrno(err),
            else => |err| return unexpectedErrno(err),
        }
    }
}

/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// `file_path` is relative to the open directory handle `dir_fd`.
/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
/// On WASI, `file_path` should be encoded as valid UTF-8.
/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
/// See also `openat`.
fn openatZ(dir_fd: fd_t, file_path: [*:0]const u8, flags: O, mode: mode_t) OpenError!fd_t {
    const openat_sym = if (lfs64_abi) system.openat64 else system.openat;
    while (true) {
        const rc = openat_sym(dir_fd, file_path, flags, mode);
        switch (errno(rc)) {
            .SUCCESS => return @intCast(rc),
            .INTR => continue,

            .FAULT => unreachable,
            .INVAL => return error.BadPathName,
            .BADF => unreachable,
            .ACCES => return error.AccessDenied,
            .FBIG => return error.FileTooBig,
            .OVERFLOW => return error.FileTooBig,
            .ISDIR => return error.IsDir,
            .LOOP => return error.SymLinkLoop,
            .MFILE => return error.ProcessFdQuotaExceeded,
            .NAMETOOLONG => return error.NameTooLong,
            .NFILE => return error.SystemFdQuotaExceeded,
            .NODEV => return error.NoDevice,
            .NOENT => return error.FileNotFound,
            .SRCH => return error.ProcessNotFound,
            .NOMEM => return error.SystemResources,
            .NOSPC => return error.NoSpaceLeft,
            .NOTDIR => return error.NotDir,
            .PERM => return error.PermissionDenied,
            .EXIST => return error.PathAlreadyExists,
            .BUSY => return error.DeviceBusy,
            .OPNOTSUPP => return error.FileLocksNotSupported,
            .AGAIN => return error.WouldBlock,
            .TXTBSY => return error.FileBusy,
            .NXIO => return error.NoDevice,
            .ILSEQ => |err| if (native_os == .wasi)
                return error.InvalidUtf8
            else
                return unexpectedErrno(err),
            else => |err| return unexpectedErrno(err),
        }
    }
}

/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// `file_path` is relative to the open directory handle `dir_fd`.
/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
/// On WASI, `file_path` should be encoded as valid UTF-8.
/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
/// See also `openatZ`.
fn openat(dir_fd: fd_t, file_path: []const u8, flags: O, mode: mode_t) OpenError!fd_t {
    const file_path_c = try toPosixPath(file_path);
    return openatZ(dir_fd, &file_path_c, flags, mode);
}

const OpenError = error{
    /// In WASI, this error may occur when the file descriptor does
    /// not hold the required rights to open a new resource relative to it.
    AccessDenied,
    PermissionDenied,
    SymLinkLoop,
    ProcessFdQuotaExceeded,
    SystemFdQuotaExceeded,
    NoDevice,
    /// Either:
    /// * One of the path components does not exist.
    /// * Cwd was used, but cwd has been deleted.
    /// * The path associated with the open directory handle has been deleted.
    /// * On macOS, multiple processes or threads raced to create the same file
    ///   with `O.EXCL` set to `false`.
    FileNotFound,

    /// The path exceeded `max_path_bytes` bytes.
    NameTooLong,

    /// Insufficient kernel memory was available, or
    /// the named file is a FIFO and per-user hard limit on
    /// memory allocation for pipes has been reached.
    SystemResources,

    /// The file is too large to be opened. This error is unreachable
    /// for 64-bit targets, as well as when opening directories.
    FileTooBig,

    /// The path refers to directory but the `DIRECTORY` flag was not provided.
    IsDir,

    /// A new path cannot be created because the device has no room for the new file.
    /// This error is only reachable when the `CREAT` flag is provided.
    NoSpaceLeft,

    /// A component used as a directory in the path was not, in fact, a directory, or
    /// `DIRECTORY` was specified and the path was not a directory.
    NotDir,

    /// The path already exists and the `CREAT` and `EXCL` flags were provided.
    PathAlreadyExists,
    DeviceBusy,

    /// The underlying filesystem does not support file locks
    FileLocksNotSupported,

    /// Path contains characters that are disallowed by the underlying filesystem.
    BadPathName,

    /// WASI-only; file paths must be valid UTF-8.
    InvalidUtf8,

    /// Windows-only; file paths provided by the user must be valid WTF-8.
    /// https://simonsapin.github.io/wtf-8/
    InvalidWtf8,

    /// On Windows, `\\server` or `\\server\share` was not found.
    NetworkNotFound,

    /// This error occurs in Linux if the process to be open was not found.
    ProcessNotFound,

    /// One of these three things:
    /// * pathname  refers to an executable image which is currently being
    ///   executed and write access was requested.
    /// * pathname refers to a file that is currently in  use  as  a  swap
    ///   file, and the O_TRUNC flag was specified.
    /// * pathname  refers  to  a file that is currently being read by the
    ///   kernel (e.g., for module/firmware loading), and write access was
    ///   requested.
    FileBusy,

    WouldBlock,
} || UnexpectedError;

/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// On Windows, `file_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
/// On WASI, `file_path` should be encoded as valid UTF-8.
/// On other platforms, `file_path` is an opaque sequence of bytes with no particular encoding.
/// See also `openZ`.
pub fn open(file_path: []const u8, flags: O, perm: mode_t) OpenError!fd_t {
    const file_path_c = try toPosixPath(file_path);
    return openZ(&file_path_c, flags, perm);
}

pub fn dup2(old_fd: fd_t, new_fd: fd_t) !void {
    while (true) {
        switch (errno(system.dup2(old_fd, new_fd))) {
            .SUCCESS => return,
            .BUSY, .INTR => continue,
            .MFILE => return error.ProcessFdQuotaExceeded,
            .INVAL => unreachable, // invalid parameters passed to dup2
            .BADF => unreachable, // invalid file descriptor
            else => |err| return unexpectedErrno(err),
        }
    }
}

/// This function ignores PATH environment variable. See `execvpeZ` for that.
fn execveZ(
    path: [*:0]const u8,
    child_argv: [*:null]const ?[*:0]const u8,
    envp: [*:null]const ?[*:0]const u8,
) ExecveError {
    switch (errno(system.execve(path, child_argv, envp))) {
        .SUCCESS => unreachable,
        .FAULT => unreachable,
        .@"2BIG" => return error.SystemResources,
        .MFILE => return error.ProcessFdQuotaExceeded,
        .NAMETOOLONG => return error.NameTooLong,
        .NFILE => return error.SystemFdQuotaExceeded,
        .NOMEM => return error.SystemResources,
        .ACCES => return error.AccessDenied,
        .PERM => return error.PermissionDenied,
        .INVAL => return error.InvalidExe,
        .NOEXEC => return error.InvalidExe,
        .IO => return error.FileSystem,
        .LOOP => return error.FileSystem,
        .ISDIR => return error.IsDir,
        .NOENT => return error.FileNotFound,
        .NOTDIR => return error.NotDir,
        .TXTBSY => return error.FileBusy,
        else => |err| switch (native_os) {
            .macos, .ios, .tvos, .watchos, .visionos => switch (err) {
                .BADEXEC => return error.InvalidExe,
                .BADARCH => return error.InvalidExe,
                else => return unexpectedErrno(err),
            },
            .linux => switch (err) {
                .LIBBAD => return error.InvalidExe,
                else => return unexpectedErrno(err),
            },
            else => return unexpectedErrno(err),
        },
    }
}

/// Get an environment variable with a null-terminated name.
/// See also `getenv`.
fn getenvZ(key: [*:0]const u8) ?[:0]const u8 {
    if (builtin.link_libc) {
        const value = system.getenv(key) orelse return null;
        return mem.sliceTo(value, 0);
    }
    return getenv(mem.sliceTo(key, 0));
}

const Arg0Expand = enum {
    expand,
    no_expand,
};

/// Like `execvpeZ` except if `arg0_expand` is `.expand`, then `argv` is mutable,
/// and `argv[0]` is expanded to be the same absolute path that is passed to the execve syscall.
/// If this function returns with an error, `argv[0]` will be restored to the value it was when it was passed in.
fn execvpeZ_expandArg0(
    comptime arg0_expand: Arg0Expand,
    file: [*:0]const u8,
    child_argv: switch (arg0_expand) {
        .expand => [*:null]?[*:0]const u8,
        .no_expand => [*:null]const ?[*:0]const u8,
    },
    envp: [*:null]const ?[*:0]const u8,
) ExecveError {
    const file_slice = mem.sliceTo(file, 0);
    if (mem.indexOfScalar(u8, file_slice, '/') != null) return execveZ(file, child_argv, envp);

    const PATH = getenvZ("PATH") orelse "/usr/local/bin:/bin/:/usr/bin";
    // Use of PATH_MAX here is valid as the path_buf will be passed
    // directly to the operating system in execveZ.
    var path_buf: [PATH_MAX]u8 = undefined;
    var it = mem.tokenizeScalar(u8, PATH, ':');
    var seen_eacces = false;
    var err: ExecveError = error.FileNotFound;

    // In case of expanding arg0 we must put it back if we return with an error.
    const prev_arg0 = child_argv[0];
    defer switch (arg0_expand) {
        .expand => child_argv[0] = prev_arg0,
        .no_expand => {},
    };

    while (it.next()) |search_path| {
        const path_len = search_path.len + file_slice.len + 1;
        if (path_buf.len < path_len + 1) return error.NameTooLong;
        @memcpy(path_buf[0..search_path.len], search_path);
        path_buf[search_path.len] = '/';
        @memcpy(path_buf[search_path.len + 1 ..][0..file_slice.len], file_slice);
        path_buf[path_len] = 0;
        const full_path = path_buf[0..path_len :0].ptr;
        switch (arg0_expand) {
            .expand => child_argv[0] = full_path,
            .no_expand => {},
        }
        err = execveZ(full_path, child_argv, envp);
        switch (err) {
            error.AccessDenied => seen_eacces = true,
            error.FileNotFound, error.NotDir => {},
            else => |e| return e,
        }
    }
    if (seen_eacces) return error.AccessDenied;
    return err;
}

const ExecveError = error{
    SystemResources,
    AccessDenied,
    PermissionDenied,
    InvalidExe,
    FileSystem,
    IsDir,
    FileNotFound,
    NotDir,
    FileBusy,
    ProcessFdQuotaExceeded,
    SystemFdQuotaExceeded,
    NameTooLong,
} || UnexpectedError;

/// This function also uses the PATH environment variable to get the full path to the executable.
/// If `file` is an absolute path, this is the same as `execveZ`.
pub fn execvpeZ(
    file: [*:0]const u8,
    argv_ptr: [*:null]const ?[*:0]const u8,
    envp: [*:null]const ?[*:0]const u8,
) ExecveError {
    return execvpeZ_expandArg0(.no_expand, file, argv_ptr, envp);
}

/// Exits all threads of the program with the specified status code.
pub fn exit(status: u8) noreturn {
    if (builtin.link_libc) {
        std.c.exit(status);
    }
    if (native_os == .linux and !builtin.single_threaded) {
        linux.exit_group(status);
    }
    if (native_os == .uefi) {
        const uefi = std.os.uefi;
        // exit() is only available if exitBootServices() has not been called yet.
        // This call to exit should not fail, so we catch-ignore errors.
        if (uefi.system_table.boot_services) |bs| {
            bs.exit(uefi.handle, @enumFromInt(status), null) catch {};
        }
        // If we can't exit, reboot the system instead.
        uefi.system_table.runtime_services.resetSystem(.cold, @enumFromInt(status), null);
    }
    system.exit(status);
}

/// Creates a unidirectional data channel that can be used for interprocess communication.
fn pipe() PipeError![2]fd_t {
    var fds: [2]fd_t = undefined;
    switch (errno(system.pipe(&fds))) {
        .SUCCESS => return fds,
        .INVAL => unreachable, // Invalid parameters to pipe()
        .FAULT => unreachable, // Invalid fds pointer
        .NFILE => return error.SystemFdQuotaExceeded,
        .MFILE => return error.ProcessFdQuotaExceeded,
        else => |err| return unexpectedErrno(err),
    }
}

const PipeError = error{
    SystemFdQuotaExceeded,
    ProcessFdQuotaExceeded,
} || UnexpectedError;

pub fn pipe2(flags: O) PipeError![2]fd_t {
    if (@TypeOf(system.pipe2) != void) {
        var fds: [2]fd_t = undefined;
        switch (errno(system.pipe2(&fds, flags))) {
            .SUCCESS => return fds,
            .INVAL => unreachable, // Invalid flags
            .FAULT => unreachable, // Invalid fds pointer
            .NFILE => return error.SystemFdQuotaExceeded,
            .MFILE => return error.ProcessFdQuotaExceeded,
            else => |err| return unexpectedErrno(err),
        }
    }

    const fds: [2]fd_t = try pipe();
    errdefer {
        close(fds[0]);
        close(fds[1]);
    }

    // https://github.com/ziglang/zig/issues/18882
    if (@as(u32, @bitCast(flags)) == 0)
        return fds;

    // CLOEXEC is special, it's a file descriptor flag and must be set using
    // F.SETFD.
    if (flags.CLOEXEC) {
        for (fds) |fd| {
            switch (errno(system.fcntl(fd, F.SETFD, @as(u32, FD_CLOEXEC)))) {
                .SUCCESS => {},
                .INVAL => unreachable, // Invalid flags
                .BADF => unreachable, // Always a race condition
                else => |err| return unexpectedErrno(err),
            }
        }
    }

    const new_flags: u32 = f: {
        var new_flags = flags;
        new_flags.CLOEXEC = false;
        break :f @bitCast(new_flags);
    };
    // Set every other flag affecting the file status using F.SETFL.
    if (new_flags != 0) {
        for (fds) |fd| {
            switch (errno(system.fcntl(fd, F.SETFL, new_flags))) {
                .SUCCESS => {},
                .INVAL => unreachable, // Invalid flags
                .BADF => unreachable, // Always a race condition
                else => |err| return unexpectedErrno(err),
            }
        }
    }

    return fds;
}

const AcceptError = error{
    ConnectionAborted,

    /// The file descriptor sockfd does not refer to a socket.
    FileDescriptorNotASocket,

    /// The per-process limit on the number of open file descriptors has been reached.
    ProcessFdQuotaExceeded,

    /// The system-wide limit on the total number of open files has been reached.
    SystemFdQuotaExceeded,

    /// Not enough free memory.  This often means that the memory allocation  is  limited
    /// by the socket buffer limits, not by the system memory.
    SystemResources,

    /// Socket is not listening for new connections.
    SocketNotListening,

    ProtocolFailure,

    /// Firewall rules forbid connection.
    BlockedByFirewall,

    /// This error occurs when no global event loop is configured,
    /// and accepting from the socket would block.
    WouldBlock,

    /// An incoming connection was indicated, but was subsequently terminated by the
    /// remote peer prior to accepting the call.
    ConnectionResetByPeer,

    /// The network subsystem has failed.
    NetworkSubsystemFailed,

    /// The referenced socket is not a type that supports connection-oriented service.
    OperationNotSupported,
} || UnexpectedError;

/// Accept a connection on a socket.
/// If `sockfd` is opened in non blocking mode, the function will
/// return error.WouldBlock when EAGAIN is received.
pub fn accept(
    /// This argument is a socket that has been created with `socket`, bound to a local address
    /// with `bind`, and is listening for connections after a `listen`.
    sock: socket_t,
    /// This argument is a pointer to a sockaddr structure.  This structure is filled in with  the
    /// address  of  the  peer  socket, as known to the communications layer.  The exact format of the
    /// address returned addr is determined by the socket's address  family  (see  `socket`  and  the
    /// respective  protocol  man  pages).
    addr: ?*sockaddr,
    /// This argument is a value-result argument: the caller must initialize it to contain  the
    /// size (in bytes) of the structure pointed to by addr; on return it will contain the actual size
    /// of the peer address.
    ///
    /// The returned address is truncated if the buffer provided is too small; in this  case,  `addr_size`
    /// will return a value greater than was supplied to the call.
    addr_size: ?*socklen_t,
    /// The following values can be bitwise ORed in flags to obtain different behavior:
    /// * `SOCK.NONBLOCK` - Set the `NONBLOCK` file status flag on the open file description (see `open`)
    ///   referred  to by the new file descriptor.  Using this flag saves extra calls to `fcntl` to achieve
    ///   the same result.
    /// * `SOCK.CLOEXEC`  - Set the close-on-exec (`FD_CLOEXEC`) flag on the new file descriptor.   See  the
    ///   description  of the `CLOEXEC` flag in `open` for reasons why this may be useful.
    flags: u32,
) AcceptError!socket_t {
    const have_accept4 = !builtin.target.os.tag.isDarwin();
    assert(0 == (flags & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC))); // Unsupported flag(s)

    const accepted_sock: socket_t = while (true) {
        const rc = if (have_accept4)
            system.accept4(sock, addr, addr_size, flags)
        else
            system.accept(sock, addr, addr_size);

        switch (errno(rc)) {
            .SUCCESS => break @intCast(rc),
            .INTR => continue,
            .AGAIN => return error.WouldBlock,
            .BADF => unreachable, // always a race condition
            .CONNABORTED => return error.ConnectionAborted,
            .FAULT => unreachable,
            .INVAL => return error.SocketNotListening,
            .NOTSOCK => unreachable,
            .MFILE => return error.ProcessFdQuotaExceeded,
            .NFILE => return error.SystemFdQuotaExceeded,
            .NOBUFS => return error.SystemResources,
            .NOMEM => return error.SystemResources,
            .OPNOTSUPP => unreachable,
            .PROTO => return error.ProtocolFailure,
            .PERM => return error.BlockedByFirewall,
            else => |err| return unexpectedErrno(err),
        }
    };

    errdefer close(accepted_sock);
    if (!have_accept4) {
        try setSockFlags(accepted_sock, flags);
    }
    return accepted_sock;
}

const WaitPidResult = struct {
    pid: pid_t,
    status: u32,
};

/// Use this version of the `waitpid` wrapper if you spawned your child process using explicit
/// `fork` and `execve` method.
pub fn waitpid(pid: pid_t, flags: u32) WaitPidResult {
    var status: if (builtin.link_libc) c_int else u32 = undefined;
    while (true) {
        const rc = system.waitpid(pid, &status, @intCast(flags));
        switch (errno(rc)) {
            .SUCCESS => return .{
                .pid = @intCast(rc),
                .status = @bitCast(status),
            },
            .INTR => continue,
            .CHILD => unreachable, // The process specified does not exist. It would be a race condition to handle this error.
            .INVAL => unreachable, // Invalid flags.
            else => unreachable,
        }
    }
}

/// Call this when you made a syscall or something that sets errno
/// and you get an unexpected error.
fn unexpectedErrno(err: E) UnexpectedError {
    if (unexpected_error_tracing) {
        std.debug.print("unexpected errno: {d}\n", .{@intFromEnum(err)});
        std.debug.dumpCurrentStackTrace(std.debug.StackUnwindOptions{});
    }
    return error.Unexpected;
}

/// Whether or not `error.Unexpected` will print its value and a stack trace.
///
/// If this happens the fix is to add the error code to the corresponding
/// switch expression, possibly introduce a new error in the error set, and
/// send a patch to Zig.
const unexpected_error_tracing = builtin.mode == .Debug and switch (builtin.zig_backend) {
    .stage2_llvm, .stage2_x86_64 => true,
    else => false,
};

/// Used to convert a slice to a null terminated slice on the stack.
fn toPosixPath(file_path: []const u8) error{NameTooLong}![PATH_MAX - 1:0]u8 {
    if (std.debug.runtime_safety) assert(mem.indexOfScalar(u8, file_path, 0) == null);
    var path_with_null: [PATH_MAX - 1:0]u8 = undefined;
    // >= rather than > to make room for the null byte
    if (file_path.len >= PATH_MAX) return error.NameTooLong;
    @memcpy(path_with_null[0..file_path.len], file_path);
    path_with_null[file_path.len] = 0;
    return path_with_null;
}

const Address = extern union {
    any: sockaddr,
    un: sockaddr.un,

    pub fn getOsSockLen(_: Address) socklen_t {
        // Using the full length of the structure here is more portable than returning
        // the number of bytes actually used by the currently stored path.
        // This also is correct regardless if we are passing a socket address to the kernel
        // (e.g. in bind, connect, sendto) since we ensure the path is 0 terminated in
        // initUnix() or if we are receiving a socket address from the kernel and must
        // provide the full buffer size (e.g. getsockname, getpeername, recvfrom, accept).
        //
        // To access the path, std.mem.sliceTo(&address.un.path, 0) should be used.
        return @as(socklen_t, @intCast(@sizeOf(sockaddr.un)));
    }
};

pub fn initUnix(path: []const u8) !Address {
    var sock_addr = sockaddr.un{
        .family = AF.UNIX,
        .path = undefined,
    };

    // Add 1 to ensure a terminating 0 is present in the path array for maximum portability.
    if (path.len + 1 > sock_addr.path.len) return error.NameTooLong;

    @memset(&sock_addr.path, 0);
    @memcpy(sock_addr.path[0..path.len], path);

    return Address{ .un = sock_addr };
}

M src/socket.zig

+24, -24

......@@ -1,12 +1,13 @@
const std = @import("std");
const posix = std.posix;
const lib_posix = @import("posix.zig");

pub fn getSeshPrefix() []const u8 {
    return std.posix.getenv("ZMX_SESSION_PREFIX") orelse "";
    return lib_posix.getenv("ZMX_SESSION_PREFIX") orelse "";
}

pub fn getSeshNameFromEnv() []const u8 {
    return std.posix.getenv("ZMX_SESSION") orelse "";
    return lib_posix.getenv("ZMX_SESSION") orelse "";
}

pub fn getSeshName(alloc: std.mem.Allocator, sesh: []const u8) ![]const u8 {

......@@ -29,48 +30,47 @@ pub fn getSeshName(alloc: std.mem.Allocator, sesh: []const u8) ![]const u8 {
}

pub fn sessionConnect(sesh: []const u8) !i32 {
    var unix_addr = try std.net.Address.initUnix(sesh);
    const socket_fd = try posix.socket(posix.AF.UNIX, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
    errdefer posix.close(socket_fd);
    try posix.connect(socket_fd, &unix_addr.any, unix_addr.getOsSockLen());
    var unix_addr = try lib_posix.initUnix(sesh);
    const socket_fd = try lib_posix.socket(posix.AF.UNIX, posix.SOCK.STREAM | posix.SOCK.CLOEXEC, 0);
    errdefer lib_posix.close(socket_fd);
    try lib_posix.connect(socket_fd, &unix_addr.any, unix_addr.getOsSockLen());
    return socket_fd;
}

pub fn cleanupStaleSocket(dir: std.fs.Dir, session_name: []const u8) void {
pub fn cleanupStaleSocket(io: std.Io, dir: std.Io.Dir, session_name: []const u8) void {
    std.log.warn("stale socket found, cleaning up session={s}", .{session_name});
    dir.deleteFile(session_name) catch |err| {
    dir.deleteFile(io, session_name) catch |err| {
        std.log.warn("failed to delete stale socket err={s}", .{@errorName(err)});
    };
}

pub fn sessionExists(dir: std.fs.Dir, name: []const u8) !bool {
    // fstatatZ (not statFile) to avoid the statx syscall
    // https://github.com/neurosnap/zmx/issues/186
    const name_c = try posix.toPosixPath(name);
    const stat = posix.fstatatZ(dir.fd, &name_c, posix.AT.SYMLINK_NOFOLLOW) catch |err| switch (err) {
        error.FileNotFound => return false,
        else => return err,
pub fn sessionExists(io: std.Io, dir: std.Io.Dir, name: []const u8) !bool {
    const stat = dir.statFile(io, name, std.Io.Dir.StatFileOptions{}) catch |err| {
        switch (err) {
            error.FileNotFound => return false,
            else => return err,
        }
    };
    if (!posix.S.ISSOCK(stat.mode)) {
    if (stat.kind != .unix_domain_socket) {
        return error.FileNotUnixSocket;
    }
    return true;
}

pub fn createSocket(fname: []const u8) !i32 {
pub fn createSocket(sesh: []const u8) !i32 {
    // AF.UNIX: Unix domain socket for local IPC with client processes
    // SOCK.STREAM: Reliable, bidirectional communication
    // SOCK.NONBLOCK: Set socket to non-blocking
    const fd = try posix.socket(
    const fd = try lib_posix.socket(
        posix.AF.UNIX,
        posix.SOCK.STREAM | posix.SOCK.NONBLOCK | posix.SOCK.CLOEXEC,
        0,
    );
    errdefer posix.close(fd);
    errdefer lib_posix.close(fd);

    var unix_addr = try std.net.Address.initUnix(fname);
    try posix.bind(fd, &unix_addr.any, unix_addr.getOsSockLen());
    try posix.listen(fd, 128);
    var unix_addr = try lib_posix.initUnix(sesh);
    try lib_posix.bind(fd, &unix_addr.any, unix_addr.getOsSockLen());
    try lib_posix.listen(fd, 128);
    return fd;
}

......@@ -96,9 +96,9 @@ pub fn getSocketPath(
    return fname;
}

pub fn printSessionNameTooLong(session_name: []const u8, socket_dir: []const u8) void {
pub fn printSessionNameTooLong(io: std.Io, session_name: []const u8, socket_dir: []const u8) void {
    var buf: [4096]u8 = undefined;
    var w = std.fs.File.stderr().writer(&buf);
    var w = std.Io.File.stderr().writer(io, &buf);
    if (maxSessionNameLen(socket_dir)) |max_len| {
        w.interface.print(
            "error: session name is too long ({d} bytes, max {d} for socket directory \"{s}\")\n",

M src/util.zig

+36, -31

......@@ -33,17 +33,18 @@ pub const SessionEntry = struct {

pub fn get_session_entries(
    alloc: std.mem.Allocator,
    io: std.Io,
    socket_dir: []const u8,
) !std.ArrayList(SessionEntry) {
    std.log.info("get session entries socket_dir={s}", .{socket_dir});
    var dir = try std.fs.openDirAbsolute(socket_dir, .{ .iterate = true });
    defer dir.close();
    var dir = try std.Io.Dir.openDirAbsolute(io, socket_dir, .{ .iterate = true });
    defer dir.close(io);
    var iter = dir.iterate();

    var sessions = try std.ArrayList(SessionEntry).initCapacity(alloc, 30);

    while (try iter.next()) |entry| {
        const exists = socket.sessionExists(dir, entry.name) catch continue;
    while (try iter.next(io)) |entry| {
        const exists = socket.sessionExists(io, dir, entry.name) catch continue;
        if (exists) {
            const name = try alloc.dupe(u8, entry.name);
            errdefer alloc.free(name);

......@@ -70,7 +71,7 @@ pub fn get_session_entries(
                // daemon can miss the probe timeout; deleting its socket
                // orphans it permanently.
                if (err == error.ConnectionRefused) {
                    socket.cleanupStaleSocket(dir, entry.name);
                    socket.cleanupStaleSocket(io, dir, entry.name);
                }
                continue;
            };

......@@ -404,7 +405,7 @@ pub fn stripAnsi(alloc: std.mem.Allocator, data: []const u8) ![]const u8 {
    return result.toOwnedSlice(alloc);
}

/// Detects Ctrl+\ across raw, Kitty CSI u, and xterm modifyOtherKeys encodings.
/// Dcts Ctrl+\ across raw, Kitty CSI u, and xterm modifyOtherKeys encodings.
pub fn isCtrlBackslash(buf: []const u8) bool {
    if (buf.len == 0) return false;
    return buf[0] == 0x1C or isKeyPressed(buf, 0x5c, 0b100) or isModifyOtherKey(buf, 0x5c, 0b100);

......@@ -765,10 +766,6 @@ pub fn serializeTerminal(
    };
}

pub fn detectShell() [:0]const u8 {
    return std.posix.getenv("SHELL") orelse "/bin/sh";
}

/// Formats a session entry for list output (only the name when `short` is
/// true), adding a prefix to indicate the current session, if there is one.
pub fn writeSessionLine(

......@@ -1168,8 +1165,9 @@ test "isCtrlBackslash xterm modifyOtherKeys" {

test "serializeTerminalState excludes synchronized output replay" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try ghostty_vt.Terminal.init(alloc, .{
    var term = try ghostty_vt.Terminal.init(io, alloc, .{
        .cols = 80,
        .rows = 24,
    });

......@@ -1194,8 +1192,8 @@ test "serializeTerminalState excludes synchronized output replay" {
    try testing.expect(std.mem.indexOf(u8, output, "\x1b[?2026h") == null);
}

fn testCreateTerminal(alloc: std.mem.Allocator, cols: u16, rows: u16, vt_data: []const u8) !ghostty_vt.Terminal {
    var term = try ghostty_vt.Terminal.init(alloc, .{
fn testCreateTerminal(alloc: std.mem.Allocator, io: std.Io, cols: u16, rows: u16, vt_data: []const u8) !ghostty_vt.Terminal {
    var term = try ghostty_vt.Terminal.init(io, alloc, .{
        .cols = cols,
        .rows = rows,
        .max_scrollback = 10_000_000,

......@@ -1222,12 +1220,12 @@ fn expectCursorAt(term: *ghostty_vt.Terminal, row: usize, col: usize) !void {
    try testing.expectEqual(row, cursor.y);
}

fn serializeRoundtrip(alloc: std.mem.Allocator, source: *ghostty_vt.Terminal) !ghostty_vt.Terminal {
fn serializeRoundtrip(alloc: std.mem.Allocator, io: std.Io, source: *ghostty_vt.Terminal) !ghostty_vt.Terminal {
    const serialized = serializeTerminalState(alloc, source) orelse
        return error.SerializationFailed;
    defer alloc.free(serialized);

    var dest = try ghostty_vt.Terminal.init(alloc, .{
    var dest = try ghostty_vt.Terminal.init(io, alloc, .{
        .cols = source.screens.active.pages.cols,
        .rows = source.screens.active.pages.rows,
        .max_scrollback = 10_000_000,

......@@ -1256,15 +1254,16 @@ fn expectMarkerAtRow(alloc: std.mem.Allocator, term: *ghostty_vt.Terminal, marke

test "serializeTerminalState roundtrip preserves cursor position" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try testCreateTerminal(alloc, 80, 24, "\x1b[2J" ++ // clear
    var term = try testCreateTerminal(alloc, io, 80, 24, "\x1b[2J" ++ // clear
        "\x1b[10;20H" // cursor at row 10, col 20 (1-indexed)
    );
    defer term.deinit(alloc);

    try expectCursorAt(&term, 9, 19); // 0-indexed

    var client = try serializeRoundtrip(alloc, &term);
    var client = try serializeRoundtrip(alloc, io, &term);
    defer client.deinit(alloc);

    try expectCursorAt(&client, 9, 19);

......@@ -1272,8 +1271,9 @@ test "serializeTerminalState roundtrip preserves cursor position" {

test "serializeTerminalState roundtrip preserves CUP-positioned markers" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try testCreateTerminal(alloc, 80, 24, "\x1b[2J" ++
    var term = try testCreateTerminal(alloc, io, 80, 24, "\x1b[2J" ++
        "\x1b[2;5HMARK_A" ++
        "\x1b[6;15HMARK_B" ++
        "\x1b[10;30HMARK_C" ++

......@@ -1281,7 +1281,7 @@ test "serializeTerminalState roundtrip preserves CUP-positioned markers" {
        "\x1b[16;20H");
    defer term.deinit(alloc);

    var client = try serializeRoundtrip(alloc, &term);
    var client = try serializeRoundtrip(alloc, io, &term);
    defer client.deinit(alloc);

    try expectScreensMatch(alloc, &term, &client);

......@@ -1294,8 +1294,9 @@ test "serializeTerminalState roundtrip preserves CUP-positioned markers" {

test "serializeTerminalState with scrollback preserves visible content" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try testCreateTerminal(alloc, 80, 24, "");
    var term = try testCreateTerminal(alloc, io, 80, 24, "");
    defer term.deinit(alloc);

    var stream = term.vtStream();

......@@ -1321,7 +1322,7 @@ test "serializeTerminalState with scrollback preserves visible content" {
    try testing.expect(has_scrollback);

    // Roundtrip: serialize → feed into fresh terminal
    var client = try serializeRoundtrip(alloc, &term);
    var client = try serializeRoundtrip(alloc, io, &term);
    defer client.deinit(alloc);

    // Visible content must match (this is the core cursor corruption test)

......@@ -1336,9 +1337,10 @@ test "serializeTerminalState nested roundtrip preserves content" {
    // Simulates: inner zmx → serialized state → outer ghostty-vt → serialized again → client
    // This is the exact nested session scenario (zmx → SSH → zmx).
    const alloc = testing.allocator;
    const io = testing.io;

    // "Inner" terminal with scrollback + markers
    var inner = try testCreateTerminal(alloc, 80, 24, "");
    var inner = try testCreateTerminal(alloc, io, 80, 24, "");
    defer inner.deinit(alloc);

    {

......@@ -1365,7 +1367,7 @@ test "serializeTerminalState nested roundtrip preserves content" {
    defer alloc.free(inner_serialized);

    // "Outer" terminal processes inner's serialized output
    var outer = try testCreateTerminal(alloc, 80, 24, "");
    var outer = try testCreateTerminal(alloc, io, 80, 24, "");
    defer outer.deinit(alloc);

    {

......@@ -1375,7 +1377,7 @@ test "serializeTerminalState nested roundtrip preserves content" {
    }

    // Serialize outer (simulates outer daemon re-attach after detach)
    var client = try serializeRoundtrip(alloc, &outer);
    var client = try serializeRoundtrip(alloc, io, &outer);
    defer client.deinit(alloc);

    // Client must see the same content as inner's visible screen

......@@ -1387,15 +1389,16 @@ test "serializeTerminalState nested roundtrip preserves content" {

test "serializeTerminalState alternate screen not leaked" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try testCreateTerminal(alloc, 80, 24, "\x1b[?1049h" ++ // enter alt screen
    var term = try testCreateTerminal(alloc, io, 80, 24, "\x1b[?1049h" ++ // enter alt screen
        "\x1b[2J\x1b[3;10HALT_MARK" ++ // write on alt screen
        "\x1b[?1049l" ++ // exit alt screen
        "\x1b[2J\x1b[2;5HMAIN_MARK\x1b[8;20H" // write on main screen
    );
    defer term.deinit(alloc);

    var client = try serializeRoundtrip(alloc, &term);
    var client = try serializeRoundtrip(alloc, io, &term);
    defer client.deinit(alloc);

    try expectScreensMatch(alloc, &term, &client);

......@@ -1408,8 +1411,9 @@ test "serializeTerminalState alternate screen not leaked" {

test "serializeTerminalState size mismatch roundtrip" {
    const alloc = testing.allocator;
    const io = testing.io;

    var term = try testCreateTerminal(alloc, 80, 30, "\x1b[2J" ++
    var term = try testCreateTerminal(alloc, io, 80, 30, "\x1b[2J" ++
        "\x1b[3;10HSIZE_A" ++
        "\x1b[12;20HSIZE_B" ++
        "\x1b[20;40HSIZE_C" ++

......@@ -1419,7 +1423,7 @@ test "serializeTerminalState size mismatch roundtrip" {
    // Resize to 24 rows (simulates outer terminal being smaller)
    try term.resize(alloc, ghostty_vt.Terminal.Resize{ .cols = 80, .rows = 24 });

    var client = try serializeRoundtrip(alloc, &term);
    var client = try serializeRoundtrip(alloc, io, &term);
    defer client.deinit(alloc);

    try expectScreensMatch(alloc, &term, &client);

......@@ -1428,8 +1432,9 @@ test "serializeTerminalState size mismatch roundtrip" {

test "serializeTerminalState scrollback + size mismatch nested roundtrip" {
    const alloc = testing.allocator;
    const io = testing.io;

    var inner = try testCreateTerminal(alloc, 80, 30, "");
    var inner = try testCreateTerminal(alloc, io, 80, 30, "");
    defer inner.deinit(alloc);

    {

......@@ -1457,7 +1462,7 @@ test "serializeTerminalState scrollback + size mismatch nested roundtrip" {
        return error.SerializationFailed;
    defer alloc.free(inner_ser);

    var outer = try testCreateTerminal(alloc, 80, 24, "");
    var outer = try testCreateTerminal(alloc, io, 80, 24, "");
    defer outer.deinit(alloc);
    {
        var outer_stream = outer.vtStream();

......@@ -1465,7 +1470,7 @@ test "serializeTerminalState scrollback + size mismatch nested roundtrip" {
        outer_stream.nextSlice(inner_ser);
    }

    var client = try serializeRoundtrip(alloc, &outer);
    var client = try serializeRoundtrip(alloc, io, &outer);
    defer client.deinit(alloc);

    try expectScreensMatch(alloc, &inner, &client);

...	...		@@ -434,66 +444,69 @@ pub fn main() !void {
434	444		// Add exact-match names directly.
435	445		for (matchers.items) \|m\| {
436	446		if (!m.is_prefix) {
437		-	try resolved_names.append(alloc, try alloc.dupe(u8, m.name));
	447	+	try resolved_names.append(gpa, try gpa.dupe(u8, m.name));
438	448		}
439	449		}
440	450
441		-	var client_socket_fds = try std.ArrayList(i32).initCapacity(alloc, resolved_names.items.len);
	451	+	var client_socket_fds = try std.ArrayList(i32).initCapacity(gpa, resolved_names.items.len);
442	452		defer {
443	453		for (client_socket_fds.items) \|client_fd\| {
444		-	posix.close(client_fd);
	454	+	lib_posix.close(client_fd);
445	455		}
446		-	client_socket_fds.deinit(alloc);
	456	+	client_socket_fds.deinit(gpa);
447	457		}
448	458
449	459		for (resolved_names.items) \|session_name\| {
450		-	const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, session_name) catch \|err\| switch (err) {
451		-	error.NameTooLong => return socket.printSessionNameTooLong(session_name, cfg.socket_dir),
	460	+	const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, session_name) catch \|err\| switch (err) {
	461	+	error.NameTooLong => return socket.printSessionNameTooLong(init.io, session_name, cfg.socket_dir),
452	462		error.OutOfMemory => return err,
453	463		};
454	464		const client_sock = try socket.sessionConnect(socket_path);
455		-	try client_socket_fds.append(alloc, client_sock);
	465	+	try client_socket_fds.append(gpa, client_sock);
456	466		}
457		-	_ = try tail(client_socket_fds, false, false);
	467	+	_ = try tail(gpa, client_socket_fds, false, false);
458	468		} else if (std.mem.eql(u8, cmd, "write") or std.mem.eql(u8, cmd, "wr")) {
459	469		const session_name = args.next() orelse "";
460	470		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
461		-	return help();
	471	+	return help(io);
462	472		}
463	473		if (session_name.len == 0) return error.SessionNameRequired;
464	474		const file_path = args.next() orelse "";
465	475		if (std.mem.eql(u8, file_path, "--help") or std.mem.eql(u8, file_path, "-h")) {
466		-	return help();
	476	+	return help(io);
467	477		}
468	478		if (file_path.len == 0) return error.FilePathRequired;
469	479
470	480		var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
471		-	const cwd = std.posix.getcwd(&cwd_buf) catch "";
472		-	const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
473		-	const sesh = try socket.getSeshName(alloc, session_name);
474		-	defer alloc.free(sesh);
	481	+	const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
	482	+	const cwd = cwd_buf[0..cwd_len];
	483	+	const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);
	484	+	const sesh = try socket.getSeshName(gpa, session_name);
	485	+	defer gpa.free(sesh);
475	486		var daemon = Daemon{
	487	+	.io = io,
476	488		.running = true,
477	489		.cfg = &cfg,
478		-	.alloc = alloc,
	490	+	.alloc = std.heap.c_allocator,
479	491		.clients = clients,
480	492		.session_name = sesh,
481	493		.socket_path = undefined,
482	494		.pid = undefined,
483	495		.command = null,
484	496		.cwd = cwd,
485		-	.created_at = @intCast(std.time.timestamp()),
	497	+	.created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
486	498		.is_task_mode = true,
487	499		.leader_client_fd = null,
	500	+	.shell = shell_env,
488	501		};
489		-	daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch \|err\| switch (err) {
490		-	error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
	502	+	daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch \|err\| switch (err) {
	503	+	error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
491	504		error.OutOfMemory => return err,
492	505		};
493	506		std.log.info("socket path={s}", .{daemon.socket_path});
494	507		try writeFile(&daemon, file_path);
495	508		} else {
496		-	return help();
	509	+	return help(io);
497	510		}
498	511		}
499	512

...	...		@@ -2,7 +2,7 @@ FROM debian:12
2	2
3	3		RUN apt-get update && apt-get install -y curl git bats coreutils && rm -rf /var/lib/apt/lists/*
4	4
5		-	ARG ZIG_VERSION=0.15.2
	5	+	ARG ZIG_VERSION=0.16.0
6	6		RUN curl -L -o /tmp/zig.tar.xz https://ziglang.org/download/${ZIG_VERSION}/zig-x86_64-linux-${ZIG_VERSION}.tar.xz && \
7	7		cd /tmp && \
8	8		tar -xvf zig.tar.xz && \

...	...		@@ -80,7 +80,7 @@ nix run github:neurosnap/zmx
80	80
81	81		### src
82	82
83		-	- Requires zig `v0.15`
	83	+	- Requires zig `v0.16`
84	84		- Clone the repo
85	85		- Run build cmd
86	86

...	...		@@ -27,6 +27,7 @@ pub fn build(b: *std.Build) void {
27	27		.root_source_file = b.path("src/main.zig"),
28	28		.target = target,
29	29		.optimize = optimize,
	30	+	.link_libc = true,
30	31		});
31	32		exe_mod.addOptions("build_options", options);
32	33

...	...		@@ -54,7 +55,7 @@ pub fn build(b: *std.Build) void {
54	55		.use_lld = !is_macos,
55	56		.root_module = exe_mod,
56	57		});
57		-	exe.linkLibC();
	58	+
58	59		b.installArtifact(exe);
59	60		const run_cmd = b.addRunArtifact(exe);
60	61		run_cmd.step.dependOn(b.getInstallStep());

...	...		@@ -69,6 +70,7 @@ pub fn build(b: *std.Build) void {
69	70		.root_source_file = b.path("src/test.zig"),
70	71		.target = target,
71	72		.optimize = optimize,
	73	+	.link_libc = true,
72	74		});
73	75		const test_dep = b.dependency("ghostty", .{
74	76		.target = target,

...	...		@@ -86,7 +88,7 @@ pub fn build(b: *std.Build) void {
86	88		.use_llvm = true,
87	89		.use_lld = !is_macos,
88	90		});
89		-	exe_unit_tests.linkLibC();
	91	+
90	92		const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
91	93		test_step.dependOn(&run_exe_unit_tests.step);
92	94		}

...	...		@@ -100,7 +102,6 @@ pub fn build(b: *std.Build) void {
100	102		.use_lld = !is_macos,
101	103		.root_module = exe_mod,
102	104		});
103		-	exe_check.linkLibC();
104	105
105	106		// Finally we add the "check" step which will be detected
106	107		// by ZLS and automatically enable Build-On-Save.

...	...		@@ -121,6 +122,7 @@ pub fn build(b: *std.Build) void {
121	122		.root_source_file = b.path("src/main.zig"),
122	123		.target = resolved,
123	124		.optimize = .ReleaseSafe,
	125	+	.link_libc = true,
124	126		});
125	127		release_mod.addOptions("build_options", options);
126	128

...	...		@@ -141,7 +143,6 @@ pub fn build(b: *std.Build) void {
141	143		.use_lld = !is_local_macos,
142	144		.root_module = release_mod,
143	145		});
144		-	release_exe.linkLibC();
145	146
146	147		const os_name = @tagName(release_target.os_tag orelse .linux);
147	148		const arch_name = @tagName(release_target.cpu_arch orelse .x86_64);

...	...		@@ -156,7 +157,7 @@ pub fn build(b: *std.Build) void {
156	157
157	158		const shasum = b.addSystemCommand(&.{"sha256sum"});
158	159		shasum.addFileArg(tarball);
159		-	const shasum_output = shasum.captureStdOut();
	160	+	const shasum_output = shasum.captureStdOut(.{});
160	161
161	162		const install_tar = b.addInstallFile(tarball, b.fmt("dist/{s}", .{tarball_name}));
162	163		const install_sha = b.addInstallFile(

...	...		@@ -2,6 +2,7 @@ const std = @import("std");
2	2		const posix = std.posix;
3	3		const cross = @import("cross.zig");
4	4		const socket = @import("socket.zig");
	5	+	const lib_posix = @import("posix.zig");
5	6
6	7		pub const Tag = enum(u8) {
7	8		Input = 0,

...	...		@@ -115,7 +116,7 @@ pub fn appendMessage(
115	116		fn writeAll(fd: i32, data: []const u8) !void {
116	117		var index: usize = 0;
117	118		while (index < data.len) {
118		-	const n = try posix.write(fd, data[index..]);
	119	+	const n = try lib_posix.write(fd, data[index..]);
119	120		if (n == 0) return error.DiskQuota;
120	121		index += n;
121	122		}

...	...		@@ -223,7 +224,7 @@ const SessionProbeResult = struct {
223	224
224	225		pub fn deinit(self: *const SessionProbeResult) void {
225	226		if (self.labels) \|lbl\| self.alloc.free(lbl);
226		-	posix.close(self.fd);
	227	+	lib_posix.close(self.fd);
227	228		}
228	229		};
229	230

...	...		@@ -233,7 +234,7 @@ pub fn probeSession(
233	234		) SessionProbeError!SessionProbeResult {
234	235		const timeout_ms = 1000;
235	236		const fd = try connectSession(socket_path);
236		-	errdefer posix.close(fd);
	237	+	errdefer lib_posix.close(fd);
237	238
238	239		send(fd, .Info, "") catch return error.Unexpected;
239	240		send(fd, .LabelGet, "") catch {};

...	...		@@ -320,7 +321,7 @@ pub fn roundTripForTag(
320	321		) SessionProbeError![]u8 {
321	322		const timeout_ms = 1000;
322	323		const fd = try connectSession(socket_path);
323		-	defer posix.close(fd);
	324	+	defer lib_posix.close(fd);
324	325
325	326		send(fd, request_tag, payload) catch return error.Unexpected;
326	327

...	...		@@ -1,50 +1,52 @@
1	1		const std = @import("std");
2		-	const posix = std.posix;
3	2
4	3		pub const LogSystem = struct {
5		-	file: ?std.fs.File = null,
6		-	mutex: std.Thread.Mutex = .{},
	4	+	file: ?std.Io.File = null,
	5	+	mutex: std.Io.Mutex = .init,
7	6		current_size: u64 = 0,
8	7		max_size: u64 = 5 * 1024 * 1024, // 5MB
9	8		path: []const u8 = "",
10	9		alloc: std.mem.Allocator = undefined,
11		-	mode: u32 = 0o640,
	10	+	io: std.Io = undefined,
	11	+	mode: std.Io.File.Permissions = std.Io.File.Permissions.fromMode(0o640),
12	12
13		-	pub fn init(self: *LogSystem, alloc: std.mem.Allocator, path: []const u8, mode: u32) !void {
	13	+	pub fn init(self: *LogSystem, alloc: std.mem.Allocator, io: std.Io, path: []const u8, mode: std.Io.File.Permissions) !void {
14	14		self.alloc = alloc;
	15	+	self.io = io;
15	16		self.path = try alloc.dupe(u8, path);
16	17		self.mode = mode;
17	18
18		-	const file = std.fs.openFileAbsolute(path, .{ .mode = .read_write }) catch \|err\| switch (err) {
19		-	error.FileNotFound => try std.fs.createFileAbsolute(
	19	+	const file = std.Io.Dir.openFileAbsolute(self.io, path, .{ .mode = .read_write }) catch \|err\| switch (err) {
	20	+	error.FileNotFound => try std.Io.Dir.createFileAbsolute(
	21	+	self.io,
20	22		path,
21		-	.{ .read = true, .mode = @intCast(self.mode) },
	23	+	.{ .read = true, .permissions = self.mode },
22	24		),
23	25		else => return err,
24	26		};
25	27
26		-	// fstat (not getEndPos) to avoid the statx syscall; see #186.
27		-	const st = try posix.fstat(file.handle);
28		-	const end_pos: u64 = @intCast(st.size);
29		-	try file.seekTo(end_pos);
	28	+	const end_pos = try std.Io.File.length(file, self.io);
	29	+	var buf: [1]u8 = undefined;
	30	+	var w = std.Io.File.writer(file, self.io, &buf);
	31	+	try w.seekTo(end_pos);
30	32		self.current_size = end_pos;
31	33		self.file = file;
32	34		}
33	35
34	36		pub fn deinit(self: *LogSystem) void {
35		-	if (self.file) \|f\| f.close();
	37	+	if (self.file) \|f\| std.Io.File.close(f, self.io);
36	38		if (self.path.len > 0) self.alloc.free(self.path);
37	39		}
38	40
39	41		pub fn log(
40	42		self: *LogSystem,
41	43		comptime level: std.log.Level,
42		-	comptime scope: @Type(.enum_literal),
	44	+	comptime scope: anytype,
43	45		comptime format: []const u8,
44	46		args: anytype,
45		-	) void {
46		-	self.mutex.lock();
47		-	defer self.mutex.unlock();
	47	+	) !void {
	48	+	try self.mutex.lock(self.io);
	49	+	defer self.mutex.unlock(self.io);
48	50
49	51		if (self.file == null) {
50	52		std.log.defaultLog(level, scope, format, args);

...	...		@@ -57,7 +59,7 @@ pub const LogSystem = struct {
57	59		};
58	60		}
59	61
60		-	const now = std.time.milliTimestamp();
	62	+	const now: i64 = @intCast(@divTrunc(std.Io.Timestamp.now(self.io, .real).nanoseconds, std.time.ns_per_ms));
61	63		const prefix = "[{d}] [{s}] ({s}): ";
62	64		const scope_name = @tagName(scope);
63	65		const level_name = level.asText();

...	...		@@ -76,29 +78,34 @@ pub const LogSystem = struct {
76	78		self.current_size += total_len;
77	79
78	80		var buf: [4096]u8 = undefined;
79		-	var w = f.writerStreaming(&buf);
80		-	w.interface.print(prefix ++ format ++ "\n", prefix_args ++ args) catch {};
	81	+	var w = f.writerStreaming(self.io, &buf);
	82	+	std.Io.Writer.print(&w.interface, prefix ++ format ++ "\n", prefix_args ++ args) catch {};
81	83		w.interface.flush() catch {};
82	84		}
83	85		}
84	86
85	87		fn rotate(self: *LogSystem) !void {
86	88		if (self.file) \|f\| {
87		-	f.close();
	89	+	std.Io.File.close(f, self.io);
88	90		self.file = null;
89	91		}
90	92
91	93		const old_path = try std.fmt.allocPrint(self.alloc, "{s}.old", .{self.path});
92	94		defer self.alloc.free(old_path);
93	95
94		-	std.fs.renameAbsolute(self.path, old_path) catch \|err\| switch (err) {
	96	+	std.Io.Dir.renameAbsolute(self.path, old_path, self.io) catch \|err\| switch (err) {
95	97		error.FileNotFound => {},
96	98		else => return err,
97	99		};
98	100
99		-	self.file = try std.fs.createFileAbsolute(
	101	+	self.file = try std.Io.Dir.createFileAbsolute(
	102	+	self.io,
100	103		self.path,
101		-	.{ .truncate = true, .read = true, .mode = @intCast(self.mode) },
	104	+	.{
	105	+	.truncate = true,
	106	+	.read = true,
	107	+	.permissions = self.mode,
	108	+	},
102	109		);
103	110		self.current_size = 0;
104	111		}

...	...		@@ -9,6 +9,7 @@ const util = @import("util.zig");
9	9		const cross = @import("cross.zig");
10	10		const socket = @import("socket.zig");
11	11		const label = @import("label.zig");
	12	+	const lib_posix = @import("posix.zig");
12	13
13	14		pub const version = build_options.version;
14	15		pub const ghostty_version = build_options.ghostty_version;

...	...		@@ -22,11 +23,11 @@ pub const std_options: std.Options = .{
22	23
23	24		fn zmxLogFn(
24	25		comptime level: std.log.Level,
25		-	comptime scope: @Type(.enum_literal),
	26	+	comptime scope: anytype,
26	27		comptime format: []const u8,
27	28		args: anytype,
28	29		) void {
29		-	log_system.log(level, scope, format, args);
	30	+	log_system.log(level, scope, format, args) catch {};
30	31		}
31	32
32	33		/// Self-pipe woken by signal handlers. std.posix.poll loops on .INTR internally

Commit 4232d74

Commit `4232d74`

...	...		@@ -47,13 +48,13 @@ const SessionMatch = struct {
47	48		}
48	49		};
49	50
50		-	fn resolveSessionOrEnv(alloc: std.mem.Allocator, session_name: ?[]const u8) ![]const u8 {
	51	+	fn resolveSessionOrEnv(alloc: std.mem.Allocator, io: std.Io, session_name: ?[]const u8) ![]const u8 {
51	52		const sesh_env = socket.getSeshNameFromEnv();
52	53		const raw = if (session_name) \|name\|
53	54		if (std.mem.eql(u8, name, ".")) blk: {
54	55		if (sesh_env.len > 0) break :blk sesh_env;
55	56		var buf: [4096]u8 = undefined;
56		-	var w = std.fs.File.stderr().writer(&buf);
	57	+	var w = std.Io.File.stderr().writer(io, &buf);
57	58		w.interface.print("error: \".\" requires ZMX_SESSION (are you inside a zmx session?)\n", .{}) catch {};
58	59		w.interface.flush() catch {};
59	60		return error.SessionNameRequired;

...	...		@@ -76,7 +77,7 @@ fn parseSessionArg(alloc: std.mem.Allocator, raw: []const u8) !SessionMatch {
76	77		}
77	78
78	79		fn openSignalPipe() !void {
79		-	sig_pipe = try posix.pipe2(.{ .CLOEXEC = true, .NONBLOCK = true });
	80	+	sig_pipe = try lib_posix.pipe2(.{ .CLOEXEC = true, .NONBLOCK = true });
80	81		}
81	82
82	83		fn drainSignalPipe() void {

...	...		@@ -91,9 +92,9 @@ fn detectHelp(arg: []const u8) bool {
91	92		return (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h"));
92	93		}
93	94
94		-	pub fn main() !void {
95		-	// use c_allocator to avoid "reached unreachable code" panic in DebugAllocator when forking
96		-	const alloc = std.heap.c_allocator;
	95	+	pub fn main(init: std.process.Init) !void {
	96	+	const gpa = init.gpa;
	97	+	const io = init.io;
97	98
98	99		// Every subcommand may write to a Unix-domain socket; a peer that
99	100		// disappears between probe and send would otherwise kill us before

...	...		@@ -101,76 +102,79 @@ pub fn main() !void {
101	102		// covers the daemon.
102	103		ignoreSigpipe();
103	104
104		-	var args = try std.process.argsWithAllocator(alloc);
	105	+	var args = init.minimal.args.iterate();
105	106		defer args.deinit();
106		-	_ = args.skip(); // skip program name
	107	+	_ = args.next(); // skip program name
107	108
108		-	var cfg = try Cfg.init(alloc);
109		-	defer cfg.deinit(alloc);
	109	+	var cfg = try Cfg.init(gpa, io);
	110	+	defer cfg.deinit(gpa);
110	111
111		-	const log_path = try std.fs.path.join(alloc, &.{ cfg.log_dir, "zmx.log" });
112		-	defer alloc.free(log_path);
113		-	try log_system.init(alloc, log_path, cfg.log_mode);
	112	+	const log_path = try std.fs.path.join(gpa, &.{ cfg.log_dir, "zmx.log" });
	113	+	defer gpa.free(log_path);
	114	+	const log_mode = std.Io.File.Permissions.fromMode(cfg.log_mode);
	115	+	try log_system.init(gpa, io, log_path, log_mode);
114	116		defer log_system.deinit();
115	117
	118	+	const shell_env = init.environ_map.get("SHELL") orelse "/bin/sh";
	119	+
116	120		const cmd = args.next() orelse {
117		-	return list(&cfg, false);
	121	+	return list(gpa, io, &cfg, false);
118	122		};
119	123
120	124		if (std.mem.eql(u8, cmd, "version") or std.mem.eql(u8, cmd, "v") or std.mem.eql(u8, cmd, "-v") or std.mem.eql(u8, cmd, "--version")) {
121		-	return printVersion(&cfg);
	125	+	return printVersion(io, &cfg);
122	126		} else if (std.mem.eql(u8, cmd, "help") or std.mem.eql(u8, cmd, "h") or std.mem.eql(u8, cmd, "-h")) {
123		-	return help();
	127	+	return help(io);
124	128		} else if (std.mem.eql(u8, cmd, "list") or std.mem.eql(u8, cmd, "l") or std.mem.eql(u8, cmd, "ls")) {
125	129		var short = false;
126	130		while (args.next()) \|arg\| {
127		-	if (detectHelp(arg)) return help();
	131	+	if (detectHelp(arg)) return help(io);
128	132		if (std.mem.eql(u8, arg, "--short")) short = true;
129	133		}
130		-	return list(&cfg, short);
	134	+	return list(gpa, io, &cfg, short);
131	135		} else if (std.mem.eql(u8, cmd, "get") or std.mem.eql(u8, cmd, "g")) {
132	136		const sesh_name = args.next() orelse return error.SessionNameRequired;
133		-	if (detectHelp(sesh_name)) return help();
134		-	const sesh = try resolveSessionOrEnv(alloc, sesh_name);
135		-	defer alloc.free(sesh);
	137	+	if (detectHelp(sesh_name)) return help(io);
	138	+	const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
	139	+	defer gpa.free(sesh);
136	140		const single_kv = args.next() orelse "";
137		-	return labelGet(&cfg, sesh, single_kv);
	141	+	return labelGet(gpa, io, &cfg, sesh, single_kv);
138	142		} else if (std.mem.eql(u8, cmd, "set")) {
139	143		const sesh_name = args.next() orelse return error.SessionNameRequired;
140		-	if (detectHelp(sesh_name)) return help();
141		-	const sesh = try resolveSessionOrEnv(alloc, sesh_name);
142		-	defer alloc.free(sesh);
	144	+	if (detectHelp(sesh_name)) return help(io);
	145	+	const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
	146	+	defer gpa.free(sesh);
143	147
144	148		var kvs = std.ArrayList(u8).empty;
145		-	defer kvs.deinit(alloc);
	149	+	defer kvs.deinit(gpa);
146	150		var first = true;
147	151		while (args.next()) \|arg\| {
148		-	if (!first) try kvs.append(alloc, ' ');
149		-	try kvs.appendSlice(alloc, arg);
	152	+	if (!first) try kvs.append(gpa, ' ');
	153	+	try kvs.appendSlice(gpa, arg);
150	154		first = false;
151	155		}
152		-	return labelSet(&cfg, sesh, kvs.items);
	156	+	return labelSet(gpa, io, &cfg, sesh, kvs.items);
153	157		} else if (std.mem.eql(u8, cmd, "clear")) {
154	158		const sesh_name = args.next() orelse return error.SessionNameRequired;
155		-	if (detectHelp(sesh_name)) return help();
156		-	const sesh = try resolveSessionOrEnv(alloc, sesh_name);
157		-	defer alloc.free(sesh);
158		-	return labelClear(&cfg, sesh);
	159	+	if (detectHelp(sesh_name)) return help(io);
	160	+	const sesh = try resolveSessionOrEnv(gpa, io, sesh_name);
	161	+	defer gpa.free(sesh);
	162	+	return labelClear(gpa, io, &cfg, sesh);
159	163		} else if (std.mem.eql(u8, cmd, "completions") or std.mem.eql(u8, cmd, "c")) {
160	164		const arg = args.next() orelse return;
161	165		if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
162		-	return help();
	166	+	return help(io);
163	167		}
164	168		const shell = completions.Shell.fromString(arg) orelse return;
165		-	return printCompletions(shell);
	169	+	return printCompletions(io, shell);
166	170		} else if (std.mem.eql(u8, cmd, "detach") or std.mem.eql(u8, cmd, "d")) {
167		-	return detachAll(&cfg);
	171	+	return detachAll(gpa, io, &cfg);
168	172		} else if (std.mem.eql(u8, cmd, "history") or std.mem.eql(u8, cmd, "hi")) {
169	173		var session_name: ?[]const u8 = null;
170	174		var format: util.HistoryFormat = .plain;
171	175		while (args.next()) \|arg\| {
172	176		if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
173		-	return help();
	177	+	return help(io);
174	178		} else if (std.mem.eql(u8, arg, "--vt")) {
175	179		format = .vt;
176	180		} else if (std.mem.eql(u8, arg, "--html")) {

...	...		@@ -180,47 +184,50 @@ pub fn main() !void {
180	184		}
181	185		}
182	186		const sesh_env = socket.getSeshNameFromEnv();
183		-	const sesh = try socket.getSeshName(alloc, session_name orelse sesh_env);
184		-	defer alloc.free(sesh);
185		-	return history(&cfg, sesh, format);
	187	+	const sesh = try socket.getSeshName(gpa, session_name orelse sesh_env);
	188	+	defer gpa.free(sesh);
	189	+	return history(gpa, io, &cfg, sesh, format);
186	190		} else if (std.mem.eql(u8, cmd, "attach") or std.mem.eql(u8, cmd, "a")) {
187	191		const session_name = args.next() orelse "";
188	192		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
189		-	return help();
	193	+	return help(io);
190	194		}
191	195
192	196		var command_args: std.ArrayList([]const u8) = .empty;
193		-	defer command_args.deinit(alloc);
	197	+	defer command_args.deinit(gpa);
194	198		while (args.next()) \|arg\| {
195		-	try command_args.append(alloc, arg);
	199	+	try command_args.append(gpa, arg);
196	200		}
197	201
198		-	const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
	202	+	const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);
199	203		var command: ?[][]const u8 = null;
200	204		if (command_args.items.len > 0) {
201	205		command = command_args.items;
202	206		}
203	207
204	208		var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
205		-	const cwd = std.posix.getcwd(&cwd_buf) catch "";
	209	+	const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
	210	+	const cwd = cwd_buf[0..cwd_len];
206	211
207		-	const sesh = try socket.getSeshName(alloc, session_name);
208		-	defer alloc.free(sesh);
	212	+	const sesh = try socket.getSeshName(gpa, session_name);
	213	+	defer gpa.free(sesh);
209	214		var daemon = Daemon{
	215	+	.io = io,
210	216		.running = true,
211	217		.cfg = &cfg,
212		-	.alloc = alloc,
	218	+	.alloc = std.heap.c_allocator,
213	219		.clients = clients,
214	220		.session_name = sesh,
215	221		.socket_path = undefined,
216	222		.pid = undefined,
217	223		.command = command,
218	224		.cwd = cwd,
219		-	.created_at = @intCast(std.time.timestamp()),
	225	+	.created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
220	226		.leader_client_fd = null,
	227	+	.shell = shell_env,
221	228		};
222		-	daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch \|err\| switch (err) {
223		-	error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
	229	+	daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch \|err\| switch (err) {
	230	+	error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
224	231		error.OutOfMemory => return err,
225	232		};
226	233		std.log.info("socket path={s}", .{daemon.socket_path});

...	...		@@ -228,42 +235,45 @@ pub fn main() !void {
228	235		} else if (std.mem.eql(u8, cmd, "run") or std.mem.eql(u8, cmd, "r")) {
229	236		const session_name = args.next() orelse "";
230	237		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
231		-	return help();
	238	+	return help(io);
232	239		}
233	240
234	241		var cmd_args_raw: std.ArrayList([]const u8) = .empty;
235		-	defer cmd_args_raw.deinit(alloc);
	242	+	defer cmd_args_raw.deinit(gpa);
236	243		var detached = false;
237	244		while (args.next()) \|arg\| {
238	245		if (std.mem.startsWith(u8, arg, "-d")) {
239	246		detached = true;
240	247		} else {
241		-	try cmd_args_raw.append(alloc, arg);
	248	+	try cmd_args_raw.append(gpa, arg);
242	249		}
243	250		}
244		-	const clients = try std.ArrayList(*Client).initCapacity(alloc, 10);
	251	+	const clients = try std.ArrayList(*Client).initCapacity(gpa, 10);
245	252
246	253		var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
247		-	const cwd = std.posix.getcwd(&cwd_buf) catch "";
	254	+	const cwd_len = std.process.currentPath(io, &cwd_buf) catch 0;
	255	+	const cwd = cwd_buf[0..cwd_len];
248	256
249		-	const sesh = try socket.getSeshName(alloc, session_name);
250		-	defer alloc.free(sesh);
	257	+	const sesh = try socket.getSeshName(gpa, session_name);
	258	+	defer gpa.free(sesh);
251	259		var daemon = Daemon{
	260	+	.io = io,
252	261		.running = true,
253	262		.cfg = &cfg,
254		-	.alloc = alloc,
	263	+	.alloc = std.heap.c_allocator,
255	264		.clients = clients,
256	265		.session_name = sesh,
257	266		.socket_path = undefined,
258	267		.pid = undefined,
259	268		.command = null,
260	269		.cwd = cwd,
261		-	.created_at = @intCast(std.time.timestamp()),
	270	+	.created_at = @intCast(std.Io.Timestamp.now(io, .real).nanoseconds),
262	271		.is_task_mode = true,
263	272		.leader_client_fd = null,
	273	+	.shell = shell_env,
264	274		};
265		-	daemon.socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch \|err\| switch (err) {
266		-	error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
	275	+	daemon.socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch \|err\| switch (err) {
	276	+	error.NameTooLong => return socket.printSessionNameTooLong(daemon.io, sesh, cfg.socket_dir),
267	277		error.OutOfMemory => return err,
268	278		};
269	279		std.log.info("socket path={s}", .{daemon.socket_path});

...	...		@@ -271,76 +281,76 @@ pub fn main() !void {
271	281		} else if (std.mem.eql(u8, cmd, "send") or std.mem.eql(u8, cmd, "s")) {
272	282		const session_name = args.next() orelse "";
273	283		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
274		-	return help();
	284	+	return help(io);
275	285		}
276	286		if (session_name.len == 0) return error.SessionNameRequired;
277	287
278	288		var text_parts: std.ArrayList([]const u8) = .empty;
279		-	defer text_parts.deinit(alloc);
	289	+	defer text_parts.deinit(gpa);
280	290		while (args.next()) \|arg\| {
281		-	try text_parts.append(alloc, arg);
	291	+	try text_parts.append(gpa, arg);
282	292		}
283	293
284		-	const sesh = try socket.getSeshName(alloc, session_name);
285		-	defer alloc.free(sesh);
286		-	const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch \|err\| switch (err) {
287		-	error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
	294	+	const sesh = try socket.getSeshName(gpa, session_name);
	295	+	defer gpa.free(sesh);
	296	+	const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch \|err\| switch (err) {
	297	+	error.NameTooLong => return socket.printSessionNameTooLong(io, sesh, cfg.socket_dir),
288	298		error.OutOfMemory => return err,
289	299		};
290		-	return send(&cfg, sesh, socket_path, text_parts.items, .Send);
	300	+	return send(gpa, io, &cfg, sesh, socket_path, text_parts.items, .Send);
291	301		} else if (std.mem.eql(u8, cmd, "print") or std.mem.eql(u8, cmd, "p")) {
292	302		const session_name = args.next() orelse "";
293	303		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
294		-	return help();
	304	+	return help(io);
295	305		}
296	306		if (session_name.len == 0) return error.SessionNameRequired;
297	307
298	308		var text_parts: std.ArrayList([]const u8) = .empty;
299		-	defer text_parts.deinit(alloc);
	309	+	defer text_parts.deinit(gpa);
300	310		while (args.next()) \|arg\| {
301		-	try text_parts.append(alloc, arg);
	311	+	try text_parts.append(gpa, arg);
302	312		}
303	313
304		-	const sesh = try socket.getSeshName(alloc, session_name);
305		-	defer alloc.free(sesh);
306		-	const socket_path = socket.getSocketPath(alloc, cfg.socket_dir, sesh) catch \|err\| switch (err) {
307		-	error.NameTooLong => return socket.printSessionNameTooLong(sesh, cfg.socket_dir),
	314	+	const sesh = try socket.getSeshName(gpa, session_name);
	315	+	defer gpa.free(sesh);
	316	+	const socket_path = socket.getSocketPath(gpa, cfg.socket_dir, sesh) catch \|err\| switch (err) {
	317	+	error.NameTooLong => return socket.printSessionNameTooLong(io, sesh, cfg.socket_dir),
308	318		error.OutOfMemory => return err,
309	319		};
310		-	return send(&cfg, sesh, socket_path, text_parts.items, .Output);
	320	+	return send(gpa, io, &cfg, sesh, socket_path, text_parts.items, .Output);
311	321		} else if (std.mem.eql(u8, cmd, "kill") or std.mem.eql(u8, cmd, "k")) {
312	322		var stderr_buffer: [1024]u8 = undefined;
313		-	var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
	323	+	var stderr_writer = std.Io.File.stderr().writer(io, &stderr_buffer);
314	324		const stderr = &stderr_writer.interface;
315	325
316	326		var matchers: std.ArrayList(SessionMatch) = .empty;
317	327		defer {
318	328		for (matchers.items) \|m\| {
319		-	alloc.free(m.name);
	329	+	gpa.free(m.name);
320	330		}
321		-	matchers.deinit(alloc);
	331	+	matchers.deinit(gpa);
322	332		}
323	333		var force = false;
324	334		while (args.next()) \|session_name\| {
325	335		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
326		-	return help();
	336	+	return help(io);
327	337		}
328	338		if (std.mem.eql(u8, session_name, "--force")) {
329	339		force = true;
330	340		continue;
331	341		}
332		-	const m = try parseSessionArg(alloc, session_name);
333		-	try matchers.append(alloc, m);
	342	+	const m = try parseSessionArg(gpa, session_name);
	343	+	try matchers.append(gpa, m);
334	344		}
335	345		if (matchers.items.len == 0) {
336	346		return error.SessionNameRequired;
337	347		}
338		-	var sessions = try util.get_session_entries(alloc, cfg.socket_dir);
	348	+	var sessions = try util.get_session_entries(gpa, io, cfg.socket_dir);
339	349		defer {
340	350		for (sessions.items) \|session\| {
341		-	session.deinit(alloc);
	351	+	session.deinit(gpa);
342	352		}
343		-	sessions.deinit(alloc);
	353	+	sessions.deinit(gpa);
344	354		}
345	355
346	356		for (sessions.items) \|session\| {

...	...		@@ -349,7 +359,7 @@ pub fn main() !void {
349	359		continue;
350	360		}
351	361
352		-	kill(&cfg, session.name, force) catch \|err\| {
	362	+	kill(gpa, io, &cfg, session.name, force) catch \|err\| {
353	363		try stderr.print(
354	364		"failed to kill session={s}: {s}\n",
355	365		.{ session.name, @errorName(err) },

...	...		@@ -363,35 +373,35 @@ pub fn main() !void {
363	373		var matchers: std.ArrayList(SessionMatch) = .empty;
364	374		defer {
365	375		for (matchers.items) \|m\| {
366		-	alloc.free(m.name);
	376	+	gpa.free(m.name);
367	377		}
368		-	matchers.deinit(alloc);
	378	+	matchers.deinit(gpa);
369	379		}
370	380		while (args.next()) \|session_name\| {
371	381		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
372		-	return help();
	382	+	return help(io);
373	383		}
374		-	const m = try parseSessionArg(alloc, session_name);
375		-	try matchers.append(alloc, m);
	384	+	const m = try parseSessionArg(gpa, session_name);
	385	+	try matchers.append(gpa, m);
376	386		}
377	387		if (matchers.items.len == 0) {
378	388		return error.SessionNameRequired;
379	389		}
380		-	return wait(&cfg, matchers);
	390	+	return wait(gpa, io, &cfg, matchers);
381	391		} else if (std.mem.eql(u8, cmd, "tail") or std.mem.eql(u8, cmd, "t")) {
382	392		var matchers: std.ArrayList(SessionMatch) = .empty;
383	393		defer {
384	394		for (matchers.items) \|m\| {
385		-	alloc.free(m.name);
	395	+	gpa.free(m.name);
386	396		}
387		-	matchers.deinit(alloc);
	397	+	matchers.deinit(gpa);
388	398		}
389	399		while (args.next()) \|session_name\| {
390	400		if (std.mem.eql(u8, session_name, "--help") or std.mem.eql(u8, session_name, "-h")) {
391		-	return help();
	401	+	return help(io);
392	402		}
393		-	const m = try parseSessionArg(alloc, session_name);
394		-	try matchers.append(alloc, m);
	403	+	const m = try parseSessionArg(gpa, session_name);
	404	+	try matchers.append(gpa, m);
395	405		}
396	406		if (matchers.items.len == 0) {
397	407		return error.SessionNameRequired;

...	...		@@ -401,9 +411,9 @@ pub fn main() !void {
401	411		var resolved_names: std.ArrayList([]const u8) = .empty;
402	412		defer {
403	413		for (resolved_names.items) \|name\| {
404		-	alloc.free(name);
	414	+	gpa.free(name);
405	415		}
406		-	resolved_names.deinit(alloc);
	416	+	resolved_names.deinit(gpa);
407	417		}
408	418
409	419		var any_prefix = false;