zig-mobile-runner 0.1.0

package/src/ios_shim.zig

@@ -0,0 +1,242 @@
+const std = @import("std");
+const selectors = @import("selector.zig");
+const trace = @import("trace.zig");
+const types = @import("types.zig");
+
+pub const CommandKind = enum {
+    snapshot,
+    screenshot,
+    tap,
+    type_text,
+    erase_text,
+    hide_keyboard,
+    swipe,
+    press_back,
+    app_state,
+    settle,
+    accept_system_alert,
+    query,
+};
+
+pub const Command = struct {
+    kind: CommandKind,
+    selector: ?[]const u8 = null,
+    text: ?[]const u8 = null,
+    x: ?i32 = null,
+    y: ?i32 = null,
+    x1: ?i32 = null,
+    y1: ?i32 = null,
+    x2: ?i32 = null,
+    y2: ?i32 = null,
+    duration_ms: ?u32 = null,
+    max_chars: ?u32 = null,
+};
+
+pub fn writeCommandJson(writer: anytype, command: Command) !void {
+    try writer.writeAll("{\"cmd\":");
+    try trace.writeJsonString(writer, commandName(command.kind));
+    if (command.selector) |selector| {
+        try writer.writeAll(",\"selector\":");
+        try trace.writeJsonString(writer, selector);
+    }
+    if (command.text) |text| {
+        try writer.writeAll(",\"text\":");
+        try trace.writeJsonString(writer, text);
+    }
+    if (command.x) |value| try writer.print(",\"x\":{d}", .{value});
+    if (command.y) |value| try writer.print(",\"y\":{d}", .{value});
+    if (command.x1) |value| try writer.print(",\"x1\":{d}", .{value});
+    if (command.y1) |value| try writer.print(",\"y1\":{d}", .{value});
+    if (command.x2) |value| try writer.print(",\"x2\":{d}", .{value});
+    if (command.y2) |value| try writer.print(",\"y2\":{d}", .{value});
+    if (command.duration_ms) |value| try writer.print(",\"durationMs\":{d}", .{value});
+    if (command.max_chars) |value| try writer.print(",\"maxChars\":{d}", .{value});
+    try writer.writeAll("}\n");
+}
+
+pub fn parseSnapshotNodes(allocator: std.mem.Allocator, content: []const u8) ![]types.UiNode {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const nodes_value = parsed.value.object.get("nodes") orelse return error.IosShimMissingNodes;
+    if (nodes_value != .array) return error.IosShimNodesMustBeArray;
+
+    var nodes = std.ArrayList(types.UiNode).empty;
+    errdefer {
+        for (nodes.items) |*node| node.deinit(allocator);
+        nodes.deinit(allocator);
+    }
+
+    for (nodes_value.array.items) |node_value| {
+        if (node_value != .object) return error.IosShimNodeMustBeObject;
+        const object = node_value.object;
+        const stable_id_source = fieldString(object, "id") orelse return error.IosShimNodeMissingId;
+        const class_name_source = fieldString(object, "type") orelse "XCUIElementTypeOther";
+        const bounds_value = object.get("bounds") orelse return error.IosShimNodeMissingBounds;
+        if (bounds_value != .object) return error.IosShimBoundsMustBeObject;
+
+        const text = nonEmptyFieldString(object, "label") orelse nonEmptyFieldString(object, "value");
+        const content_desc = fieldString(object, "identifier");
+        try nodes.append(allocator, .{
+            .stable_id = try allocator.dupe(u8, stable_id_source),
+            .class_name = try allocator.dupe(u8, class_name_source),
+            .text = try dupeOptional(allocator, text),
+            .content_desc = try dupeOptional(allocator, content_desc),
+            .resource_id = try dupeOptional(allocator, content_desc),
+            .bounds = .{
+                .x = try intField(bounds_value.object, "x"),
+                .y = try intField(bounds_value.object, "y"),
+                .width = try intField(bounds_value.object, "width"),
+                .height = try intField(bounds_value.object, "height"),
+            },
+            .enabled = boolField(object, "enabled", true),
+            .visible = boolField(object, "visible", true),
+            .selected = boolField(object, "selected", false),
+        });
+    }
+
+    return try nodes.toOwnedSlice(allocator);
+}
+
+pub fn parseOkResponse(content: []const u8) !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const parsed = try std.json.parseFromSlice(std.json.Value, arena.allocator(), content, .{});
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+}
+
+pub fn parseQueryResponse(content: []const u8) !bool {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const parsed = try std.json.parseFromSlice(std.json.Value, arena.allocator(), content, .{});
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const exists = parsed.value.object.get("exists") orelse return error.IosShimMissingExists;
+    if (exists != .bool) return error.IosShimExistsMustBeBool;
+    return exists.bool;
+}
+
+pub fn parseAppStateRunning(content: []const u8) !bool {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const parsed = try std.json.parseFromSlice(std.json.Value, arena.allocator(), content, .{});
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const state = parsed.value.object.get("state") orelse return error.IosShimMissingState;
+    return switch (state) {
+        .integer => |value| value >= 3,
+        .string => |value| std.mem.eql(u8, value, "running") or
+            std.mem.eql(u8, value, "runningForeground") or
+            std.mem.eql(u8, value, "runningBackground"),
+        else => error.IosShimStateMustBeIntegerOrString,
+    };
+}
+
+pub fn parseScreenshotPng(allocator: std.mem.Allocator, content: []const u8) ![]u8 {
+    const parsed = try std.json.parseFromSlice(std.json.Value, allocator, content, .{});
+    defer parsed.deinit();
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const format = fieldString(parsed.value.object, "format") orelse return error.IosShimMissingScreenshotFormat;
+    if (!std.mem.eql(u8, format, "png")) return error.IosShimUnsupportedScreenshotFormat;
+    const encoded = fieldString(parsed.value.object, "base64") orelse return error.IosShimMissingScreenshotData;
+    const size = try std.base64.standard.Decoder.calcSizeForSlice(encoded);
+    const bytes = try allocator.alloc(u8, size);
+    errdefer allocator.free(bytes);
+    try std.base64.standard.Decoder.decode(bytes, encoded);
+    return bytes;
+}
+
+pub fn selectorString(allocator: std.mem.Allocator, wanted: selectors.Selector) !?[]u8 {
+    var count: usize = 0;
+    var prefix: []const u8 = "";
+    var value: []const u8 = "";
+
+    if (wanted.id) |actual| {
+        count += 1;
+        prefix = "resourceId=";
+        value = actual;
+    }
+    if (wanted.text) |actual| {
+        count += 1;
+        prefix = "text=";
+        value = actual;
+    }
+    if (wanted.text_contains) |actual| {
+        count += 1;
+        prefix = "textContains=";
+        value = actual;
+    }
+    if (wanted.content_desc) |actual| {
+        count += 1;
+        prefix = "identifier=";
+        value = actual;
+    }
+    if (wanted.content_desc_contains) |actual| {
+        count += 1;
+        prefix = "identifierContains=";
+        value = actual;
+    }
+    if (wanted.class_name) |actual| {
+        count += 1;
+        prefix = "type=";
+        value = actual;
+    }
+
+    if (count != 1) return null;
+    return try std.fmt.allocPrint(allocator, "{s}{s}", .{ prefix, value });
+}
+
+fn commandName(kind: CommandKind) []const u8 {
+    return switch (kind) {
+        .snapshot => "snapshot",
+        .screenshot => "screenshot",
+        .tap => "tap",
+        .type_text => "type",
+        .erase_text => "eraseText",
+        .hide_keyboard => "hideKeyboard",
+        .swipe => "swipe",
+        .press_back => "pressBack",
+        .app_state => "appState",
+        .settle => "settle",
+        .accept_system_alert => "acceptSystemAlert",
+        .query => "query",
+    };
+}
+
+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 nonEmptyFieldString(object: std.json.ObjectMap, key: []const u8) ?[]const u8 {
+    const value = fieldString(object, key) orelse return null;
+    if (value.len == 0) return null;
+    return value;
+}
+
+fn boolField(object: std.json.ObjectMap, key: []const u8, default: bool) bool {
+    const value = object.get(key) orelse return default;
+    if (value != .bool) return default;
+    return value.bool;
+}
+
+fn intField(object: std.json.ObjectMap, key: []const u8) !i32 {
+    const value = object.get(key) orelse return error.IosShimBoundsMissingField;
+    if (value != .integer) return error.IosShimBoundsFieldMustBeInteger;
+    if (value.integer < std.math.minInt(i32) or value.integer > std.math.maxInt(i32)) return error.IosShimBoundsFieldMustBeInteger;
+    return @intCast(value.integer);
+}
+
+fn dupeOptional(allocator: std.mem.Allocator, value: ?[]const u8) !?[]const u8 {
+    if (value) |actual| return try allocator.dupe(u8, actual);
+    return null;
+}

