zig-mobile-runner 0.1.0

package/src/bundle_redaction.zig

@@ -0,0 +1,272 @@
+const std = @import("std");
+
+pub const Options = struct {
+    redact: bool = false,
+    omit_screenshots: bool = false,
+};
+
+pub fn redactEntry(allocator: std.mem.Allocator, archive_path: []const u8, bytes: []const u8, options: Options) ![]u8 {
+    if (std.mem.eql(u8, archive_path, "trace.json")) {
+        return try redactTraceManifest(allocator, bytes, options);
+    }
+    if (std.mem.endsWith(u8, archive_path, ".json") or std.mem.eql(u8, archive_path, "events.jsonl")) {
+        return redactJsonishText(allocator, bytes);
+    }
+    if (isTextPath(archive_path)) {
+        return redactFreeText(allocator, bytes);
+    }
+    return try allocator.dupe(u8, bytes);
+}
+
+fn redactTraceManifest(allocator: std.mem.Allocator, bytes: []const u8, options: Options) ![]u8 {
+    var parsed = try std.json.parseFromSlice(std.json.Value, allocator, bytes, .{});
+    defer parsed.deinit();
+    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 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);
+}
+
+fn redactJsonishText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
+    const parsed = std.json.parseFromSlice(std.json.Value, allocator, bytes, .{}) catch {
+        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);
+}
+
+fn writeJsonValueRedacted(writer: anytype, value: std.json.Value, key_context: ?[]const u8) !void {
+    switch (value) {
+        .null => try writer.writeAll("null"),
+        .bool => |actual| try writer.writeAll(if (actual) "true" else "false"),
+        .integer => |actual| try writer.print("{d}", .{actual}),
+        .float => |actual| try writer.print("{d}", .{actual}),
+        .number_string => |actual| try writer.writeAll(actual),
+        .string => |actual| try writeRedactedJsonStringForKey(writer, key_context orelse "", actual),
+        .array => |array| {
+            try writer.writeAll("[");
+            for (array.items, 0..) |item, index| {
+                if (index > 0) try writer.writeAll(",");
+                try writeJsonValueRedacted(writer, item, key_context);
+            }
+            try writer.writeAll("]");
+        },
+        .object => |object| {
+            try writer.writeAll("{");
+            var first = true;
+            var iterator = object.iterator();
+            while (iterator.next()) |entry| {
+                if (!first) try writer.writeAll(",");
+                first = false;
+                try writeJsonString(writer, entry.key_ptr.*);
+                try writer.writeAll(":");
+                try writeJsonValueRedacted(writer, entry.value_ptr.*, entry.key_ptr.*);
+            }
+            try writer.writeAll("}");
+        },
+    }
+}
+
+fn writeRedactedJsonStringForKey(writer: anytype, key: []const u8, value: []const u8) !void {
+    if (isSensitiveLabel(key)) {
+        try writeJsonString(writer, "[REDACTED:secret]");
+    } else if (looksLikeBearerOrToken(value)) {
+        try writeJsonString(writer, "[REDACTED:token]");
+    } else if (looksLikeEmail(value)) {
+        try writeJsonString(writer, "[REDACTED:email]");
+    } else {
+        try writeJsonString(writer, value);
+    }
+}
+
+fn redactFreeText(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
+    var out = std.ArrayList(u8).empty;
+    errdefer out.deinit(allocator);
+    var sensitive_tag = false;
+    var index: usize = 0;
+    while (index < bytes.len) {
+        if (bytes[index] == '<') {
+            sensitive_tag = tagLooksSensitive(bytes[index..@min(bytes.len, index + 240)]);
+        } else if (bytes[index] == '>') {
+            sensitive_tag = false;
+        }
+
+        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]");
+            index += prefix_len;
+            while (index < bytes.len and bytes[index] != '"') : (index += 1) {}
+            if (index < bytes.len) {
+                try out.writer(allocator).writeByte('"');
+                index += 1;
+            }
+            continue;
+        }
+
+        if (emailEnd(bytes, index)) |end| {
+            try out.writer(allocator).writeAll("[REDACTED:email]");
+            index = end;
+            continue;
+        }
+        if (bearerEnd(bytes, index)) |end| {
+            try out.writer(allocator).writeAll("[REDACTED:token]");
+            index = end;
+            continue;
+        }
+        try out.writer(allocator).writeByte(bytes[index]);
+        index += 1;
+    }
+    return try out.toOwnedSlice(allocator);
+}
+
+fn emailEnd(bytes: []const u8, start: usize) ?usize {
+    if (start > 0 and !isDelimiter(bytes[start - 1])) return null;
+    var end = start;
+    while (end < bytes.len and !isDelimiter(bytes[end])) : (end += 1) {}
+    const value = bytes[start..end];
+    return if (looksLikeEmail(value)) end else null;
+}
+
+fn bearerEnd(bytes: []const u8, start: usize) ?usize {
+    if (!startsWithIgnoreCase(bytes[start..], "bearer ")) return null;
+    var end = start;
+    while (end < bytes.len and bytes[end] != '"' and bytes[end] != '\'' and bytes[end] != '<' and bytes[end] != '>') : (end += 1) {}
+    return end;
+}
+
+fn tagLooksSensitive(bytes: []const u8) bool {
+    const end = std.mem.indexOfScalar(u8, bytes, '>') orelse bytes.len;
+    return isSensitiveLabel(bytes[0..end]);
+}
+
+fn isScreenshotPath(path: []const u8) bool {
+    return std.mem.endsWith(u8, path, ".png") or std.mem.endsWith(u8, path, ".jpg") or std.mem.endsWith(u8, path, ".jpeg");
+}
+
+pub fn isPlaceholderScreenshotPath(path: []const u8) bool {
+    return std.mem.endsWith(u8, path, ".png");
+}
+
+pub fn isVisualArtifactPath(path: []const u8) bool {
+    return isScreenshotPath(path) or std.mem.endsWith(u8, path, ".mp4") or std.mem.endsWith(u8, path, ".webm");
+}
+
+pub const redacted_screenshot_png = [_]u8{
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+    0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4,
+    0x89, 0x00, 0x00, 0x00, 0x0a, 0x49, 0x44, 0x41,
+    0x54, 0x78, 0x9c, 0x63, 0x00, 0x01, 0x00, 0x00,
+    0x05, 0x00, 0x01, 0x0d, 0x0a, 0x2d, 0xb4, 0x00,
+    0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
+    0x42, 0x60, 0x82,
+};
+
+fn isTextPath(path: []const u8) bool {
+    return std.mem.endsWith(u8, path, ".xml") or std.mem.endsWith(u8, path, ".html") or std.mem.endsWith(u8, path, ".txt") or std.mem.endsWith(u8, path, ".log");
+}
+
+fn writeJsonString(writer: anytype, value: []const u8) !void {
+    try writer.writeAll("\"");
+    for (value) |ch| {
+        switch (ch) {
+            '"' => try writer.writeAll("\\\""),
+            '\\' => try writer.writeAll("\\\\"),
+            '\n' => try writer.writeAll("\\n"),
+            '\r' => try writer.writeAll("\\r"),
+            '\t' => try writer.writeAll("\\t"),
+            0...7, 11, 12, 14...31 => try writer.print("\\u{x:0>4}", .{ch}),
+            else => try writer.writeByte(ch),
+        }
+    }
+    try writer.writeAll("\"");
+}
+
+fn isSensitiveLabel(value: []const u8) bool {
+    const needles = [_][]const u8{
+        "password",
+        "token",
+        "secret",
+        "authorization",
+        "auth",
+        "cookie",
+        "apikey",
+        "api_key",
+        "bearer",
+    };
+    for (needles) |needle| {
+        if (indexOfIgnoreCase(value, needle) != null) return true;
+    }
+    return false;
+}
+
+fn looksLikeEmail(value: []const u8) bool {
+    if (value.len < 5 or value.len > 254) return false;
+    if (std.mem.indexOfAny(u8, value, " \t\r\n<>\"'") != null) return false;
+    const at = std.mem.indexOfScalar(u8, value, '@') orelse return false;
+    if (at == 0 or at + 3 >= value.len) return false;
+    return std.mem.indexOfScalar(u8, value[at + 1 ..], '.') != null;
+}
+
+fn looksLikeBearerOrToken(value: []const u8) bool {
+    if (indexOfIgnoreCase(value, "bearer ") != null) return true;
+    if (value.len < 40) return false;
+    const first_dot = std.mem.indexOfScalar(u8, value, '.') orelse return false;
+    const second_dot = std.mem.indexOfScalarPos(u8, value, first_dot + 1, '.') orelse return false;
+    return second_dot + 1 < value.len;
+}
+
+fn indexOfIgnoreCase(haystack: []const u8, needle: []const u8) ?usize {
+    if (needle.len == 0 or needle.len > haystack.len) return null;
+    var index: usize = 0;
+    while (index + needle.len <= haystack.len) : (index += 1) {
+        var matched = true;
+        for (needle, 0..) |needle_ch, offset| {
+            if (std.ascii.toLower(haystack[index + offset]) != std.ascii.toLower(needle_ch)) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) return index;
+    }
+    return null;
+}
+
+fn startsWithAt(bytes: []const u8, index: usize, needle: []const u8) bool {
+    return index + needle.len <= bytes.len and std.mem.eql(u8, bytes[index .. index + needle.len], needle);
+}
+
+fn startsWithIgnoreCase(haystack: []const u8, needle: []const u8) bool {
+    if (needle.len > haystack.len) return false;
+    for (needle, 0..) |needle_ch, index| {
+        if (std.ascii.toLower(haystack[index]) != std.ascii.toLower(needle_ch)) return false;
+    }
+    return true;
+}
+
+fn isDelimiter(ch: u8) bool {
+    return switch (ch) {
+        ' ', '\t', '\r', '\n', '<', '>', '"', '\'', '=', ',', ';', ')' => true,
+        else => false,
+    };
+}

