zig-mobile-runner 0.1.0

package/src/cli_validate.zig

@@ -0,0 +1,41 @@
+const std = @import("std");
+
+const cli_output = @import("cli_output.zig");
+const validation = @import("validation.zig");
+
+pub const ParsedArgs = struct {
+    path: []const u8,
+    json: bool = false,
+};
+
+pub fn parseArgs(args: []const []const u8) !ParsedArgs {
+    if (args.len == 0) return error.MissingScenarioPath;
+
+    var parsed = ParsedArgs{ .path = args[0] };
+    for (args[1..]) |arg| {
+        if (std.mem.eql(u8, arg, "--json")) {
+            parsed.json = true;
+        } else {
+            return error.UnknownFlag;
+        }
+    }
+    return parsed;
+}
+
+pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !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 result = try validation.validateFile(allocator, parsed.path);
+    defer result.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try cli_output.writeValidationJson(stdout, parsed.path, result);
+    } else {
+        try cli_output.writeValidationText(stdout, parsed.path, result);
+    }
+    if (!result.ok) std.process.exit(1);
+}

package/src/command.zig

@@ -0,0 +1,211 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub const ExecResult = struct {
+    stdout: []u8,
+    stderr: []u8,
+    term: std.process.Child.Term,
+    timed_out: bool = false,
+
+    pub fn deinit(self: ExecResult, allocator: std.mem.Allocator) void {
+        allocator.free(self.stdout);
+        allocator.free(self.stderr);
+    }
+
+    pub fn ensureSuccess(self: ExecResult) !void {
+        if (self.timed_out) return error.CommandTimedOut;
+        switch (self.term) {
+            .Exited => |code| if (code == 0) return,
+            else => {},
+        }
+        return error.CommandFailed;
+    }
+};
+
+pub fn run(
+    allocator: std.mem.Allocator,
+    argv: []const []const u8,
+    max_output_bytes: usize,
+) !ExecResult {
+    const result = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = argv,
+        .max_output_bytes = max_output_bytes,
+    });
+    return .{
+        .stdout = result.stdout,
+        .stderr = result.stderr,
+        .term = result.term,
+        .timed_out = false,
+    };
+}
+
+pub fn runWithInput(
+    allocator: std.mem.Allocator,
+    argv: []const []const u8,
+    stdin: []const u8,
+    max_output_bytes: usize,
+) !ExecResult {
+    return try runWithInputTimeout(allocator, argv, stdin, max_output_bytes, 0);
+}
+
+pub fn runWithInputTimeout(
+    allocator: std.mem.Allocator,
+    argv: []const []const u8,
+    stdin: []const u8,
+    max_output_bytes: usize,
+    timeout_ms: u64,
+) !ExecResult {
+    var child = std.process.Child.init(argv, allocator);
+    child.stdin_behavior = .Pipe;
+    child.stdout_behavior = .Pipe;
+    child.stderr_behavior = .Pipe;
+
+    var stdout = std.ArrayList(u8).empty;
+    defer stdout.deinit(allocator);
+    var stderr = std.ArrayList(u8).empty;
+    defer stderr.deinit(allocator);
+
+    try child.spawn();
+    errdefer _ = child.kill() catch {};
+
+    var done = std.Thread.ResetEvent{};
+    var timed_out = std.atomic.Value(bool).init(false);
+    const use_timeout = timeout_ms > 0;
+    const killer = if (use_timeout)
+        try std.Thread.spawn(.{}, timeoutKiller, .{
+            child.id,
+            &done,
+            &timed_out,
+            std.math.mul(u64, timeout_ms, std.time.ns_per_ms) catch std.math.maxInt(u64),
+        })
+    else
+        null;
+
+    if (child.stdin) |stdin_file| {
+        try stdin_file.writeAll(stdin);
+        stdin_file.close();
+        child.stdin = null;
+    }
+
+    child.collectOutput(allocator, &stdout, &stderr, max_output_bytes) catch |err| {
+        _ = child.kill() catch {};
+        done.set();
+        if (killer) |thread| thread.join();
+        return err;
+    };
+
+    const term = child.wait() catch |err| {
+        done.set();
+        if (killer) |thread| thread.join();
+        return err;
+    };
+    done.set();
+    if (killer) |thread| thread.join();
+
+    return .{
+        .stdout = try stdout.toOwnedSlice(allocator),
+        .stderr = try stderr.toOwnedSlice(allocator),
+        .term = term,
+        .timed_out = timed_out.load(.acquire),
+    };
+}
+
+pub fn runWithTimeout(
+    allocator: std.mem.Allocator,
+    argv: []const []const u8,
+    max_output_bytes: usize,
+    timeout_ms: u64,
+) !ExecResult {
+    if (timeout_ms == 0) return run(allocator, argv, max_output_bytes);
+
+    var child = std.process.Child.init(argv, allocator);
+    child.stdin_behavior = .Ignore;
+    child.stdout_behavior = .Pipe;
+    child.stderr_behavior = .Pipe;
+
+    var stdout = std.ArrayList(u8).empty;
+    defer stdout.deinit(allocator);
+    var stderr = std.ArrayList(u8).empty;
+    defer stderr.deinit(allocator);
+
+    try child.spawn();
+    errdefer _ = child.kill() catch {};
+
+    var done = std.Thread.ResetEvent{};
+    var timed_out = std.atomic.Value(bool).init(false);
+    const timeout_ns = std.math.mul(u64, timeout_ms, std.time.ns_per_ms) catch std.math.maxInt(u64);
+    const killer = try std.Thread.spawn(.{}, timeoutKiller, .{ child.id, &done, &timed_out, timeout_ns });
+
+    child.collectOutput(allocator, &stdout, &stderr, max_output_bytes) catch |err| {
+        _ = child.kill() catch {};
+        done.set();
+        killer.join();
+        return err;
+    };
+
+    const term = child.wait() catch |err| {
+        done.set();
+        killer.join();
+        return err;
+    };
+    done.set();
+    killer.join();
+
+    return .{
+        .stdout = try stdout.toOwnedSlice(allocator),
+        .stderr = try stderr.toOwnedSlice(allocator),
+        .term = term,
+        .timed_out = timed_out.load(.acquire),
+    };
+}
+
+fn timeoutKiller(
+    child_id: std.process.Child.Id,
+    done: *std.Thread.ResetEvent,
+    timed_out: *std.atomic.Value(bool),
+    timeout_ns: u64,
+) void {
+    done.timedWait(timeout_ns) catch {
+        timed_out.store(true, .release);
+        killChildId(child_id);
+    };
+}
+
+fn killChildId(child_id: std.process.Child.Id) void {
+    switch (builtin.os.tag) {
+        .windows => {},
+        else => std.posix.kill(child_id, std.posix.SIG.TERM) catch {},
+    }
+}
+
+pub fn escapeAdbInputText(allocator: std.mem.Allocator, text: []const u8) ![]const u8 {
+    var out = std.ArrayList(u8).empty;
+    errdefer out.deinit(allocator);
+    for (text) |ch| {
+        switch (ch) {
+            ' ' => try out.appendSlice(allocator, "%s"),
+            '&', '<', '>', ';', '|', '*', '~', '"', '\'', '\\', '(', ')' => {
+                try out.append(allocator, '\\');
+                try out.append(allocator, ch);
+            },
+            else => try out.append(allocator, ch),
+        }
+    }
+    return try out.toOwnedSlice(allocator);
+}
+
+pub fn escapeAdbShellArg(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {
+    var out = std.ArrayList(u8).empty;
+    errdefer out.deinit(allocator);
+    try out.append(allocator, '\'');
+    for (value) |ch| {
+        if (ch == '\'') {
+            try out.appendSlice(allocator, "'\\''");
+        } else {
+            try out.append(allocator, ch);
+        }
+    }
+    try out.append(allocator, '\'');
+    return try out.toOwnedSlice(allocator);
+}

package/src/config.zig

@@ -0,0 +1,305 @@
+const std = @import("std");
+const config_diagnostics = @import("config_diagnostics.zig");
+
+pub const PlatformConfig = struct {
+    enabled: bool = false,
+    default_device: ?[]const u8 = null,
+    smoke_scenario: ?[]const u8 = null,
+    trace_dir: ?[]const u8 = null,
+    avd_name: ?[]const u8 = null,
+    restore_snapshot: ?[]const u8 = null,
+    avd_system_image: ?[]const u8 = null,
+    avd_device_profile: ?[]const u8 = null,
+    reset_before_run: bool = false,
+    wait_ready: bool = false,
+    create_avd_if_missing: bool = false,
+
+    pub fn deinit(self: *PlatformConfig, allocator: std.mem.Allocator) void {
+        if (self.default_device) |value| allocator.free(value);
+        if (self.smoke_scenario) |value| allocator.free(value);
+        if (self.trace_dir) |value| allocator.free(value);
+        if (self.avd_name) |value| allocator.free(value);
+        if (self.restore_snapshot) |value| allocator.free(value);
+        if (self.avd_system_image) |value| allocator.free(value);
+        if (self.avd_device_profile) |value| allocator.free(value);
+    }
+};
+
+pub const ToolsConfig = struct {
+    adb_path: ?[]const u8 = null,
+    emulator_path: ?[]const u8 = null,
+    avdmanager_path: ?[]const u8 = null,
+    android_shim_path: ?[]const u8 = null,
+    xcrun_path: ?[]const u8 = null,
+    ios_shim_path: ?[]const u8 = null,
+    zig_path: ?[]const u8 = null,
+
+    pub fn deinit(self: *ToolsConfig, allocator: std.mem.Allocator) void {
+        if (self.adb_path) |value| allocator.free(value);
+        if (self.emulator_path) |value| allocator.free(value);
+        if (self.avdmanager_path) |value| allocator.free(value);
+        if (self.android_shim_path) |value| allocator.free(value);
+        if (self.xcrun_path) |value| allocator.free(value);
+        if (self.ios_shim_path) |value| allocator.free(value);
+        if (self.zig_path) |value| allocator.free(value);
+    }
+};
+
+pub const ArtifactConfig = struct {
+    screenshots: bool = true,
+    hierarchy: bool = true,
+    logs: bool = true,
+    screen_recording: bool = false,
+};
+
+pub const RedactionConfig = struct {
+    denylist_text: []const []const u8 = &.{},
+    allowlist_text: []const []const u8 = &.{},
+    denylist_resource_ids: []const []const u8 = &.{},
+    allowlist_resource_ids: []const []const u8 = &.{},
+
+    pub fn deinit(self: *RedactionConfig, allocator: std.mem.Allocator) void {
+        freeStringList(allocator, self.denylist_text);
+        freeStringList(allocator, self.allowlist_text);
+        freeStringList(allocator, self.denylist_resource_ids);
+        freeStringList(allocator, self.allowlist_resource_ids);
+    }
+};
+
+pub const ScriptCommand = struct {
+    name: []const u8,
+    command: []const u8,
+};
+
+pub const Config = struct {
+    schema_version: u32,
+    app_id: ?[]const u8 = null,
+    android: PlatformConfig = .{},
+    ios: PlatformConfig = .{},
+    tools: ToolsConfig = .{},
+    artifacts: ArtifactConfig = .{},
+    redaction: RedactionConfig = .{},
+    scripts: []ScriptCommand = &.{},
+
+    pub fn deinit(self: *Config, allocator: std.mem.Allocator) void {
+        if (self.app_id) |value| allocator.free(value);
+        self.android.deinit(allocator);
+        self.ios.deinit(allocator);
+        self.tools.deinit(allocator);
+        self.redaction.deinit(allocator);
+        freeScripts(allocator, self.scripts);
+    }
+};
+
+pub fn parseFile(allocator: std.mem.Allocator, path: []const u8) !Config {
+    const content = try std.fs.cwd().readFileAlloc(allocator, path, 1024 * 1024);
+    defer allocator.free(content);
+    return try parseSlice(allocator, content);
+}
+
+pub fn errorFieldPathForFile(allocator: std.mem.Allocator, path: []const u8, err: anyerror) !?[]const u8 {
+    return try config_diagnostics.errorFieldPathForFile(allocator, path, err);
+}
+
+pub fn parseSlice(allocator: std.mem.Allocator, content: []const u8) !Config {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    if (parsed.value != .object) return error.ConfigMustBeObject;
+    const object = parsed.value.object;
+    try rejectUnknownFields(object, &.{ "schemaVersion", "appId", "android", "ios", "artifacts", "redaction", "tools", "scripts" });
+    const schema_version = try requiredU32(object, "schemaVersion");
+
+    var cfg = Config{
+        .schema_version = schema_version,
+        .app_id = try optionalString(allocator, object, "appId"),
+        .android = try platformConfig(allocator, object.get("android")),
+        .ios = try platformConfig(allocator, object.get("ios")),
+        .tools = try toolsConfig(allocator, object.get("tools")),
+        .artifacts = try artifactConfig(object.get("artifacts")),
+        .redaction = try redactionConfig(allocator, object.get("redaction")),
+        .scripts = try scriptsConfig(allocator, object.get("scripts")),
+    };
+    errdefer cfg.deinit(allocator);
+
+    if (cfg.schema_version != 1) return error.UnsupportedConfigVersion;
+    return cfg;
+}
+
+fn platformConfig(allocator: std.mem.Allocator, maybe_value: ?std.json.Value) !PlatformConfig {
+    const value = maybe_value orelse return .{};
+    if (value != .object) return error.ConfigPlatformMustBeObject;
+    const object = value.object;
+    try rejectUnknownFields(object, &.{
+        "enabled",
+        "defaultDevice",
+        "smokeScenario",
+        "traceDir",
+        "avdName",
+        "restoreSnapshot",
+        "createAvdIfMissing",
+        "avdSystemImage",
+        "avdDeviceProfile",
+        "resetBeforeRun",
+        "waitReady",
+    });
+    return .{
+        .enabled = try optionalBool(object, "enabled") orelse false,
+        .default_device = try optionalString(allocator, object, "defaultDevice"),
+        .smoke_scenario = try optionalString(allocator, object, "smokeScenario"),
+        .trace_dir = try optionalString(allocator, object, "traceDir"),
+        .avd_name = try optionalString(allocator, object, "avdName"),
+        .restore_snapshot = try optionalString(allocator, object, "restoreSnapshot"),
+        .avd_system_image = try optionalString(allocator, object, "avdSystemImage"),
+        .avd_device_profile = try optionalString(allocator, object, "avdDeviceProfile"),
+        .reset_before_run = try optionalBool(object, "resetBeforeRun") orelse false,
+        .wait_ready = try optionalBool(object, "waitReady") orelse false,
+        .create_avd_if_missing = try optionalBool(object, "createAvdIfMissing") orelse false,
+    };
+}
+
+pub fn errorFieldPathForSlice(allocator: std.mem.Allocator, content: []const u8, err: anyerror) !?[]const u8 {
+    return try config_diagnostics.errorFieldPathForSlice(allocator, content, err);
+}
+
+fn toolsConfig(allocator: std.mem.Allocator, maybe_value: ?std.json.Value) !ToolsConfig {
+    const value = maybe_value orelse return .{};
+    if (value != .object) return error.ConfigToolsMustBeObject;
+    const object = value.object;
+    try rejectUnknownFields(object, &.{ "adbPath", "emulatorPath", "avdmanagerPath", "androidShimPath", "xcrunPath", "iosShimPath", "zigPath" });
+    return .{
+        .adb_path = try optionalString(allocator, object, "adbPath"),
+        .emulator_path = try optionalString(allocator, object, "emulatorPath"),
+        .avdmanager_path = try optionalString(allocator, object, "avdmanagerPath"),
+        .android_shim_path = try optionalString(allocator, object, "androidShimPath"),
+        .xcrun_path = try optionalString(allocator, object, "xcrunPath"),
+        .ios_shim_path = try optionalString(allocator, object, "iosShimPath"),
+        .zig_path = try optionalString(allocator, object, "zigPath"),
+    };
+}
+
+fn artifactConfig(maybe_value: ?std.json.Value) !ArtifactConfig {
+    const value = maybe_value orelse return .{};
+    if (value != .object) return error.ConfigArtifactsMustBeObject;
+    const object = value.object;
+    try rejectUnknownFields(object, &.{ "screenshots", "hierarchy", "logs", "screenRecording" });
+    return .{
+        .screenshots = try optionalBool(object, "screenshots") orelse true,
+        .hierarchy = try optionalBool(object, "hierarchy") orelse true,
+        .logs = try optionalBool(object, "logs") orelse true,
+        .screen_recording = try optionalBool(object, "screenRecording") orelse false,
+    };
+}
+
+fn redactionConfig(allocator: std.mem.Allocator, maybe_value: ?std.json.Value) !RedactionConfig {
+    const value = maybe_value orelse return .{};
+    if (value != .object) return error.ConfigRedactionMustBeObject;
+    const object = value.object;
+    try rejectUnknownFields(object, &.{ "denylistText", "allowlistText", "denylistResourceIds", "allowlistResourceIds" });
+    var parsed = RedactionConfig{};
+    errdefer parsed.deinit(allocator);
+    parsed.denylist_text = try optionalStringList(allocator, object, "denylistText");
+    parsed.allowlist_text = try optionalStringList(allocator, object, "allowlistText");
+    parsed.denylist_resource_ids = try optionalStringList(allocator, object, "denylistResourceIds");
+    parsed.allowlist_resource_ids = try optionalStringList(allocator, object, "allowlistResourceIds");
+    return parsed;
+}
+
+fn rejectUnknownFields(object: std.json.ObjectMap, allowed: []const []const u8) !void {
+    var iterator = object.iterator();
+    while (iterator.next()) |entry| {
+        var found = false;
+        for (allowed) |key| {
+            if (std.mem.eql(u8, entry.key_ptr.*, key)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) return error.ConfigUnknownField;
+    }
+}
+
+fn scriptsConfig(allocator: std.mem.Allocator, maybe_value: ?std.json.Value) ![]ScriptCommand {
+    const value = maybe_value orelse return &.{};
+    if (value != .object) return error.ConfigScriptsMustBeObject;
+    if (value.object.count() == 0) return &.{};
+
+    var scripts = try allocator.alloc(ScriptCommand, value.object.count());
+    errdefer allocator.free(scripts);
+
+    var written: usize = 0;
+    errdefer {
+        for (scripts[0..written]) |script| {
+            allocator.free(script.name);
+            allocator.free(script.command);
+        }
+    }
+
+    var iterator = value.object.iterator();
+    while (iterator.next()) |entry| {
+        if (entry.value_ptr.* != .string) return error.ConfigFieldMustBeString;
+        if (entry.value_ptr.string.len == 0) return error.ConfigFieldMustBeNonEmptyString;
+        scripts[written] = .{
+            .name = try allocator.dupe(u8, entry.key_ptr.*),
+            .command = try allocator.dupe(u8, entry.value_ptr.string),
+        };
+        written += 1;
+    }
+    return scripts;
+}
+
+fn requiredU32(object: std.json.ObjectMap, key: []const u8) !u32 {
+    const value = object.get(key) orelse return error.MissingConfigSchemaVersion;
+    if (value != .integer) return error.ConfigSchemaVersionMustBeInteger;
+    if (value.integer < 0 or value.integer > std.math.maxInt(u32)) return error.ConfigSchemaVersionMustBeInteger;
+    return @intCast(value.integer);
+}
+
+fn optionalString(allocator: std.mem.Allocator, object: std.json.ObjectMap, key: []const u8) !?[]const u8 {
+    const value = object.get(key) orelse return null;
+    if (value == .null) return null;
+    if (value != .string) return error.ConfigFieldMustBeString;
+    if (value.string.len == 0) return error.ConfigFieldMustBeNonEmptyString;
+    return try allocator.dupe(u8, value.string);
+}
+
+fn optionalBool(object: std.json.ObjectMap, key: []const u8) !?bool {
+    const value = object.get(key) orelse return null;
+    if (value != .bool) return error.ConfigFieldMustBeBool;
+    return value.bool;
+}
+
+fn optionalStringList(allocator: std.mem.Allocator, object: std.json.ObjectMap, key: []const u8) ![]const []const u8 {
+    const value = object.get(key) orelse return &.{};
+    if (value != .array) return error.ConfigFieldMustBeStringArray;
+    if (value.array.items.len == 0) return &.{};
+
+    var output = try allocator.alloc([]const u8, value.array.items.len);
+    errdefer allocator.free(output);
+    var written: usize = 0;
+    errdefer {
+        for (output[0..written]) |item| allocator.free(item);
+    }
+
+    for (value.array.items, 0..) |item, index| {
+        if (item != .string) return error.ConfigFieldMustBeStringArray;
+        if (item.string.len == 0) return error.ConfigFieldMustBeNonEmptyString;
+        output[index] = try allocator.dupe(u8, item.string);
+        written += 1;
+    }
+    return output;
+}
+
+fn freeStringList(allocator: std.mem.Allocator, list: []const []const u8) void {
+    if (list.len == 0) return;
+    for (list) |item| allocator.free(item);
+    allocator.free(list);
+}
+
+fn freeScripts(allocator: std.mem.Allocator, scripts: []ScriptCommand) void {
+    if (scripts.len == 0) return;
+    for (scripts) |script| {
+        allocator.free(script.name);
+        allocator.free(script.command);
+    }
+    allocator.free(scripts);
+}