fix: paginated endpoints now behave better with pagers by default

Author: stainless-app[bot]

README.md

@@ -123,7 +123,51 @@ For details about specific commands, use the `--help` flag.
 The CLI also provides resource-based commands for more advanced usage:
 
 ```sh
-hypeman [resource] [command] [flags]
+# Pull an image
+hypeman pull nginx:alpine
+
+# Boot a new VM (auto-pulls image if needed)
+hypeman run --name my-app nginx:alpine
+
+# List running VMs
+hypeman ps
+# show all VMs
+hypeman ps -a
+
+# View logs of your app
+# All commands support using VM name, ID, or partial ID
+hypeman logs my-app
+hypeman logs -f my-app
+
+# Execute a command in a running VM
+hypeman exec my-app whoami
+# Shell into the VM
+hypeman exec -it my-app /bin/sh
+
+# VM lifecycle
+# Turn off the VM
+hypeman stop my-app
+# Boot the VM that was turned off
+hypeman start my-app
+# Put the VM to sleep (paused)
+hypeman standby my-app
+# Awaken the VM (resumed)
+hypeman restore my-app
+
+# Create a reverse proxy ("ingress") from the host to your VM
+hypeman ingress create --name my-ingress my-app --hostname my-nginx-app --port 80 --host-port 8081
+
+# List ingresses
+hypeman ingress list
+
+# Curl nginx through your ingress
+curl --header "Host: my-nginx-app" http://127.0.0.1:8081
+
+# Delete an ingress
+hypeman ingress delete my-ingress
+
+# Delete all VMs
+hypeman rm --force --all
 ```
 
 ## Resource Management
