core/gtk/glfw: open urls using an apprt action instead of doing it directly

Partial implementation of #5256

This implements the core changes necessary to open urls using an apprt
action rather than doing it directly from the core.

Implements the open_url action in the GTK and GLFW apprts.

Note that this should not be merged until a macOS-savvy developer can add
an implementation of the open_url action for the macOS apprt.

Author: jcollie

Diff for: include/ghostty.h

@@ -558,6 +558,18 @@ typedef struct {
   bool soft;
 } ghostty_action_reload_config_s;
 
+// apprt.action.OpenUrlKind
+typedef enum {
+  GHOSTTY_ACTION_OPEN_URL_KIND_TEXT,
+  GHOSTTY_ACTION_OPEN_URL_KIND_UNKNOWN,
+} ghostty_action_open_url_kind_e;
+
+// apprt.action.OpenUrl.C
+typedef struct {
+  ghostty_action_open_url_kind_e kind;
+  const char* url;
+} ghostty_action_open_url_s;
+
 // apprt.Action.Key
 typedef enum {
   GHOSTTY_ACTION_QUIT,
@@ -599,6 +611,7 @@ typedef enum {
   GHOSTTY_ACTION_COLOR_CHANGE,
   GHOSTTY_ACTION_RELOAD_CONFIG,
   GHOSTTY_ACTION_CONFIG_CHANGE,
+  GHOSTTY_ACTION_OPEN_URL,
 } ghostty_action_tag_e;
 
 typedef union {
@@ -625,6 +638,7 @@ typedef union {
   ghostty_action_color_change_s color_change;
   ghostty_action_reload_config_s reload_config;
   ghostty_action_config_change_s config_change;
+  ghostty_action_open_url_s open_url;
 } ghostty_action_u;
 
 typedef struct {

Diff for: src/Surface.zig

@@ -3275,15 +3275,25 @@ fn processLinks(self: *Surface, pos: apprt.CursorPos) !bool {
                 .trim = false,
             });
             defer self.alloc.free(str);
-            try internal_os.open(self.alloc, .unknown, str);
+            _ = try self.rt_app.performAction(
+                .{ .surface = self },
+                .open_url,
+                .{ .kind = .unknown, .url = str },
+            );
         },
 
         ._open_osc8 => {
             const uri = self.osc8URI(sel.start()) orelse {
                 log.warn("failed to get URI for OSC8 hyperlink", .{});
                 return false;
             };
-            try internal_os.open(self.alloc, .unknown, uri);
+            const str = try self.alloc.dupeZ(u8, uri);
+            defer self.alloc.free(str);
+            _ = try self.rt_app.performAction(
+                .{ .surface = self },
+                .open_url,
+                .{ .kind = .unknown, .url = str },
+            );
         },
     }
 