package/src/ios_snapshot.zig

@@ -0,0 +1,20 @@
+const std = @import("std");
+const types = @import("types.zig");
+
+pub fn parsePngViewport(bytes: []const u8) ?types.Viewport {
+    const signature = "\x89PNG\r\n\x1a\n";
+    if (bytes.len < 24 or !std.mem.eql(u8, bytes[0..8], signature)) return null;
+    if (!std.mem.eql(u8, bytes[12..16], "IHDR")) return null;
+
+    return .{
+        .width = readBigEndianU32(bytes[16..20]),
+        .height = readBigEndianU32(bytes[20..24]),
+    };
+}
+
+fn readBigEndianU32(bytes: []const u8) u32 {
+    return (@as(u32, bytes[0]) << 24) |
+        (@as(u32, bytes[1]) << 16) |
+        (@as(u32, bytes[2]) << 8) |
+        @as(u32, bytes[3]);
+}

package/src/json_fields.zig

@@ -0,0 +1,80 @@
+const std = @import("std");
+
+pub fn field(params: ?std.json.Value, key: []const u8) ?std.json.Value {
+    const value = params orelse return null;
+    if (value != .object) return null;
+    return value.object.get(key);
+}
+
+pub fn requiredString(params: ?std.json.Value, key: []const u8, missing_error: anyerror, type_error: anyerror) ![]const u8 {
+    const value = field(params, key) orelse return missing_error;
+    return stringValue(value, type_error);
+}
+
+pub fn requiredStringFromObject(object: std.json.ObjectMap, key: []const u8, missing_error: anyerror, type_error: anyerror) ![]const u8 {
+    const value = object.get(key) orelse return missing_error;
+    return stringValue(value, type_error);
+}
+
+pub fn optionalStringFromObject(object: std.json.ObjectMap, key: []const u8, type_error: anyerror) !?[]const u8 {
+    const value = object.get(key) orelse return null;
+    return try stringValue(value, type_error);
+}
+
+pub fn requiredI32(params: ?std.json.Value, key: []const u8, missing_error: anyerror, type_error: anyerror) !i32 {
+    const value = field(params, key) orelse return missing_error;
+    return i32Value(value, type_error);
+}
+
+pub fn requiredI32FromObject(object: std.json.ObjectMap, key: []const u8, missing_error: anyerror, type_error: anyerror) !i32 {
+    const value = object.get(key) orelse return missing_error;
+    return i32Value(value, type_error);
+}
+
+pub fn optionalU64(params: ?std.json.Value, key: []const u8, default_value: u64, type_error: anyerror) !u64 {
+    const value = field(params, key) orelse return default_value;
+    return u64Value(value, type_error);
+}
+
+pub fn optionalU64FromObject(object: std.json.ObjectMap, key: []const u8, default_value: u64, type_error: anyerror) !u64 {
+    const value = object.get(key) orelse return default_value;
+    return u64Value(value, type_error);
+}
+
+pub fn optionalBool(params: ?std.json.Value, key: []const u8, default_value: bool, type_error: anyerror) !bool {
+    const value = field(params, key) orelse return default_value;
+    return boolValue(value, type_error);
+}
+
+pub fn optionalBoolFromObject(object: std.json.ObjectMap, key: []const u8, default_value: bool, type_error: anyerror) !bool {
+    const value = object.get(key) orelse return default_value;
+    return boolValue(value, type_error);
+}
+
+fn stringValue(value: std.json.Value, type_error: anyerror) ![]const u8 {
+    return switch (value) {
+        .string => |actual| actual,
+        else => type_error,
+    };
+}
+
+fn i32Value(value: std.json.Value, type_error: anyerror) !i32 {
+    return switch (value) {
+        .integer => |actual| @as(i32, @intCast(actual)),
+        else => type_error,
+    };
+}
+
+fn u64Value(value: std.json.Value, type_error: anyerror) !u64 {
+    return switch (value) {
+        .integer => |actual| @as(u64, @intCast(actual)),
+        else => type_error,
+    };
+}
+
+fn boolValue(value: std.json.Value, type_error: anyerror) !bool {
+    return switch (value) {
+        .bool => |actual| actual,
+        else => type_error,
+    };
+}

