openAgent

1import { dlopen, ptr } from "bun:ffi"
2import type { ReadStream } from "node:tty"
3 
4const STD_INPUT_HANDLE = -10
5const ENABLE_PROCESSED_INPUT = 0x0001
6 
7const kernel = () =>
8  dlopen("kernel32.dll", {
9    GetStdHandle: { args: ["i32"], returns: "ptr" },
10    GetConsoleMode: { args: ["ptr", "ptr"], returns: "i32" },
11    SetConsoleMode: { args: ["ptr", "u32"], returns: "i32" },
12    FlushConsoleInputBuffer: { args: ["ptr"], returns: "i32" },
13  })
14 
15let k32: ReturnType<typeof kernel> | undefined
16 
17function load() {
18  if (process.platform !== "win32") return false
19  try {
20    k32 ??= kernel()
21    return true
22  } catch {
23    return false
24  }
25}
26 
27/**
28 * Clear ENABLE_PROCESSED_INPUT on the console stdin handle.
29 */
30export function win32DisableProcessedInput() {
31  if (process.platform !== "win32") return
32  if (!process.stdin.isTTY) return
33  if (!load()) return
34 
35  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
36  const buf = new Uint32Array(1)
37  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
38 
39  const mode = buf[0]!
40  if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
41  k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
42}
43 
44/**
45 * Discard any queued console input (mouse events, key presses, etc.).
46 */
47export function win32FlushInputBuffer() {
48  if (process.platform !== "win32") return
49  if (!process.stdin.isTTY) return
50  if (!load()) return
51 
52  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
53  k32!.symbols.FlushConsoleInputBuffer(handle)
54}
55 
56let unhook: (() => void) | undefined
57 
58/**
59 * Keep ENABLE_PROCESSED_INPUT disabled.
60 *
61 * On Windows, Ctrl+C becomes a CTRL_C_EVENT (instead of stdin input) when
62 * ENABLE_PROCESSED_INPUT is set. Various runtimes can re-apply console modes
63 * (sometimes on a later tick), and the flag is console-global, not per-process.
64 *
65 * We combine:
66 * - A `setRawMode(...)` hook to re-clear after known raw-mode toggles.
67 * - A low-frequency poll as a backstop for native/external mode changes.
68 */
69export function win32InstallCtrlCGuard() {
70  if (process.platform !== "win32") return
71  if (!process.stdin.isTTY) return
72  if (!load()) return
73  if (unhook) return unhook
74 
75  const stdin = process.stdin as ReadStream
76  const original = stdin.setRawMode
77 
78  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
79  const buf = new Uint32Array(1)
80 
81  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
82  const initial = buf[0]!
83 
84  const enforce = () => {
85    if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
86    const mode = buf[0]!
87    if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
88    k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
89  }
90 
91  // Some runtimes can re-apply console modes on the next tick; enforce twice.
92  const later = () => {
93    enforce()
94    setImmediate(enforce)
95  }
96 
97  let wrapped: ReadStream["setRawMode"] | undefined
98 
99  if (typeof original === "function") {
100    wrapped = (mode: boolean) => {
101      const result = original.call(stdin, mode)
102      later()
103      return result
104    }
105 
106    stdin.setRawMode = wrapped
107  }
108 
109  // Ensure it's cleared immediately too (covers any earlier mode changes).
110  later()
111 
112  const interval = setInterval(enforce, 100)
113  interval.unref()
114 
115  let done = false
116  unhook = () => {
117    if (done) return
118    done = true
119 
120    clearInterval(interval)
121    if (wrapped && stdin.setRawMode === wrapped) {
122      stdin.setRawMode = original
123    }
124 
125    k32!.symbols.SetConsoleMode(handle, initial)
126    unhook = undefined
127  }
128 
129  return unhook
130}
131