feat(terminal): a right-click menu that fits, Backspace deletes a selection (#44) (#46)

- Right-click over a link offers Copy link, with text marked offers Copy;
  Close tab leaves the terminal's menu (the tab's own menu keeps it).
- Backspace or Delete over a selection on the line being edited deletes it,
  by the presses a user would make (core, so Prism's terminals too).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: Maxaubert

package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-term-core",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "What Prism Terminal and Prism share: the terminal (pty, shells, agent detection and indicator, themes, links, the panel, dictation) and the update chip with its window. TypeScript source, compiled by the host.",
   "license": "MIT",
   "private": true,

renderer/components/TerminalPanel.tsx

@@ -12,6 +12,12 @@ import { followsHostStyle, paintsGround, termApi, termHost } from '../host'
 import { normalizeColor } from '../lib/termAnsi'
 import { findLinks, linkColor } from '../lib/termLinks'
 import { arrowKeys, caretClickAllowed, caretDelta, type ClickGate } from '../lib/termClickCaret'
+import {
+  linkAt,
+  selectionDeleteAllowed,
+  selectionDeleteKeys,
+  type SelectionGate
+} from '../lib/termSelectionEdit'
 import { attachLinkPaint, type LinkPainter } from '../lib/termLinkPaint'
 import {
   onTermLookChange,
@@ -168,7 +174,10 @@ function attachClickCaret(term: Terminal, el: HTMLElement, id: string): () => vo
   // hidden to itself. Returning false lets xterm apply it as always.
   let cursorHidden = false
   const cursorMode = (hidden: boolean) => (params: (number | number[])[]): boolean => {
-    if (params.some((p) => p === 25)) cursorHidden = hidden
+    if (params.some((p) => p === 25)) {
+      cursorHidden = hidden
+      hiddenCursor.set(id, hidden)
+    }
     return false
   }
   const show = term.parser.registerCsiHandler({ prefix: '?', final: 'h' }, cursorMode(false))
@@ -248,6 +257,107 @@ function attachClickCaret(term: Terminal, el: HTMLElement, id: string): () => vo
   }
 }
 
