From c10fe736fd9b102dc9bd35fd87de2140f3724c7a Mon Sep 17 00:00:00 2001
From: "nekomimi.pet" <meowskulls@nekomimi.pet>
Date: Thu, 24 Sep 2026 21:43:18 -0400
Subject: [PATCH] fix(cli): rebuild mouse reports that bubbletea splits across
 reads

Bubble Tea v1's reader parses input 256 bytes at a time. When a read ends
inside an SGR mouse report ("ESC[<64;19;5M"), the ESC [ is taken as an
Alt+[ key and the rest arrives as typed runes, so scrolling typed
"[<64;19;5M" into the prompt. Trackpad bursts fill the buffer easily.
v1.3.10 parses the same way.

A program filter turns the Alt+[ and "<b;x;yM" pair back into the mouse
event; a lone Alt+[ is dropped (unbound; Option+[ arrives as a character).
---
 cli/cmd/albedo/main.go                |   4 +-
 cli/internal/tui/mouse_repair.go      |  96 ++++++++++++++++++++++
 cli/internal/tui/mouse_repair_test.go | 111 ++++++++++++++++++++++++++
 3 files changed, 209 insertions(+), 2 deletions(-)
 create mode 100644 cli/internal/tui/mouse_repair.go
 create mode 100644 cli/internal/tui/mouse_repair_test.go

diff --git a/cli/cmd/albedo/main.go b/cli/cmd/albedo/main.go
index 3b4f742..b5c502c 100644
--- a/cli/cmd/albedo/main.go
+++ b/cli/cmd/albedo/main.go
@@ -224,7 +224,7 @@ func open(id, workspace string, fresh bool) error {
 		appModel.BrowserOpener = config.OpenBrowser
 		appModel.Login.BrowserOpener = config.OpenBrowser
 	}
-	p := tea.NewProgram(appModel, tea.WithFPS(120))
+	p := tea.NewProgram(appModel, tea.WithFPS(120), tea.WithFilter(tui.RepairSplitMouse()))
 	_, err = p.Run()
 	return err
 }
@@ -425,7 +425,7 @@ func run(args []string) error {
 				appModel.Login.BrowserOpener = config.OpenBrowser
 			}
 		}
-		p := tea.NewProgram(appModel, tea.WithFPS(120))
+		p := tea.NewProgram(appModel, tea.WithFPS(120), tea.WithFilter(tui.RepairSplitMouse()))
 		_, err = p.Run()
 		return err
 
diff --git a/cli/internal/tui/mouse_repair.go b/cli/internal/tui/mouse_repair.go
new file mode 100644
index 0000000..fc7a9ca
--- /dev/null
+++ b/cli/internal/tui/mouse_repair.go
@@ -0,0 +1,96 @@
+package tui
+
+import (
+	"regexp"
+	"strconv"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// sgrTail is what remains of an SGR mouse report once its "ESC [" was
+// consumed on its own: "<button;x;y" and M (press) or m (release).
+var sgrTail = regexp.MustCompile(`^<(\d+);(\d+);(\d+)([Mm])$`)
+
+// RepairSplitMouse is a program filter that rebuilds mouse reports Bubble
+// Tea v1 splits. Its reader parses 256-byte reads; when input backs up and a
+// read ends inside "ESC[<64;19;5M", the "ESC[" becomes an Alt+[ key and the
+// rest arrives as typed runes, so scrolling types "[<64;19;5M" into the input.
+// The pair is turned back into the mouse event. A lone Alt+[ is dropped: it
+// has no binding, and macOS Option+[ arrives as a character, not as Alt.
+func RepairSplitMouse() func(tea.Model, tea.Msg) tea.Msg {
+	held := false
+	return func(_ tea.Model, msg tea.Msg) tea.Msg {
+		key, isKey := msg.(tea.KeyMsg)
+		if isKey && key.Alt && key.Type == tea.KeyRunes && len(key.Runes) == 1 && key.Runes[0] == '[' {
+			held = true
+			return nil
+		}
+		if !held {
+			return msg
+		}
+		held = false
+		if isKey && key.Type == tea.KeyRunes && !key.Alt {
+			if mouse, ok := parseSGRTail(string(key.Runes)); ok {
+				return mouse
+			}
+		}
+		return msg
+	}
+}
+
+// parseSGRTail decodes "<b;x;y" + M/m as Bubble Tea's SGR parser does.
+func parseSGRTail(s string) (tea.MouseMsg, bool) {
+	m := sgrTail.FindStringSubmatch(s)
+	if m == nil {
+		return tea.MouseMsg{}, false
+	}
+	b, err1 := strconv.Atoi(m[1])
+	x, err2 := strconv.Atoi(m[2])
+	y, err3 := strconv.Atoi(m[3])
+	if err1 != nil || err2 != nil || err3 != nil {
+		return tea.MouseMsg{}, false
+	}
+	const (
+		bitShift  = 0b0000_0100
+		bitAlt    = 0b0000_1000
+		bitCtrl   = 0b0001_0000
+		bitMotion = 0b0010_0000
+		bitWheel  = 0b0100_0000
+		bitAdd    = 0b1000_0000
+		bitsMask  = 0b0000_0011
+	)
+	var e tea.MouseEvent
+	switch {
+	case b&bitAdd != 0:
+		e.Button = tea.MouseButtonBackward + tea.MouseButton(b&bitsMask)
+	case b&bitWheel != 0:
+		e.Button = tea.MouseButtonWheelUp + tea.MouseButton(b&bitsMask)
+	default:
+		e.Button = tea.MouseButtonLeft + tea.MouseButton(b&bitsMask)
+		if b&bitsMask == bitsMask {
+			e.Action = tea.MouseActionRelease
+			e.Button = tea.MouseButtonNone
+		}
+	}
+	if b&bitMotion != 0 && !e.IsWheel() {
+		e.Action = tea.MouseActionMotion
+	}
+	if m[4] == "m" && e.Action != tea.MouseActionMotion && !e.IsWheel() {
+		e.Action = tea.MouseActionRelease
+	}
+	e.Alt, e.Ctrl, e.Shift = b&bitAlt != 0, b&bitCtrl != 0, b&bitShift != 0
+	e.X, e.Y = x-1, y-1
+	switch {
+	case e.Button == tea.MouseButtonWheelUp:
+		e.Type = tea.MouseWheelUp
+	case e.Button == tea.MouseButtonWheelDown:
+		e.Type = tea.MouseWheelDown
+	case e.Action == tea.MouseActionRelease:
+		e.Type = tea.MouseRelease
+	case e.Action == tea.MouseActionMotion:
+		e.Type = tea.MouseMotion
+	case e.Button == tea.MouseButtonLeft:
+		e.Type = tea.MouseLeft
+	}
+	return tea.MouseMsg(e), true
+}
diff --git a/cli/internal/tui/mouse_repair_test.go b/cli/internal/tui/mouse_repair_test.go
new file mode 100644
index 0000000..550a7f7
--- /dev/null
+++ b/cli/internal/tui/mouse_repair_test.go
@@ -0,0 +1,111 @@
+package tui
+
+import (
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestSplitMouseReportsBecomeMouseEvents(t *testing.T) {
+	filter := RepairSplitMouse()
+	altBracket := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'['}, Alt: true}
+	tail := func(s string) tea.KeyMsg { return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)} }
+
+	if filter(nil, altBracket) != nil {
+		t.Fatal("the split prefix reached the model")
+	}
+	got, ok := filter(nil, tail("<64;19;5M")).(tea.MouseMsg)
+	if !ok || got.Button != tea.MouseButtonWheelUp || got.X != 18 || got.Y != 4 {
+		t.Fatalf("wheel up not rebuilt: %#v", got)
+	}
+	filter(nil, altBracket)
+	if got, _ := filter(nil, tail("<65;1;1M")).(tea.MouseMsg); got.Button != tea.MouseButtonWheelDown {
+		t.Fatalf("wheel down not rebuilt: %#v", got)
+	}
+	filter(nil, altBracket)
+	if got, _ := filter(nil, tail("<0;10;3m")).(tea.MouseMsg); got.Action != tea.MouseActionRelease {
+		t.Fatalf("release not rebuilt: %#v", got)
+	}
+	// Ordinary typing is untouched, including the same text without the prefix.
+	for _, msg := range []tea.Msg{tail("<64;19;5M"), tail("hello"), tea.KeyMsg{Type: tea.KeyEnter}} {
+		if got := filter(nil, msg); got == nil {
+			t.Fatalf("%v was dropped", msg)
+		}
+		if _, isMouse := filter(nil, msg).(tea.MouseMsg); isMouse {
+			t.Fatalf("%v became a mouse event", msg)
+		}
+	}
+	filter(nil, altBracket)
+	if got := filter(nil, tail("hello")); got.(tea.KeyMsg).String() != "hello" {
+		t.Fatal("text after a lone alt+[ was changed")
+	}
+}
+
+// chunked returns its data in fixed-size reads, like a backed-up terminal.
+type chunked struct {
+	data []byte
+	size int
+}
+
+func (c *chunked) Read(p []byte) (int, error) {
+	if len(c.data) == 0 {
+		select {} // hold the program open until it quits
+	}
+	n := min(len(p), c.size, len(c.data))
+	copy(p, c.data[:n])
+	c.data = c.data[n:]
+	return n, nil
+}
+
+type recorder struct {
+	msgs []tea.Msg
+	want int
+}
+
+func (r *recorder) Init() tea.Cmd { return nil }
+func (r *recorder) View() string  { return "" }
+func (r *recorder) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg.(type) {
+	case tea.KeyMsg, tea.MouseMsg:
+		r.msgs = append(r.msgs, msg)
+		if len(r.msgs) >= r.want {
+			return r, tea.Quit
+		}
+	}
+	return r, nil
+}
+
+// Bubble Tea's own reader, fed full 256-byte reads that end inside a report.
+func TestBubbleTeaReaderSplitsAreRepaired(t *testing.T) {
+	var stream []byte
+	for i := 0; i < 60; i++ {
+		stream = append(stream, "\x1b[<64;19;5M"...)
+	}
+	run := func(filter bool) (mouse, keys int) {
+		model := &recorder{want: 60}
+		opts := []tea.ProgramOption{tea.WithInput(&chunked{data: stream, size: 256}), tea.WithoutRenderer(), tea.WithoutSignalHandler()}
+		if filter {
+			opts = append(opts, tea.WithFilter(RepairSplitMouse()))
+		} else {
+			model.want = 61 // each split adds a key
+		}
+		done := make(chan struct{})
+		go func() { _, _ = tea.NewProgram(model, opts...).Run(); close(done) }()
+		<-done
+		for _, msg := range model.msgs {
+			switch msg.(type) {
+			case tea.MouseMsg:
+				mouse++
+			case tea.KeyMsg:
+				keys++
+			}
+		}
+		return mouse, keys
+	}
+	if mouse, keys := run(false); keys == 0 {
+		t.Fatalf("expected the unfiltered reader to split a report (mouse %d)", mouse)
+	}
+	if mouse, keys := run(true); mouse != 60 || keys != 0 {
+		t.Fatalf("filtered: %d mouse events, %d keys; want 60 and 0", mouse, keys)
+	}
+}
-- 
2.54.0