zeno-mobile-runner 0.2.1 → 0.2.2

package/src/stdio.zig

@@ -0,0 +1,129 @@
+const std = @import("std");
+
+const default_buffer_size = 8192;
+var process_environ: ?std.process.Environ = null;
+var process_threaded: ?std.Io.Threaded = null;
+
+fn processIo() std.Io {
+    if (process_threaded) |*threaded| return threaded.io();
+    return std.Io.Threaded.global_single_threaded.io();
+}
+
+pub fn initProcess(init: std.process.Init.Minimal, allocator: std.mem.Allocator) void {
+    process_environ = init.environ;
+    process_threaded = .init(allocator, .{
+        .argv0 = .init(init.args),
+        .environ = init.environ,
+    });
+}
+
+pub fn deinitProcess() void {
+    if (process_threaded) |*threaded| {
+        threaded.deinit();
+        process_threaded = null;
+    }
+    process_environ = null;
+}
+
+pub fn io() std.Io {
+    return processIo();
+}
+
+pub fn sleepNs(nanoseconds: u64) void {
+    std.Io.sleep(
+        processIo(),
+        std.Io.Duration.fromNanoseconds(@intCast(nanoseconds)),
+        .awake,
+    ) catch {};
+}
+
+pub fn nowNs() i96 {
+    return std.Io.Clock.real.now(processIo()).nanoseconds;
+}
+
+pub fn nowMs() i64 {
+    return @intCast(@divTrunc(nowNs(), std.time.ns_per_ms));
+}
+
+pub fn getenv(name: []const u8) ?[]const u8 {
+    const environ = process_environ orelse return null;
+    const block = environ.block;
+    const Block = @TypeOf(block);
+    if (Block != std.process.Environ.PosixBlock) return null;
+
+    for (block.view().slice) |entry_ptr| {
+        const entry = std.mem.span(entry_ptr);
+        if (entry.len <= name.len or entry[name.len] != '=') continue;
+        if (std.mem.eql(u8, entry[0..name.len], name)) return entry[name.len + 1 ..];
+    }
+    return null;
+}
+
+pub fn access(path: []const u8) !void {
+    return accessWithOptions(path, .{});
+}
+
+pub fn accessWithOptions(path: []const u8, options: std.Io.Dir.AccessOptions) !void {
+    return std.Io.Dir.cwd().access(processIo(), path, options);
+}
+
+pub fn readFileAlloc(allocator: std.mem.Allocator, path: []const u8, limit: usize) ![]u8 {
+    return std.Io.Dir.cwd().readFileAlloc(processIo(), path, allocator, .limited(limit));
+}
+
+pub const Output = struct {
+    buffer: [default_buffer_size]u8 = undefined,
+    file_writer: std.Io.File.Writer = undefined,
+    initialized: bool = false,
+
+    pub fn init(self: *Output, file: std.Io.File) void {
+        self.file_writer = file.writerStreaming(processIo(), &self.buffer);
+        self.initialized = true;
+    }
+
+    pub fn writer(self: *Output) *std.Io.Writer {
+        return &self.file_writer.interface;
+    }
+
+    pub fn flush(self: *Output) !void {
+        if (self.initialized) try self.file_writer.interface.flush();
+    }
+
+    pub fn deinit(self: *Output) void {
+        self.flush() catch {};
+        self.initialized = false;
+    }
+};
+
+pub const Input = struct {
+    buffer: [default_buffer_size]u8 = undefined,
+    file_reader: std.Io.File.Reader = undefined,
+
+    pub fn init(self: *Input, file: std.Io.File) void {
+        self.file_reader = file.readerStreaming(processIo(), &self.buffer);
+    }
+
+    pub fn reader(self: *Input) *std.Io.Reader {
+        return &self.file_reader.interface;
+    }
+};
+
+pub fn readLineAlloc(reader: *std.Io.Reader, allocator: std.mem.Allocator, max_bytes: usize) !?[]u8 {
+    var out: std.Io.Writer.Allocating = .init(allocator);
+    errdefer out.deinit();
+
+    _ = try reader.streamDelimiterLimit(&out.writer, '\n', .limited(max_bytes));
+
+    const next = reader.peek(1) catch |err| switch (err) {
+        error.EndOfStream => {
+            if (out.writer.end == 0) {
+                out.deinit();
+                return null;
+            }
+            return try out.toOwnedSlice();
+        },
+        else => |actual| return actual,
+    };
+    if (next.len > 0 and next[0] == '\n') reader.toss(1);
+    return try out.toOwnedSlice();
+}

