add draft smtp server

.vscode/launch.json

···
             "program": "${workspaceFolder}/main.go",
             "args": [
                 "up",
+                "--http-addr=:8080",
                 "--ssh-addr=:2222",
+                "--smtp-addr=:2525",
             ],
             "env": {
                 "SMALLWEB_DIR": "${workspaceFolder}/examples"

.vscode/tasks.json

···
         {
             "label": "Go: Generate",
             "type": "shell",
-            "command": "go generate ./...",
+            "command": "go generate ./..."
         }
     ]
 }

app/app.go

···
 }
 
 type App struct {
-	Admin  bool              `json:"admin"`
-	Name   string            `json:"name"`
-	Dir    string            `json:"dir,omitempty"`
-	Domain string            `json:"-"`
-	URL    string            `json:"url"`
-	Env    map[string]string `json:"-"`
-	Config AppConfig         `json:"-"`
+	Admin      bool              `json:"admin"`
+	Name       string            `json:"name"`
+	RootDir    string            `json:"-"`
+	RootDomain string            `json:"-"`
+	Dir        string            `json:"dir,omitempty"`
+	Domain     string            `json:"-"`
+	URL        string            `json:"url"`
+	Env        map[string]string `json:"-"`
+	Config     AppConfig         `json:"-"`
 }
 