@@ -213,6 +257,12 @@ hypeman run --hypervisor qemu --name qemu-vm myimage:latest
 hypeman run --hypervisor cloud-hypervisor --name ch-vm myimage:latest
 ```
 
+The CLI also provides resource-based commands for more advanced usage:
+
+```sh
+hypeman [resource] [command] [flags]
+```
+
 ## Global Flags
 
 - `--debug` - Enable debug logging (includes HTTP request/response details)

pkg/cmd/cmdutil.go

@@ -82,28 +82,99 @@ func streamOutput(label string, generateOutput func(w *os.File) error) error {
 		return streamToStdout(generateOutput)
 	}
 
-	pagerInput, outputFile, isSocketPair, err := createPagerFiles()
-	if err != nil {
-		return err
+	// Windows lacks UNIX socket APIs, so we fall back to pipes there or if
+	// socket creation fails. We prefer sockets when available because they
+	// allow for smaller buffer sizes, preventing unnecessary data streaming
+	// from the backend. Pipes typically have large buffers but serve as a
+	// decent alternative when sockets aren't available.
+	if runtime.GOOS == "windows" {
+		return streamToPagerWithPipe(label, generateOutput)
+	}
+
+	// Try to use socket pair for better buffer control
+	pagerInput, pid, err := openSocketPairPager(label)
+	if err != nil || pagerInput == nil {
+		// Fall back to pipe if socket setup fails
+		return streamToPagerWithPipe(label, generateOutput)
 	}
 	defer pagerInput.Close()
-	defer outputFile.Close()
 
-	cmd, err := startPagerCommand(pagerInput, label, isSocketPair)
+	// If we would be streaming to a terminal and aren't forcing color one way
+	// or the other, we should configure things to use color so the pager gets
+	// colorized input.
+	if isTerminal(os.Stdout) && os.Getenv("FORCE_COLOR") == "" {
+		os.Setenv("FORCE_COLOR", "1")
+	}
+
+	// If the pager exits before reading all input, then generateOutput() will
+	// produce a broken pipe error, which is fine and we don't want to propagate it.
+	if err := generateOutput(pagerInput); err != nil &&
+		!strings.Contains(err.Error(), "broken pipe") {
+		return err
+	}
+
+	// Close the file NOW before we wait for the child process to terminate.
+	// This way, the child will receive the end-of-file signal and know that
+	// there is no more input. Otherwise the child process may block
+	// indefinitely waiting for another line (this can happen when streaming
+	// less than a screenful of data to a pager).
+	pagerInput.Close()
+
+	// Wait for child process to exit
+	var wstatus syscall.WaitStatus
+	_, err = syscall.Wait4(pid, &wstatus, 0, nil)
+	if wstatus.ExitStatus() != 0 {
+		return fmt.Errorf("Pager exited with non-zero exit status: %d", wstatus.ExitStatus())
+	}
+	return err
+}
+
+func streamToPagerWithPipe(label string, generateOutput func(w *os.File) error) error {
+	r, w, err := os.Pipe()
 	if err != nil {
 		return err
 	}
+	defer r.Close()
+	defer w.Close()
+
+	pagerProgram := os.Getenv("PAGER")
+	if pagerProgram == "" {
+		pagerProgram = "less"
+	}
 
-	if err := pagerInput.Close(); err != nil {
+	if _, err := exec.LookPath(pagerProgram); err != nil {
 		return err
 	}
 
-	// If the pager exits before reading all input, then generateOutput() will
-	// produce a broken pipe error, which is fine and we don't want to propagate it.
-	if err := generateOutput(outputFile); err != nil && !strings.Contains(err.Error(), "broken pipe") {
+	cmd := exec.Command(pagerProgram)
+	cmd.Stdin = r
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = append(os.Environ(),
+		"LESS=-r -P "+label,
+		"MORE=-r -P "+label,
+	)
+
+	if err := cmd.Start(); err != nil {
 		return err
 	}
 
+	if err := r.Close(); err != nil {
+		return err
+	}
+
+	// If we would be streaming to a terminal and aren't forcing color one way
+	// or the other, we should configure things to use color so the pager gets
+	// colorized input.
+	if isTerminal(os.Stdout) && os.Getenv("FORCE_COLOR") == "" {
+		os.Setenv("FORCE_COLOR", "1")
+	}
+
+	if err := generateOutput(w); err != nil && !strings.Contains(err.Error(), "broken pipe") {
+		return err
+	}
+
+	w.Close()
 	return cmd.Wait()
 }
 
@@ -137,31 +208,33 @@ func startPagerCommand(pagerInput *os.File, label string, useSocketpair bool) (*
 		pagerProgram = "less"
 	}
 
-	if shouldUseColors(os.Stdout) {
-		os.Setenv("FORCE_COLOR", "1")
+	pagerPath, err := exec.LookPath(pagerProgram)
+	if err != nil {
+		unix.Close(parentFd)
+		return nil, 0, err
 	}
 
-	var cmd *exec.Cmd
-	if useSocketpair {
-		cmd = exec.Command(pagerProgram, fmt.Sprintf("/dev/fd/%d", pagerInput.Fd()))
-		cmd.ExtraFiles = []*os.File{pagerInput}
-	} else {
-		cmd = exec.Command(pagerProgram)
-		cmd.Stdin = pagerInput
-	}
+	env := os.Environ()
+	env = append(env, "LESS=-r -P "+label)
+	env = append(env, "MORE=-r -P "+label)
 
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = append(os.Environ(),
-		"LESS=-r -f -P "+label,
-		"MORE=-r -f -P "+label,
-	)
+	procAttr := &syscall.ProcAttr{
+		Dir: "",
+		Env: env,
+		Files: []uintptr{
+			uintptr(childFd),        // stdin (fd 0)
+			uintptr(syscall.Stdout), // stdout (fd 1)
+			uintptr(syscall.Stderr), // stderr (fd 2)
+		},
+	}
 
-	if err := cmd.Start(); err != nil {
-		return nil, err
+	pid, err := syscall.ForkExec(pagerPath, []string{pagerProgram}, procAttr)
+	if err != nil {
+		unix.Close(parentFd)
+		return nil, 0, err
 	}
 
-	return cmd, nil
+	return parentConn, pid, nil
 }
 
 func shouldUseColors(w io.Writer) bool {