@cueloop/client 0.1.0-alpha.41 → 0.1.0-alpha.42

package/native/build.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Rebuild libcueloopvt.dylib: libghostty-vt (Ghostty's VT core) statically linked
-# behind the flat FFI shim in src/shim.c. Pinned to a Ghostty commit + Zig 0.16.0.
-# Output lands in native/<os>-<arch>/libcueloopvt.dylib. Requires curl, git, clang.
+# behind the flat FFI shim. Pinned to a Ghostty commit + Zig 0.16.0.
+# Output lands in native/<os>-<arch>/libcueloopvt.dylib. Requires curl and git.
 set -eu
 
 GHOSTTY_COMMIT="5834a0e3df621802e9578e4562d88b0c2ad4ada8"
@@ -10,47 +10,73 @@ ZIG_VERSION="0.16.0"
 here="$(cd "$(dirname "$0")" && pwd)"
 work="${TMPDIR:-/tmp}/cueloop-libghostty-build"
 mkdir -p "$work"
+export ZIG_GLOBAL_CACHE_DIR="$work/zig-gcache"
+export ZIG_LOCAL_CACHE_DIR="$work/zig-lcache"
 cd "$work"
 
-# host triple for the prebuilt dir + zig download
+# Host triple for the Bun prebuilt dir and Zig download. The two tools use
+# different architecture names.
 arch="$(uname -m)"; os="$(uname -s | tr '[:upper:]' '[:lower:]')"
 case "$os" in darwin) zig_os="macos"; dylib="libcueloopvt.dylib";; linux) zig_os="linux"; dylib="libcueloopvt.so";; *) echo "unsupported os $os" >&2; exit 1;; esac
-outdir="$here/${os}-${arch}"
+case "$arch-$os" in
+  arm64-darwin|aarch64-linux) zig_arch="aarch64"; bun_arch="arm64";;
+  x86_64-darwin|x86_64-linux) zig_arch="x86_64"; bun_arch="x64";;
+  *) echo "unsupported architecture $arch on $os" >&2; exit 1;;
+esac
+case "$zig_arch-$zig_os" in
+  aarch64-macos) zig_sha="b23d70deaa879b5c2d486ed3316f7eaa53e84acf6fc9cc747de152450d401489";;
+  x86_64-macos) zig_sha="0387557ed1877bc6a2e1802c8391953baddba76081876301c522f52977b52ba7";;
+  aarch64-linux) zig_sha="ea4b09bfb22ec6f6c6ceac57ab63efb6b46e17ab08d21f69f3a48b38e1534f17";;
+  x86_64-linux) zig_sha="70e49664a74374b48b51e6f3fdfbf437f6395d42509050588bd49abe52ba3d00";;
+esac
+outdir="$here/${os}-${bun_arch}"
+zig_archive="zig-$zig_arch-$zig_os-$ZIG_VERSION.tar.xz"
 
-if [ ! -x "zig-$arch-$zig_os-$ZIG_VERSION/zig" ]; then
+if [ ! -f "$zig_archive" ]; then
   echo "== fetching zig $ZIG_VERSION =="
-  curl -sSL -o zig.tar.xz "https://ziglang.org/download/$ZIG_VERSION/zig-$arch-$zig_os-$ZIG_VERSION.tar.xz"
-  tar -xf zig.tar.xz
+  curl -fsSL -o "$zig_archive" "https://ziglang.org/download/$ZIG_VERSION/$zig_archive"
 fi
-zig="$work/zig-$arch-$zig_os-$ZIG_VERSION/zig"
+printf '%s  %s\n' "$zig_sha" "$zig_archive" | shasum -a 256 -c -
 
 if [ ! -d ghostty ]; then
   echo "== cloning ghostty @ $GHOSTTY_COMMIT =="
   mkdir ghostty && cd ghostty && git init -q
   git remote add origin https://github.com/ghostty-org/ghostty.git
-  git fetch -q --depth 1 origin "$GHOSTTY_COMMIT"
-  git checkout -q FETCH_HEAD
   cd ..
 fi
