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>

.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
-  quit [code]   - Quit shell with optional status code
+  exit [code]   - Exit shell with status code (default: $?)
+  quit [code]   - Quit shell with status code (default: $?)
   set VAR=val   - Set environment variable
   export VAR=val - Export environment variable
   help          - Show this help
@@ -22,15 +23,122 @@ 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
 
 ```
 
+### 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 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
 
 Der Prompt wird über die Umgebungsvariable `GOSH_COLORS` eingefärbt. Sie besteht aus durch `:` getrennten Einträgen `schlüssel=code`:
@@ -102,6 +210,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_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
@@ -843,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)
@@ -1158,7 +1183,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 +1215,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()
@@ -1252,3 +1277,456 @@ func TestExecInput_PassesStdin(t *testing.T) {
 		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)
+	}
+}
+
+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)
+	}
+}