ethagent 4.3.0 → 4.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethagent",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "description": "Portable Ethereum identity for your AI agent. Its soul, memory, and skills live onchain via ERC-8004 + IPFS and snap back into any session.",
   "type": "module",
   "bin": {

package/src/app/input/AppInputProvider.tsx

@@ -1,135 +1,16 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef } from 'react'
-import { useStdin, useStdout } from 'ink'
-import type { AppInputEvent } from './appInputParser.js'
-import {
-  BRACKETED_PASTE_DISABLE,
-  BRACKETED_PASTE_ENABLE,
-  createAppInputParseState,
-  DISABLE_KITTY_KEYBOARD,
-  DISABLE_MODIFY_OTHER_KEYS,
-  ENABLE_KITTY_KEYBOARD,
-  ENABLE_MODIFY_OTHER_KEYS,
-  hasPendingAppInput,
-  parseAppInput,
-} from './appInputParser.js'
+import { useInput, type Key } from 'ink'
 
-const DEBUG_INPUT = Boolean(process.env.ETHAGENT_DEBUG_INPUT)
-const DEBUG_LOG_PATH = path.join(os.homedir(), '.ethagent', 'input-debug.log')
+export type { Key }
 
-function logRawChunk(chunk: Buffer | string): void {
-  if (!DEBUG_INPUT) return
-  try {
-    const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8')
-    const codepoints = [...text].map(c => c.codePointAt(0)?.toString(16).padStart(4, '0') ?? '????').join(' ')
-    const hex = Buffer.isBuffer(chunk) ? chunk.toString('hex') : Buffer.from(chunk, 'utf8').toString('hex')
-    const line = `[${new Date().toISOString()}] codepoints=${codepoints} hex=${hex} text=${JSON.stringify(text)}\n`
-    fs.appendFileSync(DEBUG_LOG_PATH, line)
-  } catch {
-  }
-}
-
-type InputHandler = (input: string, key: AppInputEvent['key'], event: AppInputEvent) => void
-
-type HandlerEntry = {
-  handlerRef: React.MutableRefObject<InputHandler>
-  isActiveRef: React.MutableRefObject<boolean>
-}
-
-type AppInputContextValue = {
-  register(entry: HandlerEntry): () => void
-}
-
-const AppInputContext = createContext<AppInputContextValue | null>(null)
-const PENDING_ESCAPE_FLUSH_MS = 50
-
-export const AppInputProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const { stdin } = useStdin()
-  const { stdout } = useStdout()
-  const handlersRef = useRef<Set<HandlerEntry>>(new Set())
-  const parseStateRef = useRef(createAppInputParseState())
-  const flushTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-  const dispatch = useCallback((event: AppInputEvent) => {
-    for (const entry of handlersRef.current) {
-      if (!entry.isActiveRef.current) continue
-      entry.handlerRef.current(event.input, event.key, event)
-    }
-  }, [])
+export type InputHandler = (input: string, key: Key) => void
 
-  const flushPending = useCallback(() => {
-    flushTimerRef.current = null
-    const result = parseAppInput(parseStateRef.current, null)
-    parseStateRef.current = result.state
-    for (const event of result.events) dispatch(event)
-  }, [dispatch])
-
-  const scheduleFlush = useCallback(() => {
-    if (flushTimerRef.current) clearTimeout(flushTimerRef.current)
-    flushTimerRef.current = setTimeout(flushPending, PENDING_ESCAPE_FLUSH_MS)
-  }, [flushPending])
-
-  useEffect(() => {
-    if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') return
-
-    const handleData = (chunk: Buffer | string) => {
-      logRawChunk(chunk)
-      if (flushTimerRef.current) {
-        clearTimeout(flushTimerRef.current)
-        flushTimerRef.current = null
-      }
-      const result = parseAppInput(parseStateRef.current, chunk)
-      parseStateRef.current = result.state
-      for (const event of result.events) dispatch(event)
-      if (hasPendingAppInput(parseStateRef.current)) scheduleFlush()
-    }
-
-    stdin.setEncoding('utf8')
-    stdin.setRawMode(true)
-    stdin.ref()
-    stdin.on('data', handleData)
-    stdin.resume()
-    stdout.write(BRACKETED_PASTE_ENABLE)
-    stdout.write(ENABLE_KITTY_KEYBOARD)
-    stdout.write(ENABLE_MODIFY_OTHER_KEYS)
-
-    return () => {
-      if (flushTimerRef.current) clearTimeout(flushTimerRef.current)
-      stdout.write(DISABLE_MODIFY_OTHER_KEYS)
-      stdout.write(DISABLE_KITTY_KEYBOARD)
-      stdout.write(BRACKETED_PASTE_DISABLE)
-      stdin.off('data', handleData)
-      stdin.setRawMode(false)
-      stdin.pause()
-      stdin.unref()
-    }
-  }, [dispatch, scheduleFlush, stdin, stdout])
-
-  const value = useMemo<AppInputContextValue>(() => ({
-    register(entry) {
-      handlersRef.current.add(entry)
-      return () => {
-        handlersRef.current.delete(entry)
-      }
-    },
-  }), [])
-
-  return <AppInputContext.Provider value={value}>{children}</AppInputContext.Provider>
+export type UseAppInputOptions = {
+  isActive?: boolean
 }
 