+if ! git -C ghostty cat-file -e "$GHOSTTY_COMMIT^{commit}" 2>/dev/null; then
+  git -C ghostty fetch -q --depth 1 origin "$GHOSTTY_COMMIT"
+fi
+
+# Build only from fresh trees materialized from the verified archive and exact
+# Git object. Cached working-tree edits and stale install outputs cannot enter.
+build_root="$(mktemp -d "$work/native-build.XXXXXX")"
+trap 'rm -rf "$build_root"' EXIT HUP INT TERM
+tar -xf "$zig_archive" -C "$build_root"
+zig="$build_root/zig-$zig_arch-$zig_os-$ZIG_VERSION/zig"
+ghostty_source="$build_root/ghostty"
+mkdir "$ghostty_source"
+git -C ghostty archive "$GHOSTTY_COMMIT" | tar -x -C "$ghostty_source"
 
 echo "== building libghostty-vt (ReleaseFast) =="
-cd ghostty
+cd "$ghostty_source"
 # The final xcframework packaging step can fail while the .a we need is produced,
 # so tolerate a non-zero exit here but assert the static lib exists below.
-ZIG_GLOBAL_CACHE_DIR="$work/zig-gcache" ZIG_LOCAL_CACHE_DIR="$work/zig-lcache" \
-  "$zig" build -Demit-lib-vt -Doptimize=ReleaseFast --prefix "$work/vt-install" || true
+vt_install="$build_root/vt-install"
+"$zig" build -Demit-lib-vt -Doptimize=ReleaseFast --prefix "$vt_install" || true
 cd ..
-staticlib="$work/vt-install/lib/libghostty-vt.a"
+staticlib="$vt_install/lib/libghostty-vt.a"
 [ -f "$staticlib" ] || { echo "build failed: $staticlib not produced" >&2; exit 1; }
 
 echo "== linking shim -> $outdir/$dylib =="
 mkdir -p "$outdir"
 if [ "$os" = "darwin" ]; then
-  clang -O2 -dynamiclib -o "$outdir/$dylib" "$here/src/shim.c" \
-    -I"$work/vt-install/include" "$staticlib" \
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -install_name "@rpath/$dylib" \
+    -I"$vt_install/include" "$here/src/shim.zig" "$staticlib" \
     -framework CoreFoundation -framework CoreText -framework CoreGraphics
 else
-  clang -O2 -shared -fPIC -o "$outdir/$dylib" "$here/src/shim.c" \
-    -I"$work/vt-install/include" "$staticlib" -lm -lpthread
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -I"$vt_install/include" "$here/src/shim.zig" "$staticlib" -lm -lpthread
 fi
 echo "== done: $outdir/$dylib =="

package/native/src/shim.zig

