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

package/native/build-pty.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+# Build libcuelooppty: the flat forkpty(3) FFI shim in src/pty.zig. Pure libc, so
+# unlike build.sh this needs no Ghostty clone - just the pinned Zig toolchain.
+# Output lands in native/<os>-<arch>/libcuelooppty.{dylib,so}. Requires curl.
+set -eu
+
+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"
+
+arch="$(uname -m)"; os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+case "$os" in darwin) zig_os="macos"; dylib="libcuelooppty.dylib";; linux) zig_os="linux"; dylib="libcuelooppty.so";; *) echo "unsupported os $os" >&2; exit 1;; esac
+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 [ ! -f "$zig_archive" ]; then
+  echo "== fetching zig $ZIG_VERSION =="
+  curl -fsSL -o "$zig_archive" "https://ziglang.org/download/$ZIG_VERSION/$zig_archive"
+fi
+printf '%s  %s\n' "$zig_sha" "$zig_archive" | shasum -a 256 -c -
+
+build_root="$(mktemp -d "$work/native-pty-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"
+
+echo "== building pty shim -> $outdir/$dylib =="
+mkdir -p "$outdir"
+if [ "$os" = "darwin" ]; then
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" \
+    -install_name "@rpath/$dylib" "$here/src/pty.zig"
+else
+  "$zig" build-lib -dynamic -OReleaseFast -lc -femit-bin="$outdir/$dylib" "$here/src/pty.zig"
+fi
+echo "== done: $outdir/$dylib =="

package/native/src/pty.zig

