Files
pages/internal/server/structured_view.go
T
Anya Tokugawa c1175d389f 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.
2026-09-27 14:44:43 +09:00

319 lines
9.0 KiB
Go

package server
import (
"archive/tar"
"archive/zip"
"bufio"
"bytes"
"compress/gzip"
"debug/pe"
"encoding/base64"
"encoding/csv"
"encoding/json"
"fmt"
"io"
"math"
"mime"
"mime/multipart"
"mime/quotedprintable"
"net/mail"
"net/url"
"path/filepath"
"strconv"
"strings"
"unicode/utf8"
)
type archiveEntryView struct {
Name string `json:"name"`
Size uint64 `json:"size"`
IsDir bool `json:"is_dir"`
IsImage bool `json:"is_image"`
URL string `json:"url,omitempty"`
}
type metadataView struct {
Name string
Value string
}
func structuredContentView(view *contentView, body []byte, semanticPath string) {
switch view.AdapterID {
case "csv":
parseCSVView(view, body)
case "excalidraw":
parseExcalidrawView(view, body)
case "archive":
if !strings.EqualFold(filepath.Ext(view.Filename), ".zip") {
view.MetadataStatus = "pending"
view.MetadataURL = metadataProjectionURL("archive", view.RevisionUUID, semanticPath)
break
}
reader, err := zip.NewReader(bytes.NewReader(body), int64(len(body)))
if err != nil {
view.ParseError = err.Error()
return
}
for _, file := range reader.File {
if len(view.ArchiveEntries) >= maxArchiveMetadataEntries {
view.ArchiveTruncated = true
break
}
ext := strings.ToLower(filepath.Ext(file.Name))
query := url.Values{"path": {semanticPath}, "entry": {file.Name}, "rev": {view.RevisionUUID}}
view.ArchiveEntries = append(view.ArchiveEntries, archiveEntryView{
Name: file.Name, Size: file.UncompressedSize64,
IsDir: file.FileInfo().IsDir(),
IsImage: ext == ".jpg" || ext == ".jpeg" || ext == ".png" ||
ext == ".gif" || ext == ".webp" || ext == ".avif",
URL: "/v/archive?" + query.Encode(),
})
}
case "eml":
message, err := mail.ReadMessage(bytes.NewReader(body))
if err != nil {
view.ParseError = err.Error()
return
}
for _, name := range []string{"From", "To", "Cc", "Date", "Subject", "Message-ID"} {
if value := message.Header.Get(name); value != "" {
if decoded, err := new(mime.WordDecoder).DecodeHeader(value); err == nil {
value = decoded
}
view.Metadata = append(view.Metadata, metadataView{name, value})
}
}
view.Text = emailText(message.Header, message.Body)
case "pe":
file, err := pe.NewFile(bytes.NewReader(body))
if err != nil {
view.ParseError = err.Error()
return
}
defer file.Close()
view.Metadata = append(view.Metadata,
metadataView{"Machine", fmt.Sprintf("0x%04x", file.FileHeader.Machine)},
metadataView{"Sections", strconv.Itoa(int(file.FileHeader.NumberOfSections))},
metadataView{"Timestamp", strconv.FormatUint(uint64(file.FileHeader.TimeDateStamp), 10)},
metadataView{"Characteristics", fmt.Sprintf("0x%04x", file.FileHeader.Characteristics)},
)
for _, section := range file.Sections {
view.Metadata = append(view.Metadata, metadataView{
"Section " + section.Name,
fmt.Sprintf("virtual=%d raw=%d", section.VirtualSize, section.Size),
})
}
case "debian-package":
parseDebianPackage(view, body)
}
}
const (
maxExcalidrawBytes = 2 << 20
maxExcalidrawElements = 5000
maxExcalidrawPoints = 100000
maxExcalidrawText = 1 << 20
)
func parseExcalidrawView(view *contentView, body []byte) {
if len(body) > maxExcalidrawBytes {
view.ParseError = "Excalidraw scene exceeds the 2 MiB interactive limit"
return
}
var scene struct {
Type string `json:"type"`
Elements []json.RawMessage `json:"elements"`
}
if err := json.Unmarshal(body, &scene); err != nil {
view.ParseError = err.Error()
return
}
if scene.Type != "excalidraw" {
view.ParseError = "invalid Excalidraw scene type"
return
}
if len(scene.Elements) > maxExcalidrawElements {
view.ParseError = "Excalidraw scene exceeds the 5000 element limit"
return
}
pointsTotal := 0
textTotal := 0
for _, raw := range scene.Elements {
var element struct {
Type string `json:"type"`
X float64 `json:"x"`
Y float64 `json:"y"`
W float64 `json:"width"`
H float64 `json:"height"`
Points [][]float64 `json:"points"`
Text string `json:"text"`
}
if err := json.Unmarshal(raw, &element); err != nil || element.Type == "" ||
math.IsNaN(element.X) || math.IsInf(element.X, 0) ||
math.IsNaN(element.Y) || math.IsInf(element.Y, 0) ||
math.IsNaN(element.W) || math.IsInf(element.W, 0) ||
math.IsNaN(element.H) || math.IsInf(element.H, 0) {
view.ParseError = "invalid Excalidraw element"
return
}
pointsTotal += len(element.Points)
textTotal += len(element.Text)
if pointsTotal > maxExcalidrawPoints || textTotal > maxExcalidrawText {
view.ParseError = "Excalidraw scene complexity exceeds the interactive limit"
return
}
for _, point := range element.Points {
if len(point) < 2 || math.IsNaN(point[0]) || math.IsInf(point[0], 0) ||
math.IsNaN(point[1]) || math.IsInf(point[1], 0) {
view.ParseError = "invalid Excalidraw point"
return
}
}
}
view.ExcalidrawValid = true
view.ExcalidrawElements = len(scene.Elements)
}
const (
maxCSVRows = 500
maxCSVColumns = 100
maxCSVCellBytes = 16 << 10
)
func parseCSVView(view *contentView, body []byte) {
reader := csv.NewReader(bytes.NewReader(body))
reader.FieldsPerRecord = -1
for len(view.CSVRows) < maxCSVRows {
record, err := reader.Read()
if err == io.EOF {
return
}
if err != nil {
// A bounded initial window can end halfway through its final record.
view.CSVTruncated = true
if len(view.CSVRows) == 0 {
view.ParseError = err.Error()
}
return
}
if len(record) > maxCSVColumns {
record = record[:maxCSVColumns]
view.CSVTruncated = true
}
for index, cell := range record {
if len(cell) > maxCSVCellBytes {
prefix := []byte(cell[:maxCSVCellBytes])
for len(prefix) > 0 && !utf8.Valid(prefix) {
prefix = prefix[:len(prefix)-1]
}
record[index] = string(prefix) + "…"
view.CSVTruncated = true
}
}
view.CSVRows = append(view.CSVRows, record)
}
if _, err := reader.Read(); err != io.EOF {
view.CSVTruncated = true
}
}
func emailText(header mail.Header, body io.Reader) string {
mediaType, params, _ := mime.ParseMediaType(header.Get("Content-Type"))
if strings.HasPrefix(mediaType, "multipart/") && params["boundary"] != "" {
reader := multipart.NewReader(body, params["boundary"])
for {
part, err := reader.NextPart()
if err != nil {
break
}
partType, _, _ := mime.ParseMediaType(part.Header.Get("Content-Type"))
if partType == "text/plain" || partType == "text/html" || partType == "" {
return readMailBody(part.Header.Get("Content-Transfer-Encoding"), part)
}
}
return ""
}
return readMailBody(header.Get("Content-Transfer-Encoding"), body)
}
func readMailBody(encoding string, body io.Reader) string {
switch strings.ToLower(strings.TrimSpace(encoding)) {
case "quoted-printable":
body = quotedprintable.NewReader(body)
case "base64":
body = base64.NewDecoder(base64.StdEncoding, body)
}
payload, _ := io.ReadAll(io.LimitReader(body, 4<<20))
return string(payload)
}
func parseDebianPackage(view *contentView, body []byte) {
reader := bufio.NewReader(bytes.NewReader(body))
magic := make([]byte, 8)
if _, err := io.ReadFull(reader, magic); err != nil || string(magic) != "!<arch>\n" {
view.ParseError = "invalid Debian ar archive"
return
}
for {
header := make([]byte, 60)
if _, err := io.ReadFull(reader, header); err != nil {
break
}
name := strings.TrimSpace(strings.TrimSuffix(string(header[:16]), "/"))
size, err := strconv.ParseInt(strings.TrimSpace(string(header[48:58])), 10, 64)
if err != nil || size < 0 {
view.ParseError = "invalid ar member"
return
}
payload := make([]byte, size)
if _, err := io.ReadFull(reader, payload); err != nil {
view.ParseError = err.Error()
return
}
if size%2 != 0 {
_, _ = reader.ReadByte()
}
view.Metadata = append(view.Metadata, metadataView{"Member", fmt.Sprintf("%s (%d bytes)", name, size)})
if name == "debian-binary" {
view.Metadata = append(view.Metadata, metadataView{"Debian format", strings.TrimSpace(string(payload))})
}
if name == "control.tar.gz" {
parseDebControl(view, payload)
}
}
}
func parseDebControl(view *contentView, payload []byte) {
gz, err := gzip.NewReader(bytes.NewReader(payload))
if err != nil {
return
}
defer gz.Close()
tr := tar.NewReader(gz)
for {
header, err := tr.Next()
if err != nil {
return
}
if strings.TrimPrefix(header.Name, "./") != "control" {
continue
}
control, _ := io.ReadAll(io.LimitReader(tr, 1<<20))
view.Text = string(control)
message, err := mail.ReadMessage(bytes.NewReader(append(control, '\n', '\n')))
if err == nil {
for name, values := range message.Header {
view.Metadata = append(view.Metadata, metadataView{name, strings.Join(values, ", ")})
}
}
return
}
}
func archiveEntryContentType(name string, data []byte) string {
if byExtension := mime.TypeByExtension(strings.ToLower(filepath.Ext(name))); byExtension != "" {
return byExtension
}
return "application/octet-stream"
}