bubbletea/tty.go
Johnny Chen bc55190481
fix: synchronize canceled input cleanup (#1876)
AI-assisted-by: Codex (GPT 6.1 sol)
Co-authored-by: Drew Smirnoff <drew@charm.land>
Signed-off-by: Drew Smirnoff <drew@charm.land>
2026-11-20 18:44:32 +04:00

228 lines
5.6 KiB
Go

package tea
import (
"context"
"fmt"
"os"
"strconv"
"time"
uv "github.com/charmbracelet/ultraviolet"
"github.com/charmbracelet/x/term"
)
func (p *Program) suspend() {
if err := p.releaseTerminal(true); err != nil {
// If we can't release input, abort.
return
}
suspendProcess()
_ = p.RestoreTerminal()
go p.Send(ResumeMsg{})
}
func (p *Program) initTerminal() error {
if p.disableRenderer {
return nil
}
return p.initInput()
}
// restoreTerminalState restores the terminal to the state prior to running the
// Bubble Tea program.
func (p *Program) restoreTerminalState() error {
// Flush queued commands.
_ = p.flush()
return p.restoreInput()
}
// restoreInput restores the tty input to its original state.
func (p *Program) restoreInput() error {
if p.ttyInput != nil && p.previousTtyInputState != nil {
if err := term.Restore(p.ttyInput.Fd(), p.previousTtyInputState); err != nil {
return fmt.Errorf("bubbletea: error restoring console: %w", err)
}
}
if p.ttyOutput != nil && p.previousOutputState != nil {
if err := term.Restore(p.ttyOutput.Fd(), p.previousOutputState); err != nil {
return fmt.Errorf("bubbletea: error restoring console: %w", err)
}
}
return nil
}
// initInputReader (re)commences reading inputs.
func (p *Program) initInputReader(cancel bool) error {
if cancel && p.cancelReader != nil {
p.cancelReader.Cancel()
p.waitForReadLoop()
}
// Close the reader we are about to replace, otherwise its resources (e.g.
// the epoll file descriptor on Linux) leak on every ReleaseTerminal and
// RestoreTerminal cycle. Only close it once its read loop has exited: if
// waitForReadLoop timed out, the loop may still be using it.
if p.cancelReader != nil && p.readLoopDone != nil {
select {
case <-p.readLoopDone:
_ = p.cancelReader.Close()
default:
}
}
term := p.environ.Getenv("TERM")
// Initialize the input reader.
// This need to be done after the terminal has been initialized and set to
// raw mode.
var err error
p.cancelReader, err = uv.NewCancelReader(p.input)
if err != nil {
return fmt.Errorf("bubbletea: could not create cancelable reader: %w", err)
}
drv := uv.NewTerminalReader(p.cancelReader, term)
drv.SetLogger(p.logger)
p.inputScanner = drv
p.readLoopDone = make(chan struct{})
go p.readLoop(p.ctx, drv, p.readLoopDone, p.errs)
return nil
}
// readLoop streams input events to the program until ctx is done or reading
// fails. It takes the per-run state it uses as arguments rather than reading
// it from p: the loop can outlive [Program.shutdown], see
// [Program.shutdownInput], and must not race with a later run replacing it.
func (p *Program) readLoop(ctx context.Context, scanner *uv.TerminalReader, done chan struct{}, errs chan error) {
defer close(done)
if err := scanner.StreamEvents(ctx, p.msgs); err != nil {
select {
case <-ctx.Done():
return
case errs <- err:
}
}
}
const inputReadLoopTimeout = 500 * time.Millisecond
// shutdownInput cancels input before closing the reader's resources. Keep the
// bounded shutdown for slow readers, but retain ownership of a reader that is
// still in use until its input loop has actually finished.
func (p *Program) shutdownInput() {
reader := p.cancelReader
if reader == nil {
return
}
// The reader is closed below, or later once its input loop finishes.
// Forget it so that a later run doesn't close it again: closing it closes
// raw file descriptors, and closing one twice can close an unrelated file
// that has since reused the number.
p.cancelReader = nil
if reader.Cancel() && p.readLoopDone != nil {
done := p.readLoopDone
timer := time.NewTimer(inputReadLoopTimeout)
defer timer.Stop()
select {
case <-done:
case <-timer.C:
go func() {
<-done
_ = reader.Close()
}()
return
}
}
_ = reader.Close()
}
// waitForReadLoop waits for the cancelReader to finish its read loop.
func (p *Program) waitForReadLoop() {
select {
case <-p.readLoopDone:
case <-time.After(inputReadLoopTimeout):
// The read loop hangs, which means the input
// cancelReader's cancel function has returned true even
// though it was not able to cancel the read.
}
}
const (
defaultWidth = 80
defaultHeight = 24
)
// fallbackDimensions returns width and height, falling back to COLUMNS/LINES
// environment variables or 80x24 defaults when dimensions are non-positive.
func (p *Program) fallbackDimensions(width, height int) (int, int) {
if width <= 0 {
var cols string
if p != nil && p.environ != nil {
cols = p.environ.Getenv("COLUMNS")
} else {
cols = os.Getenv("COLUMNS")
}
if c, err := strconv.Atoi(cols); err == nil && c > 0 {
width = c
} else {
width = defaultWidth
}
}
if height <= 0 {
var lines string
if p != nil && p.environ != nil {
lines = p.environ.Getenv("LINES")
} else {
lines = os.Getenv("LINES")
}
if l, err := strconv.Atoi(lines); err == nil && l > 0 {
height = l
} else {
height = defaultHeight
}
}
return width, height
}
// checkResize detects the current size of the output and informs the program
// via a WindowSizeMsg.
func (p *Program) checkResize() {
if p.ttyOutput == nil {
// can't query window size
return
}
w, h, err := term.GetSize(p.ttyOutput.Fd())
if err != nil {
select {
case <-p.ctx.Done():
case p.errs <- err:
}
return
}
w, h = p.fallbackDimensions(w, h)
p.width, p.height = w, h
p.Send(WindowSizeMsg{Width: w, Height: h})
}
// OpenTTY opens the running terminal's TTY for reading and writing.
func OpenTTY() (*os.File, *os.File, error) {
in, out, err := uv.OpenTTY()
if err != nil {
return nil, nil, fmt.Errorf("bubbletea: could not open TTY: %w", err)
}
return in, out, nil
}