add draft smtp server
+100
-63
+2
.vscode/launch.json
+2
.vscode/launch.json
+1
-1
.vscode/tasks.json
+1
-1
.vscode/tasks.json
+20
-16
app/app.go
+20
-16
app/app.go
···
31
31
}
32
32
33
33
type App struct {
34
-
Admin bool `json:"admin"`
35
-
Name string `json:"name"`
36
-
Dir string `json:"dir,omitempty"`
37
-
Domain string `json:"-"`
38
-
URL string `json:"url"`
39
-
Env map[string]string `json:"-"`
40
-
Config AppConfig `json:"-"`
34
+
Admin bool `json:"admin"`
35
+
Name string `json:"name"`
36
+
RootDir string `json:"-"`
37
+
RootDomain string `json:"-"`
38
+
Dir string `json:"dir,omitempty"`
39
+
Domain string `json:"-"`
40
+
URL string `json:"url"`
41
+
Env map[string]string `json:"-"`
42
+
Config AppConfig `json:"-"`
41
43
}
42
44
43
-
func (me *App) Root() string {
45
+
func (me *App) DataDir() string {
44
46
dir := me.Dir
45
47
if fi, err := os.Lstat(dir); err == nil && fi.Mode()&os.ModeSymlink != 0 {
46
48
if root, err := os.Readlink(dir); err == nil {
···
99
101
}
100
102
101
103
app := App{
102
-
Name: appname,
103
-
Admin: isAdmin,
104
-
Dir: filepath.Join(rootDir, appname),
105
-
Domain: fmt.Sprintf("%s.%s", appname, domain),
106
-
URL: fmt.Sprintf("https://%s.%s/", appname, domain),
107
-
Env: make(map[string]string),
104
+
Name: appname,
105
+
Admin: isAdmin,
106
+
RootDir: rootDir,
107
+
RootDomain: domain,
108
+
Dir: filepath.Join(rootDir, appname),
109
+
Domain: fmt.Sprintf("%s.%s", appname, domain),
110
+
URL: fmt.Sprintf("https://%s.%s/", appname, domain),
111
+
Env: make(map[string]string),
108
112
}
109
113
110
114
for _, dotenvPath := range []string{
···
202
206
}
203
207
204
208
if me.Config.Entrypoint != "" {
205
-
return filepath.Join(me.Root(), me.Config.Entrypoint)
209
+
return filepath.Join(me.DataDir(), me.Config.Entrypoint)
206
210
}
207
211
208
212
for _, candidate := range []string{"main.js", "main.ts", "main.jsx", "main.tsx"} {
209
-
path := filepath.Join(me.Root(), candidate)
213
+
path := filepath.Join(me.DataDir(), candidate)
210
214
if utils.FileExists(path) {
211
215
return path
212
216
}
+1
-1
cmd/crons.go
+1
-1
cmd/crons.go
+1
-1
cmd/email.go
+1
-1
cmd/email.go
···
84
84
return fmt.Errorf("failed to load app: %w", err)
85
85
}
86
86
87
-
wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
87
+
wk := worker.NewWorker(a)
88
88
89
89
if err := wk.SendEmail(cmd.Context(), strings.NewReader(message.String())); err != nil {
90
90
return fmt.Errorf("failed to send email: %w", err)
+1
-1
cmd/fetch.go
+1
-1
cmd/fetch.go
+1
-1
cmd/run.go
+1
-1
cmd/run.go
···
29
29
return fmt.Errorf("failed to load app: %w", err)
30
30
}
31
31
32
-
wk := worker.NewWorker(a, k.String("dir"), k.String("domain"))
32
+
wk := worker.NewWorker(a)
33
33
command, err := wk.Command(cmd.Context(), args[1:]...)
34
34
if err != nil {
35
35
return fmt.Errorf("failed to create command: %w", err)
+43
-23
cmd/up.go
+43
-23
cmd/up.go
···
25
25
"github.com/caddyserver/certmagic"
26
26
"github.com/charmbracelet/ssh"
27
27
"github.com/creack/pty"
28
+
"github.com/mhale/smtpd"
28
29
"github.com/pkg/sftp"
29
30
"github.com/pomdtr/smallweb/app"
30
31
"github.com/pomdtr/smallweb/watcher"
···
39
40
func NewCmdUp() *cobra.Command {
40
41
var flags struct {
41
42
cron bool
42
-
addr string
43
+
httpAddr string
44
+
smtpAddr string
43
45
sshAddr string
44
46
sshHostKey string
45
47
onDemandTLS bool
···
110
112
fmt.Fprintf(os.Stderr, "Serving *.%s from %s with on-demand TLS...\n", k.String("domain"), utils.AddTilde(k.String("dir")))
111
113
go certmagic.HTTPS(nil, handler)
112
114
} else {
113
-
addr := flags.addr
115
+
addr := flags.httpAddr
114
116
if addr == "" {
115
117
if flags.cert != "" || flags.key != "" {
116
118
addr = "0.0.0.0:443"
···
166
168
},
167
169
SubsystemHandlers: map[string]ssh.SubsystemHandler{
168
170
"sftp": func(sess ssh.Session) {
169
-
var workDir string
170
-
if sess.User() == "_" {
171
-
workDir = k.String("dir")
172
-
} else {
173
-
app, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
174
-
if err != nil {
175
-
fmt.Fprintln(sess, "failed to load app:", err)
176
-
return
177
-
}
178
-
179
-
workDir = filepath.Join(app.Root(), "data")
180
-
if _, err := os.Stat(workDir); err != nil {
181
-
fmt.Fprintln(sess, "failed to get app data directory")
182
-
return
183
-
}
171
+
if sess.User() != "_" {
172
+
fmt.Fprintln(sess, "sftp is only allowed for the _ user")
173
+
return
184
174
}
185
175
186
176
server, err := sftp.NewServer(
187
177
sess,
188
-
sftp.WithServerWorkingDirectory(workDir),
178
+
sftp.WithServerWorkingDirectory(utils.AddTilde(k.String("dir"))),
189
179
)
190
180
191
181
if err != nil {
···
211
201
cmd = exec.Command(execPath, sess.Command()...)
212
202
cmd.Env = os.Environ()
213
203
} else {
214
-
app, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
204
+
a, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), sess.User()))
215
205
if err != nil {
216
206
fmt.Fprintf(sess, "failed to load app: %v\n", err)
217
207
return
218
208
}
219
209
220
-
wk := worker.NewWorker(app, k.String("dir"), k.String("domain"))
210
+
wk := worker.NewWorker(a)
221
211
command, err := wk.Command(sess.Context(), sess.Command()...)
222
212
if err != nil {
223
213
fmt.Fprintf(sess, "failed to get command: %v\n", err)
···
289
279
defer server.Close()
290
280
}
291
281
282
+
if flags.smtpAddr != "" {
283
+
fmt.Fprintf(os.Stderr, "Starting SFTP server on %s...\n", flags.smtpAddr)
284
+
go smtpd.ListenAndServe(flags.smtpAddr, func(remoteAddr net.Addr, from string, to []string, data []byte) error {
285
+
for _, recipient := range to {
286
+
parts := strings.SplitN(recipient, "@", 2)
287
+
appname, domain := parts[0], parts[1]
288
+
if domain != k.String("domain") {
289
+
continue
290
+
}
291
+
292
+
a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), appname))
293
+
if err != nil {
294
+
if errors.Is(err, app.ErrAppNotFound) {
295
+
continue
296
+
}
297
+
298
+
return fmt.Errorf("failed to load app: %v", err)
299
+
}
300
+
301
+
wk := worker.NewWorker(a)
302
+
if err := wk.SendEmail(context.Background(), strings.NewReader(string(data))); err != nil {
303
+
return fmt.Errorf("failed to send email: %v", err)
304
+
}
305
+
}
306
+
307
+
return nil
308
+
}, "Smallweb", k.String("domain"))
309
+
}
310
+
292
311
// sigint handling
293
312
sigint := make(chan os.Signal, 1)
294
313
signal.Notify(sigint, os.Interrupt)
···
298
317
},
299
318
}
300
319
301
-
cmd.Flags().StringVar(&flags.addr, "addr", "", "address to listen on")
320
+
cmd.Flags().StringVar(&flags.httpAddr, "http-addr", "", "address to listen on")
302
321
cmd.Flags().StringVar(&flags.sshAddr, "ssh-addr", "", "address to listen on for ssh/sftp")
322
+
cmd.Flags().StringVar(&flags.smtpAddr, "smtp-addr", "", "address to listen on")
303
323
cmd.Flags().StringVar(&flags.sshHostKey, "ssh-host-key", "~/.ssh/id_ed25519", "ssh host key")
304
324
cmd.Flags().BoolVar(&flags.onDemandTLS, "on-demand-tls", false, "enable on-demand TLS")
305
325
cmd.Flags().StringVar(&flags.cert, "cert", "", "tls certificate file")
···
308
328
309
329
cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "cert")
310
330
cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "key")
311
-
cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "addr")
331
+
cmd.MarkFlagsMutuallyExclusive("on-demand-tls", "http-addr")
312
332
313
333
return cmd
314
334
}
···
442
462
return nil, fmt.Errorf("failed to load app: %w", err)
443
463
}
444
464
445
-
wk := worker.NewWorker(a, k.String("dir"), domain)
465
+
wk := worker.NewWorker(a)
446
466
447
467
wk.Logger = me.logger
448
468
if err := wk.Start(); err != nil {
examples/email/main.ts
examples/inbox/main.ts
examples/email/main.ts
examples/inbox/main.ts
+6
examples/inbox/email.eml
+6
examples/inbox/email.eml
+6
examples/inbox/run.sh
+6
examples/inbox/run.sh
+1
go.mod
+1
go.mod
+2
go.sum
+2
go.sum
···
298
298
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
299
299
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
300
300
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
301
+
github.com/mhale/smtpd v0.8.3 h1:8j8YNXajksoSLZja3HdwvYVZPuJSqAxFsib3adzRRt8=
302
+
github.com/mhale/smtpd v0.8.3/go.mod h1:MQl+y2hwIEQCXtNhe5+55n0GZOjSmeqORDIXbqUL3x4=
301
303
github.com/mholt/acmez/v2 v2.0.3 h1:CgDBlEwg3QBp6s45tPQmFIBrkRIkBT4rW4orMM6p4sw=
302
304
github.com/mholt/acmez/v2 v2.0.3/go.mod h1:pQ1ysaDeGrIMvJ9dfJMk5kJNkn7L2sb3UhyrX6Q91cw=
303
305
github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
+15
-19
worker/worker.go
+15
-19
worker/worker.go
···
52
52
53
53
type Worker struct {
54
54
App app.App
55
-
RootDir string
56
-
Domain string
57
55
Env map[string]string
58
56
StartedAt time.Time
59
57
···
64
62
activeRequests atomic.Int32
65
63
}
66
64
67
-
func commandEnv(a app.App, rootDir string, domain string) []string {
65
+
func commandEnv(a app.App) []string {
68
66
env := []string{}
69
67
70
68
for k, v := range a.Env {
···
76
74
env = append(env, fmt.Sprintf("DENO_DIR=%s", filepath.Join(xdg.CacheHome, "smallweb", "deno")))
77
75
78
76
env = append(env, fmt.Sprintf("SMALLWEB_VERSION=%s", build.Version))
79
-
env = append(env, fmt.Sprintf("SMALLWEB_DIR=%s", rootDir))
80
-
env = append(env, fmt.Sprintf("SMALLWEB_DOMAIN=%s", domain))
77
+
env = append(env, fmt.Sprintf("SMALLWEB_DIR=%s", a.RootDir))
78
+
env = append(env, fmt.Sprintf("SMALLWEB_DOMAIN=%s", a.RootDomain))
81
79
env = append(env, fmt.Sprintf("SMALLWEB_APP_NAME=%s", a.Name))
82
80
env = append(env, fmt.Sprintf("SMALLWEB_APP_DOMAIN=%s", a.Domain))
83
81
env = append(env, fmt.Sprintf("SMALLWEB_APP_URL=%s", a.URL))
···
88
86
89
87
if a.Admin {
90
88
env = append(env, "SMALLWEB_ADMIN=1")
91
-
env = append(env, "SMALLWEB_LOG_PATH=%s", utils.GetLogFilename(domain))
89
+
env = append(env, "SMALLWEB_LOG_PATH=%s", utils.GetLogFilename(a.RootDomain))
92
90
}
93
91
94
92
return env
95
93
}
96
94
97
-
func NewWorker(app app.App, rootDir string, domain string) *Worker {
95
+
func NewWorker(app app.App) *Worker {
98
96
worker := &Worker{
99
-
App: app,
100
-
RootDir: rootDir,
101
-
Domain: domain,
97
+
App: app,
102
98
}
103
99
104
100
return worker
···
128
124
if a.Admin {
129
125
args = append(
130
126
args,
131
-
fmt.Sprintf("--allow-read=%s,%s,%s,%s", me.RootDir, sandboxPath, deno, npmCache),
132
-
fmt.Sprintf("--allow-write=%s", me.RootDir),
127
+
fmt.Sprintf("--allow-read=%s,%s,%s,%s", me.App.RootDir, sandboxPath, deno, npmCache),
128
+
fmt.Sprintf("--allow-write=%s", me.App.RootDir),
133
129
)
134
130
135
131
return args
136
132
}
137
133
138
-
appRoot := a.Root()
134
+
appRoot := a.DataDir()
139
135
// if root is not a symlink
140
136
if fi, err := os.Lstat(appRoot); err == nil && fi.Mode()&os.ModeSymlink == 0 {
141
137
args = append(
···
192
188
args = append(args, sandboxPath, input.String())
193
189
194
190
command := exec.Command(deno, args...)
195
-
command.Dir = me.App.Root()
196
-
command.Env = commandEnv(me.App, me.RootDir, me.Domain)
191
+
command.Dir = me.App.DataDir()
192
+
command.Env = commandEnv(me.App)
197
193
198
194
stdoutPipe, err := command.StdoutPipe()
199
195
if err != nil {
···
505
501
denoArgs = append(denoArgs, sandboxPath, input.String())
506
502
507
503
command := exec.CommandContext(ctx, deno, denoArgs...)
508
-
command.Dir = me.App.Root()
504
+
command.Dir = me.App.DataDir()
509
505
510
-
command.Env = commandEnv(me.App, me.RootDir, me.Domain)
506
+
command.Env = commandEnv(me.App)
511
507
512
508
return command, nil
513
509
}
···
534
530
denoArgs = append(denoArgs, sandboxPath, input.String())
535
531
536
532
command := exec.CommandContext(ctx, deno, denoArgs...)
537
-
command.Dir = me.App.Root()
533
+
command.Dir = me.App.DataDir()
538
534
command.Stderr = os.Stderr
539
-
command.Env = commandEnv(me.App, me.RootDir, me.Domain)
535
+
command.Env = commandEnv(me.App)
540
536
541
537
stdin, err := command.StdinPipe()
542
538
if err != nil {