resolution. func (a *App) ServeLanding(w http.ResponseWriter, r *http.Request) bool { if r.URL.Path != "/" && r.URL.Path != "/relays" { return false } if r.Method == http.MethodGet && r.URL.Path == "/" { a.landingPage(w, r) return true } if r.Method == http.MethodGet && r.URL.Path == "/relays" { a.relayList(w, r) return true } if r.Method == http.MethodPost && r.URL.Path == "/relays" { a.createRelay(w, r) return true } http.Error(w, "method not allowed", http.StatusMethodNotAllowed) return true } type landingRelay struct{ Name, URL, Status string } func (a *App) landingPage(w http.ResponseWriter, r *http.Request) { relays, err := a.publicRelays(r.Context(), r) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } tmpl := template.Must(template.New("landing").Parse(`tiny relays

tiny relays

Self-hosted relays with permanent ownership.

Create a relay

Public relays

Name	Status
{{.Name}}	{{.Status}}

No public relays are listed.

`)) w.Header().Set("Content-Type", "text/html; charset=utf-8") _ = tmpl.Execute(w, relays) } func (a *App) relayList(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet { http.Error(w, "method not allowed", http.StatusMethodNotAllowed) return } tmpl := template.Must(template.New("create").Parse(`Create relay

Create a permanent relay

Use a NIP-07 browser signer. Ownership is assigned to the signer.

Browser provisioning is restricted to operator-approved owners. The command line remains available to the host operator.

Back

`)) w.Header().Set("Content-Type", "text/html; charset=utf-8") _ = tmpl.Execute(w, struct{ Templates []string }{Templates: templates.Names()}) } func (a *App) createRelay(w http.ResponseWriter, r *http.Request) { reader := io.Reader(r.Body) if a.cfg.MaxMessageBytes > 0 { reader = http.MaxBytesReader(w, r.Body, a.cfg.MaxMessageBytes) } body, err := io.ReadAll(reader) if err != nil { http.Error(w, err.Error(), 400) return } var input struct { Name string `json:"name"` Template string `json:"template"` Owner string `json:"owner"` Source string `json:"source"` } if err := json.Unmarshal(body, &input); err != nil { r.Body = io.NopCloser(strings.NewReader(string(body))) _ = r.ParseForm() input.Name, input.Template, input.Owner, input.Source = r.FormValue("name"), r.FormValue("template"), r.FormValue("owner"), r.FormValue("source") } if input.Template == "" { input.Template = "default" } if input.Source != "" { u, parseErr := url.Parse(input.Source) if parseErr != nil || u.Host == "" || u.User != nil || (u.Scheme != "http" && u.Scheme != "https" && u.Scheme != "ws" && u.Scheme != "wss") { http.Error(w, "source must be an http, https, ws, or wss relay", 400) return } } requestedURL := a.publicURL(r, "") + "/relays" validator := auth.NewValidator(time.Now) proof, err := validator.VerifyNIP98(r.Header.Get("Authorization"), requestedURL, r.Method, string(body)) if err != nil { http.Error(w, err.Error(), 401) return } if proof.PubKey != input.Owner { http.Error(w, "owner must match the signer", 403) return } if !a.provisionAllowed(proof.PubKey) { http.Error(w, "browser provisioning is disabled for this owner", http.StatusForbidden) return } consumed, err := a.catalog.ConsumeAuth(r.Context(), proof.ID, time.Now().Add(time.Minute)) if err != nil { http.Error(w, "authorization storage failed", http.StatusInternalServerError) return } if !consumed { http.Error(w, "authorization has already been used", http.StatusUnauthorized) return } meta, err := a.Create(r.Context(), catalog.CreateOptions{Name: input.Name, Owner: input.Owner, Template: input.Template, Source: input.Source}) if err != nil { http.Error(w, err.Error(), 400) return } writeJSON(w, http.StatusCreated, map[string]any{"name": meta.Name, "owner": meta.Owner, "status": meta.Status, "url": strings.TrimSuffix(a.publicURL(r, ""), "/") + "/r/" + meta.Name}) } func (a *App) provisionAllowed(pubkey string) bool { for _, allowed := range a.cfg.ProvisionOwners { if strings.EqualFold(strings.TrimSpace(allowed), pubkey) { return true } } return false } func (a *App) publicRelays(ctx context.Context, r *http.Request) ([]landingRelay, error) { items, err := a.catalog.List(ctx) if err != nil { return nil, err } result := make([]landingRelay, 0, len(items)) base := strings.TrimSuffix(a.publicURL(r, ""), "/") for _, item := range items { if item.Status != catalog.StatusReady { continue } store, openErr := storage.Open(ctx, item.Paths.Database) if openErr != nil { continue } var p policy.Policy policyErr := store.GetSetting(ctx, "policy", &p) _ = store.Close() if policyErr != nil || !p.DirectoryPublic { continue } result = append(result, landingRelay{Name: item.Name, URL: base + "/r/" + item.Name, Status: string(item.Status)}) } return result, nil }