zeno-mobile-runner 0.1.3 → 0.2.0

package/src/json_rpc_trace.zig

@@ -1,5 +1,9 @@
 const std = @import("std");
+const cli_discover = @import("cli_discover.zig");
+const cli_explore = @import("cli_explore.zig");
 const protocol = @import("json_rpc_protocol.zig");
+const report = @import("report.zig");
+const runner_events = @import("runner_events.zig");
 const trace = @import("trace.zig");
 
 pub fn writeEventsResult(
@@ -71,3 +75,111 @@ pub fn recordSimplePayload(tw: *trace.TraceWriter, kind: []const u8, key: []cons
     try writer.writeAll("}");
     try tw.recordEvent(kind, payload.items);
 }
+
+pub fn writeDiscoverResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+    out_path: []const u8,
+    include_actions: bool,
+    validate: bool,
+    force: bool,
+    name: ?[]const u8,
+    app_id: ?[]const u8,
+) !void {
+    const tw = live_trace orelse {
+        try protocol.writeResultRaw(writer, id, "{\"ok\":false,\"mode\":\"discover\",\"traceDir\":null,\"message\":\"start zmr serve with --trace-dir to enable live trace discovery\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var discovered = try cli_discover.discoverFromTrace(allocator, .{
+        .from_trace = tw.root_dir,
+        .out_path = out_path,
+        .name = name,
+        .app_id = app_id,
+        .include_actions = include_actions,
+        .validate = validate,
+        .force = force,
+        .json = true,
+    });
+    defer discovered.deinit(allocator);
+    try runner_events.recordTraceDiscover(
+        tw,
+        if (discovered.summary.ok) "ok" else "failed",
+        discovered.summary.draft.out_path,
+        include_actions,
+        discovered.summary.validated,
+    );
+
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try cli_discover.writeJson(payload.writer(allocator), discovered.summary, discovered.validation);
+    try protocol.writeResultRaw(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+}
+
+pub fn writeExploreResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+    out_path: []const u8,
+    goal: []const u8,
+    include_actions: bool,
+    validate: bool,
+    force: bool,
+    name: ?[]const u8,
+    app_id: ?[]const u8,
+) !void {
+    const tw = live_trace orelse {
+        try protocol.writeResultRaw(writer, id, "{\"ok\":false,\"mode\":\"explore\",\"traceDir\":null,\"message\":\"start zmr serve with --trace-dir to enable live trace exploration\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var explored = try cli_explore.exploreFromTrace(allocator, .{
+        .from_trace = tw.root_dir,
+        .out_path = out_path,
+        .goal = goal,
+        .name = name,
+        .app_id = app_id,
+        .include_actions = include_actions,
+        .validate = validate,
+        .force = force,
+        .json = true,
+    });
+    defer explored.deinit(allocator);
+    try runner_events.recordTraceExplore(
+        tw,
+        if (explored.summary.ok) "ok" else "failed",
+        explored.discovered.summary.draft.out_path,
+        goal,
+        include_actions,
+        explored.discovered.summary.validated,
+    );
+
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try cli_explore.writeJson(payload.writer(allocator), explored.summary, explored.discovered.summary, explored.discovered.validation);
+    try protocol.writeResultRaw(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+}
+
+pub fn writeExplainResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    live_trace: ?*trace.TraceWriter,
+) !void {
+    const tw = live_trace orelse {
+        try protocol.writeResultRaw(writer, id, "{\"traceDir\":null,\"message\":\"start zmr serve with --trace-dir to enable live RPC trace explanation\"}");
+        return;
+    };
+
+    try tw.flushManifest();
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    try report.writeTraceExplanationJson(allocator, tw.root_dir, payload.writer(allocator));
+    try protocol.writeResultRaw(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+    try tw.recordEvent("trace.explain", "{\"status\":\"ok\"}");
+}

package/src/main.zig

@@ -1,9 +1,13 @@
 const std = @import("std");
 const cli_devices = @import("cli_devices.zig");
+const cli_discover = @import("cli_discover.zig");
 const cli_doctor = @import("cli_doctor.zig");
+const cli_draft = @import("cli_draft.zig");
+const cli_explore = @import("cli_explore.zig");
 const cli_info = @import("cli_info.zig");
 const cli_init = @import("cli_init.zig");
 const cli_import = @import("cli_import.zig");
+const cli_inspect = @import("cli_inspect.zig");
 const cli_run = @import("cli_run.zig");
 const cli_serve = @import("cli_serve.zig");
 const cli_trace = @import("cli_trace.zig");
@@ -40,12 +44,20 @@ fn mainInner() !void {
         try cli_info.runSchemas(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "doctor")) {
         try cli_doctor.run(allocator, &args);
+    } else if (std.mem.eql(u8, command_name, "discover")) {
+        try cli_discover.run(allocator, &args);
+    } else if (std.mem.eql(u8, command_name, "draft")) {
+        try cli_draft.run(allocator, &args);
+    } else if (std.mem.eql(u8, command_name, "explore")) {
+        try cli_explore.run(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "validate")) {
         try cli_validate.run(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "init")) {
         try cli_init.run(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "import")) {
         try cli_import.run(allocator, &args);
+    } else if (std.mem.eql(u8, command_name, "inspect")) {
+        try cli_inspect.run(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "run")) {
         try cli_run.run(allocator, &args);
     } else if (std.mem.eql(u8, command_name, "report")) {
@@ -76,6 +88,9 @@ fn writeTopLevelError(err: anyerror) void {
     if (err == error.CommandFailed) {
         stderr.writeAll("hint: run `zmr doctor --json` for setup diagnostics.\n") catch {};
     }
+    if (err == error.UnknownFlag) {
+        stderr.writeAll("hint: run `zmr help` for each command's flags and arguments.\n") catch {};
+    }
 }
 
 fn exitCodeForError(err: anyerror) u8 {
@@ -85,6 +100,12 @@ fn exitCodeForError(err: anyerror) u8 {
         error.MissingScenarioPath,
         error.MissingDeviceSerial,
         error.MissingTraceDir,
+        error.MissingReportInput,
+        error.MissingReportOutput,
+        error.MissingDraftOut,
+        error.MissingDiscoverOut,
+        error.MissingJUnitOutput,
+        error.MissingTraceBundleOutput,
         error.MissingAppId,
         error.MissingAdbPath,
         error.MissingXcrunPath,
@@ -110,12 +131,16 @@ fn usage() !void {
         \\  zmr schemas [--json]
         \\  zmr devices [--json] [--platform android|ios] [--ios-device-type simulator|physical|all] [--adb <path>] [--xcrun <path>]
         \\  zmr doctor [--json] [--strict] [--config <path>] [--zig <path>] [--adb <path>] [--android-shim <path>] [--xcrun <path>] [--ios-shim <path>]
+        \\  zmr discover --from-trace <trace-dir> --out <scenario.json> [--include-actions] [--validate] [--name <name>] [--app-id <id>] [--force] [--json]
+        \\  zmr draft --from-trace <trace-dir> --out <scenario.json> [--include-actions] [--name <name>] [--app-id <id>] [--force] [--json]
+        \\  zmr explore --from-trace <trace-dir> --out <scenario.json> [--goal <goal>] [--include-actions] [--validate] [--name <name>] [--app-id <id>] [--force] [--json]
         \\  zmr validate <scenario.json> [--json]
         \\  zmr init [scenario.json] [--app-id <id>] [--force] [--json]
         \\  zmr init --app [--dir <app-root>] [--app-id <id>] [--force] [--json]
         \\  zmr import flow-yaml <flow.yaml> --out <scenario.json> [--name <name>] [--app-id <id>] [--force] [--json]
-        \\  zmr run [scenario.json] [--json] [--config <path>] [--platform android|ios] [--ios-device-type simulator|physical] [--device <serial>] [--app-id <id>] [--trace-dir <path>] [--android-avd <name>] [--create-avd-if-missing] [--avd-system-image <pkg>] [--avd-device <profile>] [--restore-snapshot <name>] [--reset-emulator] [--wait-emulator] [--screen-record] [--no-screen-record] [--adb <path>] [--emulator <path>] [--avdmanager <path>] [--android-shim <path>] [--xcrun <path>] [--ios-shim <path>]
-        \\  zmr report <trace-or-benchmark-dir> --out <report.html>
+        \\  zmr inspect [--json] [--dir <app-root>] [--config <path>]
+        \\  zmr run [scenario.json] [--json] [--config <path>] [--platform android|ios] [--ios-device-type simulator|physical] [--device <serial>] [--app-id <id>] [--trace-dir <path>] [--discover-out <scenario.json>] [--android-avd <name>] [--create-avd-if-missing] [--avd-system-image <pkg>] [--avd-device <profile>] [--restore-snapshot <name>] [--reset-emulator] [--wait-emulator] [--screen-record] [--no-screen-record] [--adb <path>] [--emulator <path>] [--avdmanager <path>] [--android-shim <path>] [--xcrun <path>] [--ios-shim <path>]
+        \\  zmr report <trace-or-benchmark-dir> --out <report.html> [--junit <report.xml>]
         \\  zmr explain <trace-dir> [--json]
         \\  zmr export <trace-dir> --out <bundle.zmrtrace> [--redact] [--omit-screenshots]
         \\  zmr serve --transport stdio [--config <path>] [--platform android|ios] [--ios-device-type simulator|physical] [--device <serial>] [--app-id <id>] [--trace-dir <path>] [--adb <path>] [--android-shim <path>] [--xcrun <path>] [--ios-shim <path>]

package/src/mcp.zig

@@ -1,11 +1,16 @@
 const std = @import("std");
+const cli_output = @import("cli_output.zig");
 const errors = @import("errors.zig");
 const mcp_protocol = @import("mcp_protocol.zig");
 const mcp_trace = @import("mcp_trace.zig");
+const params_parser = @import("json_rpc_params.zig");
+const rpc_trace = @import("json_rpc_trace.zig");
 const runner = @import("runner.zig");
+const runner_events = @import("runner_events.zig");
 const selector = @import("selector.zig");
 const semantic = @import("semantic.zig");
 const trace = @import("trace.zig");
+const validation = @import("validation.zig");
 
 pub fn serveStdioWithTrace(allocator: std.mem.Allocator, device: anytype, live_trace: ?*trace.TraceWriter) !void {
     var stdin = std.fs.File.stdin().deprecatedReader();
@@ -128,6 +133,35 @@ fn callTool(
         return;
     }
 
+    if (std.mem.eql(u8, tool_name, "install_app")) {
+        const path = try requiredParamString(arguments, "path");
+        try device.install(path);
+        if (live_trace) |tw| try rpc_trace.recordSimplePayload(tw, "app.install", "path", path);
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "launch_app")) {
+        try device.launch();
+        if (live_trace) |tw| try tw.recordEvent("app.launch", "{\"status\":\"ok\"}");
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "stop_app")) {
+        try device.stop();
+        if (live_trace) |tw| try tw.recordEvent("app.stop", "{\"status\":\"ok\"}");
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "clear_state")) {
+        try device.clearState();
+        if (live_trace) |tw| try tw.recordEvent("app.clearState", "{\"status\":\"ok\"}");
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
     if (std.mem.eql(u8, tool_name, "tap")) {
         const wanted = try parseArgumentsSelector(allocator, arguments);
         defer wanted.deinit(allocator);
@@ -144,6 +178,44 @@ fn callTool(
             try runner.typeTextSelector(device, wanted, text, live_trace, .{});
         } else {
             try device.typeText(text);
+            if (live_trace) |tw| try rpc_trace.recordSimplePayload(tw, "ui.type", "text", text);
+        }
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "swipe")) {
+        const x1 = try params_parser.requiredI32(arguments, "x1");
+        const y1 = try params_parser.requiredI32(arguments, "y1");
+        const x2 = try params_parser.requiredI32(arguments, "x2");
+        const y2 = try params_parser.requiredI32(arguments, "y2");
+        const duration_ms = @as(u32, @intCast(try optionalParamU64(arguments, "durationMs", 300)));
+        try device.swipe(x1, y1, x2, y2, duration_ms);
+        if (live_trace) |tw| try runner_events.recordSwipe(tw, x1, y1, x2, y2, duration_ms);
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "hide_keyboard")) {
+        try device.hideKeyboard();
+        if (live_trace) |tw| try tw.recordEvent("ui.hideKeyboard", "{\"status\":\"ok\"}");
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "erase_text")) {
+        const max_chars = @as(u32, @intCast(try optionalParamU64(arguments, "maxChars", 80)));
+        if (paramField(arguments, "selector")) |selector_value| {
+            const wanted = try selector.parseFromJson(allocator, selector_value);
+            defer wanted.deinit(allocator);
+            try runner.eraseTextSelector(device, wanted, max_chars, live_trace, .{});
+        } else {
+            try device.eraseText(max_chars);
+            if (live_trace) |tw| {
+                const payload = try std.fmt.allocPrint(tw.allocator, "{{\"maxChars\":{d}}}", .{max_chars});
+                defer tw.allocator.free(payload);
+                try tw.recordEvent("ui.eraseText", payload);
+            }
         }
         try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
         return;
@@ -151,12 +223,15 @@ fn callTool(
 
     if (std.mem.eql(u8, tool_name, "press_back")) {
         try device.pressBack();
+        if (live_trace) |tw| try tw.recordEvent("ui.pressBack", "{\"status\":\"ok\"}");
         try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
         return;
     }
 
     if (std.mem.eql(u8, tool_name, "open_link")) {
-        try device.openLink(try requiredParamString(arguments, "url"));
+        const url = try requiredParamString(arguments, "url");
+        try device.openLink(url);
+        if (live_trace) |tw| try runner_events.recordActionStatus(tw, "app.openLink", "ok", null, url);
         try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
         return;
     }
@@ -166,11 +241,80 @@ fn callTool(
         defer wanted.deinit(allocator);
         const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
         const visible = try runner.waitUntilVisible(device, wanted, timeout_ms, live_trace, .{});
-        try writer.writeAll("{\"jsonrpc\":\"2.0\",\"id\":");
-        try mcp_protocol.writeId(writer, id);
-        try writer.writeAll(",\"result\":{\"content\":[{\"type\":\"text\",\"text\":\"{\\\"visible\\\":");
-        try writer.writeAll(if (visible) "true" else "false");
-        try writer.writeAll("}\"}]}}\n");
+        try writeVisibleToolResult(writer, id, visible);
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "wait_not_visible")) {
+        const wanted = try parseArgumentsSelector(allocator, arguments);
+        defer wanted.deinit(allocator);
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
+        const gone = try runner.waitUntilNotVisible(device, wanted, timeout_ms, live_trace, .{});
+        try writeVisibleToolResult(writer, id, !gone);
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "wait_any")) {
+        const selectors = try params_parser.selectors(allocator, arguments);
+        defer {
+            for (selectors) |wanted| wanted.deinit(allocator);
+            allocator.free(selectors);
+        }
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
+        const matched = try runner.waitUntilAnyVisible(device, selectors, timeout_ms, live_trace, .{});
+        try writeMatchedIndexToolResult(allocator, writer, id, matched);
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "scroll_until_visible")) {
+        const wanted = try parseArgumentsSelector(allocator, arguments);
+        defer wanted.deinit(allocator);
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
+        const visible = try runner.scrollUntilVisible(
+            device,
+            wanted,
+            timeout_ms,
+            try params_parser.optionalDirection(arguments, "direction", .down),
+            live_trace,
+            .{},
+        );
+        try writeVisibleToolResult(writer, id, visible);
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "assert_visible")) {
+        const wanted = try parseArgumentsSelector(allocator, arguments);
+        defer wanted.deinit(allocator);
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
+        if (!try runner.assertVisible(device, wanted, timeout_ms, live_trace, .{})) return error.AssertionFailed;
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "assert_not_visible")) {
+        const wanted = try parseArgumentsSelector(allocator, arguments);
+        defer wanted.deinit(allocator);
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 5000);
+        if (!try runner.assertNotVisible(device, wanted, timeout_ms, live_trace, .{})) return error.AssertionFailed;
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "assert_healthy")) {
+        const timeout_ms = try optionalParamU64(arguments, "timeoutMs", 0);
+        if (!try runner.assertHealthy(device, timeout_ms, live_trace, .{})) return error.AssertionFailed;
+        try mcp_protocol.writeToolTextResult(writer, id, "{\"ok\":true}");
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "scenario_validate")) {
+        const path = try requiredParamString(arguments, "path");
+        var result = try validation.validateFile(allocator, path);
+        defer result.deinit(allocator);
+        var payload = std.ArrayList(u8).empty;
+        defer payload.deinit(allocator);
+        try cli_output.writeValidationJson(payload.writer(allocator), path, result);
+        try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
         return;
     }
 