-func (me *App) Root() string {
+func (me *App) DataDir() string {
 	dir := me.Dir
 	if fi, err := os.Lstat(dir); err == nil && fi.Mode()&os.ModeSymlink != 0 {
 		if root, err := os.Readlink(dir); err == nil {
···
 	}
 
 	app := App{
-		Name:   appname,
-		Admin:  isAdmin,
-		Dir:    filepath.Join(rootDir, appname),
-		Domain: fmt.Sprintf("%s.%s", appname, domain),
-		URL:    fmt.Sprintf("https://%s.%s/", appname, domain),
-		Env:    make(map[string]string),
+		Name:       appname,
+		Admin:      isAdmin,
+		RootDir:    rootDir,
+		RootDomain: domain,
+		Dir:        filepath.Join(rootDir, appname),
+		Domain:     fmt.Sprintf("%s.%s", appname, domain),
+		URL:        fmt.Sprintf("https://%s.%s/", appname, domain),
+		Env:        make(map[string]string),
 	}
 
 	for _, dotenvPath := range []string{
···
 	}
 
 	if me.Config.Entrypoint != "" {
-		return filepath.Join(me.Root(), me.Config.Entrypoint)
+		return filepath.Join(me.DataDir(), me.Config.Entrypoint)
 	}
 
 	for _, candidate := range []string{"main.js", "main.ts", "main.jsx", "main.tsx"} {
-		path := filepath.Join(me.Root(), candidate)
+		path := filepath.Join(me.DataDir(), candidate)
 		if utils.FileExists(path) {
 			return path
 		}

cmd/crons.go

···
 					continue
 				}
 
-				wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
+				wk := worker.NewWorker(a)
 
 				command, err := wk.Command(context.Background(), job.Args...)
 				if err != nil {

cmd/email.go

···
 				return fmt.Errorf("failed to load app: %w", err)
 			}
 
-			wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
+			wk := worker.NewWorker(a)
 
 			if err := wk.SendEmail(cmd.Context(), strings.NewReader(message.String())); err != nil {
 				return fmt.Errorf("failed to send email: %w", err)

cmd/fetch.go

···
 				return fmt.Errorf("failed to load app: %w", err)
 			}
 
-			wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
+			wk := worker.NewWorker(a)
 			if err := wk.Start(); err != nil {
 				return fmt.Errorf("failed to start worker: %w", err)
 			}

cmd/run.go

···
 				return fmt.Errorf("failed to load app: %w", err)
 			}
 
-			wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
+			wk := worker.NewWorker(a)
 			command, err := wk.Command(cmd.Context(), args[1:]...)
 			if err != nil {
 				return fmt.Errorf("failed to create command: %w", err)

cmd/up.go

···
 	"github.com/caddyserver/certmagic"
 	"github.com/charmbracelet/ssh"
 	"github.com/creack/pty"
+	"github.com/mhale/smtpd"
 	"github.com/pkg/sftp"
 	"github.com/pomdtr/smallweb/app"
 	"github.com/pomdtr/smallweb/watcher"
···
 func NewCmdUp() *cobra.Command {
 	var flags struct {
 		cron        bool
-		addr        string
+		httpAddr    string
+		smtpAddr    string
 		sshAddr     string
 		sshHostKey  string
 		onDemandTLS bool
···
 				fmt.Fprintf(os.Stderr, "Serving *.%s from %s with on-demand TLS...\n", k.String("domain"), utils.AddTilde(k.String("dir")))
 				go certmagic.HTTPS(nil, handler)
 			} else {
-				addr := flags.addr
+				addr := flags.httpAddr
 				if addr == "" {
 					if flags.cert != "" || flags.key != "" {
 						addr = "0.0.0.0:443"
···
 					},
 					SubsystemHandlers: map[string]ssh.SubsystemHandler{
 						"sftp": func(sess ssh.Session) {
-							var workDir string
-							if sess.User() == "_" {
-								workDir = k.String("dir")
-							} else {
-								app, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
-								if err != nil {
-									fmt.Fprintln(sess, "failed to load app:", err)
-									return
-								}
-
-								workDir = filepath.Join(app.Root(), "data")
-								if _, err := os.Stat(workDir); err != nil {
-									fmt.Fprintln(sess, "failed to get app data directory")
-									return
-								}
+							if sess.User() != "_" {
+								fmt.Fprintln(sess, "sftp is only allowed for the _ user")
+								return
 							}
 
 							server, err := sftp.NewServer(
 								sess,
-								sftp.WithServerWorkingDirectory(workDir),
+								sftp.WithServerWorkingDirectory(utils.AddTilde(k.String("dir"))),
 							)
 
 							if err != nil {
···
 							cmd = exec.Command(execPath, sess.Command()...)
 							cmd.Env = os.Environ()
 						} else {
-							app, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
+							a, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
 							if err != nil {
 								fmt.Fprintf(sess, "failed to load app: %v\n", err)
 								return
 							}
 
-							wk := worker.NewWorker(app, k.String("dir"), k.String("domain"))
+							wk := worker.NewWorker(a)
 							command, err := wk.Command(sess.Context(), sess.Command()...)
 							if err != nil {
 								fmt.Fprintf(sess, "failed to get command: %v\n", err)
···
 				defer server.Close()
 			}
 
+			if flags.smtpAddr != "" {
+				fmt.Fprintf(os.Stderr, "Starting SFTP server on %s...\n", flags.smtpAddr)
+				go smtpd.ListenAndServe(flags.smtpAddr, func(remoteAddr net.Addr, from string, to []string, data []byte) error {
+					for _, recipient := range to {
+						parts := strings.SplitN(recipient, "@", 2)
+						appname, domain := parts[0], parts[1]
+						if domain != k.String("domain") {
+							continue
+						}
+
+						a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), appname))
+						if err != nil {
+							if errors.Is(err, app.ErrAppNotFound) {
+								continue
+							}
+
+							return fmt.Errorf("failed to load app: %v", err)
+						}
+
+						wk := worker.NewWorker(a)
+						if err := wk.SendEmail(context.Background(), strings.NewReader(string(data))); err != nil {
+							return fmt.Errorf("failed to send email: %v", err)
+						}
+					}
+
+					return nil
+				}, "Smallweb", k.String("domain"))
+			}
+
 			// sigint handling
 			sigint := make(chan os.Signal, 1)
 			signal.Notify(sigint, os.Interrupt)
···
 		},
 	}
 
-	cmd.Flags().StringVar(&flags.addr, "addr", "", "address to listen on")
+	cmd.Flags().StringVar(&flags.httpAddr, "http-addr", "", "address to listen on")
 	cmd.Flags().StringVar(&flags.sshAddr, "ssh-addr", "", "address to listen on for ssh/sftp")
+	cmd.Flags().StringVar(&flags.smtpAddr, "smtp-addr", "", "address to listen on")
 	cmd.Flags().StringVar(&flags.sshHostKey, "ssh-host-key", "~/.ssh/id_ed25519", "ssh host key")
 	cmd.Flags().BoolVar(&flags.onDemandTLS, "on-demand-tls", false, "enable on-demand TLS")
 	cmd.Flags().StringVar(&flags.cert, "cert", "", "tls certificate file")
···
 
 	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "cert")
 	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "key")
-	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "addr")
+	cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "http-addr")
 
 	return cmd
 }
···
 		return nil, fmt.Errorf("failed to load app: %w", err)
 	}
 
