aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/terminal/tmux
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/terminal/tmux
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/terminal/tmux')
-rw-r--r--vendor/libghostty-vt/src/terminal/tmux/control.zig839
-rw-r--r--vendor/libghostty-vt/src/terminal/tmux/layout.zig638
-rw-r--r--vendor/libghostty-vt/src/terminal/tmux/output.zig590
-rw-r--r--vendor/libghostty-vt/src/terminal/tmux/viewer.zig2283
4 files changed, 4350 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/terminal/tmux/control.zig b/vendor/libghostty-vt/src/terminal/tmux/control.zig
new file mode 100644
index 00000000..3b94eb16
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/tmux/control.zig
@@ -0,0 +1,839 @@
+//! This file contains the implementation for tmux control mode. See
+//! tmux(1) for more information on control mode. Some basics are documented
+//! here but this is not meant to be a comprehensive source of protocol
+//! documentation.
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const assert = @import("../../quirks.zig").inlineAssert;
+const oni = @import("oniguruma");
+
+const log = std.log.scoped(.terminal_tmux);
+
+/// A tmux control mode parser. This takes in output from tmux control
+/// mode and parses it into a structured notifications.
+///
+/// It is up to the caller to establish the connection to the tmux
+/// control mode session in some way (e.g. via exec, a network socket,
+/// whatever). This is fully agnostic to how the data is received and sent.
+pub const Parser = struct {
+ /// Current state of the client.
+ state: State = .idle,
+
+ /// The buffer used to store in-progress notifications, output, etc.
+ buffer: std.Io.Writer.Allocating,
+
+ /// The maximum size in bytes of the buffer. This is used to limit
+ /// memory usage. If the buffer exceeds this size, the client will
+ /// enter a broken state (the control mode session will be forcibly
+ /// exited and future data dropped).
+ max_bytes: usize = 1024 * 1024,
+
+ const State = enum {
+ /// Outside of any active notifications. This should drop any output
+ /// unless it is '%' on the first byte of a line. The buffer will be
+ /// cleared when it sees '%', this is so that the previous notification
+ /// data is valid until we receive/process new data.
+ idle,
+
+ /// We experienced unexpected input and are in a broken state
+ /// so we cannot continue processing. When this state is set,
+ /// the buffer has been deinited and must not be accessed.
+ broken,
+
+ /// Inside an active notification (started with '%').
+ notification,
+
+ /// Inside a begin/end block.
+ block,
+ };
+
+ pub fn deinit(self: *Parser) void {
+ // If we're in a broken state, we already deinited
+ // the buffer, so we don't need to do anything.
+ if (self.state == .broken) return;
+
+ self.buffer.deinit();
+ }
+
+ // Handle a byte of input.
+ //
+ // If we reach our byte limit this will return OutOfMemory. It only
+ // does this on the first time we exceed the limit; subsequent calls
+ // will return null as we drop all input in a broken state.
+ pub fn put(self: *Parser, byte: u8) Allocator.Error!?Notification {
+ // If we're in a broken state, just do nothing.
+ //
+ // We have to do this check here before we check the buffer, because if
+ // we're in a broken state then we'd have already deinited the buffer.
+ if (self.state == .broken) return null;
+
+ if (self.buffer.written().len >= self.max_bytes) {
+ self.broken();
+ return error.OutOfMemory;
+ }
+
+ switch (self.state) {
+ // Drop because we're in a broken state.
+ .broken => return null,
+
+ // Waiting for a notification so if the byte is not '%' then
+ // we're in a broken state. Control mode output should always
+ // be wrapped in '%begin/%end' orelse we expect a notification.
+ // Return an exit notification.
+ .idle => if (byte != '%') {
+ self.broken();
+ return .{ .exit = {} };
+ } else {
+ self.buffer.clearRetainingCapacity();
+ self.state = .notification;
+ },
+
+ // If we're in a notification and its not a newline then
+ // we accumulate. If it is a newline then we have a
+ // complete notification we need to parse.
+ .notification => if (byte == '\n') {
+ // We have a complete notification, parse it.
+ return self.parseNotification() catch {
+ // If parsing failed, then we do not mark the state
+ // as broken because we may be able to continue parsing
+ // other types of notifications.
+ //
+ // In the future we may want to emit a notification
+ // here about unknown or unsupported notifications.
+ return null;
+ };
+ },
+
+ // If we're in a block then we accumulate until we see a newline
+ // and then we check to see if that line ended the block.
+ .block => if (byte == '\n') {
+ const written = self.buffer.written();
+ const idx = if (std.mem.lastIndexOfScalar(
+ u8,
+ written,
+ '\n',
+ )) |v| v + 1 else 0;
+ const line = written[idx..];
+
+ if (parseBlockTerminator(line)) |terminator| {
+ const output = std.mem.trimRight(
+ u8,
+ written[0..idx],
+ "\r\n",
+ );
+
+ // Important: do not clear buffer since the notification
+ // contains it.
+ self.state = .idle;
+ switch (terminator) {
+ .end => return .{ .block_end = output },
+ .err => {
+ log.warn("tmux control mode error={s}", .{output});
+ return .{ .block_err = output };
+ },
+ }
+ }
+
+ // Didn't end the block, continue accumulating.
+ },
+ }
+
+ self.buffer.writer.writeByte(byte) catch |err| switch (err) {
+ error.WriteFailed => return error.OutOfMemory,
+ };
+
+ return null;
+ }
+
+ const ParseError = error{RegexError};
+
+ const BlockTerminator = enum { end, err };
+
+ /// Block payload is raw data, so a line only terminates a block if it
+ /// exactly matches tmux's `%end`/`%error` guard-line shape.
+ fn parseBlockTerminator(line_raw: []const u8) ?BlockTerminator {
+ var line = line_raw;
+ if (line.len > 0 and line[line.len - 1] == '\r') {
+ line = line[0 .. line.len - 1];
+ }
+
+ var fields = std.mem.tokenizeScalar(u8, line, ' ');
+ const cmd = fields.next() orelse return null;
+ const terminator: BlockTerminator = if (std.mem.eql(u8, cmd, "%end"))
+ .end
+ else if (std.mem.eql(u8, cmd, "%error"))
+ .err
+ else
+ return null;
+
+ const time = fields.next() orelse return null;
+ const command_id = fields.next() orelse return null;
+ const flags = fields.next() orelse return null;
+ const extra = fields.next();
+
+ // In the future, we should compare these to the %begin block
+ // because the tmux source guarantees that these always match and
+ // that is a more robust way to match.
+ _ = std.fmt.parseInt(usize, time, 10) catch return null;
+ _ = std.fmt.parseInt(usize, command_id, 10) catch return null;
+ _ = std.fmt.parseInt(usize, flags, 10) catch return null;
+ if (extra != null) return null;
+
+ return terminator;
+ }
+
+ fn parseNotification(self: *Parser) ParseError!?Notification {
+ assert(self.state == .notification);
+
+ const line = line: {
+ var line = self.buffer.written();
+ if (line[line.len - 1] == '\r') line = line[0 .. line.len - 1];
+ break :line line;
+ };
+ const cmd = cmd: {
+ const idx = std.mem.indexOfScalar(u8, line, ' ') orelse line.len;
+ break :cmd line[0..idx];
+ };
+
+ // The notification MUST exist because we guard entering the notification
+ // state on seeing at least a '%'.
+ if (std.mem.eql(u8, cmd, "%begin")) {
+ // We don't use the rest of the tokens for now because tmux
+ // claims to guarantee that begin/end are always in order and
+ // never intermixed. In the future, we should probably validate
+ // this.
+ // TODO(tmuxcc): do this before merge?
+
+ // Move to block state because we expect a corresponding end/error
+ // and want to accumulate the data.
+ self.state = .block;
+ self.buffer.clearRetainingCapacity();
+ return null;
+ } else if (std.mem.eql(u8, cmd, "%output")) cmd: {
+ var re = oni.Regex.init(
+ "^%output %([0-9]+) (.+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+ const data = line[@intCast(starts[2])..@intCast(ends[2])];
+
+ // Important: do not clear buffer here since name points to it
+ self.state = .idle;
+ return .{ .output = .{ .pane_id = id, .data = data } };
+ } else if (std.mem.eql(u8, cmd, "%session-changed")) cmd: {
+ var re = oni.Regex.init(
+ "^%session-changed \\$([0-9]+) (.+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+ const name = line[@intCast(starts[2])..@intCast(ends[2])];
+
+ // Important: do not clear buffer here since name points to it
+ self.state = .idle;
+ return .{ .session_changed = .{ .id = id, .name = name } };
+ } else if (std.mem.eql(u8, cmd, "%sessions-changed")) cmd: {
+ if (!std.mem.eql(u8, line, "%sessions-changed")) {
+ log.warn("failed to match notification cmd={s} line=\"{s}\"", .{ cmd, line });
+ break :cmd;
+ }
+
+ self.buffer.clearRetainingCapacity();
+ self.state = .idle;
+ return .{ .sessions_changed = {} };
+ } else if (std.mem.eql(u8, cmd, "%layout-change")) cmd: {
+ var re = oni.Regex.init(
+ "^%layout-change @([0-9]+) (.+) (.+) (.*)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+ const layout = line[@intCast(starts[2])..@intCast(ends[2])];
+ const visible_layout = line[@intCast(starts[3])..@intCast(ends[3])];
+ const raw_flags = line[@intCast(starts[4])..@intCast(ends[4])];
+
+ // Important: do not clear buffer here since layout strings point to it
+ self.state = .idle;
+ return .{ .layout_change = .{
+ .window_id = id,
+ .layout = layout,
+ .visible_layout = visible_layout,
+ .raw_flags = raw_flags,
+ } };
+ } else if (std.mem.eql(u8, cmd, "%window-add")) cmd: {
+ var re = oni.Regex.init(
+ "^%window-add @([0-9]+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+
+ self.buffer.clearRetainingCapacity();
+ self.state = .idle;
+ return .{ .window_add = .{ .id = id } };
+ } else if (std.mem.eql(u8, cmd, "%window-renamed")) cmd: {
+ var re = oni.Regex.init(
+ "^%window-renamed @([0-9]+) (.+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+ const name = line[@intCast(starts[2])..@intCast(ends[2])];
+
+ // Important: do not clear buffer here since name points to it
+ self.state = .idle;
+ return .{ .window_renamed = .{ .id = id, .name = name } };
+ } else if (std.mem.eql(u8, cmd, "%window-pane-changed")) cmd: {
+ var re = oni.Regex.init(
+ "^%window-pane-changed @([0-9]+) %([0-9]+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const window_id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[1])..@intCast(ends[1])],
+ 10,
+ ) catch unreachable;
+ const pane_id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[2])..@intCast(ends[2])],
+ 10,
+ ) catch unreachable;
+
+ self.buffer.clearRetainingCapacity();
+ self.state = .idle;
+ return .{ .window_pane_changed = .{ .window_id = window_id, .pane_id = pane_id } };
+ } else if (std.mem.eql(u8, cmd, "%client-detached")) cmd: {
+ var re = oni.Regex.init(
+ "^%client-detached (.+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const client = line[@intCast(starts[1])..@intCast(ends[1])];
+
+ // Important: do not clear buffer here since client points to it
+ self.state = .idle;
+ return .{ .client_detached = .{ .client = client } };
+ } else if (std.mem.eql(u8, cmd, "%client-session-changed")) cmd: {
+ var re = oni.Regex.init(
+ "^%client-session-changed (.+) \\$([0-9]+) (.+)$",
+ .{ .capture_group = true },
+ oni.Encoding.utf8,
+ oni.Syntax.default,
+ null,
+ ) catch |err| {
+ log.warn("regex init failed error={}", .{err});
+ return error.RegexError;
+ };
+ defer re.deinit();
+
+ var region = re.search(line, .{}) catch |err| {
+ log.warn("failed to match notification cmd={s} line=\"{s}\" err={}", .{ cmd, line, err });
+ break :cmd;
+ };
+ defer region.deinit();
+ const starts = region.starts();
+ const ends = region.ends();
+
+ const client = line[@intCast(starts[1])..@intCast(ends[1])];
+ const session_id = std.fmt.parseInt(
+ usize,
+ line[@intCast(starts[2])..@intCast(ends[2])],
+ 10,
+ ) catch unreachable;
+ const name = line[@intCast(starts[3])..@intCast(ends[3])];
+
+ // Important: do not clear buffer here since client/name point to it
+ self.state = .idle;
+ return .{ .client_session_changed = .{ .client = client, .session_id = session_id, .name = name } };
+ } else {
+ // Unknown notification, log it and return to idle state.
+ log.warn("unknown tmux control mode notification={s}", .{cmd});
+ }
+
+ // Unknown command. Clear the buffer and return to idle state.
+ self.buffer.clearRetainingCapacity();
+ self.state = .idle;
+
+ return null;
+ }
+
+ // Mark the tmux state as broken.
+ fn broken(self: *Parser) void {
+ self.state = .broken;
+ self.buffer.deinit();
+ }
+};
+
+/// Possible notification types from tmux control mode. These are documented
+/// in tmux(1). A lot of the simple documentation was copied from that man
+/// page here.
+pub const Notification = union(enum) {
+ /// Entering tmux control mode. This isn't an actual event sent by
+ /// tmux but is one sent by us to indicate that we have detected that
+ /// tmux control mode is starting.
+ enter,
+
+ /// Exit.
+ ///
+ /// NOTE: The tmux protocol contains a "reason" string (human friendly)
+ /// associated with this. We currently drop it because we don't need it
+ /// but this may be something we want to add later. If we do add it,
+ /// we have to consider buffer limits and how we handle those (dropping
+ /// vs truncating, etc.).
+ exit,
+
+ /// Dispatched at the end of a begin/end block with the raw data.
+ /// The control mode parser can't parse the data because it is unaware
+ /// of the command that was sent to trigger this output.
+ block_end: []const u8,
+ block_err: []const u8,
+
+ /// Raw output from a pane.
+ output: struct {
+ pane_id: usize,
+ data: []const u8, // unescaped
+ },
+
+ /// The client is now attached to the session with ID session-id, which is
+ /// named name.
+ session_changed: struct {
+ id: usize,
+ name: []const u8,
+ },
+
+ /// A session was created or destroyed.
+ sessions_changed,
+
+ /// The layout of the window with ID window-id changed.
+ layout_change: struct {
+ window_id: usize,
+ layout: []const u8,
+ visible_layout: []const u8,
+ raw_flags: []const u8,
+ },
+
+ /// The window with ID window-id was linked to the current session.
+ window_add: struct {
+ id: usize,
+ },
+
+ /// The window with ID window-id was renamed to name.
+ window_renamed: struct {
+ id: usize,
+ name: []const u8,
+ },
+
+ /// The active pane in the window with ID window-id changed to the pane
+ /// with ID pane-id.
+ window_pane_changed: struct {
+ window_id: usize,
+ pane_id: usize,
+ },
+
+ /// The client has detached.
+ client_detached: struct {
+ client: []const u8,
+ },
+
+ /// The client is now attached to the session with ID session-id, which is
+ /// named name.
+ client_session_changed: struct {
+ client: []const u8,
+ session_id: usize,
+ name: []const u8,
+ },
+
+ pub fn format(self: Notification, writer: *std.Io.Writer) !void {
+ const T = Notification;
+ const info = @typeInfo(T).@"union";
+
+ try writer.writeAll(@typeName(T));
+ if (info.tag_type) |TagType| {
+ try writer.writeAll("{ .");
+ try writer.writeAll(@tagName(@as(TagType, self)));
+ try writer.writeAll(" = ");
+
+ inline for (info.fields) |u_field| {
+ if (self == @field(TagType, u_field.name)) {
+ const value = @field(self, u_field.name);
+ switch (u_field.type) {
+ []const u8 => try writer.print("\"{s}\"", .{std.mem.trim(u8, value, " \t\r\n")}),
+ else => try writer.print("{any}", .{value}),
+ }
+ }
+ }
+
+ try writer.writeAll(" }");
+ }
+ }
+};
+
+test "tmux begin/end empty" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1578922740 269 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1578922740 269 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("", n.block_end);
+}
+
+test "tmux begin/error empty" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1578922740 269 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%error 1578922740 269 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_err);
+ try testing.expectEqualStrings("", n.block_err);
+}
+
+test "tmux begin/end data" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1578922740 269 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\nworld\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1578922740 269 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("hello\nworld", n.block_end);
+}
+
+test "tmux block payload may start with %end" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1 1 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end not really\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1 1 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("%end not really\nhello", n.block_end);
+}
+
+test "tmux block payload may start with %error" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1 1 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%error not really\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1 1 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("%error not really\nhello", n.block_end);
+}
+
+test "tmux block may terminate with real %error after misleading payload" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1 1 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%error not really\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%error 1 1 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_err);
+ try testing.expectEqualStrings("%error not really\nhello", n.block_err);
+}
+
+test "tmux block terminator requires exact token count" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1 1 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1 1 1 trailing\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1 1 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("%end 1 1 1 trailing\nhello", n.block_end);
+}
+
+test "tmux block terminator requires numeric metadata" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%begin 1 1 1\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end foo bar baz\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("hello\n") |byte| try testing.expect(try c.put(byte) == null);
+ for ("%end 1 1 1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .block_end);
+ try testing.expectEqualStrings("%end foo bar baz\nhello", n.block_end);
+}
+
+test "tmux output" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%output %42 foo bar baz") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .output);
+ try testing.expectEqual(42, n.output.pane_id);
+ try testing.expectEqualStrings("foo bar baz", n.output.data);
+}
+
+test "tmux session-changed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%session-changed $42 foo") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .session_changed);
+ try testing.expectEqual(42, n.session_changed.id);
+ try testing.expectEqualStrings("foo", n.session_changed.name);
+}
+
+test "tmux sessions-changed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%sessions-changed") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .sessions_changed);
+}
+
+test "tmux sessions-changed carriage return" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%sessions-changed\r") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .sessions_changed);
+}
+
+test "tmux layout-change" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%layout-change @2 1234x791,0,0{617x791,0,0,0,617x791,618,0,1} 1234x791,0,0{617x791,0,0,0,617x791,618,0,1} *-") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .layout_change);
+ try testing.expectEqual(2, n.layout_change.window_id);
+ try testing.expectEqualStrings("1234x791,0,0{617x791,0,0,0,617x791,618,0,1}", n.layout_change.layout);
+ try testing.expectEqualStrings("1234x791,0,0{617x791,0,0,0,617x791,618,0,1}", n.layout_change.visible_layout);
+ try testing.expectEqualStrings("*-", n.layout_change.raw_flags);
+}
+
+test "tmux window-add" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%window-add @14") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .window_add);
+ try testing.expectEqual(14, n.window_add.id);
+}
+
+test "tmux window-renamed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%window-renamed @42 bar") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .window_renamed);
+ try testing.expectEqual(42, n.window_renamed.id);
+ try testing.expectEqualStrings("bar", n.window_renamed.name);
+}
+
+test "tmux window-pane-changed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%window-pane-changed @42 %2") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .window_pane_changed);
+ try testing.expectEqual(42, n.window_pane_changed.window_id);
+ try testing.expectEqual(2, n.window_pane_changed.pane_id);
+}
+
+test "tmux client-detached" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%client-detached /dev/pts/1") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .client_detached);
+ try testing.expectEqualStrings("/dev/pts/1", n.client_detached.client);
+}
+
+test "tmux client-session-changed" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var c: Parser = .{ .buffer = .init(alloc) };
+ defer c.deinit();
+ for ("%client-session-changed /dev/pts/1 $2 mysession") |byte| try testing.expect(try c.put(byte) == null);
+ const n = (try c.put('\n')).?;
+ try testing.expect(n == .client_session_changed);
+ try testing.expectEqualStrings("/dev/pts/1", n.client_session_changed.client);
+ try testing.expectEqual(2, n.client_session_changed.session_id);
+ try testing.expectEqualStrings("mysession", n.client_session_changed.name);
+}
diff --git a/vendor/libghostty-vt/src/terminal/tmux/layout.zig b/vendor/libghostty-vt/src/terminal/tmux/layout.zig
new file mode 100644
index 00000000..df1a5391
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/tmux/layout.zig
@@ -0,0 +1,638 @@
+const std = @import("std");
+const testing = std.testing;
+const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
+
+/// A tmux layout.
+///
+/// This is a tree structure so by definition it pretty much needs to be
+/// allocated. We leave allocation up to the user of this struct, but
+/// a general recommendation is to use an arena allocator for simplicity
+/// in freeing the entire layout at once.
+pub const Layout = struct {
+ /// Width, height of the node
+ width: usize,
+ height: usize,
+
+ /// X and Y offset from the top-left corner of the window.
+ x: usize,
+ y: usize,
+
+ /// The content of this node, either a pane (leaf) or more nodes
+ /// (split) horizontally or vertically.
+ content: Content,
+
+ pub const Content = union(enum) {
+ pane: usize,
+ horizontal: []const Layout,
+ vertical: []const Layout,
+ };
+
+ pub const ParseError = Allocator.Error || error{SyntaxError};
+
+ /// Parse a layout string that includes a 4-character checksum prefix.
+ ///
+ /// The expected format is: `XXXX,layout_string` where XXXX is the
+ /// 4-character hexadecimal checksum and the layout string follows
+ /// after the comma. For example: `f8f9,80x24,0,0{40x24,0,0,1,40x24,40,0,2}`.
+ ///
+ /// Returns `ChecksumMismatch` if the checksum doesn't match the layout.
+ /// Returns `SyntaxError` if the format is invalid.
+ pub fn parseWithChecksum(
+ alloc: Allocator,
+ str: []const u8,
+ ) (ParseError || error{ChecksumMismatch})!Layout {
+ // If the string is less than 5 characters, it can't possibly
+ // be correct. 4-char checksum + comma. In practice it should
+ // be even longer, but that'll fail parse later.
+ if (str.len < 5) return error.SyntaxError;
+ if (str[4] != ',') return error.SyntaxError;
+
+ // The layout string should start with a 4-character checksum.
+ const checksum: Checksum = .calculate(str[5..]);
+ if (!std.mem.startsWith(
+ u8,
+ str,
+ &checksum.asString(),
+ )) return error.ChecksumMismatch;
+
+ // Checksum matches, parse the rest.
+ return try parse(alloc, str[5..]);
+ }
+
+ /// Parse a layout string into a Layout structure. The given allocator
+ /// will be used for all allocations within the layout. Note that
+ /// individual nodes can't be freed so this allocator must be some
+ /// kind of arena allocator.
+ ///
+ /// The layout string must be fully provided as a single string.
+ /// Layouts are generally small so this should not be a problem.
+ ///
+ /// Tmux layout strings have the following format:
+ ///
+ /// - WxH,X,Y,ID Leaf pane: width×height, x-offset, y-offset, pane ID
+ /// - WxH,X,Y{...} Horizontal split (left-right), children comma-separated
+ /// - WxH,X,Y[...] Vertical split (top-bottom), children comma-separated
+ pub fn parse(alloc: Allocator, str: []const u8) ParseError!Layout {
+ var offset: usize = 0;
+ const root = try parseNext(
+ alloc,
+ str,
+ &offset,
+ );
+ if (offset != str.len) return error.SyntaxError;
+ return root;
+ }
+
+ fn parseNext(
+ alloc: Allocator,
+ str: []const u8,
+ offset: *usize,
+ ) ParseError!Layout {
+ // Find the first `x` to grab the width.
+ const width: usize = if (std.mem.indexOfScalar(
+ u8,
+ str[offset.*..],
+ 'x',
+ )) |idx| width: {
+ defer offset.* += idx + 1; // Consume `x`
+ break :width std.fmt.parseInt(
+ usize,
+ str[offset.* .. offset.* + idx],
+ 10,
+ ) catch return error.SyntaxError;
+ } else return error.SyntaxError;
+
+ // Find the height, up to a comma.
+ const height: usize = if (std.mem.indexOfScalar(
+ u8,
+ str[offset.*..],
+ ',',
+ )) |idx| height: {
+ defer offset.* += idx + 1; // Consume `,`
+ break :height std.fmt.parseInt(
+ usize,
+ str[offset.* .. offset.* + idx],
+ 10,
+ ) catch return error.SyntaxError;
+ } else return error.SyntaxError;
+
+ // Find X
+ const x: usize = if (std.mem.indexOfScalar(
+ u8,
+ str[offset.*..],
+ ',',
+ )) |idx| x: {
+ defer offset.* += idx + 1; // Consume `,`
+ break :x std.fmt.parseInt(
+ usize,
+ str[offset.* .. offset.* + idx],
+ 10,
+ ) catch return error.SyntaxError;
+ } else return error.SyntaxError;
+
+ // Find Y, which can end in any of `,{,[`
+ const y: usize = if (std.mem.indexOfAny(
+ u8,
+ str[offset.*..],
+ ",{[",
+ )) |idx| y: {
+ defer offset.* += idx; // Don't consume the delimiter!
+ break :y std.fmt.parseInt(
+ usize,
+ str[offset.* .. offset.* + idx],
+ 10,
+ ) catch return error.SyntaxError;
+ } else return error.SyntaxError;
+
+ // Determine our child node.
+ const content: Layout.Content = switch (str[offset.*]) {
+ ',' => content: {
+ // Consume the delimiter
+ offset.* += 1;
+
+ // Leaf pane. Read up to `,}]` because we may be in
+ // a set of nodes. If none exist, end of string is fine.
+ const idx = std.mem.indexOfAny(
+ u8,
+ str[offset.*..],
+ ",}]",
+ ) orelse str.len - offset.*;
+
+ defer offset.* += idx; // Consume the pane ID, not the delimiter
+ const pane_id = std.fmt.parseInt(
+ usize,
+ str[offset.* .. offset.* + idx],
+ 10,
+ ) catch return error.SyntaxError;
+
+ break :content .{ .pane = pane_id };
+ },
+
+ '{', '[' => |opening| content: {
+ var nodes: std.ArrayList(Layout) = .empty;
+ defer nodes.deinit(alloc);
+
+ // Move beyond our opening
+ offset.* += 1;
+
+ while (true) {
+ try nodes.append(alloc, try parseNext(
+ alloc,
+ str,
+ offset,
+ ));
+
+ // We should not reach the end of string here because
+ // we expect a closing bracket.
+ if (offset.* >= str.len) return error.SyntaxError;
+
+ // If it is a comma, we expect another node.
+ if (str[offset.*] == ',') {
+ offset.* += 1; // Consume
+ continue;
+ }
+
+ // We expect a closing bracket now.
+ switch (opening) {
+ '{' => if (str[offset.*] != '}') return error.SyntaxError,
+ '[' => if (str[offset.*] != ']') return error.SyntaxError,
+ else => return error.SyntaxError,
+ }
+
+ // Successfully parsed all children.
+ offset.* += 1; // Consume closing bracket
+ break :content switch (opening) {
+ '{' => .{ .horizontal = try nodes.toOwnedSlice(alloc) },
+ '[' => .{ .vertical = try nodes.toOwnedSlice(alloc) },
+ else => unreachable,
+ };
+ }
+ },
+
+ // indexOfAny above guarantees we have only the above
+ else => unreachable,
+ };
+
+ return .{
+ .width = width,
+ .height = height,
+ .x = x,
+ .y = y,
+ .content = content,
+ };
+ }
+};
+
+pub const Checksum = enum(u16) {
+ _,
+
+ /// Calculate the checksum of a tmux layout string.
+ /// The algorithm rotates the checksum right by 1 bit (with wraparound)
+ /// and adds the ASCII value of each character.
+ pub fn calculate(str: []const u8) Checksum {
+ var result: u16 = 0;
+ for (str) |c| {
+ // Rotate right by 1: (result >> 1) + ((result & 1) << 15)
+ result = (result >> 1) | ((result & 1) << 15);
+ result +%= c;
+ }
+
+ return @enumFromInt(result);
+ }
+
+ /// Convert the checksum to a 4-character hexadecimal string. This
+ /// is always zero-padded to match the tmux implementation
+ /// (in layout-custom.c).
+ pub fn asString(self: Checksum) [4]u8 {
+ const value = @intFromEnum(self);
+ const charset = "0123456789abcdef";
+ return .{
+ charset[(value >> 12) & 0xf],
+ charset[(value >> 8) & 0xf],
+ charset[(value >> 4) & 0xf],
+ charset[value & 0xf],
+ };
+ }
+};
+
+test "simple single pane" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0,42");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+ try testing.expectEqual(0, layout.x);
+ try testing.expectEqual(0, layout.y);
+ try testing.expectEqual(42, layout.content.pane);
+}
+
+test "single pane with offset" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "40x12,10,5,7");
+ try testing.expectEqual(40, layout.width);
+ try testing.expectEqual(12, layout.height);
+ try testing.expectEqual(10, layout.x);
+ try testing.expectEqual(5, layout.y);
+ try testing.expectEqual(7, layout.content.pane);
+}
+
+test "single pane large values" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "1920x1080,100,200,999");
+ try testing.expectEqual(1920, layout.width);
+ try testing.expectEqual(1080, layout.height);
+ try testing.expectEqual(100, layout.x);
+ try testing.expectEqual(200, layout.y);
+ try testing.expectEqual(999, layout.content.pane);
+}
+
+test "horizontal split two panes" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0{40x24,0,0,1,40x24,40,0,2}");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+ try testing.expectEqual(0, layout.x);
+ try testing.expectEqual(0, layout.y);
+
+ const children = layout.content.horizontal;
+ try testing.expectEqual(2, children.len);
+
+ try testing.expectEqual(40, children[0].width);
+ try testing.expectEqual(24, children[0].height);
+ try testing.expectEqual(0, children[0].x);
+ try testing.expectEqual(0, children[0].y);
+ try testing.expectEqual(1, children[0].content.pane);
+
+ try testing.expectEqual(40, children[1].width);
+ try testing.expectEqual(24, children[1].height);
+ try testing.expectEqual(40, children[1].x);
+ try testing.expectEqual(0, children[1].y);
+ try testing.expectEqual(2, children[1].content.pane);
+}
+
+test "vertical split two panes" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0[80x12,0,0,1,80x12,0,12,2]");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+ try testing.expectEqual(0, layout.x);
+ try testing.expectEqual(0, layout.y);
+
+ const children = layout.content.vertical;
+ try testing.expectEqual(2, children.len);
+
+ try testing.expectEqual(80, children[0].width);
+ try testing.expectEqual(12, children[0].height);
+ try testing.expectEqual(0, children[0].x);
+ try testing.expectEqual(0, children[0].y);
+ try testing.expectEqual(1, children[0].content.pane);
+
+ try testing.expectEqual(80, children[1].width);
+ try testing.expectEqual(12, children[1].height);
+ try testing.expectEqual(0, children[1].x);
+ try testing.expectEqual(12, children[1].y);
+ try testing.expectEqual(2, children[1].content.pane);
+}
+
+test "horizontal split three panes" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parse(arena.allocator(), "120x24,0,0{40x24,0,0,1,40x24,40,0,2,40x24,80,0,3}");
+ try testing.expectEqual(120, layout.width);
+ try testing.expectEqual(24, layout.height);
+
+ const children = layout.content.horizontal;
+ try testing.expectEqual(3, children.len);
+ try testing.expectEqual(1, children[0].content.pane);
+ try testing.expectEqual(2, children[1].content.pane);
+ try testing.expectEqual(3, children[2].content.pane);
+}
+
+test "nested horizontal in vertical" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ // Vertical split with top pane and bottom horizontal split
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0[80x12,0,0,1,80x12,0,12{40x12,0,12,2,40x12,40,12,3}]");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+
+ const vert_children = layout.content.vertical;
+ try testing.expectEqual(2, vert_children.len);
+
+ // First child is a simple pane
+ try testing.expectEqual(1, vert_children[0].content.pane);
+
+ // Second child is a horizontal split
+ const horiz_children = vert_children[1].content.horizontal;
+ try testing.expectEqual(2, horiz_children.len);
+ try testing.expectEqual(2, horiz_children[0].content.pane);
+ try testing.expectEqual(3, horiz_children[1].content.pane);
+}
+
+test "nested vertical in horizontal" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ // Horizontal split with left pane and right vertical split
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0{40x24,0,0,1,40x24,40,0[40x12,40,0,2,40x12,40,12,3]}");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+
+ const horiz_children = layout.content.horizontal;
+ try testing.expectEqual(2, horiz_children.len);
+
+ // First child is a simple pane
+ try testing.expectEqual(1, horiz_children[0].content.pane);
+
+ // Second child is a vertical split
+ const vert_children = horiz_children[1].content.vertical;
+ try testing.expectEqual(2, vert_children.len);
+ try testing.expectEqual(2, vert_children[0].content.pane);
+ try testing.expectEqual(3, vert_children[1].content.pane);
+}
+
+test "deeply nested layout" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ // Three levels deep
+ const layout: Layout = try .parse(arena.allocator(), "80x24,0,0{40x24,0,0[40x12,0,0,1,40x12,0,12,2],40x24,40,0,3}");
+
+ const horiz = layout.content.horizontal;
+ try testing.expectEqual(2, horiz.len);
+
+ const vert = horiz[0].content.vertical;
+ try testing.expectEqual(2, vert.len);
+ try testing.expectEqual(1, vert[0].content.pane);
+ try testing.expectEqual(2, vert[1].content.pane);
+
+ try testing.expectEqual(3, horiz[1].content.pane);
+}
+
+test "syntax error empty string" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), ""));
+}
+
+test "syntax error missing width" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "x24,0,0,1"));
+}
+
+test "syntax error missing height" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x,0,0,1"));
+}
+
+test "syntax error missing x" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,,0,1"));
+}
+
+test "syntax error missing y" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,,1"));
+}
+
+test "syntax error missing pane id" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0,"));
+}
+
+test "syntax error non-numeric width" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "abcx24,0,0,1"));
+}
+
+test "syntax error non-numeric pane id" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0,abc"));
+}
+
+test "syntax error unclosed horizontal bracket" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0{40x24,0,0,1"));
+}
+
+test "syntax error unclosed vertical bracket" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0[40x24,0,0,1"));
+}
+
+test "syntax error mismatched brackets" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0{40x24,0,0,1]"));
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0[40x24,0,0,1}"));
+}
+
+test "syntax error trailing data" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0,1extra"));
+}
+
+test "syntax error no x separator" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "8024,0,0,1"));
+}
+
+test "syntax error no content delimiter" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parse(arena.allocator(), "80x24,0,0"));
+}
+
+// parseWithChecksum tests
+
+test "parseWithChecksum valid" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ const layout: Layout = try .parseWithChecksum(arena.allocator(), "f8f9,80x24,0,0{40x24,0,0,1,40x24,40,0,2}");
+ try testing.expectEqual(80, layout.width);
+ try testing.expectEqual(24, layout.height);
+}
+
+test "parseWithChecksum mismatch" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.ChecksumMismatch, Layout.parseWithChecksum(arena.allocator(), "0000,80x24,0,0{40x24,0,0,1,40x24,40,0,2}"));
+}
+
+test "parseWithChecksum too short" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parseWithChecksum(arena.allocator(), "bb62"));
+ try testing.expectError(error.SyntaxError, Layout.parseWithChecksum(arena.allocator(), ""));
+}
+
+test "parseWithChecksum missing comma" {
+ var arena: ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+
+ try testing.expectError(error.SyntaxError, Layout.parseWithChecksum(arena.allocator(), "bb62x159x48,0,0"));
+}
+
+// Checksum tests
+
+test "checksum empty string" {
+ const checksum = Checksum.calculate("");
+ try testing.expectEqual(@as(u16, 0), @intFromEnum(checksum));
+ try testing.expectEqualStrings("0000", &checksum.asString());
+}
+
+test "checksum single character" {
+ // 'A' = 65, first iteration: csum = 0 >> 1 | 0 = 0, then 0 + 65 = 65
+ const checksum = Checksum.calculate("A");
+ try testing.expectEqual(@as(u16, 65), @intFromEnum(checksum));
+ try testing.expectEqualStrings("0041", &checksum.asString());
+}
+
+test "checksum two characters" {
+ // 'A' (65): csum = 0, rotate = 0, add 65 => 65
+ // 'B' (66): csum = 65, rotate => (65 >> 1) | ((65 & 1) << 15) = 32 | 32768 = 32800
+ // add 66 => 32800 + 66 = 32866
+ const checksum = Checksum.calculate("AB");
+ try testing.expectEqual(@as(u16, 32866), @intFromEnum(checksum));
+ try testing.expectEqualStrings("8062", &checksum.asString());
+}
+
+test "checksum simple layout" {
+ const checksum = Checksum.calculate("80x24,0,0,42");
+ try testing.expectEqualStrings("d962", &checksum.asString());
+}
+
+test "checksum horizontal split layout" {
+ const checksum = Checksum.calculate("80x24,0,0{40x24,0,0,1,40x24,40,0,2}");
+ try testing.expectEqualStrings("f8f9", &checksum.asString());
+}
+
+test "checksum asString zero padding" {
+ // Value 0x000f should produce "000f"
+ const checksum: Checksum = @enumFromInt(0x000f);
+ try testing.expectEqualStrings("000f", &checksum.asString());
+}
+
+test "checksum asString all digits" {
+ // Value 0x1234 should produce "1234"
+ const checksum: Checksum = @enumFromInt(0x1234);
+ try testing.expectEqualStrings("1234", &checksum.asString());
+}
+
+test "checksum asString with letters" {
+ // Value 0xabcd should produce "abcd"
+ const checksum: Checksum = @enumFromInt(0xabcd);
+ try testing.expectEqualStrings("abcd", &checksum.asString());
+}
+
+test "checksum asString max value" {
+ // Value 0xffff should produce "ffff"
+ const checksum: Checksum = @enumFromInt(0xffff);
+ try testing.expectEqualStrings("ffff", &checksum.asString());
+}
+
+test "checksum wraparound" {
+ const checksum = Checksum.calculate("\xff\xff\xff\xff\xff\xff\xff\xff");
+ try testing.expectEqualStrings("03fc", &checksum.asString());
+}
+
+test "checksum deterministic" {
+ // Same input should always produce same output
+ const str = "159x48,0,0{79x48,0,0,79x48,80,0}";
+ const checksum1 = Checksum.calculate(str);
+ const checksum2 = Checksum.calculate(str);
+ try testing.expectEqual(checksum1, checksum2);
+}
+
+test "checksum different inputs different outputs" {
+ const checksum1 = Checksum.calculate("80x24,0,0,1");
+ const checksum2 = Checksum.calculate("80x24,0,0,2");
+ try testing.expect(@intFromEnum(checksum1) != @intFromEnum(checksum2));
+}
+
+test "checksum known tmux layout bb62" {
+ // From tmux documentation: "bb62,159x48,0,0{79x48,0,0,79x48,80,0}"
+ // The checksum "bb62" corresponds to the layout "159x48,0,0{79x48,0,0,79x48,80,0}"
+ const checksum = Checksum.calculate("159x48,0,0{79x48,0,0,79x48,80,0}");
+ try testing.expectEqualStrings("bb62", &checksum.asString());
+}
diff --git a/vendor/libghostty-vt/src/terminal/tmux/output.zig b/vendor/libghostty-vt/src/terminal/tmux/output.zig
new file mode 100644
index 00000000..6b8073e4
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/tmux/output.zig
@@ -0,0 +1,590 @@
+const std = @import("std");
+const testing = std.testing;
+
+pub const ParseError = error{
+ MissingEntry,
+ ExtraEntry,
+ FormatError,
+};
+
+/// Parse the output from a command with the given format struct
+/// (returned usually by FormatStruct). The format struct is expected
+/// to be in the order of the variables used in the format string and
+/// the variables are expected to be plain variables (no conditionals,
+/// extra formatting, etc.). Each variable is expected to be separated
+/// by a single `delimiter` character.
+pub fn parseFormatStruct(
+ comptime T: type,
+ str: []const u8,
+ delimiter: u8,
+) ParseError!T {
+ // Parse all our fields
+ const fields = @typeInfo(T).@"struct".fields;
+ var it = std.mem.splitScalar(u8, str, delimiter);
+ var result: T = undefined;
+ inline for (fields) |field| {
+ const part = it.next() orelse return error.MissingEntry;
+ @field(result, field.name) = Variable.parse(
+ @field(Variable, field.name),
+ part,
+ ) catch return error.FormatError;
+ }
+
+ // We should have consumed all parts now.
+ if (it.next() != null) return error.ExtraEntry;
+
+ return result;
+}
+
+pub fn comptimeFormat(
+ comptime vars: []const Variable,
+ comptime delimiter: u8,
+) []const u8 {
+ comptime {
+ @setEvalBranchQuota(50000);
+ var counter: std.Io.Writer.Discarding = .init(&.{});
+ try format(&counter.writer, vars, delimiter);
+
+ var buf: [counter.count]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ try format(&writer, vars, delimiter);
+ const final = buf;
+ return final[0..writer.end];
+ }
+}
+
+/// Format a set of variables into the proper format string for tmux
+/// that we can handle with `parseFormatStruct`.
+pub fn format(
+ writer: *std.Io.Writer,
+ vars: []const Variable,
+ delimiter: u8,
+) std.Io.Writer.Error!void {
+ for (vars, 0..) |variable, i| {
+ if (i != 0) try writer.writeByte(delimiter);
+ try writer.print("#{{{t}}}", .{variable});
+ }
+}
+
+/// Returns a struct type that contains fields for each of the given
+/// format variables. This can be used with `parseFormatStruct` to
+/// parse an output string into a format struct.
+pub fn FormatStruct(comptime vars: []const Variable) type {
+ var fields: [vars.len]std.builtin.Type.StructField = undefined;
+ for (vars, &fields) |variable, *field| {
+ field.* = .{
+ .name = @tagName(variable),
+ .type = variable.Type(),
+ .default_value_ptr = null,
+ .is_comptime = false,
+ .alignment = @alignOf(variable.Type()),
+ };
+ }
+
+ return @Type(.{ .@"struct" = .{
+ .layout = .auto,
+ .fields = &fields,
+ .decls = &.{},
+ .is_tuple = false,
+ } });
+}
+
+/// Possible variables in a tmux format string that we support.
+///
+/// Tmux supports a large number of variables, but we only implement
+/// a subset of them here that are relevant to the use case of implementing
+/// control mode for terminal emulators.
+pub const Variable = enum {
+ /// 1 if pane is in alternate screen.
+ alternate_on,
+ /// Saved cursor X in alternate screen.
+ alternate_saved_x,
+ /// Saved cursor Y in alternate screen.
+ alternate_saved_y,
+ /// 1 if bracketed paste mode is enabled.
+ bracketed_paste,
+ /// 1 if the cursor is blinking.
+ cursor_blinking,
+ /// Cursor colour in pane. Possible formats:
+ /// - Named colors: `black`, `red`, `green`, `yellow`, `blue`, `magenta`,
+ /// `cyan`, `white`, `default`, `terminal`, or bright variants.
+ /// - 256 colors: `colour<N>` where N is 0-255 (e.g., `colour100`).
+ /// - RGB hex: `#RRGGBB` (e.g., `#ff0000`).
+ /// - Empty string if unset.
+ cursor_colour,
+ /// Pane cursor flag.
+ cursor_flag,
+ /// Cursor shape in pane. Possible values: `block`, `underline`, `bar`,
+ /// or `default`.
+ cursor_shape,
+ /// Cursor X position in pane.
+ cursor_x,
+ /// Cursor Y position in pane.
+ cursor_y,
+ /// 1 if focus reporting is enabled.
+ focus_flag,
+ /// Pane insert flag.
+ insert_flag,
+ /// Pane keypad cursor flag.
+ keypad_cursor_flag,
+ /// Pane keypad flag.
+ keypad_flag,
+ /// Pane mouse all flag.
+ mouse_all_flag,
+ /// Pane mouse any flag.
+ mouse_any_flag,
+ /// Pane mouse button flag.
+ mouse_button_flag,
+ /// Pane mouse SGR flag.
+ mouse_sgr_flag,
+ /// Pane mouse standard flag.
+ mouse_standard_flag,
+ /// Pane mouse UTF-8 flag.
+ mouse_utf8_flag,
+ /// Pane origin flag.
+ origin_flag,
+ /// Unique pane ID prefixed with `%` (e.g., `%0`, `%42`).
+ pane_id,
+ /// Pane tab positions as a comma-separated list of 0-indexed column
+ /// numbers (e.g., `8,16,24,32`). Empty string if no tabs are set.
+ pane_tabs,
+ /// Bottom of scroll region in pane.
+ scroll_region_lower,
+ /// Top of scroll region in pane.
+ scroll_region_upper,
+ /// Unique session ID prefixed with `$` (e.g., `$0`, `$42`).
+ session_id,
+ /// Server version (e.g., `3.5a`).
+ version,
+ /// Unique window ID prefixed with `@` (e.g., `@0`, `@42`).
+ window_id,
+ /// Width of window.
+ window_width,
+ /// Height of window.
+ window_height,
+ /// Window layout description, ignoring zoomed window panes. Format is
+ /// `<checksum>,<layout>` where checksum is a 4-digit hex CRC16 and layout
+ /// encodes pane dimensions as `WxH,X,Y[,ID]` with `{...}` for horizontal
+ /// splits and `[...]` for vertical splits.
+ window_layout,
+ /// Pane wrap flag.
+ wrap_flag,
+
+ /// Parse the given string value into the appropriate resulting
+ /// type for this variable.
+ pub fn parse(comptime self: Variable, value: []const u8) !Type(self) {
+ return switch (self) {
+ .alternate_on,
+ .bracketed_paste,
+ .cursor_blinking,
+ .cursor_flag,
+ .focus_flag,
+ .insert_flag,
+ .keypad_cursor_flag,
+ .keypad_flag,
+ .mouse_all_flag,
+ .mouse_any_flag,
+ .mouse_button_flag,
+ .mouse_sgr_flag,
+ .mouse_standard_flag,
+ .mouse_utf8_flag,
+ .origin_flag,
+ .wrap_flag,
+ => std.mem.eql(u8, value, "1"),
+ .alternate_saved_x,
+ .alternate_saved_y,
+ .cursor_x,
+ .cursor_y,
+ .scroll_region_lower,
+ .scroll_region_upper,
+ => try std.fmt.parseInt(usize, value, 10),
+ .session_id => if (value.len >= 2 and value[0] == '$')
+ try std.fmt.parseInt(usize, value[1..], 10)
+ else
+ return error.FormatError,
+ .window_id => if (value.len >= 2 and value[0] == '@')
+ try std.fmt.parseInt(usize, value[1..], 10)
+ else
+ return error.FormatError,
+ .pane_id => if (value.len >= 2 and value[0] == '%')
+ try std.fmt.parseInt(usize, value[1..], 10)
+ else
+ return error.FormatError,
+ .window_width => try std.fmt.parseInt(usize, value, 10),
+ .window_height => try std.fmt.parseInt(usize, value, 10),
+ .cursor_colour,
+ .cursor_shape,
+ .pane_tabs,
+ .version,
+ .window_layout,
+ => value,
+ };
+ }
+
+ /// The type of the parsed value for this variable type.
+ pub fn Type(comptime self: Variable) type {
+ return switch (self) {
+ .alternate_on,
+ .bracketed_paste,
+ .cursor_blinking,
+ .cursor_flag,
+ .focus_flag,
+ .insert_flag,
+ .keypad_cursor_flag,
+ .keypad_flag,
+ .mouse_all_flag,
+ .mouse_any_flag,
+ .mouse_button_flag,
+ .mouse_sgr_flag,
+ .mouse_standard_flag,
+ .mouse_utf8_flag,
+ .origin_flag,
+ .wrap_flag,
+ => bool,
+ .alternate_saved_x,
+ .alternate_saved_y,
+ .cursor_x,
+ .cursor_y,
+ .scroll_region_lower,
+ .scroll_region_upper,
+ .session_id,
+ .window_id,
+ .pane_id,
+ .window_width,
+ .window_height,
+ => usize,
+ .cursor_colour,
+ .cursor_shape,
+ .pane_tabs,
+ .version,
+ .window_layout,
+ => []const u8,
+ };
+ }
+};
+
+test "parse alternate_on" {
+ try testing.expectEqual(true, try Variable.parse(.alternate_on, "1"));
+ try testing.expectEqual(false, try Variable.parse(.alternate_on, "0"));
+ try testing.expectEqual(false, try Variable.parse(.alternate_on, ""));
+ try testing.expectEqual(false, try Variable.parse(.alternate_on, "true"));
+ try testing.expectEqual(false, try Variable.parse(.alternate_on, "yes"));
+}
+
+test "parse alternate_saved_x" {
+ try testing.expectEqual(0, try Variable.parse(.alternate_saved_x, "0"));
+ try testing.expectEqual(42, try Variable.parse(.alternate_saved_x, "42"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.alternate_saved_x, "abc"));
+}
+
+test "parse alternate_saved_y" {
+ try testing.expectEqual(0, try Variable.parse(.alternate_saved_y, "0"));
+ try testing.expectEqual(42, try Variable.parse(.alternate_saved_y, "42"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.alternate_saved_y, "abc"));
+}
+
+test "parse cursor_x" {
+ try testing.expectEqual(0, try Variable.parse(.cursor_x, "0"));
+ try testing.expectEqual(79, try Variable.parse(.cursor_x, "79"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.cursor_x, "abc"));
+}
+
+test "parse cursor_y" {
+ try testing.expectEqual(0, try Variable.parse(.cursor_y, "0"));
+ try testing.expectEqual(23, try Variable.parse(.cursor_y, "23"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.cursor_y, "abc"));
+}
+
+test "parse scroll_region_upper" {
+ try testing.expectEqual(0, try Variable.parse(.scroll_region_upper, "0"));
+ try testing.expectEqual(5, try Variable.parse(.scroll_region_upper, "5"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.scroll_region_upper, "abc"));
+}
+
+test "parse scroll_region_lower" {
+ try testing.expectEqual(0, try Variable.parse(.scroll_region_lower, "0"));
+ try testing.expectEqual(23, try Variable.parse(.scroll_region_lower, "23"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.scroll_region_lower, "abc"));
+}
+
+test "parse session id" {
+ try testing.expectEqual(42, try Variable.parse(.session_id, "$42"));
+ try testing.expectEqual(0, try Variable.parse(.session_id, "$0"));
+ try testing.expectError(error.FormatError, Variable.parse(.session_id, "0"));
+ try testing.expectError(error.FormatError, Variable.parse(.session_id, "@0"));
+ try testing.expectError(error.FormatError, Variable.parse(.session_id, "$"));
+ try testing.expectError(error.FormatError, Variable.parse(.session_id, ""));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.session_id, "$abc"));
+}
+
+test "parse window id" {
+ try testing.expectEqual(42, try Variable.parse(.window_id, "@42"));
+ try testing.expectEqual(0, try Variable.parse(.window_id, "@0"));
+ try testing.expectEqual(12345, try Variable.parse(.window_id, "@12345"));
+ try testing.expectError(error.FormatError, Variable.parse(.window_id, "0"));
+ try testing.expectError(error.FormatError, Variable.parse(.window_id, "$0"));
+ try testing.expectError(error.FormatError, Variable.parse(.window_id, "@"));
+ try testing.expectError(error.FormatError, Variable.parse(.window_id, ""));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.window_id, "@abc"));
+}
+
+test "parse window width" {
+ try testing.expectEqual(80, try Variable.parse(.window_width, "80"));
+ try testing.expectEqual(0, try Variable.parse(.window_width, "0"));
+ try testing.expectEqual(12345, try Variable.parse(.window_width, "12345"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.window_width, "abc"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.window_width, "80px"));
+ try testing.expectError(error.Overflow, Variable.parse(.window_width, "-1"));
+}
+
+test "parse window height" {
+ try testing.expectEqual(24, try Variable.parse(.window_height, "24"));
+ try testing.expectEqual(0, try Variable.parse(.window_height, "0"));
+ try testing.expectEqual(12345, try Variable.parse(.window_height, "12345"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.window_height, "abc"));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.window_height, "24px"));
+ try testing.expectError(error.Overflow, Variable.parse(.window_height, "-1"));
+}
+
+test "parse window layout" {
+ try testing.expectEqualStrings("abc123", try Variable.parse(.window_layout, "abc123"));
+ try testing.expectEqualStrings("", try Variable.parse(.window_layout, ""));
+ try testing.expectEqualStrings("a]b,c{d}e(f)", try Variable.parse(.window_layout, "a]b,c{d}e(f)"));
+}
+
+test "parse cursor_flag" {
+ try testing.expectEqual(true, try Variable.parse(.cursor_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.cursor_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.cursor_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.cursor_flag, "true"));
+}
+
+test "parse insert_flag" {
+ try testing.expectEqual(true, try Variable.parse(.insert_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.insert_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.insert_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.insert_flag, "true"));
+}
+
+test "parse keypad_cursor_flag" {
+ try testing.expectEqual(true, try Variable.parse(.keypad_cursor_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.keypad_cursor_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.keypad_cursor_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.keypad_cursor_flag, "true"));
+}
+
+test "parse keypad_flag" {
+ try testing.expectEqual(true, try Variable.parse(.keypad_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.keypad_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.keypad_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.keypad_flag, "true"));
+}
+
+test "parse mouse_any_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_any_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_any_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_any_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_any_flag, "true"));
+}
+
+test "parse mouse_button_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_button_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_button_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_button_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_button_flag, "true"));
+}
+
+test "parse mouse_sgr_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_sgr_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_sgr_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_sgr_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_sgr_flag, "true"));
+}
+
+test "parse mouse_standard_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_standard_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_standard_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_standard_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_standard_flag, "true"));
+}
+
+test "parse mouse_utf8_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_utf8_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_utf8_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_utf8_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_utf8_flag, "true"));
+}
+
+test "parse wrap_flag" {
+ try testing.expectEqual(true, try Variable.parse(.wrap_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.wrap_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.wrap_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.wrap_flag, "true"));
+}
+
+test "parse bracketed_paste" {
+ try testing.expectEqual(true, try Variable.parse(.bracketed_paste, "1"));
+ try testing.expectEqual(false, try Variable.parse(.bracketed_paste, "0"));
+ try testing.expectEqual(false, try Variable.parse(.bracketed_paste, ""));
+ try testing.expectEqual(false, try Variable.parse(.bracketed_paste, "true"));
+}
+
+test "parse cursor_blinking" {
+ try testing.expectEqual(true, try Variable.parse(.cursor_blinking, "1"));
+ try testing.expectEqual(false, try Variable.parse(.cursor_blinking, "0"));
+ try testing.expectEqual(false, try Variable.parse(.cursor_blinking, ""));
+ try testing.expectEqual(false, try Variable.parse(.cursor_blinking, "true"));
+}
+
+test "parse focus_flag" {
+ try testing.expectEqual(true, try Variable.parse(.focus_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.focus_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.focus_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.focus_flag, "true"));
+}
+
+test "parse mouse_all_flag" {
+ try testing.expectEqual(true, try Variable.parse(.mouse_all_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_all_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.mouse_all_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.mouse_all_flag, "true"));
+}
+
+test "parse origin_flag" {
+ try testing.expectEqual(true, try Variable.parse(.origin_flag, "1"));
+ try testing.expectEqual(false, try Variable.parse(.origin_flag, "0"));
+ try testing.expectEqual(false, try Variable.parse(.origin_flag, ""));
+ try testing.expectEqual(false, try Variable.parse(.origin_flag, "true"));
+}
+
+test "parse pane_id" {
+ try testing.expectEqual(42, try Variable.parse(.pane_id, "%42"));
+ try testing.expectEqual(0, try Variable.parse(.pane_id, "%0"));
+ try testing.expectError(error.FormatError, Variable.parse(.pane_id, "0"));
+ try testing.expectError(error.FormatError, Variable.parse(.pane_id, "@0"));
+ try testing.expectError(error.FormatError, Variable.parse(.pane_id, "%"));
+ try testing.expectError(error.FormatError, Variable.parse(.pane_id, ""));
+ try testing.expectError(error.InvalidCharacter, Variable.parse(.pane_id, "%abc"));
+}
+
+test "parse cursor_colour" {
+ try testing.expectEqualStrings("red", try Variable.parse(.cursor_colour, "red"));
+ try testing.expectEqualStrings("#ff0000", try Variable.parse(.cursor_colour, "#ff0000"));
+ try testing.expectEqualStrings("", try Variable.parse(.cursor_colour, ""));
+}
+
+test "parse cursor_shape" {
+ try testing.expectEqualStrings("block", try Variable.parse(.cursor_shape, "block"));
+ try testing.expectEqualStrings("underline", try Variable.parse(.cursor_shape, "underline"));
+ try testing.expectEqualStrings("bar", try Variable.parse(.cursor_shape, "bar"));
+ try testing.expectEqualStrings("", try Variable.parse(.cursor_shape, ""));
+}
+
+test "parse pane_tabs" {
+ try testing.expectEqualStrings("0,8,16,24", try Variable.parse(.pane_tabs, "0,8,16,24"));
+ try testing.expectEqualStrings("", try Variable.parse(.pane_tabs, ""));
+ try testing.expectEqualStrings("0", try Variable.parse(.pane_tabs, "0"));
+}
+
+test "parse version" {
+ try testing.expectEqualStrings("3.5a", try Variable.parse(.version, "3.5a"));
+ try testing.expectEqualStrings("3.5", try Variable.parse(.version, "3.5"));
+ try testing.expectEqualStrings("next-3.5", try Variable.parse(.version, "next-3.5"));
+ try testing.expectEqualStrings("", try Variable.parse(.version, ""));
+}
+
+test "parseFormatStruct single field" {
+ const T = FormatStruct(&.{.session_id});
+ const result = try parseFormatStruct(T, "$42", ' ');
+ try testing.expectEqual(42, result.session_id);
+}
+
+test "parseFormatStruct multiple fields" {
+ const T = FormatStruct(&.{ .session_id, .window_id, .window_width, .window_height });
+ const result = try parseFormatStruct(T, "$1 @2 80 24", ' ');
+ try testing.expectEqual(1, result.session_id);
+ try testing.expectEqual(2, result.window_id);
+ try testing.expectEqual(80, result.window_width);
+ try testing.expectEqual(24, result.window_height);
+}
+
+test "parseFormatStruct with string field" {
+ const T = FormatStruct(&.{ .window_id, .window_layout });
+ const result = try parseFormatStruct(T, "@5,abc123", ',');
+ try testing.expectEqual(5, result.window_id);
+ try testing.expectEqualStrings("abc123", result.window_layout);
+}
+
+test "parseFormatStruct different delimiter" {
+ const T = FormatStruct(&.{ .window_width, .window_height });
+ const result = try parseFormatStruct(T, "120\t40", '\t');
+ try testing.expectEqual(120, result.window_width);
+ try testing.expectEqual(40, result.window_height);
+}
+
+test "parseFormatStruct missing entry" {
+ const T = FormatStruct(&.{ .session_id, .window_id });
+ try testing.expectError(error.MissingEntry, parseFormatStruct(T, "$1", ' '));
+}
+
+test "parseFormatStruct extra entry" {
+ const T = FormatStruct(&.{.session_id});
+ try testing.expectError(error.ExtraEntry, parseFormatStruct(T, "$1 @2", ' '));
+}
+
+test "parseFormatStruct format error" {
+ const T = FormatStruct(&.{.session_id});
+ try testing.expectError(error.FormatError, parseFormatStruct(T, "42", ' '));
+ try testing.expectError(error.FormatError, parseFormatStruct(T, "@42", ' '));
+ try testing.expectError(error.FormatError, parseFormatStruct(T, "$abc", ' '));
+}
+
+test "parseFormatStruct empty string" {
+ const T = FormatStruct(&.{.session_id});
+ try testing.expectError(error.FormatError, parseFormatStruct(T, "", ' '));
+}
+
+test "parseFormatStruct with empty layout field" {
+ const T = FormatStruct(&.{ .session_id, .window_layout });
+ const result = try parseFormatStruct(T, "$1,", ',');
+ try testing.expectEqual(1, result.session_id);
+ try testing.expectEqualStrings("", result.window_layout);
+}
+
+fn testFormat(
+ comptime vars: []const Variable,
+ comptime delimiter: u8,
+ comptime expected: []const u8,
+) !void {
+ const comptime_result = comptime comptimeFormat(vars, delimiter);
+ try testing.expectEqualStrings(expected, comptime_result);
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ try format(&writer, vars, delimiter);
+ try testing.expectEqualStrings(expected, buf[0..writer.end]);
+}
+
+test "format single variable" {
+ try testFormat(&.{.session_id}, ' ', "#{session_id}");
+}
+
+test "format multiple variables" {
+ try testFormat(&.{ .session_id, .window_id, .window_width, .window_height }, ' ', "#{session_id} #{window_id} #{window_width} #{window_height}");
+}
+
+test "format with comma delimiter" {
+ try testFormat(&.{ .window_id, .window_layout }, ',', "#{window_id},#{window_layout}");
+}
+
+test "format with tab delimiter" {
+ try testFormat(&.{ .window_width, .window_height }, '\t', "#{window_width}\t#{window_height}");
+}
+
+test "format empty variables" {
+ try testFormat(&.{}, ' ', "");
+}
+
+test "format all variables" {
+ try testFormat(&.{ .session_id, .window_id, .window_width, .window_height, .window_layout }, ' ', "#{session_id} #{window_id} #{window_width} #{window_height} #{window_layout}");
+}
diff --git a/vendor/libghostty-vt/src/terminal/tmux/viewer.zig b/vendor/libghostty-vt/src/terminal/tmux/viewer.zig
new file mode 100644
index 00000000..585c9540
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/tmux/viewer.zig
@@ -0,0 +1,2283 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
+const testing = std.testing;
+const assert = @import("../../quirks.zig").inlineAssert;
+const size = @import("../size.zig");
+const CircBuf = @import("../../datastruct/main.zig").CircBuf;
+const CursorStyle = @import("../cursor.zig").Style;
+const Screen = @import("../Screen.zig");
+const ScreenSet = @import("../ScreenSet.zig");
+const Terminal = @import("../Terminal.zig");
+const Layout = @import("layout.zig").Layout;
+const control = @import("control.zig");
+const output = @import("output.zig");
+
+const log = std.log.scoped(.terminal_tmux_viewer);
+
+// TODO: A list of TODOs as I think about them.
+// - We need to make startup more robust so session and block can happen
+// out of order.
+// - We need to ignore `output` for panes that aren't yet initialized
+// (until capture-panes are complete).
+// - We should note what the active window pane is on the tmux side;
+// we can use this at least for initial focus.
+
+// NOTE: There is some fragility here that can possibly break if tmux
+// changes their implementation. In particular, the order of notifications
+// and assurances about what is sent when are based on reading the tmux
+// source code as of Dec, 2025. These aren't documented as fixed.
+//
+// I've tried not to depend on anything that seems like it'd change
+// in the future. For example, it seems reasonable that command output
+// always comes before session attachment. But, I am noting this here
+// in case something breaks in the future we can consider it. We should
+// be able to easily unit test all variations seen in the real world.
+
+/// The initial capacity of the command queue. We dynamically resize
+/// as necessary so the initial value isn't that important, but if we
+/// want to feel good about it we should make it large enough to support
+/// our most realistic use cases without resizing.
+const COMMAND_QUEUE_INITIAL = 8;
+
+/// A viewer is a tmux control mode client that attempts to create
+/// a remote view of a tmux session, including providing the ability to send
+/// new input to the session.
+///
+/// This is the primary use case for tmux control mode, but technically
+/// tmux control mode clients can do anything a normal tmux client can do,
+/// so the `control.zig` and other files in this folder are more general
+/// purpose.
+///
+/// This struct helps move through a state machine of connecting to a tmux
+/// session, negotiating capabilities, listing window state, etc.
+///
+/// ## Viewer Lifecycle
+///
+/// The viewer progresses through several states from initial connection
+/// to steady-state operation. Here is the full flow:
+///
+/// ```
+/// ┌─────────────────────────────────────────────┐
+/// │ TMUX CONTROL MODE START │
+/// │ (DCS 1000p received by host) │
+/// └─────────────────┬───────────────────────────┘
+/// │
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ startup_block │
+/// │ │
+/// │ Wait for initial %begin/%end block from │
+/// │ tmux. This is the response to the initial │
+/// │ command (e.g., "attach -t 0"). │
+/// └─────────────────┬───────────────────────────┘
+/// │ %end / %error
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ startup_session │
+/// │ │
+/// │ Wait for %session-changed notification │
+/// │ to get the initial session ID. │
+/// └─────────────────┬───────────────────────────┘
+/// │ %session-changed
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ command_queue │
+/// │ │
+/// │ Main operating state. Process commands │
+/// │ sequentially and handle notifications. │
+/// └─────────────────────────────────────────────┘
+/// │
+/// ┌───────────────────────────┼───────────────────────────┐
+/// │ │ │
+/// ▼ ▼ ▼
+/// ┌──────────────────────────┐ ┌──────────────────────────┐ ┌────────────────────────┐
+/// │ tmux_version │ │ list_windows │ │ %output / %layout- │
+/// │ │ │ │ │ change / etc. │
+/// │ Query tmux version for │ │ Get all windows in the │ │ │
+/// │ compatibility checks. │ │ current session. │ │ Handle live updates │
+/// └──────────────────────────┘ └────────────┬─────────────┘ │ from tmux server. │
+/// │ └────────────────────────┘
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ syncLayouts │
+/// │ │
+/// │ For each window, parse layout and sync │
+/// │ panes. New panes trigger capture commands. │
+/// └─────────────────┬───────────────────────────┘
+/// │
+/// ┌───────────────────────────┴───────────────────────────┐
+/// │ For each new pane: │
+/// ▼ ▼
+/// ┌──────────────────────────┐ ┌──────────────────────────┐
+/// │ pane_history │ │ pane_visible │
+/// │ (primary screen) │ │ (primary screen) │
+/// │ │ │ │
+/// │ Capture scrollback │ │ Capture visible area │
+/// │ history into terminal. │ │ into terminal. │
+/// └──────────────────────────┘ └──────────────────────────┘
+/// │ │
+/// ▼ ▼
+/// ┌──────────────────────────┐ ┌──────────────────────────┐
+/// │ pane_history │ │ pane_visible │
+/// │ (alternate screen) │ │ (alternate screen) │
+/// └──────────────────────────┘ └──────────────────────────┘
+/// │ │
+/// └───────────────────────────┬───────────────────────────┘
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ pane_state │
+/// │ │
+/// │ Query cursor position, cursor style, │
+/// │ and alternate screen mode for all panes. │
+/// └─────────────────────────────────────────────┘
+/// │
+/// ▼
+/// ┌─────────────────────────────────────────────┐
+/// │ READY FOR OPERATION │
+/// │ │
+/// │ Panes are populated with content. The │
+/// │ viewer handles %output for live updates, │
+/// │ %layout-change for pane changes, and │
+/// │ %session-changed for session switches. │
+/// └─────────────────────────────────────────────┘
+/// ```
+///
+/// ## Error Handling
+///
+/// At any point, if an unrecoverable error occurs or tmux sends `%exit`,
+/// the viewer transitions to the `defunct` state and emits an `.exit` action.
+///
+/// ## Session Changes
+///
+/// When `%session-changed` is received during `command_queue` state, the
+/// viewer resets itself completely: clears all windows/panes, emits an
+/// empty windows action, and restarts the `list_windows` flow for the new
+/// session.
+///
+pub const Viewer = struct {
+ /// Allocator used for all internal state.
+ alloc: Allocator,
+
+ /// Current state of the state machine.
+ state: State,
+
+ /// The current session ID we're attached to.
+ session_id: usize,
+
+ /// The tmux server version string (e.g., "3.5a"). We capture this
+ /// on startup because it will allow us to change behavior between
+ /// versions as necessary.
+ tmux_version: []const u8,
+
+ /// The list of commands we've sent that we want to send and wait
+ /// for a response for. We only send one command at a time just
+ /// to avoid any possible confusion around ordering.
+ command_queue: CommandQueue,
+
+ /// The windows in the current session.
+ windows: std.ArrayList(Window),
+
+ /// The panes in the current session, mapped by pane ID.
+ panes: PanesMap,
+
+ /// The arena used for the prior action allocated state. This contains
+ /// the contents for the actions as well as the actions slice itself.
+ action_arena: ArenaAllocator.State,
+
+ /// A single action pre-allocated that we use for single-action
+ /// returns (common). This ensures that we can never get allocation
+ /// errors on single-action returns, especially those such as `.exit`.
+ action_single: [1]Action,
+
+ pub const CommandQueue = CircBuf(Command, undefined);
+ pub const PanesMap = std.AutoArrayHashMapUnmanaged(usize, Pane);
+
+ pub const Action = union(enum) {
+ /// Tmux has closed the control mode connection, we should end
+ /// our viewer session in some way.
+ exit,
+
+ /// Send a command to tmux, e.g. `list-windows`. The caller
+ /// should not worry about parsing this or reading what command
+ /// it is; just send it to tmux as-is. This will include the
+ /// trailing newline so you can send it directly.
+ command: []const u8,
+
+ /// Windows changed. This may add, remove or change windows. The
+ /// caller is responsible for diffing the new window list against
+ /// the prior one. Remember that for a given Viewer, window IDs
+ /// are guaranteed to be stable. Additionally, tmux (as of Dec 2025)
+ /// never reuses window IDs within a server process lifetime.
+ windows: []const Window,
+
+ pub fn format(self: Action, writer: *std.Io.Writer) !void {
+ const T = Action;
+ const info = @typeInfo(T).@"union";
+
+ try writer.writeAll(@typeName(T));
+ if (info.tag_type) |TagType| {
+ try writer.writeAll("{ .");
+ try writer.writeAll(@tagName(@as(TagType, self)));
+ try writer.writeAll(" = ");
+
+ inline for (info.fields) |u_field| {
+ if (self == @field(TagType, u_field.name)) {
+ const value = @field(self, u_field.name);
+ switch (u_field.type) {
+ []const u8 => try writer.print("\"{s}\"", .{std.mem.trim(u8, value, " \t\r\n")}),
+ else => try writer.print("{any}", .{value}),
+ }
+ }
+ }
+
+ try writer.writeAll(" }");
+ }
+ }
+ };
+
+ pub const Input = union(enum) {
+ /// Data from tmux was received that needs to be processed.
+ tmux: control.Notification,
+ };
+
+ pub const Window = struct {
+ id: usize,
+ width: usize,
+ height: usize,
+ layout_arena: ArenaAllocator.State,
+ layout: Layout,
+
+ pub fn deinit(self: *Window, alloc: Allocator) void {
+ self.layout_arena.promote(alloc).deinit();
+ }
+ };
+
+ pub const Pane = struct {
+ terminal: Terminal,
+
+ pub fn deinit(self: *Pane, alloc: Allocator) void {
+ self.terminal.deinit(alloc);
+ }
+ };
+
+ /// Initialize a new viewer.
+ ///
+ /// The given allocator is used for all internal state. You must
+ /// call deinit when you're done with the viewer to free it.
+ pub fn init(alloc: Allocator) Allocator.Error!Viewer {
+ // Create our initial command queue
+ var command_queue: CommandQueue = try .init(alloc, COMMAND_QUEUE_INITIAL);
+ errdefer command_queue.deinit(alloc);
+
+ return .{
+ .alloc = alloc,
+ .state = .startup_block,
+ // The default value here is meaningless. We don't get started
+ // until we receive a session-changed notification which will
+ // set this to a real value.
+ .session_id = 0,
+ .tmux_version = "",
+ .command_queue = command_queue,
+ .windows = .empty,
+ .panes = .empty,
+ .action_arena = .{},
+ .action_single = undefined,
+ };
+ }
+
+ pub fn deinit(self: *Viewer) void {
+ {
+ for (self.windows.items) |*window| window.deinit(self.alloc);
+ self.windows.deinit(self.alloc);
+ }
+ {
+ var it = self.command_queue.iterator(.forward);
+ while (it.next()) |command| command.deinit(self.alloc);
+ self.command_queue.deinit(self.alloc);
+ }
+ {
+ var it = self.panes.iterator();
+ while (it.next()) |kv| kv.value_ptr.deinit(self.alloc);
+ self.panes.deinit(self.alloc);
+ }
+ if (self.tmux_version.len > 0) {
+ self.alloc.free(self.tmux_version);
+ }
+ self.action_arena.promote(self.alloc).deinit();
+ }
+
+ /// Send in an input event (such as a tmux protocol notification,
+ /// keyboard input for a pane, etc.) and process it. The returned
+ /// list is a set of actions to take as a result of the input prior
+ /// to the next input. This list may be empty.
+ pub fn next(self: *Viewer, input: Input) []const Action {
+ // Developer note: this function must never return an error. If
+ // an error occurs we must go into a defunct state or some other
+ // state to gracefully handle it.
+ return switch (input) {
+ .tmux => self.nextTmux(input.tmux),
+ };
+ }
+
+ fn nextTmux(
+ self: *Viewer,
+ n: control.Notification,
+ ) []const Action {
+ return switch (self.state) {
+ .defunct => defunct: {
+ log.info("received notification in defunct state, ignoring", .{});
+ break :defunct &.{};
+ },
+
+ .startup_block => self.nextStartupBlock(n),
+ .startup_session => self.nextStartupSession(n),
+ .command_queue => self.nextCommand(n),
+ };
+ }
+
+ fn nextStartupBlock(
+ self: *Viewer,
+ n: control.Notification,
+ ) []const Action {
+ assert(self.state == .startup_block);
+
+ switch (n) {
+ // This is only sent by the DCS parser when we first get
+ // DCS 1000p, it should never reach us here.
+ .enter => unreachable,
+
+ // I don't think this is technically possible (reading the
+ // tmux source code), but if we see an exit we can semantically
+ // handle this without issue.
+ .exit => return self.defunct(),
+
+ // Any begin and end (even error) is fine! Now we wait for
+ // session-changed to get the initial session ID. session-changed
+ // is guaranteed to come after the initial command output
+ // since if the initial command is `attach` tmux will run that,
+ // queue the notification, then do notificatins.
+ .block_end, .block_err => {
+ self.state = .startup_session;
+ return &.{};
+ },
+
+ // I don't like catch-all else branches but startup is such
+ // a special case of looking for very specific things that
+ // are unlikely to expand.
+ else => return &.{},
+ }
+ }
+
+ fn nextStartupSession(
+ self: *Viewer,
+ n: control.Notification,
+ ) []const Action {
+ assert(self.state == .startup_session);
+
+ switch (n) {
+ .enter => unreachable,
+
+ .exit => return self.defunct(),
+
+ .session_changed => |info| {
+ self.session_id = info.id;
+
+ var arena = self.action_arena.promote(self.alloc);
+ defer self.action_arena = arena.state;
+ _ = arena.reset(.free_all);
+
+ return self.enterCommandQueue(
+ arena.allocator(),
+ &.{ .tmux_version, .list_windows },
+ ) catch {
+ log.warn("failed to queue command, becoming defunct", .{});
+ return self.defunct();
+ };
+ },
+
+ else => return &.{},
+ }
+ }
+
+ fn nextIdle(
+ self: *Viewer,
+ n: control.Notification,
+ ) []const Action {
+ assert(self.state == .idle);
+
+ switch (n) {
+ .enter => unreachable,
+ .exit => return self.defunct(),
+ else => return &.{},
+ }
+ }
+
+ fn nextCommand(
+ self: *Viewer,
+ n: control.Notification,
+ ) []const Action {
+ // We have to be in a command queue, but the command queue MAY
+ // be empty. If it is empty, then receivedCommandOutput will
+ // handle it by ignoring any command output. That's okay!
+ assert(self.state == .command_queue);
+
+ // Clear our prior arena so it is ready to be used for any
+ // actions immediately.
+ {
+ var arena = self.action_arena.promote(self.alloc);
+ _ = arena.reset(.free_all);
+ self.action_arena = arena.state;
+ }
+
+ // Setup our empty actions list that commands can populate.
+ var actions: std.ArrayList(Action) = .empty;
+
+ // Track whether the in-flight command slot is available. Starts true
+ // if queue is empty (no command in flight). Set to true when a command
+ // completes (block_end/block_err) or the queue is reset (session_changed).
+ var command_consumed = self.command_queue.empty();
+
+ switch (n) {
+ .enter => unreachable,
+ .exit => return self.defunct(),
+
+ inline .block_end,
+ .block_err,
+ => |content, tag| {
+ self.receivedCommandOutput(
+ &actions,
+ content,
+ tag == .block_err,
+ ) catch {
+ log.warn("failed to process command output, becoming defunct", .{});
+ return self.defunct();
+ };
+
+ // Command is consumed since a block end/err is the output
+ // from a command.
+ command_consumed = true;
+ },
+
+ .output => |out| self.receivedOutput(
+ out.pane_id,
+ out.data,
+ ) catch |err| {
+ log.warn(
+ "failed to process output for pane id={}: {}",
+ .{ out.pane_id, err },
+ );
+ },
+
+ // Session changed means we switched to a different tmux session.
+ // We need to reset our state and start fresh with list-windows.
+ // This completely replaces the viewer, so treat it like a fresh start.
+ .session_changed => |info| {
+ self.sessionChanged(
+ &actions,
+ info.id,
+ ) catch {
+ log.warn("failed to handle session change, becoming defunct", .{});
+ return self.defunct();
+ };
+
+ // Command is consumed because sessionChanged resets
+ // our entire viewer.
+ command_consumed = true;
+ },
+
+ // Layout changed of a single window.
+ .layout_change => |info| self.layoutChanged(
+ &actions,
+ info.window_id,
+ info.layout,
+ ) catch {
+ // Note: in the future, we can probably handle a failure
+ // here with a fallback to remove this one window, list
+ // windows again, and try again.
+ log.warn("failed to handle layout change, becoming defunct", .{});
+ return self.defunct();
+ },
+
+ // A window was added to this session.
+ .window_add => |info| self.windowAdd(info.id) catch {
+ log.warn("failed to handle window add, becoming defunct", .{});
+ return self.defunct();
+ },
+
+ // The active pane changed. We don't care about this because
+ // we handle our own focus.
+ .window_pane_changed => {},
+
+ // We ignore this one. It means a session was created or
+ // destroyed. If it was our own session we will get an exit
+ // notification very soon. If it is another session we don't
+ // care.
+ .sessions_changed => {},
+
+ // We don't use window names for anything, currently.
+ .window_renamed => {},
+
+ // This is for other clients, which we don't do anything about.
+ // For us, we'll get `exit` or `session_changed`, respectively.
+ .client_detached,
+ .client_session_changed,
+ => {},
+ }
+
+ // After processing commands, we add our next command to
+ // execute if we have one. We do this last because command
+ // processing may itself queue more commands. We only emit a
+ // command if a prior command was consumed (or never existed).
+ if (self.state == .command_queue and command_consumed) {
+ if (self.command_queue.first()) |next_command| {
+ // We should not have any commands, because our nextCommand
+ // always queues them.
+ if (comptime std.debug.runtime_safety) {
+ for (actions.items) |action| {
+ if (action == .command) assert(false);
+ }
+ }
+
+ var arena = self.action_arena.promote(self.alloc);
+ defer self.action_arena = arena.state;
+ const arena_alloc = arena.allocator();
+
+ var builder: std.Io.Writer.Allocating = .init(arena_alloc);
+ next_command.formatCommand(&builder.writer) catch
+ return self.defunct();
+ actions.append(
+ arena_alloc,
+ .{ .command = builder.writer.buffered() },
+ ) catch return self.defunct();
+ }
+ }
+
+ return actions.items;
+ }
+
+ /// When the layout changes for a single window, a pane may be added
+ /// or removed that we've never seen, in addition to the layout itself
+ /// physically changing.
+ ///
+ /// To handle this, its similar to list-windows except we expect the
+ /// window to already exist. We update the layout, do the initLayout
+ /// call for any diffs, setup commands to capture any new panes,
+ /// prune any removed panes.
+ fn layoutChanged(
+ self: *Viewer,
+ actions: *std.ArrayList(Action),
+ window_id: usize,
+ layout_str: []const u8,
+ ) !void {
+ // Find the window this layout change is for.
+ const window: *Window = window: for (self.windows.items) |*w| {
+ if (w.id == window_id) break :window w;
+ } else {
+ log.info("layout change for unknown window id={}", .{window_id});
+ return;
+ };
+
+ // Clear our prior window arena and setup our layout
+ window.layout = layout: {
+ var arena = window.layout_arena.promote(self.alloc);
+ defer window.layout_arena = arena.state;
+ _ = arena.reset(.retain_capacity);
+ break :layout Layout.parseWithChecksum(
+ arena.allocator(),
+ layout_str,
+ ) catch |err| {
+ log.info(
+ "failed to parse window layout id={} layout={s}",
+ .{ window_id, layout_str },
+ );
+ return err;
+ };
+ };
+
+ // Reset our arena so we can build up actions.
+ var arena = self.action_arena.promote(self.alloc);
+ defer self.action_arena = arena.state;
+ const arena_alloc = arena.allocator();
+
+ // Our initial action is to definitely let the caller know that
+ // some windows changed.
+ try actions.append(arena_alloc, .{ .windows = self.windows.items });
+
+ // Sync up our panes
+ try self.syncLayouts(self.windows.items);
+ }
+
+ /// When a window is added to the session, we need to refresh our window
+ /// list to get the new window's information.
+ fn windowAdd(
+ self: *Viewer,
+ window_id: usize,
+ ) !void {
+ _ = window_id; // We refresh all windows via list-windows
+
+ // Queue list-windows to get the updated window list
+ try self.queueCommands(&.{.list_windows});
+ }
+
+ fn syncLayouts(
+ self: *Viewer,
+ windows: []const Window,
+ ) !void {
+ // Go through the window layout and setup all our panes. We move
+ // this into a new panes map so that we can easily prune our old
+ // list.
+ var panes: PanesMap = .empty;
+ errdefer {
+ // Clear out all the new panes.
+ var panes_it = panes.iterator();
+ while (panes_it.next()) |kv| {
+ if (!self.panes.contains(kv.key_ptr.*)) {
+ kv.value_ptr.deinit(self.alloc);
+ }
+ }
+ panes.deinit(self.alloc);
+ }
+ for (windows) |window| try initLayout(
+ self.alloc,
+ &self.panes,
+ &panes,
+ window.layout,
+ );
+
+ // Build up the list of removed panes.
+ var removed: std.ArrayList(usize) = removed: {
+ var removed: std.ArrayList(usize) = .empty;
+ errdefer removed.deinit(self.alloc);
+ var panes_it = self.panes.iterator();
+ while (panes_it.next()) |kv| {
+ if (panes.contains(kv.key_ptr.*)) continue;
+ try removed.append(self.alloc, kv.key_ptr.*);
+ }
+
+ break :removed removed;
+ };
+ defer removed.deinit(self.alloc);
+
+ // Ensure we can add the windows
+ try self.windows.ensureTotalCapacity(self.alloc, windows.len);
+
+ // Get our list of added panes and setup our command queue
+ // to populate them.
+ // TODO: errdefer cleanup
+ {
+ var panes_it = panes.iterator();
+ var added: bool = false;
+ while (panes_it.next()) |kv| {
+ const pane_id: usize = kv.key_ptr.*;
+ if (self.panes.contains(pane_id)) continue;
+ added = true;
+ try self.queueCommands(&.{
+ .{ .pane_history = .{ .id = pane_id, .screen_key = .primary } },
+ .{ .pane_visible = .{ .id = pane_id, .screen_key = .primary } },
+ .{ .pane_history = .{ .id = pane_id, .screen_key = .alternate } },
+ .{ .pane_visible = .{ .id = pane_id, .screen_key = .alternate } },
+ });
+ }
+
+ // If we added any panes, then we also want to resync the pane
+ // state (terminal modes and cursor positions and so on).
+ if (added) try self.queueCommands(&.{.pane_state});
+ }
+
+ // No more errors after this point. We're about to replace all
+ // our owned state with our temporary state, and our errdefers
+ // above will double-free if there is an error.
+ errdefer comptime unreachable;
+
+ // Replace our window list if it changed. We assume it didn't
+ // change if our pointer is pointing to the same data.
+ if (windows.ptr != self.windows.items.ptr) {
+ for (self.windows.items) |*window| window.deinit(self.alloc);
+ self.windows.clearRetainingCapacity();
+ self.windows.appendSliceAssumeCapacity(windows);
+ }
+
+ // Replace our panes
+ {
+ // First remove our old panes
+ for (removed.items) |id| if (self.panes.fetchSwapRemove(
+ id,
+ )) |entry_const| {
+ var entry = entry_const;
+ entry.value.deinit(self.alloc);
+ };
+ // We can now deinit self.panes because the existing
+ // entries are preserved.
+ self.panes.deinit(self.alloc);
+ self.panes = panes;
+ }
+ }
+
+ /// When a session changes, we have to basically reset our whole state.
+ /// To do this, we emit an empty windows event (so callers can clear all
+ /// windows), reset ourself, and start all over.
+ fn sessionChanged(
+ self: *Viewer,
+ actions: *std.ArrayList(Action),
+ session_id: usize,
+ ) (Allocator.Error || std.Io.Writer.Error)!void {
+ // Build up a new viewer. Its the easiest way to reset ourselves.
+ var replacement: Viewer = try .init(self.alloc);
+ errdefer replacement.deinit();
+
+ // Our actions must start out empty so we don't mix arenas
+ assert(actions.items.len == 0);
+ errdefer actions.* = .empty;
+
+ // Build actions: empty windows notification + list-windows command
+ var arena = replacement.action_arena.promote(replacement.alloc);
+ const arena_alloc = arena.allocator();
+ try actions.append(arena_alloc, .{ .windows = &.{} });
+
+ // Setup our command queue and put ourselves in the command queue
+ // state.
+ try replacement.queueCommands(&.{.list_windows});
+ replacement.state = .command_queue;
+
+ // Transfer preserved version to replacement
+ replacement.tmux_version = try replacement.alloc.dupe(u8, self.tmux_version);
+
+ // Save arena state back before swap
+ replacement.action_arena = arena.state;
+
+ // Swap our self, no more error handling after this.
+ errdefer comptime unreachable;
+ self.deinit();
+ self.* = replacement;
+
+ // Set our session ID and jump directly to the list
+ self.session_id = session_id;
+
+ assert(self.state == .command_queue);
+ }
+
+ fn receivedCommandOutput(
+ self: *Viewer,
+ actions: *std.ArrayList(Action),
+ content: []const u8,
+ is_err: bool,
+ ) !void {
+ // Get the command we're expecting output for. We need to get the
+ // non-pointer value because we are deleting it from the circular
+ // buffer immediately. This shallow copy is all we need since
+ // all the memory in Command is owned by GPA.
+ const command: Command = if (self.command_queue.first()) |ptr| switch (ptr.*) {
+ // I truly can't explain this. A simple `ptr.*` copy will cause
+ // our memory to become undefined when deleteOldest is called
+ // below. I logged all the pointers and they don't match so I
+ // don't know how its being set to undefined. But a copy like
+ // this does work.
+ inline else => |v, tag| @unionInit(
+ Command,
+ @tagName(tag),
+ v,
+ ),
+ } else {
+ // If we have no pending commands, this is unexpected.
+ log.info("unexpected block output err={}", .{is_err});
+ return;
+ };
+ self.command_queue.deleteOldest(1);
+ defer command.deinit(self.alloc);
+
+ // We'll use our arena for the return value here so we can
+ // easily accumulate actions.
+ var arena = self.action_arena.promote(self.alloc);
+ defer self.action_arena = arena.state;
+ const arena_alloc = arena.allocator();
+
+ // Process our command
+ switch (command) {
+ .user => {},
+
+ .pane_state => try self.receivedPaneState(content),
+
+ .list_windows => try self.receivedListWindows(
+ arena_alloc,
+ actions,
+ content,
+ ),
+
+ .pane_history => |cap| try self.receivedPaneHistory(
+ cap.screen_key,
+ cap.id,
+ content,
+ ),
+
+ .pane_visible => |cap| try self.receivedPaneVisible(
+ cap.screen_key,
+ cap.id,
+ content,
+ ),
+
+ .tmux_version => try self.receivedTmuxVersion(content),
+ }
+ }
+
+ fn receivedTmuxVersion(
+ self: *Viewer,
+ content: []const u8,
+ ) !void {
+ const line = std.mem.trim(u8, content, " \t\r\n");
+ if (line.len == 0) return;
+
+ const data = output.parseFormatStruct(
+ Format.tmux_version.Struct(),
+ line,
+ Format.tmux_version.delim,
+ ) catch |err| {
+ log.info("failed to parse tmux version: {s}", .{line});
+ return err;
+ };
+
+ if (self.tmux_version.len > 0) {
+ self.alloc.free(self.tmux_version);
+ }
+ self.tmux_version = try self.alloc.dupe(u8, data.version);
+ }
+
+ fn receivedListWindows(
+ self: *Viewer,
+ arena_alloc: Allocator,
+ actions: *std.ArrayList(Action),
+ content: []const u8,
+ ) !void {
+ // If there is an error, reset our actions to what it was before.
+ errdefer actions.shrinkRetainingCapacity(actions.items.len);
+
+ // This stores our new window state from this list-windows output.
+ var windows: std.ArrayList(Window) = .empty;
+ defer windows.deinit(self.alloc);
+
+ // Parse all our windows
+ var it = std.mem.splitScalar(u8, content, '\n');
+ while (it.next()) |line_raw| {
+ const line = std.mem.trim(u8, line_raw, " \t\r");
+ if (line.len == 0) continue;
+ const data = output.parseFormatStruct(
+ Format.list_windows.Struct(),
+ line,
+ Format.list_windows.delim,
+ ) catch |err| {
+ log.info("failed to parse list-windows line: {s}", .{line});
+ return err;
+ };
+
+ // Parse the layout
+ var arena: ArenaAllocator = .init(self.alloc);
+ errdefer arena.deinit();
+ const window_alloc = arena.allocator();
+ const layout: Layout = Layout.parseWithChecksum(
+ window_alloc,
+ data.window_layout,
+ ) catch |err| {
+ log.info(
+ "failed to parse window layout id={} layout={s}",
+ .{ data.window_id, data.window_layout },
+ );
+ return err;
+ };
+
+ try windows.append(self.alloc, .{
+ .id = data.window_id,
+ .width = data.window_width,
+ .height = data.window_height,
+ .layout_arena = arena.state,
+ .layout = layout,
+ });
+ }
+
+ // Setup our windows action so the caller can process GUI
+ // window changes.
+ try actions.append(arena_alloc, .{ .windows = windows.items });
+
+ // Sync up our layouts. This will populate unknown panes, prune, etc.
+ try self.syncLayouts(windows.items);
+ }
+
+ fn receivedPaneState(
+ self: *Viewer,
+ content: []const u8,
+ ) !void {
+ var it = std.mem.splitScalar(u8, content, '\n');
+ while (it.next()) |line_raw| {
+ const line = std.mem.trim(u8, line_raw, " \t\r");
+ if (line.len == 0) continue;
+
+ const data = output.parseFormatStruct(
+ Format.list_panes.Struct(),
+ line,
+ Format.list_panes.delim,
+ ) catch |err| {
+ log.info("failed to parse list-panes line: {s}", .{line});
+ return err;
+ };
+
+ // Get the pane for this ID
+ const entry = self.panes.getEntry(data.pane_id) orelse {
+ log.info("received pane state for untracked pane id={}", .{data.pane_id});
+ continue;
+ };
+ const pane: *Pane = entry.value_ptr;
+ const t: *Terminal = &pane.terminal;
+
+ // Determine which screen to use based on alternate_on
+ const screen_key: ScreenSet.Key = if (data.alternate_on) .alternate else .primary;
+
+ // Set cursor position on the appropriate screen (tmux uses 0-based)
+ if (t.screens.get(screen_key)) |screen| {
+ cursor: {
+ const cursor_x = std.math.cast(
+ size.CellCountInt,
+ data.cursor_x,
+ ) orelse break :cursor;
+ const cursor_y = std.math.cast(
+ size.CellCountInt,
+ data.cursor_y,
+ ) orelse break :cursor;
+ if (cursor_x >= screen.pages.cols or
+ cursor_y >= screen.pages.rows) break :cursor;
+ screen.cursorAbsolute(cursor_x, cursor_y);
+ }
+
+ // Set cursor shape on this screen
+ if (data.cursor_shape.len > 0) {
+ if (std.mem.eql(u8, data.cursor_shape, "block")) {
+ screen.cursor.cursor_style = .block;
+ } else if (std.mem.eql(u8, data.cursor_shape, "underline")) {
+ screen.cursor.cursor_style = .underline;
+ } else if (std.mem.eql(u8, data.cursor_shape, "bar")) {
+ screen.cursor.cursor_style = .bar;
+ }
+ }
+ // "default" or unknown: leave as-is
+ }
+
+ // Set alternate screen saved cursor position
+ if (t.screens.get(.alternate)) |alt_screen| cursor: {
+ const alt_x = std.math.cast(
+ size.CellCountInt,
+ data.alternate_saved_x,
+ ) orelse break :cursor;
+ const alt_y = std.math.cast(
+ size.CellCountInt,
+ data.alternate_saved_y,
+ ) orelse break :cursor;
+
+ // If our coordinates are outside our screen we ignore it.
+ // tmux actually sends MAX_INT for when there isn't a set
+ // cursor position, so this isn't theoretical.
+ if (alt_x >= alt_screen.pages.cols or
+ alt_y >= alt_screen.pages.rows) break :cursor;
+
+ alt_screen.cursorAbsolute(alt_x, alt_y);
+ }
+
+ // Set cursor visibility
+ t.modes.set(.cursor_visible, data.cursor_flag);
+
+ // Set cursor blinking
+ t.modes.set(.cursor_blinking, data.cursor_blinking);
+
+ // Terminal modes
+ t.modes.set(.insert, data.insert_flag);
+ t.modes.set(.wraparound, data.wrap_flag);
+ t.modes.set(.keypad_keys, data.keypad_flag);
+ t.modes.set(.cursor_keys, data.keypad_cursor_flag);
+ t.modes.set(.origin, data.origin_flag);
+
+ // Mouse modes
+ t.modes.set(.mouse_event_any, data.mouse_all_flag);
+ t.modes.set(.mouse_event_button, data.mouse_any_flag);
+ t.modes.set(.mouse_event_normal, data.mouse_button_flag);
+ t.modes.set(.mouse_event_x10, data.mouse_standard_flag);
+ t.modes.set(.mouse_format_utf8, data.mouse_utf8_flag);
+ t.modes.set(.mouse_format_sgr, data.mouse_sgr_flag);
+
+ // Focus and bracketed paste
+ t.modes.set(.focus_event, data.focus_flag);
+ t.modes.set(.bracketed_paste, data.bracketed_paste);
+
+ // Scroll region (tmux uses 0-based values)
+ scroll: {
+ const scroll_top = std.math.cast(
+ size.CellCountInt,
+ data.scroll_region_upper,
+ ) orelse break :scroll;
+ const scroll_bottom = std.math.cast(
+ size.CellCountInt,
+ data.scroll_region_lower,
+ ) orelse break :scroll;
+ t.scrolling_region.top = scroll_top;
+ t.scrolling_region.bottom = scroll_bottom;
+ }
+
+ // Tab stops - parse comma-separated list and set
+ t.tabstops.reset(0); // Clear all tabstops first
+ if (data.pane_tabs.len > 0) {
+ var tabs_it = std.mem.splitScalar(u8, data.pane_tabs, ',');
+ while (tabs_it.next()) |tab_str| {
+ const col = std.fmt.parseInt(usize, tab_str, 10) catch continue;
+ const col_cell = std.math.cast(size.CellCountInt, col) orelse continue;
+ if (col_cell >= t.cols) continue;
+ t.tabstops.set(col_cell);
+ }
+ }
+ }
+ }
+
+ fn receivedPaneHistory(
+ self: *Viewer,
+ screen_key: ScreenSet.Key,
+ id: usize,
+ content: []const u8,
+ ) !void {
+ // Get our pane
+ const entry = self.panes.getEntry(id) orelse {
+ log.info("received pane history for untracked pane id={}", .{id});
+ return;
+ };
+ const pane: *Pane = entry.value_ptr;
+ const t: *Terminal = &pane.terminal;
+ _ = try t.switchScreen(screen_key);
+ const screen: *Screen = t.screens.active;
+
+ // Get a VT stream from the terminal so we can send data as-is into
+ // it. This will populate the active area too so it won't be exactly
+ // correct but we'll get the active contents soon.
+ var stream = t.vtStream();
+ defer stream.deinit();
+ stream.nextSlice(content);
+
+ // Populate the active area to be empty since this is only history.
+ // We'll fill it with blanks and move the cursor to the top-left.
+ t.carriageReturn();
+ for (0..t.rows) |_| try t.index();
+ t.setCursorPos(1, 1);
+
+ // Our active area should be empty
+ if (comptime std.debug.runtime_safety) {
+ var discarding: std.Io.Writer.Discarding = .init(&.{});
+ screen.dumpString(&discarding.writer, .{
+ .tl = screen.pages.getTopLeft(.active),
+ .unwrap = false,
+ }) catch unreachable;
+ assert(discarding.count == 0);
+ }
+ }
+
+ fn receivedPaneVisible(
+ self: *Viewer,
+ screen_key: ScreenSet.Key,
+ id: usize,
+ content: []const u8,
+ ) !void {
+ // Get our pane
+ const entry = self.panes.getEntry(id) orelse {
+ log.info("received pane visible for untracked pane id={}", .{id});
+ return;
+ };
+ const pane: *Pane = entry.value_ptr;
+ const t: *Terminal = &pane.terminal;
+ _ = try t.switchScreen(screen_key);
+
+ // Erase the active area and reset the cursor to the top-left
+ // before writing the visible content.
+ t.eraseDisplay(.complete, false);
+ t.setCursorPos(1, 1);
+
+ var stream = t.vtStream();
+ defer stream.deinit();
+ stream.nextSlice(content);
+ }
+
+ fn receivedOutput(
+ self: *Viewer,
+ id: usize,
+ data: []const u8,
+ ) !void {
+ const entry = self.panes.getEntry(id) orelse {
+ log.info("received output for untracked pane id={}", .{id});
+ return;
+ };
+ const pane: *Pane = entry.value_ptr;
+ const t: *Terminal = &pane.terminal;
+
+ var stream = t.vtStream();
+ defer stream.deinit();
+ stream.nextSlice(data);
+ }
+
+ fn initLayout(
+ gpa_alloc: Allocator,
+ panes_old: *const PanesMap,
+ panes_new: *PanesMap,
+ layout: Layout,
+ ) !void {
+ switch (layout.content) {
+ // Nested layouts, continue going.
+ .horizontal, .vertical => |layouts| {
+ for (layouts) |l| {
+ try initLayout(
+ gpa_alloc,
+ panes_old,
+ panes_new,
+ l,
+ );
+ }
+ },
+
+ // A leaf! Initialize.
+ .pane => |id| pane: {
+ const gop = try panes_new.getOrPut(gpa_alloc, id);
+ if (gop.found_existing) break :pane;
+ errdefer _ = panes_new.swapRemove(gop.key_ptr.*);
+
+ // If we already have this pane, it is already initialized
+ // so just copy it over.
+ if (panes_old.getEntry(id)) |entry| {
+ gop.value_ptr.* = entry.value_ptr.*;
+ break :pane;
+ }
+
+ // TODO: We need to gracefully handle overflow of our
+ // max cols/width here. In practice we shouldn't hit this
+ // so we cast but its not safe.
+ var t: Terminal = try .init(gpa_alloc, .{
+ .cols = @intCast(layout.width),
+ .rows = @intCast(layout.height),
+ });
+ errdefer t.deinit(gpa_alloc);
+
+ gop.value_ptr.* = .{
+ .terminal = t,
+ };
+ },
+ }
+ }
+
+ /// Enters the command queue state from any other state, queueing
+ /// the commands and returning an action to execute the first command.
+ fn enterCommandQueue(
+ self: *Viewer,
+ arena_alloc: Allocator,
+ commands: []const Command,
+ ) Allocator.Error![]const Action {
+ assert(self.state != .command_queue);
+ assert(commands.len > 0);
+
+ // Build our command string to send for the action.
+ var builder: std.Io.Writer.Allocating = .init(arena_alloc);
+ commands[0].formatCommand(&builder.writer) catch return error.OutOfMemory;
+ const action: Action = .{ .command = builder.writer.buffered() };
+
+ // Add our commands
+ try self.command_queue.ensureUnusedCapacity(self.alloc, commands.len);
+ for (commands) |cmd| self.command_queue.appendAssumeCapacity(cmd);
+
+ // Move into the command queue state
+ self.state = .command_queue;
+
+ return self.singleAction(action);
+ }
+
+ /// Queue multiple commands to execute. This doesn't add anything
+ /// to the actions queue or return actions or anything because the
+ /// command_queue state will automatically send the next command when
+ /// it receives output.
+ fn queueCommands(
+ self: *Viewer,
+ commands: []const Command,
+ ) Allocator.Error!void {
+ try self.command_queue.ensureUnusedCapacity(
+ self.alloc,
+ commands.len,
+ );
+ for (commands) |command| {
+ self.command_queue.appendAssumeCapacity(command);
+ }
+ }
+
+ /// Helper to return a single action. The input action may use the arena
+ /// for allocated memory; this will not touch the arena.
+ fn singleAction(self: *Viewer, action: Action) []const Action {
+ // Make our single action slice.
+ self.action_single[0] = action;
+ return &self.action_single;
+ }
+
+ fn defunct(self: *Viewer) []const Action {
+ self.state = .defunct;
+ return self.singleAction(.exit);
+ }
+};
+
+const State = enum {
+ /// We start in this state just after receiving the initial
+ /// DCS 1000p opening sequence. We wait for an initial
+ /// begin/end block that is guaranteed to be sent by tmux for
+ /// the initial control mode command. (See tmux server-client.c
+ /// where control mode starts).
+ startup_block,
+
+ /// After receiving the initial block, we wait for a session-changed
+ /// notification to record the initial session ID.
+ startup_session,
+
+ /// Tmux has closed the control mode connection
+ defunct,
+
+ /// We're sitting on the command queue waiting for command output
+ /// in the order provided in the `command_queue` field. This field
+ /// isn't part of the state because it can be queued at any state.
+ ///
+ /// Precondition: if self.command_queue.len > 0, then the first
+ /// command in the queue has already been sent to tmux (via a
+ /// `command` Action). The next output is assumed to be the result
+ /// of this command.
+ ///
+ /// To satisfy the above, any transitions INTO this state should
+ /// send a command Action for the first command in the queue.
+ command_queue,
+};
+
+const Command = union(enum) {
+ /// List all windows so we can sync our window state.
+ list_windows,
+
+ /// Capture history for the given pane ID.
+ pane_history: CapturePane,
+
+ /// Capture visible area for the given pane ID.
+ pane_visible: CapturePane,
+
+ /// Capture the pane terminal state as best we can. The pane ID(s)
+ /// are part of the output so we can map it back to our panes.
+ pane_state,
+
+ /// Get the tmux server version.
+ tmux_version,
+
+ /// User command. This is a command provided by the user. Since
+ /// this is user provided, we can't be sure what it is.
+ user: []const u8,
+
+ const CapturePane = struct {
+ id: usize,
+ screen_key: ScreenSet.Key,
+ };
+
+ pub fn deinit(self: Command, alloc: Allocator) void {
+ return switch (self) {
+ .list_windows,
+ .pane_history,
+ .pane_visible,
+ .pane_state,
+ .tmux_version,
+ => {},
+ .user => |v| alloc.free(v),
+ };
+ }
+
+ /// Format the command into the command that should be executed
+ /// by tmux. Trailing newlines are appended so this can be sent as-is
+ /// to tmux.
+ pub fn formatCommand(
+ self: Command,
+ writer: *std.Io.Writer,
+ ) std.Io.Writer.Error!void {
+ switch (self) {
+ .list_windows => try writer.writeAll(std.fmt.comptimePrint(
+ "list-windows -F '{s}'\n",
+ .{comptime Format.list_windows.comptimeFormat()},
+ )),
+
+ .pane_history => |cap| try writer.print(
+ // -p = output to stdout instead of buffer
+ // -e = output escape sequences for SGR
+ // -a = capture alternate screen (only valid for alternate)
+ // -q = quiet, don't error if alternate screen doesn't exist
+ // -S - = start at the top of history ("-")
+ // -E -1 = end at the last line of history (1 before the
+ // visible area is -1).
+ // -t %{d} = target a specific pane ID
+ "capture-pane -p -e -q {s}-S - -E -1 -t %{d}\n",
+ .{
+ if (cap.screen_key == .alternate) "-a " else "",
+ cap.id,
+ },
+ ),
+
+ .pane_visible => |cap| try writer.print(
+ // -p = output to stdout instead of buffer
+ // -e = output escape sequences for SGR
+ // -a = capture alternate screen (only valid for alternate)
+ // -q = quiet, don't error if alternate screen doesn't exist
+ // -t %{d} = target a specific pane ID
+ // (no -S/-E = capture visible area only)
+ "capture-pane -p -e -q {s}-t %{d}\n",
+ .{
+ if (cap.screen_key == .alternate) "-a " else "",
+ cap.id,
+ },
+ ),
+
+ .pane_state => try writer.writeAll(std.fmt.comptimePrint(
+ "list-panes -F '{s}'\n",
+ .{comptime Format.list_panes.comptimeFormat()},
+ )),
+
+ .tmux_version => try writer.writeAll(std.fmt.comptimePrint(
+ "display-message -p '{s}'\n",
+ .{comptime Format.tmux_version.comptimeFormat()},
+ )),
+
+ .user => |v| try writer.writeAll(v),
+ }
+ }
+};
+
+/// Format strings used for commands in our viewer.
+const Format = struct {
+ /// The variables included in this format, in order.
+ vars: []const output.Variable,
+
+ /// The delimiter to use between variables. This must be a character
+ /// guaranteed to not appear in any of the variable outputs.
+ delim: u8,
+
+ const list_panes: Format = .{
+ .delim = ';',
+ .vars = &.{
+ .pane_id,
+ // Cursor position & appearance
+ .cursor_x,
+ .cursor_y,
+ .cursor_flag,
+ .cursor_shape,
+ .cursor_colour,
+ .cursor_blinking,
+ // Alternate screen
+ .alternate_on,
+ .alternate_saved_x,
+ .alternate_saved_y,
+ // Terminal modes
+ .insert_flag,
+ .wrap_flag,
+ .keypad_flag,
+ .keypad_cursor_flag,
+ .origin_flag,
+ // Mouse modes
+ .mouse_all_flag,
+ .mouse_any_flag,
+ .mouse_button_flag,
+ .mouse_standard_flag,
+ .mouse_utf8_flag,
+ .mouse_sgr_flag,
+ // Focus & special features
+ .focus_flag,
+ .bracketed_paste,
+ // Scroll region
+ .scroll_region_upper,
+ .scroll_region_lower,
+ // Tab stops
+ .pane_tabs,
+ },
+ };
+
+ const list_windows: Format = .{
+ .delim = ' ',
+ .vars = &.{
+ .session_id,
+ .window_id,
+ .window_width,
+ .window_height,
+ .window_layout,
+ },
+ };
+
+ const tmux_version: Format = .{
+ .delim = ' ',
+ .vars = &.{.version},
+ };
+
+ /// The format string, available at comptime.
+ pub fn comptimeFormat(comptime self: Format) []const u8 {
+ return output.comptimeFormat(self.vars, self.delim);
+ }
+
+ /// The struct that can contain the parsed output.
+ pub fn Struct(comptime self: Format) type {
+ return output.FormatStruct(self.vars);
+ }
+};
+
+const TestStep = struct {
+ input: Viewer.Input,
+ contains_tags: []const std.meta.Tag(Viewer.Action) = &.{},
+ contains_command: []const u8 = "",
+ check: ?*const fn (viewer: *Viewer, []const Viewer.Action) anyerror!void = null,
+ check_command: ?*const fn (viewer: *Viewer, []const u8) anyerror!void = null,
+
+ fn run(self: TestStep, viewer: *Viewer) !void {
+ const actions = viewer.next(self.input);
+
+ // Common mistake, forgetting the newline on a command.
+ for (actions) |action| {
+ if (action == .command) {
+ try testing.expect(std.mem.endsWith(u8, action.command, "\n"));
+ }
+ }
+
+ for (self.contains_tags) |tag| {
+ var found = false;
+ for (actions) |action| {
+ if (action == tag) {
+ found = true;
+ break;
+ }
+ }
+ try testing.expect(found);
+ }
+
+ if (self.contains_command.len > 0) {
+ var found = false;
+ for (actions) |action| {
+ if (action == .command and
+ std.mem.startsWith(u8, action.command, self.contains_command))
+ {
+ found = true;
+ break;
+ }
+ }
+ try testing.expect(found);
+ }
+
+ if (self.check) |check_fn| {
+ try check_fn(viewer, actions);
+ }
+
+ if (self.check_command) |check_fn| {
+ var found = false;
+ for (actions) |action| {
+ if (action == .command) {
+ found = true;
+ try check_fn(viewer, action.command);
+ }
+ }
+ try testing.expect(found);
+ }
+ }
+};
+
+/// A helper to run a series of test steps against a viewer and assert
+/// that the expected actions are produced.
+///
+/// I'm generally not a fan of these types of abstracted tests because
+/// it makes diagnosing failures harder, but being able to construct
+/// simulated tmux inputs and verify outputs is going to be extremely
+/// important since the tmux control mode protocol is very complex and
+/// fragile.
+fn testViewer(viewer: *Viewer, steps: []const TestStep) !void {
+ for (steps, 0..) |step, i| {
+ step.run(viewer) catch |err| {
+ log.warn("testViewer step failed i={} step={}", .{ i, step });
+ return err;
+ };
+ }
+}
+
+test "immediate exit" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .check = (struct {
+ fn check(_: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(0, actions.len);
+ }
+ }).check,
+ },
+ });
+}
+
+test "session changed resets state" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "first",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive window layout with two panes (same format as "initial flow" test)
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$1 @0 83 44 027b,83x44,0,0[83x20,0,0,0,83x23,0,21,1]
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(1, v.session_id);
+ try testing.expectEqual(1, v.windows.items.len);
+ try testing.expectEqual(2, v.panes.count());
+ try testing.expectEqualStrings("3.5a", v.tmux_version);
+ }
+ }).check,
+ },
+ // Now session changes - should reset everything but keep version
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 2,
+ .name = "second",
+ } } },
+ .contains_tags = &.{ .windows, .command },
+ .contains_command = "list-windows",
+ .check = (struct {
+ fn check(v: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ // Session ID should be updated
+ try testing.expectEqual(2, v.session_id);
+ // Windows should be cleared (empty windows action sent)
+ var found_empty_windows = false;
+ for (actions) |action| {
+ if (action == .windows and action.windows.len == 0) {
+ found_empty_windows = true;
+ }
+ }
+ try testing.expect(found_empty_windows);
+ // Old windows should be cleared
+ try testing.expectEqual(0, v.windows.items.len);
+ // Old panes should be cleared
+ try testing.expectEqual(0, v.panes.count());
+ // Version should still be preserved
+ try testing.expectEqualStrings("3.5a", v.tmux_version);
+ }
+ }).check,
+ },
+ // Receive new window layout for new session (same layout, different session/window)
+ // Uses same pane IDs 0,1 - they should be re-created since old panes were cleared
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$2 @1 83 44 027b,83x44,0,0[83x20,0,0,0,83x23,0,21,1]
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(2, v.session_id);
+ try testing.expectEqual(1, v.windows.items.len);
+ try testing.expectEqual(1, v.windows.items[0].id);
+ // Panes 0 and 1 should be created (fresh, since old ones were cleared)
+ try testing.expectEqual(2, v.panes.count());
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "initial flow" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 42,
+ .name = "main",
+ } } },
+ .contains_command = "display-message",
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(42, v.session_id);
+ }
+ }).check,
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqualStrings("3.5a", v.tmux_version);
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 027b,83x44,0,0[83x20,0,0,0,83x23,0,21,1]
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .contains_command = "capture-pane",
+ // pane_history for pane 0 (primary)
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %0"));
+ try testing.expect(!std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\Hello, world!
+ ,
+ } },
+ // Moves on to pane_visible for pane 0 (primary)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %0"));
+ try testing.expect(!std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ const pane: *Viewer.Pane = v.panes.getEntry(0).?.value_ptr;
+ const screen: *Screen = pane.terminal.screens.active;
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .history = .{} },
+ );
+ defer testing.allocator.free(str);
+ try testing.expectEqualStrings("Hello, world!", str);
+ }
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .active = .{} },
+ );
+ defer testing.allocator.free(str);
+ try testing.expectEqualStrings("", str);
+ }
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_history for pane 0 (alternate)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %0"));
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_visible for pane 0 (alternate)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %0"));
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_history for pane 1 (primary)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %1"));
+ try testing.expect(!std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_visible for pane 1 (primary)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %1"));
+ try testing.expect(!std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_history for pane 1 (alternate)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %1"));
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ // Moves on to pane_visible for pane 1 (alternate)
+ .contains_command = "capture-pane",
+ .check_command = (struct {
+ fn check(_: *Viewer, command: []const u8) anyerror!void {
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-t %1"));
+ try testing.expect(std.mem.containsAtLeast(u8, command, 1, "-a"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ },
+ .{
+ .input = .{ .tmux = .{ .output = .{ .pane_id = 0, .data = "new output" } } },
+ .check = (struct {
+ fn check(v: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(0, actions.len);
+ const pane: *Viewer.Pane = v.panes.getEntry(0).?.value_ptr;
+ const screen: *Screen = pane.terminal.screens.active;
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .active = .{} },
+ );
+ defer testing.allocator.free(str);
+ try testing.expect(std.mem.containsAtLeast(u8, str, 1, "new output"));
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .{ .output = .{ .pane_id = 999, .data = "ignored" } } },
+ .check = (struct {
+ fn check(_: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(0, actions.len);
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "layout change" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "test",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive initial window layout with one pane
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 b7dd,83x44,0,0,0
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(1, v.windows.items.len);
+ try testing.expectEqual(1, v.panes.count());
+ try testing.expect(v.panes.contains(0));
+ }
+ }).check,
+ },
+ // Complete all capture-pane commands for pane 0 (primary and alternate)
+ // plus pane_state
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // Now send a layout_change that splits into two panes
+ .{
+ .input = .{ .tmux = .{ .layout_change = .{
+ .window_id = 0,
+ .layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .visible_layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .raw_flags = "*",
+ } } },
+ .contains_tags = &.{.windows},
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ // Should still have 1 window
+ try testing.expectEqual(1, v.windows.items.len);
+ // Should now have 2 panes (0 and 2)
+ try testing.expectEqual(2, v.panes.count());
+ try testing.expect(v.panes.contains(0));
+ try testing.expect(v.panes.contains(2));
+ // Commands should be queued for the new pane (4 capture-pane + 1 pane_state)
+ try testing.expectEqual(5, v.command_queue.len());
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "layout_change does not return command when queue not empty" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "test",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive initial window layout with one pane
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 b7dd,83x44,0,0,0
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expect(!v.command_queue.empty());
+ }
+ }).check,
+ },
+ // Do NOT complete capture-pane commands - queue still has commands.
+ // Send a layout_change that splits into two panes.
+ // This should NOT return a command action since queue was not empty.
+ .{
+ .input = .{ .tmux = .{ .layout_change = .{
+ .window_id = 0,
+ .layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .visible_layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .raw_flags = "*",
+ } } },
+ .contains_tags = &.{.windows},
+ .check = (struct {
+ fn check(v: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(2, v.panes.count());
+ // Should not contain a command action
+ for (actions) |action| {
+ try testing.expect(action != .command);
+ }
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "layout_change returns command when queue was empty" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "test",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive initial window layout with one pane
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 b7dd,83x44,0,0,0
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ },
+ // Complete all capture-pane commands for pane 0
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // Queue should now be empty
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expect(v.command_queue.empty());
+ }
+ }).check,
+ },
+ // Now send a layout_change that splits into two panes.
+ // This should return a command action since we're queuing commands
+ // for the new pane and the queue was empty.
+ .{
+ .input = .{ .tmux = .{ .layout_change = .{
+ .window_id = 0,
+ .layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .visible_layout = "e07b,83x44,0,0[83x22,0,0,0,83x21,0,23,2]",
+ .raw_flags = "*",
+ } } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(2, v.panes.count());
+ try testing.expect(!v.command_queue.empty());
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "window_add queues list_windows when queue empty" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "test",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive initial window layout with one pane
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 b7dd,83x44,0,0,0
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ },
+ // Complete all capture-pane commands for pane 0
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // Queue should now be empty
+ .{
+ .input = .{ .tmux = .{ .block_end = "" } },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expect(v.command_queue.empty());
+ }
+ }).check,
+ },
+ // Now send window_add - should trigger list-windows command
+ .{
+ .input = .{ .tmux = .{ .window_add = .{ .id = 1 } } },
+ .contains_command = "list-windows",
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ // Command queue should have list_windows
+ try testing.expect(!v.command_queue.empty());
+ try testing.expectEqual(1, v.command_queue.len());
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "window_add queues list_windows when queue not empty" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial startup
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 1,
+ .name = "test",
+ } } },
+ .contains_command = "display-message",
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // Receive initial window layout with one pane
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 83 44 b7dd,83x44,0,0,0
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ // Queue should have capture-pane commands
+ try testing.expect(!v.command_queue.empty());
+ }
+ }).check,
+ },
+ // Do NOT complete capture-pane commands - queue still has commands.
+ // Send window_add - should queue list-windows but NOT return command action
+ .{
+ .input = .{ .tmux = .{ .window_add = .{ .id = 1 } } },
+ .check = (struct {
+ fn check(v: *Viewer, actions: []const Viewer.Action) anyerror!void {
+ // Should not contain a command action since queue was not empty
+ for (actions) |action| {
+ try testing.expect(action != .command);
+ }
+ // But list_windows should be in the queue
+ try testing.expect(!v.command_queue.empty());
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}
+
+test "two pane flow with pane state" {
+ var viewer = try Viewer.init(testing.allocator);
+ defer viewer.deinit();
+
+ try testViewer(&viewer, &.{
+ // Initial block_end from attach
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // Session changed notification
+ .{
+ .input = .{ .tmux = .{ .session_changed = .{
+ .id = 0,
+ .name = "0",
+ } } },
+ .contains_command = "display-message",
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(0, v.session_id);
+ }
+ }).check,
+ },
+ // Receive version response, which triggers list-windows
+ .{
+ .input = .{ .tmux = .{ .block_end = "3.5a" } },
+ .contains_command = "list-windows",
+ },
+ // list-windows output with 2 panes in a vertical split
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\$0 @0 165 79 ca97,165x79,0,0[165x40,0,0,0,165x38,0,41,4]
+ ,
+ } },
+ .contains_tags = &.{ .windows, .command },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ try testing.expectEqual(1, v.windows.items.len);
+ const window = v.windows.items[0];
+ try testing.expectEqual(0, window.id);
+ try testing.expectEqual(165, window.width);
+ try testing.expectEqual(79, window.height);
+ try testing.expectEqual(2, v.panes.count());
+ try testing.expect(v.panes.contains(0));
+ try testing.expect(v.panes.contains(4));
+ }
+ }).check,
+ },
+ // capture-pane pane 0 primary history
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\prompt %
+ \\prompt %
+ ,
+ } },
+ },
+ // capture-pane pane 0 primary visible
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\prompt %
+ ,
+ } },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ const pane: *Viewer.Pane = v.panes.getEntry(0).?.value_ptr;
+ const screen: *Screen = pane.terminal.screens.active;
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .history = .{} },
+ );
+ defer testing.allocator.free(str);
+ // History has 2 lines with "prompt %" (padded to screen width)
+ try testing.expect(std.mem.containsAtLeast(u8, str, 2, "prompt %"));
+ }
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .active = .{} },
+ );
+ defer testing.allocator.free(str);
+ try testing.expectEqualStrings("prompt %", str);
+ }
+ }
+ }).check,
+ },
+ // capture-pane pane 0 alternate history (empty)
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // capture-pane pane 0 alternate visible (empty)
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // capture-pane pane 4 primary history
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\prompt %
+ ,
+ } },
+ },
+ // capture-pane pane 4 primary visible
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\prompt %
+ ,
+ } },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ const pane: *Viewer.Pane = v.panes.getEntry(4).?.value_ptr;
+ const screen: *Screen = pane.terminal.screens.active;
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .history = .{} },
+ );
+ defer testing.allocator.free(str);
+ try testing.expectEqualStrings("prompt %", str);
+ }
+ {
+ const str = try screen.dumpStringAlloc(
+ testing.allocator,
+ .{ .active = .{} },
+ );
+ defer testing.allocator.free(str);
+ // Active screen starts with "prompt %" at beginning
+ try testing.expect(std.mem.startsWith(u8, str, "prompt %"));
+ }
+ }
+ }).check,
+ },
+ // capture-pane pane 4 alternate history (empty)
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // capture-pane pane 4 alternate visible (empty)
+ .{ .input = .{ .tmux = .{ .block_end = "" } } },
+ // list-panes output with terminal state
+ .{
+ .input = .{ .tmux = .{
+ .block_end =
+ \\%0;42;0;1;;;;0;4294967295;4294967295;0;1;0;0;0;0;0;0;0;0;0;;;0;39;8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160
+ \\%4;10;5;1;;;;0;4294967295;4294967295;0;1;0;0;0;0;0;0;0;0;0;;;0;37;8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160
+ ,
+ } },
+ .check = (struct {
+ fn check(v: *Viewer, _: []const Viewer.Action) anyerror!void {
+ // Pane 0: cursor at (42, 0), cursor visible, wraparound on
+ {
+ const pane: *Viewer.Pane = v.panes.getEntry(0).?.value_ptr;
+ const t: *Terminal = &pane.terminal;
+ const screen: *Screen = t.screens.get(.primary).?;
+ try testing.expectEqual(42, screen.cursor.x);
+ try testing.expectEqual(0, screen.cursor.y);
+ try testing.expect(t.modes.get(.cursor_visible));
+ try testing.expect(t.modes.get(.wraparound));
+ try testing.expect(!t.modes.get(.insert));
+ try testing.expect(!t.modes.get(.origin));
+ try testing.expect(!t.modes.get(.keypad_keys));
+ try testing.expect(!t.modes.get(.cursor_keys));
+ }
+ // Pane 4: cursor at (10, 5), cursor visible, wraparound on
+ {
+ const pane: *Viewer.Pane = v.panes.getEntry(4).?.value_ptr;
+ const t: *Terminal = &pane.terminal;
+ const screen: *Screen = t.screens.get(.primary).?;
+ try testing.expectEqual(10, screen.cursor.x);
+ try testing.expectEqual(5, screen.cursor.y);
+ try testing.expect(t.modes.get(.cursor_visible));
+ try testing.expect(t.modes.get(.wraparound));
+ try testing.expect(!t.modes.get(.insert));
+ try testing.expect(!t.modes.get(.origin));
+ try testing.expect(!t.modes.get(.keypad_keys));
+ try testing.expect(!t.modes.get(.cursor_keys));
+ }
+ }
+ }).check,
+ },
+ .{
+ .input = .{ .tmux = .exit },
+ .contains_tags = &.{.exit},
+ },
+ });
+}