@@ -0,0 +1,114 @@
+// Flat FFI wrapper over libghostty-vt. It hides the allocator vtable, the
+// by-value GhosttyPoint that bun:ffi cannot pass, and packed-cell decoding.
+const std = @import("std");
+const ghostty = @cImport({
+    @cInclude("ghostty/vt/types.h");
+    @cInclude("ghostty/vt/allocator.h");
+    @cInclude("ghostty/vt/terminal.h");
+    @cInclude("ghostty/vt/point.h");
+    @cInclude("ghostty/vt/grid_ref.h");
+    @cInclude("ghostty/vt/screen.h");
+    @cInclude("ghostty/vt/style.h");
+    @cInclude("ghostty/vt/color.h");
+});
+
+const CvtCell = extern struct {
+    codepoint: u32,
+    fg_r: u8,
+    fg_g: u8,
+    fg_b: u8,
+    fg_kind: u8,
+    bg_r: u8,
+    bg_g: u8,
+    bg_b: u8,
+    bg_kind: u8,
+    width: u8,
+    flags: u8,
+    _pad: u16,
+};
+
+comptime {
+    std.debug.assert(@sizeOf(CvtCell) == 16);
+}
+
+export fn cvt_new(cols: u16, rows: u16) ?*anyopaque {
+    var terminal: ghostty.GhosttyTerminal = null;
+    if (ghostty.ghostty_terminal_new(null, &terminal, cols, rows) != ghostty.GHOSTTY_SUCCESS) {
+        return null;
+    }
+    return terminal;
+}
+
+export fn cvt_free(terminal: ?*anyopaque) void {
+    if (terminal) |handle| ghostty.ghostty_terminal_free(@ptrCast(handle));
+}
+
+export fn cvt_write(terminal: *anyopaque, data: [*]const u8, len: usize) void {
+    ghostty.ghostty_terminal_vt_write(@ptrCast(terminal), data, len);
+}
+
+export fn cvt_resize(terminal: *anyopaque, cols: u16, rows: u16) void {
+    // Cell pixel size does not affect the character grid.
+    _ = ghostty.ghostty_terminal_resize(@ptrCast(terminal), cols, rows, 1, 1);
+}
+
+// Writes [col u16 LE, row u16 LE, visible u8] into the caller's eight bytes.
+export fn cvt_cursor(terminal: *anyopaque, out: [*]u8) void {
+    var x: u16 = 0;
+    var y: u16 = 0;
+    var visible = false;
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_X, &x);
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_Y, &y);
+    _ = ghostty.ghostty_terminal_get(@ptrCast(terminal), ghostty.GHOSTTY_TERMINAL_DATA_CURSOR_VISIBLE, &visible);
+    out[0] = @truncate(x);
+    out[1] = @truncate(x >> 8);
+    out[2] = @truncate(y);
+    out[3] = @truncate(y >> 8);
+    out[4] = @intFromBool(visible);
+}
+
+fn decodeColor(color: *const ghostty.GhosttyStyleColor, red: *u8, green: *u8, blue: *u8, kind: *u8) void {
+    if (color.tag == ghostty.GHOSTTY_STYLE_COLOR_RGB) {
+        kind.* = 2;
+        red.* = color.value.rgb.r;
+        green.* = color.value.rgb.g;
+        blue.* = color.value.rgb.b;
+    } else if (color.tag == ghostty.GHOSTTY_STYLE_COLOR_PALETTE) {
+        kind.* = 1;
+        red.* = @intCast(color.value.palette);
+    }
+}
+
+export fn cvt_cell(terminal: *anyopaque, x: u16, y: u32, out: *CvtCell) c_int {
+    out.* = std.mem.zeroes(CvtCell);
+
+    var point: ghostty.GhosttyPoint = undefined;
+    point.tag = ghostty.GHOSTTY_POINT_TAG_VIEWPORT;
+    point.value.coordinate.x = x;
+    point.value.coordinate.y = y;
+
+    var reference: ghostty.GhosttyGridRef = undefined;
+    if (ghostty.ghostty_terminal_grid_ref(@ptrCast(terminal), point, &reference) != ghostty.GHOSTTY_SUCCESS) return -1;
+
+    var cell: ghostty.GhosttyCell = undefined;
+    if (ghostty.ghostty_grid_ref_cell(&reference, &cell) != ghostty.GHOSTTY_SUCCESS) return -1;
+
+    _ = ghostty.ghostty_cell_get(cell, ghostty.GHOSTTY_CELL_DATA_CODEPOINT, &out.codepoint);
+    var width: u32 = 0;
+    _ = ghostty.ghostty_cell_get(cell, ghostty.GHOSTTY_CELL_DATA_WIDE, &width);
+    out.width = @intCast(width);
+
+    var style: ghostty.GhosttyStyle = undefined;
+    ghostty.ghostty_style_default(&style);
+    if (ghostty.ghostty_grid_ref_style(&reference, &style) == ghostty.GHOSTTY_SUCCESS) {
+        decodeColor(&style.fg_color, &out.fg_r, &out.fg_g, &out.fg_b, &out.fg_kind);
+        decodeColor(&style.bg_color, &out.bg_r, &out.bg_g, &out.bg_b, &out.bg_kind);
+        if (style.bold) out.flags |= 1;
+        if (style.italic) out.flags |= 2;
+        if (style.underline != 0) out.flags |= 4;
+        if (style.inverse) out.flags |= 8;
+        if (style.faint) out.flags |= 16;
+        if (style.strikethrough) out.flags |= 32;
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.41",
+  "version": "0.1.0-alpha.42",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -26,10 +26,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.41",
-    "@cueloop/extension-api": "0.1.0-alpha.41",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.41",
-    "@cueloop/schema": "0.1.0-alpha.41",
+    "@cueloop/daemon": "0.1.0-alpha.42",
+    "@cueloop/extension-api": "0.1.0-alpha.42",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.42",
+    "@cueloop/schema": "0.1.0-alpha.42",
     "@opentui/core": "^0.5.2",
     "@opentui/keymap": "0.5.2",
     "@opentui/react": "^0.5.2",

package/src/components/terminal-pane.ts

@@ -120,7 +120,7 @@ export class TerminalPaneRenderable extends Renderable {
     for (let y = 0; y < this.height; y++) {
       for (let x = 0; x < this.width; x++) {
         const cell = this.vt.readCell(x, y);
-        // width 0 = the trailing half of a wide glyph already painted at x-1: skip it.
+        // Skip an empty normal-width cell; the buffer already starts blank.
         if (cell && cell.width === 0 && cell.codepoint === 0) continue;
         const char = cell && cell.codepoint ? String.fromCodePoint(cell.codepoint) : " ";
         let fg = cell ? resolveColor(cell.fg, DEFAULT_FG) : DEFAULT_FG;

package/src/ghostty-terminal.test.ts

@@ -42,4 +42,41 @@ describe("ghostty-terminal FFI", () => {
     expect(cursor.x).toBe(3);
     term.free();
   });
+
+  test.skipIf(!factory)(
+    "preserves the native screen contract across resize and styled text",
+    () => {
+      // Arrange
+      const term = factory!.create(8, 2)!;
+
+      // Act - resize first, then write RGB colors, every supported style, and a wide glyph
+      term.resize(6, 3);
+      term.write(
+        new TextEncoder().encode(
+          "\x1b[38;2;12;34;56;48;2;78;90;123;1;3;4;7;9mA\x1b[0m\x1b[2mF\x1b[0m\u754c",
+        ),
+      );
+
+      // Assert - the flat native ABI retains cell data and rejects coordinates outside the viewport
+      expect(term.readCell(0, 0)).toEqual({
+        codepoint: 0x41,
+        fg: { kind: "rgb", r: 12, g: 34, b: 56 },
+        bg: { kind: "rgb", r: 78, g: 90, b: 123 },
+        width: 0,
+        bold: true,
+        italic: true,
+        underline: true,
+        inverse: true,
+        faint: false,
+        strikethrough: true,
+      });
+      expect(term.readCell(1, 0)?.faint).toBe(true);
+      expect(term.readCell(2, 0)?.codepoint).toBe("\u754c".codePointAt(0));
+      expect(term.readCell(2, 0)?.width).toBe(1);
+      expect(term.readCell(3, 0)?.width).toBe(2);
+      expect(term.readCell(6, 0)).toBeNull();
+      expect(term.readCell(0, 3)).toBeNull();
+      term.free();
+    },
+  );
 });

package/src/ghostty-terminal.ts

@@ -1,6 +1,6 @@
 /**
  * A live in-process terminal emulator backed by Ghostty's VT core (libghostty-vt)
- * through a flat FFI shim (native/src/shim.c). Feed it a child process's PTY
+ * through a flat FFI shim (native/src/shim.zig). Feed it a child process's PTY
  * output with `write`, then read the rendered screen cell-by-cell with `readCell`
  * to paint it anywhere - this is what lets a real `cc`/shell render inside an
  * OpenTUI box. Load with `loadGhosttyTerminals`, which returns null when no
@@ -30,7 +30,7 @@ export interface GhosttyCell {
   codepoint: number;
   fg: GhosttyColor;
   bg: GhosttyColor;
-  /** 0 = wide-char trailing cell (skip it), 1 = normal, 2 = double-width lead. */
+  /** Ghostty width tag: 0 = normal, 1 = double-width lead, 2 = trailing cell. */
   width: number;
   bold: boolean;
   italic: boolean;

package/native/src/shim.c

@@ -1,107 +0,0 @@
-// Flat, FFI-trivial wrapper over libghostty-vt: hides the allocator vtable, the
-// by-value GhosttyPoint (which bun:ffi cannot pass), and the packed-cell decode,
-// exposing exactly what an OpenTUI paint loop needs - new/write/resize/cell/free.
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <string.h>
-#include "ghostty/vt/types.h"
-#include "ghostty/vt/allocator.h"
-#include "ghostty/vt/terminal.h"
-#include "ghostty/vt/point.h"
-#include "ghostty/vt/grid_ref.h"
-#include "ghostty/vt/screen.h"
-#include "ghostty/vt/style.h"
-#include "ghostty/vt/color.h"
-
-typedef struct {
-  uint32_t codepoint;    // 0 = blank
-  uint8_t fg_r, fg_g, fg_b, fg_kind;  // kind: 0 default, 1 palette (index in fg_r), 2 rgb
-  uint8_t bg_r, bg_g, bg_b, bg_kind;
-  uint8_t width;         // 0 (wide trailing), 1, 2
-  uint8_t flags;         // bit0 bold, 1 italic, 2 underline, 3 inverse, 4 faint, 5 strikethrough
-  uint16_t _pad;
-} CvtCell;
-
-void *cvt_new(uint16_t cols, uint16_t rows) {
-  GhosttyTerminal t = NULL;
-  // NULL allocator selects libghostty's default (libc malloc/free when linked).
-  if (ghostty_terminal_new(NULL, &t, cols, rows) != GHOSTTY_SUCCESS) return NULL;
-  return (void *)t;
-}
-
-void cvt_free(void *t) {
-  if (t) ghostty_terminal_free((GhosttyTerminal)t);
-}
-
-void cvt_write(void *t, const uint8_t *data, size_t len) {
-  ghostty_terminal_vt_write((GhosttyTerminal)t, data, len);
-}
-
-void cvt_resize(void *t, uint16_t cols, uint16_t rows) {
-  // cell pixel size is irrelevant to the character grid; pass a nominal 1x1.
-  ghostty_terminal_resize((GhosttyTerminal)t, cols, rows, 1, 1);
-}
-
-// Writes cursor state into out8: [0..1] col (u16), [2..3] row (u16), [4] visible (u8).
-void cvt_cursor(void *t, uint8_t *out8) {
-  uint16_t cx = 0, cy = 0;
-  bool vis = false;
-  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_X, &cx);
-  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_Y, &cy);
-  ghostty_terminal_get((GhosttyTerminal)t, GHOSTTY_TERMINAL_DATA_CURSOR_VISIBLE, &vis);
-  memcpy(out8, &cx, 2);
-  memcpy(out8 + 2, &cy, 2);
-  out8[4] = vis ? 1 : 0;
-}
-
-static void decode_color(const GhosttyStyleColor *c, uint8_t *r, uint8_t *g, uint8_t *b,
-                         uint8_t *kind) {
-  if (c->tag == GHOSTTY_STYLE_COLOR_RGB) {
-    *kind = 2;
-    *r = c->value.rgb.r;
-    *g = c->value.rgb.g;
-    *b = c->value.rgb.b;
-  } else if (c->tag == GHOSTTY_STYLE_COLOR_PALETTE) {
-    *kind = 1;
-    *r = (uint8_t)c->value.palette;  // palette index in r; JS maps 0-255 -> RGB
-    *g = 0;
-    *b = 0;
-  } else {
-    *kind = 0;
-  }
-}
-
-// Reads the viewport cell at (x, y). Returns 0 on success, -1 otherwise.
-int cvt_cell(void *t, uint16_t x, uint32_t y, CvtCell *out) {
-  memset(out, 0, sizeof(*out));
-  GhosttyPoint p;
-  p.tag = GHOSTTY_POINT_TAG_VIEWPORT;
-  p.value.coordinate.x = x;
-  p.value.coordinate.y = y;
-  GhosttyGridRef ref;
-  if (ghostty_terminal_grid_ref((GhosttyTerminal)t, p, &ref) != GHOSTTY_SUCCESS) return -1;
-  GhosttyCell cell;
-  if (ghostty_grid_ref_cell(&ref, &cell) != GHOSTTY_SUCCESS) return -1;
-  uint32_t cp = 0;
-  ghostty_cell_get(cell, GHOSTTY_CELL_DATA_CODEPOINT, &cp);
-  out->codepoint = cp;
-  uint32_t wide = 0;
-  ghostty_cell_get(cell, GHOSTTY_CELL_DATA_WIDE, &wide);
-  out->width = (uint8_t)wide;
-  GhosttyStyle st;
-  ghostty_style_default(&st);
-  if (ghostty_grid_ref_style(&ref, &st) == GHOSTTY_SUCCESS) {
-    decode_color(&st.fg_color, &out->fg_r, &out->fg_g, &out->fg_b, &out->fg_kind);
-    decode_color(&st.bg_color, &out->bg_r, &out->bg_g, &out->bg_b, &out->bg_kind);
-    uint8_t f = 0;
-    if (st.bold) f |= 1;
-    if (st.italic) f |= 2;
-    if (st.underline) f |= 4;
-    if (st.inverse) f |= 8;
-    if (st.faint) f |= 16;
-    if (st.strikethrough) f |= 32;
-    out->flags = f;
-  }
-  return 0;
-}