nastech-tui 0.0.1

package/packages/nastech-ink/src/ink/termio/sgr.ts

@@ -0,0 +1,362 @@
+/**
+ * SGR (Select Graphic Rendition) Parser
+ *
+ * Parses SGR parameters and applies them to a TextStyle.
+ * Handles both semicolon (;) and colon (:) separated parameters.
+ */
+
+import type { NamedColor, TextStyle, UnderlineStyle } from './types.js'
+import { defaultStyle } from './types.js'
+
+const NAMED_COLORS: NamedColor[] = [
+  'black',
+  'red',
+  'green',
+  'yellow',
+  'blue',
+  'magenta',
+  'cyan',
+  'white',
+  'brightBlack',
+  'brightRed',
+  'brightGreen',
+  'brightYellow',
+  'brightBlue',
+  'brightMagenta',
+  'brightCyan',
+  'brightWhite'
+]
+
+const UNDERLINE_STYLES: UnderlineStyle[] = ['none', 'single', 'double', 'curly', 'dotted', 'dashed']
+
+type Param = { value: number | null; subparams: number[]; colon: boolean }
+
+function parseParams(str: string): Param[] {
+  if (str === '') {
+    return [{ value: 0, subparams: [], colon: false }]
+  }
+
+  const result: Param[] = []
+  let current: Param = { value: null, subparams: [], colon: false }
+  let num = ''
+  let inSub = false
+
+  for (let i = 0; i <= str.length; i++) {
+    const c = str[i]
+
+    if (c === ';' || c === undefined) {
+      const n = num === '' ? null : parseInt(num, 10)
+
+      if (inSub) {
+        if (n !== null) {
+          current.subparams.push(n)
+        }
+      } else {
+        current.value = n
+      }
+
+      result.push(current)
+      current = { value: null, subparams: [], colon: false }
+      num = ''
+      inSub = false
+    } else if (c === ':') {
+      const n = num === '' ? null : parseInt(num, 10)
+
+      if (!inSub) {
+        current.value = n
+        current.colon = true
+        inSub = true
+      } else {
+        if (n !== null) {
+          current.subparams.push(n)
+        }
+      }
+
+      num = ''
+    } else if (c >= '0' && c <= '9') {
+      num += c
+    }
+  }
+
+  return result
+}
+
+function parseExtendedColor(
+  params: Param[],
+  idx: number
+): { r: number; g: number; b: number } | { index: number } | null {
+  const p = params[idx]
+
+  if (!p) {
+    return null
+  }
+
+  if (p.colon && p.subparams.length >= 1) {
+    if (p.subparams[0] === 5 && p.subparams.length >= 2) {
+      return { index: p.subparams[1]! }
+    }
+
+    if (p.subparams[0] === 2 && p.subparams.length >= 4) {
+      const off = p.subparams.length >= 5 ? 1 : 0
+
+      return {
+        r: p.subparams[1 + off]!,
+        g: p.subparams[2 + off]!,
+        b: p.subparams[3 + off]!
+      }
+    }
+  }
+
+  const next = params[idx + 1]
+
+  if (!next) {
+    return null
+  }
+
+  if (next.value === 5 && params[idx + 2]?.value !== null && params[idx + 2]?.value !== undefined) {
+    return { index: params[idx + 2]!.value! }
+  }
+
+  if (next.value === 2) {
+    const r = params[idx + 2]?.value
+    const g = params[idx + 3]?.value
+    const b = params[idx + 4]?.value
+
+    if (r !== null && r !== undefined && g !== null && g !== undefined && b !== null && b !== undefined) {
+      return { r, g, b }
+    }
+  }
+
+  return null
+}
+
+export function applySGR(paramStr: string, style: TextStyle): TextStyle {
+  const params = parseParams(paramStr)
+  let s = { ...style }
+  let i = 0
+
+  while (i < params.length) {
+    const p = params[i]!
+    const code = p.value ?? 0
+
+    if (code === 0) {
+      s = defaultStyle()
+      i++
+
+      continue
+    }
+
+    if (code === 1) {
+      s.bold = true
+      i++
+
+      continue
+    }
+
+    if (code === 2) {
+      s.dim = true
+      i++
+
+      continue
+    }
+
+    if (code === 3) {
+      s.italic = true
+      i++
+
+      continue
+    }
+
+    if (code === 4) {
+      s.underline = p.colon ? (UNDERLINE_STYLES[p.subparams[0]!] ?? 'single') : 'single'
+      i++
+
+      continue
+    }
+
+    if (code === 5 || code === 6) {
+      s.blink = true
+      i++
+
+      continue
+    }
+
+    if (code === 7) {
+      s.inverse = true
+      i++
+
+      continue
+    }
+
+    if (code === 8) {
+      s.hidden = true
+      i++
+
+      continue
+    }
+
+    if (code === 9) {
+      s.strikethrough = true
+      i++
+
+      continue
+    }
+
+    if (code === 21) {
+      s.underline = 'double'
+      i++
+
+      continue
+    }
+
+    if (code === 22) {
+      s.bold = false
+      s.dim = false
+      i++
+
+      continue
+    }
+
+    if (code === 23) {
+      s.italic = false
+      i++
+
+      continue
+    }
+
+    if (code === 24) {
+      s.underline = 'none'
+      i++
+
+      continue
+    }
+
+    if (code === 25) {
+      s.blink = false
+      i++
+
+      continue
+    }
+
+    if (code === 27) {
+      s.inverse = false
+      i++
+
+      continue
+    }
+
+    if (code === 28) {
+      s.hidden = false
+      i++
+
+      continue
+    }
+
+    if (code === 29) {
+      s.strikethrough = false
+      i++
+
+      continue
+    }
+
+    if (code === 53) {
+      s.overline = true
+      i++
+
+      continue
+    }
+
+    if (code === 55) {
+      s.overline = false
+      i++
+
+      continue
+    }
+
+    if (code >= 30 && code <= 37) {
+      s.fg = { type: 'named', name: NAMED_COLORS[code - 30]! }
+      i++
+
+      continue
+    }
+
+    if (code === 39) {
+      s.fg = { type: 'default' }
+      i++
+
+      continue
+    }
+
+    if (code >= 40 && code <= 47) {
+      s.bg = { type: 'named', name: NAMED_COLORS[code - 40]! }
+      i++
+
+      continue
+    }
+
+    if (code === 49) {
+      s.bg = { type: 'default' }
+      i++
+
+      continue
+    }
+
+    if (code >= 90 && code <= 97) {
+      s.fg = { type: 'named', name: NAMED_COLORS[code - 90 + 8]! }
+      i++
+
+      continue
+    }
+
+    if (code >= 100 && code <= 107) {
+      s.bg = { type: 'named', name: NAMED_COLORS[code - 100 + 8]! }
+      i++
+
+      continue
+    }
+
+    if (code === 38) {
+      const c = parseExtendedColor(params, i)
+
+      if (c) {
+        s.fg = 'index' in c ? { type: 'indexed', index: c.index } : { type: 'rgb', ...c }
+        i += p.colon ? 1 : 'index' in c ? 3 : 5
+
+        continue
+      }
+    }
+
+    if (code === 48) {
+      const c = parseExtendedColor(params, i)
+
+      if (c) {
+        s.bg = 'index' in c ? { type: 'indexed', index: c.index } : { type: 'rgb', ...c }
+        i += p.colon ? 1 : 'index' in c ? 3 : 5
+
+        continue
+      }
+    }
+
+    if (code === 58) {
+      const c = parseExtendedColor(params, i)
+
+      if (c) {
+        s.underlineColor = 'index' in c ? { type: 'indexed', index: c.index } : { type: 'rgb', ...c }
+        i += p.colon ? 1 : 'index' in c ? 3 : 5
+
+        continue
+      }
+    }
+
+    if (code === 59) {
+      s.underlineColor = { type: 'default' }
+      i++
+
+      continue
+    }
+
+    i++
+  }
+
+  return s
+}