package/src/trace.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const selector = @import("selector.zig");
 const trace_json = @import("trace_json.zig");
 const types = @import("types.zig");
@@ -28,11 +29,11 @@ pub const TraceWriter = struct {
     }
 
     pub fn initWithOptions(allocator: std.mem.Allocator, root_dir: []const u8, capture: CaptureOptions) !TraceWriter {
-        try std.fs.cwd().makePath(root_dir);
+        try std.Io.Dir.cwd().createDirPath(stdio.io(), root_dir);
         try resetTraceDirectory(allocator, root_dir);
         const artifacts_path = try std.fs.path.join(allocator, &.{ root_dir, "artifacts" });
         defer allocator.free(artifacts_path);
-        try std.fs.cwd().makePath(artifacts_path);
+        try std.Io.Dir.cwd().createDirPath(stdio.io(), artifacts_path);
         return .{
             .allocator = allocator,
             .root_dir = try allocator.dupe(u8, root_dir),
@@ -51,7 +52,7 @@ pub const TraceWriter = struct {
             .scenario_name = try self.allocator.dupe(u8, scenario_name),
             .app_id = try dupeOptional(self.allocator, app_id),
             .status = try self.allocator.dupe(u8, "running"),
-            .started_at_ms = std.time.milliTimestamp(),
+            .started_at_ms = stdio.nowMs(),
         };
         try self.writeManifest();
     }
@@ -68,7 +69,7 @@ pub const TraceWriter = struct {
         var manifest = &self.manifest.?;
         self.allocator.free(manifest.status);
         manifest.status = try self.allocator.dupe(u8, options.status);
-        manifest.ended_at_ms = std.time.milliTimestamp();
+        manifest.ended_at_ms = stdio.nowMs();
         manifest.failed_step_index = options.failed_step_index;
         if (manifest.error_name) |value| self.allocator.free(value);
         manifest.error_name = try dupeOptional(self.allocator, options.error_name);
@@ -99,9 +100,9 @@ pub const TraceWriter = struct {
     pub fn writeArtifact(self: *TraceWriter, name: []const u8, bytes: []const u8) ![]const u8 {
         const path = try self.artifactPath(name);
         errdefer self.allocator.free(path);
-        var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-        defer file.close();
-        try file.writeAll(bytes);
+        var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+        defer file.close(stdio.io());
+        try std.Io.File.writeStreamingAll(file, stdio.io(), bytes);
         return path;
     }
 
@@ -110,15 +111,22 @@ pub const TraceWriter = struct {
         if (isPartialFailureEvent(kind, payload)) self.partial_failure_count += 1;
         const path = try std.fs.path.join(self.allocator, &.{ self.root_dir, "events.jsonl" });
         defer self.allocator.free(path);
-        var file = try std.fs.cwd().createFile(path, .{ .truncate = false });
-        defer file.close();
-        try file.seekFromEnd(0);
+        const existing = stdio.readFileAlloc(self.allocator, path, 64 * 1024 * 1024) catch |err| switch (err) {
+            error.FileNotFound => "",
+            else => return err,
+        };
+        const had_existing_file = existing.ptr != "".ptr;
+        defer if (had_existing_file) self.allocator.free(existing);
+
+        var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+        defer file.close(stdio.io());
         var write_buffer: [4096]u8 = undefined;
-        var file_writer = file.writerStreaming(&write_buffer);
+        var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
         const writer = &file_writer.interface;
+        if (existing.len > 0) try writer.writeAll(existing);
         try writer.print(
             "{{\"seq\":{d},\"timestampMs\":{d},\"kind\":\"{s}\",\"payload\":",
-            .{ self.event_count, std.time.milliTimestamp(), kind },
+            .{ self.event_count, stdio.nowMs(), kind },
         );
         try trace_json.writeRedactedJsonPayload(self.allocator, writer, payload, self.capture.redaction);
         try writer.writeAll("}\n");
@@ -131,10 +139,10 @@ pub const TraceWriter = struct {
         defer self.allocator.free(file_name);
         const path = try self.artifactPath(file_name);
         errdefer self.allocator.free(path);
-        var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-        defer file.close();
+        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.writer(&write_buffer);
+        var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
         try trace_json.writeSnapshotJsonRedacted(&file_writer.interface, snapshot, self.capture.redaction);
         try file_writer.interface.flush();
         return path;
@@ -149,10 +157,10 @@ pub const TraceWriter = struct {
         const manifest = self.manifest.?;
         const path = try std.fs.path.join(self.allocator, &.{ self.root_dir, "trace.json" });
         defer self.allocator.free(path);
-        var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-        defer file.close();
+        var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+        defer file.close(stdio.io());
         var write_buffer: [4096]u8 = undefined;
-        var file_writer = file.writer(&write_buffer);
+        var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
         const writer = &file_writer.interface;
 
         try writer.writeAll("{");
@@ -223,7 +231,7 @@ fn resetTraceDirectory(allocator: std.mem.Allocator, root_dir: []const u8) !void
     for (stale_files) |name| {
         const path = try std.fs.path.join(allocator, &.{ root_dir, name });
         defer allocator.free(path);
-        std.fs.cwd().deleteFile(path) catch |err| switch (err) {
+        std.Io.Dir.cwd().deleteFile(stdio.io(), path) catch |err| switch (err) {
             error.FileNotFound => {},
             else => return err,
         };
@@ -232,11 +240,11 @@ fn resetTraceDirectory(allocator: std.mem.Allocator, root_dir: []const u8) !void
     const artifacts_path = try std.fs.path.join(allocator, &.{ root_dir, "artifacts" });
     defer allocator.free(artifacts_path);
     var artifacts_exists = true;
-    std.fs.cwd().access(artifacts_path, .{}) catch |err| switch (err) {
+    stdio.access(artifacts_path) catch |err| switch (err) {
         error.FileNotFound => artifacts_exists = false,
         else => return err,
     };
-    if (artifacts_exists) try std.fs.cwd().deleteTree(artifacts_path);
+    if (artifacts_exists) try std.Io.Dir.cwd().deleteTree(stdio.io(), artifacts_path);
 }
 
 const Manifest = struct {
@@ -271,7 +279,7 @@ pub fn attachReportPath(allocator: std.mem.Allocator, root_dir: []const u8, repo
     const manifest_path = try std.fs.path.join(allocator, &.{ root_dir, "trace.json" });
     defer allocator.free(manifest_path);
 
-    const content = std.fs.cwd().readFileAlloc(allocator, manifest_path, 1024 * 1024) catch |err| switch (err) {
+    const content = stdio.readFileAlloc(allocator, manifest_path, 1024 * 1024) catch |err| switch (err) {
         error.FileNotFound => return,
         else => return err,
     };
@@ -283,12 +291,12 @@ pub fn attachReportPath(allocator: std.mem.Allocator, root_dir: []const u8, repo
 
     const arena_allocator = parsed.arena.allocator();
     const owned_report_path = try arena_allocator.dupe(u8, report_path);
-    try parsed.value.object.put("reportPath", .{ .string = owned_report_path });
+    try parsed.value.object.put(arena_allocator, "reportPath", .{ .string = owned_report_path });
 
-    var file = try std.fs.cwd().createFile(manifest_path, .{ .truncate = true });
-    defer file.close();
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), manifest_path, .{ .truncate = true });
+    defer file.close(stdio.io());
     var write_buffer: [4096]u8 = undefined;
-    var file_writer = file.writer(&write_buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &write_buffer);
     try std.json.Stringify.value(parsed.value, .{}, &file_writer.interface);
     try file_writer.interface.writeByte('\n');
     try file_writer.interface.flush();

package/src/trace_summary.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const trace = @import("trace.zig");
 const trace_summary_diagnostic = @import("trace_summary_diagnostic.zig");
 
@@ -59,7 +60,7 @@ const TerminalEvent = struct {
 pub fn read(allocator: std.mem.Allocator, trace_dir: []const u8) !Summary {
     const manifest_path = try std.fs.path.join(allocator, &.{ trace_dir, "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);
 
     const manifest = try std.json.parseFromSlice(std.json.Value, allocator, manifest_content, .{});
@@ -91,7 +92,7 @@ pub fn read(allocator: std.mem.Allocator, trace_dir: []const u8) !Summary {
 
     const events_path = try std.fs.path.join(allocator, &.{ trace_dir, events_path_value });
     defer allocator.free(events_path);
-    if (std.fs.cwd().readFileAlloc(allocator, events_path, 64 * 1024 * 1024)) |events_content| {
+    if (stdio.readFileAlloc(allocator, events_path, 64 * 1024 * 1024)) |events_content| {
         defer allocator.free(events_content);
         try scanEvents(allocator, events_content, &terminal, &diagnostic, &partial_failure, &last_kind);
     } else |err| switch (err) {

package/src/trace_summary_diagnostic.zig

@@ -142,44 +142,46 @@ fn writeJoinedStringArrayJson(writer: anytype, value: []const u8) !void {
 
 fn joinStringArray(allocator: std.mem.Allocator, value: std.json.Value, limit: usize) !?[]u8 {
     if (value != .array or value.array.items.len == 0) return null;
-    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 written: usize = 0;
     for (value.array.items) |item| {
         if (item != .string) continue;
-        if (written > 0) try out.writer(allocator).writeAll(" | ");
-        try out.writer(allocator).writeAll(item.string);
+        if (written > 0) try writer.writeAll(" | ");
+        try writer.writeAll(item.string);
         written += 1;
         if (written >= limit) break;
     }
     if (written == 0) {
-        out.deinit(allocator);
+        out.deinit();
         return null;
     }
-    return try out.toOwnedSlice(allocator);
+    return try out.toOwnedSlice();
 }
 
 fn joinNearestMatches(allocator: std.mem.Allocator, value: std.json.Value, limit: usize) !?[]u8 {
     if (value != .array or value.array.items.len == 0) return null;
-    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 written: usize = 0;
     for (value.array.items) |item| {
         if (item != .object) continue;
         const text = stringField(item.object, "text") orelse continue;
-        if (written > 0) try out.writer(allocator).writeAll(" | ");
-        try out.writer(allocator).writeAll(text);
+        if (written > 0) try writer.writeAll(" | ");
+        try writer.writeAll(text);
         if (intField(item.object, "score")) |score| {
-            try out.writer(allocator).print(" (score {d})", .{score});
+            try writer.print(" (score {d})", .{score});
         }
         written += 1;
         if (written >= limit) break;
     }
     if (written == 0) {
-        out.deinit(allocator);
+        out.deinit();
         return null;
     }
-    return try out.toOwnedSlice(allocator);
+    return try out.toOwnedSlice();
 }
 
 fn dupeOptionalString(allocator: std.mem.Allocator, value: ?[]const u8) !?[]u8 {

package/src/validation.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const errors = @import("errors.zig");
 const scenario = @import("scenario.zig");
 
@@ -23,7 +24,7 @@ pub const Result = struct {
 };
 
 pub fn validateFile(allocator: std.mem.Allocator, path: []const u8) !Result {
-    const content = std.fs.cwd().readFileAlloc(allocator, path, 16 * 1024 * 1024) catch |err| return failure(allocator, null, err);
+    const content = stdio.readFileAlloc(allocator, path, 16 * 1024 * 1024) catch |err| return failure(allocator, null, err);
     defer allocator.free(content);
     const script = scenario.parseSlice(allocator, content) catch |err| return failure(allocator, content, err);
     defer script.deinit(allocator);
@@ -91,10 +92,10 @@ fn diagnoseFailure(allocator: std.mem.Allocator, content: []const u8, err: anyer
         => try pathDiagnostic(allocator, content, "$.steps", "steps"),
         error.StepMissingAction,
         error.StepActionMustBeString,
-        error.UnknownAction,
-        error.UnknownScenarioAction,
+        error.unknownAction,
+        error.unknownScenarioAction,
         => try pathDiagnostic(allocator, content, "$.steps[].action", "action"),
-        error.UnknownScrollDirection,
+        error.unknownScrollDirection,
         => try pathDiagnostic(allocator, content, "$.steps[].direction", "direction"),
         error.StepMissingUrl,
         => try pathDiagnostic(allocator, content, "$.steps[].url", "url"),

package/src/version.zig

@@ -1,4 +1,4 @@
-pub const runner_version = "0.2.1";
+pub const runner_version = "0.2.2";
 pub const protocol_version = "2026-04-28";
 pub const protocol_min_compatible_version = "2026-04-28";
 pub const protocol_stability = "dev-preview";