Lightpanda: the headless browser designed for AI and automation
add `--load-resources` CLI arg, supporting `image` param
Halil Durake58f99da18a6
diff --git a/src/Config.zig b/src/Config.zigindex e2dcd8813..b986066b7 100644--- a/src/Config.zig+++ b/src/Config.zig@@ -211,6 +211,26 @@ fn caPathValidator(}}+// Sub-resources the browser actually requests. A comma-separated list so+// more can be opted into individually as they land; only `image` fetches+// today.+pub const LoadResources = packed struct(u1) {+ image: bool = false,+};++fn loadResourcesValidator(_: Allocator, args: *std.process.Args.Iterator, target: *LoadResources) !void {+ const resources = args.next() orelse return error.MissingArgument;++ var it = std.mem.splitScalar(u8, resources, ',');+ while (it.next()) |resource| {+ inline for (@typeInfo(LoadResources).@"struct".fields) |field| {+ if (std.mem.eql(u8, field.name, resource)) {+ @field(target, field.name) = true;+ }+ }+ }+}+/// Common CLI args.const CommonOptions = .{.{ .name = "obey_robots", .type = bool },@@ -245,6 +265,12 @@ const CommonOptions = .{.{ .name = "disable_subframes", .type = bool },.{ .name = "disable_workers", .type = bool },.{ .name = "enable_external_stylesheets", .type = bool },+ .{+ .name = "load_resources",+ .type = LoadResources,+ .default = LoadResources{},+ .validator = loadResourcesValidator,+ },.{ .name = "v8_flags_unsafe", .type = ?[]const u8 },.{ .name = "v8_max_heap_mb", .type = ?u32 },.{ .name = "watchdog_ms", .type = ?u32 },@@ -526,6 +552,13 @@ pub fn enableExternalStylesheets(self: *const Config) bool {};}+pub fn loadResources(self: *const Config) LoadResources {+ return switch (self.mode) {+ inline .serve, .fetch, .mcp, .agent => |opts| opts.load_resources,+ else => unreachable,+ };+}+pub fn v8Flags(self: *const Config) ?[]const u8 {return switch (self.mode) {inline .serve, .fetch, .mcp, .agent => |opts| opts.v8_flags_unsafe,diff --git a/src/browser/Frame.zig b/src/browser/Frame.zigindex afd14ae2a..66ed65457 100644--- a/src/browser/Frame.zig+++ b/src/browser/Frame.zig@@ -2384,6 +2384,155 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []cotry self.fireElementEvent(element, comptime .wrap("load"));}+// Asynchronous, unlike `loadExternalStylesheet`: nothing in the document+// depends on the result, so there's no reason to block the parser on it.+// The request does take a `_pending_loads` slot, so the window load event+// waits for it the way the HTML spec says it should.+pub fn loadImage(self: *Frame, image: *Element.Html.Image, src: []const u8) !void {+ const session = self._session;+ // Fragment-parsed images (innerHTML, DOMParser, ...) may never be+ // attached, and may belong to another Document. Same call as+ // `loadExternalStylesheet` makes. They still get the synthetic load the+ // no-fetch path would have given them, so the two modes agree.+ if (self._parse_mode == .fragment) {+ return self.queueLoad(Factory.protoOf(image));+ }++ const arena = try session.getArena(.small, "Frame.loadImage");+ defer arena.release();++ const resolved = URL.resolve(arena.allocator(), self.base(), src, .{ .encoding = self.charset }) catch |err| {+ // An unresolvable src is a load failure the same way a 404 is, and+ // unlike a real fetch we can settle it without a request. No pending+ // load was taken out yet, so queue rather than decrementing.+ log.info(.http, "image resolve", .{ .err = err, .src = src });+ image._complete = true;+ return self.queueElementEvent(Factory.protoOf(image), .@"error");+ };++ // an in-flight image is a fixed-size record we can hand back the moment it+ // settles, and a page can create a lot of them.+ const load = try self._factory.create(ImageLoad{+ .frame = self,+ .image = image,+ .generation = image._generation,+ });+ errdefer self._factory.destroy(load);++ // New load event always sets `_complete` back to false.+ image._complete = false;+ self._pending_loads += 1;+ errdefer {+ image._complete = true;+ self._pending_loads -= 1;+ }++ const transfer = try session.browser.http_client.newRequest(.{+ .ctx = load,+ .url = resolved,+ .method = .GET,+ .frame_id = self._frame_id,+ .loader_id = self._loader_id,+ .cookie_jar = &session.cookie_jar,+ .cookie_origin = self.url,+ .resource_type = .image,+ .notification = session.notification,+ .headers_only = true,+ .header_callback = ImageLoad.headerCallback,+ .data_callback = ImageLoad.dataCallback,+ .done_callback = ImageLoad.doneCallback,+ .error_callback = ImageLoad.errorCallback,+ .shutdown_callback = ImageLoad.shutdownCallback,+ }, &self._http_owner);+ {+ // `deinit` fires no callbacks, so the errdefers above are still the+ // ones responsible for undoing our state on this path.+ errdefer transfer.deinit();+ // Part of mimicking the real request: origins that content-negotiate+ // (or that turn away clients which don't look like browsers) key off+ // exactly this header.+ try transfer.addHeader("Accept", "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8", .{});+ try self.headersForRequest(transfer);+ }++ // From here the transfer owns `load`. `submit` either succeeds or has+ // already routed the failure through error_callback, which settles the+ // ImageLoad and gives the pending-load slot back.+ transfer.submit() catch |err| {+ log.warn(.http, "image fetch", .{ .err = err, .url = resolved });+ };+}++// One in-flight image fetch. Exactly one of done/error/shutdown runs, and+// each releases the `_pending_loads` slot taken in `loadImage`.+const ImageLoad = struct {+ frame: *Frame,+ image: *Element.Html.Image,+ generation: u32,+ status: u16 = 0,++ fn headerCallback(transfer: *HttpClient.Transfer) !HttpClient.Transfer.HeaderResult {+ const self: *ImageLoad = @ptrCast(@alignCast(transfer.req.ctx));+ self.status = transfer.responseStatus() orelse 0;+ return .proceed;+ }++ fn dataCallback(_: *HttpClient.Transfer, _: []const u8) !void {+ // Nothing should ever reach here.+ unreachable;+ }++ fn doneCallback(ctx: *anyopaque) !void {+ const self: *ImageLoad = @ptrCast(@alignCast(ctx));+ const ok = self.status >= 200 and self.status < 300;+ self.settle(if (ok) .load else .@"error");+ }++ fn errorCallback(ctx: *anyopaque, err: anyerror) void {+ const self: *ImageLoad = @ptrCast(@alignCast(ctx));+ log.info(.http, "image fetch", .{ .err = err, .status = self.status });+ self.settle(.@"error");+ }++ fn shutdownCallback(ctx: *anyopaque) void {+ const self: *ImageLoad = @ptrCast(@alignCast(ctx));+ const frame = self.frame;+ self.image._complete = true;+ frame._factory.destroy(self);++ // Teardown or a superseding navigation. Release the slot directly:+ // `pendingLoadCompleted` could reach `documentIsComplete`, and+ // running the load event on a frame that's being dismantled is+ // exactly what we're being told to stop doing.+ frame._pending_loads -|= 1;+ }++ fn settle(self: *ImageLoad, kind: QueuedEvent.Kind) void {+ const frame = self.frame;+ const image = self.image;+ defer frame._factory.destroy(self);++ // A later src assignment owns the element's events now; this+ // response is only still here to give its pending-load slot back.+ const superseded = self.generation != image._generation;+ if (!superseded) {+ image._complete = true;+ }++ if (!superseded and !frame.isGoingAway()) {+ const name: String = switch (kind) {+ .load => comptime .wrap("load"),+ .@"error" => comptime .wrap("error"),+ };+ frame.fireElementEvent(image.asElement(), name) catch |err| {+ log.warn(.js, "image event", .{ .err = err, .kind = kind });+ };+ }++ frame.pendingLoadCompleted();+ }+};+fn fireElementEvent(self: *Frame, el: *Element, name: String) !void {const event = try Event.initTrusted(name, .{}, self._page);try self._event_manager.dispatch(el.asEventTarget(), event);diff --git a/src/browser/Session.zig b/src/browser/Session.zigindex 09233a32b..811612cf6 100644--- a/src/browser/Session.zig+++ b/src/browser/Session.zig@@ -20,6 +20,7 @@ const std = @import("std");const lp = @import("lightpanda");const App = @import("../App.zig");+const Config = @import("../Config.zig");const History = @import("webapi/History.zig");const storage = @import("webapi/storage/storage.zig");@@ -115,6 +116,15 @@ _console_capture: bool = false,// (synchronous fetch + parse + register on `document.styleSheets`).load_external_stylesheets: bool = false,+// Sub-resources to actually request. Off by default: a driver that only+// reads the DOM shouldn't pay for bytes it never looks at. Set from the+// `--load-resources` CLI flag at session init; the LP.configureLoading CDP+// method can flip it per-session. When `image` is set,+// `Image.imageAddedCallback` routes to `Frame.loadImage` and an <img>'s+// load/error event reflects the real HTTP status instead of always being+// a synthetic load.+load_resources: Config.LoadResources = .{},+/// Caller-supplied cancellation probe. `Runner._wait` polls it between/// ticks; once `check` returns true the wait returns `error.Cancelled`./// The agent installs this so SIGINT can abort an in-flight tool call@@ -180,6 +190,7 @@ pub fn init(self: *Session, browser: *Browser, notification: *Notification) !voi.worker_loading_enabled = !browser.app.config.disableWorkers(),._console_messages = .init(allocator),.load_external_stylesheets = browser.app.config.enableExternalStylesheets(),+ .load_resources = browser.app.config.loadResources(),};errdefer self._console_messages.deinit();}diff --git a/src/browser/webapi/element/html/Image.zig b/src/browser/webapi/element/html/Image.zigindex 5d08a42e1..4538353a7 100644--- a/src/browser/webapi/element/html/Image.zig+++ b/src/browser/webapi/element/html/Image.zig@@ -1,5 +1,6 @@const lp = @import("lightpanda");const std = @import("std");+const log = lp.log;const js = @import("../../../js/js.zig");const Factory = @import("../../../Factory.zig");const Frame = @import("../../../Frame.zig");@@ -7,10 +8,20 @@ const Node = @import("../../Node.zig");const Element = @import("../../Element.zig");const HtmlElement = @import("../Html.zig");+const String = lp.String;+const Image = @This();pub const Proto = HtmlElement;-_pad: bool = false,++// Bumped on every src assignment. An in-flight fetch carries the value it+// was issued under; when they no longer match, a newer src has taken over+// and the older response must not fire events on this element.+_generation: u32 = 0,+// Per spec, false only while a fetch is in flight. Without+// `--load-resources image` there is never a fetch, so it never leaves true.+_complete: bool = true,+_proto_canary: if (lp.IS_DEBUG) *HtmlElement else void = undefined,pub fn constructor(w_: ?u32, h_: ?u32, frame: *Frame) !*Image {@@ -48,10 +59,12 @@ pub fn getSrc(self: *const Image, frame: *Frame) ![]const u8 {}pub fn setSrc(self: *Image, value: []const u8, frame: *Frame) !void {- const element = self.asElement();- try element.setAttributeSafe(comptime .wrap("src"), .wrap(value), frame);- // No need to check if `Image` is connected to DOM; this is a special case.- return self.imageAddedCallback(frame);+ // Setting the attribute is enough: `_put` dispatches to+ // `Build.attributeChange`, which starts the load. Calling+ // `imageAddedCallback` here too would issue the request twice (the first+ // one immediately superseded, so it costs a request and shows nothing).+ // Connectivity still isn't checked — a detached `new Image()` loads.+ return self.asElement().setAttributeSafe(comptime .wrap("src"), .wrap(value), frame);}pub fn getLoading(self: *const Image) []const u8 {@@ -74,17 +87,21 @@ pub fn getNaturalHeight(_: *const Image) u32 {return 0;}-pub fn getComplete(_: *const Image) bool {- // Per spec, complete is true when: no src/srcset, src is empty,- // image is fully available, or image is broken (with no pending request).- // Since we never fetch images, they are in the "broken" state, which has- // complete=true. This is consistent with naturalWidth/naturalHeight=0.- return true;+pub fn getComplete(self: *const Image) bool {+ // Per spec, complete is true when: no src/srcset, src is empty, the+ // image is fully available, or the image is broken with no pending+ // request. Every one of those is "no fetch in flight", which is exactly+ // what `_complete` tracks. Without `--load-resources image` nothing ever+ // clears it.+ return self._complete;}-/// Used in `Page.nodeIsReady`.+/// The one funnel for "this element's src became current": parser-created+/// images (`Build.created`), `img.src = ...` (`setSrc`) and+/// `setAttribute("src", ...)` (`Build.attributeChange`) all land here.pub fn imageAddedCallback(self: *Image, frame: *Frame) !void {- // if we're planning on navigating to another frame, don't trigger load event.+ // if we're planning on navigating to another frame, don't trigger a load event+ // or start fetching a resource.if (frame.isGoingAway()) {return;}@@ -94,7 +111,28 @@ pub fn imageAddedCallback(self: *Image, frame: *Frame) !void {const src = element.getAttributeSafe(comptime .wrap("src")) orelse return;if (src.len == 0) return;- try frame.queueLoad(Factory.protoOf(self));+ // If image loading not desired, we just do fake "load" event.+ if (frame._session.load_resources.image == false) {+ return frame.queueLoad(Factory.protoOf(self));+ }++ // A fetch still in flight for the previous src is stale as of right now,+ // and this is the only place that knows it. Wrapping is fine: colliding+ // needs a request to still be in flight 2^32 src assignments later, which+ // outlives any transfer timeout by several orders of magnitude.+ self._generation +%= 1;++ // Deliberately not propagated. `newRequest` is declared `anyerror`, and+ // this runs on DOM mutation paths with narrow declared error sets+ // (`Node.cloneNode`'s `CloneError`, for one). Failing to even issue the+ // request is the same observable outcome as the request failing, so+ // report it the same way — `loadImage` has already unwound `_complete`+ // and the pending-load slot by the time it returns an error.+ frame.loadImage(self, src) catch |err| {+ log.warn(.http, "image fetch", .{ .err = err, .src = src });+ // On failure, queue "error" event.+ return frame.queueElementEvent(Factory.protoOf(self), .@"error");+ };}pub const JsApi = struct {@@ -140,6 +178,15 @@ pub const Build = struct {const self = node.as(Image);return self.imageAddedCallback(frame);}++ // `img.src = ...` routes through `setSrc`, but `setAttribute("src", ...)`+ // only reaches us here, and both have to (re)do fetch.+ pub fn attributeChange(element: *Element, name: String, _: String, frame: *Frame) !void {+ if (!name.eql(comptime .wrap("src"))) {+ return;+ }+ return element.as(Image).imageAddedCallback(frame);+ }};const testing = @import("../../../../testing.zig");diff --git a/src/cdp/domains/lp.zig b/src/cdp/domains/lp.zigindex a331714f7..659d5ef98 100644--- a/src/cdp/domains/lp.zig+++ b/src/cdp/domains/lp.zig@@ -20,6 +20,7 @@ const std = @import("std");const lp = @import("lightpanda");const CDP = @import("../CDP.zig");+const Config = @import("../../Config.zig");const Node = @import("../Node.zig");const DOMNode = @import("../../browser/webapi/Node.zig");@@ -98,12 +99,14 @@ fn configureLoading(cmd: *CDP.Command) !void {subFrame: ?bool = null,worker: ?bool = null,externalStylesheets: ?bool = null,+ images: ?bool = null,})) orelse return error.InvalidParams;const bc = cmd.browser_context orelse return error.NoBrowserContext;if (params.subFrame) |v| bc.session.subframe_loading_enabled = v;if (params.worker) |v| bc.session.worker_loading_enabled = v;if (params.externalStylesheets) |v| bc.session.load_external_stylesheets = v;+ if (params.images) |v| bc.session.load_resources.image = v;return cmd.sendResult(null, .{});}diff --git a/src/cdp/domains/network.zig b/src/cdp/domains/network.zigindex c5fd99de7..df83a30a0 100644--- a/src/cdp/domains/network.zig+++ b/src/cdp/domains/network.zig@@ -650,6 +650,7 @@ fn initialPriority(resource_type: HttpClient.Request.ResourceType) []const u8 {return switch (resource_type) {.document, .stylesheet => "VeryHigh",.script, .xhr, .fetch, .eventsource => "High",+ .image => "Low",};}diff --git a/src/network/HttpClient.zig b/src/network/HttpClient.zigindex cf7bdaf53..d1151d1a8 100644--- a/src/network/HttpClient.zig+++ b/src/network/HttpClient.zig@@ -539,7 +539,7 @@ pub fn activity(self: *const Client) Activity {.http = self.http_active + self.dispatch_count + self.intercepted + self.delayed_count,.ws_events = self.ws_dispatch_count,.ws_conns = self.ws_active,- .pending = self.pending_queue.first != null,+ .pending = self.pending_queue.first != null or self.pending_low_queue.first != null,};}@@ -831,13 +831,24 @@ fn isGated(self: *const Client, transfer: *const Transfer) bool {return transfer.id != blocking_id;}+// Resources the page's progress doesn't depend on. Images are fetched for+// their status (so load/error is honest) and, with `--fetch-images headers`,+// a page can queue dozens of them in one parse — none of which should come+// ahead of the script that's blocking the parser.+fn isLowPriority(resource_type: Request.ResourceType) bool {+ return switch (resource_type) {+ .image => false, // EXPERIMENT+ .document, .xhr, .script, .fetch, .stylesheet, .eventsource => false,+ };+}+fn startPending(self: *Client) !void {try self.startDelayed();while (self.pending_queue.popFirst()) |queue_node| {const transfer: *Transfer = @fieldParentPtr("_node", queue_node);const conn = self.network.getConnection() orelse {- self.pending_queue.prepend(queue_node);- return;+ queue.prepend(queue_node);+ return false;};// Bridge state to .created so a failure inside makeRequest before// any commit cleans up via the failAsync below. makeRequest flips to@@ -853,6 +864,7 @@ fn startPending(self: *Client) !void {return err;};}+ return true;}// Enter the pipeline for every delayed transfer whose time has come.@@ -1107,6 +1119,13 @@ fn cacheStore(self: *Client, transfer: *Transfer) void {// entry a second time on any early return below.transfer._cache_intent = .none;+ // A headers_only transfer never read the body. Storing it would put an+ // empty entry under the real cache key and every later full fetch of+ // that URL (an XHR, a `full` image fetch) would hit it and get nothing.+ if (transfer.req.headers_only) {+ return;+ }+// could have been disabled while waiting of the responseconst cache = self.cache.active() orelse return;@@ -1285,11 +1304,19 @@ pub fn syncRequest(self: *Client, transfer: *Transfer) !SyncResponse {}fn processTransfer(self: *Client, transfer: *Transfer) !void {- if (self.network.getConnection()) |conn| {- return self.makeRequest(conn, transfer);+ const low = isLowPriority(transfer.req.resource_type);+ if (!low or self.pending_queue.first == null) {+ if (self.network.getConnection()) |conn| {+ return self.makeRequest(conn, transfer);+ }}- self.pending_queue.append(&transfer._node);+ transfer._queued_low = low;+ if (low) {+ self.pending_low_queue.append(&transfer._node);+ } else {+ self.pending_queue.append(&transfer._node);+ }transfer.state = .queued;}@@ -1509,6 +1536,11 @@ fn processOneMessage(self: *Client, msg: http.Handles.MultiMessage, transfer: *Tlog.debug(.http, "WriteError downgraded", .{ .url = transfer.req.url, .bytes = transfer.res.bytes_received });break :blk null;}+ // Our own headers_only abort, not a failure: fall through so the+ // response is materialized and delivered with an empty body.+ if (err == error.WriteError and transfer.res.headers_only_abort) {+ break :blk null;+ }break :blk err;} else null;@@ -1751,6 +1783,7 @@ pub const Request = struct {fetch,stylesheet,eventsource,+ image,// Allowed Values: Document, Stylesheet, Image, Media, Font, Script,// TextTrack, XHR, Fetch, Prefetch, EventSource, WebSocket, Manifest,@@ -1764,6 +1797,7 @@ pub const Request = struct {.fetch => "Fetch",.stylesheet => "Stylesheet",.eventsource => "EventSource",+ .image => "Image",};}};@@ -1772,6 +1806,12 @@ pub const Request = struct {// internal requests transparently following redirects.pub const RedirectMode = enum { follow, manual, @"error" };+ // Largest body a headers_only transfer will read to the end rather than+ // abort. Draining costs bandwidth but keeps the connection poolable;+ // aborting saves bandwidth but forces a reconnect. 16 KiB is the rough+ // break-even: about ten segments, versus a TCP handshake plus a TLS one.+ pub const HEADERS_ONLY_DRAIN_MAX: usize = 16 * 1024;+frame_id: u32,loader_id: u32,method: Method,@@ -1787,6 +1827,16 @@ pub const Request = struct {timeout_ms: u32 = 0,skip_cache: bool = false,+ // Tear the transfer off the wire as soon as the first body byte arrives:+ // the caller wants the status and the response headers, not the body.+ // Unlike a HEAD, the request itself is byte-for-byte a normal GET, so+ // origins and CDNs see (and answer) exactly what a real browser sends.+ // The consumer still gets the usual start/header/done sequence with an+ // empty body; `data_callback` never fires. Note the cost: aborting+ // mid-response means the connection can't be drained, so libcurl closes+ // it instead of returning it to the pool.+ headers_only: bool = false,+// The document frame this request belongs to, for CDP attribution.// This will be different than frame_id for Workers.document_frame_id: ?u32 = null,@@ -2080,6 +2130,11 @@ pub const Transfer = struct {// node is always free by then)._node: std.DoublyLinkedList.Node = .{},+ // Which of the two pending queues _node is linked into. Only meaningful+ // while state == .queued; set at enqueue, read when unlinking, because+ // removing from the wrong list would corrupt both.+ _queued_low: bool = false,+// Buffered response ordered events awaiting dispatch._events: std.ArrayList(Event) = .empty,@@ -2643,7 +2698,11 @@ pub const Transfer = struct {}}- if (opts.check_content_length) {+ // headers_only is exempt: the cap exists to bound how much body we+ // buffer, and this transfer buffers none of it. Failing a 4 MB image+ // we were never going to read would turn the size limit into a+ // spurious `error` event on a perfectly good response.+ if (opts.check_content_length and !self.req.headers_only) {if (self.getContentLength()) |cl| {if (cl > self.client.max_response_size) {return error.ResponseTooLarge;@@ -3056,6 +3115,29 @@ pub const Transfer = struct {return @intCast(chunk_len);}+ if (transfer.req.headers_only) {+ const drainable = if (transfer.getContentLength()) |cl|+ cl <= Request.HEADERS_ONLY_DRAIN_MAX+ else+ // No Content-Length (chunked): we can't tell how much is+ // coming, so don't gamble on it being small.+ false;++ if (drainable) {+ // Reuses the redirect machinery: consumed, never buffered,+ // so the response still completes with an empty body.+ res.skip_body = true;+ return @intCast(chunk_len);+ }++ // Returning writefunc_error is the only way to end a transfer+ // early from a write callback; processOneMessage recognises+ // the flag and treats the resulting CURLE_WRITE_ERROR as a+ // completed response with an empty body.+ res.headers_only_abort = true;+ return http.writefunc_error;+ }+// Pre-size buffer from Content-Length.if (transfer.getContentLength()) |cl| {if (cl > transfer.client.max_response_size) {@@ -3338,6 +3420,12 @@ const Response = struct {skip_body: bool = false,first_data_received: bool = false,+ // Set when dataCallback deliberately killed the transfer to satisfy+ // `Request.headers_only`. processOneMessage uses it to tell our own+ // abort apart from a real CURLE_WRITE_ERROR and deliver the response+ // (headers, status, empty body) as a success.+ headers_only_abort: bool = false,+// Response body. Filled by dataCallback, consumed in processMessages.// See Stream.spare to see how this works in streaming modebuffer: std.ArrayList(u8) = .empty,