zeno-mobile-runner 0.1.2 → 0.1.8

package/scripts/run-ios-pilot.sh

@@ -156,6 +156,11 @@ run() {
   fi
 }
 
+run_zmr_report() {
+  local trace_dir="$1"
+  run "$ZMR_BIN" report "$trace_dir" --out "$trace_dir/report.html" --junit "$trace_dir/junit.xml"
+}
+
 is_retryable_simctl_text() {
   local text="$1"
   [[ "$text" == *"CoreSimulatorService connection became invalid"* ]] ||
@@ -455,7 +460,7 @@ if [[ "$RUNS" -eq 1 ]]; then
   else
     run "$ZMR_BIN" run examples/ios-smoke.json --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --device "$DEVICE" --app-id "$APP_ID" --xcrun "$XCRUN" --trace-dir "$TRACE_DIR"
   fi
-  run "$ZMR_BIN" report "$TRACE_DIR" --out "$TRACE_DIR/report.html"
+  run_zmr_report "$TRACE_DIR"
   run "$ZMR_BIN" export "$TRACE_DIR" --out "$TRACE_ROOT/ios-smoke.zmrtrace"
   run "$ZMR_BIN" export "$TRACE_DIR" --out "$TRACE_ROOT/ios-smoke-redacted.zmrtrace" --redact
 
@@ -463,7 +468,7 @@ if [[ "$RUNS" -eq 1 ]]; then
     SHIM_TRACE_DIR="$TRACE_ROOT/ios-shim-smoke"
     run rm -rf "$SHIM_TRACE_DIR"
     run "$ZMR_BIN" run examples/ios-shim-smoke.json --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --device "$DEVICE" --app-id "$APP_ID" --xcrun "$XCRUN" --ios-shim "$IOS_SHIM" --trace-dir "$SHIM_TRACE_DIR"
-    run "$ZMR_BIN" report "$SHIM_TRACE_DIR" --out "$SHIM_TRACE_DIR/report.html"
+    run_zmr_report "$SHIM_TRACE_DIR"
     run "$ZMR_BIN" export "$SHIM_TRACE_DIR" --out "$TRACE_ROOT/ios-shim-smoke.zmrtrace"
     run "$ZMR_BIN" export "$SHIM_TRACE_DIR" --out "$TRACE_ROOT/ios-shim-smoke-redacted.zmrtrace" --redact
   fi
@@ -481,11 +486,11 @@ else
   else
     ZMR_BIN="$ZMR_BIN" run "$ROOT/scripts/benchmark.sh" --zmr examples/ios-smoke.json --device "$DEVICE" --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --app-id "$APP_ID" --xcrun "$XCRUN" --runs "$RUNS" --trace-root "$TRACE_ROOT/ios-smoke-benchmark" "${benchmark_gate_args[@]}"
   fi
-  run "$ZMR_BIN" report "$TRACE_ROOT/ios-smoke-benchmark" --out "$TRACE_ROOT/ios-smoke-benchmark/report.html"
+  run_zmr_report "$TRACE_ROOT/ios-smoke-benchmark"
 
   if [[ -n "$IOS_SHIM" ]]; then
     ZMR_BIN="$ZMR_BIN" run "$ROOT/scripts/benchmark.sh" --zmr examples/ios-shim-smoke.json --device "$DEVICE" --platform ios --ios-device-type "$IOS_DEVICE_TYPE" --app-id "$APP_ID" --xcrun "$XCRUN" --ios-shim "$IOS_SHIM" --runs "$RUNS" --trace-root "$TRACE_ROOT/ios-shim-smoke-benchmark" "${benchmark_gate_args[@]}"
-    run "$ZMR_BIN" report "$TRACE_ROOT/ios-shim-smoke-benchmark" --out "$TRACE_ROOT/ios-shim-smoke-benchmark/report.html"
+    run_zmr_report "$TRACE_ROOT/ios-shim-smoke-benchmark"
   fi
 fi
 
@@ -501,8 +506,10 @@ if [[ "$RUNS" -eq 1 ]]; then
 else
   echo "Benchmark reports:"
   echo "  $TRACE_ROOT/ios-smoke-benchmark/report.html"
+  echo "  $TRACE_ROOT/ios-smoke-benchmark/junit.xml"
   if [[ -n "$IOS_SHIM" ]]; then
     echo "  $TRACE_ROOT/ios-shim-smoke-benchmark/report.html"
+    echo "  $TRACE_ROOT/ios-shim-smoke-benchmark/junit.xml"
   fi
 fi
 echo "Viewer:"

package/shims/ios/ZMRShim.swift

@@ -58,6 +58,9 @@ enum ZMRShim {
                 guard nodes.count < 256 else {
                     return nodes
                 }
+                guard element.exists else {
+                    continue
+                }
                 nodes.append(node(index: nodes.count, type: type, element: element))
             }
         }