package/src/bundle_tar.zig

@@ -0,0 +1,123 @@
+const std = @import("std");
+
+pub fn writeFile(
+    allocator: std.mem.Allocator,
+    trace_dir: []const u8,
+    archive_path: []const u8,
+    out_file: *std.fs.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 header = [_]u8{0} ** 512;
+    try writeHeader(&header, archive_path, stat.size);
+
+    try out_file.writeAll(&header);
+    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]);
+        if (n == 0) return error.UnexpectedEndOfStream;
+        try out_file.writeAll(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 {
+    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 writePadding(out_file, bytes.len);
+}
+
+fn writeHeader(header: *[512]u8, archive_path: []const u8, size: u64) !void {
+    try writeTarName(header, archive_path);
+    writeOctal(header[100..108], 0o644);
+    writeOctal(header[108..116], 0);
+    writeOctal(header[116..124], 0);
+    writeOctal(header[124..136], size);
+    writeOctal(header[136..148], 0);
+    @memset(header[148..156], ' ');
+    header[156] = '0';
+    @memcpy(header[257..263], "ustar\x00");
+    @memcpy(header[263..265], "00");
+    writeOctal(header[329..337], 0);
+    writeOctal(header[337..345], 0);
+    const checksum = tarChecksum(header);
+    writeChecksum(header[148..156], checksum);
+}
+
+fn writePadding(out_file: *std.fs.File, size: u64) !void {
+    const padding = (512 - (size % 512)) % 512;
+    if (padding > 0) try out_file.writeAll((&([_]u8{0} ** 512))[0..padding]);
+}
+
+fn isUnsafeArchivePath(archive_path: []const u8) bool {
+    return std.mem.startsWith(u8, archive_path, "/") or std.mem.indexOf(u8, archive_path, "..") != null;
+}
+
+fn writeTarName(header: *[512]u8, archive_path: []const u8) !void {
+    if (archive_path.len <= 100) {
+        @memcpy(header[0..archive_path.len], archive_path);
+        return;
+    }
+
+    var split_index: ?usize = null;
+    var index: usize = archive_path.len;
+    while (index > 0) {
+        index -= 1;
+        if (archive_path[index] != '/') continue;
+        const prefix = archive_path[0..index];
+        const name = archive_path[index + 1 ..];
+        if (prefix.len <= 155 and name.len <= 100) {
+            split_index = index;
+            break;
+        }
+    }
+    const actual_split = split_index orelse return error.ArchivePathTooLong;
+    const prefix = archive_path[0..actual_split];
+    const name = archive_path[actual_split + 1 ..];
+    @memcpy(header[0..name.len], name);
+    @memcpy(header[345 .. 345 + prefix.len], prefix);
+}
+
+fn writeOctal(field: []u8, value: u64) void {
+    @memset(field, 0);
+    const digits_len = field.len - 1;
+    var remaining = value;
+    var index = digits_len;
+    while (index > 0) {
+        index -= 1;
+        field[index] = @as(u8, @intCast('0' + (remaining & 7)));
+        remaining >>= 3;
+    }
+}
+
+fn writeChecksum(field: []u8, value: u64) void {
+    @memset(field, 0);
+    var remaining = value;
+    var index: usize = 6;
+    while (index > 0) {
+        index -= 1;
+        field[index] = @as(u8, @intCast('0' + (remaining & 7)));
+        remaining >>= 3;
+    }
+    field[6] = 0;
+    field[7] = ' ';
+}
+
+fn tarChecksum(header: *const [512]u8) u64 {
+    var sum: u64 = 0;
+    for (header) |byte| sum += byte;
+    return sum;
+}

package/src/cli_devices.zig

@@ -0,0 +1,97 @@
+const std = @import("std");
+const android = @import("android.zig");
+const device_registry = @import("device_registry.zig");
+const ios = @import("ios.zig");
+const run_options = @import("run_options.zig");
+const types = @import("types.zig");
+
+pub const IosDevicesScope = enum {
+    simulator,
+    physical,
+    all,
+};
+
+pub fn run(allocator: std.mem.Allocator, args: *std.process.ArgIterator) !void {
+    var platform: run_options.Platform = .android;
+    var ios_devices_scope: IosDevicesScope = .simulator;
+    var adb_path: []const u8 = "adb";
+    var xcrun_path: []const u8 = "xcrun";
+    var json = false;
+
+    while (args.next()) |arg| {
+        if (std.mem.eql(u8, arg, "--platform")) {
+            platform = try parsePlatform(args.next() orelse return error.MissingPlatform);
+        } else if (std.mem.eql(u8, arg, "--ios-device-type")) {
+            ios_devices_scope = try parseIosDevicesScope(args.next() orelse return error.MissingIosDeviceType);
+        } else if (std.mem.eql(u8, arg, "--adb")) {
+            adb_path = args.next() orelse return error.MissingAdbPath;
+        } else if (std.mem.eql(u8, arg, "--xcrun")) {
+            xcrun_path = args.next() orelse return error.MissingXcrunPath;
+        } else if (std.mem.eql(u8, arg, "--json")) {
+            json = true;
+        } else {
+            return error.UnknownFlag;
+        }
+    }
+
+    const devices = switch (platform) {
+        .android => try android.listDevices(allocator, adb_path),
+        .ios => try listIosDevicesForScope(allocator, xcrun_path, ios_devices_scope),
+    };
+    defer {
+        for (devices) |device| device.deinit(allocator);
+        allocator.free(devices);
+    }
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    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| {
+        try stdout.print("{s}\t{s}\n", .{ device.serial, device.state });
+    }
+}
+
+fn parsePlatform(value: []const u8) !run_options.Platform {
+    if (std.mem.eql(u8, value, "android")) return .android;
+    if (std.mem.eql(u8, value, "ios")) return .ios;
+    return error.UnsupportedPlatform;
+}
+
+pub fn parseIosDevicesScope(value: []const u8) !IosDevicesScope {
+    if (std.mem.eql(u8, value, "simulator")) return .simulator;
+    if (std.mem.eql(u8, value, "physical")) return .physical;
+    if (std.mem.eql(u8, value, "all")) return .all;
+    return error.UnsupportedIosDeviceType;
+}
+
+fn listIosDevicesForScope(allocator: std.mem.Allocator, xcrun_path: []const u8, scope: IosDevicesScope) ![]types.DeviceInfo {
+    return switch (scope) {
+        .simulator => try ios.listDevices(allocator, xcrun_path),
+        .physical => try ios.listPhysicalDevices(allocator, xcrun_path),
+        .all => blk: {
+            const simulators = try ios.listDevices(allocator, xcrun_path);
+            errdefer {
+                for (simulators) |device| device.deinit(allocator);
+                allocator.free(simulators);
+            }
+            const physical = try ios.listPhysicalDevices(allocator, xcrun_path);
+            errdefer {
+                for (physical) |device| device.deinit(allocator);
+                allocator.free(physical);
+            }
+            const combined = try allocator.alloc(types.DeviceInfo, simulators.len + physical.len);
+            @memcpy(combined[0..simulators.len], simulators);
+            @memcpy(combined[simulators.len..], physical);
+            allocator.free(simulators);
+            allocator.free(physical);
+            break :blk combined;
+        },
+    };
+}
+
+pub fn registryPlatform(platform: run_options.Platform) device_registry.Platform {
+    return switch (platform) {
+        .android => .android,
+        .ios => .ios,
+    };
+}

package/src/cli_doctor.zig

@@ -0,0 +1,114 @@
+const std = @import("std");
+
+const cli_output = @import("cli_output.zig");
+const config = @import("config.zig");
+const config_paths = @import("config_paths.zig");
+const doctor = @import("doctor.zig");
+
+pub const ParsedArgs = struct {
+    options: doctor.Options = .{},
+    json: bool = false,
+    strict: bool = false,
+    config_path: ?[]const u8 = null,
+    explicit_config: bool = false,
+};
+
+pub fn parseArgs(args: []const []const u8) !ParsedArgs {
+    var parsed = ParsedArgs{};
+    var index: usize = 0;
+    while (index < args.len) : (index += 1) {
+        const arg = args[index];
+        if (std.mem.eql(u8, arg, "--adb")) {
+            index += 1;
+            parsed.options.adb_path = if (index < args.len) args[index] else return error.MissingAdbPath;
+        } else if (std.mem.eql(u8, arg, "--android-shim")) {
+            index += 1;
+            parsed.options.android_shim_path = if (index < args.len) args[index] else return error.MissingAndroidShimPath;
+        } else if (std.mem.eql(u8, arg, "--xcrun")) {
+            index += 1;
+            parsed.options.xcrun_path = if (index < args.len) args[index] else return error.MissingXcrunPath;
+        } else if (std.mem.eql(u8, arg, "--ios-shim")) {
+            index += 1;
+            parsed.options.ios_shim_path = if (index < args.len) args[index] else return error.MissingIosShimPath;
+        } else if (std.mem.eql(u8, arg, "--zig")) {
+            index += 1;
+            parsed.options.zig_path = if (index < args.len) args[index] else return error.MissingZigPath;
+        } else if (std.mem.eql(u8, arg, "--json")) {
+            parsed.json = true;
+        } else if (std.mem.eql(u8, arg, "--strict")) {
+            parsed.strict = true;
+        } else if (std.mem.eql(u8, arg, "--config")) {
+            index += 1;
+            parsed.config_path = if (index < args.len) args[index] else return error.MissingConfigPath;
+            parsed.explicit_config = 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);
+    try runParsed(allocator, parsed);
+}
+
+fn runParsed(allocator: std.mem.Allocator, parsed: ParsedArgs) !void {
+    var options = parsed.options;
+    const actual_config_path = parsed.config_path orelse config_paths.default_path;
+    var config_check: ?doctor.Check = null;
+    defer if (config_check) |check| check.deinit(allocator);
+    var owned_option_paths = std.ArrayList([]const u8).empty;
+    defer {
+        for (owned_option_paths.items) |path| allocator.free(path);
+        owned_option_paths.deinit(allocator);
+    }
+
+    var loaded_config = config_paths.loadIfPresent(allocator, parsed.config_path) catch |err| blk: {
+        const field_path = try config.errorFieldPathForFile(allocator, actual_config_path, err);
+        defer if (field_path) |value| allocator.free(value);
+        config_check = try doctor.checkConfigError(allocator, actual_config_path, err, field_path);
+        break :blk null;
+    };
+    defer if (loaded_config) |*cfg| cfg.deinit(allocator);
+    if (loaded_config) |cfg| {
+        const config_root = try config_paths.rootForPath(allocator, actual_config_path);
+        defer allocator.free(config_root);
+        if (parsed.explicit_config) config_check = try doctor.checkConfigLoaded(allocator, actual_config_path, cfg.scripts);
+        if (std.mem.eql(u8, options.adb_path, "adb")) {
+            if (cfg.tools.adb_path) |path| options.adb_path = try config_paths.ownCommandPath(allocator, &owned_option_paths, config_root, path);
+        }
+        if (options.android_shim_path == null) {
+            if (cfg.tools.android_shim_path) |path| options.android_shim_path = try config_paths.ownFilePath(allocator, &owned_option_paths, config_root, path);
+        }
+        if (cfg.android.smoke_scenario) |path| options.android_smoke_scenario = try config_paths.ownFilePath(allocator, &owned_option_paths, config_root, path);
+        if (std.mem.eql(u8, options.xcrun_path, "xcrun")) {
+            if (cfg.tools.xcrun_path) |path| options.xcrun_path = try config_paths.ownCommandPath(allocator, &owned_option_paths, config_root, path);
+        }
+        if (options.ios_shim_path == null) {
+            if (cfg.tools.ios_shim_path) |path| options.ios_shim_path = try config_paths.ownFilePath(allocator, &owned_option_paths, config_root, path);
+        }
+        if (cfg.ios.smoke_scenario) |path| options.ios_smoke_scenario = try config_paths.ownFilePath(allocator, &owned_option_paths, config_root, path);
+        if (std.mem.eql(u8, options.zig_path, "zig")) {
+            if (cfg.tools.zig_path) |path| options.zig_path = try config_paths.ownCommandPath(allocator, &owned_option_paths, config_root, path);
+        }
+    }
+
+    const checks = try doctor.run(allocator, options);
+    defer {
+        for (checks) |check| check.deinit(allocator);
+        allocator.free(checks);
+    }
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try cli_output.writeDoctorJson(stdout, config_check, checks);
+    } else {
+        try cli_output.writeDoctorText(stdout, config_check, checks);
+    }
+    if (parsed.strict and !cli_output.doctorChecksHealthy(config_check, checks)) std.process.exit(1);
+}

package/src/cli_import.zig

@@ -0,0 +1,70 @@
+const std = @import("std");
+
+const cli_output = @import("cli_output.zig");
+const importer = @import("importer.zig");
+
+pub const ParsedArgs = struct {
+    format: []const u8,
+    source_path: []const u8,
+    out_path: ?[]const u8 = null,
+    name: ?[]const u8 = null,
+    app_id: ?[]const u8 = null,
+    force: bool = false,
+    json: bool = false,
+};
+
+pub fn parseArgs(args: []const []const u8) !ParsedArgs {
+    if (args.len == 0) return error.MissingImportFormat;
+    if (args.len == 1) return error.MissingImportPath;
+
+    var parsed = ParsedArgs{
+        .format = args[0],
+        .source_path = args[1],
+    };
+
+    var index: usize = 2;
+    while (index < args.len) : (index += 1) {
+        const arg = args[index];
+        if (std.mem.eql(u8, arg, "--out")) {
+            index += 1;
+            parsed.out_path = if (index < args.len) args[index] else return error.MissingImportOut;
+        } else if (std.mem.eql(u8, arg, "--name")) {
+            index += 1;
+            parsed.name = if (index < args.len) args[index] else return error.MissingImportName;
+        } else if (std.mem.eql(u8, arg, "--app-id")) {
+            index += 1;
+            parsed.app_id = if (index < args.len) args[index] else return error.MissingAppId;
+        } else if (std.mem.eql(u8, arg, "--force")) {
+            parsed.force = true;
+        } else if (std.mem.eql(u8, arg, "--json")) {
+            parsed.json = true;
+        } else {
+            return error.UnknownFlag;
+        }
+    }
+    if (parsed.out_path == null) return error.MissingImportOut;
+    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);
+    if (!std.mem.eql(u8, parsed.format, "flow-yaml")) return error.UnsupportedImportFormat;
+
+    const result = try importer.importFlowYamlFile(allocator, parsed.source_path, parsed.out_path.?, .{
+        .name = parsed.name,
+        .app_id = parsed.app_id,
+        .force = parsed.force,
+    });
+    defer result.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    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 ");
+    try cli_output.writeShellArg(stdout, result.out_path);
+    try stdout.writeAll("\n");
+}