Merge pull request #16 from profullstack/feat/bbs-mail-reader

AgentMail: paid-member mailbox reader (TUI + bot mode) on the BBS

Author: ralyodio

cmd/agentbbs/main.go

@@ -61,6 +61,7 @@ import (
 	"github.com/profullstack/agentbbs/internal/hub"
 	"github.com/profullstack/agentbbs/internal/irc"
 	"github.com/profullstack/agentbbs/internal/mail"
+	"github.com/profullstack/agentbbs/internal/mailbox"
 	"github.com/profullstack/agentbbs/internal/news"
 	"github.com/profullstack/agentbbs/internal/payments"
 	"github.com/profullstack/agentbbs/internal/plugin"
@@ -317,6 +318,8 @@ func (a *app) router() wish.Middleware {
 				a.handleIRC(s)
 			case auth.IsNewsName(user):
 				a.handleNews(s)
+			case auth.IsMailName(user):
+				a.handleMail(s)
 			case isVideo:
 				a.handleVideo(s, code)
 			case user == "agent":
@@ -472,6 +475,28 @@ func (a *app) sessionApps(s ssh.Session, su store.User, guest bool) []hub.Sessio
 		Cmd:         sessionExec{run: func() error { return a.runNews(s, su.Name) }},
 	})
 
