prime8dev

vfs.go (6713B)

---

 // Package vfs builds the read-only, in-memory filesystem behind the shell on
 // the about page (SSH TUI and web). Nothing here ever touches the host
 // filesystem: every node is generated from config/content values.
 package vfs
 
 import (
 	"fmt"
 	"path"
 	"sort"
 	"strings"
 	"time"
 
 	appconfig "git.prime8.dev/moncheeta/prime8dev/internal/config"
 	"git.prime8.dev/moncheeta/prime8dev/internal/utils"
 )
 
 const (
 	// FallbackUser is the shell user for anonymous sessions (and the web).
 	FallbackUser  = "visitor"
 	maxUser       = 32
 	homeDirPrefix = "/home/"
 )
 
 // SanitizeUser turns a session user into a safe single path segment
 // ([a-z0-9._-], at most 32 chars) so it can name the home directory and the
 // prompt. Anything that sanitizes to nothing (or to . / ..) becomes visitor.
 func SanitizeUser(user string) string {
 	var b strings.Builder
 	for _, r := range strings.ToLower(strings.TrimSpace(user)) {
 		if b.Len() >= maxUser {
 			break
 		}
 		switch {
 		case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '.', r == '_', r == '-':
 			b.WriteRune(r)
 		}
 	}
 	s := strings.Trim(b.String(), ".")
 	if s == "" {
 		return FallbackUser
 	}
 	return s
 }
 
 // HomeDir is the user's home directory in the virtual fs.
 func HomeDir(user string) string {
 	return homeDirPrefix + user
 }
 
 // Node is a file or directory. Directories have Children; files have Content.
 type Node struct {
 	Name     string           `json:"name"`
 	Dir      bool             `json:"dir,omitempty"`
 	Content  string           `json:"content,omitempty"`
 	Children map[string]*Node `json:"children,omitempty"`
 }
 
 // NewDir returns an empty directory node.
 func NewDir(name string) *Node {
 	return &Node{Name: name, Dir: true, Children: map[string]*Node{}}
 }
 
 // AddDir returns the child directory name, creating it if needed.
 func (n *Node) AddDir(name string) *Node {
 	if c, ok := n.Children[name]; ok && c.Dir {
 		return c
 	}
 	c := NewDir(name)
 	n.Children[name] = c
 	return c
 }
 
 // AddFile adds (or replaces) a file.
 func (n *Node) AddFile(name, content string) {
 	n.Children[name] = &Node{Name: name, Content: content}
 }
 
 // SortedChildren lists a directory by name.
 func (n *Node) SortedChildren() []*Node {
 	out := make([]*Node, 0, len(n.Children))
 	for _, c := range n.Children {
 		out = append(out, c)
 	}
 	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
 	return out
 }
 
 // Lookup walks an absolute virtual path; nil when it does not exist.
 func (n *Node) Lookup(abs string) *Node {
 	cur := n
 	for _, part := range strings.Split(strings.Trim(abs, "/"), "/") {
 		if part == "" {
 			continue
 		}
 		if !cur.Dir {
 			return nil
 		}
 		c, ok := cur.Children[part]
 		if !ok {
 			return nil
 		}
 		cur = c
 	}
 	return cur
 }
 
 // Source is everything the filesystem is generated from.
 type Source struct {
 	User       string
 	About      appconfig.About
 	CurrentJob *appconfig.Experience
 	Experience []appconfig.Experience
 	Projects   []appconfig.Project
 	// Readmes overrides project READMEs by project id (falls back to
 	// Project.Markdown).
 	Readmes map[string]string
 	Now     time.Time
 }
 
 // Build lays out:
 //
 //	/home/<user>/{about,bio,contact}
 //	/home/<user>/{interests,hobbies,languages}/<item>
 //	/home/<user>/experience/<id>
 //	/home/<user>/projects/<id>/{README.md,info}
 func Build(src Source) *Node {
 	root := NewDir("/")
 	home := root.AddDir("home").AddDir(src.User)
 	root.AddDir("tmp")
 
 	a := src.About
 	home.AddFile("bio", a.Bio)
 	home.AddFile("about", aboutFile(src))
 	home.AddFile("contact", strings.Join([]string{
 		"email:    damian@prime8.dev",
 		"web:      " + appconfig.SiteURL,
 		"git:      " + appconfig.SiteURL + "/projects",
 		"linkedin: https://linkedin.com/in/damian-myrda",
 		"ssh:      ssh prime8.dev",
 	}, "\n"))
 
 	for dir, items := range map[string][]string{
 		"interests": a.Interests,
 		"hobbies":   a.Hobbies,
 		"languages": a.Languages,
 	} {
 		d := home.AddDir(dir)
 		for _, item := range items {
 			if name := Name(item); name != "" {
 				d.AddFile(name, item)
 			}
 		}
 	}
 
 	expDir := home.AddDir("experience")
 	for _, e := range src.Experience {
 		if name := Name(e.ID); name != "" {
 			expDir.AddFile(name, experienceFile(e))
 		}
 	}
 
 	projDir := home.AddDir("projects")
 	for _, p := range src.Projects {
 		name := Name(p.ID)
 		if name == "" {
 			continue
 		}
 		d := projDir.AddDir(name)
 		readme := strings.TrimSpace(src.Readmes[p.ID])
 		if readme == "" {
 			readme = strings.TrimSpace(p.Markdown)
 		}
 		if readme != "" {
 			d.AddFile("README.md", readme)
 		}
 		info := []string{"name:  " + p.Name, "about: " + p.Subtitle}
 		if len(p.Tech) > 0 {
 			info = append(info, "tech:  "+strings.Join(p.Tech, ", "))
 		}
 		if p.Repo != "" {
 			info = append(info,
 				"clone: git clone "+appconfig.GitCloneURL(p.Repo),
 				"       git clone "+appconfig.GitSSHCloneURL(p.Repo),
 			)
 		}
 		d.AddFile("info", strings.Join(info, "\n"))
 	}
 
 	return root
 }
 
 func aboutFile(src Source) string {
 	a := src.About
 	role := a.Profession
 	if src.CurrentJob != nil {
 		role = src.CurrentJob.Role + " @ " + src.CurrentJob.Company
 	}
 	now := src.Now
 	if now.IsZero() {
 		now = time.Now()
 	}
 	lines := []string{
 		"name:     " + a.Name,
 		"role:     " + role,
 		"location: " + a.Location,
 		"uptime:   " + utils.Uptime(appconfig.Birthday, now),
 	}
 	for _, kv := range a.Setup {
 		lines = append(lines, fmt.Sprintf("%-9s %s", kv.Key+":", kv.Value))
 	}
 	lines = append(lines, "langs:    "+strings.Join(a.Languages, ", "))
 	return strings.Join(lines, "\n")
 }
 
 func experienceFile(e appconfig.Experience) string {
 	lines := []string{
 		e.Role + " @ " + e.Company,
 		utils.FormatRange(e.StartDate, e.EndDate, e.Current) + " (" + utils.FormatDurationShort(e.StartDate, e.EndDate, e.Current) + ")",
 		"",
 	}
 	lines = append(lines, e.Description...)
 	if len(e.Tech) > 0 {
 		lines = append(lines, "", "tech: "+strings.Join(e.Tech, ", "))
 	}
 	if e.URL != "" {
 		lines = append(lines, "url:  "+e.URL)
 	}
 	return strings.Join(lines, "\n")
 }
 
 // Name turns a label into a single path component.
 func Name(s string) string {
 	s = strings.TrimSpace(strings.ToLower(s))
 	s = strings.NewReplacer("/", "-", " ", "-").Replace(s)
 	if s == "." || s == ".." {
 		return ""
 	}
 	return s
 }
 
 // Resolve turns p (absolute, ~-relative, or relative to cwd) into a clean
 // absolute virtual path.
 func Resolve(home, cwd, p string) string {
 	switch {
 	case p == "" || p == "~":
 		return home
 	case strings.HasPrefix(p, "~/"):
 		p = home + p[1:]
 	case !strings.HasPrefix(p, "/"):
 		p = cwd + "/" + p
 	}
 	return path.Clean(p)
 }
 
 // DisplayPath abbreviates the home directory to ~.
 func DisplayPath(home, abs string) string {
 	if abs == home {
 		return "~"
 	}
 	if strings.HasPrefix(abs, home+"/") {
 		return "~" + abs[len(home):]
 	}
 	return abs
 }