+/** Whether each session's program has hidden the cursor (DECTCEM), followed
+ *  by `attachClickCaret` for the selection delete as well. */
+const hiddenCursor = new Map<string, boolean>()
+
+/** The LOGICAL line holding buffer row `y`: its first and last rows across
+ *  wraps, every cell's width, the joined text, and the cell just past the
+ *  last printed one. */
+function logicalLine(term: Terminal, y: number): {
+  first: number
+  last: number
+  widths: number[]
+  text: string
+  textEnd: number
+} {
+  const b = term.buffer.active
+  let first = y
+  while (first > 0 && b.getLine(first)?.isWrapped) first -= 1
+  let last = y
+  while (last + 1 < b.length && b.getLine(last + 1)?.isWrapped) last += 1
+  const widths: number[] = []
+  let textEnd = 0
+  let text = ''
+  for (let i = first; i <= last; i += 1) {
+    const line = b.getLine(i)
+    text += line?.translateToString(false) ?? ''
+    for (let x = 0; x < term.cols; x += 1) {
+      const cell = line?.getCell(x)
+      widths.push(cell?.getWidth() ?? 1)
+      if (cell && cell.getChars() !== '') textEnd = widths.length - 1 + Math.max(1, cell.getWidth())
+    }
+  }
+  return { first, last, widths, text, textEnd }
+}
+
+/**
+ * BACKSPACE (or Delete) OVER A SELECTION deletes it (owner, 2026-09-23), when
+ * the selection sits on the line being edited at a quiet prompt; the rules and
+ * the presses are `termSelectionEdit`'s. Returns whether it acted, so the key
+ * handler knows to swallow the key; anywhere else Backspace is the shell's.
+ */
+function deleteSelection(term: Terminal, id: string): boolean {
+  const range = term.getSelectionPosition()
+  if (!range) return false
+  const b = term.buffer.active
+  const y = b.baseY + b.cursorY
+  const line = logicalLine(term, y)
+  let textBelow = false
+  for (let i = line.last + 1; i < b.length && !textBelow; i += 1)
+    if ((b.getLine(i)?.translateToString(true) ?? '').length) textBelow = true
+  // xterm reports the range 0-based with the end exclusive, whatever its
+  // typings say (MEASURED in the `selectionDelete` e2e).
+  const inLine = (row: number): boolean => row >= line.first && row <= line.last
+  const gate: SelectionGate = {
+    mouseTracking: term.modes.mouseTrackingMode,
+    alternate: b.type !== 'normal',
+    scrolledBack: b.viewportY !== b.baseY,
+    cursorHidden: hiddenCursor.get(id) ?? false,
+    textBelow,
+    onLine: inLine(range.start.y) && inLine(range.end.y)
+  }
+  if (!selectionDeleteAllowed(gate)) return false
+  const at = (p: { x: number; y: number }): number => (p.y - line.first) * term.cols + p.x
+  const keys = selectionDeleteKeys(
+    line.widths,
+    (y - line.first) * term.cols + b.cursorX,
+    at(range.start),
+    at(range.end),
+    line.textEnd,
+    term.modes.applicationCursorKeysMode
+  )
+  term.clearSelection()
+  if (!keys) return true
+  markTouched(id)
+  termApi().termInput(id, keys)
+  return true
+}
+
+/**
+ * WHAT A RIGHT-CLICK LANDED ON, for the host's menu (owner, 2026-09-23: "if i
+ * click it on a link it shows copy link, if i click it with text marked it
+ * says copy"): the selection's text, and the link under the point (whole, even
+ * when it wraps). Read-only; a host that has no session by that id gets nothing.
+ */
+export function termContextAt(id: string, clientX: number, clientY: number): { selection: string; link: string | null } {
+  const s = sessions.get(id)
+  if (!s) return { selection: '', link: null }
+  const term = s.term
+  const selection = term.hasSelection() ? term.getSelection() : ''
+  const screen = term.element?.querySelector<HTMLElement>('.xterm-screen')
+  if (!screen) return { selection, link: null }
+  const r = screen.getBoundingClientRect()
+  const col = Math.floor((clientX - r.left) / (r.width / term.cols))
+  const row = Math.floor((clientY - r.top) / (r.height / term.rows))
+  if (col < 0 || col >= term.cols || row < 0 || row >= term.rows) return { selection, link: null }
+  const y = term.buffer.active.viewportY + row
+  const line = logicalLine(term, y)
+  const target = (y - line.first) * term.cols + col
+  const charAt = line.widths.slice(0, target).filter((w) => w !== 0).length
+  return { selection, link: linkAt(line.text, charAt) }
+}
+
 /** Refit a session and tell the pty its new geometry. */
 function refitSession(id: string, s: Session): void {
   if (!s.el.clientWidth || !s.el.clientHeight) return
@@ -340,6 +450,7 @@ export function disposeTermSession(id: string): void {
   const s = sessions.get(id)
   if (!s) return
   sessions.delete(id)
+  hiddenCursor.delete(id)
   forgetSession(id)
   s.unsub.forEach((u) => u())
   s.links.dispose()
@@ -560,6 +671,20 @@ function createSession(id: string, root: string, shellId: string | undefined): S
       term.clearSelection()
       return false
     }
+    // Backspace or Delete over a selection on the line being edited deletes
+    // it (owner, 2026-09-23); anywhere else the key is the shell's as ever.
+    if (
+      (e.key === 'Backspace' || e.key === 'Delete') &&
+      !e.ctrlKey &&
+      !e.shiftKey &&
+      !e.altKey &&
+      !e.metaKey &&
+      term.hasSelection() &&
+      deleteSelection(term, id)
+    ) {
+      e.preventDefault()
+      return false
+    }
     // THE HOST'S CHORDS (core/renderer/host). Which keys belong to the app
     // even over a focused shell is the one thing the two apps disagree about
     // (Prism closes a tab on Ctrl+W and toggles the panel on Ctrl+`; Prism

renderer/lib/termSelectionEdit.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+import { linkAt, selectionDeleteAllowed, selectionDeleteKeys, type SelectionGate } from './termSelectionEdit'
+
+const plain: SelectionGate = {
+  mouseTracking: 'none',
+  alternate: false,
+  scrolledBack: false,
+  cursorHidden: false,
+  textBelow: false,
+  onLine: true
+}
+const cells = (n: number): number[] => Array(n).fill(1)
+const L = '\x1b[D'
+const R = '\x1b[C'
+const BS = '\x7f'
+
+describe('selectionDeleteAllowed', () => {
+  it('allows a selection on the line being edited at a quiet prompt', () => {
+    expect(selectionDeleteAllowed(plain)).toBe(true)
+  })
+
+  it('refuses every case where the line is not ours to edit', () => {
+    expect(selectionDeleteAllowed({ ...plain, onLine: false })).toBe(false)
+    expect(selectionDeleteAllowed({ ...plain, alternate: true })).toBe(false)
+    expect(selectionDeleteAllowed({ ...plain, scrolledBack: true })).toBe(false)
+    expect(selectionDeleteAllowed({ ...plain, cursorHidden: true })).toBe(false)
+    expect(selectionDeleteAllowed({ ...plain, textBelow: true })).toBe(false)
+    expect(selectionDeleteAllowed({ ...plain, mouseTracking: 'vt200' })).toBe(false)
+  })
+})
+
+describe('selectionDeleteKeys', () => {
+  // "PS> echo hello world", cursor at the end (cell 20).
+  const line = cells(40)
+  it('deletes a word at the end with Backspaces only', () => {
+    expect(selectionDeleteKeys(line, 20, 15, 20, 20, false)).toBe(BS.repeat(5))
+  })
+
+  it('walks to the end of a selection in the middle first', () => {
+    // "hello" is cells 10-15, the cursor is 5 to its right.
+    expect(selectionDeleteKeys(line, 20, 10, 15, 20, false)).toBe(L.repeat(5) + BS.repeat(5))
+  })
+
+  it('walks right when the cursor is before the selection', () => {
+    expect(selectionDeleteKeys(line, 4, 10, 15, 20, false)).toBe(R.repeat(11) + BS.repeat(5))
+  })
+
+  it('takes a selection made backwards the same way', () => {
+    expect(selectionDeleteKeys(line, 20, 15, 10, 20, false)).toBe(L.repeat(5) + BS.repeat(5))
+  })
+
+  it('stops at the end of the text: trailing blank cells delete nothing', () => {
+    expect(selectionDeleteKeys(line, 20, 15, 35, 20, false)).toBe(BS.repeat(5))
+    expect(selectionDeleteKeys(line, 20, 25, 35, 20, false)).toBe('')
+  })
+
+  it('counts a wide character once', () => {
+    // "ab" then a wide character (2 cells, the second 0) then "c"; cursor at the end.
+    const wide = [1, 1, 2, 0, 1]
+    expect(selectionDeleteKeys(wide, 5, 2, 4, 5, false)).toBe(L + BS)
+  })
+
+  it('uses the application cursor form when the program asked for it', () => {
+    expect(selectionDeleteKeys(line, 20, 10, 15, 20, true)).toBe('\x1bOD'.repeat(5) + BS.repeat(5))
+  })
+})
+
+describe('linkAt', () => {
+  const text = 'see https://example.com/docs. then'
+  it('names the link under the character', () => {
+    expect(linkAt(text, 4)).toBe('https://example.com/docs')
+    expect(linkAt(text, 27)).toBe('https://example.com/docs')
+  })
+
+  it('is null off the link, including its sentence full stop', () => {
+    expect(linkAt(text, 2)).toBeNull()
+    expect(linkAt(text, 28)).toBeNull()
+  })
+})

renderer/lib/termSelectionEdit.ts

@@ -0,0 +1,71 @@
+// BACKSPACE DELETES WHAT IS SELECTED (owner, 2026-09-23: "i should also be able
+// to highlight text and use backspace to delete the selected text"). As with a
+// click on the line (`termClickCaret`), the shell owns the line being edited,
+// so the delete is turned into the presses that would do it by hand: walk the
+// cursor to the END of the selection, then one Backspace per character. Every
+// line editor understands both (PSReadLine, cmd, readline, an agent's input).
+//
+// And WHAT IS UNDER THE POINTER, for the right-click menu (same day: "if i
+// click it on a link it shows copy link, if i click it with text marked it
+// says copy"). Pure, so every rule is tested without a terminal.
+
+import { arrowKeys, caretDelta, type MouseTracking } from './termClickCaret'
+import { findLinks } from './termLinks'
+
+/** Everything that decides whether Backspace may delete the selection. */
+export interface SelectionGate {
+  /** The program asked for the mouse (a TUI): the selection is not ours. */
+  mouseTracking: MouseTracking
+  /** A full-screen program's own screen: there is no line being edited. */
+  alternate: boolean
+  /** The view is scrolled back into history, away from the cursor. */
+  scrolledBack: boolean
+  /** The program hid the cursor, so the cursor is not where it edits. */
+  cursorHidden: boolean
+  /** Something is printed below the cursor's line: a program is running. */
+  textBelow: boolean
+  /** The selection starts and ends on the line holding the cursor. */
+  onLine: boolean
+}
+
+export function selectionDeleteAllowed(g: SelectionGate): boolean {
+  return (
+    g.mouseTracking === 'none' &&
+    !g.alternate &&
+    !g.scrolledBack &&
+    !g.cursorHidden &&
+    !g.textBelow &&
+    g.onLine
+  )
+}
+
+/**
+ * The presses that delete cells `[start, end)` of the cursor's logical line:
+ * Left or Right to the end of the selection, then a Backspace (DEL, 0x7f) per
+ * character in it. `widths`, `cursor` and `textEnd` are `caretDelta`'s. A
+ * selection running past the text stops at its end, so trailing blank cells
+ * delete nothing; wide characters count once, which is what a line editor
+ * deletes by. Empty when there is nothing to delete.
+ */
+export function selectionDeleteKeys(
+  widths: readonly number[],
+  cursor: number,
+  start: number,
+  end: number,
+  textEnd: number,
+  applicationCursor: boolean
+): string {
+  const to = Math.min(Math.max(start, end), textEnd)
+  const from = Math.min(start, end)
+  let count = 0
+  for (let i = from; i < to; i += 1) if ((widths[i] ?? 1) !== 0) count += 1
+  if (!count) return ''
+  return arrowKeys(caretDelta(widths, cursor, to, textEnd), applicationCursor) + '\x7f'.repeat(count)
+}
+
+/** The link covering character `at` of a logical line's text, or null. A link
+ *  the line wraps keeps its whole text, since `text` is the joined rows. */
+export function linkAt(text: string, at: number): string | null {
+  const hit = findLinks(text).find((l) => at >= l.start && at < l.end)
+  return hit ? text.slice(hit.start, hit.end) : null
+}