rework config schema

.gitignore

···
 
 __debug_bin*
 /smallweb
+/www

cmd/crons.go

···
 	"log"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"time"
 
···
 					continue
 				}
 
-				app, err := app.LoadApp(name, k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), name))
+				app, err := app.LoadApp(name, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", name)))
 				if err != nil {
 					return fmt.Errorf("failed to load app: %w", err)
 				}
···
 		}
 
 		for _, name := range apps {
-			a, err := app.LoadApp(name, k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), name))
+			a, err := app.LoadApp(name, k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", name)))
 			if err != nil {
 				fmt.Println(err)
 				continue

cmd/fetch.go

···
 	"io"
 	"net/http/httptest"
 	"os"
-	"slices"
 	"strings"
 
 	"github.com/pomdtr/smallweb/app"
···
 
 			req.Host = fmt.Sprintf("%s.%s", args[0], k.String("domain"))
 
-			a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), args[0]))
+			a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", args[0])))
 			if err != nil {
 				return fmt.Errorf("failed to load app: %w", err)
 			}

cmd/logs.go

···
 			hosts := make(map[string]struct{})
 			hosts[fmt.Sprintf("%s.%s", appName, k.String("domain"))] = struct{}{}
 
-			for domain, app := range k.StringMap("customDomains") {
+			for domain, app := range k.StringMap("additionalDomains") {
 				if appName != "" && app != appName {
 					continue
 				}

cmd/root.go

···
 			return "dir", v
 		case "SMALLWEB_DOMAIN":
 			return "domain", v
-		case "SMALLWEB_REMOTE":
-			return "remote", v
-		case "SMALLWEB_CUSTOM_DOMAINS":
-			customDomains := make(map[string]string)
-			for _, entry := range strings.Split(v, ";") {
-				parts := strings.Split(entry, "=")
-				if len(parts) != 2 {
-					continue
-				}
-
-				customDomains[parts[0]] = parts[1]
-			}
-
-			return "customDomains", customDomains
+		case "SMALLWEB_ADDITIONAL_DOMAINS":
+			additionalDomains := strings.Split(v, ";")
+			return "additional_domains", additionalDomains
 		}
 
 		return "", nil

cmd/run.go

···
 import (
 	"fmt"
 	"os"
-	"slices"
 
 	"github.com/pomdtr/smallweb/app"
 	"github.com/pomdtr/smallweb/worker"
···
 				return cmd.Help()
 			}
 
-			a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), slices.Contains(k.Strings("adminApps"), args[0]))
+			a, err := app.LoadApp(args[0], k.String("dir"), k.String("domain"), k.Bool(fmt.Sprintf("apps.%s.admin", args[0])))
 			if err != nil {
 				return fmt.Errorf("failed to load app: %w", err)
 			}

cmd/up.go

