fix: enforce title stack limit and add CSI 14t/16t handlers

- Cap windowTitleStack and iconNameStack to 10 entries (matching upstream
  STACK_LIMIT) to prevent unbounded memory growth from malicious input.
- Handle CSI 14 t (GetWinSizePixels) and CSI 16 t (GetCellSizePixels) by
  firing OnRequestWindowsOptionsReport instead of silently ignoring them.
- Add WindowsOptionsReportType enum and expose the event on Terminal.

Fixes #33

Co-authored-by: Ona <no-reply@ona.com>

Author: ona-automations

inputhandler.go

@@ -98,9 +98,10 @@ type InputHandler struct {
 	OnRequestBellEmitter          EventEmitter[struct{}]
 	OnRequestResetEmitter         EventEmitter[struct{}]
 	OnRequestRefreshRowsEmitter   EventEmitter[RowRange]
-	OnColorEmitter                     EventEmitter[[]ColorEvent]
-	OnRequestSyncScrollBarEmitter      EventEmitter[struct{}]
-	OnRequestColorSchemeQueryEmitter   EventEmitter[struct{}]
+	OnColorEmitter                          EventEmitter[[]ColorEvent]
+	OnRequestSyncScrollBarEmitter           EventEmitter[struct{}]
+	OnRequestColorSchemeQueryEmitter        EventEmitter[struct{}]
+	OnRequestWindowsOptionsReportEmitter    EventEmitter[WindowsOptionsReportType]
 }
 
 // NewInputHandler creates an InputHandler and registers all parser handlers.
@@ -549,4 +550,5 @@ func (h *InputHandler) Dispose() {
 	h.OnColorEmitter.Dispose()
 	h.OnRequestSyncScrollBarEmitter.Dispose()
 	h.OnRequestColorSchemeQueryEmitter.Dispose()
+	h.OnRequestWindowsOptionsReportEmitter.Dispose()
 }

inputhandler_csi.go

@@ -5,6 +5,10 @@ import (
 	"strings"
 )
 
+// titleStackLimit is the maximum number of entries in the title/icon name push
+// stacks. Matches upstream xterm.js STACK_LIMIT (InputHandler.ts:47).
+const titleStackLimit = 10
+
 // moveCursor moves the cursor by a relative offset, clamping to valid range.
 func (h *InputHandler) moveCursor(x, y int) {
 	h.restrictCursor()
@@ -946,9 +950,15 @@ func (h *InputHandler) windowOptions(params *Params) bool {
 		}
 		if ps2 == 0 || ps2 == 2 {
 			h.windowTitleStack = append(h.windowTitleStack, h.windowTitle)
+			if len(h.windowTitleStack) > titleStackLimit {
+				h.windowTitleStack = h.windowTitleStack[len(h.windowTitleStack)-titleStackLimit:]
+			}
 		}
 		if ps2 == 0 || ps2 == 1 {
 			h.iconNameStack = append(h.iconNameStack, h.iconName)
+			if len(h.iconNameStack) > titleStackLimit {
+				h.iconNameStack = h.iconNameStack[len(h.iconNameStack)-titleStackLimit:]
+			}
 		}
 	case 23:
 		// Pop title from stack.
@@ -972,8 +982,21 @@ func (h *InputHandler) windowOptions(params *Params) bool {
 				h.OnIconNameChangeEmitter.Fire(name)
 			}
 		}
+	case 14:
+		// Report window size in pixels. Ps2 == 2 means cell size (handled by case 16 upstream),
+		// otherwise report window size.
+		ps2 := int32(0)
+		if params.Length >= 2 {
+			ps2 = params.Params[1]
+		}
+		if ps2 != 2 {
+			h.OnRequestWindowsOptionsReportEmitter.Fire(GetWinSizePixels)
+		}
+	case 16:
+		// Report cell size in pixels.
+		h.OnRequestWindowsOptionsReportEmitter.Fire(GetCellSizePixels)
 	default:
-		// Other sub-commands (14, 16, etc.) are renderer-specific; silently ignore.
+		// Other sub-commands are renderer-specific; silently ignore.
 	}
 	return true
 }

inputhandler_csi_test.go

@@ -1592,4 +1592,249 @@ func TestDSR996ColorSchemeQuery(t *testing.T) {
 	})
 }
 
+func TestWindowOptionsTitleStackLimit(t *testing.T) {
+	t.Parallel()
+
+	t.Run("title_stack_capped_at_10", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		// Set and push 15 titles.
+		for i := 0; i < 15; i++ {
+			h.ParseString("\x1b]2;title\x07")
+			h.ParseString("\x1b[22;2t") // push title
+		}
+
+		// Pop all — should get at most 10.
+		popCount := 0
+		for i := 0; i < 15; i++ {
+			fired := false
+			d := h.OnTitleChangeEmitter.Event(func(s string) { fired = true })
+			h.ParseString("\x1b[23;2t") // pop title
+			if fired {
+				popCount++
+			}
+			d.Dispose()
+		}
+		if popCount != titleStackLimit {
+			t.Errorf("popped %d titles, want exactly %d", popCount, titleStackLimit)
+		}
+	})
+
+	t.Run("icon_name_stack_capped_at_10", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		// Set and push 15 icon names.
+		for i := 0; i < 15; i++ {
+			h.ParseString("\x1b]1;icon\x07")
+			h.ParseString("\x1b[22;1t") // push icon name
+		}
+
+		// Pop all — should get at most 10.
+		popCount := 0
+		for i := 0; i < 15; i++ {
+			fired := false
+			d := h.OnIconNameChangeEmitter.Event(func(s string) { fired = true })
+			h.ParseString("\x1b[23;1t") // pop icon name
+			if fired {
+				popCount++
+			}
+			d.Dispose()
+		}
+		if popCount != titleStackLimit {
+			t.Errorf("popped %d icon names, want exactly %d", popCount, titleStackLimit)
+		}
+	})
+
+	t.Run("both_stacks_capped_at_10", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		// Push 12 entries for both title and icon name (ps2=0).
+		for i := 0; i < 12; i++ {
+			h.ParseString("\x1b]0;both\x07") // OSC 0 sets both
+			h.ParseString("\x1b[22;0t")       // push both
+		}
+
+		titlePops := 0
+		iconPops := 0
+		for i := 0; i < 12; i++ {
+			tFired := false
+			iFired := false
+			dt := h.OnTitleChangeEmitter.Event(func(s string) { tFired = true })
+			di := h.OnIconNameChangeEmitter.Event(func(s string) { iFired = true })
+			h.ParseString("\x1b[23;0t") // pop both
+			if tFired {
+				titlePops++
+			}
+			if iFired {
+				iconPops++
+			}
+			dt.Dispose()
+			di.Dispose()
+		}
+		if titlePops != titleStackLimit {
+			t.Errorf("title pops = %d, want %d", titlePops, titleStackLimit)
+		}
+		if iconPops != titleStackLimit {
+			t.Errorf("icon pops = %d, want %d", iconPops, titleStackLimit)
+		}
+	})
+
+	t.Run("stack_preserves_most_recent_entries", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		// Push 12 titles with distinct values; the first 2 should be evicted.
+		for i := 0; i < 12; i++ {
+			h.ParseString("\x1b]2;t" + string(rune('A'+i)) + "\x07")
+			h.ParseString("\x1b[22;2t")
+		}
+
+		// Pop returns from top of stack (most recent push first).
+		// Pushed: tA tB tC tD tE tF tG tH tI tJ tK tL
+		// After trim: tC tD tE tF tG tH tI tJ tK tL (oldest 2 evicted)
+		// Pop order: tL, tK, tJ, ...
+		var got string
+		d := h.OnTitleChangeEmitter.Event(func(s string) { got = s })
+		h.ParseString("\x1b[23;2t")
+		d.Dispose()
+
+		expected := "tL"
+		if got != expected {
+			t.Errorf("first pop = %q, want %q", got, expected)
+		}
+	})
+}
+
+func TestWindowOptionsCSI14t(t *testing.T) {
+	t.Parallel()
+
+	t.Run("fires_GetWinSizePixels", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		var got WindowsOptionsReportType
+		fired := false
+		d := h.OnRequestWindowsOptionsReportEmitter.Event(func(rt WindowsOptionsReportType) {
+			fired = true
+			got = rt
+		})
+		defer d.Dispose()
+
+		h.ParseString("\x1b[14t")
+		if !fired {
+			t.Fatal("OnRequestWindowsOptionsReport not fired for CSI 14 t")
+		}
+		if got != GetWinSizePixels {
+			t.Errorf("report type = %d, want GetWinSizePixels (%d)", got, GetWinSizePixels)
+		}
+	})
+
+	t.Run("ps2_not_2_fires_GetWinSizePixels", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		fired := false
+		d := h.OnRequestWindowsOptionsReportEmitter.Event(func(rt WindowsOptionsReportType) {
+			fired = true
+		})
+		defer d.Dispose()
+
+		h.ParseString("\x1b[14;1t")
+		if !fired {
+			t.Fatal("OnRequestWindowsOptionsReport not fired for CSI 14;1 t")
+		}
+	})
+
+	t.Run("ps2_eq_2_does_not_fire", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		fired := false
+		d := h.OnRequestWindowsOptionsReportEmitter.Event(func(rt WindowsOptionsReportType) {
+			fired = true
+		})
+		defer d.Dispose()
+
+		h.ParseString("\x1b[14;2t")
+		if fired {
+			t.Error("OnRequestWindowsOptionsReport should not fire for CSI 14;2 t")
+		}
+	})
+}
+
+func TestWindowOptionsCSI16t(t *testing.T) {
+	t.Parallel()
+
+	t.Run("fires_GetCellSizePixels", func(t *testing.T) {
+		t.Parallel()
+		h := newTestInputHandler(80, 24)
+
+		var got WindowsOptionsReportType
+		fired := false
+		d := h.OnRequestWindowsOptionsReportEmitter.Event(func(rt WindowsOptionsReportType) {
+			fired = true
+			got = rt
+		})
+		defer d.Dispose()
+
+		h.ParseString("\x1b[16t")
+		if !fired {
+			t.Fatal("OnRequestWindowsOptionsReport not fired for CSI 16 t")
+		}
+		if got != GetCellSizePixels {
+			t.Errorf("report type = %d, want GetCellSizePixels (%d)", got, GetCellSizePixels)
+		}
+	})
+}
+
+func TestWindowOptionsReportTerminalLevel(t *testing.T) {
+	t.Parallel()
+
+	t.Run("CSI_14t_forwarded_to_terminal", func(t *testing.T) {
+		t.Parallel()
+		term := newTestTerminal(80, 24)
+		defer term.Dispose()
+
+		var got WindowsOptionsReportType
+		fired := false
+		d := term.OnRequestWindowsOptionsReport(func(rt WindowsOptionsReportType) {
+			fired = true
+			got = rt
+		})
+		defer d.Dispose()
+
+		term.WriteString("\x1b[14t")
+		if !fired {
+			t.Fatal("Terminal.OnRequestWindowsOptionsReport not fired for CSI 14 t")
+		}
+		if got != GetWinSizePixels {
+			t.Errorf("report type = %d, want GetWinSizePixels (%d)", got, GetWinSizePixels)
+		}
+	})
+
+	t.Run("CSI_16t_forwarded_to_terminal", func(t *testing.T) {
+		t.Parallel()
+		term := newTestTerminal(80, 24)
+		defer term.Dispose()
+
+		var got WindowsOptionsReportType
+		fired := false
+		d := term.OnRequestWindowsOptionsReport(func(rt WindowsOptionsReportType) {
+			fired = true
+			got = rt
+		})
+		defer d.Dispose()
+
+		term.WriteString("\x1b[16t")
+		if !fired {
+			t.Fatal("Terminal.OnRequestWindowsOptionsReport not fired for CSI 16 t")
+		}
+		if got != GetCellSizePixels {
+			t.Errorf("report type = %d, want GetCellSizePixels (%d)", got, GetCellSizePixels)
+		}
+	})
+}
 

