zig-mobile-runner 0.1.0

package/src/android_emulator.zig

@@ -0,0 +1,154 @@
+const std = @import("std");
+const command = @import("command.zig");
+
+const default_timeout_ms = 15_000;
+
+pub const PreflightOptions = struct {
+    adb_path: []const u8 = "adb",
+    emulator_path: []const u8 = "emulator",
+    avdmanager_path: []const u8 = "avdmanager",
+    device_serial: ?[]const u8 = null,
+    avd_name: ?[]const u8 = null,
+    restore_snapshot: ?[]const u8 = null,
+    create_avd_if_missing: bool = false,
+    avd_system_image: ?[]const u8 = null,
+    avd_device_profile: ?[]const u8 = null,
+    reset_before_run: bool = false,
+    wait_ready: bool = false,
+    event_log_path: ?[]const u8 = null,
+};
+
+pub fn hasWork(options: PreflightOptions) bool {
+    return options.reset_before_run or options.wait_ready or options.create_avd_if_missing or options.avd_name != null or options.restore_snapshot != null;
+}
+
+pub fn runPreflight(allocator: std.mem.Allocator, options: PreflightOptions) !void {
+    if (!hasWork(options)) return;
+
+    if ((options.reset_before_run or options.restore_snapshot != null or options.create_avd_if_missing or options.avd_name != null) and options.avd_name == null) {
+        return error.MissingAndroidAvdName;
+    }
+    if (options.create_avd_if_missing and options.avd_system_image == null) {
+        return error.MissingAndroidAvdSystemImage;
+    }
+
+    if (options.create_avd_if_missing) {
+        try createAvdIfMissing(allocator, options, options.avd_name.?);
+    }
+
+    if (options.reset_before_run) {
+        const reset = runAdb(allocator, options, &.{ "emu", "kill" }) catch null;
+        if (reset) |result| result.deinit(allocator);
+    }
+
+    if (options.avd_name) |avd| {
+        try startEmulator(allocator, options, avd);
+    }
+
+    if (options.wait_ready) {
+        try waitReady(allocator, options);
+    }
+}
+
+fn createAvdIfMissing(allocator: std.mem.Allocator, options: PreflightOptions, avd: []const u8) !void {
+    var list = try runEmulator(allocator, options, &.{"-list-avds"});
+    defer list.deinit(allocator);
+    try list.ensureSuccess();
+    if (avdListContains(list.stdout, avd)) return;
+
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.appendSlice(allocator, &.{ options.avdmanager_path, "create", "avd", "--name", avd, "--package", options.avd_system_image.? });
+    if (options.avd_device_profile) |profile| {
+        try argv.appendSlice(allocator, &.{ "--device", profile });
+    }
+    try argv.append(allocator, "--force");
+    try recordCommand(allocator, options.event_log_path, argv.items);
+    var result = try command.runWithInputTimeout(allocator, argv.items, "no\n", 1024 * 1024, default_timeout_ms);
+    defer result.deinit(allocator);
+    try result.ensureSuccess();
+}
+
+fn avdListContains(output: []const u8, avd: []const u8) bool {
+    var lines = std.mem.splitScalar(u8, output, '\n');
+    while (lines.next()) |raw_line| {
+        const line = std.mem.trim(u8, raw_line, " \t\r\n");
+        if (std.mem.eql(u8, line, avd)) return true;
+    }
+    return false;
+}
+
+fn runEmulator(allocator: std.mem.Allocator, options: PreflightOptions, extra: []const []const u8) !command.ExecResult {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, options.emulator_path);
+    try argv.appendSlice(allocator, extra);
+    try recordCommand(allocator, options.event_log_path, argv.items);
+    return try command.runWithTimeout(allocator, argv.items, 1024 * 1024, default_timeout_ms);
+}
+
+fn startEmulator(allocator: std.mem.Allocator, options: PreflightOptions, avd: []const u8) !void {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, options.emulator_path);
+    try argv.appendSlice(allocator, &.{ "-avd", avd });
+    if (options.restore_snapshot) |snapshot| {
+        try argv.appendSlice(allocator, &.{ "-snapshot", snapshot });
+    } else {
+        try argv.append(allocator, "-no-snapshot-load");
+    }
+    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();
+}
+
+fn waitReady(allocator: std.mem.Allocator, options: PreflightOptions) !void {
+    var wait_result = try runAdb(allocator, options, &.{"wait-for-device"});
+    defer wait_result.deinit(allocator);
+    try wait_result.ensureSuccess();
+
+    for (0..120) |_| {
+        var prop = try runAdb(allocator, options, &.{ "shell", "getprop", "sys.boot_completed" });
+        defer prop.deinit(allocator);
+        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);
+    }
+    return error.AndroidEmulatorBootTimedOut;
+}
+
+fn runAdb(allocator: std.mem.Allocator, options: PreflightOptions, extra: []const []const u8) !command.ExecResult {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, options.adb_path);
+    if (options.device_serial) |serial| {
+        try argv.appendSlice(allocator, &.{ "-s", serial });
+    }
+    try argv.appendSlice(allocator, extra);
+    try recordCommand(allocator, options.event_log_path, argv.items);
+    return try command.runWithTimeout(allocator, argv.items, 1024 * 1024, default_timeout_ms);
+}
+
+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 }),
+        else => return err,
+    };
+    defer file.close();
+    try file.seekFromEnd(0);
+    var line = std.ArrayList(u8).empty;
+    defer line.deinit(allocator);
+    for (argv, 0..) |arg, index| {
+        if (index > 0) try line.append(allocator, ' ');
+        try line.appendSlice(allocator, arg);
+    }
+    try line.append(allocator, '\n');
+    try file.writeAll(line.items);
+}