-export function useAppInput(
-  handler: InputHandler,
-  options: { isActive?: boolean } = {},
-): void {
-  const ctx = useContext(AppInputContext)
-  if (!ctx) throw new Error('Hook useAppInput must be used inside AppInputProvider')
-
-  const handlerRef = useRef(handler)
-  const isActiveRef = useRef(options.isActive !== false)
-
-  useEffect(() => { handlerRef.current = handler }, [handler])
-  useEffect(() => { isActiveRef.current = options.isActive !== false }, [options.isActive])
-  useEffect(() => ctx.register({ handlerRef, isActiveRef }), [ctx])
+// Thin wrapper over Ink's built-in useInput. Ink's parseKeypress already decodes
+// modified arrows (shift/ctrl/meta), Home/End, and the Kitty keyboard protocol, so
+// we no longer hand-roll terminal escape-sequence parsing or manage raw mode here.
+export function useAppInput(handler: InputHandler, options: UseAppInputOptions = {}): void {
+  useInput(handler, options)
 }

package/src/cli/main.tsx

@@ -7,7 +7,6 @@ import { fileURLToPath } from 'node:url'
 import { theme } from '../ui/theme.js'
 import { Spinner } from '../ui/Spinner.js'
 import { KeybindingProvider } from '../app/keybindings/KeybindingProvider.js'
-import { AppInputProvider } from '../app/input/AppInputProvider.js'
 import { IdentityManager } from '../identity/manager/IdentityManager.js'
 import type { IdentityManagerResult } from '../identity/manager/IdentityManager.js'
 import { loadConfig, saveConfig, type EthagentConfig } from '../storage/config.js'
@@ -114,11 +113,9 @@ const Root: React.FC<RootProps> = ({ setExit, initialConfig }) => {
 async function renderHub(initialConfig: EthagentConfig | null | undefined): Promise<number> {
   let exitCode = 0
   const instance = render(
-    <AppInputProvider>
-      <KeybindingProvider>
-        <Root setExit={n => { exitCode = n }} initialConfig={initialConfig} />
-      </KeybindingProvider>
-    </AppInputProvider>,
+    <KeybindingProvider>
+      <Root setExit={n => { exitCode = n }} initialConfig={initialConfig} />
+    </KeybindingProvider>,
     { exitOnCtrlC: false },
   )
   const guard = (reason: unknown): void => {

package/src/cli/reset.ts

@@ -1,7 +1,6 @@
 import React from 'react'
 import { render } from 'ink'
 import { stdout, stderr } from 'node:process'
-import { AppInputProvider } from '../app/input/AppInputProvider.js'
 import { ResetConfirmView } from './ResetConfirmView.js'
 import { resetPlan, runReset } from '../storage/reset.js'
 import { clearHarnessManagedBlocks } from './syncAdapters/index.js'
@@ -44,14 +43,10 @@ async function finishReset(): Promise<void> {
 async function confirmWithInk(configDir: string, secretAccounts: string[]): Promise<boolean> {
   let confirmed = false
   const instance = render(
-    React.createElement(
-      AppInputProvider,
-      null,
-      React.createElement(ResetConfirmView, {
-        plan: { configDir, secretAccounts },
-        onDone: (value: boolean) => { confirmed = value },
-      }),
-    ),
+    React.createElement(ResetConfirmView, {
+      plan: { configDir, secretAccounts },
+      onDone: (value: boolean) => { confirmed = value },
+    }),
     { exitOnCtrlC: false },
   )
   try {

package/src/ui/Select.tsx

@@ -1,6 +1,6 @@
 import React, { useEffect, useMemo, useState } from 'react'
 import { Box, Text } from 'ink'
-import { theme, PANEL_WIDTH } from './theme.js'
+import { theme, PANEL_WIDTH, gradientColor } from './theme.js'
 import { useAppInput } from '../app/input/AppInputProvider.js'
 
 const CONTENT_WIDTH = PANEL_WIDTH - 4
@@ -11,6 +11,10 @@ function fitHint(hint: string, budget: number): string {
   return `${hint.slice(0, budget - 1)}…`
 }
 
+function rainbowColor(index: number, total: number): string {
+  return gradientColor(total <= 1 ? 0 : index / (total - 1))
+}
+
 export type SelectOption<T> = {
   value: T
   label: string
@@ -135,17 +139,18 @@ export function Select<T>({
         const belowHintText = belowHint
           ? fitHint(option.hint ?? '', CONTENT_WIDTH - rowIndent - 2)
           : ''
-        const showHeadHighlight = isActive && selectable && !isSection && option.label.length > 0
+        const showActiveGradient = isActive && selectable && !isSection && option.label.length > 0
         return (
           <Box key={absoluteIndex} flexDirection="column">
             <Box flexDirection="row" marginLeft={rowIndent}>
               <Text color={prefixColor}>{cursor} </Text>
               {prefix ? <Text color={prefixColor}>{prefix}</Text> : null}
-              {showHeadHighlight ? (
-                <>
-                  <Text color={theme.accentHighlight} bold>{option.label[0]}</Text>
-                  <Text color={labelColor} bold={bold}>{option.label.slice(1)}</Text>
-                </>
+              {showActiveGradient ? (
+                <Text>
+                  {option.label.split('').map((ch, ci) => (
+                    <Text key={ci} color={rainbowColor(ci, option.label.length)}>{ch}</Text>
+                  ))}
+                </Text>
               ) : (
                 <Text color={labelColor} bold={bold}>{option.label}</Text>
               )}

package/src/ui/TextArea.tsx

@@ -78,6 +78,15 @@ export function TextArea({
       setCursor(lineStart)
       return
     }
+    if (key.home || (key.ctrl && input === 'a')) {
+      setCursor(Math.max(0, val.lastIndexOf('\n', cur - 1) + 1))
+      return
+    }
+    if (key.end || (key.ctrl && input === 'e')) {
+      const nextNewline = val.indexOf('\n', cur)
+      setCursor(nextNewline === -1 ? val.length : nextNewline)
+      return
+    }
     if (key.ctrl || key.meta || key.tab) return
     if (input) {
       const clean = input.replace(/\r/g, '')

package/src/ui/TextInput.tsx

@@ -109,6 +109,14 @@ export function TextInput({
       if (error) setError(null)
       return
     }
+    if (key.home || (key.ctrl && input === 'a')) {
+      setCursor(0)
+      return
+    }
+    if (key.end || (key.ctrl && input === 'e')) {
+      setCursor(val.length)
+      return
+    }
     if (key.ctrl || key.meta || key.upArrow || key.downArrow || key.tab) {
       return
     }

package/src/app/input/appInputParser.ts

@@ -1,294 +0,0 @@
-import type { Key } from 'ink'
-
-export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
-export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
-export const BRACKETED_PASTE_START = '\x1b[200~'
-export const BRACKETED_PASTE_END = '\x1b[201~'
-export const ENABLE_KITTY_KEYBOARD = '\x1b[>1u'
-export const DISABLE_KITTY_KEYBOARD = '\x1b[<u'
-export const ENABLE_MODIFY_OTHER_KEYS = '\x1b[>4;2m'
-export const DISABLE_MODIFY_OTHER_KEYS = '\x1b[>4m'
-
-export type AppInputEvent = {
-  input: string
-  key: Key
-  isPasted: boolean
-  raw: string
-}
-
-export type AppInputParseState = {
-  mode: 'normal' | 'paste'
-  pending: string
-  pasteBuffer: string
-}
-
-type ParseResult = {
-  events: AppInputEvent[]
-  state: AppInputParseState
-}
-
-const ESC = '\x1b'
-const CSI_U_RE = /^\x1b\[(\d+)(?:;(\d+))?u/
-const MODIFY_OTHER_KEYS_RE = /^\x1b\[27;(\d+);(\d+)~/
-
-const KNOWN_SEQUENCES: Array<{ sequence: string; key: Partial<Key> }> = [
-  { sequence: '\x1b[A', key: { upArrow: true } },
-  { sequence: '\x1b[B', key: { downArrow: true } },
-  { sequence: '\x1b[C', key: { rightArrow: true } },
-  { sequence: '\x1b[D', key: { leftArrow: true } },
-  { sequence: '\x1b[Z', key: { tab: true, shift: true } },
-  { sequence: '\x1b[3~', key: { delete: true } },
-  { sequence: '\x1b[5~', key: { pageUp: true } },
-  { sequence: '\x1b[6~', key: { pageDown: true } },
-  { sequence: '\x1b[H', key: { home: true } },
-  { sequence: '\x1b[F', key: { end: true } },
-]
-
-const PENDING_PREFIXES = [
-  BRACKETED_PASTE_START,
-  BRACKETED_PASTE_END,
-  ...KNOWN_SEQUENCES.map(entry => entry.sequence),
-  '\x1b[13;2u',
-  '\x1b[27;2;13~',
-]
-
-export function createAppInputParseState(): AppInputParseState {
-  return { mode: 'normal', pending: '', pasteBuffer: '' }
-}
-
-export function hasPendingAppInput(state: AppInputParseState): boolean {
-  return state.pending.length > 0
-}
-
-export function parseAppInput(
-  previous: AppInputParseState,
-  chunk: Buffer | string | null,
-): ParseResult {
-  const source = previous.pending + (chunk === null ? '' : stringifyChunk(chunk))
-  const events: AppInputEvent[] = []
-  const state: AppInputParseState = {
-    mode: previous.mode,
-    pending: '',
-    pasteBuffer: previous.pasteBuffer,
-  }
-
-  let rest = source
-  while (rest.length > 0) {
-    if (state.mode === 'paste') {
-      const endIndex = rest.indexOf(BRACKETED_PASTE_END)
-      if (endIndex === -1) {
-        const pending = chunk === null ? '' : longestSuffixPrefix(rest, [BRACKETED_PASTE_END])
-        state.pasteBuffer += rest.slice(0, rest.length - pending.length)
-        state.pending = pending
-        rest = ''
-        break
-      }
-
-      state.pasteBuffer += rest.slice(0, endIndex)
-      events.push(createInputEvent(state.pasteBuffer, {}, state.pasteBuffer, true))
-      state.mode = 'normal'
-      state.pasteBuffer = ''
-      rest = rest.slice(endIndex + BRACKETED_PASTE_END.length)
-      continue
-    }
-
-    if (rest.startsWith(BRACKETED_PASTE_START)) {
-      state.mode = 'paste'
-      state.pasteBuffer = ''
-      rest = rest.slice(BRACKETED_PASTE_START.length)
-      continue
-    }
-
-    if (rest.startsWith(BRACKETED_PASTE_END)) {
-      rest = rest.slice(BRACKETED_PASTE_END.length)
-      continue
-    }
-
-    const parsed = parseNormalInput(rest, chunk === null)
-    if (parsed.kind === 'pending') {
-      state.pending = parsed.pending
-      rest = ''
-      break
-    }
-    events.push(parsed.event)
-    rest = rest.slice(parsed.length)
-  }
-
-  return { events, state }
-}
-
-type NormalParseResult =
-  | { kind: 'event'; event: AppInputEvent; length: number }
-  | { kind: 'pending'; pending: string }
-
-function parseNormalInput(source: string, flushing: boolean): NormalParseResult {
-  if (!source.startsWith(ESC)) {
-    const nextEscape = source.indexOf(ESC)
-    const text = nextEscape === -1 ? source : source.slice(0, nextEscape)
-    return { kind: 'event', event: createTextEvent(text), length: text.length }
-  }
-
-  if (!flushing && isPendingPrefix(source)) {
-    return { kind: 'pending', pending: source }
-  }
-
-  const csiU = CSI_U_RE.exec(source)
-  if (csiU) {
-    const codepoint = Number(csiU[1])
-    const modifier = csiU[2] ? Number(csiU[2]) : 1
-    return {
-      kind: 'event',
-      event: keycodeEvent(csiU[0], codepoint, modifier),
-      length: csiU[0].length,
-    }
-  }
-
-  const modifyOtherKeys = MODIFY_OTHER_KEYS_RE.exec(source)
-  if (modifyOtherKeys) {
-    return {
-      kind: 'event',
-      event: keycodeEvent(
-        modifyOtherKeys[0],
-        Number(modifyOtherKeys[2]),
-        Number(modifyOtherKeys[1]),
-      ),
-      length: modifyOtherKeys[0].length,
-    }
-  }
-
-  const known = KNOWN_SEQUENCES.find(entry => source.startsWith(entry.sequence))
-  if (known) {
-    return {
-      kind: 'event',
-      event: createInputEvent('', known.key, known.sequence),
-      length: known.sequence.length,
-    }
-  }
-
-  if (source.startsWith('\x1b\r') || source.startsWith('\x1b\n')) {
-    return {
-      kind: 'event',
-      event: createInputEvent('', { meta: true, return: true }, source.slice(0, 2)),
-      length: 2,
-    }
-  }
-
-  if (source.length >= 2) {
-    const next = source.slice(1, 2)
-    const code = next.charCodeAt(0)
-    const altInput = code >= 0x20 && code <= 0x7e ? next : ''
-    return {
-      kind: 'event',
-      event: createInputEvent(altInput, { meta: true }, source.slice(0, 2)),
-      length: 2,
-    }
-  }
-
-  return {
-    kind: 'event',
-    event: createInputEvent('', { escape: true, meta: true }, ESC),
-    length: 1,
-  }
-}
-
-const PRINTABLE_CHAR_RE = /[\p{L}\p{N}\p{M}\p{P}\p{S}\p{Z}]/u
-
-function stripNoise(text: string): string {
-  let out = ''
-  for (const ch of text) {
-    if (ch === '\uFFFD') continue
-    if (!PRINTABLE_CHAR_RE.test(ch)) continue
-    out += ch
-  }
-  return out
-}
-
-function createTextEvent(text: string): AppInputEvent {
-  if (text === '\r' || text === '\n') return createInputEvent('', { return: true }, text)
-  if (text === '\t') return createInputEvent('', { tab: true }, text)
-  if (text === '\x7f' || text === '\b') return createInputEvent('', { backspace: true }, text)
-  if (text.length === 1) {
-    const code = text.charCodeAt(0)
-    if (code > 0 && code <= 26) {
-      return createInputEvent(
-        String.fromCharCode('a'.charCodeAt(0) + code - 1),
-        { ctrl: true },
-        text,
-      )
-    }
-    if (/[A-Z]/.test(text)) return createInputEvent(text, { shift: true }, text)
-  }
-  const cleaned = stripNoise(text)
-  return createInputEvent(cleaned, {}, text)
-}
-
-function keycodeEvent(raw: string, codepoint: number, modifier: number): AppInputEvent {
-  const key = decodeModifier(modifier)
-  if (codepoint === 9)  return createInputEvent('', { ...key, tab: true }, raw)
-  if (codepoint === 13) return createInputEvent('', { ...key, return: true }, raw)
-  if (codepoint === 27) return createInputEvent('', { ...key, escape: true, meta: true }, raw)
-  const printable = codepoint >= 0x20 && codepoint <= 0x7e
-  return createInputEvent(printable ? String.fromCodePoint(codepoint) : '', key, raw)
-}
-
-function decodeModifier(modifier: number): Partial<Key> {
-  const normalized = Math.max(1, modifier) - 1
-  return {
-    shift: Boolean(normalized & 1),
-    meta: Boolean(normalized & 2),
-    ctrl: Boolean(normalized & 4),
-    super: Boolean(normalized & 8),
-  }
-}
-
-function createInputEvent(
-  input: string,
-  key: Partial<Key>,
-  raw: string,
-  isPasted = false,
-): AppInputEvent {
-  return {
-    input,
-    key: {
-      upArrow: false,
-      downArrow: false,
-      leftArrow: false,
-      rightArrow: false,
-      pageDown: false,
-      pageUp: false,
-      home: false,
-      end: false,
-      return: false,
-      escape: false,
-      ctrl: false,
-      shift: false,
-      tab: false,
-      backspace: false,
-      delete: false,
-      meta: false,
-      ...key,
-    } as Key,
-    raw,
-    isPasted,
-  }
-}
-
-function stringifyChunk(chunk: Buffer | string): string {
-  return Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk
-}
-
-function isPendingPrefix(source: string): boolean {
-  return PENDING_PREFIXES.some(sequence => sequence.startsWith(source) && sequence !== source)
-}
-
-function longestSuffixPrefix(source: string, markers: string[]): string {
-  let best = ''
-  for (const marker of markers) {
-    const maxLength = Math.min(source.length, marker.length - 1)
-    for (let length = 1; length <= maxLength; length += 1) {
-      const suffix = source.slice(source.length - length)
-      if (marker.startsWith(suffix) && suffix.length > best.length) best = suffix
-    }
-  }
-  return best
-}