ReviewOS

also looking at this

craft-native/craft

feat: add Linux and Windows named-window routing

#325
Merged glennmichael123 wants to merge codex/multi-window-linux-windows into main
29 files +2250 -200

Review threads live on the whole diff, not on one commit, so none are shown here - a thread's line means something in the branch's final form, and painting it into an intermediate step would put it on code it is not about.

packages/zig/build.zigmodified+11-0
Changes to packages/zig/build.zig
@@ -1263,6 +1263,14 @@ pub fn build(b: *std.Build) void {
12631263 }),
12641264 });
12651265
1266 const desktop_bridge_envelope_tests = b.addTest(.{
1267 .root_module = b.createModule(.{
1268 .root_source_file = b.path("src/desktop_bridge_envelope.zig"),
1269 .target = target,
1270 .optimize = optimize,
1271 }),
1272 });
1273
12661274 const desktop_script_encoding_tests = b.addTest(.{
12671275 .root_module = b.createModule(.{
12681276 .root_source_file = b.path("src/desktop_script_encoding.zig"),
@@ -1726,6 +1734,7 @@ pub fn build(b: *std.Build) void {
17261734 const run_window_context_tests = b.addRunArtifact(window_context_tests);
17271735 const run_window_reply_target_tests = b.addRunArtifact(window_reply_target_tests);
17281736 const run_desktop_window_registry_tests = b.addRunArtifact(desktop_window_registry_tests);
1737 const run_desktop_bridge_envelope_tests = b.addRunArtifact(desktop_bridge_envelope_tests);
17291738 const run_desktop_script_encoding_tests = b.addRunArtifact(desktop_script_encoding_tests);
17301739 const run_external_link_tests = b.addRunArtifact(external_link_tests);
17311740 const run_webview_recovery_tests = b.addRunArtifact(webview_recovery_tests);
@@ -1877,6 +1886,7 @@ pub fn build(b: *std.Build) void {
18771886 test_step.dependOn(&run_window_context_tests.step);
18781887 test_step.dependOn(&run_window_reply_target_tests.step);
18791888 test_step.dependOn(&run_desktop_window_registry_tests.step);
1889 test_step.dependOn(&run_desktop_bridge_envelope_tests.step);
18801890 test_step.dependOn(&run_desktop_script_encoding_tests.step);
18811891 test_step.dependOn(&run_external_link_tests.step);
18821892 test_step.dependOn(&run_webview_recovery_tests.step);
@@ -2847,6 +2857,7 @@ fn linkPlatformLibraries(b: *std.Build, module: *std.Build.Module, target_os: st
28472857 .linux => {
28482858 module.linkSystemLibrary("gtk+-3.0", .{});
28492859 module.linkSystemLibrary("webkit2gtk-4.1", .{});
2860 module.linkSystemLibrary("javascriptcoregtk-4.1", .{});
28502861 },
28512862 .windows => {
28522863 module.linkSystemLibrary("ole32", .{});
packages/zig/src/desktop_bridge_envelope.zigadded+77-0
Changes to packages/zig/src/desktop_bridge_envelope.zig
@@ -0,0 +1,77 @@
1//! The JSON envelope posted by the injected desktop page bridge.
2//!
3//! The page supplies `t`, `a`, `d` and a correlation id, never a native
4//! window pointer. The platform callback supplies the actual sender handles.
5
6const std = @import("std");
7const request_context = @import("request_context.zig");
8
9pub const max_message_bytes = 1024 * 1024;
10
11pub const Envelope = struct {
12 parsed: std.json.Parsed(std.json.Value),
13 kind: []const u8,
14 action: []const u8,
15 data: ?[]const u8,
16 request_id: ?u64,
17
18 pub fn deinit(self: *Envelope) void {
19 self.parsed.deinit();
20 }
21};
22
23pub fn parse(allocator: std.mem.Allocator, source: []const u8) !Envelope {
24 if (source.len > max_message_bytes) return error.MessageTooLarge;
25 var parsed = try std.json.parseFromSlice(std.json.Value, allocator, source, .{});
26 errdefer parsed.deinit();
27 if (parsed.value != .object) return error.InvalidBridgeMessage;
28
29 const root = parsed.value.object;
30 const kind_value = root.get("t") orelse return error.InvalidBridgeMessage;
31 const action_value = root.get("a") orelse return error.InvalidBridgeMessage;
32 if (kind_value != .string or action_value != .string) return error.InvalidBridgeMessage;
33 if (kind_value.string.len == 0 or action_value.string.len == 0) return error.InvalidBridgeMessage;
34
35 const data_value = root.get("d");
36 const data: ?[]const u8 = if (data_value) |value| switch (value) {
37 .string => |text| if (text.len == 0) null else text,
38 .null => null,
39 else => return error.InvalidBridgeMessage,
40 } else null;
41
42 return .{
43 .parsed = parsed,
44 .kind = kind_value.string,
45 .action = action_value.string,
46 .data = data,
47 .request_id = request_context.fromEnvelope(root),
48 };
49}
50
51test "reads a correlated window request without trusting a sender field" {
52 var envelope = try parse(std.testing.allocator,
53 \\{"t":"window","a":"open","d":"{\"name\":\"settings\"}","i":41,"window":1234}
54 );
55 defer envelope.deinit();
56 try std.testing.expectEqualStrings("window", envelope.kind);
57 try std.testing.expectEqualStrings("open", envelope.action);
58 try std.testing.expectEqualStrings("{\"name\":\"settings\"}", envelope.data.?);
59 try std.testing.expectEqual(@as(?u64, 41), envelope.request_id);
60}
61
62test "rejects malformed and oversize messages" {
63 try std.testing.expectError(error.InvalidBridgeMessage, parse(std.testing.allocator, "[]"));
64 try std.testing.expectError(error.InvalidBridgeMessage, parse(std.testing.allocator, "{\"t\":\"window\"}"));
65 try std.testing.expectError(error.InvalidBridgeMessage, parse(std.testing.allocator, "{\"t\":\"window\",\"a\":\"open\",\"d\":{}}"));
66 try std.testing.expectError(error.InvalidBridgeMessage, parse(std.testing.allocator, "{\"t\":\"window\",\"a\":\"\"}"));
67 const large = try std.testing.allocator.alloc(u8, max_message_bytes + 1);
68 defer std.testing.allocator.free(large);
69 try std.testing.expectError(error.MessageTooLarge, parse(std.testing.allocator, large));
70}
71
72test "an id-less fire-and-forget action does not inherit a pending reply" {
73 var envelope = try parse(std.testing.allocator, "{\"t\":\"window\",\"a\":\"close\",\"d\":\"\"}");
74 defer envelope.deinit();
75 try std.testing.expect(envelope.data == null);
76 try std.testing.expect(envelope.request_id == null);
77}
packages/zig/src/desktop_window_registry.zigmodified+12-1
Changes to packages/zig/src/desktop_window_registry.zig
@@ -24,7 +24,7 @@ pub const Registry = struct {
2424 }
2525
2626 pub fn rememberWithContext(self: *Registry, window: usize, webview: usize, context: usize) ?u32 {
27 if (window == 0 or webview == 0 or self.byWindow(window) != null or self.next_id == 0) return null;
27 if (window == 0 or webview == 0 or self.byWindow(window) != null or self.byWebview(webview) != null or self.next_id == 0) return null;
2828 for (&self.entries) |*slot| {
2929 if (slot.* == null) {
3030 const id = self.next_id;
@@ -56,6 +56,16 @@ pub const Registry = struct {
5656 return null;
5757 }
5858
59 pub fn byWebview(self: *const Registry, webview: usize) ?Entry {
60 if (webview == 0) return null;
61 for (self.entries) |slot| {
62 if (slot) |entry| {
63 if (entry.webview == webview) return entry;
64 }
65 }
66 return null;
67 }
68
5969 pub fn latest(self: *const Registry) ?Entry {
6070 var result: ?Entry = null;
6171 for (self.entries) |slot| {
@@ -121,6 +131,7 @@ test "invalid and duplicate native handles never occupy a slot" {
121131 try std.testing.expect(registry.remember(0x1000, 0) == null);
122132 try std.testing.expect(registry.remember(0x1000, 0x1001) != null);
123133 try std.testing.expect(registry.remember(0x1000, 0x2001) == null);
134 try std.testing.expect(registry.remember(0x2000, 0x1001) == null);
124135 try std.testing.expectEqual(@as(usize, 1), registry.count());
125136 try std.testing.expect(registry.forgetWindow(0x2000) == null);
126137 try std.testing.expectEqual(@as(usize, 1), registry.count());
packages/zig/src/linux.zigmodified+185-5
Changes to packages/zig/src/linux.zig
@@ -1,6 +1,11 @@
11const std = @import("std");
2const bridge_error = @import("bridge_error.zig");
3const desktop_bridge_envelope = @import("desktop_bridge_envelope.zig");
24const desktop_window_registry = @import("desktop_window_registry.zig");
5const json_utils = @import("json_utils.zig");
6const request_context = @import("request_context.zig");
37const window_context = @import("window_context.zig");
8const window_registry = @import("window_registry.zig");
49const window_reply_target = @import("window_reply_target.zig");
510
611// Linux implementation using GTK3 and WebKit2GTK 4.1.
@@ -29,6 +34,7 @@ pub extern "c" fn gtk_window_set_position(window: *anyopaque, x: c_int, y: c_int
2934pub extern "c" fn webkit_web_view_new() *anyopaque;
3035pub extern "c" fn webkit_web_view_load_uri(webview: *anyopaque, uri: [*:0]const u8) void;
3136pub extern "c" fn webkit_web_view_load_html(webview: *anyopaque, html: [*:0]const u8, base_uri: [*:0]const u8) void;
37pub extern "c" fn webkit_web_view_reload(webview: *anyopaque) void;
3238pub extern "c" fn webkit_web_view_get_settings(webview: *anyopaque) *anyopaque;
3339pub extern "c" fn webkit_settings_set_enable_developer_extras(settings: *anyopaque, enabled: c_int) void;
3440pub extern "c" fn webkit_settings_set_enable_webgl(settings: *anyopaque, enabled: c_int) void;
@@ -79,6 +85,9 @@ pub extern "c" fn webkit_user_script_new(
7985) *anyopaque;
8086pub extern "c" fn webkit_user_content_manager_add_script(manager: *anyopaque, script: *anyopaque) void;
8187pub extern "c" fn webkit_user_content_manager_remove_all_scripts(manager: *anyopaque) void;
88pub extern "c" fn webkit_user_content_manager_register_script_message_handler(manager: *anyopaque, name: [*:0]const u8) c_int;
89pub extern "c" fn webkit_javascript_result_get_js_value(result: *anyopaque) *anyopaque;
90pub extern "c" fn jsc_value_to_json(value: *anyopaque, indent: c_uint) ?[*:0]u8;
8291
8392pub extern "c" fn gtk_container_add(container: *anyopaque, widget: *anyopaque) void;
8493
@@ -220,7 +229,175 @@ fn registerWindow(gtk_window: *anyopaque, webview: *anyopaque) ?u32 {
220229/// Forget the handle at actual teardown, so neither path leaves a stale
221230/// webview eligible for bridge replies.
222231fn onWindowDestroyed(widget: *anyopaque, _: ?*anyopaque) callconv(.c) void {
223 _ = desktop_windows.forgetWindow(@intFromPtr(widget));
232 const entry = desktop_windows.forgetWindow(@intFromPtr(widget)) orelse return;
233 window_registry.forgetOwner(entry.webview);
234 window_registry.forget(entry.window);
235}
236
237/// WebKit supplies the WebView via signal user data; a page-supplied window id
238/// is only a name to resolve after the native sender has been authenticated.
239fn onScriptMessage(_: *anyopaque, result: *anyopaque, user_data: ?*anyopaque) callconv(.c) void {
240 const sender = user_data orelse return;
241 const entry = desktop_windows.byWebview(@intFromPtr(sender)) orelse return;
242 const value = webkit_javascript_result_get_js_value(result);
243 const json_z = jsc_value_to_json(value, 0) orelse return;
244 defer g_free(@ptrCast(json_z));
245
246 var envelope = desktop_bridge_envelope.parse(std.heap.c_allocator, std.mem.span(json_z)) catch return;
247 defer envelope.deinit();
248 window_context.push(entry.window, entry.webview);
249 defer window_context.pop();
250 request_context.push(envelope.request_id);
251 defer request_context.pop();
252
253 if (!std.mem.eql(u8, envelope.kind, "window")) {
254 bridge_error.sendErrorToJS(std.heap.c_allocator, envelope.action, error.PlatformNotSupported);
255 return;
256 }
257 handleWindowAction(envelope.action, envelope.data) catch |err| {
258 bridge_error.sendErrorToJS(std.heap.c_allocator, envelope.action, bridge_error.fromHandlerError(err));
259 };
260}
261
262fn namedWindowResult(allocator: std.mem.Allocator, name: []const u8) ![]u8 {
263 var json: std.ArrayListUnmanaged(u8) = .empty;
264 errdefer json.deinit(allocator);
265 try json.appendSlice(allocator, "{\"name\":\"");
266 try bridge_error.appendJsonEscaped(allocator, &json, name);
267 try json.appendSlice(allocator, "\"}");
268 return json.toOwnedSlice(allocator);
269}
270
271fn openNamedWindow(action: []const u8, data: ?[]const u8) !void {
272 const allocator = std.heap.c_allocator;
273 const json = data orelse return error.MissingData;
274 const explicit_name = try json_utils.getStringDecoded(allocator, json, "name");
275 defer if (explicit_name) |name| allocator.free(name);
276 const fallback_id = if (explicit_name == null)
277 try json_utils.getStringDecoded(allocator, json, "id")
278 else
279 null;
280 defer if (fallback_id) |name| allocator.free(name);
281 const name = explicit_name orelse fallback_id orelse return error.InvalidParameter;
282 if (name.len == 0 or name.len > window_registry.max_name or
283 std.mem.eql(u8, name, "main") or std.mem.indexOfScalar(u8, name, 0) != null)
284 return error.InvalidParameter;
285
286 const url = try json_utils.getStringDecoded(allocator, json, "url");
287 defer if (url) |text| allocator.free(text);
288 const html = try json_utils.getStringDecoded(allocator, json, "html");
289 defer if (html) |text| allocator.free(text);
290 if (url == null and html == null) return error.InvalidParameter;
291 const title = try json_utils.getStringDecoded(allocator, json, "title");
292 defer if (title) |text| allocator.free(text);
293 for ([_]?[]const u8{ url, html, title }) |value| {
294 if (value) |text| if (std.mem.indexOfScalar(u8, text, 0) != null)
295 return error.InvalidParameter;
296 }
297
298 // Allocate the response before creating native state. A failed allocation
299 // must not leave a live window behind a rejected creation Promise.
300 const result = try namedWindowResult(allocator, name);
301 defer allocator.free(result);
302 const owner = window_context.currentWebView() orelse return error.WebViewHandleNotSet;
303 if (window_registry.byName(name)) |existing| {
304 if (desktop_windows.byWindow(existing) == null) return error.WindowHandleNotSet;
305 if (!window_registry.rememberNamedOwned(existing, name, owner)) return error.InvalidParameter;
306 gtk_window_present(@ptrFromInt(existing));
307 bridge_error.sendResultToJS(allocator, action, result);
308 return;
309 }
310
311 const width = json_utils.getInt(u32, json, "width") orelse 800;
312 const height = json_utils.getInt(u32, json, "height") orelse 600;
313 if (width == 0 or height == 0 or width > @as(u32, std.math.maxInt(c_int)) or height > @as(u32, std.math.maxInt(c_int)))
314 return error.InvalidParameter;
315 var created = try Window.create(.{
316 .title = title orelse name,
317 .width = width,
318 .height = height,
319 .x = json_utils.getInt(i32, json, "x"),
320 .y = json_utils.getInt(i32, json, "y"),
321 .resizable = json_utils.getBool(json, "resizable") orelse true,
322 .frameless = json_utils.getBool(json, "frameless") orelse false,
323 .fullscreen = json_utils.getBool(json, "fullscreen") orelse false,
324 .dev_tools = json_utils.getBool(json, "devTools") orelse false,
325 });
326 errdefer created.close();
327 if (url) |text| try created.loadURL(text) else if (html) |text| try created.loadHTML(text);
328 if (!window_registry.rememberNamedOwned(@intFromPtr(created.gtk_window), name, owner))
329 return error.TooManyWindows;
330 created.show();
331 bridge_error.sendResultToJS(allocator, action, result);
332}
333
334fn targetWindow(data: ?[]const u8) !desktop_window_registry.Entry {
335 if (data) |json| {
336 const name = try json_utils.getStringDecoded(std.heap.c_allocator, json, "windowId");
337 defer if (name) |text| std.heap.c_allocator.free(text);
338 if (name) |text| {
339 if (!std.mem.eql(u8, text, "main")) {
340 const handle = window_registry.byName(text) orelse return error.NotFound;
341 return desktop_windows.byWindow(handle) orelse error.NotFound;
342 }
343 }
344 }
345 return desktop_windows.byWindow(window_context.current() orelse return error.WindowHandleNotSet) orelse error.WindowHandleNotSet;
346}
347
348fn handleWindowAction(action: []const u8, data: ?[]const u8) !void {
349 if (std.mem.eql(u8, action, "open") or std.mem.eql(u8, action, "create"))
350 return openNamedWindow(action, data);
351
352 const entry = try targetWindow(data);
353 const window: *anyopaque = @ptrFromInt(entry.window);
354 const webview: *anyopaque = @ptrFromInt(entry.webview);
355 if (std.mem.eql(u8, action, "show") or std.mem.eql(u8, action, "focus")) {
356 gtk_window_present(window);
357 } else if (std.mem.eql(u8, action, "hide")) {
358 gtk_widget_hide(window);
359 } else if (std.mem.eql(u8, action, "close") or std.mem.eql(u8, action, "destroy")) {
360 gtk_window_close(window);
361 } else if (std.mem.eql(u8, action, "minimize")) {
362 gtk_window_minimize(window);
363 } else if (std.mem.eql(u8, action, "maximize")) {
364 gtk_window_maximize(window);
365 } else if (std.mem.eql(u8, action, "unmaximize") or std.mem.eql(u8, action, "restore")) {
366 gtk_window_unmaximize(window);
367 } else if (std.mem.eql(u8, action, "reload")) {
368 webkit_web_view_reload(webview);
369 } else if (std.mem.eql(u8, action, "setTitle")) {
370 const json = data orelse return error.MissingData;
371 const title = (try json_utils.getStringDecoded(std.heap.c_allocator, json, "title")) orelse return error.InvalidParameter;
372 defer std.heap.c_allocator.free(title);
373 if (std.mem.indexOfScalar(u8, title, 0) != null) return error.InvalidParameter;
374 const title_z = try @import("memory.zig").dupeZ(std.heap.c_allocator, u8, title);
375 defer std.heap.c_allocator.free(title_z);
376 gtk_window_set_title(window, title_z);
377 } else if (std.mem.eql(u8, action, "setSize")) {
378 const json = data orelse return error.MissingData;
379 const width = json_utils.getInt(u32, json, "width") orelse return error.InvalidParameter;
380 const height = json_utils.getInt(u32, json, "height") orelse return error.InvalidParameter;
381 if (width == 0 or height == 0 or width > @as(u32, std.math.maxInt(c_int)) or height > @as(u32, std.math.maxInt(c_int)))
382 return error.InvalidParameter;
383 gtk_window_set_default_size(window, @intCast(width), @intCast(height));
384 } else if (std.mem.eql(u8, action, "setPosition")) {
385 const json = data orelse return error.MissingData;
386 const x = json_utils.getInt(i32, json, "x") orelse return error.InvalidParameter;
387 const y = json_utils.getInt(i32, json, "y") orelse return error.InvalidParameter;
388 gtk_window_set_position(window, x, y);
389 } else if (std.mem.eql(u8, action, "loadURL") or std.mem.eql(u8, action, "loadHTML")) {
390 const json = data orelse return error.MissingData;
391 const key: []const u8 = if (std.mem.eql(u8, action, "loadURL")) "url" else "html";
392 const value = (try json_utils.getStringDecoded(std.heap.c_allocator, json, key)) orelse return error.InvalidParameter;
393 defer std.heap.c_allocator.free(value);
394 if (std.mem.indexOfScalar(u8, value, 0) != null) return error.InvalidParameter;
395 const value_z = try @import("memory.zig").dupeZ(std.heap.c_allocator, u8, value);
396 defer std.heap.c_allocator.free(value_z);
397 if (std.mem.eql(u8, action, "loadURL")) webkit_web_view_load_uri(webview, value_z) else webkit_web_view_load_html(webview, value_z, "");
398 } else {
399 return error.PlatformNotSupported;
400 }
224401}
225402
226403// Application state
@@ -265,9 +442,16 @@ pub const Window = struct {
265442 }
266443
267444 const window = gtk_application_window_new(app_instance.?);
445 errdefer gtk_window_close(window);
268446
269447 // Create WebView
270448 const webview = webkit_web_view_new();
449 const manager = webkit_web_view_get_user_content_manager(webview);
450 // Connect before registration: WebKit can emit a page message as soon
451 // as the injected document-start API becomes available.
452 if (g_signal_connect_data(manager, "script-message-received::craft", @ptrCast(&onScriptMessage), webview, null, 0) == 0 or
453 webkit_user_content_manager_register_script_message_handler(manager, "craft") == 0)
454 return error.SignalConnectionFailed;
271455
272456 // Configure WebView settings
273457 const settings = webkit_web_view_get_settings(webview);
@@ -338,12 +522,10 @@ pub const Window = struct {
338522
339523 // Register window in the multi-window registry
340524 const window_id = registerWindow(window, webview) orelse {
341 gtk_window_close(window);
342525 return error.TooManyWindows;
343526 };
344527 if (g_signal_connect_data(window, "destroy", @ptrCast(&onWindowDestroyed), null, null, 0) == 0) {
345528 _ = desktop_windows.forgetWindow(@intFromPtr(window));
346 gtk_window_close(window);
347529 return error.SignalConnectionFailed;
348530 }
349531
@@ -357,8 +539,6 @@ pub const Window = struct {
357539 .x = x,
358540 .y = y,
359541 };
360 errdefer created.close();
361
362542 // Register the page API before any load. The user-content manager
363543 // reapplies this document-start script after navigation too.
364544 try created.injectScript(@embedFile("js/craft-bridge.js"));