Files
pages/internal/server/adapter_plugins.go
T
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

481 lines
15 KiB
Go

package server
import (
"database/sql"
"encoding/json"
"errors"
"fmt"
"mime"
"net/http"
"net/url"
"path/filepath"
"regexp"
"sort"
"strings"
"pageswiki/internal/kunstzeal"
)
const adapterPluginsConfigKey = "projection_adapter_plugins"
type adapterPlugin struct {
ID string `json:"id"`
Name string `json:"name"`
Mode string `json:"mode"` // hosted viewer or hosted editor
URLTemplate string `json:"url_template"`
MediaTypes []string `json:"media_types,omitempty"`
Extensions []string `json:"extensions,omitempty"`
Enabled bool `json:"enabled"`
NewTab bool `json:"new_tab,omitempty"`
HTMLMarkdown bool `json:"html_markdown,omitempty"`
DefaultEditor bool `json:"default_editor,omitempty"`
Unsupported bool `json:"unsupported,omitempty"`
}
type adapterAction struct {
ID string `json:"id"`
Name string `json:"name"`
Mode string `json:"mode"`
Builtin bool `json:"builtin"`
OpenURL string `json:"open_url"`
NewTab bool `json:"new_tab,omitempty"`
Default bool `json:"default,omitempty"`
}
type builtinAdapterInfo struct {
ID string `json:"id"`
Kind string `json:"kind"`
Delivery string `json:"delivery"`
Selectable bool `json:"selectable"`
}
var adapterIDPattern = regexp.MustCompile(`^[a-z][a-z0-9._-]{1,63}$`)
func builtinAdapterManifest() []builtinAdapterInfo {
projectionAdapters := kunstzeal.Catalog()
out := make([]builtinAdapterInfo, 0, len(projectionAdapters))
for _, adapter := range projectionAdapters {
out = append(out, builtinAdapterInfo{
ID: adapter.ID, Kind: adapter.Kind,
Delivery: string(adapter.Delivery), Selectable: true,
})
}
return out
}
func (s *Server) adapterPlugins(domainUUID string) ([]adapterPlugin, error) {
raw, err := s.store.GetConfigInDomain(domainUUID, adapterPluginsConfigKey)
if err != nil || strings.TrimSpace(raw) == "" {
return []adapterPlugin{}, err
}
var plugins []adapterPlugin
if err := json.Unmarshal([]byte(raw), &plugins); err != nil {
return nil, err
}
// Native execution is reserved for a future local-helper protocol. Keep
// legacy records visible, but never advertise or launch them.
for index := range plugins {
validated := plugins[index]
if err := validateAdapterPlugin(&validated); err != nil {
plugins[index].Enabled = false
plugins[index].Unsupported = true
}
}
return plugins, nil
}
func (s *Server) saveAdapterPlugins(domainUUID string, plugins []adapterPlugin) error {
sort.Slice(plugins, func(i, j int) bool { return plugins[i].ID < plugins[j].ID })
data, err := json.Marshal(plugins)
if err != nil {
return err
}
return s.store.SetConfigInDomain(domainUUID, adapterPluginsConfigKey, string(data))
}
func validateAdapterPlugin(plugin *adapterPlugin) error {
plugin.ID = strings.ToLower(strings.TrimSpace(plugin.ID))
plugin.Name = strings.TrimSpace(plugin.Name)
plugin.Mode = strings.ToLower(strings.TrimSpace(plugin.Mode))
plugin.URLTemplate = strings.TrimSpace(plugin.URLTemplate)
if !adapterIDPattern.MatchString(plugin.ID) || plugin.Name == "" {
return errors.New("invalid adapter id or name")
}
switch plugin.Mode {
case "viewer", "editor":
default:
return errors.New("mode must be viewer or editor; native integration is not implemented")
}
if !strings.Contains(plugin.URLTemplate, "{url}") &&
!strings.Contains(plugin.URLTemplate, "{path}") &&
!strings.Contains(plugin.URLTemplate, "{ticket}") {
return errors.New("URL template must contain {url}, {path}, or {ticket}")
}
if plugin.Mode == "editor" && !strings.Contains(plugin.URLTemplate, "{ticket}") {
return errors.New("hosted editor URL template must contain {ticket}")
}
sample := strings.NewReplacer(
"{url}", "https://example.invalid/v/raw/path:/sample.txt",
"{path}", "/sample.txt",
"{filename}", "sample.txt",
"{ticket}", "pwa_t_sample",
"{origin}", "https://pages.example.invalid",
).Replace(plugin.URLTemplate)
parsed, err := url.Parse(sample)
if err != nil || (parsed.Scheme != "http" && parsed.Scheme != "https") {
return errors.New("hosted adapter URL must use http or https")
}
for index, extension := range plugin.Extensions {
extension = strings.ToLower(strings.TrimSpace(extension))
if extension != "" && !strings.HasPrefix(extension, ".") {
extension = "." + extension
}
plugin.Extensions[index] = extension
}
for index, mediaType := range plugin.MediaTypes {
plugin.MediaTypes[index] = strings.ToLower(strings.TrimSpace(mediaType))
}
return nil
}
func pluginMatches(plugin adapterPlugin, mediaType, filename string) bool {
if !plugin.Enabled || plugin.Unsupported || plugin.Mode == "native" {
return false
}
if len(plugin.MediaTypes) == 0 && len(plugin.Extensions) == 0 {
return true
}
for _, candidate := range plugin.MediaTypes {
if candidate == mediaType ||
(strings.HasSuffix(candidate, "/*") &&
strings.HasPrefix(mediaType, strings.TrimSuffix(candidate, "*"))) {
return true
}
}
extension := strings.ToLower(filepath.Ext(filename))
for _, candidate := range plugin.Extensions {
if extension == candidate {
return true
}
}
return false
}
func (s *Server) adapterActionsForPath(r *http.Request, semanticPath string) ([]adapterAction, error) {
domainUUID := s.domainUUIDForRequest(r)
objectUUID, err := s.store.ResolvePathInDomain(domainUUID, semanticPath)
if err != nil {
return nil, err
}
revision, err := s.latestRevisionForRequest(r, objectUUID)
if err != nil {
return nil, err
}
mediaType, _, _ := mime.ParseMediaType(revision.ContentType)
filename := revision.Filename
if filename == "" {
filename = filepath.Base(semanticPath)
}
selected := selectProjectionAdapter(contentDescriptor{
MediaType: strings.ToLower(mediaType), Filename: filename,
SizeBytes: int64(len(revision.Body)),
})
actions := []adapterAction{
{ID: selected.ID, Name: selected.ID, Mode: "viewer", Builtin: true, OpenURL: semanticPath},
{ID: "download", Name: "download", Mode: "viewer", Builtin: true,
OpenURL: rawProjectionURL("rev:" + revision.UUID)},
}
if selected.NeedsText || selected.ID == "html" || selected.ID == "excalidraw" {
actions = append(actions, adapterAction{
ID: "editor", Name: "Pages Wiki Editor", Mode: "editor",
Builtin: true, OpenURL: "/e" + semanticPath,
})
}
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
return nil, err
}
sort.SliceStable(plugins, func(i, j int) bool {
return plugins[i].DefaultEditor && !plugins[j].DefaultEditor
})
for _, plugin := range plugins {
if pluginMatches(plugin, strings.ToLower(mediaType), filename) {
actions = append(actions, adapterAction{
ID: plugin.ID, Name: plugin.Name, Mode: plugin.Mode,
NewTab: plugin.NewTab,
Default: plugin.DefaultEditor,
OpenURL: "/v/open-with?adapter=" + url.QueryEscape(plugin.ID) +
"&path=" + url.QueryEscape(semanticPath),
})
}
}
return actions, nil
}
func (s *Server) handleAdapterAPI(w http.ResponseWriter, r *http.Request) {
action := strings.Trim(strings.TrimPrefix(r.URL.Path, "/_/api/v1/adapter"), "/")
domainUUID := s.domainUUIDForRequest(r)
switch action {
case "":
if r.Method == http.MethodGet {
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
writeEventJSON(w, 500, map[string]string{"error": err.Error()})
return
}
response := map[string]any{
"builtin": builtinAdapterManifest(), "plugins": plugins,
}
if path := strings.TrimSpace(r.URL.Query().Get("path")); path != "" {
actions, err := s.adapterActionsForPath(r, path)
if err != nil {
status := 500
if errors.Is(err, sql.ErrNoRows) {
status = 404
}
writeEventJSON(w, status, map[string]string{"error": err.Error()})
return
}
response["actions"] = actions
}
writeEventJSON(w, 200, response)
return
}
if r.Method == http.MethodPost || r.Method == http.MethodPut {
var plugin adapterPlugin
if !decodeEventJSON(w, r, &plugin) {
return
}
if err := validateAdapterPlugin(&plugin); err != nil {
writeEventJSON(w, 400, map[string]string{"error": err.Error()})
return
}
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
writeEventJSON(w, 500, map[string]string{"error": err.Error()})
return
}
if plugin.DefaultEditor {
if plugin.Mode != "editor" {
writeEventJSON(w, 400, map[string]string{"error": "only an editor can be the default editor"})
return
}
for index := range plugins {
plugins[index].DefaultEditor = false
}
}
replaced := false
for index := range plugins {
if plugins[index].ID == plugin.ID {
plugins[index] = plugin
replaced = true
}
}
if !replaced {
plugins = append(plugins, plugin)
}
if err := s.saveAdapterPlugins(domainUUID, plugins); err != nil {
writeEventJSON(w, 500, map[string]string{"error": err.Error()})
return
}
writeEventJSON(w, 200, plugin)
return
}
case "delete":
if r.Method == http.MethodPost || r.Method == http.MethodDelete {
var input struct {
ID string `json:"id"`
}
if !decodeEventJSON(w, r, &input) {
return
}
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
writeEventJSON(w, 500, map[string]string{"error": err.Error()})
return
}
filtered := plugins[:0]
for _, plugin := range plugins {
if plugin.ID != input.ID {
filtered = append(filtered, plugin)
}
}
if err := s.saveAdapterPlugins(domainUUID, filtered); err != nil {
writeEventJSON(w, 500, map[string]string{"error": err.Error()})
return
}
writeEventJSON(w, 200, map[string]bool{"deleted": true})
return
}
}
writeEventJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "unsupported adapter operation"})
}
func (s *Server) handleOpenWith(w http.ResponseWriter, r *http.Request) {
semanticPath := strings.TrimSpace(r.URL.Query().Get("path"))
adapterID := strings.TrimSpace(r.URL.Query().Get("adapter"))
if semanticPath == "" || adapterID == "" {
http.Error(w, "path and adapter are required", http.StatusBadRequest)
return
}
if s.authorizePathRequest(r, "read", semanticPath) != nil {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
plugins, err := s.adapterPlugins(s.domainUUIDForRequest(r))
if err != nil {
http.Error(w, err.Error(), 500)
return
}
var selected *adapterPlugin
for index := range plugins {
if plugins[index].ID == adapterID && plugins[index].Enabled {
selected = &plugins[index]
break
}
}
if selected == nil {
http.NotFound(w, r)
return
}
actions, err := s.adapterActionsForPath(r, semanticPath)
if err != nil {
http.Error(w, err.Error(), 404)
return
}
allowed := false
for _, action := range actions {
if action.ID == selected.ID {
allowed = true
}
}
if !allowed {
http.Error(w, "adapter does not support this document", http.StatusBadRequest)
return
}
objectUUID, err := s.store.ResolvePathInDomain(s.domainUUIDForRequest(r), semanticPath)
if err != nil {
http.NotFound(w, r)
return
}
revision, err := s.latestRevisionForRequest(r, objectUUID)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
scheme := "https"
if r.TLS == nil {
scheme = "http"
}
if forwarded := strings.ToLower(strings.TrimSpace(
strings.Split(r.Header.Get("X-Forwarded-Proto"), ",")[0],
)); forwarded == "http" || forwarded == "https" {
scheme = forwarded
}
rawURL := fmt.Sprintf("%s://%s%s", scheme, r.Host, rawProjectionURL("rev:"+revision.UUID))
filename := revision.Filename
if filename == "" {
filename = filepath.Base(semanticPath)
}
ticket := ""
if selected.Mode == "editor" {
if s.authorizePathRequest(r, "write", semanticPath) != nil {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
principalUUID := ""
if principal, principalErr := s.store.PrincipalForSession(s.domainUUIDForRequest(r), s.authTokenFromRequest(r)); principalErr == nil {
principalUUID = principal.UUID
}
ticket, err = s.store.IssueAdapterTicketForPrincipal(
principalUUID, s.domainUUIDForRequest(r), selected.ID, objectUUID, revision.UUID, semanticPath,
)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
}
origin := fmt.Sprintf("%s://%s", scheme, r.Host)
target := strings.NewReplacer(
"{url}", url.QueryEscape(rawURL),
"{path}", url.QueryEscape(semanticPath),
"{filename}", url.QueryEscape(filename),
"{ticket}", url.QueryEscape(ticket),
"{origin}", url.QueryEscape(origin),
).Replace(selected.URLTemplate)
http.Redirect(w, r, target, http.StatusFound)
}
func (s *Server) handleAdapterPluginConfig(w http.ResponseWriter, r *http.Request) {
domainUUID := s.domainUUIDForRequest(r)
id := strings.TrimSpace(r.URL.Query().Get("id"))
if r.Method == http.MethodPost {
if err := r.ParseForm(); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
id = strings.TrimSpace(r.FormValue("id"))
}
plugins, err := s.adapterPlugins(domainUUID)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
index := -1
for candidate := range plugins {
if plugins[candidate].ID == id {
index = candidate
break
}
}
if index < 0 {
http.NotFound(w, r)
return
}
if r.Method == http.MethodPost {
if r.FormValue("connection_fields") == "1" {
plugins[index].Name = strings.TrimSpace(r.FormValue("name"))
plugins[index].Mode = strings.TrimSpace(r.FormValue("mode"))
plugins[index].URLTemplate = strings.TrimSpace(r.FormValue("url_template"))
plugins[index].Enabled = r.FormValue("enabled") != ""
plugins[index].MediaTypes = splitAdapterList(r.FormValue("media_types"))
plugins[index].Extensions = splitAdapterList(r.FormValue("extensions"))
if err := validateAdapterPlugin(&plugins[index]); err != nil {
http.Error(w, err.Error(), 400)
return
}
}
plugins[index].NewTab = boolFormValue(r.FormValue("new_tab")) == "true"
plugins[index].HTMLMarkdown = boolFormValue(r.FormValue("html_markdown")) == "true"
makeDefault := boolFormValue(r.FormValue("default_editor")) == "true"
if makeDefault && plugins[index].Mode != "editor" {
http.Error(w, "only an editor can be the default editor", http.StatusBadRequest)
return
}
if makeDefault {
for candidate := range plugins {
plugins[candidate].DefaultEditor = candidate == index
}
} else {
plugins[index].DefaultEditor = false
}
if err := s.saveAdapterPlugins(domainUUID, plugins); err != nil {
http.Error(w, err.Error(), 500)
return
}
http.Redirect(w, r, "/-/sys/config?panel="+url.QueryEscape("adapter-"+id)+"&saved=1", http.StatusFound)
return
}
http.Redirect(w, r, "/-/sys/config?panel="+url.QueryEscape("adapter-"+id), http.StatusFound)
}
func splitAdapterList(value string) []string {
var values []string
for _, item := range strings.Split(value, ",") {
if item = strings.TrimSpace(item); item != "" {
values = append(values, item)
}
}
return values
}