package/src/android_screen_recording.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+const command = @import("command.zig");
+const trace = @import("trace.zig");
+const types = @import("types.zig");
+
+const default_max_output = 32 * 1024 * 1024;
+const default_adb_timeout_ms = 15_000;
+
+pub fn start(
+    allocator: std.mem.Allocator,
+    adb_path: []const u8,
+    serial: ?[]const u8,
+    remote_path: []const u8,
+) !AndroidScreenRecording {
+    const cleanup = runAdbCommand(allocator, adb_path, serial, &.{ "shell", "rm", "-f", remote_path }, 4096) catch null;
+    if (cleanup) |result| result.deinit(allocator);
+
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try appendAdbBase(allocator, &argv, adb_path, serial);
+    try argv.appendSlice(allocator, &.{ "shell", "screenrecord", remote_path });
+
+    const owned_adb_path = try allocator.dupe(u8, adb_path);
+    errdefer allocator.free(owned_adb_path);
+    const owned_serial = try types.dupeOptional(allocator, serial);
+    errdefer if (owned_serial) |value| allocator.free(value);
+    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();
+
+    return .{
+        .allocator = allocator,
+        .adb_path = owned_adb_path,
+        .serial = owned_serial,
+        .remote_path = owned_remote_path,
+        .child = child,
+    };
+}
+
+pub const AndroidScreenRecording = struct {
+    allocator: std.mem.Allocator,
+    adb_path: []const u8,
+    serial: ?[]const u8,
+    remote_path: []const u8,
+    child: std.process.Child,
+    stopped: bool = false,
+
+    pub fn deinit(self: *AndroidScreenRecording) void {
+        self.stopProcess() catch {};
+        self.allocator.free(self.adb_path);
+        if (self.serial) |value| self.allocator.free(value);
+        self.allocator.free(self.remote_path);
+    }
+
+    pub fn stopAndPull(self: *AndroidScreenRecording, writer: *trace.TraceWriter, artifact_name: []const u8) ![]const u8 {
+        try self.stopProcess();
+        const artifact_path = try writer.artifactPath(artifact_name);
+        errdefer self.allocator.free(artifact_path);
+
+        const pull = try self.runAdb(&.{ "pull", self.remote_path, artifact_path }, default_max_output);
+        defer pull.deinit(self.allocator);
+        try pull.ensureSuccess();
+
+        const cleanup = self.runAdb(&.{ "shell", "rm", "-f", self.remote_path }, 4096) catch null;
+        if (cleanup) |result| result.deinit(self.allocator);
+
+        return artifact_path;
+    }
+
+    fn stopProcess(self: *AndroidScreenRecording) !void {
+        if (self.stopped) return;
+        std.posix.kill(self.child.id, std.posix.SIG.INT) catch {};
+        _ = try self.child.wait();
+        self.stopped = true;
+    }
+
+    fn runAdb(self: *AndroidScreenRecording, extra: []const []const u8, max_output_bytes: usize) !command.ExecResult {
+        return try runAdbCommand(self.allocator, self.adb_path, self.serial, extra, max_output_bytes);
+    }
+};
+
+fn runAdbCommand(
+    allocator: std.mem.Allocator,
+    adb_path: []const u8,
+    serial: ?[]const u8,
+    extra: []const []const u8,
+    max_output_bytes: usize,
+) !command.ExecResult {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try appendAdbBase(allocator, &argv, adb_path, serial);
+    try argv.appendSlice(allocator, extra);
+    return try command.runWithTimeout(allocator, argv.items, max_output_bytes, default_adb_timeout_ms);
+}
+
+fn appendAdbBase(
+    allocator: std.mem.Allocator,
+    argv: *std.ArrayList([]const u8),
+    adb_path: []const u8,
+    serial: ?[]const u8,
+) !void {
+    try argv.append(allocator, adb_path);
+    if (serial) |value| {
+        try argv.append(allocator, "-s");
+        try argv.append(allocator, value);
+    }
+}

