add wildcards (*, ?, [...])

- unquoted * ? and [...] (including [!...]) are expanded to the
  matching file names, sorted, per path component
- hidden files only match if the pattern starts with a dot, a trailing /
  only matches directories, a pattern without match is kept as is
- quoted or escaped characters and values of variables are never
  expanded
- redirections to a pattern must match exactly one file
- completion escapes * ? [ and $ in file names

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

README.md

@@ -8,8 +8,8 @@ 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
@@ -23,12 +23,19 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (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
+  - 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
+  - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
+    2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
     the exit status is the one of the last command
 
@@ -53,7 +60,84 @@ gosh -version
 
 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. Da gosh `;`, `&&` und Pipes noch nicht kennt, darf der Befehl dabei aber nur aus einem einfachen Kommando bestehen.
+Damit funktionieren auch `ssh host befehl`, `scp` und `rsync`, wenn gosh als Login-Shell gesetzt ist. Befehle lassen sich mit `;`, `&&` und `||` verketten und mit Pipes verbinden, z. B. `ssh host 'cd /srv && git log | head'`.
+
+### 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.
+
+### Wildcards
+
+Wörter mit `*`, `?` oder `[...]` werden durch die passenden Dateinamen ersetzt, sortiert:
+
+| Muster    | passt auf                                           |
+|-----------|-----------------------------------------------------|
+| `*`       | beliebig viele Zeichen (auch keine)                 |
+| `?`       | genau ein Zeichen                                   |
+| `[abc]`   | eines der Zeichen `a`, `b`, `c`                     |
+| `[a-z]`   | ein Zeichen aus dem Bereich                         |
+| `[!abc]`  | ein Zeichen außer `a`, `b`, `c` (auch `[^abc]`)     |
+
+```
+$ ls *.go
+main.go  main_test.go
+$ cat logs/2026-*/error.log
+$ ls -d */            # nur Verzeichnisse
+```
+
+- Muster gelten pro Pfadteil, `*` passt nie auf `/`: `*/*.go` findet `.go`-Dateien eine Ebene tiefer.
+- Versteckte Dateien (mit `.` am Anfang) werden nur gefunden, wenn das Muster selbst mit `.` beginnt: `*` findet `.bashrc` nicht, `.*rc` schon.
+- Passt keine Datei, bleibt das Wort unverändert stehen (wie in `sh`), `ls *.xyz` meldet dann also `ls` den Fehler.
+- In Anführungszeichen oder mit `\` davor sind die Zeichen normale Zeichen: `echo "*"`, `echo '*.go'`, `echo \*`.
+- Werte von Variablen werden nicht als Muster behandelt (anders als in `sh`): Nach `set P=*.go` gibt `echo $P` wörtlich `*.go` aus. So kann ein Variablenwert nie unbemerkt auf viele Dateien passen. `echo $DIR/*.go` funktioniert dagegen, weil das `*` direkt in der Zeile steht.
+- Bei einer Umleitung muss das Muster genau eine Datei treffen (`> *.log`), sonst meldet gosh `ambiguous redirect`.
+
+### Pipes und Umleitungen
+
+```
+$ ls | sort -r | head -3
+$ make > build.log 2>&1
+$ grep -c error < build.log
+```
+
+| Syntax          | Bedeutung                                                  |
+|-----------------|------------------------------------------------------------|
+| `a \| b`        | stdout von `a` wird stdin von `b`                          |
+| `< datei`       | stdin aus `datei` lesen                                    |
+| `> datei`       | stdout in `datei` schreiben (wird überschrieben)           |
+| `>> datei`      | stdout an `datei` anhängen                                 |
+| `2> datei`      | stderr in `datei` schreiben (`2>>` hängt an)               |
+| `2>&1`          | stderr dorthin, wohin stdout gerade geht                   |
+| `>&2`           | stdout dorthin, wohin stderr gerade geht                   |
+| `&> datei`      | stdout und stderr in `datei` (`&>>` hängt an)              |
+| `> datei`       | ohne Befehl: legt `datei` an bzw. leert sie                |
+
+- Umleitungen werden von links nach rechts ausgewertet: `befehl > log 2>&1` schreibt beides in `log`, `befehl 2>&1 > log` schickt stderr dorthin, wo stdout vorher hinging (z. B. in eine Pipe).
+- Unterstützt werden die Dateideskriptoren 0, 1 und 2. Vor `>` und `<` zählt nur eine Zahl ohne Anführungszeichen als Deskriptor (`2>f`, aber nicht `x2>f` oder `"2">f`).
+- Operatoren in Anführungszeichen oder mit `\` davor sind normale Zeichen: `echo "a|b" 'c>d' e\>f`.
+- Der Exit-Status einer Pipeline ist der des letzten Befehls. Beendet sich ein Befehl am Ende (z. B. `head`), bekommt der schreibende Befehl davor `SIGPIPE`, `yes | head -1` endet also sofort.
+- Die Built-ins `pwd` und `help` lassen sich umleiten und in Pipes verwenden (`help | less`). `cd`, `set`, `export`, `exit` und `quit` verändern die Shell selbst und sind in einer Pipeline nicht erlaubt.
+- Ein einzelnes `&` (Hintergrundprozesse) gibt es noch nicht, es wird als normales Zeichen übergeben.
 
 ### Farben
 

main.go

@@ -12,6 +12,8 @@ import (
 	"os/user"
 	"path/filepath"
 	"runtime/debug"
+	"sort"
+	"strconv"
 	"strings"
 	"syscall"
 	"unicode"
@@ -110,7 +112,18 @@ func expandTilde(path string) string {
 	return path
 }
 
-// splitWords splits input into words like a (very) simple POSIX shell:
+// token is a word or an operator of a command line.
+type token struct {
+	op      string // "" for a word, otherwise |, <, >, >>, >&, <&, &> or &>>
+	word    string // the word, if op == ""
+	pattern string // the word as glob pattern (quoted characters escaped)
+	glob    bool   // the word contains unquoted * ? or [ and is expanded
+	fd      int    // the redirected file descriptor (for redirections)
+	dup     int    // the target file descriptor of >& and <&
+}
+
+// tokenize splits input into words and operators like a (very) simple POSIX
+// shell:
 //   - words are separated by unquoted blanks, an unquoted # starts a comment
 //   - '...' is taken literally, nothing is expanded inside
 //   - "..." expands $VAR and ${VAR}; \ only escapes $ " \ and `
@@ -119,23 +132,40 @@ func expandTilde(path string) string {
 //     an unset variable is an error, so that e.g. "rm -rf $DIR/x" never runs
 //     with an empty $DIR
 //   - ~ and ~/... are expanded at the start of an unquoted word
+//   - unquoted |, <, >, >>, N<, N>, N>>, N>&M, N<&M, &> and &>> are operators
 //
 // Expanded values are never split into several words.
-func splitWords(input string) ([]string, error) {
+func tokenize(input string) ([]token, error) {
 	var (
-		words   []string
+		tokens   []token
 		b        strings.Builder
+		pat      strings.Builder // the word as glob pattern, quoted parts escaped
+		glob     bool            // the word contains unquoted * ? or [
 		inWord   bool            // a word has been started (even if it is still empty)
 		quote    byte
 		escaped  bool
+		rawStart = -1 // start of the current word in input
 	)
 
 	endWord := func() {
 		if inWord {
-			words = append(words, b.String())
+			tokens = append(tokens, token{word: b.String(), pattern: pat.String(), glob: glob})
 		}
 		b.Reset()
+		pat.Reset()
+		glob = false
 		inWord = false
+		rawStart = -1
+	}
+	// literal adds quoted, escaped or expanded text: it is never a pattern
+	literal := func(s string) {
+		b.WriteString(s)
+		pat.WriteString(escapeGlob(s))
+	}
+	startRaw := func(i int) {
+		if rawStart < 0 {
+			rawStart = i
+		}
 	}
 
 	for i := 0; i < len(input); i++ {
@@ -143,25 +173,29 @@ func splitWords(input string) ([]string, error) {
 		switch {
 		case escaped:
 			if quote == '"' && !strings.ContainsRune("$\"\\`", rune(ch)) {
-				b.WriteByte('\\')
+				literal("\\")
 			}
-			b.WriteByte(ch)
+			literal(string(ch))
 			inWord = true
 			escaped = false
 		case quote == '\'':
 			if ch == '\'' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '\\':
+			startRaw(i)
 			escaped = true
 		case ch == '$':
+			startRaw(i)
 			value, n, err := expandVar(input[i:])
 			if err != nil {
 				return nil, err
 			}
-			b.WriteString(value)
+			// Expanded values are never patterns (and never split), so that
+			// e.g. a * in a variable does not match files
+			literal(value)
 			// A literal "$" counts as content, an expansion that is empty does
 			// not (unless quoted), like in sh
 			if n == 1 || value != "" {
@@ -172,9 +206,10 @@ func splitWords(input string) ([]string, error) {
 			if ch == '"' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '"' || ch == '\'':
+			startRaw(i)
 			quote = ch
 			inWord = true
 		case ch == ' ' || ch == '\t' || ch == '\n':
@@ -182,16 +217,76 @@ func splitWords(input string) ([]string, error) {
 		case ch == '#' && !inWord && b.Len() == 0:
 			// Comment until the end of the line
 			i = len(input)
+		case ch == '|':
+			endWord()
+			tokens = append(tokens, token{op: "|"})
+		case ch == '&' && i+1 < len(input) && input[i+1] == '>':
+			// &> and &>> redirect stdout and stderr
+			endWord()
+			op := "&>"
+			if i+2 < len(input) && input[i+2] == '>' {
+				op = "&>>"
+			}
+			tokens = append(tokens, token{op: op, fd: 1})
+			i += len(op) - 1
+		case ch == '<' || ch == '>':
+			// A word consisting only of unquoted digits right before the
+			// operator is the file descriptor, e.g. 2>file
+			fd := 0
+			if ch == '>' {
+				fd = 1
+			}
+			if inWord && rawStart >= 0 && isDigits(input[rawStart:i]) {
+				fd, _ = strconv.Atoi(input[rawStart:i])
+				b.Reset()
+				pat.Reset()
+				glob = false
+				inWord = false
+				rawStart = -1
+			} else {
+				endWord()
+			}
+			t := token{op: string(ch), fd: fd}
+			switch {
+			case ch == '>' && i+1 < len(input) && input[i+1] == '>':
+				t.op = ">>"
+				i++
+			case i+1 < len(input) && input[i+1] == '&':
+				// N>&M and N<&M duplicate file descriptor M
+				j := i + 2
+				for j < len(input) && input[j] >= '0' && input[j] <= '9' {
+					j++
+				}
+				if j == i+2 {
+					return nil, syntaxError(input[i : i+2])
+				}
+				t.op = string(ch) + "&"
+				t.dup, _ = strconv.Atoi(input[i+2 : j])
+				i = j - 1
+			}
+			tokens = append(tokens, t)
 		case ch == '~' && !inWord && b.Len() == 0 &&
-			(i+1 == len(input) || strings.IndexByte("/ \t\n", input[i+1]) >= 0):
+			(i+1 == len(input) || strings.IndexByte("/ \t\n|<>", input[i+1]) >= 0):
+			startRaw(i)
 			home := getHomeDir()
 			if home == "" {
 				home = "~"
 			}
-			b.WriteString(home)
+			literal(home)
 			inWord = true
 		default:
+			startRaw(i)
 			b.WriteByte(ch)
+			switch {
+			case ch == '*' || ch == '?' || ch == '[':
+				glob = true
+				pat.WriteByte(ch)
+			case ch == '!' && strings.HasSuffix(pat.String(), "[") && !strings.HasSuffix(pat.String(), "\\["):
+				// POSIX [!...] is [^...] in Go
+				pat.WriteByte('^')
+			default:
+				pat.WriteByte(ch)
+			}
 			inWord = true
 		}
 	}
@@ -203,6 +298,152 @@ func splitWords(input string) ([]string, error) {
 		return nil, fmt.Errorf("unterminated %c quote", quote)
 	}
 	endWord()
+	return tokens, nil
+}
+
+// escapeGlob escapes the characters that are special in a glob pattern.
+func escapeGlob(s string) string {
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		if strings.IndexByte("*?[]\\", s[i]) >= 0 {
+			b.WriteByte('\\')
+		}
+		b.WriteByte(s[i])
+	}
+	return b.String()
+}
+
+// hasGlobMeta reports whether pattern contains an unescaped * ? or [.
+func hasGlobMeta(pattern string) bool {
+	for i := 0; i < len(pattern); i++ {
+		switch pattern[i] {
+		case '\\':
+			i++
+		case '*', '?', '[':
+			return true
+		}
+	}
+	return false
+}
+
+// unescapeGlob removes the escapes from a pattern without wildcards.
+func unescapeGlob(pattern string) string {
+	var b strings.Builder
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i] == '\\' && i+1 < len(pattern) {
+			i++
+		}
+		b.WriteByte(pattern[i])
+	}
+	return b.String()
+}
+
+// expandGlob returns the paths matching pattern, sorted. Like sh, * and ?
+// do not match a leading dot (hidden files), unless the pattern component
+// starts with a dot, and a trailing / only matches directories. An invalid
+// pattern matches nothing.
+func expandGlob(pattern string) []string {
+	paths := []string{""}
+	if strings.HasPrefix(pattern, "/") {
+		paths = []string{"/"}
+	}
+	components := strings.Split(strings.Trim(pattern, "/"), "/")
+	join := func(dir, name string) string {
+		if dir == "" || strings.HasSuffix(dir, "/") {
+			return dir + name
+		}
+		return dir + "/" + name
+	}
+
+	for _, comp := range components {
+		if comp == "" {
+			continue // a//b
+		}
+		var next []string
+		for _, dir := range paths {
+			if !hasGlobMeta(comp) {
+				p := join(dir, unescapeGlob(comp))
+				if _, err := os.Lstat(p); err == nil {
+					next = append(next, p)
+				}
+				continue
+			}
+			readDir := dir
+			if readDir == "" {
+				readDir = "."
+			}
+			entries, err := os.ReadDir(readDir)
+			if err != nil {
+				continue
+			}
+			for _, e := range entries {
+				name := e.Name()
+				if strings.HasPrefix(name, ".") && !strings.HasPrefix(comp, ".") && !strings.HasPrefix(comp, "\\.") {
+					continue
+				}
+				ok, err := filepath.Match(comp, name)
+				if err != nil {
+					return nil
+				}
+				if ok {
+					next = append(next, join(dir, name))
+				}
+			}
+		}
+		paths = next
+	}
+
+	if strings.HasSuffix(pattern, "/") {
+		var dirs []string
+		for _, p := range paths {
+			if info, err := os.Stat(p); err == nil && info.IsDir() {
+				dirs = append(dirs, p+"/")
+			}
+		}
+		paths = dirs
+	}
+	sort.Strings(paths)
+	return paths
+}
+
+// expandWord returns the words a token expands to: the matching paths for
+// a pattern, or the word itself if it is no pattern or nothing matches (like
+// in sh).
+func expandWord(t token) []string {
+	if t.glob {
+		if matches := expandGlob(t.pattern); len(matches) > 0 {
+			return matches
+		}
+	}
+	return []string{t.word}
+}
+
+// isDigits reports whether s is a non-empty string of ASCII digits.
+func isDigits(s string) bool {
+	if s == "" {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if s[i] < '0' || s[i] > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// splitWords splits input into words (see tokenize). Operators are an error.
+func splitWords(input string) ([]string, error) {
+	tokens, err := tokenize(input)
+	if err != nil {
+		return nil, err
+	}
+	var words []string
+	for _, t := range tokens {
+		if t.op != "" {
+			return nil, fmt.Errorf("unexpected operator %s", t.op)
+		}
+		words = append(words, t.word)
+	}
 	return words, nil
 }
 
@@ -216,6 +457,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])
 		}
@@ -229,6 +473,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++
@@ -461,7 +709,10 @@ func newShellCompleter() *shellCompleter {
 // runes of the current word that are already typed.
 func (c *shellCompleter) Do(line []rune, pos int) ([][]rune, int) {
 	word, start, quote := currentWord(string(line[:pos]))
-	isFirstWord := strings.TrimSpace(string(line[:start])) == ""
+	// A command is expected at the start and after |, ;, && and ||
+	before := strings.TrimSpace(string(line[:start]))
+	isFirstWord := before == "" || strings.HasSuffix(before, "|") ||
+		strings.HasSuffix(before, ";") || strings.HasSuffix(before, "&&")
 
 	// Plain "~" -> "~/"
 	if word == "~" {
@@ -545,7 +796,8 @@ func currentWord(s string) (word string, start int, quote byte) {
 			}
 		case ch == '"' || ch == '\'':
 			quote = ch
-		case ch == ' ' || ch == '\t':
+		case ch == ' ' || ch == '\t' || strings.IndexByte(";|&<>", ch) >= 0:
+			// Blanks and operators end a word
 			b.Reset()
 			start = i + 1
 		default:
@@ -559,7 +811,7 @@ func currentWord(s string) (word string, start int, quote byte) {
 func escapeWord(s string) string {
 	var b strings.Builder
 	for _, r := range s {
-		if strings.ContainsRune(" \t\\'\"", r) {
+		if strings.ContainsRune(" \t\\'\";|&<>*?[$", r) {
 			b.WriteByte('\\')
 		}
 		b.WriteRune(r)
@@ -693,13 +945,8 @@ func runScript(r io.Reader) int {
 	for {
 		line, err := readLine(r)
 		if trimmed := strings.TrimSpace(line); trimmed != "" && !strings.HasPrefix(trimmed, "#") {
-			cmdErr := execInput(line)
+			printError(execInput(line))
-			status = exitStatus(cmdErr)
+			status = lastStatus
-			// A command that ran and failed reports its own errors.
-			var exitErr *exec.ExitError
-			if cmdErr != nil && !errors.As(cmdErr, &exitErr) {
-				fmt.Fprintln(os.Stderr, "gosh:", cmdErr)
-			}
 		}
 		if err != nil {
 			if err != io.EOF {
@@ -740,6 +987,14 @@ func exitStatus(err error) int {
 	if err == nil {
 		return 0
 	}
+	var statusErr statusError
+	if errors.As(err, &statusErr) {
+		return int(statusErr)
+	}
+	var synErr syntaxError
+	if errors.As(err, &synErr) {
+		return 2
+	}
 	var exitErr *exec.ExitError
 	if errors.As(err, &exitErr) {
 		if ws, ok := exitErr.Sys().(syscall.WaitStatus); ok && ws.Signaled() {
@@ -747,7 +1002,7 @@ func exitStatus(err error) int {
 		}
 		return exitErr.ExitCode()
 	}
-	if errors.Is(err, exec.ErrNotFound) || errors.Is(err, fs.ErrNotExist) {
+	if errors.Is(err, errCommandNotFound) || errors.Is(err, fs.ErrNotExist) {
 		return 127
 	}
 	if errors.Is(err, fs.ErrPermission) {
@@ -819,24 +1074,412 @@ func interactive() {
 		}
 
 		// Execute the input
-		if err := execInput(line); err != nil {
+		printError(execInput(line))
-			fmt.Fprintln(os.Stderr, err)
-		}
 	}
 }
 
-func execInput(input string) error {
+// lastStatus is the exit status of the last command ($?).
-	// Split the input into the command and its arguments, expanding
+var lastStatus int
-	// variables and ~ on the way.
+
-	args, err := splitWords(input)
+// statusError is an error that only carries an exit status; the problem has
-	if err != nil {
+// already been reported.
-		return fmt.Errorf("invalid input: %w", err)
+type statusError int
+
+func (e statusError) Error() string {
+	return "exit status " + strconv.Itoa(int(e))
+}
+
+// syntaxError is a syntax error in the input (exit status 2, like sh).
+type syntaxError string
+
+func (e syntaxError) Error() string {
+	return "syntax error near unexpected token `" + string(e) + "'"
+}
+
+// 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
+		statusErr statusError
+	)
+	if err == nil || errors.As(err, &exitErr) || errors.As(err, &statusErr) {
+		return
 	}
-	if len(args) == 0 {
+	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 syntaxError(next)
+			}
+			return nil
+		}
+		items = append(items, listItem{op: op, command: command})
 		return nil
 	}
 
-	// Check for built-in commands.
+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 = exitStatus(err)
+		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 pipeline of simple commands with redirections.
+func execCommand(input string) error {
+	// Split the input into words and operators, expanding variables and ~ on
+	// the way.
+	tokens, err := tokenize(input)
+	var synErr syntaxError
+	if errors.As(err, &synErr) {
+		return err
+	}
+	if err != nil {
+		return fmt.Errorf("invalid input: %w", err)
+	}
+	stages, err := parsePipeline(tokens)
+	if err != nil {
+		return err
+	}
+	if len(stages) == 0 {
+		return nil
+	}
+	return runPipeline(stages)
+}
+
+// redirect is a redirection of a simple command, e.g. 2>>file or 2>&1.
+type redirect struct {
+	op   string // <, >, >>, &>, &>>, >& or <&
+	fd   int    // the redirected file descriptor
+	dup  int    // the target file descriptor of >& and <&
+	file string // the file name for all other operators
+}
+
+// stage is a simple command of a pipeline.
+type stage struct {
+	args      []string
+	redirects []redirect
+}
+
+// parsePipeline groups tokens into the stages of a pipeline.
+func parsePipeline(tokens []token) ([]stage, error) {
+	var (
+		stages []stage
+		cur    stage
+	)
+	isEmpty := func(s stage) bool { return len(s.args) == 0 && len(s.redirects) == 0 }
+
+	for i := 0; i < len(tokens); i++ {
+		t := tokens[i]
+		switch t.op {
+		case "":
+			cur.args = append(cur.args, expandWord(t)...)
+		case "|":
+			if isEmpty(cur) {
+				return nil, syntaxError("|")
+			}
+			stages = append(stages, cur)
+			cur = stage{}
+		case ">&", "<&":
+			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, dup: t.dup})
+		default:
+			if i+1 == len(tokens) {
+				return nil, syntaxError("newline")
+			}
+			if next := tokens[i+1]; next.op != "" {
+				return nil, syntaxError(next.op)
+			}
+			i++
+			files := expandWord(tokens[i])
+			if len(files) > 1 {
+				return nil, fmt.Errorf("%s: ambiguous redirect", sanitize(tokens[i].word))
+			}
+			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, file: files[0]})
+		}
+	}
+
+	if isEmpty(cur) {
+		if len(stages) > 0 {
+			return nil, syntaxError("|")
+		}
+		return nil, nil
+	}
+	return append(stages, cur), nil
+}
+
+// runPipeline runs the stages of a pipeline concurrently, connecting the
+// stdout of each stage to the stdin of the next one. It returns the error of
+// the last stage (so $? is its exit status, like in sh); errors of the other
+// stages are printed.
+func runPipeline(stages []stage) error {
+	waits := make([]func() error, len(stages))
+	stdin := os.Stdin
+	for i, st := range stages {
+		stdout := os.Stdout
+		var next *os.File
+		if i < len(stages)-1 {
+			r, w, err := os.Pipe()
+			if err != nil {
+				// Let the stages that already run finish
+				if stdin != os.Stdin {
+					stdin.Close()
+				}
+				for _, wait := range waits[:i] {
+					printError(wait())
+				}
+				return err
+			}
+			stdout, next = w, r
+		}
+		waits[i] = startStage(st, stdin, stdout, len(stages) > 1)
+		stdin = next
+	}
+
+	var err error
+	for i, wait := range waits {
+		err = wait()
+		if i < len(waits)-1 {
+			printError(err)
+		}
+	}
+	return err
+}
+
+// startStage starts a stage of a pipeline with the given stdin and stdout and
+// returns a function that waits for it to finish. Pipe ends passed in are
+// closed by startStage once the stage no longer needs them, so that the
+// neighbors see EOF or get SIGPIPE.
+func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error {
+	var owned []*os.File
+	if stdin != os.Stdin {
+		owned = append(owned, stdin)
+	}
+	if stdout != os.Stdout {
+		owned = append(owned, stdout)
+	}
+	closeOwned := func() {
+		for _, f := range owned {
+			f.Close()
+		}
+	}
+	result := func(err error) func() error {
+		return func() error { return err }
+	}
+
+	// Connect the command to the terminal unless redirected. Without Stdin
+	// the command would 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.
+	fds := [3]*os.File{stdin, stdout, os.Stderr}
+	opened, err := applyRedirects(&fds, st.redirects)
+	owned = append(owned, opened...)
+	if err != nil || len(st.args) == 0 {
+		// A command without arguments only creates or truncates the files
+		closeOwned()
+		return result(err)
+	}
+
+	if builtin, ok := builtins[st.args[0]]; ok {
+		if inPipeline && builtin.changesState {
+			closeOwned()
+			return result(fmt.Errorf("%s: cannot be used in a pipeline", st.args[0]))
+		}
+		run := func() error {
+			defer closeOwned()
+			err := runBuiltin(st.args, fds[1])
+			if err != nil && fds[2] != os.Stderr {
+				// Report the error where stderr is redirected to
+				fmt.Fprintln(fds[2], "gosh:", err)
+				return statusError(1)
+			}
+			return err
+		}
+		if !inPipeline {
+			return result(run())
+		}
+		done := make(chan error, 1)
+		go func() { done <- run() }()
+		return func() error { return <-done }
+	}
+
+	cmd := exec.Command(st.args[0], st.args[1:]...)
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = fds[0], fds[1], fds[2]
+	err = cmd.Start()
+	// The child has its own copies of the files now
+	closeOwned()
+	if errors.Is(err, exec.ErrNotFound) {
+		err = fmt.Errorf("%s: %w", sanitize(st.args[0]), errCommandNotFound)
+	}
+	if err != nil {
+		return result(err)
+	}
+	return cmd.Wait
+}
+
+// applyRedirects applies the redirections in order to fds (stdin, stdout,
+// stderr) and returns the files it opened.
+func applyRedirects(fds *[3]*os.File, redirects []redirect) ([]*os.File, error) {
+	var opened []*os.File
+	fail := func(err error) ([]*os.File, error) {
+		for _, f := range opened {
+			f.Close()
+		}
+		return nil, err
+	}
+
+	for _, r := range redirects {
+		if r.fd > 2 {
+			return fail(fmt.Errorf("%d: bad file descriptor", r.fd))
+		}
+		if r.op == ">&" || r.op == "<&" {
+			if r.dup > 2 {
+				return fail(fmt.Errorf("%d: bad file descriptor", r.dup))
+			}
+			fds[r.fd] = fds[r.dup]
+			continue
+		}
+
+		flags := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
+		switch r.op {
+		case "<":
+			flags = os.O_RDONLY
+		case ">>", "&>>":
+			flags = os.O_WRONLY | os.O_CREATE | os.O_APPEND
+		}
+		f, err := os.OpenFile(r.file, flags, 0666)
+		if err != nil {
+			// "file: No such file or directory" with exit status 1, like sh
+			var pathErr *fs.PathError
+			if errors.As(err, &pathErr) {
+				err = fmt.Errorf("%s: %v", sanitize(r.file), pathErr.Err)
+			}
+			return fail(err)
+		}
+		opened = append(opened, f)
+		fds[r.fd] = f
+		if r.op == "&>" || r.op == "&>>" {
+			fds[2] = f
+		}
+	}
+	return opened, nil
+}
+
+// builtins lists the built-in commands. Commands that change the state of
+// the shell cannot be used in a pipeline, since there they would run
+// concurrently (sh runs them in a subshell where they have no effect).
+var builtins = map[string]struct{ changesState bool }{
+	"cd":     {changesState: true},
+	"pwd":    {},
+	"exit":   {changesState: true},
+	"quit":   {changesState: true},
+	"set":    {changesState: true},
+	"export": {changesState: true},
+	"help":   {},
+}
+
+// runBuiltin executes a built-in command, writing its output to stdout.
+func runBuiltin(args []string, stdout io.Writer) error {
 	switch args[0] {
 	case "cd":
 		// Save current directory before changing (for 'cd -')
@@ -870,7 +1513,7 @@ func execInput(input string) error {
 		return os.Chdir(path)
 	case "pwd":
 		wd, err := os.Getwd()
-		fmt.Println(wd)
+		fmt.Fprintln(stdout, wd)
 		return err
 	case "exit":
 		// exit with optional status code
@@ -879,7 +1522,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 {
@@ -887,7 +1530,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 {
@@ -913,14 +1556,14 @@ func execInput(input string) error {
 		os.Setenv(parts[0], parts[1])
 		return nil
 	case "help":
-		fmt.Println("gosh - Go Shell\nVersion: " + versionInfo() + `
+		fmt.Fprintln(stdout, "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
@@ -934,28 +1577,22 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (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
+  - 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
+  - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
+    2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
     the exit status is the one of the last command`)
 		return nil
 	}
-
+	return fmt.Errorf("%s: not a builtin", args[0])
-	// Prepare the command to execute.
-	cmd := exec.Command(args[0], args[1:]...)
-
-	// Connect the command to the terminal. Without Stdin the command would
-	// 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()
 }

main_test.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"errors"
 	"bytes"
+	"errors"
 	"io"
 	"os"
 	"os/exec"
@@ -859,6 +859,15 @@ func TestShellCompleter_Do(t *testing.T) {
 		{"ls " + tmpDir + "/ma", []string{"in.go"}, 2},
 		{"ls xyz", nil, 3},
 		{"ls ~", []string{"/"}, 1},
+		// Commands are completed after |, ;, && and ||, files after redirections
+		{"ls | gi", []string{"tty "}, 2},
+		{"ls|gi", []string{"tty "}, 2},
+		{"true; gi", []string{"tty "}, 2},
+		{"true && gi", []string{"tty "}, 2},
+		{"false || gi", []string{"tty "}, 2},
+		{"ls > ma", []string{"in.go"}, 2},
+		{"ls 2>ma", []string{"in.go"}, 2},
+		{"cat <ma", []string{"in.go"}, 2},
 	}
 	for _, tt := range tests {
 		got, length := completeLine(tt.line)
@@ -1348,3 +1357,376 @@ func TestReadLine_DoesNotReadAhead(t *testing.T) {
 		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)
+	}
+}
+
+func TestTokenize_Operators(t *testing.T) {
+	tests := []struct {
+		input string
+		want  []token
+	}{
+		{"a | b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
+		{"a|b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
+		{"a > f", []token{{word: "a"}, {op: ">", fd: 1}, {word: "f"}}},
+		{"a >>f", []token{{word: "a"}, {op: ">>", fd: 1}, {word: "f"}}},
+		{"a < f", []token{{word: "a"}, {op: "<", fd: 0}, {word: "f"}}},
+		{"a 2>f", []token{{word: "a"}, {op: ">", fd: 2}, {word: "f"}}},
+		{"a 2>>f", []token{{word: "a"}, {op: ">>", fd: 2}, {word: "f"}}},
+		{"a 2>&1", []token{{word: "a"}, {op: ">&", fd: 2, dup: 1}}},
+		{"a >&2", []token{{word: "a"}, {op: ">&", fd: 1, dup: 2}}},
+		{"a 0<&2", []token{{word: "a"}, {op: "<&", fd: 0, dup: 2}}},
+		{"a &>f", []token{{word: "a"}, {op: "&>", fd: 1}, {word: "f"}}},
+		{"a &>>f", []token{{word: "a"}, {op: "&>>", fd: 1}, {word: "f"}}},
+		// Only a word of unquoted digits is a file descriptor
+		{"a x2>f", []token{{word: "a"}, {word: "x2"}, {op: ">", fd: 1}, {word: "f"}}},
+		{`a "2">f`, []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
+		{"a 2 >f", []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
+		// Quoted and escaped operators are words
+		{`echo "a|b" 'c>d' e\<f`, []token{{word: "echo"}, {word: "a|b"}, {word: "c>d"}, {word: "e<f"}}},
+		// A lone & is a word
+		{"a & b", []token{{word: "a"}, {word: "&"}, {word: "b"}}},
+		{"cat ~|x", []token{{word: "cat"}, {word: getHomeDir()}, {op: "|"}, {word: "x"}}},
+	}
+	for _, tc := range tests {
+		got, err := tokenize(tc.input)
+		if err != nil {
+			t.Errorf("tokenize(%q) returned error: %v", tc.input, err)
+			continue
+		}
+		// Patterns are tested in TestTokenize_Patterns
+		for i := range got {
+			got[i].pattern, got[i].glob = "", false
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("tokenize(%q) = %+v, want %+v", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_SyntaxErrors(t *testing.T) {
+	for _, input := range []string{"echo a |", "| echo a", "echo a | | b", "echo a >", "echo a > | b", "echo a >&", "echo a 2>&x", "; a"} {
+		err := execInput(input)
+		if err == nil || !strings.Contains(err.Error(), "syntax error") {
+			t.Errorf("execInput(%q) = %v, want syntax error", input, err)
+		}
+		if lastStatus != 2 {
+			t.Errorf("execInput(%q): $? = %d, want 2", input, lastStatus)
+		}
+	}
+}
+
+func TestExecInput_PipesAndRedirections(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+
+	read := func(name string) string {
+		data, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Errorf("reading %s: %v", name, err)
+		}
+		return string(data)
+	}
+
+	tests := []struct {
+		input  string
+		file   string
+		want   string
+		status int
+	}{
+		{`printf 'b\na\nc\n' | sort | head -n 2 > out`, "out", "a\nb\n", 0},
+		{"echo one > f1; echo two >> f1", "f1", "one\ntwo\n", 0},
+		{"echo one > f2; echo two > f2", "f2", "two\n", 0},
+		{"tr a-z A-Z < f1 > f3", "f3", "ONE\nTWO\n", 0},
+		{"sh -c 'echo out; echo err >&2' > f4 2>&1", "f4", "out\nerr\n", 0},
+		{"sh -c 'echo out; echo err >&2' &> f5", "f5", "out\nerr\n", 0},
+		{"sh -c 'echo err >&2' 2> f6", "f6", "err\n", 0},
+		// 2>&1 before >file sends stderr to the old stdout (the pipe)
+		{"sh -c 'echo out; echo err >&2' 2>&1 > /dev/null | cat > f7", "f7", "err\n", 0},
+		{"sh -c 'echo err >&2' 2>&1 | tr a-z A-Z > f8", "f8", "ERR\n", 0},
+		// Builtins write to redirections and pipes
+		{"pwd > f9", "f9", dir + "\n", 0},
+		{"pwd | cat > f10", "f10", dir + "\n", 0},
+		{"help | head -n 1 > f11", "f11", "gosh - Go Shell\n", 0},
+		// Errors of builtins go to the redirected stderr
+		{"cd /gosh/no/such/dir 2> f12", "f12", "gosh: chdir /gosh/no/such/dir: no such file or directory\n", 1},
+		// The status of a pipeline is the one of the last command
+		{"false | true > f13", "f13", "", 0},
+		{"true | false > f14", "f14", "", 1},
+		// A redirection without a command creates the file
+		{"> f15", "f15", "", 0},
+		// SIGPIPE ends the writer when the reader exits
+		{"yes | head -n 1 > f16", "f16", "y\n", 0},
+		// A command that is not found does not stop the pipeline
+		{"gosh-no-such-command | echo after > f17", "f17", "after\n", 0},
+		{"echo before | gosh-no-such-command 2> f18", "f18", "", 127},
+	}
+	for _, tc := range tests {
+		execInput(tc.input)
+		if lastStatus != tc.status {
+			t.Errorf("%q: $? = %d, want %d", tc.input, lastStatus, tc.status)
+		}
+		if got := read(tc.file); got != tc.want {
+			t.Errorf("%q: %s = %q, want %q", tc.input, tc.file, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_RedirectionErrors(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	os.Chdir(t.TempDir())
+
+	tests := []struct {
+		input   string
+		wantErr string
+	}{
+		{"cat < gosh-no-such-file", "gosh-no-such-file: no such file or directory"},
+		{"echo a > gosh-no-such-dir/f", "gosh-no-such-dir/f: no such file or directory"},
+		{"echo a 3> f", "3: bad file descriptor"},
+		{"echo a 2>&5", "5: bad file descriptor"},
+		{"echo a | cd /", "cd: cannot be used in a pipeline"},
+		{"echo a | exit 3", "exit: cannot be used in a pipeline"},
+	}
+	for _, tc := range tests {
+		err := execInput(tc.input)
+		if err == nil || err.Error() != tc.wantErr {
+			t.Errorf("execInput(%q) = %v, want %q", tc.input, err, tc.wantErr)
+		}
+		if lastStatus != 1 {
+			t.Errorf("execInput(%q): $? = %d, want 1", tc.input, lastStatus)
+		}
+	}
+	// The command is not run if a redirection fails
+	if _, err := os.Stat("f"); err == nil {
+		t.Error("file f must not be created for a bad file descriptor")
+	}
+}
+
+func TestTokenize_Patterns(t *testing.T) {
+	t.Setenv("GOSH_GLOB", "*.go")
+	tests := []struct {
+		input   string
+		pattern string
+		glob    bool
+	}{
+		{"*.go", "*.go", true},
+		{"a?c", "a?c", true},
+		{"[ab].go", "[ab].go", true},
+		{"[!a].go", "[^a].go", true},
+		{"plain", "plain", false},
+		// Quoted, escaped and expanded characters are literal
+		{`"*.go"`, `\*.go`, false},
+		{`'*'.go`, `\*.go`, false},
+		{`\*.go`, `\*.go`, false},
+		{`"x"*`, `x*`, true},
+		{"$GOSH_GLOB", `\*.go`, false},
+		{`'['!a].go`, `\[!a].go`, false},
+	}
+	for _, tc := range tests {
+		tokens, err := tokenize(tc.input)
+		if err != nil || len(tokens) != 1 {
+			t.Errorf("tokenize(%q) = %+v, %v", tc.input, tokens, err)
+			continue
+		}
+		if tokens[0].pattern != tc.pattern || tokens[0].glob != tc.glob {
+			t.Errorf("tokenize(%q): pattern %q, glob %v; want %q, %v",
+				tc.input, tokens[0].pattern, tokens[0].glob, tc.pattern, tc.glob)
+		}
+	}
+}
+
+func TestExpandGlob(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, d := range []string{"sub/deep", "other"} {
+		os.MkdirAll(d, 0755)
+	}
+	for _, f := range []string{"a.go", "b.go", "c.txt", ".hidden.go", "with space.go", "[x].go", "sub/s1.go", "sub/deep/d.go", "other/o.go"} {
+		os.WriteFile(f, nil, 0644)
+	}
+
+	tests := []struct {
+		pattern string
+		want    []string
+	}{
+		{"*.go", []string{"[x].go", "a.go", "b.go", "with space.go"}},
+		{".*.go", []string{".hidden.go"}},
+		{"?.go", []string{"a.go", "b.go"}},
+		{"[ab].go", []string{"a.go", "b.go"}},
+		{"[^a].go", []string{"b.go"}},
+		{"*/*.go", []string{"other/o.go", "sub/s1.go"}},
+		{"*/", []string{"other/", "sub/"}},
+		{"sub/*/*.go", []string{"sub/deep/d.go"}},
+		{"./c*", []string{"./c.txt"}},
+		{dir + "/c*", []string{dir + "/c.txt"}},
+		{`\[x\].go`, []string{"[x].go"}},
+		{"*.xyz", nil},
+		{"[", nil},
+	}
+	for _, tc := range tests {
+		if got := expandGlob(tc.pattern); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("expandGlob(%q) = %q, want %q", tc.pattern, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_Wildcards(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, f := range []string{"a.go", "b.go", "c.txt"} {
+		os.WriteFile(f, []byte(f+"\n"), 0644)
+	}
+
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"echo *.go > out", "a.go b.go\n"},
+		{"cat *.go > out", "a.go\nb.go\n"},
+		// No match: the word is passed on unchanged, like in sh
+		{"echo *.xyz > out", "*.xyz\n"},
+		{`echo "*.go" '?.go' \*.go > out`, "*.go ?.go *.go\n"},
+		// A redirection to a pattern with a single match uses that file
+		{"echo hi > *.txt; cat c.txt > out", "hi\n"},
+	}
+	for _, tc := range tests {
+		if err := execInput(tc.input); err != nil {
+			t.Errorf("execInput(%q) returned error: %v", tc.input, err)
+		}
+		if got, _ := os.ReadFile("out"); string(got) != tc.want {
+			t.Errorf("%q: got %q, want %q", tc.input, got, tc.want)
+		}
+	}
+
+	err := execInput("echo hi > *.go")
+	if err == nil || err.Error() != "*.go: ambiguous redirect" {
+		t.Errorf("expected ambiguous redirect error, got %v", err)
+	}
+}