zeno-mobile-runner 0.2.0 → 0.2.2

package/src/bundle_tar.zig

@@ -1,42 +1,45 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 pub fn writeFile(
     allocator: std.mem.Allocator,
     trace_dir: []const u8,
     archive_path: []const u8,
-    out_file: *std.fs.File,
+    out_file: *std.Io.File,
 ) !void {
     if (isUnsafeArchivePath(archive_path)) return error.UnsafeArchivePath;
     const fs_path = try std.fs.path.join(allocator, &.{ trace_dir, archive_path });
     defer allocator.free(fs_path);
 
-    var in_file = try std.fs.cwd().openFile(fs_path, .{});
-    defer in_file.close();
-    const stat = try in_file.stat();
+    var in_file = try std.Io.Dir.cwd().openFile(stdio.io(), fs_path, .{});
+    defer in_file.close(stdio.io());
+    const stat = try in_file.stat(stdio.io());
 
     var header = [_]u8{0} ** 512;
     try writeHeader(&header, archive_path, stat.size);
 
-    try out_file.writeAll(&header);
+    try std.Io.File.writeStreamingAll(out_file.*, stdio.io(), &header);
+    var reader_buffer: [16 * 1024]u8 = undefined;
+    var reader = in_file.readerStreaming(stdio.io(), &reader_buffer);
     var buffer: [16 * 1024]u8 = undefined;
     var remaining = stat.size;
     while (remaining > 0) {
         const read_len = @min(buffer.len, remaining);
-        const n = try in_file.read(buffer[0..read_len]);
+        const n = try reader.interface.readSliceShort(buffer[0..read_len]);
         if (n == 0) return error.UnexpectedEndOfStream;
-        try out_file.writeAll(buffer[0..n]);
+        try std.Io.File.writeStreamingAll(out_file.*, stdio.io(), buffer[0..n]);
         remaining -= n;
     }
     try writePadding(out_file, stat.size);
 }
 
-pub fn writeBytes(archive_path: []const u8, bytes: []const u8, out_file: *std.fs.File) !void {
+pub fn writeBytes(archive_path: []const u8, bytes: []const u8, out_file: *std.Io.File) !void {
     if (isUnsafeArchivePath(archive_path)) return error.UnsafeArchivePath;
     var header = [_]u8{0} ** 512;
     try writeHeader(&header, archive_path, bytes.len);
 
-    try out_file.writeAll(&header);
-    try out_file.writeAll(bytes);
+    try std.Io.File.writeStreamingAll(out_file.*, stdio.io(), &header);
+    try std.Io.File.writeStreamingAll(out_file.*, stdio.io(), bytes);
     try writePadding(out_file, bytes.len);
 }
 
@@ -57,9 +60,9 @@ fn writeHeader(header: *[512]u8, archive_path: []const u8, size: u64) !void {
     writeChecksum(header[148..156], checksum);
 }
 
-fn writePadding(out_file: *std.fs.File, size: u64) !void {
+fn writePadding(out_file: *std.Io.File, size: u64) !void {
     const padding = (512 - (size % 512)) % 512;
-    if (padding > 0) try out_file.writeAll((&([_]u8{0} ** 512))[0..padding]);
+    if (padding > 0) try std.Io.File.writeStreamingAll(out_file.*, stdio.io(), (&([_]u8{0} ** 512))[0..padding]);
 }
 
 fn isUnsafeArchivePath(archive_path: []const u8) bool {

package/src/cli_devices.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const android = @import("android.zig");
 const device_registry = @import("device_registry.zig");
 const ios = @import("ios.zig");
@@ -11,7 +12,7 @@ pub const IosDevicesScope = enum {
     all,
 };
 
-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 platform: run_options.Platform = .android;
     var ios_devices_scope: IosDevicesScope = .simulator;
     var adb_path: []const u8 = "adb";
@@ -30,7 +31,7 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
         } else if (std.mem.eql(u8, arg, "--json")) {
             json = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
 
@@ -43,7 +44,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
         allocator.free(devices);
     }
 
-    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 (json) return try device_registry.writeJson(stdout, registryPlatform(platform), devices);
     if (devices.len == 0) return try stdout.print("No {s} devices found.\n", .{@tagName(platform)});
     for (devices) |device| {

package/src/cli_discover.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_draft = @import("cli_draft.zig");
 const cli_output = @import("cli_output.zig");
@@ -68,7 +69,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--json")) {
             parsed.json = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
 
@@ -77,7 +78,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
     return parsed;
 }
 
-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);
@@ -86,7 +87,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     var discovered = try discoverFromTrace(allocator, parsed);
     defer discovered.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 writeJson(stdout, discovered.summary, discovered.validation);
     } else {

package/src/cli_doctor.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_output = @import("cli_output.zig");
 const config = @import("config.zig");
@@ -42,13 +43,13 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
             parsed.config_path = if (index < args.len) args[index] else return error.MissingConfigPath;
             parsed.explicit_config = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     return parsed;
 }
 