package/packages/nastech-ink/src/ink/termio/tokenize.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+
+import { createTokenizer, type Token } from './tokenize.js'
+
+describe('tokenizer escape-sequence boundaries', () => {
+  it('reassembles a CSI mouse sequence split across two feeds', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.feed('46M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+})
+
+describe('tokenizer state-aware flush', () => {
+  it('does not emit an incomplete CSI on flush — it keeps it for reassembly', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    // A render stall lets App's watchdog flush mid-sequence. The buffered CSI
+    // prefix must NOT be emitted (that is the `46M…` leak); it stays buffered.
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.flush()).toEqual([])
+    expect(t.buffer()).toBe('\x1b[<0;35;')
+
+    // The continuation arrives on the next feed and the whole report
+    // reassembles into a single clean sequence token — nothing leaked.
+    expect(t.feed('46M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('drops a partial control sequence that survives a second flush (truncation)', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b[<0;35;')).toEqual([])
+    expect(t.flush()).toEqual([]) // first flush keeps the buffer
+    expect(t.buffer()).toBe('\x1b[<0;35;')
+
+    // Continuation never arrived: the next flush sees the same buffer and
+    // drops it so it can't fuse with the next keypress's bytes.
+    expect(t.flush()).toEqual([])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('still emits a bare ESC on flush so the Escape key works', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    expect(t.feed('\x1b')).toEqual([])
+    expect(t.flush()).toEqual([{ type: 'sequence', value: '\x1b' }])
+    expect(t.buffer()).toBe('')
+  })
+
+  it('reassembles even when a flush fires between every byte of the report', () => {
+    const t = createTokenizer({ x10Mouse: true })
+
+    // Pathological stall: a flush between each chunk. As long as the
+    // continuation eventually arrives, no fragment is ever emitted as input.
+    for (const chunk of ['\x1b[', '<', '0;', '35;', '46']) {
+      expect(t.feed(chunk)).toEqual([])
+      expect(t.flush()).toEqual([])
+    }
+
+    expect(t.feed('M')).toEqual([{ type: 'sequence', value: '\x1b[<0;35;46M' }])
+    expect(t.buffer()).toBe('')
+  })
+})
+
+// Battle-test: prove the leak class is structurally impossible, not just that
+// the known cases are patched. We hammer the tokenizer with the worst stalls a
+// terminal can produce (split + flush at every byte) and assert the two hard
+// invariants: nothing leaks as text, and every complete report reassembles.
+describe('tokenizer fuzz: fragments never leak under a flush storm', () => {
+  const sgr = (btn: number, col: number, row: number, press: boolean): string =>
+    `\x1b[<${btn};${col};${row}${press ? 'M' : 'm'}`
+
+  it('reassembles a report split + flushed at every interior byte', () => {
+    const seq = sgr(0, 35, 46, true)
+
+    // Start at 2: an earlier split is the lone-ESC ESCDELAY boundary, which
+    // intentionally flushes to the Escape key. Terminals never split a mouse
+    // report there — a report is one atomic write — so it's not a real case.
+    for (let i = 2; i < seq.length; i++) {
+      const t = createTokenizer({ x10Mouse: true })
+      const tokens: Token[] = [...t.feed(seq.slice(0, i)), ...t.flush(), ...t.feed(seq.slice(i))]
+
+      expect(tokens).toEqual([{ type: 'sequence', value: seq }])
+      expect(t.buffer()).toBe('')
+    }
+  })
+
+  it('feeds 200 random reports one byte at a time, flushing after every byte', () => {
+    // Deterministic PRNG so a failure is reproducible.
+    let s = 0x1234567
+
+    const rnd = (n: number): number => {
+      s = (s * 1103515245 + 12345) & 0x7fffffff
+
+      return s % n
+    }
+
+    const reports = Array.from({ length: 200 }, () => sgr(rnd(120), 1 + rnd(300), 1 + rnd(200), rnd(2) === 0))
+    const stream = reports.join('')
+
+    const t = createTokenizer({ x10Mouse: true })
+    const seqTokens: string[] = []
+    let textLeak = ''
+
+    const drain = (tokens: Token[]): void => {
+      for (const tok of tokens) {
+        if (tok.type === 'sequence') {
+          seqTokens.push(tok.value)
+        } else {
+          textLeak += tok.value
+        }
+      }
+    }
+
+    for (const ch of stream) {
+      drain(t.feed(ch))
+
+      // Flush storm — but not at a lone-ESC boundary (the real watchdog
+      // re-arms while bytes are pending; a single flush between feeds never
+      // hits the truncation valve).
+      if (t.buffer() !== '\x1b') {
+        drain(t.flush())
+      }
+    }
+
+    expect(textLeak).toBe('')
+    expect(seqTokens.join('')).toBe(stream)
+  })
+
+  it('keeps real keystrokes intact while mouse reports reassemble around them', () => {
+    let s = 0x0badf00d
+
+    const rnd = (n: number): number => {
+      s = (s * 1103515245 + 12345) & 0x7fffffff
+
+      return s % n
+    }
+
+    const typed = 'abc 123 xyz'
+    const expectedKeys: string[] = []
+    const expectedSeqs: string[] = []
+    const parts: string[] = []
+
+    for (let k = 0; k < 120; k++) {
+      if (rnd(3) === 0) {
+        const ch = typed[rnd(typed.length)]!
+        expectedKeys.push(ch)
+        parts.push(ch)
+      } else {
+        const seq = sgr(rnd(64), 1 + rnd(200), 1 + rnd(100), rnd(2) === 0)
+        expectedSeqs.push(seq)
+        parts.push(seq)
+      }
+    }
+
+    const stream = parts.join('')
+    const t = createTokenizer({ x10Mouse: true })
+    const seqTokens: string[] = []
+    let text = ''
+
+    const drain = (tokens: Token[]): void => {
+      for (const tok of tokens) {
+        if (tok.type === 'sequence') {
+          seqTokens.push(tok.value)
+        } else {
+          text += tok.value
+        }
+      }
+    }
+
+    for (const ch of stream) {
+      drain(t.feed(ch))
+
+      if (t.buffer() !== '\x1b') {
+        drain(t.flush())
+      }
+    }
+
+    // Every typed character survives, in order; every report reassembles whole.
+    expect(text).toBe(expectedKeys.join(''))
+    expect(seqTokens).toEqual(expectedSeqs)
+  })
+})