-	wk := worker.NewWorker(a, k.String("dir"), domain)
+	wk := worker.NewWorker(a)
 
 	wk.Logger = me.logger
 	if err := wk.Start(); err != nil {

examples/inbox/email.eml

···
+Subject: Ceci est un test
+From: [e-mail]
+To: [e-mail]
+Content-Type: text/plain; charset=utf-8
+
+yo

examples/inbox/run.sh

···
+#!/bin/sh
+
+curl smtp://localhost:2525 \
+  --mail-from '[e-mail]' \
+  --mail-rcpt '[e-mail]' \
+  --upload-file email.eml

go.mod

···
 	github.com/google/uuid v1.6.0
 	github.com/knadh/koanf/providers/confmap v0.1.0
 	github.com/knadh/koanf/providers/posflag v0.1.0
+	github.com/mhale/smtpd v0.8.3
 	github.com/pkg/sftp v1.13.7
 	github.com/robfig/cron/v3 v3.0.1
 	golang.org/x/crypto v0.31.0

go.sum

···
 github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mhale/smtpd v0.8.3 h1:8j8YNXajksoSLZja3HdwvYVZPuJSqAxFsib3adzRRt8=
+github.com/mhale/smtpd v0.8.3/go.mod h1:MQl+y2hwIEQCXtNhe5+55n0GZOjSmeqORDIXbqUL3x4=
 github.com/mholt/acmez/v2 v2.0.3 h1:CgDBlEwg3QBp6s45tPQmFIBrkRIkBT4rW4orMM6p4sw=
 github.com/mholt/acmez/v2 v2.0.3/go.mod h1:pQ1ysaDeGrIMvJ9dfJMk5kJNkn7L2sb3UhyrX6Q91cw=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=

worker/worker.go

···
 
 type Worker struct {
 	App       app.App
-	RootDir   string
-	Domain    string
 	Env       map[string]string
 	StartedAt time.Time
 
···
 	activeRequests atomic.Int32
 }
 
-func commandEnv(a app.App, rootDir string, domain string) []string {
+func commandEnv(a app.App) []string {
 	env := []string{}
 
 	for k, v := range a.Env {
···
 	env = append(env, fmt.Sprintf("DENO_DIR=%s", filepath.Join(xdg.CacheHome, "smallweb", "deno")))
 
 	env = append(env, fmt.Sprintf("SMALLWEB_VERSION=%s", build.Version))
-	env = append(env, fmt.Sprintf("SMALLWEB_DIR=%s", rootDir))
-	env = append(env, fmt.Sprintf("SMALLWEB_DOMAIN=%s", domain))
+	env = append(env, fmt.Sprintf("SMALLWEB_DIR=%s", a.RootDir))
+	env = append(env, fmt.Sprintf("SMALLWEB_DOMAIN=%s", a.RootDomain))
 	env = append(env, fmt.Sprintf("SMALLWEB_APP_NAME=%s", a.Name))
 	env = append(env, fmt.Sprintf("SMALLWEB_APP_DOMAIN=%s", a.Domain))
 	env = append(env, fmt.Sprintf("SMALLWEB_APP_URL=%s", a.URL))
···
 
 	if a.Admin {
 		env = append(env, "SMALLWEB_ADMIN=1")
-		env = append(env, "SMALLWEB_LOG_PATH=%s", utils.GetLogFilename(domain))
+		env = append(env, "SMALLWEB_LOG_PATH=%s", utils.GetLogFilename(a.RootDomain))
 	}
 
 	return env
 }
 
-func NewWorker(app app.App, rootDir string, domain string) *Worker {
+func NewWorker(app app.App) *Worker {
 	worker := &Worker{
-		App:     app,
-		RootDir: rootDir,
-		Domain:  domain,
+		App: app,
 	}
 
 	return worker
···
 	if a.Admin {
 		args = append(
 			args,
-			fmt.Sprintf("--allow-read=%s,%s,%s,%s", me.RootDir, sandboxPath, deno, npmCache),
-			fmt.Sprintf("--allow-write=%s", me.RootDir),
+			fmt.Sprintf("--allow-read=%s,%s,%s,%s", me.App.RootDir, sandboxPath, deno, npmCache),
+			fmt.Sprintf("--allow-write=%s", me.App.RootDir),
 		)
 
 		return args
 	}
 
-	appRoot := a.Root()
+	appRoot := a.DataDir()
 	// if root is not a symlink
 	if fi, err := os.Lstat(appRoot); err == nil && fi.Mode()&os.ModeSymlink == 0 {
 		args = append(
···
 	args = append(args, sandboxPath, input.String())
 
 	command := exec.Command(deno, args...)
-	command.Dir = me.App.Root()
-	command.Env = commandEnv(me.App, me.RootDir, me.Domain)
+	command.Dir = me.App.DataDir()
+	command.Env = commandEnv(me.App)
 
 	stdoutPipe, err := command.StdoutPipe()
 	if err != nil {
···
 	denoArgs = append(denoArgs, sandboxPath, input.String())
 
 	command := exec.CommandContext(ctx, deno, denoArgs...)
-	command.Dir = me.App.Root()
+	command.Dir = me.App.DataDir()
 
-	command.Env = commandEnv(me.App, me.RootDir, me.Domain)
+	command.Env = commandEnv(me.App)
 
 	return command, nil
 }
···
 	denoArgs = append(denoArgs, sandboxPath, input.String())
 
 	command := exec.CommandContext(ctx, deno, denoArgs...)
-	command.Dir = me.App.Root()
+	command.Dir = me.App.DataDir()
 	command.Stderr = os.Stderr
-	command.Env = commandEnv(me.App, me.RootDir, me.Domain)
+	command.Env = commandEnv(me.App)
 
 	stdin, err := command.StdinPipe()
 	if err != nil {