zeno-mobile-runner 0.2.1 → 0.2.2

package/src/cli_trace.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const bundle = @import("bundle.zig");
 const report = @import("report.zig");
@@ -36,11 +37,11 @@ pub fn parseReportArgs(args: []const []const u8) !ReportArgs {
             index += 1;
             junit_path = if (index < args.len) args[index] else return error.MissingJUnitOutput;
         } else if (std.mem.startsWith(u8, arg, "--")) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (input_path == null) {
             input_path = arg;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     if (input_path == null) return error.MissingReportInput;
@@ -60,7 +61,7 @@ pub fn parseExplainArgs(args: []const []const u8) !ExplainArgs {
         } else if (parsed.trace_dir == null) {
             parsed.trace_dir = arg;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     if (parsed.trace_dir == null) return error.MissingTraceDir;
@@ -85,11 +86,11 @@ pub fn parseExportArgs(args: []const []const u8) !ExportArgs {
             redact = true;
             omit_screenshots = true;
         } else if (std.mem.startsWith(u8, arg, "--")) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (trace_dir == null) {
             trace_dir = arg;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     if (trace_dir == null) return error.MissingTraceDir;
@@ -102,32 +103,40 @@ pub fn parseExportArgs(args: []const []const u8) !ExportArgs {
     };
 }
 
-pub fn runReport(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn runReport(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     var raw_args = std.ArrayList([]const u8).empty;
     defer raw_args.deinit(allocator);
     while (args.next()) |arg| try raw_args.append(allocator, arg);
 
     const parsed = try parseReportArgs(raw_args.items);
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
+
     try report.writeHtmlReport(allocator, parsed.input_path, parsed.out_path.?);
-    try std.fs.File.stdout().deprecatedWriter().print("wrote {s}\n", .{parsed.out_path.?});
+    try stdout.print("wrote {s}\n", .{parsed.out_path.?});
     if (parsed.junit_path) |junit_path| {
         try report.writeJUnitReport(allocator, parsed.input_path, junit_path);
-        try std.fs.File.stdout().deprecatedWriter().print("wrote {s}\n", .{junit_path});
+        try stdout.print("wrote {s}\n", .{junit_path});
     }
 }
 
-pub fn runExplain(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn runExplain(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     var raw_args = std.ArrayList([]const u8).empty;
     defer raw_args.deinit(allocator);
     while (args.next()) |arg| try raw_args.append(allocator, arg);
 
     const parsed = try parseExplainArgs(raw_args.items);
-    const stdout = std.fs.File.stdout().deprecatedWriter();
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
     if (parsed.json) return try report.writeTraceExplanationJson(allocator, parsed.trace_dir.?, stdout);
     try report.writeTraceExplanation(allocator, parsed.trace_dir.?, stdout);
 }
 
-pub fn runExport(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn runExport(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     var raw_args = std.ArrayList([]const u8).empty;
     defer raw_args.deinit(allocator);
     while (args.next()) |arg| try raw_args.append(allocator, arg);
@@ -137,5 +146,9 @@ pub fn runExport(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !
         .redact = parsed.redact,
         .omit_screenshots = parsed.omit_screenshots,
     });
-    try std.fs.File.stdout().deprecatedWriter().print("wrote {s}\n", .{parsed.out_path.?});
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
+    try stdout.print("wrote {s}\n", .{parsed.out_path.?});
 }

package/src/cli_validate.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_output = @import("cli_output.zig");
 const validation = @import("validation.zig");
@@ -15,11 +16,11 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         if (std.mem.eql(u8, arg, "--json")) {
             json = true;
         } else if (std.mem.startsWith(u8, arg, "--")) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (path == null) {
             path = arg;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     return ParsedArgs{
@@ -28,7 +29,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
     };
 }
 
-pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn run(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     var raw_args = std.ArrayList([]const u8).empty;
     defer raw_args.deinit(allocator);
     while (args.next()) |arg| try raw_args.append(allocator, arg);
@@ -37,7 +38,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     const result = try validation.validateFile(allocator, parsed.path);
     defer result.deinit(allocator);
 
-    const stdout = std.fs.File.stdout().deprecatedWriter();
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
     if (parsed.json) {
         try cli_output.writeValidationJson(stdout, parsed.path, result);
     } else {

package/src/command.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const builtin = @import("builtin");
+const stdio = @import("stdio.zig");
 
 pub const ExecResult = struct {
     stdout: []u8,
@@ -15,7 +15,7 @@ pub const ExecResult = struct {
     pub fn ensureSuccess(self: ExecResult) !void {
         if (self.timed_out) return error.CommandTimedOut;
         switch (self.term) {
-            .Exited => |code| if (code == 0) return,
+            .exited => |code| if (code == 0) return,
             else => {},
         }
         return error.CommandFailed;
@@ -27,10 +27,10 @@ pub fn run(
     argv: []const []const u8,
     max_output_bytes: usize,
 ) !ExecResult {
-    const result = try std.process.Child.run(.{
-        .allocator = allocator,
+    const result = try std.process.run(allocator, stdio.io(), .{
         .argv = argv,
-        .max_output_bytes = max_output_bytes,
+        .stdout_limit = .limited(max_output_bytes),
+        .stderr_limit = .limited(max_output_bytes),
     });
     return .{
         .stdout = result.stdout,
@@ -56,59 +56,24 @@ pub fn runWithInputTimeout(
     max_output_bytes: usize,
     timeout_ms: u64,
 ) !ExecResult {
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Pipe;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Pipe;
-
-    var stdout = std.ArrayList(u8).empty;
-    defer stdout.deinit(allocator);
-    var stderr = std.ArrayList(u8).empty;
-    defer stderr.deinit(allocator);
-
-    try child.spawn();
-    errdefer _ = child.kill() catch {};
-
-    var done = std.Thread.ResetEvent{};
-    var timed_out = std.atomic.Value(bool).init(false);
-    const use_timeout = timeout_ms > 0;
-    const killer = if (use_timeout)
-        try std.Thread.spawn(.{}, timeoutKiller, .{
-            child.id,
-            &done,
-            &timed_out,
-            std.math.mul(u64, timeout_ms, std.time.ns_per_ms) catch std.math.maxInt(u64),
-        })
-    else
-        null;
+    var child = try std.process.spawn(stdio.io(), .{
+        .argv = argv,
+        .stdin = .pipe,
+        .stdout = .pipe,
+        .stderr = .pipe,
+    });
+    defer if (child.id != null) child.kill(stdio.io());
 
     if (child.stdin) |stdin_file| {
-        try stdin_file.writeAll(stdin);
-        stdin_file.close();
+        var stdin_buffer: [8192]u8 = undefined;
+        var stdin_writer = stdin_file.writerStreaming(stdio.io(), &stdin_buffer);
+        try stdin_writer.interface.writeAll(stdin);
+        try stdin_writer.interface.flush();
+        stdin_file.close(stdio.io());
         child.stdin = null;
     }
 
-    child.collectOutput(allocator, &stdout, &stderr, max_output_bytes) catch |err| {
-        _ = child.kill() catch {};
-        done.set();
-        if (killer) |thread| thread.join();
-        return err;
-    };
-
-    const term = child.wait() catch |err| {
-        done.set();
-        if (killer) |thread| thread.join();
-        return err;
-    };
-    done.set();
-    if (killer) |thread| thread.join();
-
-    return .{
-        .stdout = try stdout.toOwnedSlice(allocator),
-        .stderr = try stderr.toOwnedSlice(allocator),
-        .term = term,
-        .timed_out = timed_out.load(.acquire),
-    };
+    return try collectSpawnedOutput(allocator, &child, max_output_bytes, timeoutForMs(timeout_ms));
 }
 
 pub fn runWithTimeout(
@@ -119,64 +84,81 @@ pub fn runWithTimeout(
 ) !ExecResult {
     if (timeout_ms == 0) return run(allocator, argv, max_output_bytes);
 
-    var child = std.process.Child.init(argv, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Pipe;
-    child.stderr_behavior = .Pipe;
-
-    var stdout = std.ArrayList(u8).empty;
-    defer stdout.deinit(allocator);
-    var stderr = std.ArrayList(u8).empty;
-    defer stderr.deinit(allocator);
-
-    try child.spawn();
-    errdefer _ = child.kill() catch {};
+    const result = std.process.run(allocator, stdio.io(), .{
+        .argv = argv,
+        .stdout_limit = .limited(max_output_bytes),
+        .stderr_limit = .limited(max_output_bytes),
+        .timeout = timeoutForMs(timeout_ms),
+    }) catch |err| switch (err) {
+        error.Timeout => return timedOutResult(allocator),
+        else => |actual| return actual,
+    };
+    return .{
+        .stdout = result.stdout,
+        .stderr = result.stderr,
+        .term = result.term,
+        .timed_out = false,
+    };
+}
 
-    var done = std.Thread.ResetEvent{};
-    var timed_out = std.atomic.Value(bool).init(false);
-    const timeout_ns = std.math.mul(u64, timeout_ms, std.time.ns_per_ms) catch std.math.maxInt(u64);
-    const killer = try std.Thread.spawn(.{}, timeoutKiller, .{ child.id, &done, &timed_out, timeout_ns });
+fn collectSpawnedOutput(
+    allocator: std.mem.Allocator,
+    child: *std.process.Child,
+    max_output_bytes: usize,
+    timeout: std.Io.Timeout,
+) !ExecResult {
+    var multi_reader_buffer: std.Io.File.MultiReader.Buffer(2) = undefined;
+    var multi_reader: std.Io.File.MultiReader = undefined;
+    multi_reader.init(allocator, stdio.io(), multi_reader_buffer.toStreams(), &.{ child.stdout.?, child.stderr.? });
+    defer multi_reader.deinit();
+
+    const stdout_reader = multi_reader.reader(0);
+    const stderr_reader = multi_reader.reader(1);
+
+    while (multi_reader.fill(64, timeout)) |_| {
+        if (stdout_reader.buffered().len > max_output_bytes) return error.StreamTooLong;
+        if (stderr_reader.buffered().len > max_output_bytes) return error.StreamTooLong;
+    } else |err| switch (err) {
+        error.EndOfStream => {},
+        error.Timeout => {
+            child.kill(stdio.io());
+            return timedOutResult(allocator);
+        },
+        else => |actual| return actual,
+    }
 
-    child.collectOutput(allocator, &stdout, &stderr, max_output_bytes) catch |err| {
-        _ = child.kill() catch {};
-        done.set();
-        killer.join();
-        return err;
-    };
+    try multi_reader.checkAnyError();
+    const term = try child.wait(stdio.io());
 
-    const term = child.wait() catch |err| {
-        done.set();
-        killer.join();
-        return err;
-    };
-    done.set();
-    killer.join();
+    const stdout_slice = try multi_reader.toOwnedSlice(0);
+    errdefer allocator.free(stdout_slice);
+    const stderr_slice = try multi_reader.toOwnedSlice(1);
+    errdefer allocator.free(stderr_slice);
 
     return .{
-        .stdout = try stdout.toOwnedSlice(allocator),
-        .stderr = try stderr.toOwnedSlice(allocator),
+        .stdout = stdout_slice,
+        .stderr = stderr_slice,
         .term = term,
-        .timed_out = timed_out.load(.acquire),
+        .timed_out = false,
     };
 }
 
-fn timeoutKiller(
-    child_id: std.process.Child.Id,
-    done: *std.Thread.ResetEvent,
-    timed_out: *std.atomic.Value(bool),
-    timeout_ns: u64,
-) void {
-    done.timedWait(timeout_ns) catch {
-        timed_out.store(true, .release);
-        killChildId(child_id);
+fn timedOutResult(allocator: std.mem.Allocator) !ExecResult {
+    return .{
+        .stdout = try allocator.dupe(u8, ""),
+        .stderr = try allocator.dupe(u8, ""),
+        .term = .{ .unknown = 0 },
+        .timed_out = true,
     };
 }
 
-fn killChildId(child_id: std.process.Child.Id) void {
-    switch (builtin.os.tag) {
-        .windows => {},
-        else => std.posix.kill(child_id, std.posix.SIG.TERM) catch {},
-    }
+fn timeoutForMs(timeout_ms: u64) std.Io.Timeout {
+    if (timeout_ms == 0) return .none;
+    const timeout_ns = std.math.mul(u64, timeout_ms, std.time.ns_per_ms) catch std.math.maxInt(u64);
+    return .{ .duration = .{
+        .raw = std.Io.Duration.fromNanoseconds(@intCast(timeout_ns)),
+        .clock = .awake,
+    } };
 }
 
 pub fn escapeAdbInputText(allocator: std.mem.Allocator, text: []const u8) ![]const u8 {

package/src/config.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const config_diagnostics = @import("config_diagnostics.zig");
 
 pub const PlatformConfig = struct {
@@ -92,7 +93,7 @@ pub const Config = struct {
 };
 
 pub fn parseFile(allocator: std.mem.Allocator, path: []const u8) !Config {
-    const content = try std.fs.cwd().readFileAlloc(allocator, path, 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, path, 1024 * 1024);
     defer allocator.free(content);
     return try parseSlice(allocator, content);
 }

package/src/config_diagnostics.zig

@@ -1,7 +1,8 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 pub fn errorFieldPathForFile(allocator: std.mem.Allocator, path: []const u8, err: anyerror) !?[]const u8 {
-    const content = std.fs.cwd().readFileAlloc(allocator, path, 1024 * 1024) catch return null;
+    const content = stdio.readFileAlloc(allocator, path, 1024 * 1024) catch return null;
     defer allocator.free(content);
     return try errorFieldPathForSlice(allocator, content, err);
 }

package/src/config_paths.zig

@@ -1,11 +1,12 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const config = @import("config.zig");
 
 pub const default_path = ".zmr/config.json";
 
 pub fn loadIfPresent(allocator: std.mem.Allocator, explicit_path: ?[]const u8) !?config.Config {
     if (explicit_path) |path| return try config.parseFile(allocator, path);
-    std.fs.cwd().access(default_path, .{}) catch |err| switch (err) {
+    stdio.access(default_path) catch |err| switch (err) {
         error.FileNotFound => return null,
         else => return err,
     };

package/src/doctor.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const android = @import("android.zig");
 const command = @import("command.zig");
 const config = @import("config.zig");
@@ -137,7 +138,7 @@ pub fn run(allocator: std.mem.Allocator, options: Options) ![]Check {
 }
 
 fn checkPath(allocator: std.mem.Allocator, name: []const u8, path: []const u8) !Check {
-    std.fs.cwd().access(path, .{ .mode = .read_only }) catch |err| {
+    stdio.accessWithOptions(path, .{ .read = true }) catch |err| {
         return .{
             .name = try allocator.dupe(u8, name),
             .status = .missing,
@@ -347,9 +348,9 @@ fn physicalStateBreakdown(allocator: std.mem.Allocator, devices: []const types.D
         }
     }
 
-    var parts = std.ArrayList(u8).empty;
-    defer parts.deinit(allocator);
-    const writer = parts.writer(allocator);
+    var parts: std.Io.Writer.Allocating = .init(allocator);
+    defer parts.deinit();
+    const writer = &parts.writer;
     var wrote = false;
     if (disconnected > 0) {
         try writer.print("disconnected={d}", .{disconnected});
@@ -372,7 +373,7 @@ fn physicalStateBreakdown(allocator: std.mem.Allocator, devices: []const types.D
     }
 
     if (!wrote) return try allocator.dupe(u8, "");
-    return try std.fmt.allocPrint(allocator, " ({s})", .{parts.items});
+    return try std.fmt.allocPrint(allocator, " ({s})", .{parts.writer.buffered()});
 }
 
 pub fn checkCommand(allocator: std.mem.Allocator, name: []const u8, argv: []const []const u8) !Check {
@@ -387,7 +388,7 @@ pub fn checkCommand(allocator: std.mem.Allocator, name: []const u8, argv: []cons
     };
     defer result.deinit(allocator);
 
-    if (result.term == .Exited and result.term.Exited == 0) {
+    if (result.term == .exited and result.term.exited == 0) {
         return .{
             .name = try allocator.dupe(u8, name),
             .status = .ok,
@@ -395,7 +396,7 @@ pub fn checkCommand(allocator: std.mem.Allocator, name: []const u8, argv: []cons
         };
     }
 
-    const code = if (result.term == .Exited) result.term.Exited else 255;
+    const code = if (result.term == .exited) result.term.exited else 255;
     return .{
         .name = try allocator.dupe(u8, name),
         .status = .warning,

package/src/doctor_hints.zig

@@ -19,7 +19,7 @@ pub fn hintForCheck(allocator: std.mem.Allocator, name: []const u8, status: Stat
     if (status == .ok) return null;
     const hint =
         if (std.mem.eql(u8, name, "zig"))
-            "Install Zig 0.15.2 or newer, ensure it is on PATH, then run zmr doctor again."
+            "Install Zig 0.16.0 or newer, ensure it is on PATH, then run zmr doctor again."
         else if (std.mem.eql(u8, name, "adb"))
             "Install Android SDK Platform Tools, ensure adb is on PATH, then run adb devices."
         else if (std.mem.eql(u8, name, "android-devices"))

package/src/errors.zig

@@ -21,8 +21,8 @@ pub fn classify(err: anyerror) PublicError {
         error.MissingXcrunPath => .{ .code = "cli.missing_xcrun_path", .message = "missing xcrun path" },
         error.MissingZigPath => .{ .code = "cli.missing_zig_path", .message = "missing zig path" },
         error.MissingPlatform => .{ .code = "cli.missing_platform", .message = "missing platform" },
-        error.UnknownCommand => .{ .code = "cli.unknown_command", .message = "unknown command" },
-        error.UnknownFlag => .{ .code = "cli.unknown_flag", .message = "unknown flag" },
+        error.unknownCommand => .{ .code = "cli.unknown_command", .message = "unknown command" },
+        error.unknownFlag => .{ .code = "cli.unknown_flag", .message = "unknown flag" },
         error.MissingParam => .{ .code = "cli.missing_param", .message = "missing parameter" },
         error.FileNotFound => .{ .code = "scenario.file_not_found", .message = "scenario file was not found" },
         error.SemanticSnapshotMissing => .{ .code = "draft.no_snapshot", .message = "no semantic snapshot was found in the trace" },
@@ -36,9 +36,9 @@ pub fn classify(err: anyerror) PublicError {
         error.StepMustBeObject,
         error.StepMissingAction,
         error.StepActionMustBeString,
-        error.UnknownAction,
-        error.UnknownScenarioAction,
-        error.UnknownScrollDirection,
+        error.unknownAction,
+        error.unknownScenarioAction,
+        error.unknownScrollDirection,
         error.StepMissingUrl,
         error.StepMissingText,
         error.StepMissingX1,

package/src/importer.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const importer_json = @import("importer_json.zig");
 const model = @import("importer_model.zig");
 
@@ -13,20 +14,20 @@ pub fn importFlowYamlFile(
 ) !ImportResult {
     if (!options.force and fileExists(out_path)) return error.ImportOutputExists;
 
-    const content = try std.fs.cwd().readFileAlloc(allocator, source_path, 4 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, source_path, 4 * 1024 * 1024);
     defer allocator.free(content);
 
     var imported = try parseFlowYamlSlice(allocator, content, options);
     defer imported.deinit(allocator);
 
     if (std.fs.path.dirname(out_path)) |dir| {
-        if (dir.len > 0) try std.fs.cwd().makePath(dir);
+        if (dir.len > 0) try std.Io.Dir.cwd().createDirPath(stdio.io(), dir);
     }
 
-    var file = try std.fs.cwd().createFile(out_path, .{ .truncate = true });
-    defer file.close();
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), out_path, .{ .truncate = true });
+    defer file.close(stdio.io());
     var write_buffer: [8192]u8 = undefined;
-    var file_writer = file.writer(&write_buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
     try importer_json.writeScenarioJson(&file_writer.interface, imported);
     try file_writer.interface.flush();
 
@@ -39,7 +40,7 @@ pub fn importFlowYamlFile(
 }
 
 fn fileExists(path: []const u8) bool {
-    std.fs.cwd().access(path, .{}) catch return false;
+    stdio.access(path) catch return false;
     return true;
 }
 
@@ -59,7 +60,7 @@ fn parseFlowYamlSlice(allocator: std.mem.Allocator, content: []const u8, options
     defer lines.deinit(allocator);
     var split = std.mem.splitScalar(u8, content, '\n');
     while (split.next()) |line| {
-        try lines.append(allocator, std.mem.trimRight(u8, line, "\r"));
+        try lines.append(allocator, std.mem.trimEnd(u8, line, "\r"));
     }
 
     var in_commands = false;