Lightpanda: the headless browser designed for AI and automation
WebDriver: add various basic WebDriver APIs
Karl Seguin18dcb8ac63fb
diff --git a/src/server/Server.zig b/src/server/Server.zigindex c0b3f6f8a..44c8f47d8 100644--- a/src/server/Server.zig+++ b/src/server/Server.zig@@ -1977,14 +1977,14 @@ test "server: HTTP navigate" {var c = try createTestClient();defer c.deinit();{- const res = try sessionCommand(&c, &session_id, "/url", "not json");+ const res = try sessionCommand(&c, "POST", &session_id, "/url", "not json");try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 400 Bad Request\r\n"));try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"invalid argument\",\"message\":\"invalid body\",\"stacktrace\":\"\"}}"));}const url = "http://127.0.0.1:9582/src/browser/tests/cdp/dom2.html";{- const res = try sessionCommand(&c, &session_id, "/url", "{\"url\":\"" ++ url ++ "\"}");+ const res = try sessionCommand(&c, "POST", &session_id, "/url", "{\"url\":\"" ++ url ++ "\"}");try testing.expectEqual("HTTP/1.1 200 OK\r\n" ++"Content-Length: 14\r\n" ++"Content-Type: application/json; charset=UTF-8\r\n\r\n" ++@@ -2002,11 +2002,98 @@ test "server: HTTP navigate" {try testing.expect(std.mem.indexOf(u8, msg.data, "\"url\":\"" ++ url ++ "\"") != null);}+test "server: HTTP page commands" {+ const session_id = try createHTTPSession("{\"capabilities\":{}}", false);+ defer deleteHTTPSession(&session_id, true) catch |err| @panic(@errorName(err));++ var c = try createTestClient();+ defer c.deinit();++ // the browsing context is opened by the first command that needs it+ try testing.expectEqual("{\"value\":\"about:blank\"}", responseBody(try sessionCommand(&c, "GET", &session_id, "/url", "")));++ const handle = blk: {+ const body = responseBody(try sessionCommand(&c, "GET", &session_id, "/window", ""));+ try testing.expect(std.mem.startsWith(u8, body, "{\"value\":\""));+ break :blk try testing.arena_allocator.dupe(u8, body[10..46]);+ };+ {+ const body = responseBody(try sessionCommand(&c, "GET", &session_id, "/window/handles", ""));+ try testing.expectEqual(try std.fmt.allocPrint(testing.arena_allocator, "{{\"value\":[\"{s}\"]}}", .{handle}), body);+ }++ const url = "http://127.0.0.1:9582/src/browser/tests/bidi/input.html";+ try testing.expectEqual("{\"value\":null}", responseBody(try sessionCommand(&c, "POST", &session_id, "/url", "{\"url\":\"" ++ url ++ "\"}")));+ try testing.expectEqual("{\"value\":\"" ++ url ++ "\"}", responseBody(try sessionCommand(&c, "GET", &session_id, "/url", "")));+ try testing.expectEqual("{\"value\":\"bidi input\"}", responseBody(try sessionCommand(&c, "GET", &session_id, "/title", "")));+ {+ const body = responseBody(try sessionCommand(&c, "GET", &session_id, "/source", ""));+ try testing.expect(std.mem.startsWith(u8, body, "{\"value\":\"<!DOCTYPE html>\\n<html><head><title>bidi input</title>"));+ }+ {+ const res = try c.httpRequestAlloc(try std.fmt.allocPrint(testing.arena_allocator, "GET /session/{s}/screenshot HTTP/1.1\r\n\r\n", .{&session_id}));+ defer testing.allocator.free(res);+ // base64 of the PNG signature+ try testing.expect(std.mem.startsWith(u8, responseBody(res), "{\"value\":\"iVBORw0KGgo"));+ }++ // a click on the button, then a held key. The element origin is+ // resolved after the pause parks the actions.+ {+ const actions = "{\"actions\":[" +++ "{\"type\":\"pointer\",\"id\":\"mouse\",\"parameters\":{\"pointerType\":\"mouse\"},\"actions\":[" +++ "{\"type\":\"pause\",\"duration\":20}," +++ "{\"type\":\"pointerMove\",\"x\":0,\"y\":0,\"origin\":{\"" ++ http_command.element_key ++ "\":\"1\"}}," +++ "{\"type\":\"pointerDown\",\"button\":0},{\"type\":\"pointerUp\",\"button\":0}]}," +++ "{\"type\":\"key\",\"id\":\"kb\",\"actions\":[{\"type\":\"pause\"},{\"type\":\"pause\"},{\"type\":\"pause\"},{\"type\":\"keyDown\",\"value\":\"a\"}]}]}";++ // an element reference is a sharedId, so take #btn's over BiDi+ var ws = try createTestClient();+ defer ws.deinit();+ var path_buf: [64]u8 = undefined;+ try ws.handshake(try std.fmt.bufPrint(&path_buf, "/session/{s}", .{&session_id}));+ try ws.bidiCommand(try std.fmt.allocPrint(testing.arena_allocator,+ \\{{"id":1,"method":"browsingContext.locateNodes","params":{{"context":"{s}","locator":{{"type":"css","value":"#btn"}}}}}}+ , .{handle}));+ try expectWebsocketContains(&ws, "\"sharedId\":\"1\"");++ try testing.expectEqual("{\"value\":null}", responseBody(try sessionCommand(&c, "POST", &session_id, "/actions", actions)));+ try testing.expectEqual("{\"value\":null}", responseBody(try sessionCommand(&c, "DELETE", &session_id, "/actions", "")));++ try ws.bidiCommand(try std.fmt.allocPrint(testing.arena_allocator,+ \\{{"id":2,"method":"script.evaluate","params":{{"expression":"window.events.join(' ')","awaitPromise":false,"target":{{"context":"{s}"}}}}}}+ , .{handle}));+ try expectWebsocketContains(&ws, "\"value\":\"mousemove@btn mousedown@btn mouseup@btn click@btn keydown:a@btn keyup:a@btn\"");+ }+ {+ const res = try sessionCommand(&c, "POST", &session_id, "/actions", "{\"actions\":[{\"type\":\"key\",\"id\":\"kb\",\"actions\":[{\"type\":\"keyDown\"}]}]}");+ try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 400 Bad Request\r\n"));+ try testing.expect(std.mem.indexOf(u8, res, "\"error\":\"invalid argument\"") != null);+ }++ // the reload lands on the same document+ try testing.expectEqual("{\"value\":null}", responseBody(try sessionCommand(&c, "POST", &session_id, "/refresh", "{}")));+ try testing.expectEqual("{\"value\":\"" ++ url ++ "\"}", responseBody(try sessionCommand(&c, "GET", &session_id, "/url", "")));+}++fn responseBody(res: []const u8) []const u8 {+ return res[std.mem.indexOf(u8, res, "\r\n\r\n").? + 4 ..];+}++fn expectWebsocketContains(ws: *TestClient, expected: []const u8) !void {+ const msg = try ws.readWebsocketMessage() orelse return error.NoMessage;+ defer if (msg.cleanup_fragment) ws.reader.cleanup();+ if (std.mem.indexOf(u8, msg.data, expected) == null) {+ std.debug.print("expected {s} in {s}\n", .{ expected, msg.data });+ return error.UnexpectedMessage;+ }+}+test "server: HTTP command errors" {{var c = try createTestClient();defer c.deinit();- const res = try sessionCommand(&c, "00000000-0000-4000-8000-000000000000", "/url", "{}");+ const res = try sessionCommand(&c, "POST", "00000000-0000-4000-8000-000000000000", "/url", "{}");try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 404 Not Found\r\n"));try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"invalid session id\",\"message\":\"no such session\",\"stacktrace\":\"\"}}"));}@@ -2018,14 +2105,14 @@ test "server: HTTP command errors" {var c = try createTestClient();defer c.deinit();var request_buf: [128]u8 = undefined;- const res = try c.httpRequest(try std.fmt.bufPrint(&request_buf, "GET /session/{s}/url HTTP/1.1\r\n\r\n", .{&session_id}));+ const res = try c.httpRequest(try std.fmt.bufPrint(&request_buf, "DELETE /session/{s}/url HTTP/1.1\r\n\r\n", .{&session_id}));try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 405 Method Not Allowed\r\n"));try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"unknown method\",\"message\":\"unknown method\",\"stacktrace\":\"\"}}"));}{var c = try createTestClient();defer c.deinit();- const res = try sessionCommand(&c, &session_id, "/nope", "{}");+ const res = try sessionCommand(&c, "POST", &session_id, "/nope", "{}");try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 404 Not Found\r\n"));try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"unknown command\",\"message\":\"unknown command\",\"stacktrace\":\"\"}}"));}@@ -2033,14 +2120,14 @@ test "server: HTTP command errors" {// a slow page keeps the navigate parked on the workervar slow = try createTestClient();defer slow.deinit();- try writeSessionCommand(&slow, &session_id, "/url", "{\"url\":\"http://127.0.0.1:9582/src/browser/tests/hi.html?delay_ms=500\"}");+ try writeSessionCommand(&slow, "POST", &session_id, "/url", "{\"url\":\"http://127.0.0.1:9582/src/browser/tests/hi.html?delay_ms=500\"}");lp.io.sleep(.fromMilliseconds(50), .awake) catch {};// one command at a time{var c = try createTestClient();defer c.deinit();- const res = try sessionCommand(&c, &session_id, "/url", "{\"url\":\"about:blank\"}");+ const res = try sessionCommand(&c, "POST", &session_id, "/url", "{\"url\":\"about:blank\"}");try testing.expect(std.mem.startsWith(u8, res, "HTTP/1.1 500 Internal Server Error\r\n"));try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"unknown error\",\"message\":\"a command is already in progress\",\"stacktrace\":\"\"}}"));}@@ -2052,14 +2139,14 @@ test "server: HTTP command errors" {try testing.expect(std.mem.endsWith(u8, res, "{\"value\":{\"error\":\"invalid session id\",\"message\":\"session ended\",\"stacktrace\":\"\"}}"));}-fn sessionCommand(c: *TestClient, session_id: *const [36]u8, command: []const u8, body: []const u8) ![]const u8 {- try writeSessionCommand(c, session_id, command, body);+fn sessionCommand(c: *TestClient, method: []const u8, session_id: *const [36]u8, command: []const u8, body: []const u8) ![]const u8 {+ try writeSessionCommand(c, method, session_id, command, body);return c.httpRequest("");}-fn writeSessionCommand(c: *TestClient, session_id: *const [36]u8, command: []const u8, body: []const u8) !void {+fn writeSessionCommand(c: *TestClient, method: []const u8, session_id: *const [36]u8, command: []const u8, body: []const u8) !void {var head_buf: [128]u8 = undefined;- try sys_net.writeAll(c.socket, try std.fmt.bufPrint(&head_buf, "POST /session/{s}{s} HTTP/1.1\r\nContent-Length: {d}\r\n\r\n", .{ session_id, command, body.len }));+ try sys_net.writeAll(c.socket, try std.fmt.bufPrint(&head_buf, "{s} /session/{s}{s} HTTP/1.1\r\nContent-Length: {d}\r\n\r\n", .{ method, session_id, command, body.len }));try sys_net.writeAll(c.socket, body);}diff --git a/src/server/bidi/BiDi.zig b/src/server/bidi/BiDi.zigindex 44affd688..badcd37bc 100644--- a/src/server/bidi/BiDi.zig+++ b/src/server/bidi/BiDi.zig@@ -426,6 +426,11 @@ pub const Command = struct {return self.bidi.replyResult(self.reply(), result);}+ pub fn sendDone(self: *Command) !void {+ self.answered = true;+ return self.bidi.replyDone(self.reply());+ }+pub fn sendError(self: *Command, code: []const u8, message: []const u8) !void {self.answered = true;return self.bidi.replyError(self.reply(), code, message);@@ -493,6 +498,14 @@ pub fn replyResult(self: *BiDi, reply: Reply, result: anytype) !void {}}+// A command's empty success: BiDi's {}, HTTP's null.+pub fn replyDone(self: *BiDi, reply: Reply) !void {+ switch (reply) {+ .bidi => |id| return self.sendResult(id, struct {}{}),+ .http => return self.respondHTTP(null),+ }+}+pub fn replyError(self: *BiDi, reply: Reply, code: []const u8, message: []const u8) !void {switch (reply) {.bidi => |id| return self.sendError(id, code, message),diff --git a/src/server/bidi/browsing_context.zig b/src/server/bidi/browsing_context.zigindex 03c0fa847..48c2bd18d 100644--- a/src/server/bidi/browsing_context.zig+++ b/src/server/bidi/browsing_context.zig@@ -200,13 +200,36 @@ pub const NavigateOpts = struct {};pub fn navigate(cmd: *BiDi.Command, ctx: *Context, opts: NavigateOpts) !void {- const bidi = cmd.bidi;- const frame = bidi.user_context.session.currentFrame() orelse {+ const frame = cmd.bidi.user_context.session.currentFrame() orelse {return cmd.sendError("unknown error", "no frame");};const encoded_url = URL.resolveNavigation(frame.call_arena, opts.url, .{}) catch {return cmd.sendError("invalid argument", "invalid url");};+ return startNavigation(cmd, ctx, frame, encoded_url, .{ .reason = .address_bar, .kind = .{ .push = null } }, opts.wait);+}++// Reloads the current document, replaying its method and body like CDP's+// Page.reload.+pub fn reload(cmd: *BiDi.Command, ctx: *Context, wait: NavigateOpts.Wait) !void {+ const frame = cmd.bidi.user_context.session.currentFrame() orelse {+ return cmd.sendError("unknown error", "no frame");+ };++ // the frame's arena, which these live in, is gone once the reload commits+ const arena = cmd.arena;+ const url = try arena.dupeZ(u8, frame.url);+ var nav_opts: Frame.NavigateOpts = .{ .reason = .address_bar, .kind = .reload };+ if (frame._navigated_options) |prev| {+ nav_opts.method = prev.method;+ nav_opts.body = if (prev.body) |b| try arena.dupe(u8, b) else null;+ nav_opts.header = if (prev.header) |h| try arena.dupeZ(u8, h) else null;+ }+ return startNavigation(cmd, ctx, frame, url, nav_opts, wait);+}++fn startNavigation(cmd: *BiDi.Command, ctx: *Context, frame: *Frame, url: [:0]const u8, nav_opts: Frame.NavigateOpts, wait: NavigateOpts.Wait) !void {+ const bidi = cmd.bidi;// A second navigate supersedes an in-flight one; answer the old command// so the client isn't left waiting on it forever.@@ -215,7 +238,7 @@ pub fn navigate(cmd: *BiDi.Command, ctx: *Context, opts: NavigateOpts) !void {// Set before starting: a navigation can reach its wait condition// synchronously (about:blank), which would fire the lifecycle callback// before we got a chance to record the pending command.- switch (opts.wait) {+ switch (wait) {.none => {},.interactive => ctx.pending_navigate = .{ .reply = cmd.takeReply(), .until = .interactive },.complete => ctx.pending_navigate = .{ .reply = cmd.takeReply(), .until = .complete },@@ -225,13 +248,13 @@ pub fn navigate(cmd: *BiDi.Command, ctx: *Context, opts: NavigateOpts) !void {// navigated has nothing to preserve, so it navigates in place; a live// page goes through the pending-Page replacement machinery.const nav_result = if (frame._load_state == .waiting)- frame.navigate(encoded_url, .{ .reason = .address_bar, .kind = .{ .push = null } })+ frame.navigate(url, nav_opts)else- bidi.user_context.session.initiateRootNavigation(frame._frame_id, encoded_url, .{ .reason = .address_bar, .kind = .{ .push = null } });+ bidi.user_context.session.initiateRootNavigation(frame._frame_id, url, nav_opts);nav_result catch |err| {log.warn(.bidi, "navigate", .{ .err = err });- if (opts.wait != .none and ctx.pending_navigate == null) {+ if (wait != .none and ctx.pending_navigate == null) {// the lifecycle already answered itreturn;}@@ -239,8 +262,8 @@ pub fn navigate(cmd: *BiDi.Command, ctx: *Context, opts: NavigateOpts) !void {return cmd.sendError("unknown error", "navigation failed");};- if (opts.wait == .none) {- return cmd.sendResult(.{ .navigation = &ctx.navigation_id, .url = encoded_url });+ if (wait == .none) {+ return cmd.sendResult(.{ .navigation = &ctx.navigation_id, .url = url });}}diff --git a/src/server/bidi/http_command.zig b/src/server/bidi/http_command.zigindex 0f3347b67..3b391385a 100644--- a/src/server/bidi/http_command.zig+++ b/src/server/bidi/http_command.zig@@ -21,22 +21,42 @@// worker runs it as a BiDi.Command, which answers the parked request.const std = @import("std");+const lp = @import("lightpanda");++const Frame = @import("../../browser/Frame.zig");const Method = @import("../http.zig").Connection.Method;const BiDi = @import("BiDi.zig");+const input = @import("input.zig");const browsing_context = @import("browsing_context.zig");const Allocator = std.mem.Allocator;+// The key of a WebDriver element reference: {"element-6066-…": "<sharedId>"}+pub const element_key = "element-6066-11e4-a52e-4f735466cecf";+pub const Command = union(enum) {navigate_to: NavigateTo,+ get_current_url,+ refresh,+ get_title,+ get_window_handle,+ get_window_handles,+ get_page_source,+ take_screenshot,+ perform_actions: PerformActions,+ release_actions,};pub const NavigateTo = struct {url: [:0]const u8,};+pub const PerformActions = struct {+ actions: []const std.json.Value,+};+const Route = struct {method: Method,// what follows /session/{id}@@ -46,6 +66,15 @@ const Route = struct {const routes = [_]Route{.{ .method = .POST, .path = "/url", .command = .navigate_to },+ .{ .method = .GET, .path = "/url", .command = .get_current_url },+ .{ .method = .POST, .path = "/refresh", .command = .refresh },+ .{ .method = .GET, .path = "/title", .command = .get_title },+ .{ .method = .GET, .path = "/window", .command = .get_window_handle },+ .{ .method = .GET, .path = "/window/handles", .command = .get_window_handles },+ .{ .method = .GET, .path = "/source", .command = .get_page_source },+ .{ .method = .GET, .path = "/screenshot", .command = .take_screenshot },+ .{ .method = .POST, .path = "/actions", .command = .perform_actions },+ .{ .method = .DELETE, .path = "/actions", .command = .release_actions },};pub const ParseError = error{@@ -74,6 +103,10 @@ pub fn parse(arena: Allocator, method: Method, path: []const u8, body: []const u}fn parseBody(comptime T: type, arena: Allocator, body: []const u8) ParseError!T {+ if (T == void) {+ // POSTs without parameters still send a body ("{}"); nothing to read+ return {};+ }return std.json.parseFromSliceLeaky(T, arena, body, .{.ignore_unknown_fields = true,// body is the connection's read buffer, reused once the request is parked@@ -88,26 +121,101 @@ fn parseBody(comptime T: type, arena: Allocator, body: []const u8) ParseError!Tpub fn process(cmd: *BiDi.Command) !void {switch (cmd.input.http) {.navigate_to => |p| return navigateTo(cmd, p),+ .get_current_url => return getCurrentUrl(cmd),+ .refresh => return refresh(cmd),+ .get_title => return getTitle(cmd),+ .get_window_handle => return getWindowHandle(cmd),+ .get_window_handles => return getWindowHandles(cmd),+ .get_page_source => return getPageSource(cmd),+ .take_screenshot => return takeScreenshot(cmd),+ .perform_actions => |p| return performActions(cmd, p),+ .release_actions => return releaseActions(cmd),}}-// POST /session/{id}/url. Answers once the page has loaded (the "normal"-// page load strategy).+// POST /session/{id}/url.fn navigateTo(cmd: *BiDi.Command, p: NavigateTo) !void {- const ctx = currentContext(cmd.bidi) catch |err| switch (err) {- error.CreatePage => return cmd.sendError("unknown error", "failed to create page"),- else => return err,- };+ const ctx = (try currentContext(cmd)) orelse return;return browsing_context.navigate(cmd, ctx, .{ .url = p.url, .wait = .complete });}-// An HTTP session always has a top-level browsing context; it's opened on-// first use.-fn currentContext(bidi: *BiDi) !*browsing_context.Context {- if (bidi.browsing_context) |*ctx| {+// GET /session/{id}/url+fn getCurrentUrl(cmd: *BiDi.Command) !void {+ const frame = (try currentFrame(cmd)) orelse return;+ return cmd.sendResult(frame.url);+}++// POST /session/{id}/refresh.+fn refresh(cmd: *BiDi.Command) !void {+ const ctx = (try currentContext(cmd)) orelse return;+ return browsing_context.reload(cmd, ctx, .complete);+}++// GET /session/{id}/title+fn getTitle(cmd: *BiDi.Command) !void {+ const frame = (try currentFrame(cmd)) orelse return;+ return cmd.sendResult((try frame.getTitle()) orelse "");+}++// GET /session/{id}/window. The handle is the BiDi context id+fn getWindowHandle(cmd: *BiDi.Command) !void {+ const ctx = (try currentContext(cmd)) orelse return;+ return cmd.sendResult(&ctx.id);+}++// GET /session/{id}/window/handles+fn getWindowHandles(cmd: *BiDi.Command) !void {+ const ctx = (try currentContext(cmd)) orelse return;+ return cmd.sendResult(&[_][]const u8{&ctx.id});+}++// GET /session/{id}/source+fn getPageSource(cmd: *BiDi.Command) !void {+ const frame = (try currentFrame(cmd)) orelse return;+ var aw: std.Io.Writer.Allocating = .init(cmd.arena);+ try lp.dump.root(frame.window._document, .{ .shadow = .skip }, &aw.writer, frame);+ return cmd.sendResult(aw.written());+}++// GET /session/{id}/screenshot.+fn takeScreenshot(cmd: *BiDi.Command) !void {+ const frame = (try currentFrame(cmd)) orelse return;+ const opts: lp.screenshot.Opts = .fromViewport(cmd.bidi.browser.getViewport(), false);+ const shot = try lp.screenshot.preparePng(cmd.arena, .{ .root = frame.window._document.asNode() }, opts, frame);+ return cmd.sendResult(shot);+}++// POST /session/{id}/actions.+fn performActions(cmd: *BiDi.Command, p: PerformActions) !void {+ _ = (try currentContext(cmd)) orelse return;+ return input.perform(cmd, p.actions);+}++// DELETE /session/{id}/actions+fn releaseActions(cmd: *BiDi.Command) !void {+ _ = (try currentContext(cmd)) orelse return;+ return input.release(cmd);+}++fn currentContext(cmd: *BiDi.Command) !?*browsing_context.Context {+ if (cmd.bidi.browsing_context) |*ctx| {return ctx;}- return browsing_context.openContext(bidi);+ return browsing_context.openContext(cmd.bidi) catch |err| switch (err) {+ error.CreatePage => {+ try cmd.sendError("unknown error", "failed to create page");+ return null;+ },+ else => return err,+ };+}++fn currentFrame(cmd: *BiDi.Command) !?*Frame {+ _ = (try currentContext(cmd)) orelse return null;+ return cmd.bidi.user_context.session.currentFrame() orelse {+ try cmd.sendError("no such window", "no frame");+ return null;+ };}const testing = @import("testing.zig");@@ -119,7 +227,24 @@ test "bidi.http_command: parse" {try testing.expectEqual("about:blank", command.navigate_to.url);}- try testing.expectError(error.UnknownMethod, parse(arena, .GET, "/url", ""));+ {+ // parameterless commands ignore the body+ const command = try parse(arena, .POST, "/refresh", "{}");+ try testing.expect(command == .refresh);+ }++ {+ const command = try parse(arena, .POST, "/actions", "{\"actions\":[{\"type\":\"none\",\"id\":\"n\",\"actions\":[]}]}");+ try testing.expectEqual(1, command.perform_actions.actions.len);+ }++ try testing.expect(try parse(arena, .GET, "/url", "") == .get_current_url);+ try testing.expect(try parse(arena, .GET, "/window/handles", "") == .get_window_handles);+ try testing.expect(try parse(arena, .DELETE, "/actions", "") == .release_actions);++ try testing.expectError(error.UnknownMethod, parse(arena, .PUT, "/url", ""));+ try testing.expectError(error.UnknownMethod, parse(arena, .POST, "/title", "{}"));+ try testing.expectError(error.InvalidArgument, parse(arena, .POST, "/actions", "{}"));try testing.expectError(error.UnknownCommand, parse(arena, .POST, "/nope", "{}"));try testing.expectError(error.InvalidArgument, parse(arena, .POST, "/url", "not json"));try testing.expectError(error.InvalidArgument, parse(arena, .POST, "/url", "{}"));diff --git a/src/server/bidi/input.zig b/src/server/bidi/input.zigindex 7762dfaef..8b61c275c 100644--- a/src/server/bidi/input.zig+++ b/src/server/bidi/input.zig@@ -25,6 +25,7 @@ const KeyboardEvent = @import("../../browser/webapi/event/KeyboardEvent.zig");const BiDi = @import("BiDi.zig");const remote_value = @import("remote_value.zig");+const http_command = @import("http_command.zig");const browsing_context = @import("browsing_context.zig");const log = lp.log;@@ -52,13 +53,17 @@ fn performActions(cmd: *BiDi.Command) !void {if ((try browsing_context.requireContext(cmd, p.context)) == null) {return;}+ return perform(cmd, p.actions);+}+// The core of performActions, shared with the HTTP session's Perform Actions.+pub fn perform(cmd: *BiDi.Command, actions: []const std.json.Value) !void {const bidi = cmd.bidi;const arena = try bidi.app.arena_pool.acquire(.small, "bidi input.Pending");// run takes onwership of arena, so errdefer can lead to a double-free.// explicit release on error instead, then transfer to run.- const ticks = parseTicks(bidi, arena.allocator(), p.actions) catch |err| {+ const ticks = parseTicks(bidi, arena.allocator(), actions) catch |err| {arena.release();if (err == error.OutOfMemory) {return err;@@ -89,7 +94,11 @@ fn releaseActions(cmd: *BiDi.Command) !void {if ((try browsing_context.requireContext(cmd, p.context)) == null) {return;}+ return release(cmd);+}+// The core of releaseActions, shared with the HTTP session's Release Actions.+pub fn release(cmd: *BiDi.Command) !void {const bidi = cmd.bidi;const frame = bidi.user_context.session.currentFrame() orelse {return cmd.sendError("no such frame", "no frame");@@ -113,7 +122,7 @@ fn releaseActions(cmd: *BiDi.Command) !void {}}- return cmd.sendResult(struct {}{});+ return cmd.sendDone();}fn dispatchFailed(cmd: *BiDi.Command, err: DispatchError) !void {@@ -297,7 +306,7 @@ const Pending = struct {}}- try bidi.replyResult(self.reply, struct {}{});+ try bidi.replyDone(self.reply);return false;}@@ -377,7 +386,7 @@ fn parseTicks(bidi: *BiDi, arena: Allocator, actions: []const std.json.Value) Paconst parsed = try arena.alloc(Action, sa.actions.len);for (sa.actions, parsed) |raw, *action| {- action.* = try parseAction(sa.type, raw);+ action.* = try parseAction(arena, sa.type, raw);}columns.appendAssumeCapacity(.{ .source = source, .actions = parsed });@@ -398,7 +407,8 @@ fn parseTicks(bidi: *BiDi, arena: Allocator, actions: []const std.json.Value) Pareturn ticks;}-fn parseAction(kind: Source.Kind, raw: std.json.Value) ParseError!Action {+// `arena` outlives the command: an action can run after its json is gone.+fn parseAction(arena: Allocator, kind: Source.Kind, raw: std.json.Value) ParseError!Action {const obj = switch (raw) {.object => |o| o,else => return error.InvalidActions,@@ -437,7 +447,7 @@ fn parseAction(kind: Source.Kind, raw: std.json.Value) ParseError!Action {.x = try numberField(obj, "x"),.y = try numberField(obj, "y"),.duration = try uintField(obj, "duration", 0),- .origin = try originField(obj, .pointer),+ .origin = try originField(arena, obj, .pointer),} },.scroll => .{ .scroll = .{.x = try numberField(obj, "x"),@@ -445,7 +455,7 @@ fn parseAction(kind: Source.Kind, raw: std.json.Value) ParseError!Action {.delta_x = try numberField(obj, "deltaX"),.delta_y = try numberField(obj, "deltaY"),.duration = try uintField(obj, "duration", 0),- .origin = try originField(obj, .wheel),+ .origin = try originField(arena, obj, .wheel),} },};}@@ -492,7 +502,7 @@ fn numberField(obj: std.json.ObjectMap, name: []const u8) ParseError!f64 {};}-fn originField(obj: std.json.ObjectMap, source: Source.Kind) ParseError!Origin {+fn originField(arena: Allocator, obj: std.json.ObjectMap, source: Source.Kind) ParseError!Origin {const value = obj.get("origin") orelse return .viewport;switch (value) {.null => return .viewport,@@ -506,6 +516,13 @@ fn originField(obj: std.json.ObjectMap, source: Source.Kind) ParseError!Origin {return error.InvalidOrigin;},.object => |o| {+ // an HTTP session's element reference+ if (o.get(http_command.element_key)) |ref| {+ return switch (ref) {+ .string => |s| .{ .element = try arena.dupe(u8, s) },+ else => error.InvalidOrigin,+ };+ }const typ = o.get("type") orelse return error.InvalidOrigin;if (typ != .string or std.mem.eql(u8, typ.string, "element") == false) {return error.InvalidOrigin;@@ -515,7 +532,7 @@ fn originField(obj: std.json.ObjectMap, source: Source.Kind) ParseError!Origin {else => return error.InvalidOrigin,};return switch (element.get("sharedId") orelse return error.InvalidOrigin) {- .string => |s| .{ .element = s },+ .string => |s| .{ .element = try arena.dupe(u8, s) },else => error.InvalidOrigin,};},