Skip to content

Lightpanda: the headless browser designed for AI and automation

browser: make resolveTargetFrame's _blank explicit; submit target=_blank forms into a popup

Adrià Arrufat95e8dfa400d2
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 2e664e57d..a8714a829 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -3395,21 +3395,25 @@ pub const QueuedNavigation = struct {
navigation_type: NavigationType,
};
+pub const TargetFrame = union(enum) {
+ frame: *Frame,
+ blank,
+};
+
/// Resolves a target attribute value (e.g., "_self", "_parent", "_top", or frame name)
-/// to the appropriateFrame to navigate.
-/// Returns null if the target is "_blank" (which would open a new window/tab).
+/// to the Frame to navigate.
/// Note: Callers should handle empty target separately (for owner document resolution).
-pub fn resolveTargetFrame(self: *Frame, target_name: []const u8) ?*Frame {
+pub fn resolveTargetFrame(self: *Frame, target_name: []const u8) TargetFrame {
if (std.ascii.eqlIgnoreCase(target_name, "_self")) {
- return self;
+ return .{ .frame = self };
}
if (std.ascii.eqlIgnoreCase(target_name, "_blank")) {
- return null;
+ return .blank;
}
if (std.ascii.eqlIgnoreCase(target_name, "_parent")) {
- return self.parent orelse self;
+ return .{ .frame = self.parent orelse self };
}
if (std.ascii.eqlIgnoreCase(target_name, "_top")) {
@@ -3417,13 +3421,13 @@ pub fn resolveTargetFrame(self: *Frame, target_name: []const u8) ?*Frame {
while (frame.parent) |f| {
frame = f;
}
- return frame;
+ return .{ .frame = frame };
}
// Named frame lookup: search current frame's descendants first, then from root
// This follows the HTML spec's "implementation-defined" search order.
if (findFrameByName(self, target_name)) |f| {
- return f;
+ return .{ .frame = f };
}
// If not found in descendants, search from root (catches siblings and ancestors' descendants)
@@ -3433,13 +3437,33 @@ pub fn resolveTargetFrame(self: *Frame, target_name: []const u8) ?*Frame {
}
if (root != self) {
if (findFrameByName(root, target_name)) |f| {
- return f;
+ return .{ .frame = f };
}
}
// If no frame found with that name, navigate in current frame
// (this matches browser behavior - unknown targets act like _self)
- return self;
+ return .{ .frame = self };
+}
+
+/// Per spec the opener is withheld unless the element has rel=opener.
+pub fn openBlankTarget(self: *Frame, element: *Element, url: []const u8) !*Frame {
+ return self.openPopup(.{
+ .url = url,
+ .name = "",
+ .opener = if (hasRelToken(element, "opener")) self.window else null,
+ });
+}
+
+fn hasRelToken(element: *Element, token: []const u8) bool {
+ const rel = element.getAttributeSafe(comptime .wrap("rel")) orelse return false;
+ var it = std.mem.tokenizeAny(u8, rel, &std.ascii.whitespace);
+ while (it.next()) |t| {
+ if (std.ascii.eqlIgnoreCase(t, token)) {
+ return true;
+ }
+ }
+ return false;
}
fn findFrameByName(frame: *Frame, name: []const u8) ?*Frame {
@@ -3502,14 +3526,11 @@ pub fn submitForm(self: *Frame, submitter_: ?*Element, form_: ?*Element.Html.For
break :blk form_element.getAttributeSafe(comptime .wrap("target"));
};
- const target_frame = blk: {
+ const target: TargetFrame = blk: {
const target_name = target_name_ orelse {
- break :blk form_element.ownerFrame(self);
- };
- break :blk self.resolveTargetFrame(target_name) orelse {
- log.warn(.not_implemented, "target", .{ .type = self._type, .url = self.url, .target = target_name });
- return;
+ break :blk .{ .frame = form_element.ownerFrame(self) };
};
+ break :blk self.resolveTargetFrame(target_name);
};
if (submit_opts.fire_event) {
@@ -3670,6 +3691,12 @@ pub fn submitForm(self: *Frame, submitter_: ?*Element, form_: ?*Element.Html.For
action = try URL.concatQueryString(arena.allocator(), action, buf.written());
}
+ // Opened only once the submission goes ahead, so an aborted one leaves
+ // no stray window.
+ const target_frame = switch (target) {
+ .frame => |f| f,
+ .blank => try form_element.ownerFrame(self).openBlankTarget(form_element, ""),
+ };
return self.scheduleNavigationWithArena(arena, action, opts, .{ .form = target_frame });
}
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index b3f78287a..fe8ae8475 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -552,17 +552,13 @@ fn followLink(frame: *Frame, target: *Node, element: *Element, href: []const u8,
if (target_name.len == 0) {
break :blk target.ownerFrame(frame);
}
- break :blk frame.resolveTargetFrame(target_name) orelse {
- // _blank: a new top-level context, as window.open creates. The
- // opener is withheld unless rel=opener.
- const owner = target.ownerFrame(frame);
- try element.focus(frame);
- _ = try owner.openPopup(.{
- .url = href,
- .name = "",
- .opener = if (hasRelToken(element, "opener")) owner.window else null,
- });
- return;
+ break :blk switch (frame.resolveTargetFrame(target_name)) {
+ .frame => |f| f,
+ .blank => {
+ try element.focus(frame);
+ _ = try target.ownerFrame(frame).openBlankTarget(element, href);
+ return;
+ },
};
};
@@ -573,17 +569,6 @@ fn followLink(frame: *Frame, target: *Node, element: *Element, href: []const u8,
}, .{ .anchor = target_frame });
}
-fn hasRelToken(element: *Element, token: []const u8) bool {
- const rel = element.getAttributeSafe(comptime .wrap("rel")) orelse return false;
- var it = std.mem.tokenizeAny(u8, rel, &std.ascii.whitespace);
- while (it.next()) |t| {
- if (std.ascii.eqlIgnoreCase(t, token)) {
- return true;
- }
- }
- return false;
-}
-
pub fn triggerKeyboard(frame: *Frame, keyboard_event: *KeyboardEvent) !void {
const event = keyboard_event.asEvent();
// Dispatch to the effective active element. When nothing is explicitly
diff --git a/src/browser/tests/frames/target.html b/src/browser/tests/frames/target.html
index f15fdb144..8194eeb9a 100644
--- a/src/browser/tests/frames/target.html
+++ b/src/browser/tests/frames/target.html
@@ -45,6 +45,14 @@
testing.expectEqual(true, location.pathname.endsWith('target.html'));
</script>
+<form id=fblank target=_blank action=support/page.html>
+ <input type=submit id=submit_blank>
+</form>
+<script id=form_blank>
+ $('#submit_blank').click();
+ testing.expectEqual(true, location.pathname.endsWith('target.html'));
+</script>
+
<iframe name=frame3 id=f3></iframe>
<form target="_top" action="support/page.html">
<input type=submit id=submit1 formtarget="frame3">
diff --git a/src/browser/tests/mcp_target_blank.html b/src/browser/tests/mcp_target_blank.html
index 31689fb53..d098b9165 100644
--- a/src/browser/tests/mcp_target_blank.html
+++ b/src/browser/tests/mcp_target_blank.html
@@ -3,5 +3,9 @@
<head><title>opener</title></head>
<body>
<a id="nt" target="_blank" href="mcp_actions.html">new tab</a>
+ <form id="nf" target="_blank" action="mcp_actions.html">
+ <input name="q" value="1">
+ <button id="fs">submit</button>
+ </form>
</body>
</html>
diff --git a/src/browser/tools.zig b/src/browser/tools.zig
index 9fe441b7d..93cad5912 100644
--- a/src/browser/tools.zig
+++ b/src/browser/tools.zig
@@ -1544,7 +1544,7 @@ fn execEvaluate(arena: std.mem.Allocator, session: *lp.Session, registry: *CDPNo
}
// Script may have queued a navigation (e.g. `top.location = …`).
- try awaitQueuedNavigation(session, page._frame_id);
+ try awaitQueuedNavigation(session, page);
const after = session.currentFrame() orelse return result;
if (before == null or before.? == after) return result;
@@ -1759,13 +1759,17 @@ fn mapActionError(err: anytype) ToolError {
/// If the previous action queued a navigation (form submit, link click,
/// Enter on an input), drive the runner until it completes or times out.
-fn awaitQueuedNavigation(session: *lp.Session, frame_id: u32) ToolError!void {
+fn awaitQueuedNavigation(session: *lp.Session, frame: *lp.Frame) ToolError!void {
+ // Runner waits are keyed by Page root (a popup lives on its opener's
+ // Page). Read it before processing: a synthetic root navigation frees
+ // the Page in place.
+ const root_frame_id = frame._page.frame._frame_id;
const navigated = session.processQueuedNavigation() catch return ToolError.InternalError;
if (navigated == false) {
return;
}
var runner = session.runner(.{});
- runner.waitForFrame(frame_id, 10000, .{ .until = .done }) catch |err|
+ runner.waitForFrame(root_frame_id, 10000, .{ .until = .done }) catch |err|
return if (err == error.Cancelled) ToolError.Cancelled else ToolError.NavigationFailed;
}
@@ -1795,7 +1799,7 @@ fn beginAction(session: *lp.Session) ActionScope {
fn finalizeAction(arena: std.mem.Allocator, session: *lp.Session, registry: *CDPNode.Registry, scope: ActionScope, body: []const u8) ToolError![]const u8 {
const before = scope.frame;
if (before) |b| {
- try awaitQueuedNavigation(session, b._frame_id);
+ try awaitQueuedNavigation(session, b);
}
var page = try requireFrame(session);
// A queued navigation that swaps the root frame tears down the previous
@@ -1944,7 +1948,7 @@ fn execWaitForScript(arena: std.mem.Allocator, session: *lp.Session, arguments:
// script may have queued a navigation (e.g. top.location=…); drain it so
// the next command reads post-navigation state
- try awaitQueuedNavigation(session, frame._frame_id);
+ try awaitQueuedNavigation(session, frame);
return "Script returned truthy.";
}
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 002c793e2..dadb7baf7 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -704,7 +704,10 @@ pub fn open(self: *Window, url_: ?[]const u8, target_: ?[]const u8, features_: ?
std.ascii.eqlIgnoreCase(target, "_parent") or
std.ascii.eqlIgnoreCase(target, "_top"))
{
- const nav_target = frame.resolveTargetFrame(target) orelse frame;
+ const nav_target = switch (frame.resolveTargetFrame(target)) {
+ .frame => |f| f,
+ .blank => unreachable,
+ };
const nav_url = if (raw_url.len == 0) "about:blank" else raw_url;
try frame.scheduleNavigation(nav_url, .{
.reason = .script,
diff --git a/src/mcp/tools.zig b/src/mcp/tools.zig
index d0b3ba58d..8184e46b5 100644
--- a/src/mcp/tools.zig
+++ b/src/mcp/tools.zig
@@ -525,6 +525,48 @@ test "MCP - click on a target=_blank link follows the new window" {
try testing.expectJson(.{ .id = 2, .result = .{
.content = &.{.{ .type = "text", .text = "http://localhost:9582/src/browser/tests/mcp_actions.html" }},
} }, out.written());
+
+ // navigation from inside the followed popup
+ out.clearRetainingCapacity();
+ const navigate =
+ \\{
+ \\ "jsonrpc": "2.0",
+ \\ "id": 3,
+ \\ "method": "tools/call",
+ \\ "params": {
+ \\ "name": "evaluate",
+ \\ "arguments": { "script": "location.href = 'mcp_target_blank.html'" }
+ \\ }
+ \\}
+ ;
+ try router.handleMessage(server, testing.arena_allocator, navigate);
+ try testing.expect(std.mem.indexOf(u8, out.written(), "\"isError\":false") != null);
+
+ out.clearRetainingCapacity();
+ try router.handleMessage(server, testing.arena_allocator, get_url);
+ try testing.expectJson(.{ .id = 2, .result = .{
+ .content = &.{.{ .type = "text", .text = "http://localhost:9582/src/browser/tests/mcp_target_blank.html" }},
+ } }, out.written());
+}
+
+test "MCP - submitting a target=_blank form follows the new window" {
+ var out: std.Io.Writer.Allocating = .init(testing.arena_allocator);
+ const server = try testLoadPage("http://localhost:9582/src/browser/tests/mcp_target_blank.html", &out.writer);
+ defer server.deinit();
+
+ const click =
+ \\{
+ \\ "jsonrpc": "2.0",
+ \\ "id": 1,
+ \\ "method": "tools/call",
+ \\ "params": {
+ \\ "name": "click",
+ \\ "arguments": { "selector": "#fs" }
+ \\ }
+ \\}
+ ;
+ try router.handleMessage(server, testing.arena_allocator, click);
+ try testing.expect(std.mem.indexOf(u8, out.written(), "Opened a new window; tools now act on it. Page url: http://localhost:9582/src/browser/tests/mcp_actions.html?q=1") != null);
}
test "MCP - evaluate: localStorage persists across navigations and is origin-scoped" {