fix(win32): use ffi to get around bun raw input/ctrl+c issues

[Hona]

No description provided.

[github-actions]

Hey! Your PR title experiment: use ffi to get around bun raw input/ctrl+c issues doesn't follow conventional commit format.

Please update it to start with one of:

• feat: or feat(scope): new feature
• fix: or fix(scope): bug fix
• docs: or docs(scope): documentation changes
• chore: or chore(scope): maintenance tasks
• refactor: or refactor(scope): code refactoring
• test: or test(scope): adding or updating tests

Where scope is the package name (e.g., app, desktop, opencode).

See CONTRIBUTING.md for details.

[github-actions]

The following comment was made by an LLM, it may be inaccurate:

Found a potentially related PR:

• fix(opencode): require double Ctrl+C to exit in TUI #12733 - fix(opencode): require double Ctrl+C to exit in TUI
  • This PR directly addresses Ctrl+C handling in the TUI, which is the same issue that PR fix(win32): use ffi to get around bun raw input/ctrl+c issues #13052 is trying to solve using FFI as a workaround.

The other PRs found are related to keybinding and input handling but don't appear to be addressing the specific FFI workaround or Ctrl+C raw input issues that PR #13052 is tackling.

[opencode-agent]

⚠️ Blocking Beta Release

This PR cannot be merged into the beta branch due to: Merge conflicts with dev branch

Please resolve this issue to include this PR in the next beta release.

[Copilot]

Pull request overview

Adds a Windows-specific Bun FFI workaround to prevent CTRL_C_EVENT from killing the shared console process group (notably when running under bun run), by clearing ENABLE_PROCESSED_INPUT, ignoring Ctrl+C at the OS level, and optionally re-enforcing the console mode during the TUI lifecycle.

Changes:

• Add win32.ts (Bun FFI wrapper around kernel32.dll) to manipulate Windows console mode and Ctrl+C handling.
• Invoke the Win32 console tweaks very early in CLI startup and again within TUI initialization.
• Start a polling guard in the TUI app to re-clear ENABLE_PROCESSED_INPUT if opentui/native calls re-enable it.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 4 comments.

File	Description
packages/opencode/src/index.ts	Calls Win32 Ctrl+C mitigations at top-level during CLI startup.
packages/opencode/src/cli/cmd/tui/win32.ts	Introduces Bun FFI helpers for Windows console mode/Ctrl+C behavior and a polling enforcement loop.
packages/opencode/src/cli/cmd/tui/thread.ts	Disables processed input early in the TUI thread command handler before worker startup.
packages/opencode/src/cli/cmd/tui/app.tsx	Re-applies Win32 settings around raw mode toggles and starts the polling enforcement on mount.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

win32IgnoreCtrlC() permanently disables Ctrl+C delivery for the process (and there’s no corresponding restore). That can leave users unable to interrupt the program and can also affect shutdown events. Consider adding a restore function (e.g. call SetConsoleCtrlHandler(NULL, FALSE)) and ensuring it runs on cleanup/exit.

[Copilot]

win32EnforceCtrlCGuard() starts a polling interval but doesn’t return a handle or provide a way to stop it. Consider returning the interval id (and possibly calling .unref() if supported) so callers can clear it on exit/unmount to avoid leaking timers.

Suggested change

	export function win32EnforceCtrlCGuard() {
	if (process.platform !== "win32") return
	if (!process.stdin.isTTY) return
	if (!load()) return
	const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
	const buf = new Uint32Array(1)
	setInterval(() => {
	if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
	const mode = buf[0]!
	if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
	k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
	}, 100)
	export function win32EnforceCtrlCGuard(): ReturnType<typeof setInterval> | undefined {
	if (process.platform !== "win32") return undefined
	if (!process.stdin.isTTY) return undefined
	if (!load()) return undefined
	const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
	const buf = new Uint32Array(1)
	const interval = setInterval(() => {
	if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
	const mode = buf[0]!
	if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
	k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
	}, 100)
	// Allow the process to exit naturally even if this interval is active.
	;(interval as any)?.unref?.()
	return interval

[Copilot]

win32EnforceCtrlCGuard() is started on mount but never stopped. If the TUI unmounts/remounts or if tui() is used in a context that doesn’t hard-exit the process, this will accumulate intervals. Consider capturing the interval id and clearing it in an onCleanup/exit handler.

[Copilot]

These top-level calls make the entire CLI ignore Ctrl+C on Windows TTYs (via SetConsoleCtrlHandler), which breaks interruption for non-TUI commands like opencode serve (it awaits forever). Consider scoping this to the TUI entrypoints only and/or restoring the previous Ctrl+C behavior on exit so other commands remain stoppable.

Suggested change

	// Disable Windows CTRL_C_EVENT as early as possible. When running under
	// `bun run` (e.g. `bun dev`), the parent bun process shares this console
	// and would be killed by the OS before any JS signal handler fires.
	win32DisableProcessedInput()
	// Belt-and-suspenders: even if something re-enables ENABLE_PROCESSED_INPUT
	// later (opentui raw mode, libuv, etc.), ignore the generated event.
	win32IgnoreCtrlC()
	// Disable Windows CTRL_C_EVENT as early as possible, but only for TUI
	// entrypoints. When running under `bun run` (e.g. `bun dev`), the parent
	// bun process shares this console and would be killed by the OS before
	// any JS signal handler fires. Restricting this behavior to TUI commands
	// avoids breaking Ctrl+C for non-TUI commands like `opencode serve`.
	if (process.platform === "win32") {
	const argv = hideBin(process.argv)
	const cmd = argv[0]
	const sub = argv[1]
	// TUI entrypoints:
	// - `opencode attach`
	// - `opencode tui thread`
	// - (optional alias) `opencode tui-thread`
	const isTuiCommand =
	cmd === "attach" ||
	(cmd === "tui" && sub === "thread") ||
	cmd === "tui-thread"
	if (isTuiCommand) {
	win32DisableProcessedInput()
	// Belt-and-suspenders: even if something re-enables ENABLE_PROCESSED_INPUT
	// later (opentui raw mode, libuv, etc.), ignore the generated event.
	win32IgnoreCtrlC()
	}
	}

[github-actions]

Thanks for your contribution!

This PR doesn't have a linked issue. All PRs must reference an existing issue.

Please:

1. Open an issue describing the bug/feature (if one doesn't exist)
2. Add Fixes #<number> or Closes #<number> to this PR description

See CONTRIBUTING.md for details.

[rekram1-node]

lgtm