package/src/android_shell.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+const command = @import("command.zig");
+
+pub const Args = struct {
+    allocator: std.mem.Allocator,
+    argv: std.ArrayList([]const u8) = .empty,
+    owned: std.ArrayList([]const u8) = .empty,
+
+    pub fn deinit(self: *Args) void {
+        for (self.owned.items) |value| self.allocator.free(value);
+        self.owned.deinit(self.allocator);
+        self.argv.deinit(self.allocator);
+    }
+
+    pub fn items(self: *const Args) []const []const u8 {
+        return self.argv.items;
+    }
+
+    fn appendLiteral(self: *Args, value: []const u8) !void {
+        try self.argv.append(self.allocator, value);
+    }
+
+    fn appendOwned(self: *Args, value: []const u8) !void {
+        try self.owned.append(self.allocator, value);
+        try self.argv.append(self.allocator, value);
+    }
+
+    fn appendFmt(self: *Args, comptime fmt: []const u8, values: anytype) !void {
+        const value = try std.fmt.allocPrint(self.allocator, fmt, values);
+        errdefer self.allocator.free(value);
+        try self.appendOwned(value);
+    }
+};
+
+fn initArgs(allocator: std.mem.Allocator) Args {
+    return .{ .allocator = allocator };
+}
+
+pub fn openLinkIntent(allocator: std.mem.Allocator, url: []const u8, app_id: []const u8) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+
+    const escaped_url = try command.escapeAdbShellArg(allocator, url);
+    errdefer allocator.free(escaped_url);
+
+    try args.appendLiteral("shell");
+    try args.appendLiteral("am");
+    try args.appendLiteral("start");
+    try args.appendLiteral("-a");
+    try args.appendLiteral("android.intent.action.VIEW");
+    try args.appendLiteral("-d");
+    try args.appendOwned(escaped_url);
+    try args.appendLiteral(app_id);
+    return args;
+}
+
+pub fn tap(allocator: std.mem.Allocator, x: i32, y: i32) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+    try args.appendLiteral("shell");
+    try args.appendLiteral("input");
+    try args.appendLiteral("tap");
+    try args.appendFmt("{d}", .{x});
+    try args.appendFmt("{d}", .{y});
+    return args;
+}
+
+pub fn typeText(allocator: std.mem.Allocator, text: []const u8) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+    const escaped = try command.escapeAdbInputText(allocator, text);
+    errdefer allocator.free(escaped);
+    try args.appendLiteral("shell");
+    try args.appendLiteral("input");
+    try args.appendLiteral("text");
+    try args.appendOwned(escaped);
+    return args;
+}
+
+pub fn eraseText(allocator: std.mem.Allocator, max_chars: u32) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+    try args.appendLiteral("shell");
+    try args.appendLiteral("sh");
+    try args.appendLiteral("-c");
+    try args.appendFmt("input keyevent KEYCODE_MOVE_END; i=0; while [ $i -lt {d} ]; do input keyevent KEYCODE_DEL; i=$((i+1)); done", .{max_chars});
+    return args;
+}
+
+pub fn pressBack(allocator: std.mem.Allocator) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+    try args.appendLiteral("shell");
+    try args.appendLiteral("input");
+    try args.appendLiteral("keyevent");
+    try args.appendLiteral("BACK");
+    return args;
+}
+
+pub fn swipe(allocator: std.mem.Allocator, x1: i32, y1: i32, x2: i32, y2: i32, duration_ms: u32) !Args {
+    var args = initArgs(allocator);
+    errdefer args.deinit();
+    try args.appendLiteral("shell");
+    try args.appendLiteral("input");
+    try args.appendLiteral("swipe");
+    try args.appendFmt("{d}", .{x1});
+    try args.appendFmt("{d}", .{y1});
+    try args.appendFmt("{d}", .{x2});
+    try args.appendFmt("{d}", .{y2});
+    try args.appendFmt("{d}", .{duration_ms});
+    return args;
+}