package/src/json_rpc.zig

@@ -0,0 +1,150 @@
+const std = @import("std");
+const errors = @import("errors.zig");
+const methods = @import("json_rpc_methods.zig");
+const protocol = @import("json_rpc_protocol.zig");
+const trace = @import("trace.zig");
+
+pub const ServeOptions = struct {
+    transport: []const u8 = "stdio",
+};
+
+pub fn serveStdio(allocator: std.mem.Allocator, device: anytype) !void {
+    try serveStdioWithTrace(allocator, device, null);
+}
+
+pub fn serveStdioWithTrace(allocator: std.mem.Allocator, device: anytype, live_trace: ?*trace.TraceWriter) !void {
+    var stdin = std.fs.File.stdin().deprecatedReader();
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+
+    while (true) {
+        const line = stdin.readUntilDelimiterOrEofAlloc(allocator, '\n', 16 * 1024 * 1024) catch |err| {
+            try protocol.writeError(stdout, null, -32700, @errorName(err));
+            continue;
+        };
+        const owned_line = line orelse break;
+        defer allocator.free(owned_line);
+        const trimmed = std.mem.trim(u8, owned_line, " \t\r\n");
+        if (trimmed.len == 0) continue;
+        try dispatchLineWithTrace(allocator, device, trimmed, stdout, live_trace);
+    }
+}
+
+pub fn serveTcp(allocator: std.mem.Allocator, device: anytype, port: u16) !void {
+    try serveTcpWithTrace(allocator, device, port, null);
+}
+
+pub fn serveTcpWithTrace(allocator: std.mem.Allocator, device: anytype, port: u16, live_trace: ?*trace.TraceWriter) !void {
+    const address = try std.net.Address.parseIp("127.0.0.1", port);
+    var server = try address.listen(.{ .reuse_address = true });
+    defer server.deinit();
+
+    while (true) {
+        var connection = try server.accept();
+        defer connection.stream.close();
+        try serveTcpConnection(allocator, device, connection.stream, live_trace);
+    }
+}
+
+fn serveTcpConnection(allocator: std.mem.Allocator, device: anytype, stream: std.net.Stream, live_trace: ?*trace.TraceWriter) !void {
+    var write_buffer: [8192]u8 = undefined;
+    var stream_writer = stream.writer(&write_buffer);
+    const writer = &stream_writer.interface;
+
+    var line = std.ArrayList(u8).empty;
+    defer line.deinit(allocator);
+
+    var read_buffer: [4096]u8 = undefined;
+    while (true) {
+        const n = try stream.read(&read_buffer);
+        if (n == 0) break;
+        for (read_buffer[0..n]) |ch| {
+            if (ch == '\n') {
+                const trimmed = std.mem.trim(u8, line.items, " \t\r\n");
+                if (trimmed.len != 0) {
+                    try dispatchLineWithTrace(allocator, device, trimmed, writer, live_trace);
+                    try writer.flush();
+                }
+                line.clearRetainingCapacity();
+            } else {
+                try line.append(allocator, ch);
+            }
+        }
+    }
+
+    if (line.items.len != 0) {
+        const trimmed = std.mem.trim(u8, line.items, " \t\r\n");
+        if (trimmed.len != 0) {
+            try dispatchLineWithTrace(allocator, device, trimmed, writer, live_trace);
+            try writer.flush();
+        }
+    }
+}
+
+pub fn dispatchLine(allocator: std.mem.Allocator, device: anytype, line: []const u8, writer: anytype) !void {
+    try dispatchLineWithTrace(allocator, device, line, writer, null);
+}
+
+pub fn dispatchLineWithTrace(
+    allocator: std.mem.Allocator,
+    device: anytype,
+    line: []const u8,
+    writer: anytype,
+    live_trace: ?*trace.TraceWriter,
+) !void {
+    const parsed = std.json.parseFromSlice(std.json.Value, allocator, line, .{}) catch |err| {
+        try protocol.writeError(writer, null, -32700, @errorName(err));
+        return;
+    };
+    defer parsed.deinit();
+
+    if (parsed.value != .object) {
+        try protocol.writeError(writer, null, -32600, "request must be an object");
+        return;
+    }
+    const object = parsed.value.object;
+    const id = object.get("id");
+    const method_value = object.get("method") orelse {
+        try protocol.writeError(writer, id, -32600, "missing method");
+        return;
+    };
+    if (method_value != .string) {
+        try protocol.writeError(writer, id, -32600, "method must be a string");
+        return;
+    }
+    const params = object.get("params");
+
+    if (live_trace) |tw| try recordRpcEvent(tw, "rpc.request", method_value.string, id);
+    methods.dispatchMethod(allocator, device, method_value.string, params, id, writer, live_trace) catch |err| {
+        if (live_trace) |tw| try recordRpcErrorEvent(tw, method_value.string, id, err);
+        const classified = errors.classify(err);
+        try protocol.writeErrorWithPublicCode(writer, id, -32000, @errorName(err), classified.code);
+        return;
+    };
+    if (live_trace) |tw| try recordRpcEvent(tw, "rpc.response", method_value.string, id);
+}
+
+fn recordRpcEvent(tw: *trace.TraceWriter, kind: []const u8, method: []const u8, id: ?std.json.Value) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    const writer = payload.writer(tw.allocator);
+    try writer.writeAll("{\"method\":");
+    try trace.writeJsonString(writer, method);
+    try writer.writeAll(",\"id\":");
+    try protocol.writeId(writer, id);
+    try writer.writeAll("}");
+    try tw.recordEvent(kind, payload.items);
+}
+
+fn recordRpcErrorEvent(tw: *trace.TraceWriter, method: []const u8, id: ?std.json.Value, err: anyerror) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    const writer = payload.writer(tw.allocator);
+    try writer.writeAll("{\"method\":");
+    try trace.writeJsonString(writer, method);
+    try writer.writeAll(",\"id\":");
+    try protocol.writeId(writer, id);
+    try writer.writeAll(",\"error\":");
+    try trace.writeJsonString(writer, @errorName(err));
+    try writer.writeAll("}");
+    try tw.recordEvent("rpc.error", payload.items);
+}