@@ -4429,7 +4439,15 @@ fn writeScreenFile(
     const path = try tmp_dir.dir.realpath(filename, &path_buf);
 
     switch (write_action) {
-        .open => try internal_os.open(self.alloc, .text, path),
+        .open => {
+            const str = try self.alloc.dupeZ(u8, path);
+            defer self.alloc.free(str);
+            _ = try self.rt_app.performAction(
+                .{ .surface = self },
+                .open_url,
+                .{ .kind = .text, .url = str },
+            );
+        },
         .paste => self.io.queueMessage(try termio.Message.writeReq(
             self.alloc,
             path,

Diff for: src/apprt/action.zig

@@ -230,6 +230,11 @@ pub const Action = union(Key) {
     /// for changes.
     config_change: ConfigChange,
 
+    /// Open a URL using the native OS mechanisms. On macOS this might be `open`
+    /// or on Linux this might be `xdg-open`. The exact mechanism is up to the
+    /// apprt.
+    open_url: OpenUrl,
+
     /// Sync with: ghostty_action_tag_e
     pub const Key = enum(c_int) {
         quit,
@@ -271,6 +276,7 @@ pub const Action = union(Key) {
         color_change,
         reload_config,
         config_change,
+        open_url,
     };
 
     /// Sync with: ghostty_action_u
@@ -555,3 +561,27 @@ pub const ConfigChange = struct {
         };
     }
 };
+
+// Sync with: ghostty_action_open_url_kind_s
+pub const OpenUrlKind = enum(c_int) {
+    text,
+    unknown,
+};
+
+pub const OpenUrl = struct {
+    kind: OpenUrlKind,
+    url: [:0]const u8,
+
+    // Sync with: ghostty_action_open_url_s
+    pub const C = extern struct {
+        kind: OpenUrlKind,
+        url: [*:0]const u8,
+    };
+
+    pub fn cval(self: OpenUrl) C {
+        return .{
+            .kind = self.kind,
+            .url = self.url.ptr,
+        };
+    }
+};

Diff for: src/apprt/glfw.zig

@@ -211,6 +211,8 @@ pub const App = struct {
 
             .reload_config => try self.reloadConfig(target, value),
 
+            .open_url => self.openUrl(value),
+
             // Unimplemented
             .new_split,
             .goto_split,
@@ -433,6 +435,17 @@ pub const App = struct {
         return .unknown;
     }
 
+    /// Open a URL. On Linux, use the new `openUrlLinux` otherwise fall back
+    /// to `open`.
+    fn openUrl(self: *App, value: apprt.action.OpenUrl) void {
+        switch (builtin.os.tag) {
+            .linux => internal_os.openUrlLinux(self.app.alloc, value.url),
+            else => internal_os.open(self.alloc, value.kind, value.url) catch |err| {
+                log.warn("unable to open url: {}", .{err});
+            },
+        }
+    }
+
     /// Mac-specific settings. This is only enabled when the target is
     /// Mac and the artifact is a standalone exe. We don't target libs because
     /// the embedded API doesn't do windowing.

Diff for: src/apprt/gtk/App.zig

@@ -496,6 +496,7 @@ pub fn performAction(
         .toggle_window_decorations => self.toggleWindowDecorations(target),
         .quit_timer => self.quitTimer(value),
         .prompt_title => try self.promptTitle(target),
+        .open_url => self.openUrl(value),
 
         // Unimplemented
         .close_all_windows,
@@ -1807,3 +1808,10 @@ test "isValidAppId" {
     try testing.expect(!isValidAppId(""));
     try testing.expect(!isValidAppId("foo" ** 86));
 }
+
+pub fn openUrl(
+    app: *App,
+    value: apprt.action.OpenUrl,
+) void {
+    internal_os.openUrlLinux(app.core_app.alloc, value.url);
+}

Diff for: src/os/main.zig

@@ -47,6 +47,7 @@ pub const expandHome = homedir.expandHome;
 pub const ensureLocale = locale.ensureLocale;
 pub const clickInterval = mouse.clickInterval;
 pub const open = openpkg.open;
+pub const openUrlLinux = openpkg.openUrlLinux;
 pub const OpenType = openpkg.Type;
 pub const pipe = pipepkg.pipe;
 pub const resourcesDir = resourcesdir.resourcesDir;

Diff for: src/os/open.zig

@@ -2,6 +2,10 @@ const std = @import("std");
 const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 
+const CircBuf = @import("../datastruct/circ_buf.zig").CircBuf;
+
+const log = std.log.scoped(.os);
+
 /// The type of the data at the URL to open. This is used as a hint
 /// to potentially open the URL in a different way.
 pub const Type = enum {
@@ -77,3 +81,131 @@ const OpenCommand = struct {
     child: std.process.Child,
     wait: bool = false,
 };
+
+/// Use `xdg-open` to open a URL using the default application.
+///
+/// Any output on stderr is logged as a warning in the application logs. Output
+/// on stdout is ignored.
+pub fn openUrlLinux(
+    alloc: Allocator,
+    url: [:0]const u8,
+) void {
+    // Make a copy of the URL so that we can use it in the thread without
+    // worrying about it getting freed by other threads.
+    const copy = alloc.dupe(u8, url) catch |err| {
+        log.warn("unable to copy URL before opening: {}", .{err});
+        return;
+    };
+    // Run `xdg-open` in a thread so that it never blocks the main thread, no
+    // matter how long it takes to execute.
+    const thread = std.Thread.spawn(.{}, _openUrlLinux, .{ alloc, copy }) catch |err| {
+        alloc.free(url);
+        log.warn("unable to start thread to launch url: {}", .{err});
+        return;
+    };
+    // Don't worry about the thread any more.
+    thread.detach();
+}
+
+fn _openUrlLinux(alloc: Allocator, url: []const u8) void {
+    defer alloc.free(url);
+
+    var exe = std.process.Child.init(
+        &.{ "xdg-open", url },
+        alloc,
+    );
+
+    // We're only interested in stderr
+    exe.stdin_behavior = .Ignore;
+    exe.stdout_behavior = .Ignore;
+    exe.stderr_behavior = .Pipe;
+
+    exe.spawn() catch |err| {
+        switch (err) {
+            error.FileNotFound => {
+                log.err("Unable to find xdg-open. Please install xdg-open and ensure that it is available on the PATH.", .{});
+            },
+            else => {
+                log.warn("Unable to spawn xdg-open: {}", .{err});
+            },
+        }
+        return;
+    };
+
+    const stderr = exe.stderr orelse {
+        log.warn("Unable to access the stderr of the spawned program!", .{});
+        return;
+    };
+
+    var cb = CircBuf(u8, 0).init(alloc, 50 * 1024) catch |err| {
+        log.warn("Unable to create circular buffer: {}", .{err});
+        return;
+    };
+    defer cb.deinit(alloc);
+
+    // Read any error output and store it in a circular buffer so that we
+    // get that _last_ 50K of output.
+    while (true) {
+        var buf: [1024]u8 = undefined;
+        const len = stderr.read(&buf) catch |err| {
+            log.warn("Unable to read data from xdg-open: {}", .{err});
+            return;
+        };
+        if (len == 0) break;
+        cb.appendSlice(buf[0..len]) catch |err| {
+            log.warn("Unable to append data to circular buffer: {}", .{err});
+            return;
+        };
+    }
+
+    // If we have any stderr output we log it. This makes it easier for users to
+    // debug why some open commands may not work as expected.
+    if (cb.len() > 0) log: {
+        {
+            var it = cb.iterator(.forward);
+            while (it.next()) |char| {
+                if (std.mem.indexOfScalar(u8, &std.ascii.whitespace, char.*)) |_| continue;
+                break;
+            }
+            // it's all whitespace, don't log
+            break :log;
+        }
+        var buf = std.ArrayList(u8).init(alloc);
+        defer buf.deinit();
+        var it = cb.iterator(.forward);
+        while (it.next()) |char| {
+            if (char.* == '\n') {
+                log.err("xdg-open stderr: {s}", .{buf.items});
+                buf.clearRetainingCapacity();
+            }
+            buf.append(char.*) catch |err| {
+                log.warn("Unable to append data to buffer: {}", .{err});
+                return;
+            };
+        }
+        if (buf.items.len > 0)
+            log.err("xdg-open stderr: {s}", .{buf.items});
+    }
+
+    const rc = exe.wait() catch |err| {
+        log.warn("Unable to wait for xdg-open: {}", .{err});
+        return;
+    };
+
+    switch (rc) {
+        .Exited => |code| {
+            if (code != 0) {
+                log.warn("xdg-open exited with error code {d}", .{code});
+            }
+        },
+        .Signal => |signal| {
+            log.warn("xdg-open was terminaled with signal {}", .{signal});
+        },
+        .Stopped => |signal| {
+            log.warn("xdg-open was stopped with signal {}", .{signal});
+        },
+        .Unknown => |code| {
+            log.warn("xdg-open had an unknown error {}", .{code});
+        },
+    }
+}