@@ -179,6 +323,44 @@ fn callTool(
         return;
     }
 
+    if (std.mem.eql(u8, tool_name, "trace_discover")) {
+        try mcp_trace.writeDiscoverToolResult(
+            allocator,
+            writer,
+            id,
+            live_trace,
+            try requiredParamString(arguments, "out"),
+            try optionalParamBool(arguments, "includeActions", false),
+            try optionalParamBool(arguments, "validate", false),
+            try optionalParamBool(arguments, "force", false),
+            optionalParamString(arguments, "name"),
+            optionalParamString(arguments, "appId"),
+        );
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "trace_explore")) {
+        try mcp_trace.writeExploreToolResult(
+            allocator,
+            writer,
+            id,
+            live_trace,
+            try requiredParamString(arguments, "out"),
+            try requiredParamString(arguments, "goal"),
+            try optionalParamBool(arguments, "includeActions", false),
+            try optionalParamBool(arguments, "validate", false),
+            try optionalParamBool(arguments, "force", false),
+            optionalParamString(arguments, "name"),
+            optionalParamString(arguments, "appId"),
+        );
+        return;
+    }
+
+    if (std.mem.eql(u8, tool_name, "trace_explain")) {
+        try mcp_trace.writeExplainToolResult(allocator, writer, id, live_trace);
+        return;
+    }
+
     if (std.mem.eql(u8, tool_name, "trace_export")) {
         const out_path = try requiredParamString(arguments, "out");
         const omit_screenshots = try optionalParamBool(arguments, "omitScreenshots", false);
@@ -190,6 +372,27 @@ fn callTool(
     try mcp_protocol.writeError(writer, id, -32602, "unknown tool");
 }
 
+fn writeVisibleToolResult(writer: anytype, id: ?std.json.Value, visible: bool) !void {
+    try mcp_protocol.writeToolTextResult(writer, id, if (visible) "{\"visible\":true}" else "{\"visible\":false}");
+}
+
+fn writeMatchedIndexToolResult(
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    id: ?std.json.Value,
+    matched: ?usize,
+) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(allocator);
+    const payload_writer = payload.writer(allocator);
+    if (matched) |index| {
+        try payload_writer.print("{{\"matchedIndex\":{d}}}", .{index});
+    } else {
+        try payload_writer.writeAll("{\"matchedIndex\":null}");
+    }
+    try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+}
+
 fn parseArgumentsSelector(allocator: std.mem.Allocator, arguments: ?std.json.Value) !selector.Selector {
     const selector_value = paramField(arguments, "selector") orelse return error.MissingSelector;
     return try selector.parseFromJson(allocator, selector_value);

package/src/mcp_protocol.zig

@@ -61,4 +61,32 @@ pub fn writeId(writer: anytype, id: ?std.json.Value) !void {
     }
 }
 
