zig-mobile-runner 0.1.0

package/src/ios.zig

@@ -0,0 +1,399 @@
+const std = @import("std");
+const command = @import("command.zig");
+const ios_devices = @import("ios_devices.zig");
+const ios_lifecycle = @import("ios_lifecycle.zig");
+const ios_snapshot = @import("ios_snapshot.zig");
+const ios_shim = @import("ios_shim.zig");
+const selector = @import("selector.zig");
+const trace = @import("trace.zig");
+const types = @import("types.zig");
+
+const default_max_output = 32 * 1024 * 1024;
+const shim_timeout_ms = 600_000;
+const shim_best_effort_timeout_ms = 10_000;
+const shim_command_attempts = 2;
+const shim_bootstrap_retry_delay_ms = 500;
+
+pub const TargetKind = enum {
+    simulator,
+    physical,
+};
+
+pub const IosDevice = struct {
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8 = "xcrun",
+    udid: ?[]const u8 = null,
+    app_id: []const u8,
+    shim_path: ?[]const u8 = null,
+    target_kind: TargetKind = .simulator,
+
+    pub fn init(
+        allocator: std.mem.Allocator,
+        xcrun_path: []const u8,
+        udid: ?[]const u8,
+        app_id: []const u8,
+    ) !IosDevice {
+        return try initWithShim(allocator, xcrun_path, udid, app_id, null);
+    }
+
+    pub fn initWithShim(
+        allocator: std.mem.Allocator,
+        xcrun_path: []const u8,
+        udid: ?[]const u8,
+        app_id: []const u8,
+        shim_path: ?[]const u8,
+    ) !IosDevice {
+        return try initWithKindAndShim(allocator, xcrun_path, udid, app_id, .simulator, shim_path);
+    }
+
+    pub fn initWithKindAndShim(
+        allocator: std.mem.Allocator,
+        xcrun_path: []const u8,
+        udid: ?[]const u8,
+        app_id: []const u8,
+        target_kind: TargetKind,
+        shim_path: ?[]const u8,
+    ) !IosDevice {
+        const owned_xcrun = try allocator.dupe(u8, xcrun_path);
+        errdefer allocator.free(owned_xcrun);
+        const owned_udid = try types.dupeOptional(allocator, udid);
+        errdefer if (owned_udid) |value| allocator.free(value);
+        const owned_app_id = try allocator.dupe(u8, app_id);
+        errdefer allocator.free(owned_app_id);
+        const owned_shim_path = try types.dupeOptional(allocator, shim_path);
+
+        return .{
+            .allocator = allocator,
+            .xcrun_path = owned_xcrun,
+            .udid = owned_udid,
+            .app_id = owned_app_id,
+            .shim_path = owned_shim_path,
+            .target_kind = target_kind,
+        };
+    }
+
+    pub fn deinit(self: *IosDevice) void {
+        self.allocator.free(self.xcrun_path);
+        if (self.udid) |value| self.allocator.free(value);
+        self.allocator.free(self.app_id);
+        if (self.shim_path) |value| self.allocator.free(value);
+    }
+
+    pub fn listDevices(self: *IosDevice) ![]types.DeviceInfo {
+        return switch (self.target_kind) {
+            .simulator => try ios_devices.listSimulators(self.allocator, self.xcrun_path),
+            .physical => try ios_devices.listPhysical(self.allocator, self.xcrun_path),
+        };
+    }
+
+    pub fn install(self: *IosDevice, app_path: []const u8) !void {
+        if (self.target_kind == .physical) return try self.installPhysical(app_path);
+        const result = try self.runSimctl(&.{ "install", self.target(), app_path }, default_max_output);
+        defer result.deinit(self.allocator);
+        try result.ensureSuccess();
+    }
+
+    pub fn launch(self: *IosDevice) !void {
+        if (self.target_kind == .physical) return try self.launchPhysical(null);
+        const result = try self.runSimctl(&.{ "launch", self.target(), self.app_id }, default_max_output);
+        defer result.deinit(self.allocator);
+        result.ensureSuccess() catch |err| {
+            if (self.appIsRunningFromShimBestEffort()) return;
+            return err;
+        };
+    }
+
+    pub fn stop(self: *IosDevice) !void {
+        if (self.target_kind == .physical) return try self.stopPhysicalBestEffort();
+        const result = try self.runSimctl(&.{ "terminate", self.target(), self.app_id }, default_max_output);
+        defer result.deinit(self.allocator);
+        try result.ensureSuccess();
+    }
+
+    pub fn clearState(self: *IosDevice) !void {
+        if (self.target_kind == .physical) return try self.uninstallPhysicalBestEffort();
+        const result = try self.runSimctl(&.{ "uninstall", self.target(), self.app_id }, default_max_output);
+        defer result.deinit(self.allocator);
+        if (ios_lifecycle.isMissingInstalledApp(result)) return;
+        try result.ensureSuccess();
+    }
+
+    pub fn openLink(self: *IosDevice, url: []const u8) !void {
+        if (self.target_kind == .physical) return try self.launchPhysical(url);
+        const result = try self.runSimctl(&.{ "openurl", self.target(), url }, default_max_output);
+        defer result.deinit(self.allocator);
+        try result.ensureSuccess();
+        self.acceptOpenURLConfirmationBestEffort();
+    }
+
+    pub fn tap(self: *IosDevice, x: i32, y: i32) !void {
+        try self.runShimAction(.{ .kind = .tap, .x = x, .y = y });
+    }
+
+    pub fn tapBySelector(self: *IosDevice, wanted: selector.Selector) !bool {
+        return try self.runShimSelectorAction(.{ .kind = .tap }, wanted);
+    }
+
+    pub fn visibleBySelector(self: *IosDevice, wanted: selector.Selector) !?bool {
+        if (self.shim_path == null) return null;
+        const shim_selector = try ios_shim.selectorString(self.allocator, wanted) orelse return null;
+        defer self.allocator.free(shim_selector);
+
+        const response = try self.runShim(.{ .kind = .query, .selector = shim_selector });
+        defer self.allocator.free(response);
+        return try ios_shim.parseQueryResponse(response);
+    }
+
+    pub fn typeText(self: *IosDevice, text: []const u8) !void {
+        try self.runShimAction(.{ .kind = .type_text, .text = text });
+    }
+
+    pub fn typeTextBySelector(self: *IosDevice, wanted: selector.Selector, text: []const u8) !bool {
+        return try self.runShimSelectorAction(.{ .kind = .type_text, .text = text }, wanted);
+    }
+
+    pub fn eraseText(self: *IosDevice, max_chars: u32) !void {
+        try self.runShimAction(.{ .kind = .erase_text, .max_chars = max_chars });
+    }
+
+    pub fn eraseTextBySelector(self: *IosDevice, wanted: selector.Selector, max_chars: u32) !bool {
+        return try self.runShimSelectorAction(.{ .kind = .erase_text, .max_chars = max_chars }, wanted);
+    }
+
+    pub fn hideKeyboard(self: *IosDevice) !void {
+        try self.runShimAction(.{ .kind = .hide_keyboard });
+    }
+
+    pub fn swipe(self: *IosDevice, x1: i32, y1: i32, x2: i32, y2: i32, duration_ms: u32) !void {
+        try self.runShimAction(.{ .kind = .swipe, .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, .duration_ms = duration_ms });
+    }
+
+    pub fn pressBack(self: *IosDevice) !void {
+        try self.runShimAction(.{ .kind = .press_back });
+    }
+
+    pub fn settle(self: *IosDevice, timeout_ms: u64) !void {
+        if (self.shim_path != null) {
+            return try self.runShimAction(.{
+                .kind = .settle,
+                .duration_ms = @as(u32, @intCast(@min(timeout_ms, std.math.maxInt(u32)))),
+            });
+        }
+        std.Thread.sleep(timeout_ms * std.time.ns_per_ms);
+    }
+
+    pub fn snapshot(self: *IosDevice, 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()});
+        errdefer self.allocator.free(id);
+
+        var screenshot_artifact: ?[]const u8 = null;
+        errdefer if (screenshot_artifact) |path| self.allocator.free(path);
+        var viewport: types.Viewport = .{};
+
+        if (writer) |tw| {
+            if (tw.capture.capture_screenshots) {
+                const screenshot = self.captureScreenshot() catch null;
+                if (screenshot) |bytes| {
+                    defer self.allocator.free(bytes);
+                    viewport = ios_snapshot.parsePngViewport(bytes) orelse .{};
+                    const file_name = try std.fmt.allocPrint(self.allocator, "{s}.png", .{id});
+                    defer self.allocator.free(file_name);
+                    screenshot_artifact = try tw.writeArtifact(file_name, bytes);
+                }
+            }
+        }
+
+        const capture_logs = if (writer) |tw| tw.capture.capture_logs else true;
+        const logs = if (capture_logs) self.logDelta() catch null else null;
+        errdefer if (logs) |value| self.allocator.free(value);
+
+        const active_package = try self.allocator.dupe(u8, self.app_id);
+        errdefer self.allocator.free(active_package);
+        const nodes = if (self.shim_path != null)
+            self.snapshotNodesFromShim() catch |err| blk: {
+                if (screenshot_artifact == null) return err;
+                if (writer) |tw| try self.recordSnapshotSemanticFailure(tw, screenshot_artifact.?, err);
+                break :blk try self.allocator.alloc(types.UiNode, 0);
+            }
+        else
+            try self.allocator.alloc(types.UiNode, 0);
+        errdefer self.allocator.free(nodes);
+
+        return .{
+            .id = id,
+            .timestamp_ms = std.time.milliTimestamp(),
+            .viewport = viewport,
+            .active_package = active_package,
+            .active_activity = null,
+            .screenshot_artifact = screenshot_artifact,
+            .tree_artifact = null,
+            .focused_node_id = null,
+            .log_delta = logs,
+            .nodes = nodes,
+        };
+    }
+
+    fn captureScreenshot(self: *IosDevice) ![]u8 {
+        if (self.target_kind == .physical) {
+            const response = try self.runShim(.{ .kind = .screenshot });
+            defer self.allocator.free(response);
+            return try ios_shim.parseScreenshotPng(self.allocator, response);
+        }
+        const path = try std.fmt.allocPrint(self.allocator, "/tmp/zmr-ios-screenshot-{d}.png", .{std.time.nanoTimestamp()});
+        defer self.allocator.free(path);
+        defer std.fs.cwd().deleteFile(path) catch {};
+
+        const result = try self.runSimctl(&.{ "io", self.target(), "screenshot", path }, default_max_output);
+        defer result.deinit(self.allocator);
+        try result.ensureSuccess();
+        return try std.fs.cwd().readFileAlloc(self.allocator, path, default_max_output);
+    }
+
+    fn logDelta(self: *IosDevice) !?[]const u8 {
+        if (self.target_kind == .physical) return null;
+        const result = try self.runSimctl(&.{ "spawn", self.target(), "log", "show", "--style", "compact", "--last", "30s" }, 1024 * 1024);
+        defer result.deinit(self.allocator);
+        if (result.term != .Exited or result.term.Exited != 0) return null;
+        return try self.allocator.dupe(u8, result.stdout);
+    }
+
+    fn snapshotNodesFromShim(self: *IosDevice) ![]types.UiNode {
+        const response = try self.runShim(.{ .kind = .snapshot });
+        defer self.allocator.free(response);
+        return try ios_shim.parseSnapshotNodes(self.allocator, response);
+    }
+
+    fn recordSnapshotSemanticFailure(self: *IosDevice, writer: *trace.TraceWriter, screenshot_artifact: []const u8, err: anyerror) !void {
+        var payload = std.ArrayList(u8).empty;
+        defer payload.deinit(writer.allocator);
+        const out = payload.writer(writer.allocator);
+        try out.writeAll("{\"status\":\"failed\",\"artifactStatus\":\"captured\",\"semanticStatus\":\"failed\",\"error\":");
+        try trace.writeJsonString(out, @errorName(err));
+        try out.writeAll(",\"screenshotArtifact\":");
+        try trace.writeJsonString(out, screenshot_artifact);
+        try out.writeAll(",\"source\":\"ios-xctest-shim\"}");
+        try writer.recordEvent("observe.snapshot.semanticExtraction", payload.items);
+        _ = self;
+    }
+
+    fn runShimAction(self: *IosDevice, shim_command: ios_shim.Command) !void {
+        const response = try self.runShim(shim_command);
+        defer self.allocator.free(response);
+        try ios_shim.parseOkResponse(response);
+    }
+
+    fn runShimActionWithTimeout(self: *IosDevice, shim_command: ios_shim.Command, timeout_ms: u64) !void {
+        const response = try self.runShimWithTimeout(shim_command, timeout_ms);
+        defer self.allocator.free(response);
+        try ios_shim.parseOkResponse(response);
+    }
+
+    fn acceptOpenURLConfirmationBestEffort(self: *IosDevice) void {
+        if (self.shim_path == null) return;
+        self.runShimActionWithTimeout(.{ .kind = .accept_system_alert, .text = "Open" }, shim_best_effort_timeout_ms) catch {};
+    }
+
+    fn appIsRunningFromShimBestEffort(self: *IosDevice) bool {
+        if (self.shim_path == null) return false;
+        const response = self.runShimWithTimeout(.{ .kind = .app_state }, shim_best_effort_timeout_ms) catch return false;
+        defer self.allocator.free(response);
+        return ios_shim.parseAppStateRunning(response) catch false;
+    }
+
+    fn runShimSelectorAction(self: *IosDevice, shim_command: ios_shim.Command, wanted: selector.Selector) !bool {
+        if (self.shim_path == null) return false;
+        const shim_selector = try ios_shim.selectorString(self.allocator, wanted) orelse return false;
+        defer self.allocator.free(shim_selector);
+
+        var command_with_selector = shim_command;
+        command_with_selector.selector = shim_selector;
+        try self.runShimAction(command_with_selector);
+        return true;
+    }
+
+    fn runShim(self: *IosDevice, shim_command: ios_shim.Command) ![]u8 {
+        return self.runShimWithTimeout(shim_command, shim_timeout_ms);
+    }
+
+    fn runShimWithTimeout(self: *IosDevice, shim_command: ios_shim.Command, timeout_ms: u64) ![]u8 {
+        const path = self.shim_path orelse return error.IosXCTestShimRequired;
+
+        var input = std.ArrayList(u8).empty;
+        defer input.deinit(self.allocator);
+        try ios_shim.writeCommandJson(input.writer(self.allocator), shim_command);
+
+        var attempt: usize = 0;
+        while (attempt < shim_command_attempts) {
+            attempt += 1;
+            const result = try command.runWithInputTimeout(self.allocator, &.{path}, input.items, 4 * 1024 * 1024, timeout_ms);
+            defer result.deinit(self.allocator);
+
+            result.ensureSuccess() catch |err| {
+                if (attempt < shim_command_attempts and err == error.CommandFailed and isTransientShimBootstrapFailure(result)) {
+                    std.Thread.sleep(shim_bootstrap_retry_delay_ms * std.time.ns_per_ms);
+                    continue;
+                }
+                return err;
+            };
+            return try self.allocator.dupe(u8, result.stdout);
+        }
+
+        return error.CommandFailed;
+    }
+
+    fn target(self: *IosDevice) []const u8 {
+        return self.udid orelse "booted";
+    }
+
+    fn runSimctl(self: *IosDevice, extra: []const []const u8, max_output_bytes: usize) !command.ExecResult {
+        return try ios_devices.runSimctlCommand(self.allocator, self.xcrun_path, extra, max_output_bytes);
+    }
+
+    fn installPhysical(self: *IosDevice, app_path: []const u8) !void {
+        try ios_lifecycle.installPhysical(self.allocator, self.xcrun_path, self.target(), app_path);
+    }
+
+    fn launchPhysical(self: *IosDevice, url: ?[]const u8) !void {
+        try ios_lifecycle.launchPhysical(self.allocator, self.xcrun_path, self.target(), self.app_id, url);
+    }
+
+    fn stopPhysicalBestEffort(self: *IosDevice) !void {
+        try ios_lifecycle.stopPhysicalBestEffort(self.allocator, self.xcrun_path, self.target(), self.app_id);
+    }
+
+    fn uninstallPhysicalBestEffort(self: *IosDevice) !void {
+        try ios_lifecycle.uninstallPhysicalBestEffort(self.allocator, self.xcrun_path, self.target(), self.app_id);
+    }
+};
+
+fn isTransientShimBootstrapFailure(result: command.ExecResult) bool {
+    if (result.timed_out) return false;
+    switch (result.term) {
+        .Exited => |code| if (code == 0) return false,
+        else => return false,
+    }
+    return std.mem.indexOf(u8, result.stderr, "iOS shim server exited before it became ready") != null or
+        std.mem.indexOf(u8, result.stderr, "Early unexpected exit") != null or
+        std.mem.indexOf(u8, result.stderr, "operation never finished bootstrapping") != null;
+}
+
+pub fn listDevices(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
+    return try ios_devices.listSimulators(allocator, xcrun_path);
+}
+
+pub fn listPhysicalDevices(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
+    return try ios_devices.listPhysical(allocator, xcrun_path);
+}
+
+pub fn parseDevicesJson(allocator: std.mem.Allocator, content: []const u8) ![]types.DeviceInfo {
+    return try ios_devices.parseSimulatorsJson(allocator, content);
+}
+
+pub fn parsePhysicalDevicesJson(allocator: std.mem.Allocator, content: []const u8) ![]types.DeviceInfo {
+    return try ios_devices.parsePhysicalDevicesJson(allocator, content);
+}
+
+test "ios xctest shim timeout allows cold xcodebuild startup" {
+    try std.testing.expect(shim_timeout_ms >= 300_000);
+    try std.testing.expect(shim_best_effort_timeout_ms <= 15_000);
+}