@@ -0,0 +1,193 @@
+// Flat, FFI-trivial pseudo-terminal over libc forkpty(3). Exposes exactly what
+// the embedded Agent-tab terminal needs: spawn a child on a PTY, non-blocking
+// read of its output, write, resize, and reap. Handles are small ints into a
+// fixed table so bun:ffi only ever passes ints and byte pointers, never structs.
+//
+// Packed-argument contract (avoids shell parsing and per-token FFI marshalling):
+//   argv_packed: "arg0\0arg1\0...\0"  - NUL-separated, terminated by an empty
+//                                       token (a trailing extra NUL).
+//   env_packed:  "K=V\0K=V\0...\0"    - same shape; empty means inherit parent.
+//   cwd:         a plain C string, or empty to keep the parent's directory.
+
+const std = @import("std");
+const builtin = @import("builtin");
+
+const c = @cImport({
+    @cInclude("unistd.h");
+    @cInclude("fcntl.h");
+    @cInclude("errno.h");
+    @cInclude("signal.h");
+    @cInclude("stdlib.h");
+    @cInclude("string.h");
+    @cInclude("termios.h");
+    @cInclude("sys/ioctl.h");
+    @cInclude("sys/wait.h");
+    if (builtin.os.tag == .macos) @cInclude("util.h") else @cInclude("pty.h");
+});
+
+extern var environ: [*c][*c]u8;
+
+const MAX_SESSIONS = 64;
+const MAX_TOKENS = 1024;
+
+const PtySession = struct {
+    in_use: bool = false,
+    master_fd: c_int = -1,
+    pid: c.pid_t = 0,
+    reaped: bool = false,
+    exit_code: c_int = 0,
+};
+
+var sessions = [_]PtySession{.{}} ** MAX_SESSIONS;
+
+// Split a double-NUL-terminated packed buffer into a NULL-terminated array of
+// pointers into that same buffer. Returns the token count, or -1 on overflow.
+fn splitPacked(packed_buffer: [*c]u8, out: [][*c]u8) c_int {
+    var count: usize = 0;
+    var cursor: [*c]u8 = packed_buffer;
+    while (cursor[0] != 0) {
+        if (count >= out.len - 1) return -1;
+        out[count] = cursor;
+        count += 1;
+        cursor += c.strlen(cursor) + 1;
+    }
+    out[count] = null;
+    return @intCast(count);
+}
+
+// Reap the child once, recording its exit status. WNOHANG unless `block`.
+fn reapSession(session: *PtySession, block: bool) void {
+    if (session.reaped) return;
+    var status: c_int = 0;
+    const result = c.waitpid(session.pid, &status, if (block) 0 else c.WNOHANG);
+    if (result != session.pid) return;
+    session.reaped = true;
+    if (c.WIFEXITED(status)) {
+        session.exit_code = c.WEXITSTATUS(status);
+    } else if (c.WIFSIGNALED(status)) {
+        session.exit_code = 128 + c.WTERMSIG(status);
+    } else {
+        session.exit_code = -1;
+    }
+}
+
+fn sessionOf(handle: c_int) ?*PtySession {
+    if (handle < 0 or handle >= MAX_SESSIONS) return null;
+    const session = &sessions[@intCast(handle)];
+    if (!session.in_use) return null;
+    return session;
+}
+
+// Spawn `argv_packed` on a fresh PTY sized cols x rows, in cwd, with env_packed
+// (or the parent's env when empty). Returns a session handle, or -1 on failure.
+export fn cueloop_pty_spawn(argv_packed: [*c]u8, cwd: [*c]const u8, env_packed: [*c]u8, cols: c_int, rows: c_int) c_int {
+    var handle: c_int = -1;
+    for (0..MAX_SESSIONS) |index| {
+        if (!sessions[index].in_use) {
+            handle = @intCast(index);
+            break;
+        }
+    }
+    if (handle < 0) return -1;
+
+    var argv: [MAX_TOKENS][*c]u8 = undefined;
+    if (splitPacked(argv_packed, &argv) < 1) return -1;
+
+    var envp: [MAX_TOKENS][*c]u8 = undefined;
+    const have_env = env_packed != null and env_packed[0] != 0;
+    if (have_env and splitPacked(env_packed, &envp) < 0) return -1;
+
+    var winsize = std.mem.zeroes(c.struct_winsize);
+    winsize.ws_col = @intCast(cols);
+    winsize.ws_row = @intCast(rows);
+
+    var master_fd: c_int = -1;
+    const pid = c.forkpty(&master_fd, null, null, &winsize);
+    if (pid < 0) return -1;
+
+    if (pid == 0) {
+        // Child: adopt cwd/env then exec; _exit on any failure so a broken child never runs JS.
+        if (cwd != null and cwd[0] != 0) {
+            if (c.chdir(cwd) != 0) c._exit(127);
+        }
+        if (have_env) environ = &envp;
+        _ = c.execvp(argv[0], &argv);
+        c._exit(127);
+    }
+
+    // Parent: non-blocking master so reads can poll without stalling the loop.
+    const flags = c.fcntl(master_fd, c.F_GETFL, @as(c_int, 0));
+    _ = c.fcntl(master_fd, c.F_SETFL, flags | c.O_NONBLOCK);
+
+    sessions[@intCast(handle)] = .{
+        .in_use = true,
+        .master_fd = master_fd,
+        .pid = pid,
+        .reaped = false,
+        .exit_code = 0,
+    };
+    return handle;
+}
+
+export fn cueloop_pty_write(handle: c_int, data: [*c]const u8, len: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    const written = c.write(session.master_fd, data, @intCast(len));
+    return @intCast(written);
+}
+
+// Non-blocking read of child output. Returns bytes read (>0), 0 when nothing is
+// available yet, -2 once the child has exited and its output is drained, or -1.
+export fn cueloop_pty_read(handle: c_int, buf: [*c]u8, len: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    const bytes_read = c.read(session.master_fd, buf, @intCast(len));
+    if (bytes_read > 0) return @intCast(bytes_read);
+    if (bytes_read == 0) {
+        reapSession(session, true);
+        return -2; // EOF: slave closed
+    }
+    const err = std.c._errno().*;
+    if (err == c.EAGAIN or err == c.EWOULDBLOCK) {
+        reapSession(session, false);
+        return if (session.reaped) -2 else 0; // exited with no more output vs still running
+    }
+    if (err == c.EIO) {
+        reapSession(session, true);
+        return -2; // Linux: slave gone
+    }
+    return -1;
+}
+
+export fn cueloop_pty_resize(handle: c_int, cols: c_int, rows: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    var winsize = std.mem.zeroes(c.struct_winsize);
+    winsize.ws_col = @intCast(cols);
+    winsize.ws_row = @intCast(rows);
+    return c.ioctl(session.master_fd, c.TIOCSWINSZ, &winsize);
+}
+
+export fn cueloop_pty_kill(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    return c.kill(session.pid, c.SIGTERM);
+}
+
+export fn cueloop_pty_get_pid(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    return @intCast(session.pid);
+}
+
+export fn cueloop_pty_get_exit_code(handle: c_int) c_int {
+    const session = sessionOf(handle) orelse return -1;
+    reapSession(session, true);
+    return session.exit_code;
+}
+
+export fn cueloop_pty_close(handle: c_int) void {
+    const session = sessionOf(handle) orelse return;
+    // Close the master first (hangs up the child), then block to reap it: after the
+    // SIGTERM from kill() plus this SIGHUP a well-behaved child exits at once, so the
+    // wait returns promptly and never leaves a zombie.
+    if (session.master_fd >= 0) _ = c.close(session.master_fd);
+    reapSession(session, true);
+    session.in_use = false;
+    session.master_fd = -1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.42",
+  "version": "0.1.0-alpha.44",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -26,16 +26,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@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",
+    "@cueloop/daemon": "0.1.0-alpha.44",
+    "@cueloop/extension-api": "0.1.0-alpha.44",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.44",
+    "@cueloop/schema": "0.1.0-alpha.44",
     "@opentui/core": "^0.5.2",
     "@opentui/keymap": "0.5.2",
     "@opentui/react": "^0.5.2",
     "@opentui/ssh": "0.5.2",
     "@pierre/diffs": "^1.3.5",
-    "bun-pty": "^0.4.10",
     "diff": "^8",
     "react": "^19.2.0"
   },

