aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-09-10 21:51:57 +0300
committerGitHub <noreply@github.com>2026-09-10 21:51:57 +0300
commit425c86179791cd32e2d4ce0ae7f269940b4b0663 (patch)
treee52c4383a6d69216cbe2a32638bf90841d7e2189 /vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig
parent90e947a6e26e02f10ec7f1694c4eb5b78a86406b (diff)
chore: upgrade libghostty and preserve terminal behavior (#3906)
Diffstat (limited to 'vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig')
-rw-r--r--vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig248
1 files changed, 248 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig b/vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig
new file mode 100644
index 00000000..1f7584f1
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/kitty/dnd_response.zig
@@ -0,0 +1,248 @@
+const std = @import("std");
+const Terminator = @import("../osc.zig").Terminator;
+
+/// The maximum raw bytes per base64-encoded chunk, chosen by kitty so a
+/// chunk is exactly 4096 base64 characters (the protocol's chunk limit).
+pub const max_chunk_raw = 3072;
+
+/// The maximum bytes per plain-text (non-base64) chunk.
+pub const max_chunk_plain = 4096;
+
+/// Error names used in protocol error payloads. The wire encoding is
+/// the tag name itself. This matches kitty's get_errno_name vocabulary,
+/// which extends the spec's list with EISDIR, ENOSPC, and OK.
+pub const Errno = enum {
+ OK,
+ EPERM,
+ ENOENT,
+ EIO,
+ EINVAL,
+ EMFILE,
+ ENOMEM,
+ EFBIG,
+ EISDIR,
+ ENOSPC,
+ EUNKNOWN,
+};
+
+/// The payload encoding for a message.
+pub const Encoding = enum {
+ /// Payload bytes are sent as-is (MIME lists, error strings).
+ plain,
+
+ /// Payload bytes are base64-encoded (all binary data).
+ base64,
+};
+
+/// The `x`/`y`/`Y` keys of the data request currently being answered,
+/// echoed in responses and errors so the client can match them up. Only
+/// non-zero keys are written, matching kitty's drop_append_request_keys.
+pub const RequestKeys = struct {
+ x: i32 = 0,
+ y: i32 = 0,
+ Y: i32 = 0,
+
+ pub fn format(self: RequestKeys, writer: *std.Io.Writer) !void {
+ if (self.x != 0) try writer.print(":x={d}", .{self.x});
+ if (self.y != 0) try writer.print(":y={d}", .{self.y});
+ if (self.Y != 0) try writer.print(":Y={d}", .{self.Y});
+ }
+};
+
+/// Encode a complete protocol message: one bare OSC when `data` is
+/// empty, otherwise one complete OSC per chunk of `data`, each
+/// repeating the header. The final chunk carries `m=0`, earlier
+/// chunks `m=1`.
+///
+/// `header` is the metadata without the OSC introducer, e.g. "t=q" or
+/// "t=m:x=5:y=3". The client ID is appended as `:i=N` when non-zero.
+pub fn encode(
+ writer: *std.Io.Writer,
+ header: []const u8,
+ client_id: u32,
+ data: []const u8,
+ encoding: Encoding,
+ terminator: Terminator,
+) std.Io.Writer.Error!void {
+ // The client ID is part of the repeated header.
+ var id_buf: [16]u8 = undefined;
+ const id: []const u8 = if (client_id != 0) std.fmt.bufPrint(
+ &id_buf,
+ ":i={d}",
+ .{client_id},
+ ) catch unreachable else "";
+
+ if (data.len == 0) {
+ try writer.print("\x1b]72;{s}{s}{s}", .{
+ header,
+ id,
+ terminator.string(),
+ });
+ return;
+ }
+
+ const limit: usize = switch (encoding) {
+ .base64 => max_chunk_raw,
+ .plain => max_chunk_plain,
+ };
+
+ var offset: usize = 0;
+ while (offset < data.len) {
+ const chunk_len = @min(data.len - offset, limit);
+ const chunk = data[offset .. offset + chunk_len];
+ offset += chunk_len;
+ const last: u8 = if (offset >= data.len) '0' else '1';
+
+ try writer.print("\x1b]72;{s}{s}:m={c};", .{ header, id, last });
+ switch (encoding) {
+ .plain => try writer.writeAll(chunk),
+ .base64 => {
+ var b64_buf: [std.base64.standard.Encoder.calcSize(max_chunk_raw)]u8 = undefined;
+ try writer.writeAll(std.base64.standard.Encoder.encode(
+ &b64_buf,
+ chunk,
+ ));
+ },
+ }
+ try writer.writeAll(terminator.string());
+ }
+}
+
+/// Encode an error response. `kind` selects the header: t=R for drop
+/// data request errors, t=E for drag offer errors. The payload is
+/// "NAME" or "NAME:description", sent plain (not base64).
+pub fn encodeError(
+ writer: *std.Io.Writer,
+ kind: enum { drop, drag },
+ keys: RequestKeys,
+ client_id: u32,
+ errno: Errno,
+ desc: []const u8,
+ terminator: Terminator,
+) std.Io.Writer.Error!void {
+ var header_buf: [64]u8 = undefined;
+ const header = std.fmt.bufPrint(&header_buf, "t={c}{f}", .{
+ @as(u8, switch (kind) {
+ .drop => 'R',
+ .drag => 'E',
+ }),
+ keys,
+ }) catch unreachable;
+
+ // Description strings are short static messages; size the buffer
+ // for the longest error name plus a generous description.
+ var payload_buf: [256]u8 = undefined;
+ const payload = if (desc.len > 0) std.fmt.bufPrint(
+ &payload_buf,
+ "{t}:{s}",
+ .{ errno, desc },
+ ) catch unreachable else @tagName(errno);
+
+ try encode(writer, header, client_id, payload, .plain, terminator);
+}
+
+test "encode: bare message" {
+ const testing = std.testing;
+ var buf: [128]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ try encode(&writer, "t=q", 0, "", .plain, .st);
+ try testing.expectEqualStrings("\x1b]72;t=q\x1b\\", writer.buffered());
+}
+
+test "encode: bare message with client id" {
+ const testing = std.testing;
+ var buf: [128]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ try encode(&writer, "t=q", 7, "", .plain, .st);
+ try testing.expectEqualStrings("\x1b]72;t=q:i=7\x1b\\", writer.buffered());
+}
+
+test "encode: plain payload single chunk" {
+ const testing = std.testing;
+ var buf: [128]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ try encode(&writer, "t=m:x=1:y=2", 0, "text/plain ", .plain, .st);
+ try testing.expectEqualStrings(
+ "\x1b]72;t=m:x=1:y=2:m=0;text/plain \x1b\\",
+ writer.buffered(),
+ );
+}
+
+test "encode: base64 payload chunking" {
+ const testing = std.testing;
+ const alloc = testing.allocator;
+
+ var aw: std.Io.Writer.Allocating = .init(alloc);
+ defer aw.deinit();
+
+ // Exactly one byte more than a chunk to force two chunks.
+ const data = [_]u8{'A'} ** (max_chunk_raw + 1);
+ try encode(&aw.writer, "t=r:x=1", 3, &data, .base64, .st);
+
+ const out = aw.written();
+
+ // First chunk: full header, m=1, 4096 base64 chars.
+ const prefix = "\x1b]72;t=r:x=1:i=3:m=1;";
+ try testing.expect(std.mem.startsWith(u8, out, prefix));
+ const first_end = std.mem.indexOf(u8, out, "\x1b\\").?;
+ try testing.expectEqual(@as(usize, prefix.len + 4096), first_end);
+
+ // Second chunk: m=0 with the single remaining byte.
+ const rest = out[first_end + 2 ..];
+ try testing.expect(std.mem.startsWith(u8, rest, "\x1b]72;t=r:x=1:i=3:m=0;"));
+
+ // Decodes back to the original data.
+ var decoded: std.ArrayList(u8) = .empty;
+ defer decoded.deinit(alloc);
+ var it = std.mem.splitSequence(u8, out, "\x1b\\");
+ while (it.next()) |osc| {
+ if (osc.len == 0) continue;
+ const payload_start = std.mem.indexOfScalar(u8, osc, ';').?;
+ const payload = osc[std.mem.indexOfScalarPos(u8, osc, payload_start + 1, ';').? + 1 ..];
+ const n = try std.base64.standard.Decoder.calcSizeForSlice(payload);
+ const start = decoded.items.len;
+ try decoded.resize(alloc, start + n);
+ try std.base64.standard.Decoder.decode(decoded.items[start..], payload);
+ }
+ try testing.expectEqualSlices(u8, &data, decoded.items);
+}
+
+test "encodeError: with and without description" {
+ const testing = std.testing;
+ var buf: [256]u8 = undefined;
+
+ {
+ var writer: std.Io.Writer = .fixed(&buf);
+ try encodeError(&writer, .drop, .{ .x = 2 }, 0, .ENOENT, "drop data request index out of bounds", .st);
+ try testing.expectEqualStrings(
+ "\x1b]72;t=R:x=2:m=0;ENOENT:drop data request index out of bounds\x1b\\",
+ writer.buffered(),
+ );
+ }
+ {
+ var writer: std.Io.Writer = .fixed(&buf);
+ try encodeError(&writer, .drag, .{}, 5, .EPERM, "", .st);
+ try testing.expectEqualStrings(
+ "\x1b]72;t=E:i=5:m=0;EPERM\x1b\\",
+ writer.buffered(),
+ );
+ }
+}
+
+test "RequestKeys: only non-zero keys written" {
+ const testing = std.testing;
+ var buf: [64]u8 = undefined;
+
+ {
+ const s = try std.fmt.bufPrint(&buf, "{f}", .{RequestKeys{}});
+ try testing.expectEqualStrings("", s);
+ }
+ {
+ const s = try std.fmt.bufPrint(&buf, "{f}", .{RequestKeys{ .x = 1, .y = 2, .Y = 3 }});
+ try testing.expectEqualStrings(":x=1:y=2:Y=3", s);
+ }
+ {
+ const s = try std.fmt.bufPrint(&buf, "{f}", .{RequestKeys{ .Y = 4 }});
+ try testing.expectEqualStrings(":Y=4", s);
+ }
+}