package/src/ios_devices.zig

@@ -0,0 +1,219 @@
+const std = @import("std");
+const command = @import("command.zig");
+const types = @import("types.zig");
+
+const default_max_output = 32 * 1024 * 1024;
+const simctl_retry_attempts = 6;
+const simctl_retry_delay_ms = 500;
+
+pub fn listSimulators(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
+    const result = try runSimctlCommand(allocator, xcrun_path, &.{ "list", "devices", "--json" }, 4 * 1024 * 1024);
+    defer result.deinit(allocator);
+    try result.ensureSuccess();
+    return try parseSimulatorsJson(allocator, result.stdout);
+}
+
+pub fn listPhysical(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
+    const json = try runDevicectlJsonCommand(allocator, xcrun_path, &.{ "list", "devices" });
+    defer allocator.free(json);
+    return try parsePhysicalDevicesJson(allocator, json);
+}
+
+pub fn runSimctlCommand(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    extra: []const []const u8,
+    max_output_bytes: usize,
+) !command.ExecResult {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, xcrun_path);
+    try argv.append(allocator, "simctl");
+    try argv.appendSlice(allocator, extra);
+
+    var attempt: usize = 0;
+    while (true) {
+        const result = try command.run(allocator, argv.items, max_output_bytes);
+        if (attempt + 1 >= simctl_retry_attempts or !isRetriableSimctlFailure(result)) {
+            return result;
+        }
+        result.deinit(allocator);
+        attempt += 1;
+        std.Thread.sleep(simctl_retry_delay_ms * std.time.ns_per_ms);
+    }
+}
+
+pub fn runDevicectlCommand(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    extra: []const []const u8,
+    max_output_bytes: usize,
+) !command.ExecResult {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, xcrun_path);
+    try argv.append(allocator, "devicectl");
+    try argv.appendSlice(allocator, extra);
+    return try command.run(allocator, argv.items, max_output_bytes);
+}
+
+pub fn runDevicectlJsonCommand(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    extra: []const []const u8,
+) ![]u8 {
+    const path = try std.fmt.allocPrint(allocator, "/tmp/zmr-devicectl-{d}.json", .{std.time.nanoTimestamp()});
+    defer allocator.free(path);
+    defer std.fs.cwd().deleteFile(path) catch {};
+
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.append(allocator, xcrun_path);
+    try argv.append(allocator, "devicectl");
+    try argv.appendSlice(allocator, extra);
+    try argv.appendSlice(allocator, &.{ "--json-output", path, "--quiet" });
+
+    const result = try command.run(allocator, argv.items, default_max_output);
+    defer result.deinit(allocator);
+    try result.ensureSuccess();
+    return try std.fs.cwd().readFileAlloc(allocator, path, default_max_output);
+}
+
+pub fn parseSimulatorsJson(allocator: std.mem.Allocator, content: []const u8) ![]types.DeviceInfo {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    if (parsed.value != .object) return error.SimctlDevicesMustBeObject;
+    const devices_value = parsed.value.object.get("devices") orelse return error.SimctlDevicesMissingDevices;
+    if (devices_value != .object) return error.SimctlDevicesMustBeObject;
+
+    var devices = std.ArrayList(types.DeviceInfo).empty;
+    errdefer {
+        for (devices.items) |device| device.deinit(allocator);
+        devices.deinit(allocator);
+    }
+
+    var runtime_iterator = devices_value.object.iterator();
+    while (runtime_iterator.next()) |runtime_entry| {
+        const runtime_devices = runtime_entry.value_ptr.*;
+        if (runtime_devices != .array) continue;
+        for (runtime_devices.array.items) |device_value| {
+            if (device_value != .object) continue;
+            const object = device_value.object;
+            if (fieldBool(object, "isAvailable") == false) continue;
+            const udid = fieldString(object, "udid") orelse continue;
+            const state = fieldString(object, "state") orelse continue;
+            if (!std.mem.eql(u8, state, "Booted")) continue;
+            try devices.append(allocator, .{
+                .serial = try allocator.dupe(u8, udid),
+                .state = try allocator.dupe(u8, state),
+            });
+        }
+    }
+
+    return try devices.toOwnedSlice(allocator);
+}
+
+pub fn parsePhysicalDevicesJson(allocator: std.mem.Allocator, content: []const u8) ![]types.DeviceInfo {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    if (parsed.value != .object) return error.DevicectlDevicesMustBeObject;
+    const result_value = parsed.value.object.get("result") orelse return error.DevicectlDevicesMissingResult;
+    if (result_value != .object) return error.DevicectlDevicesMustBeObject;
+    const devices_value = result_value.object.get("devices") orelse return error.DevicectlDevicesMissingDevices;
+    if (devices_value != .array) return error.DevicectlDevicesMustBeArray;
+
+    var devices = std.ArrayList(types.DeviceInfo).empty;
+    errdefer {
+        for (devices.items) |device| device.deinit(allocator);
+        devices.deinit(allocator);
+    }
+
+    for (devices_value.array.items) |device_value| {
+        if (device_value != .object) continue;
+        const object = device_value.object;
+        const hardware = fieldObject(object, "hardwareProperties") orelse continue;
+        if (!fieldStringEquals(hardware, "platform", "iOS")) continue;
+        if (!fieldStringEquals(hardware, "reality", "physical")) continue;
+        const serial = fieldString(object, "identifier") orelse fieldString(hardware, "udid") orelse continue;
+        const connection = fieldObject(object, "connectionProperties");
+        const state = if (connection) |value|
+            fieldString(value, "tunnelState") orelse fieldString(value, "pairingState") orelse "available"
+        else
+            "available";
+        try devices.append(allocator, .{
+            .serial = try allocator.dupe(u8, serial),
+            .state = try allocator.dupe(u8, state),
+        });
+    }
+
+    return try devices.toOwnedSlice(allocator);
+}
+
+pub fn findPidForBundleId(allocator: std.mem.Allocator, content: []const u8, app_id: []const u8) !?i64 {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    return findPidInValue(parsed.value, app_id);
+}
+
+fn isRetriableSimctlFailure(result: command.ExecResult) bool {
+    if (result.timed_out) return false;
+    switch (result.term) {
+        .Exited => |code| if (code == 0) return false,
+        else => return false,
+    }
+    return std.mem.indexOf(u8, result.stderr, "CoreSimulatorService connection became invalid") != null or
+        std.mem.indexOf(u8, result.stderr, "Failed to initialize simulator device set") != null or
+        std.mem.indexOf(u8, result.stderr, "simdiskimaged") != null or
+        std.mem.indexOf(u8, result.stderr, "Connection refused") != null;
+}
+
+fn findPidInValue(value: std.json.Value, app_id: []const u8) ?i64 {
+    switch (value) {
+        .object => |object| {
+            var has_bundle = false;
+            var pid: ?i64 = null;
+            var iterator = object.iterator();
+            while (iterator.next()) |entry| {
+                if (entry.value_ptr.* == .string and std.mem.eql(u8, entry.value_ptr.string, app_id)) {
+                    has_bundle = true;
+                }
+                if (std.mem.indexOf(u8, entry.key_ptr.*, "pid") != null or std.mem.indexOf(u8, entry.key_ptr.*, "processIdentifier") != null) {
+                    if (entry.value_ptr.* == .integer) pid = entry.value_ptr.integer;
+                }
+                if (findPidInValue(entry.value_ptr.*, app_id)) |nested| return nested;
+            }
+            if (has_bundle) return pid;
+            return null;
+        },
+        .array => |array| {
+            for (array.items) |item| {
+                if (findPidInValue(item, app_id)) |pid| return pid;
+            }
+            return null;
+        },
+        else => return null,
+    }
+}
+
+fn fieldObject(object: std.json.ObjectMap, key: []const u8) ?std.json.ObjectMap {
+    const value = object.get(key) orelse return null;
+    if (value != .object) return null;
+    return value.object;
+}
+
+fn fieldStringEquals(object: std.json.ObjectMap, key: []const u8, expected: []const u8) bool {
+    const value = fieldString(object, key) orelse return false;
+    return std.mem.eql(u8, value, expected);
+}
+
+fn fieldString(object: std.json.ObjectMap, key: []const u8) ?[]const u8 {
+    const value = object.get(key) orelse return null;
+    if (value != .string) return null;
+    return value.string;
+}
+
+fn fieldBool(object: std.json.ObjectMap, key: []const u8) bool {
+    const value = object.get(key) orelse return true;
+    if (value != .bool) return true;
+    return value.bool;
+}

