fix: cli no longer hangs when stdin is attached to a pipe with empty input

Author: stainless-app[bot]

pkg/cmd/cmdutil.go

@@ -70,9 +70,35 @@ var debugMiddlewareOption = option.WithMiddleware(
 	},
 )
 
+// isInputPiped tries to check for input being piped into the CLI which tells us that we should try to read
+// from stdin. This can be a bit tricky in some cases like when an stdin is connected to a pipe but nothing is
+// being piped in (this may happen in some environments like Cursor's integration terminal or CI), which is
+// why this function is a little more elaborate than it'd be otherwise.
 func isInputPiped() bool {
-	stat, _ := os.Stdin.Stat()
-	return (stat.Mode() & os.ModeCharDevice) == 0
+	stat, err := os.Stdin.Stat()
+	if err != nil {
+		return false
+	}
+
+	mode := stat.Mode()
+
+	// Regular file (redirect like < file.txt) — only if non-empty.
+	//
+	// Notably, on Unix the case like `< /dev/null` is handled below because `/dev/null` is not a regular
+	// file. On Windows, NUL appears as a regular file with size 0, so it's also handled correctly.
+	if mode.IsRegular() && stat.Size() > 0 {
+		return true
+	}
+
+	// For pipes/sockets (e.g. `echo foo | stainlesscli`), use an OS-specific check to determine whether
+	// data is actually available. Some environments like Cursor's integrated terminal connect stdin as a
+	// pipe even when nothing is being piped.
+	if mode&(os.ModeNamedPipe|os.ModeSocket) != 0 {
+		// Defined in either cmdutil_unix.go or cmdutil_windows.go.
+		return isPipedDataAvailableOSSpecific()
+	}
+
+	return false
 }
 
 func isTerminal(w io.Writer) bool {

pkg/cmd/cmdutil_unix.go

@@ -12,6 +12,17 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+func isPipedDataAvailableOSSpecific() bool {
+	// Try to determine if there's non-empty data being piped into the command by polling for data for a short
+	// amount of time. This is necessary because some environments (e.g. Cursor's integrated terminal) connect
+	// stdin as a pipe even when nothing is being piped, which would cause the command to block indefinitely
+	// waiting for input that will never come. The 10 ms timeout is arbitrary -- designed to be long enough to
+	// allow data to be detected, but short enough that it shouldn't cause a noticeable delay in command runs.
+	fds := []unix.PollFd{{Fd: int32(os.Stdin.Fd()), Events: unix.POLLIN}}
+	n, _ := unix.Poll(fds, 10 /* ms */)
+	return n > 0
+}
+
 func streamOutputOSSpecific(label string, generateOutput func(w *os.File) error) error {
 	// Try to use socket pair for better buffer control
 	pagerInput, pid, err := openSocketPairPager(label)

pkg/cmd/cmdutil_windows.go

@@ -2,7 +2,31 @@
 
 package cmd
 
-import "os"
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	kernel32          = syscall.NewLazyDLL("kernel32.dll")
+	procPeekNamedPipe = kernel32.NewProc("PeekNamedPipe")
+)
+
+func isPipedDataAvailableOSSpecific() bool {
+	// On Windows, unix.Poll is not available. Use PeekNamedPipe to check if data is available
+	// on the pipe without consuming it.
+	var available uint32
+	r, _, _ := procPeekNamedPipe.Call(
+		os.Stdin.Fd(),
+		0,
+		0,
+		0,
+		uintptr(unsafe.Pointer(&available)),
+		0,
+	)
+	return r != 0 && available > 0
+}
 
 func streamOutputOSSpecific(label string, generateOutput func(w *os.File) error) error {
 	// We have a trick with sockets that we use when possible on Unix-like systems. Those APIs aren't