terminal.go

@@ -48,7 +48,8 @@ type Terminal struct {
 	OnResizeEmitter                  EventEmitter[BufferResizeEvent]
 	OnScrollEmitter                  EventEmitter[int]
 	OnRenderEmitter                  EventEmitter[RowRange]
-	OnRequestColorSchemeQueryEmitter EventEmitter[struct{}]
+	OnRequestColorSchemeQueryEmitter        EventEmitter[struct{}]
+	OnRequestWindowsOptionsReportEmitter    EventEmitter[WindowsOptionsReportType]
 }
 
 // New creates a new Terminal with the given options.
@@ -86,6 +87,7 @@ func New(opts ...Option) *Terminal {
 	ih.OnCursorMoveEmitter.Event(func(struct{}) { t.OnCursorMoveEmitter.Fire(struct{}{}) })
 	ih.OnRequestRefreshRowsEmitter.Event(func(r RowRange) { t.OnRenderEmitter.Fire(r) })
 	ih.OnRequestColorSchemeQueryEmitter.Event(func(struct{}) { t.OnRequestColorSchemeQueryEmitter.Fire(struct{}{}) })
+	ih.OnRequestWindowsOptionsReportEmitter.Event(func(rt WindowsOptionsReportType) { t.OnRequestWindowsOptionsReportEmitter.Fire(rt) })
 
 	// Forward buffer service events.
 	bufSvc.OnResizeEmitter.Event(func(e BufferResizeEvent) { t.OnResizeEmitter.Fire(e) })
@@ -260,6 +262,11 @@ func (t *Terminal) OnRequestColorSchemeQuery(fn func()) Disposable {
 	return t.OnRequestColorSchemeQueryEmitter.Event(func(struct{}) { fn() })
 }
 
+// OnRequestWindowsOptionsReport subscribes to window-options report requests (CSI 14 t, CSI 16 t).
+func (t *Terminal) OnRequestWindowsOptionsReport(fn func(WindowsOptionsReportType)) Disposable {
+	return t.OnRequestWindowsOptionsReportEmitter.Event(fn)
+}
+
 // OnColor subscribes to color palette query/set/restore events (OSC 4/10/11/12).
 func (t *Terminal) OnColor(fn func([]ColorEvent)) Disposable {
 	return t.inputHandler.OnColorEmitter.Event(fn)
@@ -410,4 +417,5 @@ func (t *Terminal) Dispose() {
 	t.OnScrollEmitter.Dispose()
 	t.OnRenderEmitter.Dispose()
 	t.OnRequestColorSchemeQueryEmitter.Dispose()
+	t.OnRequestWindowsOptionsReportEmitter.Dispose()
 }

types.go

@@ -177,6 +177,16 @@ type DeleteEvent struct {
 // BufferIndex denotes a position in the buffer: [rowIndex, colIndex].
 type BufferIndex [2]int
 
+// WindowsOptionsReportType identifies a window-options report request (CSI t).
+type WindowsOptionsReportType int
+
+const (
+	// GetWinSizePixels requests the window size in pixels (CSI 14 t).
+	GetWinSizePixels WindowsOptionsReportType = 0
+	// GetCellSizePixels requests the cell size in pixels (CSI 16 t).
+	GetCellSizePixels WindowsOptionsReportType = 1
+)
+
 // KittyKeyboardState tracks the kitty keyboard protocol state.
 type KittyKeyboardState struct {
 	Flags     int