Fix numpad input handling

Author: jahooma

cli/src/components/__tests__/multiline-input.test.tsx

@@ -1,5 +1,10 @@
 import { describe, test, expect } from 'bun:test'
 
+import {
+  getKeypadPrintableSequence,
+  isKeypadEnter,
+} from '../../utils/keypad-keys'
+
 /**
  * Tests for tab character cursor rendering in MultilineInput component.
  *
@@ -13,23 +18,23 @@ import { describe, test, expect } from 'bun:test'
 /**
  * Check if a key event represents printable character input (not a special key).
  * This mirrors the function in multiline-input.tsx for testing.
- * 
+ *
  * Uses a positive heuristic based on key.name length rather than a brittle deny-list.
  * Special keys have descriptive multi-character names (like 'backspace', 'up', 'f1')
  * while regular printable characters either have no name or a single-character name.
  */
 function isPrintableCharacterKey(key: { name?: string }): boolean {
   const name = key.name
-  
+
   // No name = likely multi-byte input (Chinese, Japanese, Korean, etc.)
   if (!name) return true
-  
+
   // Single character name = regular ASCII printable (a, b, 1, $, etc.)
   if (name.length === 1) return true
-  
+
   // Special case: space key has name 'space' but is printable
   if (name === 'space') return true
-  
+
   // Multi-char name = special key (up, f1, backspace, etc.)
   return false
 }
