Execute Command Line Binary And Continually Read Stdout

In Go, I would like to execute a binary from within my application and continually read what the command prints to stdout. However, the one caveat is that the binary is programmed to execute its task infinitely until it reads the enter key, and I don't have access to the binary's source code. If I execute the binary directly from a terminal, it behaves correctly. However, if I execute the binary from within my application, it somehow thinks that it reads the enter key, and closes almost immediately. Here is a code snippet demonstrating how I'm trying to execute the binary, pipe it's stdout, and print it to the screen:

func main() {
	// The binary that I want to execute.
	cmd := exec.Command("/usr/lib/demoApp")

	// Pipe the command's output.
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		fmt.Println(err)
	}
	stdoutReader := bufio.NewReader(stdout)

	// Start the command.
	err = cmd.Start()
	if err != nil {
		fmt.Println(err)
	}

	// Read and print the command's output.
	buff := make([]byte, 1024)
	var n int
	for err == nil {
		n, err = stdoutReader.Read(buff)
		if n > 0 {
			fmt.Printf(string(buff[0:n]))
		}
	}
	_ = cmd.Wait()
}

Any ideas if what I'm trying to accomplish is possible?

As @mgagnon mentioned, your problem might lie somewhere else; like perhaps the external dependency just bails due to not running in a terminal. Using following to simulate demoApp:

func main() {
	fmt.Println("Press enter to exit")
	// Every second, report fake progress
	go func() {
		for {
			fmt.Print("Doing stuff...\n")
			time.Sleep(time.Second)
		}
	}()

	for {
		// Read single character and if enter, exit.
		consoleReader := bufio.NewReaderSize(os.Stdin, 1)
		input, _ := consoleReader.ReadByte()

		// Enter = 10 | 13 (LF or CR)
		if input == 10 || input == 13 {
			fmt.Println("Exiting...")
			os.Exit(0)
		}
	}
}

... this works fine for me:

func main() {
	cmd := exec.Command("demoApp.exe")
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		panic(err)
	}

	stdin, err := cmd.StdinPipe()
	if err != nil {
		log.Fatal(err)
	}

	go func() {
		defer stdin.Close()
		// After 3 seconds of running, send newline to cause program to exit.
		time.Sleep(time.Second * 3)
		io.WriteString(stdin, "\n")
	}()

	cmd.Start()

	// Scan and print command's stdout
	scanner := bufio.NewScanner(stdout)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	// Wait for program to exit.
	cmd.Wait()
}

$ go run main.go
Press enter to exit
Doing stuff...
Doing stuff...
Doing stuff...
Exiting...

The only difference between this and your code is that I'm using stdin to send a newline after 3 seconds to terminate the cmd. Also using scanner for brevity.

Using this as my /usr/lib/demoApp:

package main

import (
   "fmt"
   "time"
)

func main() {
   for {
      fmt.Print("North East South West")
      time.Sleep(time.Second)
   }
}

This program works as expected:

package main

import (
   "os"
   "os/exec"
)

func main() {
   cmd := exec.Command("demoApp")
   stdout, err := cmd.StdoutPipe()
   if err != nil {
      panic(err)
   }
   cmd.Start()
   defer cmd.Wait()
   for {
      var b [1024]byte
      stdout.Read(b[:])
      os.Stdout.Write(b[:])
   }
}