-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);
@@ -104,7 +105,10 @@ fn runParsed(allocator: std.mem.Allocator, parsed: ParsedArgs) !void {
         allocator.free(checks);
     }
 
-    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.writeDoctorJson(stdout, config_check, checks);
     } else {

package/src/cli_draft.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_output = @import("cli_output.zig");
 const trace = @import("trace.zig");
@@ -100,7 +101,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--json")) {
             parsed.json = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
 
@@ -109,7 +110,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
     return parsed;
 }
 
-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);
@@ -118,7 +119,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     var draft = try draftFromTrace(allocator, parsed);
     defer draft.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 writeJson(stdout, draft.summary);
         return;
@@ -150,7 +154,7 @@ pub fn draftFromTrace(allocator: std.mem.Allocator, parsed: ParsedArgs) !OwnedDr
 
     const manifest_path = try std.fs.path.join(allocator, &.{ from_trace, "trace.json" });
     defer allocator.free(manifest_path);
-    const manifest_content = try std.fs.cwd().readFileAlloc(allocator, manifest_path, 1024 * 1024);
+    const manifest_content = try stdio.readFileAlloc(allocator, manifest_path, 1024 * 1024);
     defer allocator.free(manifest_content);
 
     var parsed_manifest = try std.json.parseFromSlice(std.json.Value, allocator, manifest_content, .{});
