add command lists (;, &&, ||) and $?

- split input at unquoted ;, && and || and run the commands like sh;
  variables are expanded per command when it runs
- $? and ${?} expand to the exit status of the last command,
  exit/quit without argument use it
- syntax errors for missing commands around operators (status 2)
- "command not found" message instead of the raw exec error, no more
  "exit status N" message when a command fails

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.goreleaser.yaml

@@ -22,7 +22,7 @@ builds:
     flags:
       - -trimpath
     ldflags:
-      - -s -w -X main.version={{ .Version }}
+      - -s -w -X main.version={{ .Version }} -X main.commit={{ .ShortCommit }} -X main.branch={{ .Branch }}
     goos:
       - linux
       - darwin

README.md

@@ -2,13 +2,14 @@
 
 ```
 gosh - Go Shell
+Version: 0.2.1 (branch: main, commit: 03e791c)
 
 Built-in commands:
   cd [dir]       - Change directory (cd with no args goes to home)
   pwd           - Print working directory
   echo [args]   - Echo arguments
-  exit [code]   - Exit shell with optional status code
+  exit [code]   - Exit shell with status code (default: $?)
-  quit [code]   - Quit shell with optional status code
+  quit [code]   - Quit shell with status code (default: $?)
   set VAR=val   - Set environment variable
   export VAR=val - Export environment variable
   help          - Show this help
@@ -28,9 +29,58 @@ Features:
     disabled with $NO_COLOR, TERM=dumb or when output is not a terminal
   - Environment variable expansion ($VAR, ${VAR}, ${VAR:-default});
     using an unset variable is an error, use ${VAR:-} for an empty default
+  - Command lists: a ; b (run both), a && b (b only if a succeeded),
+    a || b (b only if a failed); $? is the exit status of the last command
+  - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
+    the exit status is the one of the last command
 
 ```
 
+### Aufruf
+
+```
+gosh [-l] [-i] [script]
+gosh [-l] -c command
+gosh -version
+```
+
+| Aufruf                 | Verhalten                                                        |
+|------------------------|------------------------------------------------------------------|
+| `gosh`                 | interaktive Shell (wenn stdin ein Terminal ist)                  |
+| `gosh -c 'befehl'`     | führt den Befehl aus und beendet sich                            |
+| `gosh skript.gosh`     | führt das Skript Zeile für Zeile aus                             |
+| `befehle \| gosh`      | liest die Befehle von stdin                                      |
+| `-i`                   | erzwingt den interaktiven Modus, auch ohne Terminal              |
+| `-l`, `--login`        | Login-Shell (wird akzeptiert, eine Startdatei gibt es noch nicht) |
+
+Ohne Terminal bricht gosh bei einem fehlgeschlagenen Befehl nicht ab und beendet sich mit dem Exit-Status des letzten Befehls: `127`, wenn ein Befehl nicht gefunden wurde, `126`, wenn er nicht ausführbar ist, `128+n`, wenn er durch Signal `n` beendet wurde. Leere Zeilen und Zeilen, die mit `#` beginnen, werden übersprungen, Skripte können also mit `#!/usr/bin/gosh` beginnen.
+
+Damit funktionieren auch `ssh host befehl`, `scp` und `rsync`, wenn gosh als Login-Shell gesetzt ist. Befehle lassen sich mit `;`, `&&` und `||` verketten (z. B. `ssh host 'cd /srv && git pull'`), Pipes und Umleitungen kennt gosh aber noch nicht.
+
+### Befehlslisten und Exit-Status
+
+Mehrere Befehle in einer Zeile werden wie in `sh` verknüpft:
+
+| Liste      | Bedeutung                                         |
+|------------|---------------------------------------------------|
+| `a ; b`    | erst `a`, dann `b`                                |
+| `a && b`   | `b` nur, wenn `a` erfolgreich war (Exit-Status 0) |
+| `a \|\| b` | `b` nur, wenn `a` fehlgeschlagen ist              |
+
+`&&` und `||` werden von links nach rechts ausgewertet, `a && b || c` führt also `c` aus, wenn `a` oder `b` fehlschlägt. Variablen werden erst beim Ausführen des jeweiligen Befehls expandiert, `cd /tmp && echo $PWD` gibt also schon das neue Verzeichnis aus.
+
+`$?` (bzw. `${?}`) enthält den Exit-Status des letzten Befehls, `exit` ohne Argument beendet gosh mit diesem Status:
+
+```
+$ false; echo $?
+1
+$ gibtsnicht || echo "Status $?"
+gosh: gibtsnicht: command not found
+Status 127
+```
+
+Schlägt ein Programm fehl, gibt gosh selbst keine Meldung mehr aus (das Programm meldet den Fehler selbst), nur bei Fehlern von gosh, z. B. wenn ein Befehl nicht gefunden wird.
+
 ### Farben
 
 Der Prompt wird über die Umgebungsvariable `GOSH_COLORS` eingefärbt. Sie besteht aus durch `:` getrennten Einträgen `schlüssel=code`:
@@ -102,6 +152,15 @@ _gosh is not meant for production use, it is just a proof of concept._
 go build ./
 ```
 
+Die Version lässt sich mit `gosh -version` (oder `--version`, `-V`) abfragen und steht auch in der Ausgabe von `help`:
+
+```
+$ gosh -version
+gosh 0.2.1 (branch: main, commit: 03e791c)
+```
+
+Version und Branch werden beim Bauen mit GoReleaser per `-ldflags` gesetzt. Bei einem einfachen `go build` steht dort `dev`, der Commit wird dann aus den von Go eingebetteten Git-Informationen gelesen (mit `-dirty`, falls es uncommittete Änderungen gab).
+
 ## Release
 
 Binaries sowie `.deb`- und `.rpm`-Pakete werden mit [GoReleaser](https://goreleaser.com) gebaut (Konfiguration: `.goreleaser.yaml`).

main.go

@@ -1,15 +1,20 @@
 package main
 
 import (
+	"bufio"
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"os"
 	"os/exec"
 	"os/signal"
 	"os/user"
 	"path/filepath"
+	"runtime/debug"
+	"strconv"
 	"strings"
+	"syscall"
 	"unicode"
 	"unicode/utf8"
 
@@ -19,8 +24,51 @@ import (
 // ErrNoPath is returned when 'cd' was called without a second argument.
 var ErrNoPath = errors.New("path required")
 
-// version is set at build time via -ldflags "-X main.version=..."
+// Build information, set at build time via
-var version = "dev"
+// -ldflags "-X main.version=... -X main.commit=... -X main.branch=...".
+var (
+	version = "dev"
+	commit  = ""
+	branch  = ""
+)
+
+// versionInfo returns the version including branch and commit, e.g.
+// "0.2.1 (branch: main, commit: 03e791c)". Without ldflags (plain go build)
+// the commit is taken from the VCS information that Go embeds in the binary.
+func versionInfo() string {
+	c := commit
+	if c == "" {
+		if info, ok := debug.ReadBuildInfo(); ok {
+			var dirty bool
+			for _, s := range info.Settings {
+				switch s.Key {
+				case "vcs.revision":
+					c = s.Value
+				case "vcs.modified":
+					dirty = s.Value == "true"
+				}
+			}
+			if len(c) > 7 {
+				c = c[:7]
+			}
+			if c != "" && dirty {
+				c += "-dirty"
+			}
+		}
+	}
+
+	var details []string
+	if branch != "" {
+		details = append(details, "branch: "+branch)
+	}
+	if c != "" {
+		details = append(details, "commit: "+c)
+	}
+	if len(details) == 0 {
+		return version
+	}
+	return version + " (" + strings.Join(details, ", ") + ")"
+}
 
 // previousDir tracks the previous working directory for 'cd -' support
 var previousDir string
@@ -169,6 +217,9 @@ func expandVar(s string) (string, int, error) {
 			return "", 0, errors.New("missing } in variable reference")
 		}
 		name, def, hasDef := strings.Cut(s[2:end], ":-")
+		if name == "?" {
+			return strconv.Itoa(lastStatus), end + 1, nil
+		}
 		if !isVarName(name) {
 			return "", 0, fmt.Errorf("bad substitution: %s", s[:end+1])
 		}
@@ -182,6 +233,10 @@ func expandVar(s string) (string, int, error) {
 		return value, end + 1, nil
 	}
 
+	if len(s) > 1 && s[1] == '?' {
+		return strconv.Itoa(lastStatus), 2, nil
+	}
+
 	n := 1
 	for n < len(s) && isVarNameByte(s[n], n == 1) {
 		n++
@@ -567,12 +622,146 @@ func completeFilePath(line, prefix string) []string {
 	return matches
 }
 
+const usage = `usage: gosh [-l] [-i] [script]
+       gosh [-l] -c command
+       gosh -version`
+
 func main() {
-	if len(os.Args) > 1 && (os.Args[1] == "--version" || os.Args[1] == "-V") {
+	os.Exit(run(os.Args[1:]))
-		fmt.Println("gosh", version)
+}
-		return
+
+// run parses the command line and runs gosh in the matching mode. It returns
+// the exit status of the shell.
+func run(args []string) int {
+	// -l/--login is accepted for compatibility (e.g. "su -l", login(1)), but
+	// gosh does not read a startup file yet. -i forces interactive mode even
+	// if stdin is not a terminal.
+	forceInteractive := false
+flags:
+	for len(args) > 0 {
+		switch args[0] {
+		case "-l", "--login":
+		case "-i":
+			forceInteractive = true
+		default:
+			break flags
+		}
+		args = args[1:]
 	}
 
+	if len(args) > 0 {
+		switch arg := args[0]; {
+		case arg == "-version" || arg == "--version" || arg == "-V":
+			fmt.Println("gosh", versionInfo())
+			return 0
+		case arg == "-h" || arg == "--help":
+			fmt.Println(usage)
+			return 0
+		case arg == "-c":
+			// Like sh, further arguments are allowed (they would become $0,
+			// $1, ...), but gosh has no positional parameters yet.
+			if len(args) < 2 {
+				fmt.Fprintln(os.Stderr, "gosh: -c: option requires an argument")
+				fmt.Fprintln(os.Stderr, usage)
+				return 2
+			}
+			return runScript(strings.NewReader(args[1]))
+		case strings.HasPrefix(arg, "-") && arg != "-":
+			fmt.Fprintf(os.Stderr, "gosh: %s: invalid option\n", arg)
+			fmt.Fprintln(os.Stderr, usage)
+			return 2
+		case arg == "-":
+			return runScript(os.Stdin)
+		default:
+			f, err := os.Open(arg)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, "gosh:", err)
+				return 127
+			}
+			defer f.Close()
+			return runScript(bufio.NewReader(f))
+		}
+	}
+
+	// Without a terminal (e.g. "echo ls | gosh") read the commands from stdin.
+	if !forceInteractive && !readline.IsTerminal(int(os.Stdin.Fd())) {
+		return runScript(os.Stdin)
+	}
+
+	interactive()
+	return 0
+}
+
+// runScript executes the commands from r line by line. Like sh, it does not
+// stop at a failing command and returns the exit status of the last one.
+// Empty lines and lines starting with # (e.g. a #!/usr/bin/gosh line) are
+// skipped.
+func runScript(r io.Reader) int {
+	status := 0
+	for {
+		line, err := readLine(r)
+		if trimmed := strings.TrimSpace(line); trimmed != "" && !strings.HasPrefix(trimmed, "#") {
+			printError(execInput(line))
+			status = lastStatus
+		}
+		if err != nil {
+			if err != io.EOF {
+				fmt.Fprintln(os.Stderr, "gosh:", err)
+				return 1
+			}
+			return status
+		}
+	}
+}
+
+// readLine reads a single line from r without the trailing newline. It reads
+// byte by byte so that nothing after the line is consumed: when the script
+// comes from stdin, the commands it starts read the rest of stdin (like in
+// sh, "printf 'cat\nhello\n' | gosh" prints hello). Pass a bufio.Reader if
+// that does not matter.
+func readLine(r io.Reader) (string, error) {
+	var b strings.Builder
+	buf := make([]byte, 1)
+	for {
+		n, err := r.Read(buf)
+		if n > 0 {
+			if buf[0] == '\n' {
+				return b.String(), nil
+			}
+			b.WriteByte(buf[0])
+		}
+		if err != nil {
+			return b.String(), err
+		}
+	}
+}
+
+// exitStatus converts the result of execInput into a shell exit status: the
+// exit code of the command, 128+n if it was killed by signal n, 127 if it was
+// not found, 126 if it could not be executed and 1 for other errors.
+func exitStatus(err error) int {
+	if err == nil {
+		return 0
+	}
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) {
+		if ws, ok := exitErr.Sys().(syscall.WaitStatus); ok && ws.Signaled() {
+			return 128 + int(ws.Signal())
+		}
+		return exitErr.ExitCode()
+	}
+	if errors.Is(err, errCommandNotFound) || errors.Is(err, fs.ErrNotExist) {
+		return 127
+	}
+	if errors.Is(err, fs.ErrPermission) {
+		return 126
+	}
+	return 1
+}
+
+// interactive runs the interactive shell with line editing, history and
+// completion until the user exits.
+func interactive() {
 	// Ctrl+C sends SIGINT to the whole foreground process group. Catch it so
 	// that it only stops the running command and not the shell. (signal.Ignore
 	// would be inherited by the child processes.)
@@ -633,13 +822,142 @@ func main() {
 		}
 
 		// Execute the input
-		if err := execInput(line); err != nil {
+		printError(execInput(line))
-			fmt.Fprintln(os.Stderr, err)
-		}
 	}
 }
 
+// lastStatus is the exit status of the last command ($?).
+var lastStatus int
+
+// errCommandNotFound is returned when an external command does not exist.
+var errCommandNotFound = errors.New("command not found")
+
+// printError prints an error of a command to stderr. Commands that ran and
+// failed have already reported the problem themselves, only their exit
+// status is kept.
+func printError(err error) {
+	var exitErr *exec.ExitError
+	if err == nil || errors.As(err, &exitErr) {
+		return
+	}
+	fmt.Fprintln(os.Stderr, "gosh:", err)
+}
+
+// listItem is a command of a command list together with the operator that
+// connects it to the previous command ("" for the first one).
+type listItem struct {
+	op      string // "", ";", "&&" or "||"
+	command string
+}
+
+// splitList splits input at unquoted ;, && and ||. Quotes, escapes, ${...}
+// and comments are handled like in splitWords, but nothing is expanded yet:
+// that happens per command when it runs, so "cd /tmp && echo $PWD" works.
+func splitList(input string) ([]listItem, error) {
+	var (
+		items     []listItem
+		op        string
+		start     int
+		quote     byte
+		escaped   bool
+		wordStart = true // the next character starts a word
+	)
+
+	end := len(input)
+	add := func(i int, next string) error {
+		command := input[start:i]
+		if strings.TrimSpace(command) == "" {
+			// "a;" is fine, but an operator needs a command on both sides
+			if next != "" || op == "&&" || op == "||" {
+				if next == "" {
+					next = op
+				}
+				return fmt.Errorf("syntax error near unexpected token `%s'", next)
+			}
+			return nil
+		}
+		items = append(items, listItem{op: op, command: command})
+		return nil
+	}
+
+scan:
+	for i := 0; i < len(input); i++ {
+		ch := input[i]
+		isWordStart := wordStart
+		wordStart = false
+		switch {
+		case escaped:
+			escaped = false
+		case quote == '\'':
+			if ch == '\'' {
+				quote = 0
+			}
+		case ch == '\\':
+			escaped = true
+		case ch == '$' && i+1 < len(input) && input[i+1] == '{':
+			// Skip ${...} as a whole, like expandVar does
+			if j := strings.IndexByte(input[i:], '}'); j >= 0 {
+				i += j
+			}
+		case quote == '"':
+			if ch == '"' {
+				quote = 0
+			}
+		case ch == '"' || ch == '\'':
+			quote = ch
+		case ch == ' ' || ch == '\t' || ch == '\n':
+			wordStart = true
+		case ch == '#' && isWordStart:
+			end = i
+			break scan
+		case ch == ';',
+			ch == '&' && i+1 < len(input) && input[i+1] == '&',
+			ch == '|' && i+1 < len(input) && input[i+1] == '|':
+			next := input[i : i+1]
+			if ch != ';' {
+				next = input[i : i+2]
+			}
+			if err := add(i, next); err != nil {
+				return nil, err
+			}
+			i += len(next) - 1
+			op = next
+			start = i + 1
+			wordStart = true
+		}
+	}
+
+	// An unterminated quote or a trailing \ is reported by splitWords
+	if err := add(end, ""); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// execInput executes a line of input: a list of commands separated by ;, &&
+// and ||. It returns the error of the last command that was run; errors of
+// earlier commands are printed. $? is updated after each command.
 func execInput(input string) error {
+	items, err := splitList(input)
+	if err != nil {
+		lastStatus = 2
+		return err
+	}
+
+	var lastErr error
+	for _, item := range items {
+		if (item.op == "&&" && lastStatus != 0) || (item.op == "||" && lastStatus == 0) {
+			continue
+		}
+		printError(lastErr)
+		lastErr = execCommand(item.command)
+		lastStatus = exitStatus(lastErr)
+	}
+	return lastErr
+}
+
+// execCommand executes a single simple command.
+func execCommand(input string) error {
 	// Split the input into the command and its arguments, expanding
 	// variables and ~ on the way.
 	args, err := splitWords(input)
@@ -693,7 +1011,7 @@ func execInput(input string) error {
 			fmt.Sscanf(args[1], "%d", &exitCode)
 			os.Exit(exitCode)
 		}
-		os.Exit(0)
+		os.Exit(lastStatus)
 	case "quit":
 		// quit with optional status code
 		if len(args) > 1 {
@@ -701,7 +1019,7 @@ func execInput(input string) error {
 			fmt.Sscanf(args[1], "%d", &exitCode)
 			os.Exit(exitCode)
 		}
-		os.Exit(0)
+		os.Exit(lastStatus)
 	case "set":
 		// set VAR=value - set environment variable
 		if len(args) < 2 {
@@ -727,14 +1045,14 @@ func execInput(input string) error {
 		os.Setenv(parts[0], parts[1])
 		return nil
 	case "help":
-		fmt.Println(`gosh - Go Shell
+		fmt.Println("gosh - Go Shell\nVersion: " + versionInfo() + `
 
 Built-in commands:
   cd [dir]       - Change directory (cd with no args goes to home)
   pwd           - Print working directory
   echo [args]   - Echo arguments
-  exit [code]   - Exit shell with optional status code
+  exit [code]   - Exit shell with status code (default: $?)
-  quit [code]   - Quit shell with optional status code
+  quit [code]   - Quit shell with status code (default: $?)
   set VAR=val   - Set environment variable
   export VAR=val - Export environment variable
   help          - Show this help
@@ -753,17 +1071,29 @@ Features:
     (keys user, root, path; values are ANSI SGR codes, empty = no color);
     disabled with $NO_COLOR, TERM=dumb or when output is not a terminal
   - Environment variable expansion ($VAR, ${VAR}, ${VAR:-default});
-    using an unset variable is an error, use ${VAR:-} for an empty default`)
+    using an unset variable is an error, use ${VAR:-} for an empty default
+  - Command lists: a ; b (run both), a && b (b only if a succeeded),
+    a || b (b only if a failed); $? is the exit status of the last command
+  - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
+    the exit status is the one of the last command`)
 		return nil
 	}
 
 	// Prepare the command to execute.
 	cmd := exec.Command(args[0], args[1:]...)
 
-	// Set the correct output device.
+	// Connect the command to the terminal. Without Stdin the command would
-	cmd.Stderr = os.Stderr
+	// read from /dev/null, so interactive programs (su, vim, ssh, ...) would
+	// get EOF right away. readline only reads from stdin while a line is
+	// being edited, so it does not steal input from the command.
+	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
 
 	// Execute the command return the error.
-	return cmd.Run()
+	err = cmd.Run()
+	if errors.Is(err, exec.ErrNotFound) {
+		return fmt.Errorf("%s: %w", sanitize(args[0]), errCommandNotFound)
+	}
+	return err
 }

main_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"os"
 	"os/exec"
@@ -648,6 +649,21 @@ func TestExecInput_ExportNoArgs(t *testing.T) {
 	}
 }
 
+func TestVersionInfo(t *testing.T) {
+	origVersion, origCommit, origBranch := version, commit, branch
+	defer func() { version, commit, branch = origVersion, origCommit, origBranch }()
+
+	version, commit, branch = "1.2.3", "abc1234", "main"
+	if got := versionInfo(); got != "1.2.3 (branch: main, commit: abc1234)" {
+		t.Errorf("versionInfo() = %q", got)
+	}
+
+	branch = ""
+	if got := versionInfo(); got != "1.2.3 (commit: abc1234)" {
+		t.Errorf("versionInfo() without branch = %q", got)
+	}
+}
+
 func TestExecInput_Help(t *testing.T) {
 	// Just verify help doesn't return an error
 	// We can't easily capture stdout in a unit test without a pipe
@@ -1158,7 +1174,7 @@ func TestShell_History(t *testing.T) {
 	histFile := filepath.Join(t.TempDir(), "gosh", "history")
 	workDir := t.TempDir()
 
-	cmd := exec.Command(bin)
+	cmd := exec.Command(bin, "-i")
 	cmd.Dir = workDir
 	cmd.Env = append(os.Environ(), "GOSH_HISTFILE="+histFile)
 	cmd.Stdin = strings.NewReader("echo first\n set SECRET=hunter2\nexit\n")
@@ -1190,7 +1206,7 @@ func TestShell_History(t *testing.T) {
 func TestShell_SIGINTKillsOnlyChild(t *testing.T) {
 	bin := buildShell(t)
 
-	cmd := exec.Command(bin)
+	cmd := exec.Command(bin, "-i")
 	// Own process group, so that we can signal it like the terminal does
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 	stdin, err := cmd.StdinPipe()
@@ -1221,3 +1237,237 @@ func TestShell_SIGINTKillsOnlyChild(t *testing.T) {
 		t.Errorf("child was not interrupted (took %v)", elapsed)
 	}
 }
+
+func TestExecInput_PassesStdin(t *testing.T) {
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	origStdin := os.Stdin
+	os.Stdin = r
+	defer func() {
+		os.Stdin = origStdin
+		r.Close()
+	}()
+
+	if _, err := w.WriteString("hello\n"); err != nil {
+		t.Fatal(err)
+	}
+	w.Close()
+
+	out := filepath.Join(t.TempDir(), "out")
+	t.Setenv("GOSH_TEST_OUT", out)
+	if err := execInput(`sh -c 'read x; printf %s "$x" > "$GOSH_TEST_OUT"'`); err != nil {
+		t.Fatal(err)
+	}
+	got, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "hello" {
+		t.Errorf("command read %q from stdin, want %q", got, "hello")
+	}
+}
+
+func TestExitStatus(t *testing.T) {
+	tests := []struct {
+		input string
+		want  int
+	}{
+		{"true", 0},
+		{"false", 1},
+		{`sh -c "exit 42"`, 42},
+		{`sh -c "kill -TERM \$\$"`, 128 + 15},
+		{"gosh-no-such-command", 127},
+		{"cd /gosh-no-such-dir", 127},
+	}
+	for _, tc := range tests {
+		if got := exitStatus(execInput(tc.input)); got != tc.want {
+			t.Errorf("exitStatus(execInput(%q)) = %d, want %d", tc.input, got, tc.want)
+		}
+	}
+	if got := exitStatus(errors.New("other")); got != 1 {
+		t.Errorf("exitStatus(other error) = %d, want 1", got)
+	}
+}
+
+func TestRunScript(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+
+	dir := t.TempDir()
+	script := "#!/usr/bin/gosh\n" +
+		"# comment\n" +
+		"\n" +
+		"cd " + dir + "\n" +
+		"  # indented comment\n" +
+		"touch first\n" +
+		"false\n" +
+		"touch second" // no trailing newline
+	if got := runScript(strings.NewReader(script)); got != 0 {
+		t.Errorf("runScript() = %d, want 0", got)
+	}
+	for _, name := range []string{"first", "second"} {
+		if _, err := os.Stat(filepath.Join(dir, name)); err != nil {
+			t.Errorf("expected %s to be created: %v", name, err)
+		}
+	}
+
+	// The status of the last command is returned
+	if got := runScript(strings.NewReader("true\nsh -c 'exit 3'\n")); got != 3 {
+		t.Errorf("runScript() = %d, want 3", got)
+	}
+}
+
+func TestRun_Options(t *testing.T) {
+	tests := []struct {
+		args []string
+		want int
+	}{
+		{[]string{"-c", "true"}, 0},
+		{[]string{"-c", "false"}, 1},
+		{[]string{"-l", "-c", "sh -c 'exit 5'"}, 5},
+		{[]string{"-c"}, 2},
+		{[]string{"-x"}, 2},
+		{[]string{"/gosh/no/such/script"}, 127},
+	}
+	for _, tc := range tests {
+		if got := run(tc.args); got != tc.want {
+			t.Errorf("run(%q) = %d, want %d", tc.args, got, tc.want)
+		}
+	}
+}
+
+func TestReadLine_DoesNotReadAhead(t *testing.T) {
+	r := strings.NewReader("first\nsecond\n")
+	line, err := readLine(r)
+	if line != "first" || err != nil {
+		t.Fatalf("readLine() = %q, %v", line, err)
+	}
+	if r.Len() != len("second\n") {
+		t.Errorf("readLine() consumed more than one line, %d bytes left", r.Len())
+	}
+}
+
+func TestSplitList(t *testing.T) {
+	tests := []struct {
+		input string
+		want  []listItem
+	}{
+		{"", nil},
+		{"   ", nil},
+		{"# only a comment", nil},
+		{"ls", []listItem{{"", "ls"}}},
+		{"a; b", []listItem{{"", "a"}, {";", " b"}}},
+		{"a;", []listItem{{"", "a"}}},
+		{"a && b || c", []listItem{{"", "a "}, {"&&", " b "}, {"||", " c"}}},
+		{`echo "a;b" 'c&&d' e\;f`, []listItem{{"", `echo "a;b" 'c&&d' e\;f`}}},
+		{`echo "x\"; y"`, []listItem{{"", `echo "x\"; y"`}}},
+		{"echo ${X:-a;b}; c", []listItem{{"", "echo ${X:-a;b}"}, {";", " c"}}},
+		{"echo a # b; c", []listItem{{"", "echo a "}}},
+		{"echo a#b; c", []listItem{{"", "echo a#b"}, {";", " c"}}},
+		{"echo a|b", []listItem{{"", "echo a|b"}}},
+	}
+	for _, tc := range tests {
+		got, err := splitList(tc.input)
+		if err != nil {
+			t.Errorf("splitList(%q) returned error: %v", tc.input, err)
+			continue
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("splitList(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestSplitList_SyntaxErrors(t *testing.T) {
+	for _, input := range []string{"; a", "a ;; b", "&& a", "a &&", "a ||", "a && ; b", "a || && b"} {
+		if _, err := splitList(input); err == nil || !strings.Contains(err.Error(), "syntax error") {
+			t.Errorf("splitList(%q) = %v, want syntax error", input, err)
+		}
+	}
+}
+
+func TestExecInput_Lists(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("D", dir)
+	tests := []struct {
+		input   string
+		created []string
+		missing []string
+		status  int
+	}{
+		{"touch $D/a; touch $D/b", []string{"a", "b"}, nil, 0},
+		{"false; touch $D/c", []string{"c"}, nil, 0},
+		{"true && touch $D/d", []string{"d"}, nil, 0},
+		{"false && touch $D/e", nil, []string{"e"}, 1},
+		{"false || touch $D/f", []string{"f"}, nil, 0},
+		{"true || touch $D/g", nil, []string{"g"}, 0},
+		{"false && touch $D/h || touch $D/i", []string{"i"}, []string{"h"}, 0},
+		{"true && false || touch $D/j", []string{"j"}, nil, 0},
+		{"gosh-no-such-command || touch $D/k", []string{"k"}, nil, 0},
+		{"true && sh -c 'exit 4'", nil, nil, 4},
+	}
+	for _, tc := range tests {
+		execInput(tc.input)
+		if lastStatus != tc.status {
+			t.Errorf("%q: $? = %d, want %d", tc.input, lastStatus, tc.status)
+		}
+		for _, name := range tc.created {
+			if _, err := os.Stat(filepath.Join(dir, name)); err != nil {
+				t.Errorf("%q: expected %s to be created", tc.input, name)
+			}
+		}
+		for _, name := range tc.missing {
+			if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
+				t.Errorf("%q: %s must not be created", tc.input, name)
+			}
+		}
+	}
+}
+
+func TestExecInput_ExpandsPerCommand(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	out := filepath.Join(dir, "out")
+	t.Setenv("GOSH_TEST_OUT", out)
+	os.Unsetenv("GOSH_TEST_LIST")
+	defer os.Unsetenv("GOSH_TEST_LIST")
+
+	// The variable is set by the first command and used by the second one
+	err := execInput(`set GOSH_TEST_LIST=hello && sh -c 'printf %s "$GOSH_TEST_LIST" > "$GOSH_TEST_OUT"'`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, _ := os.ReadFile(out); string(got) != "hello" {
+		t.Errorf("got %q, want %q", got, "hello")
+	}
+}
+
+func TestExpandVar_LastStatus(t *testing.T) {
+	execInput("sh -c 'exit 3'")
+	for _, input := range []string{"$?", "${?}"} {
+		words, err := splitWords("echo " + input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if words[1] != "3" {
+			t.Errorf("%s = %q, want %q", input, words[1], "3")
+		}
+	}
+	execInput("true")
+	if words, _ := splitWords("echo $?"); words[1] != "0" {
+		t.Errorf("$? = %q after true, want 0", words[1])
+	}
+}
+
+func TestExecInput_CommandNotFound(t *testing.T) {
+	err := execInput("gosh-no-such-command")
+	if err == nil || err.Error() != "gosh-no-such-command: command not found" {
+		t.Errorf("got %v, want command not found", err)
+	}
+	if lastStatus != 127 {
+		t.Errorf("$? = %d, want 127", lastStatus)
+	}
+}