package/src/ios_lifecycle.zig

@@ -0,0 +1,72 @@
+const std = @import("std");
+const command = @import("command.zig");
+const ios_devices = @import("ios_devices.zig");
+
+const default_max_output = 32 * 1024 * 1024;
+
+pub fn installPhysical(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    target: []const u8,
+    app_path: []const u8,
+) !void {
+    const result = try ios_devices.runDevicectlCommand(allocator, xcrun_path, &.{ "device", "install", "app", "--device", target, app_path }, default_max_output);
+    defer result.deinit(allocator);
+    try result.ensureSuccess();
+}
+
+pub fn launchPhysical(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    target: []const u8,
+    app_id: []const u8,
+    url: ?[]const u8,
+) !void {
+    var argv = std.ArrayList([]const u8).empty;
+    defer argv.deinit(allocator);
+    try argv.appendSlice(allocator, &.{ "device", "process", "launch", "--device", target, "--terminate-existing" });
+    if (url) |value| try argv.appendSlice(allocator, &.{ "--payload-url", value });
+    try argv.append(allocator, app_id);
+
+    const result = try ios_devices.runDevicectlCommand(allocator, xcrun_path, argv.items, default_max_output);
+    defer result.deinit(allocator);
+    try result.ensureSuccess();
+}
+
+pub fn stopPhysicalBestEffort(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    target: []const u8,
+    app_id: []const u8,
+) !void {
+    const process_json = ios_devices.runDevicectlJsonCommand(allocator, xcrun_path, &.{ "device", "info", "processes", "--device", target }) catch return;
+    defer allocator.free(process_json);
+    const pid = ios_devices.findPidForBundleId(allocator, process_json, app_id) catch null;
+    if (pid) |value| {
+        const pid_text = try std.fmt.allocPrint(allocator, "{d}", .{value});
+        defer allocator.free(pid_text);
+        const result = try ios_devices.runDevicectlCommand(allocator, xcrun_path, &.{ "device", "process", "terminate", "--device", target, "--pid", pid_text }, default_max_output);
+        defer result.deinit(allocator);
+        try result.ensureSuccess();
+    }
+}
+
+pub fn uninstallPhysicalBestEffort(
+    allocator: std.mem.Allocator,
+    xcrun_path: []const u8,
+    target: []const u8,
+    app_id: []const u8,
+) !void {
+    const result = try ios_devices.runDevicectlCommand(allocator, xcrun_path, &.{ "device", "uninstall", "app", "--device", target, app_id }, default_max_output);
+    defer result.deinit(allocator);
+    if (isMissingInstalledApp(result)) return;
+    try result.ensureSuccess();
+}
+
+pub fn isMissingInstalledApp(result: command.ExecResult) bool {
+    switch (result.term) {
+        .Exited => |code| if (code == 0) return false,
+        else => return false,
+    }
+    return std.mem.indexOf(u8, result.stderr, "No installed application with bundle identifier") != null;
+}