chore: update to zig 0.16 and zigzag v0.1.5 (#3)

* chore: update to zig 0.16 and zigzag v0.1.5

Migrates sshz to Zig 0.16's reworked I/O model, where filesystem,
process, and network operations require an `Io` instance. The main
entry point now takes `std.process.Init`, and `io` plus `environ_map`
are threaded through ssh_config, meta, app, and checker.

Notable changes:
- main: `std.process.spawn(io, ...)` replaces `std.process.Child.init`
- main: `std.Io.File.stdout()` replaces `std.fs.File{ .handle = ... }`
- main: `init.minimal.args.toSlice(arena)` replaces `argsAlloc/argsFree`
- ssh_config/meta: switch to `std.Io.Dir.cwd()` with buffered writers
  and `init.environ_map.get("HOME")` for env access
- checker: use `std.Io.net.HostName.connect(io, port, .{})` for TCP
  status checks
- views: `zz.Color.cyan`/`white` are now consts (not functions)
- CI: install Zig 0.16.0
- build.zig.zon: bump zigzag to v0.1.5, set minimum_zig_version

Note: the zigzag dependency hash needs to be regenerated with
`zig fetch --save=zigzag <url>` against a real Zig 0.16 toolchain;
the current value in build.zig.zon is the v0.1.2 hash and will be
rejected at build time.

* fix: correct readFileAlloc/rename param order for zig 0.16

- readFileAlloc takes (io, sub_path, gpa, limit) not (io, gpa, sub_path, limit)
- rename uses method call style: dir.rename(old_path, new_dir, new_path, io)

* fix: use ArrayList .empty and std.Io.Mutex for zig 0.16

- Unmanaged std.ArrayList no longer has default field values, so .{}
  initialization fails; switch to .empty
- std.Thread.Mutex is gone; use std.Io.Mutex with lockUncancelable(io)
  and unlock(io)
- ResultQueue now also takes an Io instance so its mutex can lock

* fix: use std.Io.Timestamp.now() instead of removed std.time.timestamp

* fix: complete migration to zig 0.16 - build and tests pass

- build.zig.zon: use real v0.1.5 hash from zig fetch
- app.zig: ArrayList(...).empty (not .{}) for new unmanaged ArrayList
- checker.zig: pass .mode = .stream for HostName.connect
- meta.zig/utils.zig/ssh_config.zig: route io through for the new
  std.Io.Timestamp.now(.real) clock API
- tests/test_meta.zig: pass std.testing.io to recordConnection

Verified locally: zig 0.16.0 builds the exe, all 29 tests pass,
and zig fmt --check src/ is clean.

* chore: remove accidentally committed zig-pkg cache, add to .gitignore

* fix: address PR #3 review feedback

- main: guard args[1][0] with len > 0 to avoid OOB on empty arg
- checker: unlock mutex on toOwnedSlice OOM in joinAllThreads
- checker: parse IPv4/IPv6 literals before HostName.init so bare
  IPv6 hosts no longer always report offline
- ssh_config: createDirPath before openDir in writeFile so save
  succeeds when ~/.ssh is missing
- ssh_config/meta: propagate dir/file errors instead of swallowing
  them in createDirPath/backupFile/rotateBackups

* fix: address pre-existing bugs flagged in PR #3 review

- ssh_config: Config now owns the raw file buffer so hosts/raw_lines
  slices remain valid after readFile (CodeRabbit critical: dangling
  reference on `parse` content)
- meta: JSON-escape host names, tags, and port-forward fields when
  serialising so values containing `"`, `\\`, or control characters
  no longer corrupt meta.json (CodeRabbit major)
- app.deleteSelectedHost: look up the config entry by name from the
  visible list instead of by display index, so sorting no longer
  causes the wrong host to be deleted (CodeRabbit critical)
- app.saveForm: always call setTags so clearing the tags field in
  the edit form persists an empty list (CodeRabbit major)
- app.connectToSelected: stop recording the connection in the TUI
  path; directConnect already records it after the TUI exits, so
  this was double-counting connect_count (CodeAnt major)

* fix: maintain visible_indices so search/tag filters keep selected in sync

Move filter logic from the renderer into Model.rebuildVisibleIndices.
`selected` is now an index into `visible_indices` (the filtered display
order), so navigation, edit ('e'), forward ('f'), delete ('d'),
connect (Enter), and confirm-delete prompts all reference the same
host the user actually sees highlighted, regardless of search text or
tag filter.

- add Model.visible_indices, rebuilt on rebuildHostList,
  cycleSortMode, cycleTagFilter, and every search-text mutation
- moveDown bounds-check against visible_indices.items.len
- views/host_list.zig drops matchesSearch/hasTag (now in app.zig)
  and iterates model.visible_indices directly

* fix: deep-copy strings in ssh_config so addHost/removeHost don't leak

`parse` previously returned a `Config` whose `Host` fields and
`raw_lines` borrowed from the input buffer; `addHost` mixed in
allocPrint'd lines, leaving `deinit` unable to tell which strings to
free. The pre-existing leak forced one test to use `page_allocator`
and skip `deinit` entirely.

This change makes Config the sole owner of every string inside it:

- `parse` deep-copies host names, host fields, and every raw line
  (with `errdefer` cleanup on partial OOM)
- `setHostField` becomes fallible and dupes its value
- `addHost` deep-copies its incoming `Host` and lines, then commits
  with a two-phase swap so a failed `toOwnedSlice` doesn't strand
  half-owned state on `config`
- `removeHost` frees the dropped host's strings and the dropped
  `raw_lines` entries
- `Config.deinit` walks hosts/lines and frees their strings via a
  shared `freeHostStrings` helper
- `readFile` reverts to `defer free(content)` — no buffer transfer
  needed now that `parse` owns its copies
- `Model.saveForm` no longer pre-dupes form values, since `addHost`
  now takes ownership; this also closes a leak when the form `name`
  field was empty
- ssh_config tests for addHost switch to `std.testing.allocator`
  with `defer config.deinit(...)`, validating the ownership story
  with the leak detector

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: midasdf <midasdf@users.noreply.github.com>

Author: midasdf

.github/workflows/ci.yml

@@ -18,8 +18,8 @@ jobs:
 
       - name: Install Zig
         run: |
-          curl -sL "https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz" | tar -xJ
-          echo "$PWD/zig-x86_64-linux-0.15.2" >> "$GITHUB_PATH"
+          curl -sL "https://ziglang.org/download/0.16.0/zig-x86_64-linux-0.16.0.tar.xz" | tar -xJ
+          echo "$PWD/zig-x86_64-linux-0.16.0" >> "$GITHUB_PATH"
 
       - name: Format check
         continue-on-error: true

.gitignore

@@ -1,2 +1,3 @@
 .zig-cache/
 zig-out/
+zig-pkg/

build.zig.zon

@@ -2,11 +2,12 @@
     .name = .sshz,
     .version = "0.1.0",
     .fingerprint = 0x138d7fea3306d410,
+    .minimum_zig_version = "0.16.0",
     .paths = .{ "build.zig", "build.zig.zon", "src" },
     .dependencies = .{
         .zigzag = .{
-            .url = "https://github.com/meszmate/zigzag/archive/refs/tags/v0.1.2.tar.gz",
-            .hash = "zigzag-0.1.0-YXwYS20gCwATYmA0IOAYQVHykNP--Dl7bKfp2UDE0K2I",
+            .url = "https://github.com/meszmate/zigzag/archive/refs/tags/v0.1.5.tar.gz",
+            .hash = "zigzag-0.1.2-YXwYS17aEQBlpxPETTrhY5leFh7vV0DpnXJbHogs4Lsv",
         },
     },
 }

