Files
pages/internal/server/adapter_plugins.go
T
Anya Tokugawa 02fb77f72b
Build and publish container images / images (push) Successful in 9m2s
Release container images / release (push) Successful in 21s
feat(slides): add sandboxed Reveal.js viewer and editor preview
2026-11-08 22:10:52 +09:00

484 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 (mediaType == "text/html" || mediaType == "text/markdown" || mediaType == "text/x-markdown") && s.systemExtensionEnabled(domainUUID, "viewer.slides") {
actions = append(actions, adapterAction{ID: "reveal", Name: "Reveal.js", Mode: "viewer", Builtin: true, OpenURL: "/v/slides" + semanticPath})
}
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
}