rework logs
+43
-42
+1
-3
app/app.go
+1
-3
app/app.go
···
35
35
}
36
36
37
37
type App struct {
38
-
Admin bool `json:"admin"`
39
38
Name string `json:"name"`
40
39
RootDir string `json:"-"`
41
40
RootDomain string `json:"-"`
···
114
113
return apps, nil
115
114
}
116
115
117
-
func LoadApp(appname string, rootDir string, domain string, isAdmin bool) (App, error) {
116
+
func LoadApp(appname string, rootDir string, domain string) (App, error) {
118
117
appDir := filepath.Join(rootDir, appname)
119
118
if !utils.FileExists(filepath.Join(rootDir, appname)) {
120
119
return App{}, ErrAppNotFound
···
122
121
123
122
app := App{
124
123
Name: appname,
125
-
Admin: isAdmin,
126
124
RootDir: rootDir,
127
125
RootDomain: domain,
128
126
BaseDir: filepath.Join(rootDir, appname),
+3
-3
cmd/crons.go
+3
-3
cmd/crons.go
···
74
74
}
75
75
}
76
76
77
-
a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", appname)))
77
+
a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"))
78
78
if err != nil {
79
79
return fmt.Errorf("failed to load app %s: %w", appname, err)
80
80
}
···
158
158
continue
159
159
}
160
160
161
-
a, err := app.LoadApp(appname, k.String("rootDir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", appname)))
161
+
a, err := app.LoadApp(appname, k.String("rootDir"), k.String("domain"))
162
162
if err != nil {
163
163
fmt.Println(err)
164
164
continue
165
165
}
166
-
wk := worker.NewWorker(a, nil)
166
+
wk := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), nil)
167
167
168
168
command, err := wk.Command(context.Background(), job.Strings("args"), nil)
169
169
if err != nil {
+1
-2
cmd/list.go
+1
-2
cmd/list.go
···
43
43
Name: name,
44
44
BaseDir: filepath.Join(k.String("dir"), name),
45
45
URL: fmt.Sprintf("https://%s.%s", name, k.String("domain")),
46
-
Admin: k.Bool(fmt.Sprintf("apps.%s.admin", name)),
47
46
})
48
47
}
49
48
···
122
121
printer.AddField(strings.Replace(a.BaseDir, os.Getenv("HOME"), "~", 1))
123
122
printer.AddField(a.URL)
124
123
125
-
if a.Admin {
124
+
if k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)) {
126
125
printer.AddField("Yes")
127
126
} else {
128
127
printer.AddField("No")
+2
-3
cmd/open.go
+2
-3
cmd/open.go
···
4
4
"fmt"
5
5
"os"
6
6
"path/filepath"
7
-
"slices"
8
7
"strings"
9
8
10
9
"github.com/cli/browser"
···
35
34
}
36
35
37
36
appName := filepath.Base(appDir)
38
-
a, err := app.LoadApp(appName, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", appName)))
37
+
a, err := app.LoadApp(appName, k.String("dir"), k.String("domain"))
39
38
if err != nil {
40
39
return fmt.Errorf("failed to load app: %w", err)
41
40
}
···
47
46
return nil
48
47
}
49
48
50
-
a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), args[0]))
49
+
a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"))
51
50
if err != nil {
52
51
return fmt.Errorf("failed to load app: %w", err)
53
52
}
+2
-2
cmd/run.go
+2
-2
cmd/run.go
···
32
32
return cmd.Help()
33
33
}
34
34
35
-
a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", args[0])))
35
+
a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"))
36
36
if err != nil {
37
37
return fmt.Errorf("failed to load app: %w", err)
38
38
}
39
39
40
-
wk := worker.NewWorker(a, nil)
40
+
wk := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), nil)
41
41
var input []byte
42
42
if !isatty.IsTerminal(os.Stdin.Fd()) {
43
43
i, err := io.ReadAll(os.Stdin)
+22
-22
cmd/up.go
+22
-22
cmd/up.go
···
29
29
"github.com/charmbracelet/wish"
30
30
"github.com/coreos/go-oidc/v3/oidc"
31
31
"github.com/knadh/koanf/providers/file"
32
+
"github.com/lmittmann/tint"
32
33
"github.com/mattn/go-isatty"
33
34
"github.com/mhale/smtpd"
34
35
sloghttp "github.com/samber/slog-http"
···
80
81
},
81
82
RunE: func(cmd *cobra.Command, args []string) error {
82
83
var logger *slog.Logger
83
-
if flags.logFormat == "" {
84
-
if isatty.IsTerminal(os.Stdout.Fd()) {
85
-
logger = slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{}))
86
-
} else {
87
-
logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{}))
88
-
}
89
-
} else if flags.logFormat == "json" {
84
+
switch flags.logFormat {
85
+
case "json":
90
86
logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{}))
91
-
} else if flags.logFormat == "text" {
92
-
logger = slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{}))
93
-
} else {
87
+
case "text", "":
88
+
logger = slog.New(tint.NewHandler(os.Stdout, &tint.Options{
89
+
NoColor: !isatty.IsTerminal(os.Stdout.Fd()),
90
+
}))
91
+
default:
94
92
return fmt.Errorf("invalid log format: %s", flags.logFormat)
95
93
}
96
94
···
170
168
},
171
169
}
172
170
logger.Info("serving on-demand https", "domain", k.String("domain"), "dir", k.String("dir"))
173
-
go certmagic.HTTPS(nil, sloghttp.New(logger.With("logger", "http"))(handler))
171
+
logMiddleware := sloghttp.New(logger.With("logger", "http"))
172
+
go certmagic.HTTPS(nil, logMiddleware(handler))
174
173
} else if flags.tlsCert != "" && flags.tlsKey != "" {
175
174
cert, err := tls.LoadX509KeyPair(flags.tlsCert, flags.tlsKey)
176
175
if err != nil {
···
192
191
return ErrSilent
193
192
}
194
193
195
-
logger.Info("serving https", "domain", k.String("domain"), "dir", k.String("dir"))
196
-
go http.Serve(ln, sloghttp.New(logger.With("logger", "http"))(handler))
194
+
logger.Info("serving https", "domain", k.String("domain"), "dir", k.String("dir"), "addr", addr)
195
+
logMiddleware := sloghttp.New(logger.With("logger", "http"))
196
+
go http.Serve(ln, logMiddleware(handler))
197
197
} else {
198
198
addr := flags.addr
199
199
if addr == "" {
···
206
206
return ErrSilent
207
207
}
208
208
209
-
logger.Info("serving http", "domain", k.String("domain"), "dir", k.String("dir"))
210
-
go http.Serve(ln, sloghttp.New(logger.With("logger", "http"))(handler))
209
+
logger.Info("serving http", "domain", k.String("domain"), "dir", k.String("dir"), "addr", addr)
210
+
logMiddleware := sloghttp.New(logger.With("logger", "http"))
211
+
go http.Serve(ln, logMiddleware(handler))
211
212
}
212
213
213
214
if flags.enableCrons {
···
232
233
continue
233
234
}
234
235
235
-
a, err := app.LoadApp(account, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", parts[0])))
236
+
a, err := app.LoadApp(account, k.String("dir"), k.String("domain"))
236
237
if err != nil {
237
238
logger.Error("failed to load app", "error", err)
238
239
continue
239
240
}
240
241
241
-
worker := worker.NewWorker(a, nil)
242
+
worker := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), nil)
242
243
if err := worker.SendEmail(context.Background(), data); err != nil {
243
244
logger.Error("failed to send email", "error", err)
244
245
continue
···
324
325
wish.WithMiddleware(func(next ssh.Handler) ssh.Handler {
325
326
return func(sess ssh.Session) {
326
327
if sess.User() != "_" {
327
-
a, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", sess.User())))
328
+
a, err := app.LoadApp(sess.User(), k.String("dir"), k.String("domain"))
328
329
if err != nil {
329
330
fmt.Fprintf(sess, "failed to load app: %v\n", err)
330
331
sess.Exit(1)
331
332
return
332
333
}
333
334
334
-
wk := worker.NewWorker(a, nil)
335
+
wk := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), nil)
335
336
var input []byte
336
337
if !sess.EmulatedPty() {
337
338
input, err = io.ReadAll(sess)
···
979
980
me.workerMu.Lock()
980
981
defer me.workerMu.Unlock()
981
982
982
-
a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", appname)))
983
+
a, err := app.LoadApp(appname, k.String("dir"), k.String("domain"))
983
984
if err != nil {
984
985
return nil, fmt.Errorf("failed to load app: %w", err)
985
986
}
986
987
987
-
wk := worker.NewWorker(a, me.logger.With("logger", "console", "app", appname))
988
-
988
+
wk := worker.NewWorker(a, k.Bool(fmt.Sprintf("apps.%s.admin", a.Name)), me.logger.With("logger", "console", "app", appname))
989
989
if err := wk.Start(); err != nil {
990
990
return nil, fmt.Errorf("failed to start worker: %w", err)
991
991
}
+1
go.mod
+1
go.mod
+2
go.sum
+2
go.sum
···
297
297
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
298
298
github.com/libdns/libdns v0.2.3 h1:ba30K4ObwMGB/QTmqUxf3H4/GmUrCAIkMWejeGl12v8=
299
299
github.com/libdns/libdns v0.2.3/go.mod h1:4Bj9+5CQiNMVGf87wjX4CY3HQJypUHRuLvlsfsZqLWQ=
300
+
github.com/lmittmann/tint v1.0.7 h1:D/0OqWZ0YOGZ6AyC+5Y2kD8PBEzBk6rFHVSfOqCkF9Y=
301
+
github.com/lmittmann/tint v1.0.7/go.mod h1:HIS3gSy7qNwGCj+5oRjAutErFBl4BzdQP6cJZ0NfMwE=
300
302
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
301
303
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
302
304
github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
+9
-7
worker/worker.go
+9
-7
worker/worker.go
···
34
34
Env map[string]string
35
35
StartedAt time.Time
36
36
Logger *slog.Logger
37
+
Admin bool
37
38
38
39
port int
39
40
idleTimer *time.Timer
···
41
42
activeRequests atomic.Int32
42
43
}
43
44
44
-
func commandEnv(a app.App) []string {
45
+
func commandEnv(a app.App, admin bool) []string {
45
46
env := []string{}
46
47
47
48
for k, v := range a.Env {
···
58
59
env = append(env, fmt.Sprintf("SMALLWEB_APP_DOMAIN=%s", a.Domain))
59
60
env = append(env, fmt.Sprintf("SMALLWEB_APP_URL=%s", a.URL))
60
61
env = append(env, fmt.Sprintf("SMALLWEB_APP_DIR=%s", a.BaseDir))
61
-
if a.Admin {
62
+
if admin {
62
63
env = append(env, "SMALLWEB_ADMIN=1")
63
64
}
64
65
···
73
74
return env
74
75
}
75
76
76
-
func NewWorker(app app.App, logger *slog.Logger) *Worker {
77
+
func NewWorker(app app.App, admin bool, logger *slog.Logger) *Worker {
77
78
worker := &Worker{
78
79
App: app,
79
80
Logger: logger,
81
+
Admin: admin,
80
82
}
81
83
82
84
return worker
···
101
103
}
102
104
103
105
npmCache := filepath.Join(xdg.CacheHome, "deno", "npm", "registry.npmjs.org")
104
-
if me.App.Admin {
106
+
if me.Admin {
105
107
args = append(
106
108
args,
107
109
fmt.Sprintf("--allow-read=%s,%s,%s", me.App.RootDir, deno, npmCache),
···
176
178
command := exec.Command(deno, args...)
177
179
command.Stdin = strings.NewReader(sandboxContent)
178
180
command.Dir = me.App.Dir()
179
-
command.Env = commandEnv(me.App)
181
+
command.Env = commandEnv(me.App, me.Admin)
180
182
181
183
stdoutPipe, err := command.StdoutPipe()
182
184
if err != nil {
···
495
497
command.Stdin = strings.NewReader(sandboxContent)
496
498
command.Dir = me.App.Dir()
497
499
498
-
command.Env = commandEnv(me.App)
500
+
command.Env = commandEnv(me.App, me.Admin)
499
501
500
502
return command, nil
501
503
}
···
534
536
command.Stdout = os.Stdout
535
537
command.Dir = me.App.Dir()
536
538
537
-
command.Env = commandEnv(me.App)
539
+
command.Env = commandEnv(me.App, me.Admin)
538
540
539
541
return command.Run()
540
542
}