zeno-mobile-runner 0.2.1 → 0.2.2

package/shims/ios/ZMRShimUITestCase.swift

@@ -187,7 +187,7 @@ final class ZMRShimUITestCase: XCTestCase {
         case "appState":
             return ["status": "ok", "state": app.state.rawValue]
         case "acceptSystemAlert":
-            return acceptSystemAlert(buttonText: command.text ?? "Open")
+            return acceptSystemAlert(buttonText: command.text ?? "Open", app: app)
         default:
             return error("unknown.command", "unsupported command: \(command.cmd)")
         }
@@ -229,7 +229,7 @@ final class ZMRShimUITestCase: XCTestCase {
         ["status": "error", "code": code, "message": message]
     }
 
-    private func acceptSystemAlert(buttonText: String) -> [String: Any] {
+    private func acceptSystemAlert(buttonText: String, app: XCUIApplication) -> [String: Any] {
         let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")
         var labels = [buttonText, "Open", "Allow", "OK", "Continue"]
         labels = labels.reduce(into: [String]()) { unique, label in
@@ -264,12 +264,121 @@ final class ZMRShimUITestCase: XCTestCase {
             }
         }
 
+        let expoDeepLinkSelection = acceptExpoDevClientDeepLink(app: app)
+        if expoDeepLinkSelection.accepted {
+            acceptedCount += 1
+            lastAcceptedLabel = expoDeepLinkSelection.label
+        }
+
+        let expoHomeSelection = resumeExpoDevClientHome(app: app)
+        if expoHomeSelection.accepted {
+            acceptedCount += 1
+            lastAcceptedLabel = expoHomeSelection.label
+        }
+
         if acceptedCount > 0 {
             return ["status": "ok", "accepted": true, "label": lastAcceptedLabel, "count": acceptedCount]
         }
         return ["status": "ok", "accepted": false, "count": 0]
     }
 
+    private func acceptExpoDevClientDeepLink(app: XCUIApplication) -> (accepted: Bool, label: String) {
+        guard app.staticTexts["Deep link received:"].waitForExistence(timeout: 1) else {
+            return (false, "")
+        }
+
+        let candidateQueries = [
+            app.buttons.allElementsBoundByIndex,
+            app.cells.allElementsBoundByIndex,
+            app.staticTexts.allElementsBoundByIndex
+        ]
+
+        for elements in candidateQueries {
+            for element in elements {
+                let label = element.label.trimmingCharacters(in: .whitespacesAndNewlines)
+                guard isExpoDevClientDeepLinkTarget(label: label), element.isHittable else {
+                    continue
+                }
+
+                element.tap()
+                Thread.sleep(forTimeInterval: 1.0)
+                return (true, label)
+            }
+        }
+
+        return (false, "")
+    }
+
+    private func isExpoDevClientDeepLinkTarget(label: String) -> Bool {
+        if label.isEmpty {
+            return false
+        }
+
+        let rejectedExactLabels = [
+            "Deep link received:",
+            "Select an app to open it:",
+            "Go back"
+        ]
+        if rejectedExactLabels.contains(label) {
+            return false
+        }
+
+        if label.contains("://") || label.hasPrefix("Note:") || label.contains("next app you open") {
+            return false
+        }
+
+        return true
+    }
+
+    private func resumeExpoDevClientHome(app: XCUIApplication) -> (accepted: Bool, label: String) {
+        guard app.staticTexts["Development servers"].waitForExistence(timeout: 1) else {
+            return (false, "")
+        }
+
+        let candidateQueries = [
+            app.buttons.allElementsBoundByIndex,
+            app.cells.allElementsBoundByIndex,
+            app.staticTexts.allElementsBoundByIndex
+        ]
+
+        for elements in candidateQueries {
+            for element in elements {
+                let label = element.label.trimmingCharacters(in: .whitespacesAndNewlines)
+                guard isExpoDevClientProjectTarget(label: label), element.exists else {
+                    continue
+                }
+
+                element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap()
+                Thread.sleep(forTimeInterval: 1.0)
+                return (true, label)
+            }
+        }
+
+        return (false, "")
+    }
+
+    private func isExpoDevClientProjectTarget(label: String) -> Bool {
+        if label.isEmpty {
+            return false
+        }
+
+        let rejectedExactLabels = [
+            "Development servers",
+            "Recently opened",
+            "Fetch development servers",
+            "Enter URL manually"
+        ]
+        if rejectedExactLabels.contains(label) {
+            return false
+        }
+
+        if label.hasPrefix("http://") || label.hasPrefix("https://") {
+            return false
+        }
+
+        return label.contains(" http://") || label.contains(" https://")
+    }
+
     private func hideKeyboard(app: XCUIApplication) -> [String: Any] {
         guard app.keyboards.firstMatch.exists else {
             return ok()
@@ -375,41 +484,39 @@ final class ZMRShimUITestCase: XCTestCase {
             return nil
         }
 
-        let query: XCUIElementQuery?
+        let queries: [XCUIElementQuery]
         switch parts.field {
         case "text", "label":
             let predicate = parts.contains
                 ? NSPredicate(format: "label CONTAINS[c] %@", parts.value)
                 : NSPredicate(format: "label == %@", parts.value)
-            query = app.descendants(matching: .any).matching(predicate)
+            queries = allDescendantQueries(app: app, type: .any).map { $0.matching(predicate) }
         case "identifier", "resourceId":
             let predicate = parts.contains
                 ? NSPredicate(format: "identifier CONTAINS[c] %@", parts.value)
                 : NSPredicate(format: "identifier == %@", parts.value)
-            query = app.descendants(matching: .any).matching(predicate)
+            queries = allDescendantQueries(app: app, type: .any).map { $0.matching(predicate) }
         case "value":
             let predicate = parts.contains
                 ? NSPredicate(format: "value CONTAINS[c] %@", parts.value)
                 : NSPredicate(format: "value == %@", parts.value)
-            query = app.descendants(matching: .any).matching(predicate)
+            queries = allDescendantQueries(app: app, type: .any).map { $0.matching(predicate) }
         case "id":
             if parts.value.hasPrefix("id:") {
                 let identifier = String(parts.value.dropFirst("id:".count))
-                query = app.descendants(matching: .any).matching(identifier: identifier)
+                queries = allDescendantQueries(app: app, type: .any).map { $0.matching(identifier: identifier) }
             } else if parts.value.hasPrefix("label:") {
                 let label = String(parts.value.dropFirst("label:".count))
-                query = app.descendants(matching: .any).matching(NSPredicate(format: "label == %@", label))
+                let predicate = NSPredicate(format: "label == %@", label)
+                queries = allDescendantQueries(app: app, type: .any).map { $0.matching(predicate) }
             } else {
-                query = nil
+                queries = []
             }
         default:
-            query = nil
+            queries = []
         }
 
-        guard let element = query?.firstMatch, element.exists else {
-            return nil
-        }
-        return element
+        return firstExistingElement(queries: queries)
     }
 
     private func resolveFastElement(selector: String, app: XCUIApplication, preferredTypes: [XCUIElement.ElementType]) -> XCUIElement? {
@@ -449,9 +556,15 @@ final class ZMRShimUITestCase: XCTestCase {
     private func fastTextQueries(app: XCUIApplication, preferredTypes: [XCUIElement.ElementType]) -> [XCUIElementQuery] {
         var queries: [XCUIElementQuery] = []
         if !preferredTypes.isEmpty {
-            queries.append(contentsOf: preferredTypes.map { app.descendants(matching: $0) })
+            queries.append(contentsOf: preferredTypes.flatMap { allDescendantQueries(app: app, type: $0) })
         }
         queries.append(contentsOf: [
+            app.windows.descendants(matching: .button),
+            app.windows.descendants(matching: .staticText),
+            app.windows.descendants(matching: .textField),
+            app.windows.descendants(matching: .secureTextField),
+            app.windows.descendants(matching: .textView),
+            app.windows.descendants(matching: .image),
             app.buttons,
             app.staticTexts,
             app.textFields,
@@ -462,6 +575,13 @@ final class ZMRShimUITestCase: XCTestCase {
         return queries
     }
 
+    private func allDescendantQueries(app: XCUIApplication, type: XCUIElement.ElementType) -> [XCUIElementQuery] {
+        [
+            app.windows.descendants(matching: type),
+            app.descendants(matching: type)
+        ]
+    }
+
     private func fastIdentifierQueries(
         app: XCUIApplication,
         preferredTypes: [XCUIElement.ElementType],

package/src/android.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const command = @import("command.zig");
 const android_device_info = @import("android_device_info.zig");
 const android_shell = @import("android_shell.zig");
@@ -93,7 +94,7 @@ pub const AndroidDevice = struct {
 
             if (self.isAppForeground() catch false) return;
             if (attempt + 1 < open_link_attempts) {
-                std.Thread.sleep(open_link_retry_delay_ms * std.time.ns_per_ms);
+                stdio.sleepNs(open_link_retry_delay_ms * std.time.ns_per_ms);
             }
         }
         return error.AppDidNotOpen;
@@ -164,11 +165,11 @@ pub const AndroidDevice = struct {
                 .duration_ms = @as(u32, @intCast(@min(timeout_ms, std.math.maxInt(u32)))),
             });
         }
-        std.Thread.sleep(timeout_ms * std.time.ns_per_ms);
+        stdio.sleepNs(timeout_ms * std.time.ns_per_ms);
     }
 
     pub fn snapshot(self: *AndroidDevice, writer: ?*trace.TraceWriter) !types.ObservationSnapshot {
-        const id = if (writer) |tw| try tw.nextSnapshotId() else try std.fmt.allocPrint(self.allocator, "snapshot-{d}", .{std.time.milliTimestamp()});
+        const id = if (writer) |tw| try tw.nextSnapshotId() else try std.fmt.allocPrint(self.allocator, "snapshot-{d}", .{stdio.nowMs()});
         errdefer self.allocator.free(id);
 
         const xml = if (self.shim_path == null) try self.dumpHierarchy() else null;
@@ -215,7 +216,7 @@ pub const AndroidDevice = struct {
 
         return .{
             .id = id,
-            .timestamp_ms = std.time.milliTimestamp(),
+            .timestamp_ms = stdio.nowMs(),
             .viewport = screen,
             .display_density_dpi = display_density_dpi,
             .active_package = active.package,
@@ -273,7 +274,7 @@ pub const AndroidDevice = struct {
     fn logDelta(self: *AndroidDevice) !?[]const u8 {
         const result = try self.runAdb(&.{ "logcat", "-d", "-t", "80" }, 1024 * 1024);
         defer result.deinit(self.allocator);
-        if (result.term != .Exited or result.term.Exited != 0) return null;
+        if (result.term != .exited or result.term.exited != 0) return null;
         return try self.allocator.dupe(u8, result.stdout);
     }
 
@@ -292,11 +293,11 @@ pub const AndroidDevice = struct {
     fn runShim(self: *AndroidDevice, shim_command: ios_shim.Command) ![]u8 {
         const path = self.shim_path orelse return error.AndroidShimRequired;
 
-        var input = std.ArrayList(u8).empty;
-        defer input.deinit(self.allocator);
-        try ios_shim.writeCommandJson(input.writer(self.allocator), shim_command);
+        var input: std.Io.Writer.Allocating = .init(self.allocator);
+        defer input.deinit();
+        try ios_shim.writeCommandJson(&input.writer, shim_command);
 
-        const result = try command.runWithInputTimeout(self.allocator, &.{path}, input.items, 4 * 1024 * 1024, shim_timeout_ms);
+        const result = try command.runWithInputTimeout(self.allocator, &.{path}, input.writer.buffered(), 4 * 1024 * 1024, shim_timeout_ms);
         defer result.deinit(self.allocator);
         try result.ensureSuccess();
         return try self.allocator.dupe(u8, result.stdout);

package/src/android_emulator.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const command = @import("command.zig");
 
 const default_timeout_ms = 15_000;
@@ -100,11 +101,12 @@ fn startEmulator(allocator: std.mem.Allocator, options: PreflightOptions, avd: [
     try argv.appendSlice(allocator, &.{ "-netdelay", "none", "-netspeed", "full" });
     try recordCommand(allocator, options.event_log_path, argv.items);
 
-    var child = std.process.Child.init(argv.items, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    _ = try std.process.spawn(stdio.io(), .{
+        .argv = argv.items,
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
 }
 
 fn waitReady(allocator: std.mem.Allocator, options: PreflightOptions) !void {
@@ -118,7 +120,7 @@ fn waitReady(allocator: std.mem.Allocator, options: PreflightOptions) !void {
         try prop.ensureSuccess();
         const value = std.mem.trim(u8, prop.stdout, " \t\r\n");
         if (std.mem.eql(u8, value, "1")) return;
-        std.Thread.sleep(2 * std.time.ns_per_s);
+        stdio.sleepNs(2 * std.time.ns_per_s);
     }
     return error.AndroidEmulatorBootTimedOut;
 }
@@ -137,12 +139,20 @@ fn runAdb(allocator: std.mem.Allocator, options: PreflightOptions, extra: []cons
 
 fn recordCommand(allocator: std.mem.Allocator, maybe_path: ?[]const u8, argv: []const []const u8) !void {
     const path = maybe_path orelse return;
-    var file = std.fs.cwd().openFile(path, .{ .mode = .write_only }) catch |err| switch (err) {
-        error.FileNotFound => try std.fs.cwd().createFile(path, .{ .truncate = true }),
+    const existing = stdio.readFileAlloc(allocator, path, 4 * 1024 * 1024) catch |err| switch (err) {
+        error.FileNotFound => "",
         else => return err,
     };
-    defer file.close();
-    try file.seekFromEnd(0);
+    const had_existing_file = existing.ptr != "".ptr;
+    defer if (had_existing_file) allocator.free(existing);
+
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+    defer file.close(stdio.io());
+    var write_buffer: [8192]u8 = undefined;
+    var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
+    const writer = &file_writer.interface;
+    if (existing.len > 0) try writer.writeAll(existing);
+
     var line = std.ArrayList(u8).empty;
     defer line.deinit(allocator);
     for (argv, 0..) |arg, index| {
@@ -150,5 +160,6 @@ fn recordCommand(allocator: std.mem.Allocator, maybe_path: ?[]const u8, argv: []
         try line.appendSlice(allocator, arg);
     }
     try line.append(allocator, '\n');
-    try file.writeAll(line.items);
+    try writer.writeAll(line.items);
+    try writer.flush();
 }

package/src/android_screen_recording.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const command = @import("command.zig");
 const trace = @import("trace.zig");
 const types = @import("types.zig");
@@ -27,11 +28,12 @@ pub fn start(
     const owned_remote_path = try allocator.dupe(u8, remote_path);
     errdefer allocator.free(owned_remote_path);
 
-    var child = std.process.Child.init(argv.items, allocator);
-    child.stdin_behavior = .Ignore;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = .Ignore;
-    try child.spawn();
+    const child = try std.process.spawn(stdio.io(), .{
+        .argv = argv.items,
+        .stdin = .ignore,
+        .stdout = .ignore,
+        .stderr = .ignore,
+    });
 
     return .{
         .allocator = allocator,
@@ -74,8 +76,10 @@ pub const AndroidScreenRecording = struct {
 
     fn stopProcess(self: *AndroidScreenRecording) !void {
         if (self.stopped) return;
-        std.posix.kill(self.child.id, std.posix.SIG.INT) catch {};
-        _ = try self.child.wait();
+        if (self.child.id) |child_id| {
+            std.posix.kill(child_id, std.posix.SIG.INT) catch {};
+            _ = try self.child.wait(stdio.io());
+        }
         self.stopped = true;
     }
 

package/src/bundle.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const bundle_redaction = @import("bundle_redaction.zig");
 const bundle_tar = @import("bundle_tar.zig");
+const stdio = @import("stdio.zig");
 
 pub const ExportOptions = bundle_redaction.Options;
 
@@ -40,8 +41,8 @@ pub fn exportTraceBundleWithOptions(
         try entries.append(allocator, try allocator.dupe(u8, entry));
     }
 
-    var out_file = try std.fs.cwd().createFile(out_path, .{ .truncate = true });
-    defer out_file.close();
+    var out_file = try std.Io.Dir.cwd().createFile(stdio.io(), out_path, .{ .truncate = true });
+    defer out_file.close(stdio.io());
 
     for (entries.items) |archive_path| {
         if (options.redact) {
@@ -60,7 +61,7 @@ pub fn exportTraceBundleWithOptions(
             try bundle_tar.writeFile(allocator, trace_dir, archive_path, &out_file);
         }
     }
-    try out_file.writeAll(&([_]u8{0} ** 1024));
+    try std.Io.File.writeStreamingAll(out_file, stdio.io(), &([_]u8{0} ** 1024));
 }
 
 fn requireTraceFile(
@@ -75,18 +76,18 @@ fn requireTraceFile(
 fn traceFileExists(allocator: std.mem.Allocator, trace_dir: []const u8, archive_path: []const u8) !bool {
     const path = try std.fs.path.join(allocator, &.{ trace_dir, archive_path });
     defer allocator.free(path);
-    const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
+    const file = std.Io.Dir.cwd().openFile(stdio.io(), path, .{}) catch |err| switch (err) {
         error.FileNotFound => return false,
         else => return err,
     };
-    file.close();
+    file.close(stdio.io());
     return true;
 }
 
 fn readTraceFile(allocator: std.mem.Allocator, trace_dir: []const u8, archive_path: []const u8) ![]u8 {
     const path = try std.fs.path.join(allocator, &.{ trace_dir, archive_path });
     defer allocator.free(path);
-    return try std.fs.cwd().readFileAlloc(allocator, path, 64 * 1024 * 1024);
+    return try stdio.readFileAlloc(allocator, path, 64 * 1024 * 1024);
 }
 
 fn collectArtifactEntries(
@@ -98,14 +99,14 @@ fn collectArtifactEntries(
     const fs_dir = try std.fs.path.join(allocator, &.{ trace_dir, archive_dir });
     defer allocator.free(fs_dir);
 
-    var dir = std.fs.cwd().openDir(fs_dir, .{ .iterate = true }) catch |err| switch (err) {
+    var dir = std.Io.Dir.cwd().openDir(stdio.io(), fs_dir, .{ .iterate = true }) catch |err| switch (err) {
         error.FileNotFound => return,
         else => return err,
     };
-    defer dir.close();
+    defer dir.close(stdio.io());
 
     var iterator = dir.iterate();
-    while (try iterator.next()) |entry| {
+    while (try iterator.next(stdio.io())) |entry| {
         const archive_path = try std.fmt.allocPrint(allocator, "{s}/{s}", .{ archive_dir, entry.name });
         errdefer allocator.free(archive_path);
         switch (entry.kind) {

package/src/bundle_redaction.zig

@@ -24,21 +24,21 @@ fn redactTraceManifest(allocator: std.mem.Allocator, bytes: []const u8, options:
     if (parsed.value != .object) return try redactJsonishText(allocator, bytes);
 
     const arena_allocator = parsed.arena.allocator();
-    var redaction = std.json.ObjectMap.init(arena_allocator);
-    try redaction.put("enabled", .{ .bool = true });
-    try redaction.put("screenshots", .{ .string = if (options.omit_screenshots) "omitted" else "placeholder" });
-    try redaction.put("screenRecordings", .{ .string = "omitted" });
-    try redaction.put("textArtifacts", .{ .string = "scrubbed" });
-    try redaction.put("screenshotsOmitted", .{ .bool = options.omit_screenshots });
-    try redaction.put("screenshotsRedacted", .{ .bool = !options.omit_screenshots });
-    try redaction.put("screenRecordingsOmitted", .{ .bool = true });
-    try parsed.value.object.put("redaction", .{ .object = redaction });
+    var redaction = std.json.ObjectMap{};
+    try redaction.put(arena_allocator, "enabled", .{ .bool = true });
+    try redaction.put(arena_allocator, "screenshots", .{ .string = if (options.omit_screenshots) "omitted" else "placeholder" });
+    try redaction.put(arena_allocator, "screenRecordings", .{ .string = "omitted" });
+    try redaction.put(arena_allocator, "textArtifacts", .{ .string = "scrubbed" });
+    try redaction.put(arena_allocator, "screenshotsOmitted", .{ .bool = options.omit_screenshots });
+    try redaction.put(arena_allocator, "screenshotsRedacted", .{ .bool = !options.omit_screenshots });
+    try redaction.put(arena_allocator, "screenRecordingsOmitted", .{ .bool = true });
+    try parsed.value.object.put(arena_allocator, "redaction", .{ .object = redaction });
 
-    var out = std.ArrayList(u8).empty;
-    errdefer out.deinit(allocator);
-    try writeJsonValueRedacted(out.writer(allocator), parsed.value, null);
-    try out.writer(allocator).writeByte('\n');
-    return try out.toOwnedSlice(allocator);
+    var out: std.Io.Writer.Allocating = .init(allocator);
+    errdefer out.deinit();
+    try writeJsonValueRedacted(&out.writer, parsed.value, null);
+    try out.writer.writeByte('\n');
+    return try out.toOwnedSlice();
 }
 
 fn redactJsonishText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
@@ -46,11 +46,11 @@ fn redactJsonishText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
         return redactFreeText(allocator, bytes);
     };
     defer parsed.deinit();
-    var out = std.ArrayList(u8).empty;
-    errdefer out.deinit(allocator);
-    try writeJsonValueRedacted(out.writer(allocator), parsed.value, null);
-    try out.writer(allocator).writeByte('\n');
-    return try out.toOwnedSlice(allocator);
+    var out: std.Io.Writer.Allocating = .init(allocator);
+    errdefer out.deinit();
+    try writeJsonValueRedacted(&out.writer, parsed.value, null);
+    try out.writer.writeByte('\n');
+    return try out.toOwnedSlice();
 }
 
 fn writeJsonValueRedacted(writer: anytype, value: std.json.Value, key_context: ?[]const u8) !void {
@@ -98,8 +98,9 @@ fn writeRedactedJsonStringForKey(writer: anytype, key: []const u8, value: []cons
 }
 
 fn redactFreeText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
-    var out = std.ArrayList(u8).empty;
-    errdefer out.deinit(allocator);
+    var out: std.Io.Writer.Allocating = .init(allocator);
+    errdefer out.deinit();
+    const writer = &out.writer;
     var sensitive_tag = false;
     var index: usize = 0;
     while (index < bytes.len) {
@@ -111,31 +112,31 @@ fn redactFreeText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
 
         if (sensitive_tag and (startsWithAt(bytes, index, "text=\"") or startsWithAt(bytes, index, "content-desc=\""))) {
             const prefix_len: usize = if (startsWithAt(bytes, index, "text=\"")) 6 else 14;
-            try out.writer(allocator).writeAll(bytes[index .. index + prefix_len]);
-            try out.writer(allocator).writeAll("[REDACTED:secret]");
+            try writer.writeAll(bytes[index .. index + prefix_len]);
+            try writer.writeAll("[REDACTED:secret]");
             index += prefix_len;
             while (index < bytes.len and bytes[index] != '"') : (index += 1) {}
             if (index < bytes.len) {
-                try out.writer(allocator).writeByte('"');
+                try writer.writeByte('"');
                 index += 1;
             }
             continue;
         }
 
         if (emailEnd(bytes, index)) |end| {
-            try out.writer(allocator).writeAll("[REDACTED:email]");
+            try writer.writeAll("[REDACTED:email]");
             index = end;
             continue;
         }
         if (bearerEnd(bytes, index)) |end| {
-            try out.writer(allocator).writeAll("[REDACTED:token]");
+            try writer.writeAll("[REDACTED:token]");
             index = end;
             continue;
         }
-        try out.writer(allocator).writeByte(bytes[index]);
+        try writer.writeByte(bytes[index]);
         index += 1;
     }
-    return try out.toOwnedSlice(allocator);
+    return try out.toOwnedSlice();
 }
 
 fn emailEnd(bytes: []const u8, start: usize) ?usize {

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| {