package/shims/ios/ZMRShimUITestCase.swift

@@ -128,7 +128,7 @@ final class ZMRShimUITestCase: XCTestCase {
             guard isFastQueryable(parts: parts) else {
                 return error("selector.unsupported", "unsupported query selector: \(selector)")
             }
-            let element = resolveFastElement(selector: selector, app: app, preferredTypes: [])
+            let element = resolveElement(selector: selector, app: app, preferredTypes: [])
             return [
                 "status": "ok",
                 "exists": element?.exists ?? false,
@@ -328,19 +328,49 @@ final class ZMRShimUITestCase: XCTestCase {
             return fast
         }
 
-        let matchedElements = app.descendants(matching: .any).allElementsBoundByIndex.filter { element in
-            matches(selector: selector, element: element)
-        }
-        if let preferred = matchedElements.first(where: { preferredTypes.contains($0.elementType) && $0.isHittable }) {
-            return preferred
+        return resolveBroadElement(selector: selector, app: app)
+    }
+
+    private func resolveBroadElement(selector: String, app: XCUIApplication) -> XCUIElement? {
+        guard let parts = selectorParts(selector) else {
+            return nil
         }
-        if let preferred = matchedElements.first(where: { preferredTypes.contains($0.elementType) }) {
-            return preferred
+
+        let query: XCUIElementQuery?
+        switch parts.field {
+        case "text", "label":
+            let predicate = parts.contains
+                ? NSPredicate(format: "label CONTAINS[c] %@", parts.value)
+                : NSPredicate(format: "label == %@", parts.value)
+            query = app.descendants(matching: .any).matching(predicate)
+        case "identifier", "resourceId":
+            let predicate = parts.contains
+                ? NSPredicate(format: "identifier CONTAINS[c] %@", parts.value)
+                : NSPredicate(format: "identifier == %@", parts.value)
+            query = app.descendants(matching: .any).matching(predicate)
+        case "value":
+            let predicate = parts.contains
+                ? NSPredicate(format: "value CONTAINS[c] %@", parts.value)
+                : NSPredicate(format: "value == %@", parts.value)
+            query = app.descendants(matching: .any).matching(predicate)
+        case "id":
+            if parts.value.hasPrefix("id:") {
+                let identifier = String(parts.value.dropFirst("id:".count))
+                query = app.descendants(matching: .any).matching(identifier: identifier)
+            } else if parts.value.hasPrefix("label:") {
+                let label = String(parts.value.dropFirst("label:".count))
+                query = app.descendants(matching: .any).matching(NSPredicate(format: "label == %@", label))
+            } else {
+                query = nil
+            }
+        default:
+            query = nil
         }
-        if let hittable = matchedElements.first(where: { $0.isHittable }) {
-            return hittable
+
+        guard let element = query?.firstMatch, element.exists else {
+            return nil
         }
-        return matchedElements.first
+        return element
     }
 
     private func resolveFastElement(selector: String, app: XCUIApplication, preferredTypes: [XCUIElement.ElementType]) -> XCUIElement? {

package/skills/zmr-mobile-testing/SKILL.md

@@ -57,9 +57,34 @@ zmr mcp --config .zmr/config.json --trace-dir traces/zmr-agent
 ```
 
 Use the `semantic_snapshot`, `tap`, `type`, `wait_visible`, `trace_events`, and
-`trace_export` tools. Prefer `semantic_snapshot` because it normalizes Android
-and iOS hierarchy classes into roles, selectors, bounds, and recommended
-actions.
+`trace_explore`, `trace_discover`, and `trace_export` tools. Prefer
+`semantic_snapshot` because it normalizes Android and iOS hierarchy classes
+into roles, selectors, bounds, and recommended actions.
+
+After a session has produced trace artifacts, prefer the review-first
+exploration handoff when a goal should travel with the generated scenario
+candidate:
+
+```json
+{"method":"trace.explore","params":{"out":".zmr/discovered/login-smoke.json","goal":"find a stable login smoke","includeActions":true,"validate":true,"force":true}}
+```
+
+For MCP agents, call `trace_explore` with the same `out`, `goal`,
+`includeActions`, `validate`, and `force` arguments. The offline CLI equivalent
+is:
+
+```bash
+zmr explore --from-trace traces/zmr-agent \
+  --out .zmr/discovered/login-smoke.json \
+  --goal "find a stable login smoke" \
+  --include-actions \
+  --validate \
+  --json
+```
+
+Treat the output as a starting point. Its JSON includes `autonomous:false`,
+`reviewRequired:true`, `guardrails`, replay coverage, validation, and next
+commands; it does not crawl, discover credentials, or commit tests.
 
 ## Scenario Pattern
 

package/src/cli_discover.zig

@@ -0,0 +1,239 @@
+const std = @import("std");
+
+const cli_draft = @import("cli_draft.zig");
+const cli_output = @import("cli_output.zig");
+const trace = @import("trace.zig");
+const validation = @import("validation.zig");
+const version = @import("version.zig");
+
+pub const ParsedArgs = struct {
+    from_trace: ?[]const u8 = null,
+    out_path: ?[]const u8 = null,
+    name: ?[]const u8 = null,
+    app_id: ?[]const u8 = null,
+    include_actions: bool = false,
+    validate: bool = false,
+    force: bool = false,
+    json: bool = false,
+};
+
+pub const DiscoverSummary = struct {
+    ok: bool,
+    draft: cli_draft.DraftSummary,
+    validated: bool,
+};
+
+pub const JsonOptions = struct {
+    mode: []const u8 = "discover",
+    goal: ?[]const u8 = null,
+    autonomous: ?bool = null,
+    review_required: ?bool = null,
+    guardrails: []const []const u8 = &.{},
+};
+
+pub const OwnedDiscover = struct {
+    draft: cli_draft.OwnedDraft,
+    validation: ?validation.Result = null,
+    summary: DiscoverSummary,
+
+    pub fn deinit(self: *OwnedDiscover, allocator: std.mem.Allocator) void {
+        if (self.validation) |result| result.deinit(allocator);
+        self.draft.deinit(allocator);
+    }
+};
+
+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, "--from-trace")) {
+            index += 1;
+            parsed.from_trace = if (index < args.len) args[index] else return error.MissingTraceDir;
+        } else if (std.mem.eql(u8, arg, "--out")) {
+            index += 1;
+            parsed.out_path = if (index < args.len) args[index] else return error.MissingDraftOut;
+        } else if (std.mem.eql(u8, arg, "--name")) {
+            index += 1;
+            parsed.name = if (index < args.len) args[index] else return error.MissingParam;
+        } 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, "--include-actions")) {
+            parsed.include_actions = true;
+        } else if (std.mem.eql(u8, arg, "--validate")) {
+            parsed.validate = true;
+        } 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.from_trace == null) return error.MissingTraceDir;
+    if (parsed.out_path == null) return error.MissingDraftOut;
+    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);
+    var discovered = try discoverFromTrace(allocator, parsed);
+    defer discovered.deinit(allocator);
+
+    const stdout = std.fs.File.stdout().deprecatedWriter();
+    if (parsed.json) {
+        try writeJson(stdout, discovered.summary, discovered.validation);
+    } else {
+        try stdout.print("wrote {s}\n", .{discovered.summary.draft.out_path});
+        if (discovered.validation) |result| {
+            if (result.ok) {
+                try stdout.print("validated {s}\n", .{discovered.summary.draft.out_path});
+            } else {
+                try stdout.print("validation failed {s}\n", .{discovered.summary.draft.out_path});
+            }
+        }
+        try stdout.writeAll("next: zmr validate --json ");
+        try cli_output.writeShellArg(stdout, discovered.summary.draft.out_path);
+        try stdout.writeAll("\n");
+    }
+    if (!discovered.summary.ok) std.process.exit(1);
+}
+
+pub fn discoverFromTrace(allocator: std.mem.Allocator, parsed: ParsedArgs) !OwnedDiscover {
+    var draft = try cli_draft.draftFromTrace(allocator, .{
+        .from_trace = parsed.from_trace,
+        .out_path = parsed.out_path,
+        .name = parsed.name,
+        .app_id = parsed.app_id,
+        .include_actions = parsed.include_actions,
+        .force = parsed.force,
+        .json = parsed.json,
+    });
+    errdefer draft.deinit(allocator);
+
+    var validation_result: ?validation.Result = null;
+    errdefer if (validation_result) |result| result.deinit(allocator);
+    if (parsed.validate) {
+        validation_result = try validation.validateFile(allocator, draft.summary.out_path);
+    }
+
+    const ok = draft.summary.ok and (validation_result == null or validation_result.?.ok);
+    return .{
+        .draft = draft,
+        .validation = validation_result,
+        .summary = .{
+            .ok = ok,
+            .draft = draft.summary,
+            .validated = parsed.validate,
+        },
+    };
+}
+
+pub fn writeJson(writer: anytype, summary: DiscoverSummary, validation_result: ?validation.Result) !void {
+    try writeJsonWithOptions(writer, summary, validation_result, .{});
+}
+
+pub fn writeJsonWithOptions(writer: anytype, summary: DiscoverSummary, validation_result: ?validation.Result, options: JsonOptions) !void {
+    const draft = summary.draft;
+    try writer.writeAll("{\"ok\":");
+    try writer.writeAll(if (summary.ok) "true" else "false");
+    try writer.writeAll(",\"mode\":");
+    try trace.writeJsonString(writer, options.mode);
+    try writer.writeAll(",\"schemaVersion\":1");
+    try writer.writeAll(",\"runnerVersion\":");
+    try trace.writeJsonString(writer, version.runner_version);
+    try writer.writeAll(",\"protocolVersion\":");
+    try trace.writeJsonString(writer, version.protocol_version);
+    if (options.goal) |goal| {
+        try writer.writeAll(",\"goal\":");
+        try trace.writeJsonString(writer, goal);
+    }
+    if (options.autonomous) |autonomous| {
+        try writer.writeAll(",\"autonomous\":");
+        try writer.writeAll(if (autonomous) "true" else "false");
+    }
+    if (options.review_required) |review_required| {
+        try writer.writeAll(",\"reviewRequired\":");
+        try writer.writeAll(if (review_required) "true" else "false");
+    }
+    if (options.guardrails.len > 0) {
+        try writer.writeAll(",\"guardrails\":[");
+        for (options.guardrails, 0..) |guardrail, index| {
+            if (index > 0) try writer.writeAll(",");
+            try trace.writeJsonString(writer, guardrail);
+        }
+        try writer.writeAll("]");
+    }
+    try writer.writeAll(",\"out\":");
+    try trace.writeJsonString(writer, draft.out_path);
+    try writer.writeAll(",\"traceDir\":");
+    try trace.writeJsonString(writer, draft.trace_dir);
+    try writer.writeAll(",\"sourceSnapshot\":");
+    try trace.writeJsonString(writer, draft.source_snapshot);
+    try writer.writeAll(",\"name\":");
+    try trace.writeJsonString(writer, draft.name);
+    try writer.writeAll(",\"appId\":");
+    if (draft.app_id) |actual| {
+        try trace.writeJsonString(writer, actual);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.print(",\"selectorCount\":{d},\"stepCount\":{d}", .{ draft.selector_count, draft.step_count });
+    try cli_draft.writeReplayJson(writer, draft.replay);
+    try writer.writeAll(",\"warnings\":[");
+    for (draft.warnings, 0..) |warning, index| {
+        if (index > 0) try writer.writeAll(",");
+        try trace.writeJsonString(writer, warning);
+    }
+    try writer.writeAll("],\"validated\":");
+    try writer.writeAll(if (summary.validated) "true" else "false");
+    try writer.writeAll(",\"validation\":");
+    if (validation_result) |result| {
+        try writeValidationObject(writer, draft.out_path, result);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"nextCommands\":[\"zmr validate --json ");
+    try cli_output.writeShellArgJsonContent(writer, draft.out_path);
+    try writer.writeAll("\",\"zmr run ");
+    try cli_output.writeShellArgJsonContent(writer, draft.out_path);
+    try writer.writeAll(" --json --trace-dir ");
+    try cli_output.writeShellArgJsonContent(writer, draft.trace_dir);
+    try writer.writeAll("\"]}\n");
+}
+
+fn writeValidationObject(writer: anytype, path: []const u8, result: validation.Result) !void {
+    try writer.writeAll("{\"ok\":");
+    try writer.writeAll(if (result.ok) "true" else "false");
+    try writer.writeAll(",\"path\":");
+    try trace.writeJsonString(writer, path);
+    if (result.ok) {
+        try writer.writeAll(",\"name\":");
+        try trace.writeJsonString(writer, result.name.?);
+        try writer.writeAll(",\"appId\":");
+        if (result.app_id) |app_id| {
+            try trace.writeJsonString(writer, app_id);
+        } else {
+            try writer.writeAll("null");
+        }
+        try writer.print(",\"stepCount\":{d}", .{result.step_count});
+    } else {
+        try writer.writeAll(",\"errorCode\":");
+        try trace.writeJsonString(writer, result.error_code.?);
+        try writer.writeAll(",\"message\":");
+        try trace.writeJsonString(writer, result.message.?);
+        if (result.path) |field_path| {
+            try writer.writeAll(",\"fieldPath\":");
+            try trace.writeJsonString(writer, field_path);
+        }
+        if (result.line) |line| try writer.print(",\"line\":{d}", .{line});
+        if (result.column) |column| try writer.print(",\"column\":{d}", .{column});
+    }
+    try writer.writeAll("}");
+}