Compose a pasted CR/LF instead of submitting on it

A terminal that never negotiates bracketed paste (DEC 2004) delivers a
multi-line paste as ordinary keystrokes, carriage returns included, and a
bare CR is the same "return" that sends the message. Pasting three lines
was sending three separate messages instead of composing one.

An unmodified Enter that lands in a keystroke burst right after a plain
character is paste-carried, not a deliberate submit, so it now becomes a
newline; a CRLF pair collapses to one newline instead of two. A real
Ctrl+J-then-Enter (insert a line, then send) still sends, since Ctrl+J
never counts as "a printable character" preceding it.

Author: TheGreatAxios

src/tui-opentui/prompt-features.test.ts

@@ -207,6 +207,49 @@ describe("text paste", () => {
     async (h) => await h.mockInput.pasteBracketedText(`${"x".repeat(4000)}\nend`),
     `${"x".repeat(4000)}\nend`,
   )
+
+  // A terminal that never negotiated DEC 2004 hands a paste to us as plain
+  // keystrokes -- CR included -- instead of one `paste` event. Without a
+  // burst guard, the bare CR after "line one" would hit the same submit
+  // binding a deliberate Enter does, sending the message after its first
+  // line instead of composing all three.
+  pasteCase(
+    "a CRLF paste arriving as raw keystrokes still composes instead of submitting",
+    async (h) => await h.mockInput.typeText("line one\r\nline two\r\nline three"),
+    "line one\nline two\nline three",
+  )
+})
+
+describe("un-bracketed paste vs. deliberate Enter", () => {
+  test("Ctrl+J then Enter still sends -- a newline chord followed by a real Enter is not a paste", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: true,
+          run: "idle",
+        })
+        try {
+          const submitted: string[] = []
+          setShellBridgeHooks(shell, {
+            onSubmit: (text) => submitted.push(text),
+            onInterrupt: () => {},
+            exclusive: true,
+          })
+          shell.prompt.focus()
+          shell.prompt.value = "first"
+          h.mockInput.pressKey("\n")
+          h.mockInput.pressKey("\r")
+          await h.renderOnce()
+          expect(submitted).toEqual(["first\n"])
+          expect(shell.prompt.value).toBe("")
+        } finally {
+          shell.dispose()
+        }
+      },
+      { width: 80, height: 24 },
+    )
+  })
 })
 
 describe("sent-message recall", () => {

src/tui-opentui/shell.ts

@@ -652,6 +652,12 @@ export type AppShell = {
    * ./prompt-kill-ring.js).
    */
   promptKillRing: KillRing
+  /** `Date.now()` of the last keypress; detects an un-bracketed paste burst (see `PASTE_BURST_MS`). */
+  lastKeyAt: number
+  /** Whether that last keypress inserted a plain character (see `isPrintableInsertKey`). */
+  lastKeyWasPrintable: boolean
+  /** A converted CR is about to be followed by its CRLF partner LF; swallow that LF. */
+  suppressNextLinefeed: boolean
   /** Images attached with Ctrl+P, sent with the next prompt submit. */
   pendingAttachments: PendingImageAttachment[]
   /** Up/Down recall of messages already sent in this session. */
@@ -682,6 +688,23 @@ export type PrimaryOverlayKind =
   | "mcp"
   | "plugin_credentials"
 
+// Human keystrokes land tens of milliseconds apart at the fastest; a paste
+// replayed onto stdin without bracketed-paste framing lands effectively all
+// at once. Anything under this gap between keypresses is paste, not typing.
+const PASTE_BURST_MS = 15
+
+/** A single unmodified character, as opposed to a control chord or named key. */
+function isPrintableInsertKey(key: KeyEvent): boolean {
+  return (
+    !key.ctrl &&
+    !key.meta &&
+    !key.option &&
+    typeof key.sequence === "string" &&
+    key.sequence.length === 1 &&
+    key.sequence >= " "
+  )
+}
+
 const DEFAULT_TITLE = "corbits"
 const DEFAULT_OVERLAY_ITEMS = [
   "Allow bash: ls",
@@ -4586,6 +4609,46 @@ export function createAppShell(
     // kill ring — Ctrl+K/U/W and Alt+D delete natively but discard the text;
     // Ctrl+Y/Alt+Y need somewhere to yank it back from.
     const keyName = typeof key.name === "string" ? key.name.toLowerCase() : ""
+
+    // The LF half of a CRLF pair the block below just turned into a newline:
+    // without this, "line one\r\nline two" would insert two newlines, one for
+    // the converted CR and one for the LF arriving right behind it.
+    const suppressLinefeed = shell.suppressNextLinefeed
+    shell.suppressNextLinefeed = false
+    if (suppressLinefeed && keyName === "linefeed" && !key.ctrl && !key.meta && !key.option) {
+      key.preventDefault()
+      return
+    }
+
+    // A terminal that never negotiated bracketed paste (DEC 2004) hands a
+    // multi-line paste to us as ordinary keystrokes, CR and all -- and a bare
+    // CR is the same "return" that submits. Left alone, pasting three lines
+    // sends three separate messages instead of composing one. Bracketed paste
+    // delivers the whole blob as one `paste` event and never reaches here, so
+    // this only fires on the raw-keystroke fallback.
+    //
+    // Detecting it needs two signals, not one: a lone fast Enter can happen
+    // (key rollover, a scripted "send keys"), and a lone printable character
+    // right before Enter is just typing. What never happens from a human is a
+    // printable character landing, then Enter, both inside a keystroke burst
+    // — that shape is unique to a paste being replayed byte-for-byte. Gating
+    // on both keeps a deliberate Ctrl+J-then-Enter (newline, then send) safe,
+    // since Ctrl+J is not "a printable character," while still catching
+    // "...end of line one<CR><LF>line two..." arriving as raw keystrokes.
+    const now = Date.now()
+    const sincePreviousKey = now - shell.lastKeyAt
+    const previousKeyWasPrintable = shell.lastKeyWasPrintable
+    shell.lastKeyAt = now
+    shell.lastKeyWasPrintable = isPrintableInsertKey(key)
+    const isBareReturn =
+      !key.ctrl && !key.meta && !key.option && (keyName === "return" || keyName === "kpenter")
+    if (isBareReturn && previousKeyWasPrintable && sincePreviousKey < PASTE_BURST_MS) {
+      key.preventDefault()
+      shell.prompt.insertText("\n")
+      shell.suppressNextLinefeed = true
+      return
+    }
+
     const isCtrlKillYank =
       key.ctrl &&
       !key.meta &&
@@ -4902,6 +4965,9 @@ export function createAppShell(
     observe: null,
     parentStreamLog: null,
     promptKillRing: emptyKillRing,
+    lastKeyAt: 0,
+    lastKeyWasPrintable: false,
+    suppressNextLinefeed: false,
     pendingAttachments: [],
     sentHistory: createSentHistoryBrowse([]),
     disposed: false,