@@ -219,7 +223,7 @@ fn parseReplaySteps(
 ) !ReplayDraft {
     const events_path = try std.fs.path.join(allocator, &.{ trace_dir, metadata.events_path });
     defer allocator.free(events_path);
-    const content = std.fs.cwd().readFileAlloc(allocator, events_path, 64 * 1024 * 1024) catch |err| switch (err) {
+    const content = stdio.readFileAlloc(allocator, events_path, 64 * 1024 * 1024) catch |err| switch (err) {
         error.FileNotFound => {
             try appendWarning(allocator, owned, "trace events were not found; action replay was skipped");
             return .{
@@ -393,14 +397,14 @@ fn latestSnapshotPath(
 
     const artifacts_path = try std.fs.path.join(allocator, &.{ trace_dir, metadata.artifacts_dir });
     defer allocator.free(artifacts_path);
-    var dir = try std.fs.cwd().openDir(artifacts_path, .{ .iterate = true });
-    defer dir.close();
+    var dir = try std.Io.Dir.cwd().openDir(stdio.io(), artifacts_path, .{ .iterate = true });
+    defer dir.close(stdio.io());
 
     var iterator = dir.iterate();
     var best_number: usize = 0;
     var best_name: ?[]u8 = null;
     defer if (best_name) |value| allocator.free(value);
-    while (try iterator.next()) |entry| {
+    while (try iterator.next(stdio.io())) |entry| {
         if (entry.kind != .file) continue;
         const number = snapshotNumber(entry.name) orelse continue;
         if (best_name == null or number > best_number) {
@@ -422,7 +426,7 @@ fn parseSemanticSelectors(
     path: []const u8,
     owned: *OwnedDraft,
 ) ![]DraftSelector {
-    const content = try std.fs.cwd().readFileAlloc(allocator, path, 8 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, path, 8 * 1024 * 1024);
     defer allocator.free(content);
 
     var parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
@@ -505,16 +509,16 @@ fn writeScenarioFile(
     force: bool,
 ) !void {
     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 = if (force)
-        try std.fs.cwd().createFile(out_path, .{ .truncate = true })
+        try std.Io.Dir.cwd().createFile(stdio.io(), out_path, .{ .truncate = true })
     else
-        try std.fs.cwd().createFile(out_path, .{ .exclusive = true });
-    defer file.close();
+        try std.Io.Dir.cwd().createFile(stdio.io(), out_path, .{ .exclusive = 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 writeScenarioJson(&file_writer.interface, name, app_id, action_steps, selectors);
     try file_writer.interface.flush();
 }
@@ -609,9 +613,9 @@ fn actionWithStringField(
     key: []const u8,
     value: []const u8,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",");
@@ -619,7 +623,7 @@ fn actionWithStringField(
     try writer.writeAll(":");
     try trace.writeJsonString(writer, value);
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithIntField(
@@ -629,15 +633,15 @@ fn actionWithIntField(
     key: []const u8,
     value: usize,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",");
     try trace.writeJsonString(writer, key);
     try writer.print(":{d}}}", .{value});
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithSelector(
@@ -646,15 +650,15 @@ fn actionWithSelector(
     action: []const u8,
     selector_value: std.json.Value,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",\"selector\":");
     try writeJsonValue(writer, selector_value);
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithSelectorAndString(
@@ -665,9 +669,9 @@ fn actionWithSelectorAndString(
     key: []const u8,
     value: []const u8,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",\"selector\":");
@@ -677,7 +681,7 @@ fn actionWithSelectorAndString(
     try writer.writeAll(":");
     try trace.writeJsonString(writer, value);
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithSelectorAndInt(
@@ -688,9 +692,9 @@ fn actionWithSelectorAndInt(
     key: []const u8,
     value: usize,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",\"selector\":");
@@ -698,7 +702,7 @@ fn actionWithSelectorAndInt(
     try writer.writeAll(",");
     try trace.writeJsonString(writer, key);
     try writer.print(":{d}}}", .{value});
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithSelectors(
@@ -708,16 +712,16 @@ fn actionWithSelectors(
     selectors_value: std.json.Value,
     timeout_ms: ?usize,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":");
     try trace.writeJsonString(writer, action);
     try writer.writeAll(",\"selectors\":");
     try writeJsonValue(writer, selectors_value);
     if (timeout_ms) |actual| try writer.print(",\"timeoutMs\":{d}", .{actual});
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithSwipe(
@@ -729,13 +733,13 @@ fn actionWithSwipe(
     y2: i32,
     duration_ms: ?usize,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.print("{{\"action\":\"swipe\",\"x1\":{d},\"y1\":{d},\"x2\":{d},\"y2\":{d}", .{ x1, y1, x2, y2 });
     if (duration_ms) |actual| try writer.print(",\"durationMs\":{d}", .{actual});
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn actionWithScrollUntilVisible(
@@ -745,9 +749,9 @@ fn actionWithScrollUntilVisible(
     direction: ?[]const u8,
     timeout_ms: ?usize,
 ) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    defer buffer.deinit(allocator);
-    const writer = buffer.writer(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    defer buffer.deinit();
+    const writer = &buffer.writer;
     try writer.writeAll("{\"action\":\"scrollUntilVisible\",\"selector\":");
     try writeJsonValue(writer, selector_value);
     if (direction) |actual| {
@@ -756,7 +760,7 @@ fn actionWithScrollUntilVisible(
     }
     if (timeout_ms) |actual| try writer.print(",\"timeoutMs\":{d}", .{actual});
     try writer.writeAll("}");
-    return try ownBytes(allocator, owned, buffer.items);
+    return try ownBytes(allocator, owned, buffer.writer.buffered());
 }
 
 fn warnMissingReplayField(
@@ -919,6 +923,6 @@ fn snapshotNumber(name: []const u8) ?usize {
 }
 
 fn pathExists(path: []const u8) bool {
-    std.fs.cwd().access(path, .{}) catch return false;
+    stdio.access(path) catch return false;
     return true;
 }

package/src/cli_explore.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_discover = @import("cli_discover.zig");
 const cli_output = @import("cli_output.zig");
@@ -66,7 +67,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--json")) {
             parsed.json = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
 
@@ -75,7 +76,7 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
     return parsed;
 }
 
-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);
@@ -84,7 +85,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     var explored = try exploreFromTrace(allocator, parsed);
     defer explored.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 writeJson(stdout, explored.summary, explored.discovered.summary, explored.discovered.validation);
     } else {

package/src/cli_import.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_output = @import("cli_output.zig");
 const importer = @import("importer.zig");
@@ -39,13 +40,13 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--json")) {
             json = true;
         } else if (std.mem.startsWith(u8, arg, "--")) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (format == null) {
             format = arg;
         } else if (source_path == null) {
             source_path = arg;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     if (format == null) return error.MissingImportFormat;
@@ -62,7 +63,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);
@@ -77,7 +78,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     });
     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) return try cli_output.writeImportJson(stdout, parsed.format, parsed.source_path, result);
     try stdout.print("wrote {s}\n", .{result.out_path});
     try stdout.writeAll("next: zmr validate ");

package/src/cli_info.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const schema_registry = @import("schema_registry.zig");
 const version = @import("version.zig");
@@ -9,29 +10,35 @@ pub fn parseJsonFlag(args: []const []const u8) !bool {
         if (std.mem.eql(u8, arg, "--json")) {
             json = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     return json;
 }
 
-pub fn runVersion(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn runVersion(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     const json = try parseArgIterator(allocator, args);
-    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 (json) return try version.writeJson(stdout);
     try version.writePlain(stdout);
 }
 
-pub fn runSchemas(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+pub fn runSchemas(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !void {
     const json = try parseArgIterator(allocator, args);
-    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 (json) return try schema_registry.writeJson(stdout);
     for (schema_registry.all()) |schema_info| {
         try stdout.print("{s}\t{s}\n", .{ schema_info.name, schema_info.path });
     }
 }
 
-fn parseArgIterator(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !bool {
+fn parseArgIterator(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) !bool {
     var raw_args = std.ArrayList([]const u8).empty;
     defer raw_args.deinit(allocator);
     while (args.next()) |arg| try raw_args.append(allocator, arg);

package/src/cli_init.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const cli_output = @import("cli_output.zig");
 const scaffold = @import("scaffold.zig");
@@ -31,26 +32,29 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
         } else if (std.mem.eql(u8, arg, "--json")) {
             parsed.json = true;
         } else if (std.mem.startsWith(u8, arg, "--")) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (parsed.app_scaffold) {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         } else if (!path_set) {
             parsed.path = arg;
             path_set = true;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     return parsed;
 }
 
-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);
 
     const parsed = try parseArgs(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.app_scaffold) {
         try scaffold.writeAppScaffold(allocator, parsed.dir, parsed.app_id, parsed.force);
         if (parsed.json) return try cli_output.writeInitAppJson(stdout, parsed.dir, parsed.app_id);

package/src/cli_inspect.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 const config = @import("config.zig");
 const scaffold = @import("scaffold.zig");
@@ -59,13 +60,13 @@ pub fn parseArgs(args: []const []const u8) !ParsedArgs {
             index += 1;
             parsed.config_path = if (index < args.len) args[index] else return error.MissingParam;
         } else {
-            return error.UnknownFlag;
+            return error.unknownFlag;
         }
     }
     return parsed;
 }
 
-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);
@@ -74,7 +75,10 @@ pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
     var owned = try inspect(allocator, parsed);
     defer owned.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 writeJson(stdout, owned.inspection);
     } else {
@@ -140,7 +144,7 @@ fn appendPlatform(
 }
 
 fn pathExists(path: []const u8) bool {
-    std.fs.cwd().access(path, .{}) catch return false;
+    stdio.access(path) catch return false;
     return true;
 }