-const tool_list_json = "{\"tools\":[" ++ "{\"name\":\"snapshot\",\"description\":\"Capture the current mobile observation snapshot as JSON.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++ "{\"name\":\"semantic_snapshot\",\"description\":\"Capture an agent-optimized mobile semantic tree with roles, names, selectors, bounds, and recommended actions.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++ "{\"name\":\"tap\",\"description\":\"Tap a visible element by selector.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"}}}}," ++ "{\"name\":\"type\",\"description\":\"Type text, optionally after focusing an element by selector.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"text\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"text\":{\"type\":\"string\"}}}}," ++ "{\"name\":\"press_back\",\"description\":\"Press Android back or the platform-equivalent navigation action.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++ "{\"name\":\"open_link\",\"description\":\"Open a deep link URL in the target app.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"url\"],\"properties\":{\"url\":{\"type\":\"string\"}}}}," ++ "{\"name\":\"wait_visible\",\"description\":\"Wait for an element selector to become visible.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++ "{\"name\":\"trace_events\",\"description\":\"Read live trace events from a traced MCP session.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{\"afterSeq\":{\"type\":\"integer\",\"minimum\":0},\"limit\":{\"type\":\"integer\",\"minimum\":1}}}}," ++ "{\"name\":\"trace_export\",\"description\":\"Export the active trace directory as a .zmrtrace bundle.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"out\"],\"properties\":{\"out\":{\"type\":\"string\"},\"redact\":{\"type\":\"boolean\"},\"omitScreenshots\":{\"type\":\"boolean\"}}}}" ++ "]}";
+const tool_list_json =
+    "{\"tools\":[" ++
+    "{\"name\":\"snapshot\",\"description\":\"Capture the current mobile observation snapshot as JSON.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"semantic_snapshot\",\"description\":\"Capture an agent-optimized mobile semantic tree with roles, names, selectors, bounds, and recommended actions.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"install_app\",\"description\":\"Install an app artifact on the selected device.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"path\"],\"properties\":{\"path\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"launch_app\",\"description\":\"Launch the configured app on the selected device.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"stop_app\",\"description\":\"Stop the configured app on the selected device.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"clear_state\",\"description\":\"Clear the configured app state where the platform supports it.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"tap\",\"description\":\"Tap a visible element by selector.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"}}}}," ++
+    "{\"name\":\"type\",\"description\":\"Type text, optionally after focusing an element by selector.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"text\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"text\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"hide_keyboard\",\"description\":\"Dismiss the software keyboard when the platform can do so.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"erase_text\",\"description\":\"Erase text, optionally after focusing an element by selector.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{\"selector\":{\"type\":\"object\"},\"maxChars\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"swipe\",\"description\":\"Swipe between absolute screen coordinates.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"x1\",\"y1\",\"x2\",\"y2\"],\"properties\":{\"x1\":{\"type\":\"integer\"},\"y1\":{\"type\":\"integer\"},\"x2\":{\"type\":\"integer\"},\"y2\":{\"type\":\"integer\"},\"durationMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"press_back\",\"description\":\"Press Android back or the platform-equivalent navigation action.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"open_link\",\"description\":\"Open a deep link URL in the target app.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"url\"],\"properties\":{\"url\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"wait_visible\",\"description\":\"Wait for an element selector to become visible.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"wait_not_visible\",\"description\":\"Wait for an element selector to no longer be visible.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"wait_any\",\"description\":\"Wait for the first visible selector from an ordered selector list.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selectors\"],\"properties\":{\"selectors\":{\"type\":\"array\",\"minItems\":1,\"items\":{\"type\":\"object\"}},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"scroll_until_visible\",\"description\":\"Scroll until an element selector is visible.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"direction\":{\"type\":\"string\",\"enum\":[\"down\",\"up\"]},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"assert_visible\",\"description\":\"Assert that an element selector is visible within the timeout.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"assert_not_visible\",\"description\":\"Assert that an element selector is not visible within the timeout.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"selector\"],\"properties\":{\"selector\":{\"type\":\"object\"},\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"assert_healthy\",\"description\":\"Assert that the app is free of common crash and error overlays.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{\"timeoutMs\":{\"type\":\"integer\",\"minimum\":0}}}}," ++
+    "{\"name\":\"scenario_validate\",\"description\":\"Validate a ZMR scenario file and return structured diagnostics.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"path\"],\"properties\":{\"path\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"trace_events\",\"description\":\"Read live trace events from a traced MCP session.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{\"afterSeq\":{\"type\":\"integer\",\"minimum\":0},\"limit\":{\"type\":\"integer\",\"minimum\":1}}}}," ++
+    "{\"name\":\"trace_explain\",\"description\":\"Summarize the active trace status, failure, diagnostics, and next commands.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"properties\":{}}}," ++
+    "{\"name\":\"trace_explore\",\"description\":\"Generate a review-required scenario draft for a stated goal from the active trace directory.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"out\",\"goal\"],\"properties\":{\"out\":{\"type\":\"string\"},\"goal\":{\"type\":\"string\"},\"includeActions\":{\"type\":\"boolean\"},\"validate\":{\"type\":\"boolean\"},\"force\":{\"type\":\"boolean\"},\"name\":{\"type\":\"string\"},\"appId\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"trace_discover\",\"description\":\"Generate a reviewable scenario draft from the active trace directory.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"out\"],\"properties\":{\"out\":{\"type\":\"string\"},\"includeActions\":{\"type\":\"boolean\"},\"validate\":{\"type\":\"boolean\"},\"force\":{\"type\":\"boolean\"},\"name\":{\"type\":\"string\"},\"appId\":{\"type\":\"string\"}}}}," ++
+    "{\"name\":\"trace_export\",\"description\":\"Export the active trace directory as a .zmrtrace bundle.\",\"inputSchema\":{\"type\":\"object\",\"additionalProperties\":false,\"required\":[\"out\"],\"properties\":{\"out\":{\"type\":\"string\"},\"redact\":{\"type\":\"boolean\"},\"omitScreenshots\":{\"type\":\"boolean\"}}}}" ++
+    "]}";