package/src/App.plan-review.test.tsx

@@ -87,26 +87,20 @@ function backgroundsOf(setup: Setup, needle: string): string[] {
   return backgrounds;
 }
 
-/** Whether any border character (box-drawing) is painted in the given foreground hex. */
-function hasBorderColor(setup: Setup, hex: string): boolean {
-  for (const line of setup.captureSpans().lines) {
-    for (const span of line.spans) {
-      if (!/[╭╮╰╯│─┌┐└┘]/.test(span.text)) continue;
-      const [red, green, blue] = span.fg.toInts();
-      const rendered =
-        "#" + [red, green, blue].map((part) => part.toString(16).padStart(2, "0")).join("");
-      if (rendered === hex) return true;
-    }
-  }
-  return false;
-}
-
 /** Move the cursor to "The daemon persists sessions to disk atomically." */
 async function toContextParagraph(setup: Setup): Promise<void> {
   await press(setup, "j");
   await press(setup, "j");
 }
 
+/** Click the first on-screen occurrence of a string, by its char-frame position. */
+async function clickText(setup: Setup, needle: string): Promise<void> {
+  const lines = setup.captureCharFrame().split("\n");
+  const row = lines.findIndex((line) => line.includes(needle));
+  await setup.mockMouse.click(lines[row]!.indexOf(needle) + 1, row);
+  await setup.renderOnce();
+}
+
 describe("share button", () => {
   test("the owner's plan header shows the Share button next to Edit", async () => {
     // Arrange / Act
@@ -296,6 +290,45 @@ describe("inline compose keeps the anchor painted", () => {
     // runner, and the whole-suite publish lane has timed even 15s out; give the
     // heaviest frame-wait chain generous headroom so runner load cannot flake it.
   }, 60_000);
+
+  test("clicking the Cancel word-button closes the compose box", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "v");
+    await press(setup, "l");
+    await press(setup, "c");
+    await waitForText(setup, "Cancel");
+
+    // Act
+    await clickText(setup, "Cancel");
+
+    // Assert
+    await waitForTextGone(setup, 'comment on "');
+  });
+
+  test("clicking Cancel in a saved card's edit composer closes it", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await toContextParagraph(setup);
+    await press(setup, "v");
+    await press(setup, "l");
+    await press(setup, "c");
+    await waitForText(setup, "Cancel");
+    await type(setup, "note body");
+    await press(setup, "enter");
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    // select the saved card, then activate it to open the in-place editor
+    await clickText(setup, "note body");
+    await clickText(setup, "note body");
+    await waitForText(setup, "Cancel");
+
+    // Act
+    await clickText(setup, "Cancel");
+
+    // Assert - the editor closes back to the plain saved card
+    await waitForTextGone(setup, "Cancel");
+  });
 });
 
 describe("compose newline convention", () => {
@@ -525,7 +558,7 @@ describe("sheet header", () => {
     expect(frame).toContain("Share");
   });
 
-  test("the Agent tab shows the harness launcher and a compact status footer", async () => {
+  test("the Agent tab shows the text-only harness launcher buttons", async () => {
     // Arrange
     const setup = await renderApp();
     const lines = setup.captureCharFrame().split("\n");
@@ -536,12 +569,11 @@ describe("sheet header", () => {
     await setup.mockMouse.click(tabColumn + 1, tabRow);
     await setup.renderOnce();
 
-    // Assert - branded launcher cards, and the submitter kept in the footer
-    await waitForText(setup, "claude code");
+    // Assert - the three launcher buttons, in order
+    await waitForText(setup, "Claude Code");
     const frame = setup.captureCharFrame();
-    expect(frame).toContain("Ask an agent about this plan");
-    expect(frame).toContain("codex");
-    expect(frame).toContain("agent/worker-3");
+    expect(frame).toContain("Pi");
+    expect(frame).toContain("OpenAI Codex");
   });
 });
 
@@ -549,18 +581,12 @@ describe("quick-actions settings editor", () => {
   test("expanding an action edits its system prompt inline and persists it", async () => {
     // Arrange
     const setup = await renderApp();
-    const clickText = async (needle: string): Promise<void> => {
-      const lines = setup.captureCharFrame().split("\n");
-      const row = lines.findIndex((line) => line.includes(needle));
-      await setup.mockMouse.click(lines[row]!.indexOf(needle) + 1, row);
-      await setup.renderOnce();
-    };
 
     // Act - open Settings, enter Actions, expand the first action, type into its input
-    await clickText("menu");
-    await clickText("Settings");
-    await clickText("Actions");
-    await clickText("Zoom out, research in depth");
+    await clickText(setup, "menu");
+    await clickText(setup, "Settings");
+    await clickText(setup, "Actions");
+    await clickText(setup, "Zoom out, research in depth");
     await type(setup, "CUSTOM");
     await setup.renderOnce();
 
@@ -589,9 +615,9 @@ describe("edit-exit reconciliation", () => {
 
       // Act
       // deselect the card so e reaches the editor hand-off, then edit; deselection
-      // shows as the card's accent border fading to a dim border (transparent fill)
+      // shows as the card's selected fill (elevated) clearing to a transparent card
       await press(setup, "escape");
-      await waitForState(setup, () => !hasBorderColor(setup, DARK.accent));
+      await waitForState(setup, () => !backgroundsOf(setup, "Anchor me").includes(DARK.elevated));
       await press(setup, "e");
 
       // Assert

package/src/components/AnnotationCard.stories.tsx

@@ -29,6 +29,7 @@ export const SavedSelected: Story = {
         isOrphan: false,
         isBlocking: false,
         author: "me",
+        tone: DARK.accent,
         editing: null,
         onPress: () => {},
       }}
@@ -48,12 +49,13 @@ export const SavedCollaborator: Story = {
         isOrphan: false,
         isBlocking: false,
         author: "Priya",
+        tone: DARK.blue,
         editing: null,
         onPress: () => {},
       }}
     />
   ),
-  expectedColors: [DARK.border],
+  expectedColors: [DARK.blue],
 };
 
 export const SavedOrphanBlocking: Story = {
@@ -67,12 +69,13 @@ export const SavedOrphanBlocking: Story = {
         isOrphan: true,
         isBlocking: true,
         author: "me",
+        tone: DARK.accent,
         editing: null,
         onPress: () => {},
       }}
     />
   ),
-  expectedColors: [DARK.border],
+  expectedColors: [DARK.accent],
 };
 
 export const SavedEditing: Story = {
@@ -86,6 +89,7 @@ export const SavedEditing: Story = {
         isOrphan: false,
         isBlocking: false,
         author: "me",
+        tone: DARK.accent,
         editing: { text: "new body", ...draftCallbacks },
         onPress: () => {},
       }}

package/src/components/AnnotationCard.tsx

@@ -34,6 +34,8 @@ export interface AnnotationSaved {
   isBlocking: boolean;
   /** Border-title author: a collaborator's display name, or "me" for the reviewer's own note. */
   author: string;
+  /** Border + title color for this card (own = salmon, collaborator = blue). */
+  tone: string;
   /** Non-null while the card body is being rewritten in place. */
   editing: AnnotationDraft | null;
   onPress: () => void;
@@ -202,9 +204,11 @@ export function AnnotationCard({
         height: cardHeight(contentRows),
         border: true,
         borderStyle: FRAME_BORDER_STYLE,
-        // cards stay transparent in every theme; selection is the bright
-        // kind-colored border, while unselected cards recede to a dim border
-        borderColor: card.isSelected || card.editing ? kindColor : tokens.border,
+        // the border (and its title) always wears the card's tone - salmon for
+        // own notes, blue for a collaborator's; selection reads from a filled
+        // background so the color stays put whether or not the card is active
+        borderColor: card.tone,
+        backgroundColor: card.isSelected || card.editing ? tokens.elevated : "transparent",
         paddingLeft: 1,
         paddingRight: 1,
       }}

package/src/components/ConfirmCard.tsx

@@ -103,7 +103,7 @@ export function ConfirmCard({
     <Card
       title=" submit review "
       contentRows={CONFIRM_CONTENT_ROWS + (viewedSummary !== undefined ? 1 : 0)}
-      borderColor={tokens.accent}
+      borderColor={tokens.text}
       backgroundColor="transparent"
       marginRight={1}
       theme={theme}

package/src/components/ReviewRail.tsx

@@ -140,6 +140,8 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
           : isAgentNote(annotation)
             ? "agent"
             : "me",
+        // own + agent notes read as salmon; a share collaborator's note as blue
+        tone: annotation.author && !isAgentNote(annotation) ? tokens.blue : tokens.accent,
         editing:
           cardEdit && cardEdit.id === annotation.id
             ? {
@@ -187,7 +189,6 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
         width,
         backgroundColor: tokens.panel,
         flexDirection: "column",
-        paddingLeft: 1,
         paddingBottom: 1,
       }}
     >
@@ -202,8 +203,7 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
         </TabList>
       </Tabs>
       {railTab === "agent" ? (
-        <box style={{ flexGrow: 1, flexDirection: "column", paddingLeft: 2 }}>
-          <text> </text>
+        <box style={{ flexGrow: 1, flexDirection: "column" }}>
           <AgentLauncher
             session={session}
             onLaunchHarness={onLaunchHarness}
@@ -295,8 +295,8 @@ function RemovalCard({
       <Card
         title={title}
         contentRows={contentRows}
-        borderColor={isSelected ? tokens.red : tokens.border}
-        backgroundColor="transparent"
+        borderColor={tokens.red}
+        backgroundColor={isSelected ? tokens.elevated : "transparent"}
         theme={theme}
       >
         {previewLines.length === 0 ? (