···
 			if flags.onDemandTLS {
 				certmagic.Default.OnDemand = &certmagic.OnDemandConfig{
 					DecisionFunc: func(ctx context.Context, name string) error {
-						domain := k.String("domain")
-						if name == domain {
-							return nil
-						}
-
-						customDomains := k.StringMap("customDomains")
-						if _, ok := customDomains[name]; ok {
-							return nil
-						}
-
-						parts := strings.SplitN(name, ".", 2)
-						if len(parts) != 2 {
-							return fmt.Errorf("invalid domain: %s", name)
-						}
-
-						base := parts[1]
-						if base == domain {
+						if _, _, ok := lookupApp(name); ok {
 							return nil
 						}
 
-						if target, ok := customDomains[base]; ok && target == "*" {
+						if _, err := os.Stat(filepath.Join(k.String("dir"), name)); err == nil {
 							return nil
 						}
 
-						return fmt.Errorf("domain not found: %s", name)
+						return fmt.Errorf("domain not found")
 					},
 				}
 				fmt.Fprintf(cmd.ErrOrStderr(), "Serving *.%s from %s on %s...\n", k.String("domain"), utils.AddTilde(k.String("dir")), ":443")
···
 					wish.WithAddress(flags.sshAddr),
 					wish.WithHostKeyPath(hostKey),
 					wish.WithPublicKeyAuth(func(ctx ssh.Context, key ssh.PublicKey) bool {
-						authorizedKeyPaths := []string{filepath.Join(k.String("dir"), ".smallweb", "authorized_keys")}
-
+						authorizedKeys := k.Strings("authorizedKeys")
 						if ctx.User() != "_" {
-							authorizedKeyPaths = append(authorizedKeyPaths, filepath.Join(k.String("dir"), ctx.User(), "authorized_keys"))
+							authorizedKeys = append(authorizedKeys, k.Strings(fmt.Sprintf("apps.%s.authorizedKeys"))...)
 						}
 
-						for _, authorizedKeysPath := range authorizedKeyPaths {
-							if _, err := os.Stat(authorizedKeysPath); err != nil {
-								return false
-							}
-
-							authorizedKeysBytes, err := os.ReadFile(authorizedKeysPath)
+						for _, authorizedKey := range authorizedKeys {
+							k, _, _, _, err := gossh.ParseAuthorizedKey([]byte(authorizedKey))
 							if err != nil {
-								return false
+								continue
 							}
 
-							for len(authorizedKeysBytes) > 0 {
-								k, _, _, rest, err := gossh.ParseAuthorizedKey(authorizedKeysBytes)
-								if err != nil {
-									return false
-								}
-
-								if ssh.KeysEqual(k, key) {
-									return true
-								}
-
-								authorizedKeysBytes = rest
+							if ssh.KeysEqual(k, key) {
+								return true
 							}
 						}
 
 						return false
 					}),
-					// TODO: re-implement sftp
 					sftp.SSHOption(k.String("dir"), nil),
 					wish.WithMiddleware(func(next ssh.Handler) ssh.Handler {
 						return func(sess ssh.Session) {
···
 								cmd.Env = os.Environ()
 								cmd.Env = append(cmd.Env, "SMALLWEB_DISABLE_PLUGINS=true")
 							} else {
-								a, 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"), k.Bool(fmt.Sprintf("apps.%s.admin", sess.User())))
 								if err != nil {
 									fmt.Fprintf(sess, "failed to load app: %v\n", err)
 									sess.Exit(1)
···
 }
 
 func (me *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	appname, redirect, ok := lookupApp(r.Host, k.String("domain"), k.StringMap("customDomains"))
+	appname, redirect, ok := lookupApp(r.Host)
 	if !ok {
 		w.WriteHeader(http.StatusNotFound)
 		w.Write([]byte(fmt.Sprintf("No app found for host %s", r.Host)))
···
 	wk.ServeHTTP(w, r)
 }
 
-func lookupApp(host string, domain string, customDomains map[string]string) (app string, redirect bool, found bool) {
+func lookupApp(domain string) (app string, redirect bool, found bool) {
 	// check exact matches first
-	for key, value := range customDomains {
-		if value == "*" {
-			continue
-		}
-
-		if key == host {
-			return value, false, true
-		}
+	if domain == k.String("domain") {
+		return "www", true, true
 	}
 
-	if host == domain {
-		return "www", true, true
+	if strings.HasSuffix(domain, fmt.Sprintf(".%s", k.String("domain"))) {
+		return strings.TrimSuffix(domain, fmt.Sprintf(".%s", k.String("domain"))), false, true
 	}
 
-	// check for subdomains
-	for key, value := range customDomains {
-		if value != "*" {
-			continue
-		}
-
-		if key == host {
+	for _, additionalDomain := range k.Strings("additionalDomains") {
+		if domain == additionalDomain {
 			return "www", true, true
 		}
 
-		if strings.HasSuffix(host, "."+key) {
-			return strings.TrimSuffix(host, "."+key), false, true
+		if strings.HasSuffix(domain, fmt.Sprintf(".%s", additionalDomain)) {
+			return strings.TrimSuffix(domain, fmt.Sprintf(".%s", additionalDomain)), false, true
 		}
 	}
 
-	if strings.HasSuffix(host, "."+domain) {
-		return strings.TrimSuffix(host, "."+domain), false, true
+	for _, app := range k.MapKeys("apps") {
+		if slices.Contains(k.Strings(fmt.Sprintf("apps.%s.additionalDomains")), domain) {
+			return app, false, true
+		}
 	}
 
 	return "", false, false
···
 	me.mu.Lock()
 	defer me.mu.Unlock()
 
-	a, err := app.LoadApp(appname, rootDir, domain, slices.Contains(k.Strings("adminApps"), appname))
+	a, err := app.LoadApp(appname, rootDir, domain, k.Bool(fmt.Sprintf("apps.%s.admin", appname)))
 	if err != nil {
 		return nil, fmt.Errorf("failed to load app: %w", err)
 	}

cmd/up_test.go

···
-package cmd
-
-import (
-	"testing"
-)
-
-func TestLookupApp(t *testing.T) {
-	type TestCaseWant struct {
-		app      string
-		redirect bool
-		ok       bool
-	}
-	type TestCase struct {
-		name          string
-		host          string
-		domain        string
-		customDomains map[string]string
-		want          TestCaseWant
-	}
-
-	cases := []TestCase{
-		{
-			name:   "apex domain",
-			host:   "smallweb.run",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "www",
-				redirect: true,
-				ok:       true,
-			},
-		},
-		{
-			name:   "subdomain",
-			host:   "example.smallweb.run",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "example",
-				redirect: false,
-				ok:       true,
-			},
-		},
-		{
-			name:   "custom subdomain",
-			host:   "custom.smallweb.run",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "www",
-				redirect: false,
-				ok:       true,
-			},
-		},
-		{
-			name:   "custom domain exact match",
-			host:   "smallweb.cloud",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "cloud",
-				redirect: false,
-				ok:       true,
-			},
-		},
-		{
-			name:   "custom domain wildcard apex domain",
-			host:   "pomdtr.me",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "www",
-				redirect: true,
-				ok:       true,
-			},
-		},
-		{
-			name:   "custom domain wildcard subdomain",
-			host:   "example.pomdtr.me",
-			domain: "smallweb.run",
-			customDomains: map[string]string{
-				"smallweb.cloud":      "cloud",
-				"custom.smallweb.run": "www",
-				"pomdtr.me":           "*",
-			},
-			want: TestCaseWant{
-				app:      "example",
-				redirect: false,
-				ok:       true,
-			},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			app, redirect, ok := lookupApp(c.host, c.domain, c.customDomains)
-			if app != c.want.app || redirect != c.want.redirect || ok != c.want.ok {
-				t.Errorf("lookupApp() = %v, %v, %v; want %v, %v, %v", app, redirect, ok, c.want.app, c.want.redirect, c.want.ok)
-			}
-		})
-	}
-}

examples/.smallweb/config.json

···
 {
-    "adminApps": [
-        "ls"
-    ]
+    "authorizedKeys": [
+        "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJW+GQk0KCvSreL+y3AZdtCu82+13E2eEled+sGRkIEv"
+    ],
+    "apps": {
+        "ls": {
+            "admin": true
+        }
+    }
 }

schemas/config.schema.json

···
     "type": "object",
     "properties": {
         "domain": {
-            "description": "Domain name",
+            "description": "Smallweb name",
             "type": "string"
         },
-        "customDomains": {
-            "description": "Custom domains",
-            "type": "object",
-            "additionalProperties": {
+        "additionalDomains": {
+            "description": "Additional wildcard domains",
+            "type": "array",
+            "items": {
                 "type": "string"
             }
         },
-        "adminApps": {
-            "description": "Admin apps",
+        "authorizedKeys": {
+            "description": "Authorized SSH keys",
             "type": "array",
             "items": {
                 "type": "string"
             }
+        },
+        "apps": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/definitions/appConfig"
+            }
+        }
+    },
+    "definitions": {
+        "appConfig": {
+            "type": "object",
+            "properties": {
+                "admin": {
+                    "description": "Give the app admin privileges",
+                    "type": "boolean"
+                },
+                "additionalDomains": {
+                    "description": "Additional app domains",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "authorizedKeys": {
+                    "description": "Authorized SSH keys",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            }
         }
     }
-}
+}

worker/worker.go

···
 		return args
 	}
 
-	authorizedKeysPath := filepath.Join(me.App.RootDir, ".smallweb", "authorized_keys")
-
 	// if root is not a symlink
 	if fi, err := os.Lstat(appDir); err == nil && fi.Mode()&os.ModeSymlink == 0 {
 		args = append(
 			args,
-			fmt.Sprintf("--allow-read=%s,%s,%s,%s,%s", appDir, authorizedKeysPath, sandboxPath, deno, npmCache),
+			fmt.Sprintf("--allow-read=%s,%s,%s,%s", appDir, sandboxPath, deno, npmCache),
 			fmt.Sprintf("--allow-write=%s", me.App.DataDir()),
 		)
 
···
 
 	args = append(
 		args,
-		fmt.Sprintf("--allow-read=%s,%s,%s,%s,%s,%s", appDir, authorizedKeysPath, target, sandboxPath, deno, npmCache),
+		fmt.Sprintf("--allow-read=%s,%s,%s,%s,%s", appDir, target, sandboxPath, deno, npmCache),
 		fmt.Sprintf("--allow-write=%s,%s", me.App.DataDir(), filepath.Join(target, "data")),
 	)
 	return args