core, gtk: implement host resources dir for Flatpak

Introduces host resources directory as a new concept: A directory
containing application resources that can only be accessed from the host
operating system. This is significant for sandboxed application runtimes
like Flatpak where shells spawned on the host should have access to
application resources to enable integrations.

Alongside this, apprt is now allowed to override the resources lookup
logic.

Author: alaviss

src/Surface.zig

@@ -543,7 +543,7 @@ pub fn init(
             .shell_integration = config.@"shell-integration",
             .shell_integration_features = config.@"shell-integration-features",
             .working_directory = config.@"working-directory",
-            .resources_dir = global_state.resources_dir,
+            .resources_dir = global_state.host_resources_dir,
             .term = config.term,
 
             // Get the cgroup if we're on linux and have the decl. I'd love

src/apprt/gtk.zig

@@ -2,6 +2,7 @@
 
 pub const App = @import("gtk/App.zig");
 pub const Surface = @import("gtk/Surface.zig");
+pub const resourcesDir = @import("gtk/flatpak.zig").resourcesDir;
 
 test {
     @import("std").testing.refAllDecls(@This());

src/apprt/gtk/flatpak.zig

@@ -0,0 +1,23 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const build_config = @import("../../build_config.zig");
+const internal_os = @import("../../os/main.zig");
+const glib = @import("glib");
+
+pub fn resourcesDir(alloc: Allocator, hostAccessible: bool) !?[]const u8 {
+    if (comptime build_config.flatpak) {
+        // Only consult Flatpak runtime data for host case.
+        if (hostAccessible and internal_os.isFlatpak()) {
+            const keyfile = glib.KeyFile.new();
+            defer keyfile.unref();
+
+            if (keyfile.loadFromFile("/.flatpak-info", .{}, null) == 0) return null;
+            const app_dir = std.mem.span(keyfile.getString("Instance", "app-path", null)) orelse return null;
+            defer glib.free(app_dir.ptr);
+
+            return try std.fs.path.join(alloc, &[_][]const u8{ app_dir, "share", "ghostty" });
+        }
+    }
+
+    return try internal_os.resourcesDir(alloc, hostAccessible);
+}

src/global.zig

@@ -9,6 +9,7 @@ const harfbuzz = @import("harfbuzz");
 const oni = @import("oniguruma");
 const crash = @import("crash/main.zig");
 const renderer = @import("renderer.zig");
+const apprt = @import("apprt.zig");
 
 /// We export the xev backend we want to use so that the rest of
 /// Ghostty can import this once and have access to the proper
@@ -37,6 +38,10 @@ pub const GlobalState = struct {
     /// from source. This is null if we can't detect it.
     resources_dir: ?[]const u8,
 
+    /// The app resources directory as seen from the host file system. Except for
+    /// sandboxed cases, this should be the same as resources_dir.
+    host_resources_dir: ?[]const u8,
+
     /// Where logging should go
     pub const Logging = union(enum) {
         disabled: void,
@@ -63,6 +68,7 @@ pub const GlobalState = struct {
             .logging = .{ .stderr = {} },
             .rlimits = .{},
             .resources_dir = null,
+            .host_resources_dir = null,
         };
         errdefer self.deinit();
 
@@ -170,9 +176,18 @@ pub const GlobalState = struct {
 
         // Find our resources directory once for the app so every launch
         // hereafter can use this cached value.
-        self.resources_dir = try internal_os.resourcesDir(self.alloc);
+        self.resources_dir = rd: {
+            if (@hasDecl(apprt.runtime, "resourcesDir")) break :rd try apprt.runtime.resourcesDir(self.alloc, false);
+            break :rd try internal_os.resourcesDir(self.alloc, false);
+        };
         errdefer if (self.resources_dir) |dir| self.alloc.free(dir);
 
+        self.host_resources_dir = rd: {
+            if (@hasDecl(apprt.runtime, "resourcesDir")) break :rd try apprt.runtime.resourcesDir(self.alloc, true);
+            break :rd try internal_os.resourcesDir(self.alloc, true);
+        };
+        errdefer if (self.host_resources_dir) |dir| self.alloc.free(dir);
+
         // Setup i18n
         if (self.resources_dir) |v| internal_os.i18n.init(v) catch |err| {
             std.log.warn("failed to init i18n, translations will not be available err={}", .{err});
@@ -183,6 +198,7 @@ pub const GlobalState = struct {
     /// doing so in dev modes will check for memory leaks.
     pub fn deinit(self: *GlobalState) void {
         if (self.resources_dir) |dir| self.alloc.free(dir);
+        if (self.host_resources_dir) |dir| self.alloc.free(dir);
 
         // Flush our crash logs
         crash.deinit();

src/os/resourcesdir.zig

@@ -6,9 +6,15 @@ const Allocator = std.mem.Allocator;
 /// exists (not all platforms or packages have it). The output is
 /// owned by the caller.
 ///
+/// `hostAccessible` should be set to true to obtain directory accessible
+/// from host environment (i.e. for sandboxed application). The returned
+/// directory might not be accesible from the application itself.
+///
 /// This is highly Ghostty-specific and can likely be generalized at
 /// some point but we can cross that bridge if we ever need to.
-pub fn resourcesDir(alloc: std.mem.Allocator) !?[]const u8 {
+pub fn resourcesDir(alloc: std.mem.Allocator, hostAccessible: bool) !?[]const u8 {
+    _ = hostAccessible;
+
     // Use the GHOSTTY_RESOURCES_DIR environment variable in release builds.
     //
     // In debug builds we try using terminfo detection first instead, since