feat: add wish.Command and wish.Cmd

The wish-exec example with vim worked because neovim was not using
STDERR.

Bubbletea doesn't have a concept of stdout and stderr, just output, so
`tea.ExecProcess` sets the `exec.Cmd` stderr to `os.Stderr`.

This would fail for bash, for instance.

This also introduces a `wish.Cmd` type and a `wish.Command`
function to properly set up a `wish.Cmd` based on `ssh.Session` (and
optionally a Pty), which can then be used with `tea.Exec`.

Finally, it adds to the wish-exec example, including the `s` key to run
a shell (bash).

closes #228

Signed-off-by: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>

examples/wish-exec/main.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"os/signal"
 	"syscall"
 	"time"
@@ -77,26 +76,35 @@ func (m model) Init() tea.Cmd {
 	return nil
 }
 
-type vimFinishedMsg struct{ err error }
+type cmdFinishedMsg struct{ err error }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
+		// PS: the execs won't work on windows.
 		switch msg.String() {
 		case "e":
-			// PS: this does not work on Windows.
-			c := exec.Command("vim", "file.txt")
-			cmd := tea.ExecProcess(c, func(err error) tea.Msg {
+			c := wish.Command(m.sess, "vim", "file.txt")
+			cmd := tea.Exec(c, func(err error) tea.Msg {
 				if err != nil {
 					log.Error("vim finished", "error", err)
 				}
-				return vimFinishedMsg{err: err}
+				return cmdFinishedMsg{err: err}
+			})
+			return m, cmd
+		case "s":
+			c := wish.Command(m.sess, "bash", "-im")
+			cmd := tea.Exec(c, func(err error) tea.Msg {
+				if err != nil {
+					log.Error("shell finished", "error", err)
+				}
+				return cmdFinishedMsg{err: err}
 			})
 			return m, cmd
 		case "q", "ctrl+c":
 			return m, tea.Quit
 		}
-	case vimFinishedMsg:
+	case cmdFinishedMsg:
 		m.err = msg.err
 		return m, nil
 	}
@@ -108,5 +116,5 @@ func (m model) View() string {
 	if m.err != nil {
 		return m.errStyle.Render(m.err.Error() + "\n")
 	}
-	return m.style.Render("Press 'e' to edit or 'q' to quit...\n")
+	return m.style.Render("Press 'e' to edit, 's' to hop into a shell, or 'q' to quit...\n")
 }

wish.go

@@ -3,6 +3,9 @@ package wish
 import (
 	"fmt"
 	"io"
+	"os/exec"
+	"runtime"
+	"time"
 
 	"github.com/charmbracelet/keygen"
 	"github.com/charmbracelet/ssh"
@@ -98,3 +101,62 @@ func Println(s ssh.Session, v ...interface{}) {
 func WriteString(s ssh.Session, v string) (int, error) {
 	return io.WriteString(s, v)
 }
+
+// Command sets stdin, stdout, and stderr to the current session's PTY slave.
+//
+// If the current session does not have a PTY, it sets them to the session
+// itself.
+func Command(s ssh.Session, name string, args ...string) *Cmd {
+	c := exec.Command(name, args...)
+	pty, _, ok := s.Pty()
+	if !ok {
+		c.Stdin, c.Stdout, c.Stderr = s, s, s
+		return &Cmd{cmd: c}
+	}
+
+	return &Cmd{c, &pty}
+}
+
+// Cmd wraps a *exec.Cmd and a ssh.Pty so a command can be properly run.
+type Cmd struct {
+	cmd *exec.Cmd
+	pty *ssh.Pty
+}
+
+// SetStderr conforms with tea.ExecCommand.
+func (*Cmd) SetStderr(io.Writer) {}
+
+// SetStdin conforms with tea.ExecCommand.
+func (*Cmd) SetStdin(io.Reader) {}
+
+// SetStdout conforms with tea.ExecCommand.
+func (*Cmd) SetStdout(io.Writer) {}
+
+// Run runs the program and waits for it to finish.
+func (c *Cmd) Run() error {
+	if c.pty == nil {
+		return c.Run()
+	}
+
+	if err := c.pty.Start(c.cmd); err != nil {
+		return err
+	}
+	start := time.Now()
+	if runtime.GOOS == "windows" {
+		for c.cmd.ProcessState == nil {
+			if time.Since(start) > time.Second*10 {
+				return fmt.Errorf("could not start process")
+			}
+			time.Sleep(100 * time.Millisecond)
+		}
+
+		if !c.cmd.ProcessState.Success() {
+			return fmt.Errorf("process failed: exit %d", c.cmd.ProcessState.ExitCode())
+		}
+	} else {
+		if err := c.cmd.Wait(); err != nil {
+			return err
+		}
+	}
+	return nil
+}