prime8dev

shell_cmds.go (28752B)

---

 package tui
 
 import (
 	"fmt"
 	"math/rand"
 	"path"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/charmbracelet/lipgloss"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/vfs"
 )
 
 // Commands for the about-page shell. Behaviour follows the web shell
 // (internal/web/scripts/modules/shell-cmds.js); writes land in the session's
 // in-memory overlay (vfs.FS) and are gone when the SSH session ends.
 
 // shellCtx is what a command sees: its argv, stdin, where its output goes, and
 // whether that is the terminal (styled) or a pipe/file (plain text).
 type shellCtx struct {
 	s     *shellState
 	fs    *vfs.FS
 	env   shellEnv
 	argv  []string
 	stdin string
 	tty   bool
 	out   func(string)
 	err   func(string)
 	res   *shellResult
 }
 
 func (c *shellCtx) resolve(p string) string { return vfs.Resolve(c.s.home, c.s.cwd, p) }
 
 func (c *shellCtx) display(abs string) string { return vfs.DisplayPath(c.s.home, abs) }
 
 type shellCmd func(c *shellCtx) int
 
 var shellUsage = map[string]string{
 	"cat":      "cat [-n] [file...]        print files (or stdin)",
 	"cd":       "cd [dir|-]                change directory (~ is home, - is the last one)",
 	"clear":    "clear                     clear the screen",
 	"cp":       "cp [-r] src... dest       copy files and directories",
 	"date":     "date                      print the date and time",
 	"echo":     "echo [-n] [-e] [text...]  print text",
 	"env":      "env                       print environment variables",
 	"exit":     "exit                      close the session",
 	"export":   "export [NAME=value...]    set environment variables",
 	"false":    "false                     do nothing, unsuccessfully",
 	"fetch":    "fetch                     system info, the same card as the top of the page",
 	"grep":     "grep [-invcrlwFq] pattern [file...]  search for a regex",
 	"head":     "head [-n N] [file...]     first N lines (default 10)",
 	"help":     "help                      list commands",
 	"history":  "history [-c]              command history (-c clears it)",
 	"hostname": "hostname                  print the host name",
 	"id":       "id                        print user and group ids",
 	"ls":       "ls [-a1d] [path...]       list directory contents",
 	"man":      "man command               show usage for a command",
 	"mkdir":    "mkdir [-p] dir...         make directories",
 	"mv":       "mv src... dest            move or rename",
 	"pwd":      "pwd                       print working directory",
 	"restore":  "restore                   drop your changes, back to the original files",
 	"rm":       "rm [-rf] path...          remove files and directories",
 	"rmdir":    "rmdir dir...              remove empty directories",
 	"sort":     "sort [-rnu] [file...]     sort lines",
 	"tail":     "tail [-n N] [file...]     last N lines (default 10)",
 	"tee":      "tee [-a] file...          copy stdin to files and stdout",
 	"touch":    "touch file...             create files",
 	"tree":     "tree [-a] [path]          draw a directory tree",
 	"true":     "true                      do nothing, successfully",
 	"type":     "type name...              say what a command is",
 	"uname":    "uname [-a]                print system information",
 	"uniq":     "uniq [-c] [file...]       collapse repeated lines",
 	"unset":    "unset NAME...             remove environment variables",
 	"uptime":   "uptime                    how long this session has been up",
 	"wc":       "wc [-lwc] [file...]       count lines, words and bytes",
 	"which":    "which command...          locate a command",
 	"whoami":   "whoami                    print the user name",
 }
 
 const shellHelpText = `prime8 shell. what you create here lasts until you disconnect.
 
   navigate   ls cd pwd tree
   read       cat head tail wc grep sort uniq
   write      echo touch mkdir cp mv rm rmdir tee
   system     fetch whoami id hostname uname date uptime env export
   session    clear history man restore exit
 
 pipes |, redirects > >> < 2>, ; && ||, globs * ? [ ], $VARS and ~ all work.
 man <cmd> for usage. try: cat about, tree projects, echo hi > notes && cat notes`
 
 var shellBuiltins = map[string]bool{
 	"cd": true, "echo": true, "exit": true, "logout": true, "export": true, "history": true,
 	"pwd": true, "type": true, "unset": true, "help": true, "true": true, "false": true,
 }
 
 var shellCommandTable map[string]shellCmd
 
 // shellCommands is every command name, sorted, for completion.
 var shellCommands []string
 
 func init() {
 	shellCommandTable = map[string]shellCmd{
 		"cat": cmdCat, "cd": cmdCd, "clear": cmdClear, "cp": cmdCp, "date": cmdDate,
 		"echo": cmdEcho, "env": cmdEnv, "exit": cmdExit, "logout": cmdExit, "export": cmdExport,
 		"false": func(*shellCtx) int { return 1 }, "fetch": cmdFetch, "grep": cmdGrep,
 		"head": func(c *shellCtx) int { return headTail(c, false) }, "help": cmdHelp,
 		"history": cmdHistory, "hostname": cmdHostname, "id": cmdID, "ls": cmdLs, "man": cmdMan,
 		"mkdir": cmdMkdir, "mv": cmdMv, "pwd": cmdPwd, "restore": cmdRestore, "rm": cmdRm,
 		"rmdir": cmdRmdir, "sort": cmdSort, "sudo": cmdSudo,
 		"tail": func(c *shellCtx) int { return headTail(c, true) }, "tee": cmdTee,
 		"touch": cmdTouch, "tree": cmdTree, "true": func(*shellCtx) int { return 0 },
 		"type": cmdType, "uname": cmdUname, "uniq": cmdUniq, "unset": cmdUnset,
 		"uptime": cmdUptime, "wc": cmdWc, "which": cmdWhich, "whoami": cmdWhoami,
 	}
 	for name := range shellCommandTable {
 		shellCommands = append(shellCommands, name)
 	}
 	sort.Strings(shellCommands)
 }
 
 // --- helpers ---
 
 // shellFlags splits leading -abc options from operands. Letters in withValue
 // take the next argument (or the rest of the cluster) as their value.
 func shellFlags(args []string, withValue string) (map[byte]string, []string) {
 	set := map[byte]string{}
 	var rest []string
 	i := 0
 	for ; i < len(args); i++ {
 		a := args[i]
 		if a == "--" {
 			i++
 			break
 		}
 		if !strings.HasPrefix(a, "-") || a == "-" || (len(a) > 1 && a[1] >= '0' && a[1] <= '9') {
 			rest = append(rest, a)
 			continue
 		}
 		for j := 1; j < len(a); j++ {
 			f := a[j]
 			if strings.IndexByte(withValue, f) >= 0 {
 				v := a[j+1:]
 				if v == "" && i+1 < len(args) {
 					i++
 					v = args[i]
 				}
 				set[f] = v
 				break
 			}
 			set[f] = "1"
 		}
 	}
 	rest = append(rest, args[i:]...)
 	return set, rest
 }
 
 func has(set map[byte]string, f byte) bool { _, ok := set[f]; return ok }
 
 func textLines(text string) []string {
 	if text == "" {
 		return nil
 	}
 	ls := strings.Split(text, "\n")
 	if ls[len(ls)-1] == "" {
 		ls = ls[:len(ls)-1]
 	}
 	return ls
 }
 
 func joinLines(ls []string) string {
 	if len(ls) == 0 {
 		return ""
 	}
 	return strings.Join(ls, "\n") + "\n"
 }
 
 // fileText is a file's content as a text stream: the generated files carry
 // no trailing newline, so add one like a real text file would have.
 func fileText(n *vfs.Node) string {
 	if n.Content == "" || strings.HasSuffix(n.Content, "\n") {
 		return n.Content
 	}
 	return n.Content + "\n"
 }
 
 type shellInput struct{ name, text string }
 
 // readInputs yields each file operand's text, or stdin when there are none.
 func readInputs(c *shellCtx, files []string) []shellInput {
 	if len(files) == 0 {
 		return []shellInput{{"", c.stdin}}
 	}
 	var out []shellInput
 	for _, f := range files {
 		if f == "-" {
 			out = append(out, shellInput{"-", c.stdin})
 			continue
 		}
 		if c.resolve(f) == "/dev/null" {
 			out = append(out, shellInput{f, ""})
 			continue
 		}
 		n := c.fs.Get(c.resolve(f))
 		switch {
 		case n == nil:
 			c.err(c.argv[0] + ": " + f + ": No such file or directory\n")
 		case n.Dir:
 			c.err(c.argv[0] + ": " + f + ": Is a directory\n")
 		default:
 			out = append(out, shellInput{f, fileText(n)})
 		}
 	}
 	return out
 }
 
 func inputsStatus(inputs []shellInput, files []string) int {
 	if len(inputs) == max(len(files), 1) {
 		return 0
 	}
 	return 1
 }
 
 func (c *shellCtx) name(n *vfs.Node, label string) string {
 	if c.tty && n != nil && n.Dir {
 		return shellDirStyle.Render(label)
 	}
 	return label
 }
 
 func errText(err error) string {
 	if err == nil {
 		return ""
 	}
 	return err.Error()
 }
 
 // writeFile creates, replaces or appends to a file through the overlay.
 func writeFile(c *shellCtx, p, content string, appendTo bool) error {
 	abs := c.resolve(p)
 	if abs == "/dev/null" {
 		return nil
 	}
 	n := c.fs.Get(abs)
 	if n != nil && n.Dir {
 		return vfs.ErrIsDir
 	}
 	if err := c.fs.CheckCreate(abs); err != nil {
 		return err
 	}
 	if appendTo && n != nil {
 		content = n.Content + content
 	}
 	return c.fs.Write(abs, content)
 }
 
 func pad2(n int) string { return fmt.Sprintf("%02d", n) }
 
 // --- commands ---
 
 func cmdHelp(c *shellCtx) int {
 	c.out(shellHelpText + "\n")
 	return 0
 }
 
 func cmdMan(c *shellCtx) int {
 	if len(c.argv) < 2 {
 		c.err("What manual page do you want?\nFor example, try 'man man'.\n")
 		return 1
 	}
 	name := c.argv[1]
 	u, ok := shellUsage[name]
 	if name == "man" {
 		u, ok = shellUsage["man"], true
 	}
 	if !ok {
 		c.err("No manual entry for " + name + "\n")
 		return 16
 	}
 	c.out(strings.ToUpper(name) + "(1)\n\n  " + u + "\n")
 	return 0
 }
 
 func cmdPwd(c *shellCtx) int      { c.out(c.s.cwd + "\n"); return 0 }
 func cmdWhoami(c *shellCtx) int   { c.out(c.s.user + "\n"); return 0 }
 func cmdHostname(c *shellCtx) int { c.out("prime8\n"); return 0 }
 
 func cmdID(c *shellCtx) int {
 	u := c.s.user
 	c.out(fmt.Sprintf("uid=1000(%s) gid=1000(%s) groups=1000(%s)\n", u, u, u))
 	return 0
 }
 
 func cmdUname(c *shellCtx) int {
 	set, _ := shellFlags(c.argv[1:], "")
 	if has(set, 'a') {
 		c.out("Linux prime8 6.12.0-prime8 #1 SMP PREEMPT_DYNAMIC x86_64 GNU/Linux\n")
 	} else {
 		c.out("Linux\n")
 	}
 	return 0
 }
 
 func cmdFetch(c *shellCtx) int {
 	if c.env.fetch == nil {
 		c.err("fetch: no system info\n")
 		return 1
 	}
 	card := c.env.fetch(c.tty)
 	if strings.TrimSpace(card) == "" {
 		c.err("fetch: no system info\n")
 		return 1
 	}
 	c.out(card + "\n")
 	return 0
 }
 
 func shellNow(c *shellCtx) time.Time {
 	if c.env.now.IsZero() {
 		return time.Now()
 	}
 	return c.env.now
 }
 
 func cmdDate(c *shellCtx) int {
 	c.out(shellNow(c).Format("Mon Jan _2 15:04:05 MST 2006") + "\n")
 	return 0
 }
 
 func cmdUptime(c *shellCtx) int {
 	now := shellNow(c)
 	mins := 0
 	if !c.s.started.IsZero() {
 		mins = int(now.Sub(c.s.started).Minutes())
 	}
 	up := fmt.Sprintf("%d min", mins)
 	if mins >= 60 {
 		up = fmt.Sprintf("%d:%s", mins/60, pad2(mins%60))
 	}
 	load := func() string { return fmt.Sprintf("%.2f", rand.Float64()*0.2) }
 	c.out(fmt.Sprintf(" %s up %s,  1 user,  load average: %s, %s, %s\n", now.Format("15:04:05"), up, load(), load(), load()))
 	return 0
 }
 
 func cmdEcho(c *shellCtx) int {
 	args := c.argv[1:]
 	newline, escapes := true, false
 	for len(args) > 0 && echoFlagRE.MatchString(args[0]) {
 		if strings.Contains(args[0], "n") {
 			newline = false
 		}
 		if strings.Contains(args[0], "e") {
 			escapes = true
 		}
 		if strings.Contains(args[0], "E") {
 			escapes = false
 		}
 		args = args[1:]
 	}
 	s := strings.Join(args, " ")
 	if escapes {
 		s = strings.NewReplacer(`\n`, "\n", `\t`, "\t", `\r`, "\r", `\\`, `\`).Replace(s)
 	}
 	if newline {
 		s += "\n"
 	}
 	c.out(s)
 	return 0
 }
 
 func cmdEnv(c *shellCtx) int {
 	env := c.s.envMap()
 	keys := make([]string, 0, len(env))
 	for k := range env {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 	for _, k := range keys {
 		c.out(k + "=" + env[k] + "\n")
 	}
 	return 0
 }
 
 var shellAssignRE = regexp.MustCompile(`^([A-Za-z_][A-Za-z0-9_]*)=(.*)$`)
 
 func cmdExport(c *shellCtx) int {
 	if len(c.argv) == 1 {
 		return cmdEnv(c)
 	}
 	status := 0
 	for _, a := range c.argv[1:] {
 		if m := shellAssignRE.FindStringSubmatch(a); m != nil {
 			c.s.setVar(m[1], m[2])
 		} else if !shellAssignRE.MatchString(a + "=") {
 			c.err("export: `" + a + "': not a valid identifier\n")
 			status = 1
 		}
 	}
 	return status
 }
 
 func cmdUnset(c *shellCtx) int {
 	for _, a := range c.argv[1:] {
 		delete(c.s.vars, a)
 	}
 	return 0
 }
 
 func cmdHistory(c *shellCtx) int {
 	set, _ := shellFlags(c.argv[1:], "")
 	if has(set, 'c') {
 		c.s.cmdHistory = nil
 		return 0
 	}
 	for i, l := range c.s.cmdHistory {
 		c.out(fmt.Sprintf("%5d  %s\n", i+1, l))
 	}
 	return 0
 }
 
 func cmdClear(c *shellCtx) int {
 	if c.tty {
 		c.res.clear = true
 	}
 	return 0
 }
 
 func cmdExit(c *shellCtx) int {
 	c.res.quit = true
 	return 0
 }
 
 func cmdSudo(c *shellCtx) int {
 	c.err(c.s.user + " is not in the sudoers file. This incident will be reported.\n")
 	return 1
 }
 
 func cmdRestore(c *shellCtx) int {
 	n := c.s.overlay.Changes()
 	c.s.overlay.Reset()
 	c.out(fmt.Sprintf("restored the original files (%d change%s dropped)\n", n, plural(n, "", "s")))
 	return 0
 }
 
 func plural(n int, one, many string) string {
 	if n == 1 {
 		return one
 	}
 	return many
 }
 
 func cmdWhich(c *shellCtx) int {
 	status := 0
 	for _, a := range c.argv[1:] {
 		switch {
 		case shellBuiltins[a]:
 			c.out(a + ": shell built-in command\n")
 		case shellCommandTable[a] != nil:
 			c.out("/usr/bin/" + a + "\n")
 		default:
 			status = 1
 		}
 	}
 	return status
 }
 
 func cmdType(c *shellCtx) int {
 	status := 0
 	for _, a := range c.argv[1:] {
 		switch {
 		case shellBuiltins[a]:
 			c.out(a + " is a shell builtin\n")
 		case shellCommandTable[a] != nil:
 			c.out(a + " is /usr/bin/" + a + "\n")
 		default:
 			c.err("type: " + a + ": not found\n")
 			status = 1
 		}
 	}
 	return status
 }
 
 func cmdCd(c *shellCtx) int {
 	args := c.argv[1:]
 	if len(args) > 1 {
 		c.err("cd: too many arguments\n")
 		return 1
 	}
 	target := ""
 	if len(args) == 1 {
 		target = args[0]
 	}
 	if target == "-" {
 		if c.s.oldpwd == "" {
 			c.err("cd: OLDPWD not set\n")
 			return 1
 		}
 		target = c.s.oldpwd
 		c.out(target + "\n")
 	}
 	abs := c.resolve(target)
 	n := c.fs.Get(abs)
 	switch {
 	case n == nil:
 		c.err("cd: " + target + ": No such file or directory\n")
 		return 1
 	case !n.Dir:
 		c.err("cd: " + target + ": Not a directory\n")
 		return 1
 	}
 	c.s.oldpwd, c.s.cwd = c.s.cwd, abs
 	return 0
 }
 
 func cmdLs(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	all := has(set, 'a') || has(set, 'A')
 	perLine := has(set, '1') || !c.tty
 	if len(rest) == 0 {
 		rest = []string{"."}
 	}
 	status := 0
 	show := func(names []string, nodes []*vfs.Node) {
 		if len(names) == 0 {
 			return
 		}
 		parts := make([]string, len(names))
 		for i := range names {
 			label := names[i]
 			if c.tty && nodes[i].Dir {
 				label += "/"
 			}
 			parts[i] = c.name(nodes[i], label)
 		}
 		if perLine {
 			c.out(strings.Join(parts, "\n") + "\n")
 		} else {
 			c.out(strings.Join(parts, "  ") + "\n")
 		}
 	}
 	var fileNames []string
 	var fileNodes []*vfs.Node
 	type dirArg struct {
 		p string
 		n *vfs.Node
 	}
 	var dirs []dirArg
 	for _, p := range rest {
 		n := c.fs.Get(c.resolve(p))
 		switch {
 		case n == nil:
 			c.err("ls: cannot access '" + p + "': No such file or directory\n")
 			status = 2
 		case n.Dir && !has(set, 'd'):
 			dirs = append(dirs, dirArg{p, n})
 		default:
 			fileNames = append(fileNames, p)
 			fileNodes = append(fileNodes, n)
 		}
 	}
 	show(fileNames, fileNodes)
 	headers := len(dirs)+len(fileNames) > 1
 	for i, d := range dirs {
 		if i > 0 || len(fileNames) > 0 {
 			c.out("\n")
 		}
 		if headers {
 			c.out(d.p + ":\n")
 		}
 		var names []string
 		var nodes []*vfs.Node
 		for _, k := range d.n.SortedChildren() {
 			if !all && strings.HasPrefix(k.Name, ".") {
 				continue
 			}
 			names = append(names, k.Name)
 			nodes = append(nodes, k)
 		}
 		show(names, nodes)
 	}
 	return status
 }
 
 func cmdCat(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	inputs := readInputs(c, rest)
 	var b strings.Builder
 	for _, in := range inputs {
 		b.WriteString(in.text)
 	}
 	text := b.String()
 	if has(set, 'n') {
 		ls := textLines(text)
 		for i, l := range ls {
 			ls[i] = fmt.Sprintf("%6d\t%s", i+1, l)
 		}
 		text = joinLines(ls)
 	}
 	c.out(text)
 	return inputsStatus(inputs, rest)
 }
 
 func cmdTree(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	p := "."
 	if len(rest) > 0 {
 		p = rest[0]
 	}
 	root := c.fs.Get(c.resolve(p))
 	if root == nil {
 		c.err(p + " [error opening dir]\n\n0 directories, 0 files\n")
 		return 2
 	}
 	dirs, files := 0, 0
 	var b strings.Builder
 	b.WriteString(c.name(root, p) + "\n")
 	var walk func(n *vfs.Node, prefix string)
 	walk = func(n *vfs.Node, prefix string) {
 		var kids []*vfs.Node
 		for _, k := range n.SortedChildren() {
 			if has(set, 'a') || !strings.HasPrefix(k.Name, ".") {
 				kids = append(kids, k)
 			}
 		}
 		for i, k := range kids {
 			last := i == len(kids)-1
 			branch, next := "├── ", "│   "
 			if last {
 				branch, next = "└── ", "    "
 			}
 			b.WriteString(prefix + branch + c.name(k, k.Name) + "\n")
 			if k.Dir {
 				dirs++
 				walk(k, prefix+next)
 			} else {
 				files++
 			}
 		}
 	}
 	if root.Dir {
 		walk(root, "")
 	}
 	fmt.Fprintf(&b, "\n%d director%s, %d file%s\n", dirs, plural(dirs, "y", "ies"), files, plural(files, "", "s"))
 	c.out(b.String())
 	return 0
 }
 
 func headTail(c *shellCtx, tail bool) int {
 	args := make([]string, len(c.argv)-1)
 	for i, a := range c.argv[1:] {
 		if headCountRE.MatchString(a) {
 			a = "-n" + a[1:]
 		}
 		args[i] = a
 	}
 	set, rest := shellFlags(args, "n")
 	n := 10
 	if v, ok := set['n']; ok {
 		x, err := strconv.Atoi(v)
 		if err != nil || x < 0 {
 			c.err(c.argv[0] + ": invalid number of lines: '" + v + "'\n")
 			return 1
 		}
 		n = x
 	}
 	inputs := readInputs(c, rest)
 	for i, in := range inputs {
 		if len(inputs) > 1 {
 			if i > 0 {
 				c.out("\n")
 			}
 			c.out("==> " + in.name + " <==\n")
 		}
 		ls := textLines(in.text)
 		if tail {
 			ls = ls[max(len(ls)-n, 0):]
 		} else {
 			ls = ls[:min(n, len(ls))]
 		}
 		c.out(joinLines(ls))
 	}
 	return inputsStatus(inputs, rest)
 }
 
 func cmdWc(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	pickL, pickW, pickC := has(set, 'l'), has(set, 'w'), has(set, 'c')
 	if !pickL && !pickW && !pickC {
 		pickL, pickW, pickC = true, true, true
 	}
 	inputs := readInputs(c, rest)
 	type row struct {
 		l, w, b int
 		name    string
 	}
 	var rows []row
 	for _, in := range inputs {
 		rows = append(rows, row{strings.Count(in.text, "\n"), len(strings.Fields(in.text)), len(in.text), in.name})
 	}
 	if len(rows) > 1 {
 		t := row{name: "total"}
 		for _, r := range rows {
 			t.l, t.w, t.b = t.l+r.l, t.w+r.w, t.b+r.b
 		}
 		rows = append(rows, t)
 	}
 	cols := 0
 	for _, p := range []bool{pickL, pickW, pickC} {
 		if p {
 			cols++
 		}
 	}
 	width := 1
 	if len(rest) == 0 && cols > 1 {
 		width = 7
 	}
 	for _, r := range rows {
 		for _, v := range []int{r.l, r.w, r.b} {
 			width = max(width, len(strconv.Itoa(v)))
 		}
 	}
 	for _, r := range rows {
 		var parts []string
 		if pickL {
 			parts = append(parts, fmt.Sprintf("%*d", width, r.l))
 		}
 		if pickW {
 			parts = append(parts, fmt.Sprintf("%*d", width, r.w))
 		}
 		if pickC {
 			parts = append(parts, fmt.Sprintf("%*d", width, r.b))
 		}
 		line := strings.Join(parts, " ")
 		if r.name != "" && r.name != "-" {
 			line += " " + r.name
 		}
 		c.out(line + "\n")
 	}
 	return inputsStatus(inputs, rest)
 }
 
 var shellMatchStyle = lipgloss.NewStyle().Foreground(colorAccent).Bold(true)
 
 func cmdGrep(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "e")
 	pattern, ok := set['e']
 	if !ok {
 		if len(rest) == 0 {
 			c.err("Usage: grep [OPTION]... PATTERNS [FILE]...\n")
 			return 2
 		}
 		pattern, rest = rest[0], rest[1:]
 	}
 	src := pattern
 	if has(set, 'F') {
 		src = regexp.QuoteMeta(pattern)
 	}
 	if has(set, 'w') {
 		src = `\b(?:` + src + `)\b`
 	}
 	if has(set, 'i') {
 		src = "(?i)" + src
 	}
 	re, err := regexp.Compile(src)
 	if err != nil {
 		lit := regexp.QuoteMeta(pattern)
 		if has(set, 'i') {
 			lit = "(?i)" + lit
 		}
 		re = regexp.MustCompile(lit)
 	}
 	recursive := has(set, 'r') || has(set, 'R')
 	var inputs []shellInput
 	errs := false
 	if len(rest) == 0 {
 		if recursive {
 			rest = []string{"."}
 		} else {
 			inputs = append(inputs, shellInput{"", c.stdin})
 		}
 	}
 	var collect func(label string, n *vfs.Node)
 	collect = func(label string, n *vfs.Node) {
 		if !n.Dir {
 			inputs = append(inputs, shellInput{label, fileText(n)})
 			return
 		}
 		for _, k := range n.SortedChildren() {
 			collect(label+"/"+k.Name, k)
 		}
 	}
 	for _, f := range rest {
 		n := c.fs.Get(c.resolve(f))
 		switch {
 		case n == nil:
 			if !has(set, 's') {
 				c.err("grep: " + f + ": No such file or directory\n")
 			}
 			errs = true
 		case n.Dir && !recursive:
 			c.err("grep: " + f + ": Is a directory\n")
 			errs = true
 		default:
 			label := strings.TrimRight(f, "/")
 			if label == "" {
 				label = f
 			}
 			collect(label, n)
 		}
 	}
 	status := 1
 	prefix := len(inputs) > 1 || recursive
 	invert := has(set, 'v')
 	for _, in := range inputs {
 		count := 0
 		for i, l := range textLines(in.text) {
 			if re.MatchString(l) == invert {
 				continue
 			}
 			count++
 			status = 0
 			if has(set, 'l') || has(set, 'c') || has(set, 'q') {
 				continue
 			}
 			head := ""
 			if prefix {
 				head += in.name + ":"
 			}
 			if has(set, 'n') {
 				head += strconv.Itoa(i+1) + ":"
 			}
 			if c.tty && head != "" {
 				head = promptPathStyle.Render(head)
 			}
 			if has(set, 'o') && !invert {
 				for _, m := range re.FindAllString(l, -1) {
 					if m == "" {
 						continue
 					}
 					if c.tty {
 						m = shellMatchStyle.Render(m)
 					}
 					c.out(head + m + "\n")
 				}
 				continue
 			}
 			if c.tty && !invert {
 				l = re.ReplaceAllStringFunc(l, func(m string) string {
 					if m == "" {
 						return m
 					}
 					return shellMatchStyle.Render(m)
 				})
 			}
 			c.out(head + l + "\n")
 		}
 		if has(set, 'c') {
 			label := ""
 			if prefix {
 				label = in.name + ":"
 			}
 			c.out(label + strconv.Itoa(count) + "\n")
 		} else if has(set, 'l') && count > 0 {
 			c.out(in.name + "\n")
 		}
 	}
 	if errs && status != 0 {
 		return 2
 	}
 	return status
 }
 
 func cmdSort(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	inputs := readInputs(c, rest)
 	var ls []string
 	for _, in := range inputs {
 		ls = append(ls, textLines(in.text)...)
 	}
 	if has(set, 'n') {
 		num := func(s string) float64 {
 			f, _ := strconv.ParseFloat(strings.Fields(s + " x")[0], 64)
 			return f
 		}
 		sort.SliceStable(ls, func(i, j int) bool { return num(ls[i]) < num(ls[j]) })
 	} else {
 		sort.Strings(ls)
 	}
 	if has(set, 'r') {
 		for i, j := 0, len(ls)-1; i < j; i, j = i+1, j-1 {
 			ls[i], ls[j] = ls[j], ls[i]
 		}
 	}
 	if has(set, 'u') {
 		var u []string
 		for i, l := range ls {
 			if i == 0 || l != ls[i-1] {
 				u = append(u, l)
 			}
 		}
 		ls = u
 	}
 	c.out(joinLines(ls))
 	return inputsStatus(inputs, rest)
 }
 
 func cmdUniq(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	inputs := readInputs(c, rest)
 	var ls []string
 	for _, in := range inputs {
 		ls = append(ls, textLines(in.text)...)
 	}
 	var out []string
 	for i := 0; i < len(ls); {
 		j := i
 		for j < len(ls) && ls[j] == ls[i] {
 			j++
 		}
 		if has(set, 'c') {
 			out = append(out, fmt.Sprintf("%7d %s", j-i, ls[i]))
 		} else {
 			out = append(out, ls[i])
 		}
 		i = j
 	}
 	c.out(joinLines(out))
 	return inputsStatus(inputs, rest)
 }
 
 func cmdTee(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	status := 0
 	for _, f := range rest {
 		if err := writeFile(c, f, c.stdin, has(set, 'a')); err != nil {
 			c.err("tee: " + f + ": " + errText(err) + "\n")
 			status = 1
 		}
 	}
 	c.out(c.stdin)
 	return status
 }
 
 func cmdTouch(c *shellCtx) int {
 	_, rest := shellFlags(c.argv[1:], "")
 	if len(rest) == 0 {
 		c.err("touch: missing file operand\n")
 		return 1
 	}
 	status := 0
 	for _, f := range rest {
 		abs := c.resolve(f)
 		if abs == "/dev/null" {
 			continue
 		}
 		if n := c.fs.Get(abs); n != nil {
 			if !c.fs.Writable(abs) {
 				c.err("touch: cannot touch '" + f + "': Permission denied\n")
 				status = 1
 			}
 			continue
 		}
 		err := c.fs.CheckCreate(abs)
 		if err == nil {
 			err = c.fs.Write(abs, "")
 		}
 		if err != nil {
 			c.err("touch: cannot touch '" + f + "': " + errText(err) + "\n")
 			status = 1
 		}
 	}
 	return status
 }
 
 func cmdMkdir(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	if len(rest) == 0 {
 		c.err("mkdir: missing operand\n")
 		return 1
 	}
 	status := 0
 	for _, d := range rest {
 		abs := c.resolve(d)
 		fail := func(err error) {
 			c.err("mkdir: cannot create directory '" + d + "': " + errText(err) + "\n")
 			status = 1
 		}
 		if has(set, 'p') {
 			cur := ""
 			for _, part := range strings.Split(strings.Trim(abs, "/"), "/") {
 				if part == "" {
 					continue
 				}
 				cur += "/" + part
 				n := c.fs.Get(cur)
 				if n != nil && n.Dir {
 					continue
 				}
 				var err error
 				if n != nil {
 					err = vfs.ErrExist
 				} else if err = c.fs.CheckCreate(cur); err == nil {
 					err = c.fs.Mkdir(cur)
 				}
 				if err != nil {
 					fail(err)
 					break
 				}
 			}
 			continue
 		}
 		var err error
 		if c.fs.Get(abs) != nil {
 			err = vfs.ErrExist
 		} else if err = c.fs.CheckCreate(abs); err == nil {
 			err = c.fs.Mkdir(abs)
 		}
 		if err != nil {
 			fail(err)
 		}
 	}
 	return status
 }
 
 func cmdRmdir(c *shellCtx) int {
 	_, rest := shellFlags(c.argv[1:], "")
 	if len(rest) == 0 {
 		c.err("rmdir: missing operand\n")
 		return 1
 	}
 	status := 0
 	for _, d := range rest {
 		abs := c.resolve(d)
 		n := c.fs.Get(abs)
 		var err error
 		switch {
 		case n == nil:
 			err = vfs.ErrNotExist
 		case !n.Dir:
 			err = vfs.ErrNotDir
 		case len(n.Children) > 0:
 			err = vfs.ErrNotEmpty
 		default:
 			if err = c.fs.CheckCreate(abs); err == nil {
 				err = c.fs.Remove(abs)
 			}
 		}
 		if err != nil {
 			c.err("rmdir: failed to remove '" + d + "': " + errText(err) + "\n")
 			status = 1
 		}
 	}
 	return status
 }
 
 var (
 	echoFlagRE  = regexp.MustCompile(`^-[neE]+$`)
 	headCountRE = regexp.MustCompile(`^-\d+$`)
 )
 
 var dotPathRE = regexp.MustCompile(`(^|/)\.\.?/*$`)
 
 func cmdRm(c *shellCtx) int {
 	set, rest := shellFlags(c.argv[1:], "")
 	recursive := has(set, 'r') || has(set, 'R')
 	force := has(set, 'f')
 	if len(rest) == 0 {
 		if force {
 			return 0
 		}
 		c.err("rm: missing operand\n")
 		return 1
 	}
 	status := 0
 	for _, p := range rest {
 		abs := c.resolve(p)
 		if dotPathRE.MatchString(p) {
 			c.err("rm: refusing to remove '.' or '..' directory: skipping '" + p + "'\n")
 			status = 1
 			continue
 		}
 		if abs == "/" && recursive {
 			c.err("rm: it is dangerous to operate recursively on '/'\nrm: use --no-preserve-root to override this failsafe\n")
 			status = 1
 			continue
 		}
 		n := c.fs.Get(abs)
 		if n == nil {
 			if !force {
 				c.err("rm: cannot remove '" + p + "': No such file or directory\n")
 				status = 1
 			}
 			continue
 		}
 		if n.Dir && !recursive {
 			c.err("rm: cannot remove '" + p + "': Is a directory\n")
 			status = 1
 			continue
 		}
 		err := c.fs.CheckCreate(abs)
 		if err == nil {
 			err = c.fs.Remove(abs)
 		}
 		if err != nil {
 			c.err("rm: cannot remove '" + p + "': " + errText(err) + "\n")
 			status = 1
 		}
 	}
 	return status
 }
 
 func cmdCp(c *shellCtx) int { return transfer(c, false) }
 func cmdMv(c *shellCtx) int { return transfer(c, true) }
 
 func transfer(c *shellCtx, move bool) int {
 	name := c.argv[0]
 	set, rest := shellFlags(c.argv[1:], "")
 	recursive := has(set, 'r') || has(set, 'R') || has(set, 'a')
 	if len(rest) < 2 {
 		if len(rest) == 1 {
 			c.err(name + ": missing destination file operand after '" + rest[0] + "'\n")
 		} else {
 			c.err(name + ": missing file operand\n")
 		}
 		return 1
 	}
 	destArg := rest[len(rest)-1]
 	srcs := rest[:len(rest)-1]
 	destAbs := c.resolve(destArg)
 	destNode := c.fs.Get(destAbs)
 	destIsDir := destNode != nil && destNode.Dir
 	if len(srcs) > 1 && !destIsDir {
 		c.err(name + ": target '" + destArg + "': Not a directory\n")
 		return 1
 	}
 	verb := "create"
 	if move {
 		verb = "move"
 	}
 	status := 0
 	for _, src := range srcs {
 		srcAbs := c.resolve(src)
 		node := c.fs.Get(srcAbs)
 		fail := func(msg string) {
 			c.err(name + ": " + msg + "\n")
 			status = 1
 		}
 		if node == nil {
 			fail("cannot stat '" + src + "': No such file or directory")
 			continue
 		}
 		if node.Dir && !move && !recursive {
 			fail("-r not specified; omitting directory '" + src + "'")
 			continue
 		}
 		target := destAbs
 		if destIsDir {
 			target = path.Join(destAbs, path.Base(srcAbs))
 		}
 		if target == srcAbs {
 			fail("'" + src + "' and '" + destArg + "' are the same file")
 			continue
 		}
 		if node.Dir && strings.HasPrefix(target+"/", srcAbs+"/") {
 			op := "copy"
 			if move {
 				op = "move"
 			}
 			fail("cannot " + op + " '" + src + "' to a subdirectory of itself, '" + c.display(target) + "'")
 			continue
 		}
 		existing := c.fs.Get(target)
 		if existing != nil && existing.Dir && !node.Dir {
 			fail("cannot overwrite directory '" + c.display(target) + "' with non-directory")
 			continue
 		}
 		if existing != nil && !existing.Dir && node.Dir {
 			fail("cannot overwrite non-directory '" + c.display(target) + "' with directory '" + src + "'")
 			continue
 		}
 		err := c.fs.CheckCreate(target)
 		if err == nil && move {
 			err = c.fs.CheckCreate(srcAbs)
 		}
 		if err == nil {
 			err = c.fs.Copy(node, target)
 		}
 		if err == nil && move {
 			err = c.fs.Remove(srcAbs)
 		}
 		if err != nil {
 			fail("cannot " + verb + " '" + src + "': " + errText(err))
 		}
 	}
 	return status
 }