@@ -256,27 +261,42 @@ describe('MultilineInput - Chinese/IME character input', () => {
     meta?: boolean
     option?: boolean
   }): boolean {
+    return getPrintableKeySequence(key) !== null
+  }
+
+  function getPrintableKeySequence(key: {
+    sequence?: string
+    name?: string
+    ctrl?: boolean
+    meta?: boolean
+    option?: boolean
+  }): string | null {
     // Must have a sequence with at least one character
     if (!key.sequence || key.sequence.length < 1) {
-      return false
+      return null
     }
 
     // No modifier keys allowed
     if (key.ctrl || key.meta || key.option) {
-      return false
+      return null
+    }
+
+    const keypadValue = getKeypadPrintableSequence(key)
+    if (keypadValue !== null) {
+      return keypadValue
     }
 
     // Must not be a control character
     if (CONTROL_CHAR_REGEX.test(key.sequence)) {
-      return false
+      return null
     }
 
     // Must be a printable character key (not a special key like arrows, function keys, etc.)
     if (!isPrintableCharacterKey(key)) {
-      return false
+      return null
     }
 
-    return true
+    return key.sequence
   }
 
   test('accepts single Chinese character (你)', () => {
@@ -387,6 +407,42 @@ describe('MultilineInput - Chinese/IME character input', () => {
     expect(shouldAcceptCharacterInput(key)).toBe(true)
   })
 
+  test('accepts Kitty keyboard numpad digit names', () => {
+    const key = {
+      sequence: '\x1b[57400u',
+      name: 'kp1',
+      ctrl: false,
+      meta: false,
+      option: false,
+    }
+
+    expect(getPrintableKeySequence(key)).toBe('1')
+  })
+
+  test('accepts raw application keypad digit sequences', () => {
+    const key = {
+      sequence: '\x1bOq',
+      name: '',
+      ctrl: false,
+      meta: false,
+      option: false,
+    }
+
+    expect(getPrintableKeySequence(key)).toBe('1')
+  })
+
+  test('accepts raw application keypad operator sequences', () => {
+    const key = {
+      sequence: '\x1bOk',
+      name: '',
+      ctrl: false,
+      meta: false,
+      option: false,
+    }
+
+    expect(getPrintableKeySequence(key)).toBe('+')
+  })
+
   test('rejects arrow key (up)', () => {
     const key = {
       sequence: '\x1b[A',
@@ -625,7 +681,9 @@ describe('MultilineInput - newline keyboard shortcuts', () => {
     hasBackslashBeforeCursor: boolean = false,
   ): 'newline' | 'submit' | 'ignore' {
     const lowerKeyName = (key.name ?? '').toLowerCase()
-    const isEnterKey = key.name === 'return' || key.name === 'enter'
+    const keypadEnter = isKeypadEnter(key)
+    const isEnterKey =
+      key.name === 'return' || key.name === 'enter' || keypadEnter
     // Ctrl+J is translated by the terminal to a linefeed character (0x0a)
     // So we detect it by checking for name === 'linefeed' rather than ctrl + j
     const isCtrlJ =
@@ -651,13 +709,13 @@ describe('MultilineInput - newline keyboard shortcuts', () => {
       !key.meta &&
       !key.option &&
       !isAltLikeModifier &&
-      !hasEscapePrefix &&
-      key.sequence === '\r' &&
+      (!hasEscapePrefix || keypadEnter) &&
+      (key.sequence === '\r' || keypadEnter) &&
       !hasBackslashBeforeCursor
     const isShiftEnter =
       isEnterKey && (Boolean(key.shift) || key.sequence === '\n')
     const isOptionEnter =
-      isEnterKey && (isAltLikeModifier || hasEscapePrefix)
+      isEnterKey && !keypadEnter && (isAltLikeModifier || hasEscapePrefix)
     const isBackslashEnter = isEnterKey && hasBackslashBeforeCursor
 
     const shouldInsertNewline =
@@ -900,6 +958,32 @@ describe('MultilineInput - newline keyboard shortcuts', () => {
     expect(getEnterKeyAction(key, false)).toBe('submit')
   })
 
+  test('keypad Enter submits with Kitty keyboard key name', () => {
+    const key = {
+      name: 'kpenter',
+      sequence: '\x1b[57414u',
+      ctrl: false,
+      meta: false,
+      shift: false,
+      option: false,
+    }
+
+    expect(getEnterKeyAction(key, false)).toBe('submit')
+  })
+
+  test('keypad Enter submits with raw application keypad sequence', () => {
+    const key = {
+      name: '',
+      sequence: '\x1bOM',
+      ctrl: false,
+      meta: false,
+      shift: false,
+      option: false,
+    }
+
+    expect(getEnterKeyAction(key, false)).toBe('submit')
+  })
+
   // --- Non-Enter key tests ---
 
   test('Regular J key (no ctrl) is ignored', () => {

cli/src/components/multiline-input.tsx

@@ -16,6 +16,10 @@ import {
 import { InputCursor } from './input-cursor'
 import { useTheme } from '../hooks/use-theme'
 import { useChatStore } from '../state/chat-store'
+import {
+  getKeypadPrintableSequence,
+  isKeypadEnter,
+} from '../utils/keypad-keys'
 import { clamp } from '../utils/math'
 import { isLinefeedActingAsEnter, markReturnKeySeen } from '../utils/terminal-enter-detection'
 import { supportsTruecolor } from '../utils/theme-system'
@@ -91,27 +95,41 @@ const TAB_WIDTH = 4
 /**
  * Check if a key event represents printable character input (not a special key).
  * Uses a positive heuristic based on key.name length rather than a brittle deny-list.
- * 
+ *
  * The key insight is that OpenTUI's parser assigns descriptive multi-character names
  * to special keys (like 'backspace', 'up', 'f1') while regular printable characters
  * either have no name (multi-byte input like Chinese) or a single-character name.
  */
 function isPrintableCharacterKey(key: KeyEvent): boolean {
   const name = key.name
-  
+
   // No name = likely multi-byte input (Chinese, Japanese, Korean, etc.) - treat as printable
   if (!name) return true
-  
+
   // Single character name = regular ASCII printable (a, b, 1, $, etc.)
   if (name.length === 1) return true
-  
+
   // Special case: space key has name 'space' but is printable
   if (name === 'space') return true
-  
+
   // Multi-char name = special key (up, f1, backspace, etc.)
   return false
 }
 
+function getPrintableKeySequence(key: KeyEvent): string | null {
+  if (!key.sequence || key.sequence.length < 1) return null
+  if (key.ctrl || key.meta || key.option) return null
+
+  const keypadValue = getKeypadPrintableSequence(key)
+  if (keypadValue !== null) return keypadValue
+
+  if (!CONTROL_CHAR_REGEX.test(key.sequence) && isPrintableCharacterKey(key)) {
+    return key.sequence
+  }
+
+  return null
+}
+
 // Helper to convert render position (in tab-expanded string) to original text position
 function renderPositionToOriginal(text: string, renderPos: number): number {
   let originalPos = 0
@@ -532,7 +550,9 @@ export const MultilineInput = forwardRef<
   const handleEnterKeys = useCallback(
     (key: KeyEvent): boolean => {
       const lowerKeyName = (key.name ?? '').toLowerCase()
-      const isReturnOrEnter = key.name === 'return' || key.name === 'enter'
+      const keypadEnter = isKeypadEnter(key)
+      const isReturnOrEnter =
+        key.name === 'return' || key.name === 'enter' || keypadEnter
 
       if (isReturnOrEnter) {
         markReturnKeySeen()
@@ -567,12 +587,12 @@ export const MultilineInput = forwardRef<
         !key.meta &&
         !key.option &&
         !isAltLikeModifier &&
-        !hasEscapePrefix &&
-        (key.sequence === '\r' || key.sequence === '\n') &&
+        (!hasEscapePrefix || keypadEnter) &&
+        (key.sequence === '\r' || key.sequence === '\n' || keypadEnter) &&
         !hasBackslashBeforeCursor
       const isShiftEnter = isEnterKey && Boolean(key.shift)
       const isOptionEnter =
-        isEnterKey && (isAltLikeModifier || hasEscapePrefix)
+        isEnterKey && !keypadEnter && (isAltLikeModifier || hasEscapePrefix)
       const isBackslashEnter = isEnterKey && hasBackslashBeforeCursor
 
       const shouldInsertNewline =
@@ -1003,18 +1023,10 @@ export const MultilineInput = forwardRef<
       }
 
       // Character input (including multi-byte characters from IME like Chinese, Japanese, Korean)
-      // Check for printable input: has a sequence, no modifier keys, and not a control character
-      if (
-        key.sequence &&
-        key.sequence.length >= 1 &&
-        !key.ctrl &&
-        !key.meta &&
-        !key.option &&
-        !CONTROL_CHAR_REGEX.test(key.sequence) &&
-        isPrintableCharacterKey(key)
-      ) {
+      const textToInsert = getPrintableKeySequence(key)
+      if (textToInsert !== null) {
         preventKeyDefault(key)
-        insertTextAtCursor(key.sequence)
+        insertTextAtCursor(textToInsert)
         return true
       }
 

cli/src/utils/__tests__/keyboard-actions.test.ts

@@ -26,6 +26,8 @@ const downKey = createKey({ name: 'down' })
 const tabKey = createKey({ name: 'tab' })
 const shiftTabKey = createKey({ name: 'tab', shift: true })
 const enterKey = createKey({ name: 'return' })
+const keypadEnterKey = createKey({ name: 'kpenter', sequence: '\x1b[57414u' })
+const rawApplicationKeypadEnterKey = createKey({ sequence: '\x1bOM' })
 const backspaceKey = createKey({ name: 'backspace' })
 
 const defaultState = createDefaultChatKeyboardState()
@@ -533,6 +535,44 @@ describe('resolveChatKeyboardAction', () => {
       })
     })
 
+    test('keypad enter without active menu does nothing', () => {
+      expect(resolveChatKeyboardAction(keypadEnterKey, defaultState)).toEqual({
+        type: 'none',
+      })
+    })
+
+    test('raw application keypad enter without active menu does nothing', () => {
+      expect(
+        resolveChatKeyboardAction(rawApplicationKeypadEnterKey, defaultState),
+      ).toEqual({
+        type: 'none',
+      })
+    })
+
+    test('keypad enter selects an active slash menu item', () => {
+      const state: ChatKeyboardState = {
+        ...defaultState,
+        slashMenuActive: true,
+        slashMatchesLength: 3,
+      }
+      expect(resolveChatKeyboardAction(keypadEnterKey, state)).toEqual({
+        type: 'slash-menu-select',
+      })
+    })
+
+    test('raw application keypad enter selects an active slash menu item', () => {
+      const state: ChatKeyboardState = {
+        ...defaultState,
+        slashMenuActive: true,
+        slashMatchesLength: 3,
+      }
+      expect(
+        resolveChatKeyboardAction(rawApplicationKeypadEnterKey, state),
+      ).toEqual({
+        type: 'slash-menu-select',
+      })
+    })
+
     test('shift+enter does nothing even in menu', () => {
       const shiftEnter = createKey({ name: 'return', shift: true })
       const state: ChatKeyboardState = {

cli/src/utils/keyboard-actions.ts

@@ -1,4 +1,5 @@
 import { getInputModeConfig, type InputMode } from './input-modes'
+import { isKeypadEnter } from './keypad-keys'
 import { isLinefeedActingAsEnter } from './terminal-enter-detection'
 import type { KeyEvent } from '@opentui/core'
 
@@ -131,8 +132,9 @@ export function resolveChatKeyboardAction(
   const isTab = key.name === 'tab' && !hasModifier(key)
   const isShiftTab =
     key.name === 'tab' && key.shift && !key.ctrl && !key.meta && !key.option
+  const keypadEnter = isKeypadEnter(key)
   const isEnter =
-    (key.name === 'return' || key.name === 'enter' ||
+    (key.name === 'return' || key.name === 'enter' || keypadEnter ||
       (key.name === 'linefeed' && isLinefeedActingAsEnter())) &&
     !key.shift &&
     !hasModifier(key)