Merge pull request #74 from forketyfork/fix/nvim-exit-delay-smear-cursor

forketyfork · web-flow · commit 4dc765fcce7f · 2026-01-09T16:03:56.000+01:00
Fix nvim exit delay and smear-cursor plugin rendering
diff --git a/build.zig b/build.zig
@@ -28,6 +28,13 @@ pub fn build(b: *std.Build) void {
         );
     }
 
+    if (b.lazyDependency("libxev", .{
+        .target = target,
+        .optimize = optimize,
+    })) |dep| {
+        exe_mod.addImport("xev", dep.module("xev"));
+    }
+
     const exe = b.addExecutable(.{
         .name = "architect",
         .root_module = exe_mod,
diff --git a/build.zig.zon b/build.zig.zon
@@ -8,6 +8,10 @@
             .url = "https://github.com/ghostty-org/ghostty/archive/f705b9f46a4083d8053cfa254898c164af46ff34.tar.gz",
             .hash = "122022d77cfd6d901de978a2667797a18d82f7ce2fd6c40d4028d6db603499dc9679",
         },
+        .libxev = .{
+            .url = "https://deps.files.ghostty.org/libxev-34fa50878aec6e5fa8f532867001ab3c36fae23e.tar.gz",
+            .hash = "libxev-0.0.0-86vtc4IcEwCqEYxEYoN_3KXmc6A9VLcm22aVImfvecYs",
+        },
     },
     .paths = .{
         "build.zig",
diff --git a/src/font.zig b/src/font.zig
@@ -47,6 +47,18 @@ pub const Font = struct {
     /// Limit cached glyph textures to avoid unbounded GPU/heap growth.
     const MAX_GLYPH_CACHE_ENTRIES: usize = 4096;
 
+    /// Maximum byte length for a single glyph string to prevent abuse from
+    /// malicious or malformed terminal output. 256 bytes allows for reasonable
+    /// grapheme clusters including emoji sequences and combining characters
+    /// while protecting against memory exhaustion attacks.
+    const MAX_GLYPH_BYTE_LENGTH: usize = 256;
+
+    /// Maximum codepoints in a single grapheme cluster before chunking.
+    /// Chosen to balance rendering performance with memory usage. Values above
+    /// this threshold are split into smaller segments to avoid creating
+    /// excessively large textures (e.g., cursor trail effects with 120+ chars).
+    const MAX_CLUSTER_SIZE: usize = 32;
+
     const CacheEntry = struct {
         texture: *c.SDL_Texture,
         seq: u64,
@@ -197,6 +209,22 @@ pub const Font = struct {
         if (codepoints.len == 0) return;
         if (codepoints.len == 1 and codepoints[0] == 0) return;
 
+        if (codepoints.len > MAX_CLUSTER_SIZE) {
+            const chars_per_chunk = MAX_CLUSTER_SIZE;
+            const cell_width = @max(1, @divTrunc(target_width, @as(c_int, @intCast(codepoints.len))));
+
+            var offset: usize = 0;
+            while (offset < codepoints.len) {
+                const chunk_end = @min(offset + chars_per_chunk, codepoints.len);
+                const chunk = codepoints[offset..chunk_end];
+                const chunk_x = x + @as(c_int, @intCast(offset)) * cell_width;
+                const chunk_width = @as(c_int, @intCast(chunk.len)) * cell_width;
+                try self.renderCluster(chunk, chunk_x, y, chunk_width, target_height, fg_color, variant);
+                offset = chunk_end;
+            }
+            return;
+        }
+
         const effective_variant = self.effectiveVariant(variant, codepoints);
 
         var total_bytes: usize = 0;
@@ -265,6 +293,22 @@ pub const Font = struct {
         if (codepoints.len == 0) return;
         if (codepoints.len == 1 and codepoints[0] == 0) return;
 
+        if (codepoints.len > MAX_CLUSTER_SIZE) {
+            const chars_per_chunk = MAX_CLUSTER_SIZE;
+            const cell_width = @max(1, @divTrunc(target_width, @as(c_int, @intCast(codepoints.len))));
+
+            var offset: usize = 0;
+            while (offset < codepoints.len) {
+                const chunk_end = @min(offset + chars_per_chunk, codepoints.len);
+                const chunk = codepoints[offset..chunk_end];
+                const chunk_x = x + @as(c_int, @intCast(offset)) * cell_width;
+                const chunk_width = @as(c_int, @intCast(chunk.len)) * cell_width;
+                try self.renderClusterFill(chunk, chunk_x, y, chunk_width, target_height, fg_color, variant);
+                offset = chunk_end;
+            }
+            return;
+        }
+
         const effective_variant = self.effectiveVariant(variant, codepoints);
 
         var total_bytes: usize = 0;
@@ -350,6 +394,11 @@ pub const Font = struct {
     }
 
     fn getGlyphTexture(self: *Font, utf8: []const u8, fg_color: c.SDL_Color, fallback: Fallback, variant: Variant) RenderGlyphError!*c.SDL_Texture {
+        if (utf8.len > MAX_GLYPH_BYTE_LENGTH) {
+            log.warn("Refusing to render excessively long glyph string: {d} bytes", .{utf8.len});
+            return error.GlyphRenderFailed;
+        }
+
         const key = GlyphKey{
             .hash = std.hash.Wyhash.hash(0, utf8),
             .color = packColor(if (fallback == .emoji) WHITE else fg_color),
diff --git a/src/main.zig b/src/main.zig
@@ -3,6 +3,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const posix = std.posix;
+const xev = @import("xev");
 const app_state = @import("app/app_state.zig");
 const notify = @import("session/notify.zig");
 const session_state = @import("session/state.zig");
@@ -241,14 +242,17 @@ pub fn main() !void {
         }
     }
 
+    var loop = try xev.Loop.init(.{});
+    defer loop.deinit();
+
     for (0..GRID_ROWS * GRID_COLS) |i| {
         var session_buf: [16]u8 = undefined;
         const session_z = try std.fmt.bufPrintZ(&session_buf, "{d}", .{i});
         sessions[i] = try SessionState.init(allocator, i, shell_path, size, session_z, notify_sock);
         init_count += 1;
     }
 
-    try sessions[0].ensureSpawned();
+    try sessions[0].ensureSpawnedWithLoop(&loop);
 
     defer {
         for (&sessions) |*session| {
@@ -417,7 +421,7 @@ pub fn main() !void {
                     ) orelse continue;
 
                     var session = &sessions[hovered_session];
-                    try session.ensureSpawned();
+                    try session.ensureSpawnedWithLoop(&loop);
 
                     const escaped = shellQuotePath(allocator, drop_path) catch |err| {
                         std.debug.print("Failed to escape dropped path: {}\n", .{err});
@@ -514,7 +518,7 @@ pub fn main() !void {
 
                             defer if (cwd_buf) |buf| allocator.free(buf);
 
-                            try sessions[next_free_idx].ensureSpawnedWithDir(cwd_z);
+                            try sessions[next_free_idx].ensureSpawnedWithDir(cwd_z, &loop);
                             sessions[next_free_idx].status = .running;
                             sessions[next_free_idx].attention = false;
 
@@ -761,6 +765,8 @@ pub fn main() !void {
             }
         }
 
+        try loop.run(.no_wait);
+
         var any_session_dirty = false;
         var has_scroll_inertia = false;
         for (&sessions) |*session| {
diff --git a/src/render/renderer.zig b/src/render/renderer.zig
@@ -168,8 +168,18 @@ fn renderSessionContent(
     term_cols: u16,
     term_rows: u16,
 ) RenderError!void {
+    if (!session.spawned) return;
+
+    const terminal = session.terminal orelse {
+        log.err("session {d} is spawned but terminal is null!", .{session.id});
+        return;
+    };
+
     const base_bg = c.SDL_Color{ .r = 14, .g = 17, .b = 22, .a = 255 };
-    const session_bg_color = base_bg;
+    const session_bg_color = if (terminal.colors.background.get()) |rgb|
+        c.SDL_Color{ .r = rgb.r, .g = rgb.g, .b = rgb.b, .a = 255 }
+    else
+        base_bg;
 
     _ = c.SDL_SetRenderDrawColor(renderer, session_bg_color.r, session_bg_color.g, session_bg_color.b, session_bg_color.a);
     const bg_rect = c.SDL_FRect{
@@ -179,13 +189,6 @@ fn renderSessionContent(
         .h = @floatFromInt(rect.h),
     };
     _ = c.SDL_RenderFillRect(renderer, &bg_rect);
-
-    if (!session.spawned) return;
-
-    const terminal = session.terminal orelse {
-        log.err("session {d} is spawned but terminal is null!", .{session.id});
-        return;
-    };
     const screen = terminal.screens.active;
     const cursor_visible = terminal.modes.get(.cursor_visible);
     const pages = screen.pages;
@@ -248,7 +251,10 @@ fn renderSessionContent(
 
             const style = list_cell.style();
             var fg_color = getCellColor(style.fg_color, default_fg);
-            var bg_color = getCellColor(style.bg_color, session_bg_color);
+            var bg_color = if (style.bg(list_cell.cell, &terminal.colors.palette.current)) |rgb|
+                c.SDL_Color{ .r = rgb.r, .g = rgb.g, .b = rgb.b, .a = 255 }
+            else
+                session_bg_color;
             const variant = chooseVariant(style);
 
             if (style.flags.inverse) {
diff --git a/src/session/state.zig b/src/session/state.zig
@@ -1,6 +1,7 @@
 const std = @import("std");
 const posix = std.posix;
 const builtin = @import("builtin");
+const xev = @import("xev");
 const ghostty_vt = @import("ghostty-vt");
 const shell_mod = @import("../shell.zig");
 const pty_mod = @import("../pty.zig");
@@ -72,6 +73,10 @@ pub const SessionState = struct {
     hovered_link_start: ?ghostty_vt.Pin = null,
     hovered_link_end: ?ghostty_vt.Pin = null,
     pending_write: std.ArrayListUnmanaged(u8) = .empty,
+    /// Process watcher for event-driven exit detection.
+    process_watcher: ?xev.Process = null,
+    /// Completion structure for process wait callback.
+    process_completion: xev.Completion = .{},
 
     pub const InitError = shell_mod.Shell.SpawnError || MakeNonBlockingError || error{
         DivisionByZero,
@@ -85,6 +90,9 @@ pub const SessionState = struct {
         StringAllocOutOfMemory,
         StyleSetNeedsRehash,
         StyleSetOutOfMemory,
+        SystemResources,
+        SystemFdQuotaExceeded,
+        InvalidArgument,
     };
 
     pub fn init(
@@ -115,10 +123,14 @@ pub const SessionState = struct {
     }
 
     pub fn ensureSpawned(self: *SessionState) InitError!void {
-        return self.ensureSpawnedWithDir(null);
+        return self.ensureSpawnedWithDir(null, null);
     }
 
-    pub fn ensureSpawnedWithDir(self: *SessionState, working_dir: ?[:0]const u8) InitError!void {
+    pub fn ensureSpawnedWithLoop(self: *SessionState, loop: *xev.Loop) InitError!void {
+        return self.ensureSpawnedWithDir(null, loop);
+    }
+
+    pub fn ensureSpawnedWithDir(self: *SessionState, working_dir: ?[:0]const u8, loop_opt: ?*xev.Loop) InitError!void {
         if (self.spawned) return;
 
         const shell = try shell_mod.Shell.spawn(
@@ -153,6 +165,21 @@ pub const SessionState = struct {
         self.cwd_dirty = true;
         self.dirty = true;
 
+        if (loop_opt) |loop| {
+            var process = try xev.Process.init(shell.child_pid);
+            errdefer process.deinit();
+
+            process.wait(
+                loop,
+                &self.process_completion,
+                SessionState,
+                self,
+                processExitCallback,
+            );
+
+            self.process_watcher = process;
+        }
+
         log.debug("spawned session {d}", .{self.id});
 
         self.processOutput() catch {};
@@ -177,6 +204,9 @@ pub const SessionState = struct {
         if (self.cwd_path) |path| {
             allocator.free(path);
         }
+        if (self.process_watcher) |*watcher| {
+            watcher.deinit();
+        }
         if (self.spawned) {
             if (self.stream) |*stream| {
                 stream.deinit();
@@ -204,6 +234,25 @@ pub const SessionState = struct {
         StyleSetOutOfMemory,
     };
 
+    fn processExitCallback(
+        self_opt: ?*SessionState,
+        _: *xev.Loop,
+        _: *xev.Completion,
+        r: xev.Process.WaitError!u32,
+    ) xev.CallbackAction {
+        const self = self_opt orelse return .disarm;
+        const exit_code = r catch |err| {
+            log.err("process wait error for session {d}: {}", .{ self.id, err });
+            return .disarm;
+        };
+
+        self.dead = true;
+        self.dirty = true;
+        log.info("session {d} process exited with code {d}", .{ self.id, exit_code });
+
+        return .disarm;
+    }
+
     pub fn checkAlive(self: *SessionState) void {
         if (!self.spawned or self.dead) return;
 
@@ -223,6 +272,10 @@ pub const SessionState = struct {
 
         self.clearSelection();
         self.pending_write.clearAndFree(self.allocator);
+        if (self.process_watcher) |*watcher| {
+            watcher.deinit();
+            self.process_watcher = null;
+        }
         if (self.spawned) {
             if (self.stream) |*stream| {
                 stream.deinit();
