typeclaw 0.37.3 → 0.37.5

package/src/tui/index.ts

@@ -23,6 +23,7 @@ import {
   formatUserPromptHistory,
   withTimestamp,
 } from './format'
+import { armTerminalGuard } from './terminal-guard'
 import { colors, editorTheme, markdownTheme } from './theme'
 
 export type ClientFactory = (url: string) => Promise<Client>
@@ -103,6 +104,10 @@ export function createTui({
     const status = new Text(colors.dim(`connecting to ${displayUrl}...`), 0, 0)
     tui.addChild(status)
     tui.start()
+    // Armed once the terminal is in raw mode + Kitty kbd protocol: restores the
+    // terminal on an abnormal exit (SSH SIGHUP, kill, crash) that never reaches
+    // tui.stop(), so the shell isn't left echoing Kitty key-release events.
+    const guard = armTerminalGuard()
     tui.requestRender()
 
     // Pre-handshake failures resolve 'connectFailed' (not throw): the standalone
@@ -113,6 +118,7 @@ export function createTui({
       status.setText(colors.red(`connection error: ${err instanceof Error ? err.message : String(err)}`))
       tui.requestRender()
       tui.stop()
+      guard.disarm()
       exit(1)
       return null
     })
@@ -124,6 +130,7 @@ export function createTui({
       tui.requestRender()
       client.close()
       tui.stop()
+      guard.disarm()
       exit(1)
       return null
     })
@@ -418,21 +425,32 @@ export function createTui({
     // Settle BEFORE closing the client: client.close() fires onClose, which
     // settles 'lostConnection'. settle() is idempotent, so the first call wins —
     // settling the deliberate outcome first keeps the later onClose a no-op.
-    const teardown = (): void => {
-      stopAllLoaders()
-      tui.stop()
-      client.close()
+    // drainInput() runs before stop() so late Kitty key-release bytes (the keys
+    // that triggered the exit) are swallowed instead of leaking to the shell
+    // over a slow SSH link. The promise is memoized so repeated callers (a
+    // fire-and-forget detach/exit plus the end-of-run await) share ONE teardown
+    // and the end-of-run await truly blocks until draining finishes — otherwise
+    // the next clack picker could start reading stdin mid-drain.
+    let teardownPromise: Promise<void> | null = null
+    const teardown = (): Promise<void> => {
+      teardownPromise ??= (async () => {
+        stopAllLoaders()
+        await terminal.drainInput().catch(() => {})
+        tui.stop()
+        client.close()
+        guard.disarm()
+      })()
+      return teardownPromise
     }
 
     const exitWith = (code: number): void => {
       settle({ reason: 'exit', exitCode: code })
-      teardown()
-      exit(code)
+      void teardown().finally(() => exit(code))
     }
 
     const detach = (): void => {
       settle({ reason: 'detach' })
-      teardown()
+      void teardown()
     }
 
     // Ctrl+C exits the client. In raw mode the kernel does NOT generate SIGINT,
@@ -490,7 +508,7 @@ export function createTui({
     }
 
     const result = await outcome
-    tui.stop()
+    await teardown()
     return result
   }
 

package/src/tui/terminal-guard.ts

@@ -0,0 +1,139 @@
+import { writeSync } from 'node:fs'
+
+// Mirrors pi-tui ProcessTerminal.stop()'s resets so an abnormal exit (SSH
+// SIGHUP, a frozen TUI the user kills, a crash, or a Bun process.exit() that
+// drops pi-tui's buffered stop() writes) can't leave the parent shell with the
+// Kitty keyboard protocol still on. While on, the terminal emits CSI-u
+// key-RELEASE events (`;1:3u`) for every keystroke, corrupting the shell. Order
+// matches stop(): pop Kitty kbd protocol, disable xterm modifyOtherKeys, disable
+// bracketed paste, end synchronized output, show cursor.
+export const RESTORE_SEQUENCE = '\x1b[<u\x1b[>4;0m\x1b[?2004l\x1b[?2026l\x1b[?25h'
+
+const STDOUT_FD = 1
+
+const SCOPED_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'] as const
+export type ScopedSignal = (typeof SCOPED_SIGNALS)[number]
+
+const SIGNAL_EXIT_CODE: Record<ScopedSignal, number> = {
+  SIGINT: 130,
+  SIGTERM: 143,
+  SIGHUP: 129,
+}
+
+export type TerminalGuardDeps = {
+  isTty: boolean
+  writeStdout: (seq: string) => void
+  setRawMode: (mode: boolean) => void
+  on: (event: string, handler: (...args: unknown[]) => void) => void
+  off: (event: string, handler: (...args: unknown[]) => void) => void
+  killSelf: (signal: ScopedSignal) => void
+  exit: (code: number) => void
+}
+
+export type TerminalGuard = {
+  arm: () => void
+  disarm: () => void
+}
+
+export function createTerminalGuard(deps: TerminalGuardDeps): TerminalGuard {
+  let armed = 0
+  let exitInstalled = false
+  let signalHandlers: Map<ScopedSignal, (...args: unknown[]) => void> | null = null
+
+  const restore = (): void => {
+    if (!deps.isTty) return
+    deps.writeStdout(RESTORE_SEQUENCE)
+    deps.setRawMode(false)
+  }
+
+  const onExit = (): void => {
+    restore()
+  }
+
+  const installSignalHandlers = (): void => {
+    if (signalHandlers !== null) return
+    const handlers = new Map<ScopedSignal, (...args: unknown[]) => void>()
+    for (const sig of SCOPED_SIGNALS) {
+      const handler = (): void => {
+        // Restore the terminal, then let the signal terminate with default
+        // semantics. Remove our handlers first so the re-raised signal isn't
+        // swallowed by this same handler; fall back to an explicit exit if the
+        // re-raise somehow doesn't terminate.
+        removeSignalHandlers()
+        restore()
+        deps.killSelf(sig)
+        deps.exit(SIGNAL_EXIT_CODE[sig])
+      }
+      deps.on(sig, handler)
+      handlers.set(sig, handler)
+    }
+    signalHandlers = handlers
+  }
+
+  const removeSignalHandlers = (): void => {
+    if (signalHandlers === null) return
+    for (const [sig, handler] of signalHandlers) deps.off(sig, handler)
+    signalHandlers = null
+  }
+
+  return {
+    arm: () => {
+      // A non-TTY process (piped/redirected, or the test runner) has no terminal
+      // state to protect, so the guard stays fully inert — it never touches the
+      // real process signal/exit handlers.
+      if (!deps.isTty) return
+      armed += 1
+      if (!exitInstalled) {
+        deps.on('exit', onExit)
+        exitInstalled = true
+      }
+      installSignalHandlers()
+    },
+    disarm: () => {
+      if (!deps.isTty) return
+      if (armed > 0) armed -= 1
+      if (armed === 0) removeSignalHandlers()
+    },
+  }
+}
+
+let defaultGuard: TerminalGuard | null = null
+
+function getDefaultGuard(): TerminalGuard {
+  defaultGuard ??= createTerminalGuard({
+    isTty: Boolean(process.stdout.isTTY),
+    writeStdout: (seq) => {
+      try {
+        writeSync(STDOUT_FD, seq)
+      } catch {
+        /* fd closed mid-teardown */
+      }
+    },
+    setRawMode: (mode) => {
+      try {
+        process.stdin.setRawMode?.(mode)
+      } catch {
+        /* terminal already torn down */
+      }
+    },
+    on: (event, handler) => {
+      process.on(event as NodeJS.Signals, handler)
+    },
+    off: (event, handler) => {
+      process.off(event as NodeJS.Signals, handler)
+    },
+    killSelf: (signal) => {
+      process.kill(process.pid, signal)
+    },
+    exit: (code) => {
+      process.exit(code)
+    },
+  })
+  return defaultGuard
+}
+
+export function armTerminalGuard(): TerminalGuard {
+  const guard = getDefaultGuard()
+  guard.arm()
+  return guard
+}

package/typeclaw.schema.json

@@ -1669,7 +1669,7 @@
       "default": {
         "enabled": true,
         "imageMaxBytes": 262144,
-        "textMaxBytes": 65536,
+        "textMaxBytes": 32768,
         "exemptTools": []
       },
       "type": "object",
@@ -1685,7 +1685,7 @@
           "maximum": 9007199254740991
         },
         "textMaxBytes": {
-          "default": 65536,
+          "default": 32768,
           "type": "integer",
           "minimum": 1024,
           "maximum": 9007199254740991