prime8dev

shell.go (14976B)

---

 package tui
 
 import (
 	"sort"
 	"strconv"
 	"strings"
 	"time"
 	"unicode"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/x/ansi"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/vfs"
 )
 
 const shellMaxHistory = 200
 
 var (
 	shellDirStyle   = lipgloss.NewStyle().Foreground(colorBlue).Bold(true)
 	shellErrorStyle = lipgloss.NewStyle().Foreground(colorRed)
 )
 
 type shellEntry struct {
 	cwd    string
 	input  string
 	output string
 	err    bool
 	// bare entries print output without a prompt line (output after clear).
 	bare bool
 }
 
 // shellState is the interactive prompt at the bottom of the about page.
 type shellState struct {
 	user   string
 	home   string
 	cwd    string
 	oldpwd string
 	input  string
 	// lastKey restarts the cursor blink: solid while typing, like a real terminal.
 	lastKey time.Time
 	history []shellEntry
 	// cleared hides the about-page intro, like `clear` in a real terminal.
 	cleared bool
 
 	// cmdHistory is what `history` lists; it survives `clear`.
 	cmdHistory []string
 	status     int
 	vars       map[string]string
 	started    time.Time
 	// overlay holds this session's writes over the shared read-only vfs. It
 	// is a pointer so copies of the model (bubbletea passes it by value)
 	// share one overlay; it lives as long as the SSH session.
 	overlay *vfs.Overlay
 }
 
 func newShellState(user string) shellState {
 	user = vfs.SanitizeUser(user)
 	home := vfs.HomeDir(user)
 	return shellState{
 		user:    user,
 		home:    home,
 		cwd:     home,
 		vars:    map[string]string{},
 		started: time.Now(),
 		overlay: vfs.NewOverlay(),
 	}
 }
 
 type shellResult struct {
 	output string
 	err    bool
 	clear  bool
 	quit   bool
 }
 
 // shellEnv is what a command line runs against.
 type shellEnv struct {
 	root  *vfs.Node // the shared, read-only generated tree; never mutated
 	now   time.Time
 	fetch func(tty bool) string
 }
 
 func (s *shellState) envMap() map[string]string {
 	env := map[string]string{
 		"HOME":     s.home,
 		"USER":     s.user,
 		"LOGNAME":  s.user,
 		"HOSTNAME": "prime8",
 		"SHELL":    "/bin/bash",
 		"TERM":     "xterm-256color",
 		"LANG":     "en_US.UTF-8",
 		"PATH":     "/usr/local/bin:/usr/bin:/bin",
 		"PWD":      s.cwd,
 	}
 	if s.oldpwd != "" {
 		env["OLDPWD"] = s.oldpwd
 	}
 	for k, v := range s.vars {
 		env[k] = v
 	}
 	return env
 }
 
 func (s *shellState) envValue(name string) string {
 	switch name {
 	case "?":
 		return strconv.Itoa(s.status)
 	case "$":
 		return "4242"
 	}
 	return s.envMap()[name]
 }
 
 func (s *shellState) setVar(name, value string) {
 	if s.vars == nil {
 		s.vars = map[string]string{}
 	}
 	if len(s.vars) < 256 && len(value) <= 4096 {
 		s.vars[name] = value
 	}
 }
 
 const shellMaxCmdHistory = 500
 
 // exec runs one input line: ; && || lists of pipelines with redirects.
 func (s *shellState) exec(env shellEnv, line string) shellResult {
 	if strings.TrimSpace(line) == "" {
 		return shellResult{}
 	}
 	if s.overlay == nil {
 		s.overlay = vfs.NewOverlay()
 	}
 	s.cmdHistory = append(s.cmdHistory, line)
 	if len(s.cmdHistory) > shellMaxCmdHistory {
 		s.cmdHistory = s.cmdHistory[len(s.cmdHistory)-shellMaxCmdHistory:]
 	}
 
 	var disp strings.Builder
 	res := shellResult{}
 	errOut := func(msg string) {
 		for _, l := range strings.SplitAfter(msg, "\n") {
 			if l == "" {
 				continue
 			}
 			nl := strings.HasSuffix(l, "\n")
 			disp.WriteString(shellErrorStyle.Render(strings.TrimSuffix(l, "\n")))
 			if nl {
 				disp.WriteString("\n")
 			}
 		}
 	}
 	cleared := false
 	finish := func() shellResult {
 		res.output = strings.TrimSuffix(disp.String(), "\n")
 		res.clear = res.clear || cleared
 		return res
 	}
 
 	toks, perr := shellTokenize(line, s.home)
 	var list []shellListItem
 	if perr == "" {
 		list, perr = shellParse(toks)
 	}
 	if perr != "" {
 		errOut("bash: " + perr + "\n")
 		s.status = 2
 		return finish()
 	}
 
 	for _, item := range list {
 		if (item.conn == "&&" && s.status != 0) || (item.conn == "||" && s.status == 0) {
 			continue
 		}
 		fs := vfs.NewFS(env.root, s.home, s.overlay)
 		stdin := ""
 		for i, cmd := range item.pipeline {
 			last := i == len(item.pipeline)-1
 			piped, status := s.runSimple(env, fs, cmd, stdin, last, &disp, errOut, &res)
 			s.status = status
 			stdin = piped
 			if res.quit {
 				return finish()
 			}
 			if res.clear {
 				// later output still shows, on the fresh screen
 				disp.Reset()
 				cleared = true
 				res.clear = false
 			}
 		}
 	}
 	return finish()
 }
 
 // runSimple runs one command of a pipeline. It returns the command's stdout
 // when that feeds the next command, and its exit status.
 func (s *shellState) runSimple(env shellEnv, fs *vfs.FS, cmd shellSimple, stdin string, last bool, disp *strings.Builder, errOut func(string), res *shellResult) (string, int) {
 	expand := func(words []shellWord) []string {
 		var argv []string
 		for _, raw := range words {
 			w := resolveVars(raw, s.envValue)
 			if !w.quoted && w.v == "" {
 				continue
 			}
 			argv = append(argv, expandGlob(w, fs.Root(), s.home, s.cwd)...)
 		}
 		return argv
 	}
 	argv := expand(cmd.words)
 
 	// NAME=value with no command sets a shell variable
 	if len(argv) > 0 && len(cmd.redirs) == 0 {
 		all := true
 		for _, a := range argv {
 			all = all && shellAssignRE.MatchString(a)
 		}
 		if all {
 			for _, a := range argv {
 				m := shellAssignRE.FindStringSubmatch(a)
 				s.setVar(m[1], m[2])
 			}
 			return "", 0
 		}
 	}
 	for len(argv) > 1 && shellAssignRE.MatchString(argv[0]) {
 		argv = argv[1:]
 	}
 
 	c := &shellCtx{s: s, fs: fs, env: env, argv: argv, stdin: stdin, res: res}
 	type fileOut struct {
 		path string
 		buf  strings.Builder
 		app  bool
 	}
 	var outFile, errFile *fileOut
 	errToOut := false
 	for _, r := range cmd.redirs {
 		if r.op == "2>&1" {
 			errToOut = true
 			continue
 		}
 		targets := expand([]shellWord{r.target})
 		if len(targets) != 1 {
 			errOut("bash: " + resolveVars(r.target, s.envValue).v + ": ambiguous redirect\n")
 			return "", 1
 		}
 		t := targets[0]
 		if r.op == "<" {
 			if c.resolve(t) == "/dev/null" {
 				c.stdin = ""
 				continue
 			}
 			n := fs.Get(c.resolve(t))
 			if n == nil || n.Dir {
 				why := "No such file or directory"
 				if n != nil {
 					why = "Is a directory"
 				}
 				errOut("bash: " + t + ": " + why + "\n")
 				return "", 1
 			}
 			c.stdin = fileText(n)
 			continue
 		}
 		app := strings.HasSuffix(r.op, ">>")
 		// the shell creates (and truncates) the target before the command runs
 		if err := writeFile(c, t, "", true); err != nil {
 			errOut("bash: " + t + ": " + errText(err) + "\n")
 			return "", 1
 		}
 		if !app {
 			_ = writeFile(c, t, "", false)
 		}
 		f := &fileOut{path: t, app: true}
 		if strings.HasPrefix(r.op, "2") {
 			errFile = f
 		} else {
 			outFile = f
 		}
 	}
 	if len(argv) == 0 {
 		return "", 0
 	}
 
 	toTerm := last && outFile == nil
 	c.tty = toTerm
 	var piped strings.Builder
 	c.out = func(str string) {
 		switch {
 		case outFile != nil:
 			outFile.buf.WriteString(str)
 		case toTerm:
 			disp.WriteString(str)
 		default:
 			piped.WriteString(str)
 		}
 	}
 	c.err = func(str string) {
 		switch {
 		case errToOut:
 			c.out(str)
 		case errFile != nil:
 			errFile.buf.WriteString(str)
 		default:
 			errOut(str)
 		}
 	}
 
 	name := argv[0]
 	status := 0
 	if fn, ok := shellCommandTable[name]; ok {
 		status = fn(c)
 	} else if strings.Contains(name, "/") {
 		n := fs.Get(c.resolve(name))
 		switch {
 		case n == nil:
 			c.err("bash: " + name + ": No such file or directory\n")
 			status = 127
 		case n.Dir:
 			c.err("bash: " + name + ": Is a directory\n")
 			status = 126
 		default:
 			c.err("bash: " + name + ": Permission denied\n")
 			status = 126
 		}
 	} else {
 		c.err(name + ": command not found\n")
 		status = 127
 	}
 
 	for _, f := range []*fileOut{outFile, errFile} {
 		if f == nil || f.buf.Len() == 0 {
 			continue
 		}
 		if err := writeFile(c, f.path, f.buf.String(), f.app); err != nil {
 			errOut("bash: " + f.path + ": " + errText(err) + "\n")
 			status = 1
 		}
 	}
 	return piped.String(), status
 }
 
 // complete expands the last word of the input: a command name in command
 // position (line start, after | ; &&), otherwise a path in the vfs.
 func (s *shellState) complete(root *vfs.Node) {
 	if s.input == "" {
 		return
 	}
 	idx := strings.LastIndexFunc(s.input, func(r rune) bool {
 		return unicode.IsSpace(r) || strings.ContainsRune(";|&<>", r)
 	})
 	word := s.input[idx+1:]
 	before := strings.TrimRightFunc(s.input[:idx+1], unicode.IsSpace)
 	if before == "" || strings.ContainsAny(before[len(before)-1:], ";|&") {
 		matches := []string{}
 		for _, c := range shellCommands {
 			if strings.HasPrefix(c, word) {
 				matches = append(matches, c)
 			}
 		}
 		if len(matches) == 1 {
 			s.input = s.input[:idx+1] + matches[0] + " "
 		} else if p := commonPrefix(matches); len(p) > len(word) {
 			s.input = s.input[:idx+1] + p
 		}
 		return
 	}
 
 	dirPart, base := "", word
 	if i := strings.LastIndex(word, "/"); i >= 0 {
 		dirPart, base = word[:i+1], word[i+1:]
 	}
 	lookupDir := dirPart
 	if lookupDir == "" {
 		lookupDir = "." // vfs.Resolve("") means home, but completion is relative to cwd
 	}
 	dir := root.Lookup(vfs.Resolve(s.home, s.cwd, lookupDir))
 	if dir == nil || !dir.Dir {
 		return
 	}
 	var matches []string
 	nodes := map[string]*vfs.Node{}
 	for _, c := range dir.SortedChildren() {
 		if strings.HasPrefix(c.Name, ".") && !strings.HasPrefix(base, ".") {
 			continue
 		}
 		if strings.HasPrefix(c.Name, base) {
 			matches = append(matches, c.Name)
 			nodes[c.Name] = c
 		}
 	}
 	if len(matches) == 0 {
 		return
 	}
 	completed := commonPrefix(matches)
 	if len(matches) == 1 {
 		if nodes[completed].Dir {
 			completed += "/"
 		} else {
 			completed += " "
 		}
 	}
 	s.input = s.input[:idx+1] + dirPart + completed
 }
 
 func commonPrefix(words []string) string {
 	if len(words) == 0 {
 		return ""
 	}
 	sorted := append([]string(nil), words...)
 	sort.Strings(sorted)
 	first, last := sorted[0], sorted[len(sorted)-1]
 	i := 0
 	for i < len(first) && i < len(last) && first[i] == last[i] {
 		i++
 	}
 	return first[:i]
 }
 
 // handleShellKey routes a key on the about page to the prompt. It reports
 // whether the key was consumed; unconsumed keys fall through to the global
 // bindings (tab switching, scrolling, quit, ...).
 func (m *portfolioModel) handleShellKey(msg tea.KeyMsg) (tea.Cmd, bool) {
 	m.shell.lastKey = time.Now()
 	s := &m.shell
 	switch msg.Type {
 	case tea.KeyRunes, tea.KeySpace:
 		r := string(msg.Runes)
 		if msg.Type == tea.KeySpace {
 			r = " "
 		}
 		// with an empty prompt, keep the digit tab shortcuts and ? help
 		if s.input == "" && !msg.Paste {
 			if _, ok := tabIndexFromKey(r); ok {
 				return nil, false
 			}
 			if r == "?" || r == " " {
 				return nil, false
 			}
 		}
 		s.input += strings.Map(func(r rune) rune {
 			if unicode.IsControl(r) {
 				return -1
 			}
 			return r
 		}, r)
 	case tea.KeyBackspace, tea.KeyCtrlH:
 		if s.input == "" {
 			return nil, true
 		}
 		rs := []rune(s.input)
 		s.input = string(rs[:len(rs)-1])
 	case tea.KeyCtrlU:
 		s.input = ""
 	case tea.KeyCtrlW:
 		trimmed := strings.TrimRightFunc(s.input, unicode.IsSpace)
 		if i := strings.LastIndexFunc(trimmed, unicode.IsSpace); i >= 0 {
 			s.input = trimmed[:i+1]
 		} else {
 			s.input = ""
 		}
 	case tea.KeyCtrlL:
 		s.history = nil
 		s.cleared = true
 	case tea.KeyCtrlD:
 		if s.input == "" {
 			return tea.Quit, true
 		}
 		return nil, true
 	case tea.KeyEsc:
 		if s.input == "" {
 			return nil, false
 		}
 		s.input = ""
 	case tea.KeyTab:
 		if s.input == "" {
 			return nil, false
 		}
 		s.complete(m.shellFS().Root())
 	case tea.KeyEnter:
 		return m.runShellLine(), true
 	default:
 		return nil, false
 	}
 	m.syncShellViewport()
 	return nil, true
 }
 
 func (m *portfolioModel) runShellLine() tea.Cmd {
 	s := &m.shell
 	line := s.input
 	s.input = ""
 	cwd := s.cwd
 	res := s.exec(m.shellEnv(), line)
 	if res.quit {
 		return tea.Quit
 	}
 	entry := shellEntry{cwd: cwd, input: line, output: res.output, err: res.err}
 	if res.clear {
 		s.history = nil
 		s.cleared = true
 		entry.bare = true
 	}
 	if !entry.bare || entry.output != "" {
 		s.history = append(s.history, entry)
 	}
 	if len(s.history) > shellMaxHistory {
 		s.history = s.history[len(s.history)-shellMaxHistory:]
 	}
 	m.syncShellViewport()
 	return m.prefetchAllProjectReadmesCmd()
 }
 
 // shellEnv is what a shell line runs against: a freshly generated base tree
 // (the session's overlay goes on top of a private clone of it).
 func (m portfolioModel) shellEnv() shellEnv {
 	now := m.now
 	if now.IsZero() {
 		now = time.Now()
 	}
 	return shellEnv{
 		root: vfs.Build(m.vfsSource()),
 		now:  now,
 		fetch: func(tty bool) string {
 			if tty {
 				return m.aboutFetch()
 			}
 			return ansi.Strip(m.aboutFetchLines())
 		},
 	}
 }
 
 // shellFS is the session's merged view, for completion.
 func (m portfolioModel) shellFS() *vfs.FS {
 	return vfs.NewFS(vfs.Build(m.vfsSource()), m.shell.home, m.shell.overlay)
 }
 
 // prefetchAllProjectReadmesCmd fills the projects/*/README.md files.
 func (m *portfolioModel) prefetchAllProjectReadmesCmd() tea.Cmd {
 	cmds := []tea.Cmd{}
 	for _, p := range m.projects {
 		if _, ok := m.projectReadmes[p.ID]; ok || m.projectReadmeLoads[p.ID] || m.gitService == nil {
 			continue
 		}
 		m.projectReadmeLoads[p.ID] = true
 		cmds = append(cmds, fetchProjectReadmeCmd(m.gitService, p))
 	}
 	if len(cmds) == 0 {
 		return nil
 	}
 	return tea.Batch(cmds...)
 }
 
 // syncShellViewport re-renders the about page and keeps the prompt in view.
 func (m *portfolioModel) syncShellViewport() {
 	if m.activeTab != tabAbout {
 		return
 	}
 	m.viewport.SetContent(m.detailContent())
 	m.viewport.GotoBottom()
 }
 
 // shellView renders past commands, their output, and the live prompt line.
 func (m portfolioModel) shellView(width int) string {
 	wrap := lipgloss.NewStyle().Width(max(width, 10))
 	parts := make([]string, 0, len(m.shell.history)*2+1)
 	for _, e := range m.shell.history {
 		if !e.bare {
 			parts = append(parts, renderShellPrompt(m.shell.user, m.shell.home, e.cwd, e.input))
 		}
 		if e.output == "" {
 			continue
 		}
 		out := e.output
 		if e.err {
 			out = shellErrorStyle.Render(out)
 		}
 		parts = append(parts, wrap.Render(out))
 	}
 	parts = append(parts, renderShellPrompt(m.shell.user, m.shell.home, m.shell.cwd, m.shell.input)+m.shell.cursor(time.Now()))
 	return strings.Join(parts, "\n")
 }
 
 func renderShellPrompt(user, home, cwd, input string) string {
 	return promptUserStyle.Render(user) +
 		promptStyle.Render("@") +
 		promptHostStyle.Render("prime8") +
 		promptStyle.Render(":") +
 		promptPathStyle.Render(vfs.DisplayPath(home, cwd)) +
 		promptDollarStyle.Render("$") +
 		promptStyle.Render(" ") +
 		promptCmdStyle.Render(input)
 }
 
 // cursorBlink is the half period of the prompt cursor's blink (xterm's 530 ms).
 const cursorBlink = 530 * time.Millisecond
 
 type cursorBlinkMsg struct{}
 
 func cursorBlinkCmd() tea.Cmd {
 	return tea.Tick(cursorBlink, func(time.Time) tea.Msg { return cursorBlinkMsg{} })
 }
 
 // cursor draws the block cursor: solid while keys arrive, then blinking.
 func (s shellState) cursor(now time.Time) string {
 	idle := now.Sub(s.lastKey)
 	if idle < cursorBlink || (idle/cursorBlink)%2 == 0 {
 		return rowStyle.Render("█")
 	}
 	return " "
 }