src/app.zig

@@ -20,27 +20,28 @@ pub const CheckRequest = struct {
 };
 
 pub const ResultQueue = struct {
-    mutex: std.Thread.Mutex = .{},
-    results: std.ArrayList(CheckResult) = .{},
+    mutex: std.Io.Mutex = std.Io.Mutex.init,
+    results: std.ArrayList(CheckResult) = .empty,
     allocator: std.mem.Allocator,
+    io: std.Io,
 
-    pub fn init(allocator: std.mem.Allocator) ResultQueue {
-        return .{ .allocator = allocator };
+    pub fn init(allocator: std.mem.Allocator, io: std.Io) ResultQueue {
+        return .{ .allocator = allocator, .io = io };
     }
 
     pub fn deinit(self: *ResultQueue) void {
         self.results.deinit(self.allocator);
     }
 
     pub fn push(self: *ResultQueue, result: CheckResult) void {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        self.mutex.lockUncancelable(self.io);
+        defer self.mutex.unlock(self.io);
         self.results.append(self.allocator, result) catch {};
     }
 
     pub fn drain(self: *ResultQueue, allocator: std.mem.Allocator) []CheckResult {
-        self.mutex.lock();
-        defer self.mutex.unlock();
+        self.mutex.lockUncancelable(self.io);
+        defer self.mutex.unlock(self.io);
         if (self.results.items.len == 0) return &.{};
         return self.results.toOwnedSlice(allocator) catch return &.{};
     }
@@ -51,19 +52,21 @@ pub const StatusChecker = struct {
     active_count: std.atomic.Value(u32),
     max_concurrent: u32 = 3,
     shutdown: std.atomic.Value(bool),
-    threads: std.ArrayList(std.Thread) = .{},
-    threads_mutex: std.Thread.Mutex = .{},
+    threads: std.ArrayList(std.Thread) = .empty,
+    threads_mutex: std.Io.Mutex = std.Io.Mutex.init,
     dispatcher_thread: ?std.Thread = null,
     generation: std.atomic.Value(u32),
     allocator: std.mem.Allocator,
+    io: std.Io,
 
-    pub fn init(queue: *ResultQueue, allocator: std.mem.Allocator) StatusChecker {
+    pub fn init(queue: *ResultQueue, allocator: std.mem.Allocator, io: std.Io) StatusChecker {
         return .{
             .queue = queue,
             .active_count = std.atomic.Value(u32).init(0),
             .shutdown = std.atomic.Value(bool).init(false),
             .generation = std.atomic.Value(u32).init(0),
             .allocator = allocator,
+            .io = io,
         };
     }
 
@@ -78,9 +81,12 @@ pub const StatusChecker = struct {
     }
 
     fn joinAllThreads(self: *StatusChecker) void {
-        self.threads_mutex.lock();
-        const threads = self.threads.toOwnedSlice(self.allocator) catch return;
-        self.threads_mutex.unlock();
+        self.threads_mutex.lockUncancelable(self.io);
+        const threads = self.threads.toOwnedSlice(self.allocator) catch {
+            self.threads_mutex.unlock(self.io);
+            return;
+        };
+        self.threads_mutex.unlock(self.io);
         for (threads) |t| t.join();
         self.allocator.free(threads);
     }
@@ -131,27 +137,36 @@ pub const StatusChecker = struct {
                 _ = self.active_count.fetchSub(1, .release);
                 continue;
             };
-            self.threads_mutex.lock();
+            self.threads_mutex.lockUncancelable(self.io);
             self.threads.append(self.allocator, thread) catch {
-                self.threads_mutex.unlock();
+                self.threads_mutex.unlock(self.io);
                 thread.join();
                 continue;
             };
-            self.threads_mutex.unlock();
+            self.threads_mutex.unlock(self.io);
         }
     }
 
     fn checkWorker(self: *StatusChecker, host_index: usize, hostname: []const u8, port: u16, gen: u32) void {
         defer _ = self.active_count.fetchSub(1, .release);
         if (self.shutdown.load(.acquire)) return;
 
-        const status = tcpCheck(hostname, port);
+        const status = tcpCheck(self.io, hostname, port);
         self.queue.push(.{ .host_index = host_index, .status = status, .generation = gen });
     }
 };
 
-fn tcpCheck(hostname: []const u8, port: u16) HostStatus {
-    const stream = std.net.tcpConnectToHost(std.heap.page_allocator, hostname, port) catch return .offline;
-    stream.close();
+fn tcpCheck(io: std.Io, hostname: []const u8, port: u16) HostStatus {
+    // Try IPv4/IPv6 literals first; HostName.init rejects ':' so a bare IPv6
+    // address would otherwise always report offline.
+    if (std.Io.net.IpAddress.parse(hostname, port)) |addr| {
+        const stream = addr.connect(io, .{ .mode = .stream }) catch return .offline;
+        stream.close(io);
+        return .online;
+    } else |_| {}
+
+    const host = std.Io.net.HostName.init(hostname) catch return .offline;
+    const stream = host.connect(io, port, .{ .mode = .stream }) catch return .offline;
+    stream.close(io);
     return .online;
 }

src/checker.zig

@@ -5,42 +5,40 @@ const app = @import("app");
 
 const version = "0.1.0";
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const arena_allocator = init.arena.allocator();
 
-    const args = try std.process.argsAlloc(allocator);
-    defer std.process.argsFree(allocator, args);
+    const args = try init.minimal.args.toSlice(arena_allocator);
 
     if (args.len >= 2 and std.mem.eql(u8, args[1], "--help")) {
-        printUsage();
+        printUsage(init.io);
         return;
     }
 
     if (args.len >= 2 and std.mem.eql(u8, args[1], "--version")) {
-        const file = std.fs.File{ .handle = std.posix.STDOUT_FILENO };
+        const file = std.Io.File.stdout();
         var buf: [256]u8 = undefined;
-        var w = file.writer(&buf);
+        var w = file.writer(init.io, &buf);
         try w.interface.print("sshz {s}\n", .{version});
         try w.interface.flush();
         return;
     }
 
     // sshz <host> [command...] — direct connect
-    if (args.len >= 2 and args[1][0] != '-') {
-        try directConnect(allocator, args[1], args[2..]);
+    if (args.len >= 2 and args[1].len > 0 and args[1][0] != '-') {
+        try directConnect(allocator, init.io, init.environ_map, args[1], args[2..]);
         return;
     }
 
     // sshz — launch TUI
-    try launchTui(allocator);
+    try launchTui(init);
 }
 
-fn printUsage() void {
-    const file = std.fs.File{ .handle = std.posix.STDOUT_FILENO };
+fn printUsage(io: std.Io) void {
+    const file = std.Io.File.stdout();
     var buf: [4096]u8 = undefined;
-    var w = file.writer(&buf);
+    var w = file.writer(io, &buf);
     w.interface.print(
         \\SSHZ - SSH Connection Manager
         \\
@@ -55,8 +53,9 @@ fn printUsage() void {
     w.interface.flush() catch {};
 }
 
-fn launchTui(allocator: std.mem.Allocator) !void {
-    var program = try zz.Program(app.Model).init(allocator);
+fn launchTui(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    var program = try zz.Program(app.Model).init(init.gpa, init.io, init.environ_map);
     try program.run();
 
     // Grab connect_host before deinit frees it
@@ -73,39 +72,40 @@ fn launchTui(allocator: std.mem.Allocator) !void {
     program.deinit();
 
     if (connect_host) |host_name| {
-        try directConnect(allocator, host_name, &.{});
+        try directConnect(allocator, init.io, init.environ_map, host_name, &.{});
     }
 }
 
-fn directConnect(allocator: std.mem.Allocator, host_name: []const u8, extra_args: []const [:0]u8) !void {
+fn directConnect(allocator: std.mem.Allocator, io: std.Io, env: *const std.process.Environ.Map, host_name: []const u8, extra_args: []const [:0]const u8) !void {
     // Record connection in meta.json
-    const meta_path = try meta_mod.defaultMetaPath(allocator);
+    const meta_path = try meta_mod.defaultMetaPath(allocator, env);
     defer allocator.free(meta_path);
 
-    var store = try meta_mod.readFile(allocator, meta_path);
+    var store = try meta_mod.readFile(allocator, io, meta_path);
     defer store.deinit(allocator);
 
-    try store.recordConnection(allocator, host_name);
-    meta_mod.writeFile(allocator, &store, meta_path) catch {};
+    try store.recordConnection(allocator, io, host_name);
+    meta_mod.writeFile(allocator, io, &store, meta_path) catch {};
 
     // Build args
-    var argv: std.ArrayList([]const u8) = .{};
+    var argv: std.ArrayList([]const u8) = .empty;
     defer argv.deinit(allocator);
 
     try argv.append(allocator, "ssh");
     try argv.append(allocator, host_name);
     for (extra_args) |arg| try argv.append(allocator, arg);
 
     // Exec ssh
-    var child = std.process.Child.init(argv.items, allocator);
-    child.stdin_behavior = .Inherit;
-    child.stdout_behavior = .Inherit;
-    child.stderr_behavior = .Inherit;
-    try child.spawn();
-    const term = try child.wait();
+    var child = try std.process.spawn(io, .{
+        .argv = argv.items,
+        .stdin = .inherit,
+        .stdout = .inherit,
+        .stderr = .inherit,
+    });
+    const term = try child.wait(io);
 
     switch (term) {
-        .Exited => |code| if (code != 0) std.process.exit(code),
+        .exited => |code| if (code != 0) std.process.exit(code),
         else => std.process.exit(1),
     }
 }