package/src/bundle.zig

@@ -0,0 +1,124 @@
+const std = @import("std");
+const bundle_redaction = @import("bundle_redaction.zig");
+const bundle_tar = @import("bundle_tar.zig");
+
+pub const ExportOptions = bundle_redaction.Options;
+
+pub fn exportTraceBundle(allocator: std.mem.Allocator, trace_dir: []const u8, out_path: []const u8) !void {
+    return exportTraceBundleWithOptions(allocator, trace_dir, out_path, .{});
+}
+
+pub fn exportTraceBundleWithOptions(
+    allocator: std.mem.Allocator,
+    trace_dir: []const u8,
+    out_path: []const u8,
+    options: ExportOptions,
+) !void {
+    try requireTraceFile(allocator, trace_dir, "trace.json", error.MissingTraceManifest);
+    try requireTraceFile(allocator, trace_dir, "events.jsonl", error.MissingTraceEvents);
+
+    var entries = std.ArrayList([]const u8).empty;
+    defer {
+        for (entries.items) |entry| allocator.free(entry);
+        entries.deinit(allocator);
+    }
+
+    try entries.append(allocator, try allocator.dupe(u8, "trace.json"));
+    try entries.append(allocator, try allocator.dupe(u8, "events.jsonl"));
+    if (traceFileExists(allocator, trace_dir, "report.html") catch |err| return err) {
+        try entries.append(allocator, try allocator.dupe(u8, "report.html"));
+    }
+
+    var artifact_entries = std.ArrayList([]const u8).empty;
+    defer {
+        for (artifact_entries.items) |entry| allocator.free(entry);
+        artifact_entries.deinit(allocator);
+    }
+    try collectArtifactEntries(allocator, trace_dir, "artifacts", &artifact_entries);
+    std.mem.sort([]const u8, artifact_entries.items, {}, stringLessThan);
+    for (artifact_entries.items) |entry| {
+        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();
+
+    for (entries.items) |archive_path| {
+        if (options.redact) {
+            if (options.omit_screenshots and bundle_redaction.isVisualArtifactPath(archive_path)) continue;
+            if (bundle_redaction.isPlaceholderScreenshotPath(archive_path)) {
+                try bundle_tar.writeBytes(archive_path, bundle_redaction.redacted_screenshot_png[0..], &out_file);
+                continue;
+            }
+            if (bundle_redaction.isVisualArtifactPath(archive_path)) continue;
+            const bytes = try readTraceFile(allocator, trace_dir, archive_path);
+            defer allocator.free(bytes);
+            const redacted = try bundle_redaction.redactEntry(allocator, archive_path, bytes, options);
+            defer allocator.free(redacted);
+            try bundle_tar.writeBytes(archive_path, redacted, &out_file);
+        } else {
+            try bundle_tar.writeFile(allocator, trace_dir, archive_path, &out_file);
+        }
+    }
+    try out_file.writeAll(&([_]u8{0} ** 1024));
+}
+
+fn requireTraceFile(
+    allocator: std.mem.Allocator,
+    trace_dir: []const u8,
+    archive_path: []const u8,
+    missing_error: anyerror,
+) !void {
+    if (!try traceFileExists(allocator, trace_dir, archive_path)) return missing_error;
+}
+
+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) {
+        error.FileNotFound => return false,
+        else => return err,
+    };
+    file.close();
+    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);
+}
+
+fn collectArtifactEntries(
+    allocator: std.mem.Allocator,
+    trace_dir: []const u8,
+    archive_dir: []const u8,
+    entries: *std.ArrayList([]const u8),
+) !void {
+    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) {
+        error.FileNotFound => return,
+        else => return err,
+    };
+    defer dir.close();
+
+    var iterator = dir.iterate();
+    while (try iterator.next()) |entry| {
+        const archive_path = try std.fmt.allocPrint(allocator, "{s}/{s}", .{ archive_dir, entry.name });
+        errdefer allocator.free(archive_path);
+        switch (entry.kind) {
+            .file => try entries.append(allocator, archive_path),
+            .directory => {
+                try collectArtifactEntries(allocator, trace_dir, archive_path, entries);
+                allocator.free(archive_path);
+            },
+            else => allocator.free(archive_path),
+        }
+    }
+}
+
+fn stringLessThan(_: void, left: []const u8, right: []const u8) bool {
+    return std.mem.lessThan(u8, left, right);
+}