+	// Mail — a Founding Lifetime Member perk: the AgentMail TUI.
+	mailLock := ""
+	switch {
+	case guest:
+		mailLock = membersOnly
+	case !su.Premium:
+		mailLock = "Founding Lifetime Member feature ($99 one-time) — upgrade: ssh join@" + a.host
+	}
+	apps = append(apps, hub.SessionApp{
+		Title:       "Mail",
+		Description: "your " + a.fe.Domain + " mailbox",
+		Locked:      mailLock,
+		Cmd: sessionExec{run: func() error {
+			c, err := a.mailClientFor(su)
+			if err != nil {
+				return err
+			}
+			defer c.Close()
+			return mailbox.RunReader(s, c)
+		}},
+	})
+
 	// Tor — a Founding Lifetime Member perk: a torsocks shell in the pod.
 	torLock := ""
 	switch {
@@ -1273,6 +1298,83 @@ func (a *app) runNews(s ssh.Session, name string) error {
 	return news.RunReader(s, addr, name)
 }
 
+// mailClientFor builds a paid-gated AgentMail client for a member, connecting to
+// the self-hosted Mailu backend. IMAP uses Dovecot master-user auth (login
+// "<name>*<master>") so the BBS gateway can open any member's mailbox with one
+// secret; SMTP defaults to the co-located relay (no auth). Returns an error if
+// the IMAP connection/login fails.
+func (a *app) mailClientFor(su store.User) (*mailbox.Client, error) {
+	domain := env("AGENTBBS_MAIL_DOMAIN", "mail.profullstack.com")
+	login := su.Name
+	if master := os.Getenv("AGENTBBS_MAIL_MASTER_USER"); master != "" {
+		login = su.Name + "*" + master
+	}
+	cfg := mailbox.IMAPConfig{
+		IMAPAddr: env("AGENTBBS_MAIL_IMAP_ADDR", domain+":993"),
+		SMTPAddr: env("AGENTBBS_MAIL_SMTP_ADDR", "127.0.0.1:25"),
+		Username: login,
+		Password: os.Getenv("AGENTBBS_MAIL_MASTER_PASS"),
+		// SMTPUser/SMTPPass left empty: submit via the trusted local relay.
+	}
+	tr, err := mailbox.NewIMAPTransport(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return mailbox.NewClient(tr, mailbox.Identity{Name: su.Name, Paid: su.Premium}, domain, 50), nil
+}
+
+// handleMail routes a Founding Lifetime member into AgentMail: an interactive
+// TUI when a PTY is present and no command is given, or the JSON bot mode
+// (ssh mail@host <cmd>, or no PTY) for agents.
+func (a *app) handleMail(s ssh.Session) {
+	fp := auth.Fingerprint(s.PublicKey())
+	if fp == "" {
+		wish.Println(s, "mail@ needs your registered SSH key. New here? ssh join@"+a.host)
+		_ = s.Exit(1)
+		return
+	}
+	u, found, err := a.st.UserByFingerprint(fp)
+	if err != nil || !found {
+		wish.Println(s, "key not registered — run: ssh join@"+a.host)
+		_ = s.Exit(1)
+		return
+	}
+	if u.Banned {
+		wish.Println(s, "this account is suspended.")
+		_ = s.Exit(1)
+		return
+	}
+	if !a.ensurePremium(&u) {
+		wish.Println(s, "  mail is a Founding Lifetime Member feature ($99 one-time). Upgrade: ssh join@"+a.host)
+		_ = s.Exit(1)
+		return
+	}
+	sessID, _ := a.st.RecordSession(u.ID, s.User(), remoteIP(s), "mail")
+	defer func() { _ = a.st.EndSession(sessID) }()
+
+	c, err := a.mailClientFor(u)
+	if err != nil {
+		wish.Println(s, "mail: "+err.Error())
+		_ = s.Exit(1)
+		return
+	}
+	defer c.Close()
+
+	args := s.Command()
+	_, _, hasPty := s.Pty()
+	if len(args) > 0 || !hasPty {
+		// Agent/bot mode: JSON in, JSON out.
+		if err := mailbox.RunBot(s.Context(), c, args, s, s); err != nil {
+			_ = s.Exit(1)
+		}
+		return
+	}
+	if err := mailbox.RunReader(s, c); err != nil {
+		wish.Println(s, "mail: "+err.Error())
+		_ = s.Exit(1)
+	}
+}
+
 // handleTorCmd runs an arbitrary command through Tor (torsocks) inside the
 // member's pod, never on the host. Premium; requires a PTY.
 func (a *app) handleTorCmd(s ssh.Session) {

go.mod

@@ -10,6 +10,8 @@ require (
 	github.com/charmbracelet/wish v1.4.7
 	github.com/creack/pty v1.1.24
 	github.com/dustin/go-nntp v0.0.0-20210723005859-f00d51cf8cc1
+	github.com/emersion/go-imap/v2 v2.0.0-beta.8
+	github.com/emersion/go-message v0.18.2
 	github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674
 	github.com/livekit/protocol v1.46.0
 	github.com/livekit/server-sdk-go/v2 v2.16.6
@@ -46,6 +48,7 @@ require (
 	github.com/dennwc/iters v1.2.2 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/frostbyte73/core v0.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect

go.sum

@@ -99,6 +99,12 @@ github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+m
 github.com/dustin/go-nntp v0.0.0-20210723005859-f00d51cf8cc1 h1:R90ND7acg9HKYj3oJBKKefk73DULdC7IlcnS7MV0X1s=
 github.com/dustin/go-nntp v0.0.0-20210723005859-f00d51cf8cc1/go.mod h1:elGbp3dKCIIdwu6jm3y6L93EVn+I6MSzYrcZXhpNS3Y=
 github.com/dustin/httputil v0.0.0-20170305193905-c47743f54f89/go.mod h1:ZoDWdnxro8Kesk3zrCNOHNFWtajFPSnDMjVEjGjQu/0=
+github.com/emersion/go-imap/v2 v2.0.0-beta.8 h1:5IXZK1E33DyeP526320J3RS7eFlCYGFgtbrfapqDPug=
+github.com/emersion/go-imap/v2 v2.0.0-beta.8/go.mod h1:dhoFe2Q0PwLrMD7oZw8ODuaD0vLYPe5uj2wcOMnvh48=
+github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg=
+github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA=
+github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 h1:oP4q0fw+fOSWn3DfFi4EXdT+B+gTtzx8GC9xsc26Znk=
+github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=

internal/auth/auth.go

@@ -65,6 +65,10 @@ var IRCNames = map[string]bool{"irc": true}
 // via an in-process newsreader. Free for any registered member, like irc@.
 var NewsNames = map[string]bool{"news": true}
 
+// MailNames route a Founding Lifetime (paid) member into the AgentMail client —
+// an interactive TUI with a PTY, or a JSON bot mode with a command/no PTY.
+var MailNames = map[string]bool{"mail": true}
+
 // GameNames are usernames that route to AgentGames: the line-delimited-JSON
 // agent-vs-agent match protocol (PRD §5.2). `play@` stays a guest hub alias.
 var GameNames = map[string]bool{"game": true, "games": true}
@@ -99,6 +103,9 @@ func IsIRCName(u string) bool { return IRCNames[strings.ToLower(u)] }
 // IsNewsName reports whether the SSH username requests the in-BBS newsreader.
 func IsNewsName(u string) bool { return NewsNames[strings.ToLower(u)] }
 
+// IsMailName reports whether the SSH username requests the AgentMail client.
+func IsMailName(u string) bool { return MailNames[strings.ToLower(u)] }
+
 // systemReserved are names that don't drive an SSH route but would still
 // collide with a per-user subdomain (<name>.<host>), the agent route, or common
 // infra hostnames — so members may not claim them as account names.

internal/mailbox/bot.go

@@ -0,0 +1,173 @@
+package mailbox
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// BotUsage is printed when a bot/agent invokes mail with no/unknown command.
+const BotUsage = `agentmail (non-interactive mode) — JSON in, JSON out:
+
+  mailboxes                       list folders
+  list [mailbox] [limit]          message summaries (default INBOX)
+  read <mailbox> <uid>            full message (marks seen; "peek" 4th arg to keep unseen)
+  search <query> [mailbox]        search summaries
+  send                            read a JSON Draft on stdin, send it
+  reply <mailbox> <uid>           read {"text":...,"replyAll":bool} on stdin
+  flag <mailbox> <uid> [on|off]   set/clear the flagged flag
+  seen <mailbox> <uid> [on|off]   set/clear the seen flag
+  delete <mailbox> <uid>          delete a message
+
+Example:  ssh mail@bbs.profullstack.com list INBOX 20`
+
+// RunBot executes one non-interactive command for agents/bots, writing JSON to
+// out. It returns an error (also emitted as {"error":...}) on failure.
+func RunBot(ctx context.Context, c *Client, args []string, in io.Reader, out io.Writer) error {
+	if len(args) == 0 {
+		fmt.Fprintln(out, BotUsage)
+		return nil
+	}
+	enc := json.NewEncoder(out)
+	enc.SetIndent("", "  ")
+	fail := func(err error) error {
+		_ = enc.Encode(map[string]string{"error": err.Error()})
+		return err
+	}
+
+	switch strings.ToLower(args[0]) {
+	case "mailboxes":
+		v, err := c.Mailboxes(ctx)
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(v)
+
+	case "list", "ls":
+		mailbox := Inbox
+		if len(args) > 1 {
+			mailbox = args[1]
+		}
+		limit := 0
+		if len(args) > 2 {
+			limit, _ = strconv.Atoi(args[2])
+		}
+		v, err := c.List(ctx, mailbox, limit)
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(v)
+
+	case "read", "show":
+		mailbox, uid, err := mailboxUID(args)
+		if err != nil {
+			return fail(err)
+		}
+		peek := len(args) > 3 && strings.EqualFold(args[3], "peek")
+		msg, ok, err := c.Read(ctx, mailbox, uid, peek)
+		if err != nil {
+			return fail(err)
+		}
+		if !ok {
+			return fail(notFound(mailbox, uid))
+		}
+		return enc.Encode(msg)
+
+	case "search":
+		if len(args) < 2 {
+			return fail(fmt.Errorf("usage: search <query> [mailbox]"))
+		}
+		mailbox := ""
+		if len(args) > 2 {
+			mailbox = args[2]
+		}
+		v, err := c.Search(ctx, args[1], mailbox, 0)
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(v)
+
+	case "send":
+		var d Draft
+		if err := json.NewDecoder(in).Decode(&d); err != nil {
+			return fail(fmt.Errorf("send expects a JSON Draft on stdin: %w", err))
+		}
+		res, err := c.Send(ctx, d)
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(res)
+
+	case "reply":
+		mailbox, uid, err := mailboxUID(args)
+		if err != nil {
+			return fail(err)
+		}
+		var body struct {
+			Text     string `json:"text"`
+			ReplyAll bool   `json:"replyAll"`
+		}
+		if err := json.NewDecoder(in).Decode(&body); err != nil {
+			return fail(fmt.Errorf("reply expects {\"text\":...} on stdin: %w", err))
+		}
+		orig, ok, err := c.Read(ctx, mailbox, uid, true)
+		if err != nil {
+			return fail(err)
+		}
+		if !ok {
+			return fail(notFound(mailbox, uid))
+		}
+		res, err := c.Reply(ctx, orig, body.Text, body.ReplyAll)
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(res)
+
+	case "flag", "seen":
+		mailbox, uid, err := mailboxUID(args)
+		if err != nil {
+			return fail(err)
+		}
+		on := true
+		if len(args) > 3 {
+			on = !strings.EqualFold(args[3], "off") && args[3] != "false" && args[3] != "0"
+		}
+		if args[0] == "flag" {
+			err = c.Flag(ctx, mailbox, uid, on)
+		} else {
+			err = c.MarkSeen(ctx, mailbox, uid, on)
+		}
+		if err != nil {
+			return fail(err)
+		}
+		return enc.Encode(map[string]any{"ok": true, "mailbox": mailbox, "uid": uid, args[0]: on})
+
+	case "delete", "rm":
+		mailbox, uid, err := mailboxUID(args)
+		if err != nil {
+			return fail(err)
+		}
+		if err := c.Delete(ctx, mailbox, uid); err != nil {
+			return fail(err)
+		}
+		return enc.Encode(map[string]any{"ok": true, "deleted": map[string]any{"mailbox": mailbox, "uid": uid}})
+
+	default:
+		fmt.Fprintln(out, BotUsage)
+		return fmt.Errorf("unknown command: %s", args[0])
+	}
+}
+
+func mailboxUID(args []string) (string, uint32, error) {
+	if len(args) < 3 {
+		return "", 0, fmt.Errorf("usage: %s <mailbox> <uid>", args[0])
+	}
+	uid, err := strconv.ParseUint(args[2], 10, 32)
+	if err != nil {
+		return "", 0, fmt.Errorf("invalid uid %q", args[2])
+	}
+	return args[1], uint32(uid), nil
+}