Implement Knowledge City platform, organizer and DAV integration

Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
This commit is contained in:
Anya Tokugawa committed 2026-09-27 14:44:43 +09:00
1 parent 288e6e94ac
commit c1175d389f
699 files changed
+110197 -4117

No files matched your search

+137
View File
@@ -0,0 +1,137 @@
package server
import (
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"net/url"
"sort"
"strings"
)
const externalResourceApprovalsConfig = "external_resource_approvals_v1"
const maxExternalResourceApprovals = 128
type externalResourceApproval struct {
Kind string `json:"kind"`
URL string `json:"url"`
Integrity string `json:"integrity,omitempty"`
}
type externalResourcePolicy struct {
items []externalResourceApproval
byKind map[string]map[string]externalResourceApproval
}
func normalizeExternalResourceURL(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if raw == "" || len(raw) > 2048 || strings.ContainsAny(raw, " \\\r\n\t") {
return "", errors.New("invalid external resource URL")
}
u, err := url.Parse(raw)
if err != nil || !u.IsAbs() || !strings.EqualFold(u.Scheme, "https") || u.Host == "" || u.User != nil || u.Fragment != "" {
return "", errors.New("external resources require an absolute HTTPS URL without credentials or fragments")
}
u.Scheme = "https"
u.Host = strings.ToLower(u.Host)
u.RawFragment = ""
return u.String(), nil
}
func normalizeExternalResourceIntegrity(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if len(raw) == 64 {
decoded, err := hex.DecodeString(raw)
if err == nil && len(decoded) == 32 {
return "sha256-" + base64.StdEncoding.EncodeToString(decoded), nil
}
}
if !strings.HasPrefix(raw, "sha256-") {
return "", errors.New("SHA-256 integrity is required")
}
decoded, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(raw, "sha256-"))
if err != nil || len(decoded) != 32 {
return "", errors.New("invalid SHA-256 integrity")
}
return "sha256-" + base64.StdEncoding.EncodeToString(decoded), nil
}
func normalizeExternalResourceApproval(item externalResourceApproval) (externalResourceApproval, error) {
item.Kind = strings.ToLower(strings.TrimSpace(item.Kind))
if item.Kind != "image" && item.Kind != "stylesheet" && item.Kind != "script" {
return externalResourceApproval{}, errors.New("invalid external resource kind")
}
var err error
item.URL, err = normalizeExternalResourceURL(item.URL)
if err != nil {
return externalResourceApproval{}, err
}
if item.Kind == "image" {
item.Integrity = ""
return item, nil
}
item.Integrity, err = normalizeExternalResourceIntegrity(item.Integrity)
if err != nil {
return externalResourceApproval{}, err
}
return item, nil
}
func newExternalResourcePolicy(items []externalResourceApproval) externalResourcePolicy {
p := externalResourcePolicy{byKind: map[string]map[string]externalResourceApproval{}}
seen := map[string]bool{}
for _, raw := range items {
item, err := normalizeExternalResourceApproval(raw)
if err != nil {
continue
}
key := item.Kind + "\x00" + item.URL
if seen[key] || len(p.items) >= maxExternalResourceApprovals {
continue
}
seen[key] = true
if p.byKind[item.Kind] == nil {
p.byKind[item.Kind] = map[string]externalResourceApproval{}
}
p.byKind[item.Kind][item.URL] = item
p.items = append(p.items, item)
}
sort.Slice(p.items, func(i, j int) bool {
if p.items[i].Kind == p.items[j].Kind {
return p.items[i].URL < p.items[j].URL
}
return p.items[i].Kind < p.items[j].Kind
})
return p
}
func (p externalResourcePolicy) approved(kind, rawURL string) (externalResourceApproval, bool) {
normalized, err := normalizeExternalResourceURL(rawURL)
if err != nil {
return externalResourceApproval{}, false
}
item, ok := p.byKind[kind][normalized]
return item, ok
}
func (s *Server) externalResourcePolicy(domainUUID string) externalResourcePolicy {
var items []externalResourceApproval
raw := strings.TrimSpace(s.getDomainConfig(externalResourceApprovalsConfig, domainUUID))
if raw != "" {
_ = json.Unmarshal([]byte(raw), &items)
}
return newExternalResourcePolicy(items)
}
func (s *Server) saveExternalResourceApprovals(domainUUID string, items []externalResourceApproval) error {
policy := newExternalResourcePolicy(items)
if len(policy.items) != len(items) {
return errors.New("invalid or duplicate external resource approval")
}
raw, err := json.Marshal(policy.items)
if err != nil {
return err
}
return s.store.SetConfigInDomain(domainUUID, externalResourceApprovalsConfig, string(raw))
}