gitspace 0.2.0-rc.1

package/src/lib/tmux-lite/shell-integration.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# tmux-lite shell integration
+# Source this file in your .bashrc or .zshrc to enable inbox notifications
+#
+# Usage: source /path/to/shell-integration.sh
+#
+# This sends exit codes to tmux-lite server after each command,
+# which creates inbox notifications for non-zero exits.
+
+# Only run if inside tmux-lite session
+if [[ -z "$TMUX_LITE" ]]; then
+  return 0 2>/dev/null || exit 0
+fi
+
+# Send OSC 777 with exit code
+__tmux_lite_report_exit() {
+  local exit_code=$?
+  # Only report non-zero exits (failures)
+  if [[ $exit_code -ne 0 ]]; then
+    printf '\033]777;exit:%d\007' "$exit_code"
+  fi
+  return $exit_code
+}
+
+# Detect shell and install hook
+if [[ -n "$ZSH_VERSION" ]]; then
+  # Zsh: use precmd hook
+  autoload -Uz add-zsh-hook
+  add-zsh-hook precmd __tmux_lite_report_exit
+elif [[ -n "$BASH_VERSION" ]]; then
+  # Bash: use PROMPT_COMMAND
+  if [[ -z "$__TMUX_LITE_PROMPT_INSTALLED" ]]; then
+    export __TMUX_LITE_PROMPT_INSTALLED=1
+    # Prepend to PROMPT_COMMAND to run before prompt
+    PROMPT_COMMAND="__tmux_lite_report_exit${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+  fi
+fi

package/src/lib/tmux-lite/terminal-queries.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import { Terminal as XTerminal } from "@xterm/headless";
+import { installDsrCprResponder } from "./terminal-queries";
+
+function writeAsync(term: XTerminal, data: string): Promise<void> {
+  return new Promise((resolve) => term.write(data, resolve));
+}
+
+describe("tmux-lite terminal queries", () => {
+  test("responds to DSR (CSI 6 n) with CPR using current cursor position", async () => {
+    const xterm = new XTerminal({ cols: 80, rows: 24, allowProposedApi: true });
+
+    const writes: Buffer[] = [];
+    const dispose = installDsrCprResponder(xterm, (data) => {
+      writes.push(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    });
+
+    try {
+      // Move cursor by writing text
+      await writeAsync(xterm, "abc");
+
+      // DSR query: request cursor position
+      await writeAsync(xterm, "\x1b[6n");
+
+      expect(writes.length).toBe(1);
+      // cursorX=3 => col=4, cursorY=0 => row=1
+      expect(writes[0]?.toString("utf-8")).toBe("\x1b[1;4R");
+    } finally {
+      dispose();
+      xterm.dispose();
+    }
+  });
+
+  test("also responds to DEC private DSR prefix variant (CSI ? 6 n)", async () => {
+    const xterm = new XTerminal({ cols: 80, rows: 24, allowProposedApi: true });
+
+    const writes: string[] = [];
+    const dispose = installDsrCprResponder(xterm, (data) => {
+      writes.push((Buffer.isBuffer(data) ? data : Buffer.from(data)).toString("utf-8"));
+    });
+
+    try {
+      await writeAsync(xterm, "x");
+      await writeAsync(xterm, "\x1b[?6n");
+
+      expect(writes).toEqual(["\x1b[1;2R"]);
+    } finally {
+      dispose();
+      xterm.dispose();
+    }
+  });
+});
+
+

package/src/lib/tmux-lite/terminal-queries.ts

@@ -0,0 +1,49 @@
+import type { Terminal as XTerminal } from "@xterm/headless";
+
+export type PtyWriter = (data: string | Buffer) => void;
+
+/**
+ * Install a minimal DSR -> CPR responder.
+ *
+ * Some TUIs send a cursor position query (DSR: CSI 6 n / ESC[6n) and expect the
+ * terminal emulator to respond on stdin with a cursor position report
+ * (CPR: CSI {row};{col} R / ESC[{row};{col}R).
+ *
+ * In Spaces, our clients are mostly render-only, so we emulate the terminal-side
+ * response server-side using xterm-headless' cursor position.
+ */
+export function installDsrCprResponder(xterm: XTerminal, writeToPty: PtyWriter): () => void {
+  const disposables: Array<{ dispose: () => void }> = [];
+
+  const register = (id: { prefix?: string; final: string }) => {
+    const d = xterm.parser.registerCsiHandler(id as any, (params: any[]) => {
+      // CSI Ps n
+      const ps = Array.isArray(params?.[0]) ? params?.[0]?.[0] : params?.[0];
+      if (ps !== 6) return false;
+
+      // xterm cursorX/cursorY are 0-based; CPR is 1-based.
+      const row = xterm.buffer.active.cursorY + 1;
+      const col = xterm.buffer.active.cursorX + 1;
+      try {
+        writeToPty(Buffer.from(`\x1b[${row};${col}R`));
+      } catch {
+        // ignore
+      }
+      return true;
+    });
+    disposables.push(d as any);
+  };
+
+  // Plain DSR (CSI 6 n)
+  register({ final: "n" });
+  // Some implementations use DEC private prefix (CSI ? Ps n)
+  register({ prefix: "?", final: "n" });
+
+  return () => {
+    for (const d of disposables) {
+      try { d.dispose(); } catch {}
+    }
+  };
+}
+
+