639 lines
18 KiB
Go
639 lines
18 KiB
Go
// Package browserreceiver hosts the local HTTP protocol used by the browser extension.
|
|
package browserreceiver
|
|
|
|
import (
|
|
"context"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/verstak/verstak-desktop/internal/core/events"
|
|
"github.com/verstak/verstak-desktop/internal/core/hostname"
|
|
)
|
|
|
|
const (
|
|
capturePath = "/api/browser-inbox/v1/captures"
|
|
activityBatchPath = "/api/browser-activity/v1/batches"
|
|
DefaultAddr = "127.0.0.1:47731"
|
|
DefaultCaptureURL = "http://" + DefaultAddr + capturePath
|
|
DefaultActivityURL = "http://" + DefaultAddr + activityBatchPath
|
|
receiverTokenHeader = "X-Verstak-Receiver-Token"
|
|
)
|
|
|
|
const (
|
|
maxCaptureBodyBytes = 12 * 1024 * 1024
|
|
maxCaptureIDBytes = 256
|
|
maxCapturedAtBytes = 64
|
|
maxCaptureSourceBytes = 128
|
|
maxPageURLBytes = 4096
|
|
maxPageTitleBytes = 512
|
|
maxPageDomainBytes = 255
|
|
maxSelectionTextBytes = 20 * 1024
|
|
maxLinkTextBytes = 512
|
|
maxBrowserNameBytes = 64
|
|
maxFileNameBytes = 255
|
|
maxFileMimeBytes = 128
|
|
maxFileTextBytes = 2 * 1024 * 1024
|
|
maxFileBytes = 8 * 1024 * 1024
|
|
maxFileDataBase64Bytes = 4 * ((maxFileBytes + 2) / 3)
|
|
maxActivityBodyBytes = 256 * 1024
|
|
maxActivityEntries = 100
|
|
maxActivityDuration = 10 * time.Minute
|
|
)
|
|
|
|
type Receiver struct {
|
|
bus *events.Bus
|
|
workspaceProvider WorkspaceProvider
|
|
optionsMu sync.RWMutex
|
|
options Options
|
|
}
|
|
|
|
type WorkspaceProvider func() string
|
|
|
|
type Options struct {
|
|
RequireToken bool
|
|
ReceiverToken string
|
|
Available func() bool
|
|
Persist func(events.Event) error
|
|
ActivityAvailable func() bool
|
|
PersistActivity func(events.Event) error
|
|
}
|
|
|
|
type Server struct {
|
|
listener net.Listener
|
|
server *http.Server
|
|
}
|
|
|
|
type CapturePayload struct {
|
|
SchemaVersion int `json:"schemaVersion"`
|
|
CaptureID string `json:"captureId"`
|
|
CapturedAt string `json:"capturedAt"`
|
|
Source string `json:"source"`
|
|
Kind string `json:"kind"`
|
|
Page CapturePage `json:"page"`
|
|
Selection *CaptureSelection `json:"selection,omitempty"`
|
|
Link *CaptureLink `json:"link,omitempty"`
|
|
File *CaptureFile `json:"file,omitempty"`
|
|
Browser *CaptureBrowser `json:"browser,omitempty"`
|
|
Context interface{} `json:"context,omitempty"`
|
|
}
|
|
|
|
type CapturePage struct {
|
|
URL string `json:"url"`
|
|
Title string `json:"title"`
|
|
Domain string `json:"domain"`
|
|
}
|
|
|
|
type CaptureSelection struct {
|
|
Text string `json:"text"`
|
|
}
|
|
|
|
type CaptureLink struct {
|
|
URL string `json:"url"`
|
|
Text string `json:"text"`
|
|
}
|
|
|
|
type CaptureFile struct {
|
|
Name string `json:"name"`
|
|
Mime string `json:"mime"`
|
|
Size int64 `json:"size"`
|
|
Text string `json:"text"`
|
|
DataBase64 string `json:"dataBase64"`
|
|
}
|
|
|
|
type CaptureBrowser struct {
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// ActivityBatchPayload contains only domain-level time accounting. It never
|
|
// accepts or emits page URLs, titles, content, or navigation history.
|
|
type ActivityBatchPayload struct {
|
|
SchemaVersion int `json:"schemaVersion"`
|
|
BatchID string `json:"batchId"`
|
|
CreatedAt string `json:"createdAt"`
|
|
Source string `json:"source"`
|
|
Entries []ActivityEntry `json:"entries"`
|
|
}
|
|
|
|
type ActivityEntry struct {
|
|
Hostname string `json:"hostname"`
|
|
StartedAt string `json:"startedAt"`
|
|
EndedAt string `json:"endedAt"`
|
|
DurationSeconds int64 `json:"durationSeconds"`
|
|
}
|
|
|
|
func New(bus *events.Bus, providers ...WorkspaceProvider) *Receiver {
|
|
return NewWithOptions(bus, Options{}, providers...)
|
|
}
|
|
|
|
func NewWithOptions(bus *events.Bus, options Options, providers ...WorkspaceProvider) *Receiver {
|
|
var provider WorkspaceProvider
|
|
if len(providers) > 0 {
|
|
provider = providers[0]
|
|
}
|
|
return &Receiver{bus: bus, workspaceProvider: provider, options: options}
|
|
}
|
|
|
|
// SetReceiverToken updates the active token without restarting the local server.
|
|
func (r *Receiver) SetReceiverToken(token string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.optionsMu.Lock()
|
|
defer r.optionsMu.Unlock()
|
|
r.options.RequireToken = true
|
|
r.options.ReceiverToken = strings.TrimSpace(token)
|
|
}
|
|
|
|
// SetPersistence configures durable capture storage and its availability gate.
|
|
func (r *Receiver) SetPersistence(available func() bool, persist func(events.Event) error) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.optionsMu.Lock()
|
|
defer r.optionsMu.Unlock()
|
|
r.options.Available = available
|
|
r.options.Persist = persist
|
|
}
|
|
|
|
// SetActivityPersistence configures durable passive browser activity storage.
|
|
// An acknowledgement is sent only after persist returns successfully.
|
|
func (r *Receiver) SetActivityPersistence(available func() bool, persist func(events.Event) error) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.optionsMu.Lock()
|
|
defer r.optionsMu.Unlock()
|
|
r.options.ActivityAvailable = available
|
|
r.options.PersistActivity = persist
|
|
}
|
|
|
|
func Start(addr string, receiver *Receiver) (*Server, error) {
|
|
if receiver == nil {
|
|
return nil, fmt.Errorf("receiver is required")
|
|
}
|
|
listener, err := net.Listen("tcp", addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
s := &Server{
|
|
listener: listener,
|
|
server: &http.Server{
|
|
Handler: receiver,
|
|
},
|
|
}
|
|
go func() {
|
|
if err := s.server.Serve(listener); err != nil && err != http.ErrServerClosed {
|
|
log.Printf("[browserreceiver] serve: %v", err)
|
|
}
|
|
}()
|
|
return s, nil
|
|
}
|
|
|
|
func (s *Server) URL() string {
|
|
if s == nil || s.listener == nil {
|
|
return ""
|
|
}
|
|
return "http://" + s.listener.Addr().String()
|
|
}
|
|
|
|
func (s *Server) Close() error {
|
|
if s == nil || s.server == nil {
|
|
return nil
|
|
}
|
|
return s.server.Shutdown(context.Background())
|
|
}
|
|
|
|
func (r *Receiver) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if req.URL.Path == activityBatchPath {
|
|
r.serveActivityBatch(w, req)
|
|
return
|
|
}
|
|
if req.URL.Path != capturePath {
|
|
http.NotFound(w, req)
|
|
return
|
|
}
|
|
if req.Method != http.MethodPost {
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
if err := r.validateReceiverToken(req); err != nil {
|
|
writeError(w, http.StatusUnauthorized, err.Error())
|
|
return
|
|
}
|
|
options := r.currentOptions()
|
|
if options.Available != nil && !options.Available() {
|
|
writeError(w, http.StatusServiceUnavailable, "browser inbox unavailable")
|
|
return
|
|
}
|
|
|
|
defer req.Body.Close()
|
|
decoder := json.NewDecoder(http.MaxBytesReader(w, req.Body, maxCaptureBodyBytes))
|
|
var payload CapturePayload
|
|
if err := decoder.Decode(&payload); err != nil {
|
|
var maxBytesErr *http.MaxBytesError
|
|
if errors.As(err, &maxBytesErr) {
|
|
writeError(w, http.StatusRequestEntityTooLarge, "capture payload exceeds limit")
|
|
return
|
|
}
|
|
writeError(w, http.StatusBadRequest, "invalid JSON")
|
|
return
|
|
}
|
|
if err := decoder.Decode(&struct{}{}); err != io.EOF {
|
|
var maxBytesErr *http.MaxBytesError
|
|
if errors.As(err, &maxBytesErr) {
|
|
writeError(w, http.StatusRequestEntityTooLarge, "capture payload exceeds limit")
|
|
return
|
|
}
|
|
writeError(w, http.StatusBadRequest, "invalid JSON")
|
|
return
|
|
}
|
|
if err := payload.Validate(); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
eventName := "browser.capture." + payload.Kind
|
|
if options.Persist == nil && (r.bus == nil || !r.bus.HasSubscribers(eventName)) {
|
|
writeError(w, http.StatusServiceUnavailable, "browser inbox unavailable")
|
|
return
|
|
}
|
|
eventPayload := payload.EventPayload()
|
|
r.annotateWorkspace(eventPayload)
|
|
event := events.Event{
|
|
Name: eventName,
|
|
Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
|
|
Payload: eventPayload,
|
|
}
|
|
if options.Persist != nil {
|
|
if err := options.Persist(event); err != nil {
|
|
log.Printf("[browserreceiver] persist %s: %v", payload.CaptureID, err)
|
|
writeError(w, http.StatusServiceUnavailable, "browser inbox unavailable")
|
|
return
|
|
}
|
|
}
|
|
if r.bus != nil {
|
|
r.bus.Publish(event)
|
|
}
|
|
|
|
w.WriteHeader(http.StatusAccepted)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{
|
|
"status": "accepted",
|
|
"captureId": payload.CaptureID,
|
|
})
|
|
}
|
|
|
|
func (r *Receiver) serveActivityBatch(w http.ResponseWriter, req *http.Request) {
|
|
if req.Method != http.MethodPost {
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"error": "method not allowed"})
|
|
return
|
|
}
|
|
if err := r.validateReceiverToken(req); err != nil {
|
|
writeError(w, http.StatusUnauthorized, err.Error())
|
|
return
|
|
}
|
|
options := r.currentOptions()
|
|
if options.ActivityAvailable == nil || !options.ActivityAvailable() || options.PersistActivity == nil {
|
|
writeError(w, http.StatusServiceUnavailable, "activity storage unavailable")
|
|
return
|
|
}
|
|
|
|
defer req.Body.Close()
|
|
decoder := json.NewDecoder(http.MaxBytesReader(w, req.Body, maxActivityBodyBytes))
|
|
var batch ActivityBatchPayload
|
|
if err := decoder.Decode(&batch); err != nil {
|
|
writeActivityDecodeError(w, err)
|
|
return
|
|
}
|
|
if err := decoder.Decode(&struct{}{}); err != io.EOF {
|
|
writeActivityDecodeError(w, err)
|
|
return
|
|
}
|
|
if err := batch.NormalizeAndValidate(); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
event := events.Event{
|
|
Name: "browser.activity.batch",
|
|
Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
|
|
Payload: batch.EventPayload(),
|
|
}
|
|
if err := options.PersistActivity(event); err != nil {
|
|
log.Printf("[browserreceiver] persist activity %s: %v", batch.BatchID, err)
|
|
writeError(w, http.StatusServiceUnavailable, "activity storage unavailable")
|
|
return
|
|
}
|
|
if r.bus != nil {
|
|
r.bus.Publish(event)
|
|
}
|
|
|
|
w.WriteHeader(http.StatusAccepted)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{
|
|
"status": "accepted",
|
|
"batchId": batch.BatchID,
|
|
})
|
|
}
|
|
|
|
func (r *Receiver) currentOptions() Options {
|
|
if r == nil {
|
|
return Options{}
|
|
}
|
|
r.optionsMu.RLock()
|
|
defer r.optionsMu.RUnlock()
|
|
return r.options
|
|
}
|
|
|
|
func (r *Receiver) validateReceiverToken(req *http.Request) error {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
r.optionsMu.RLock()
|
|
requireToken := r.options.RequireToken
|
|
expected := strings.TrimSpace(r.options.ReceiverToken)
|
|
r.optionsMu.RUnlock()
|
|
if !requireToken {
|
|
return nil
|
|
}
|
|
if expected == "" {
|
|
return fmt.Errorf("receiver token required")
|
|
}
|
|
supplied := strings.TrimSpace(req.Header.Get(receiverTokenHeader))
|
|
if supplied == "" {
|
|
return fmt.Errorf("receiver token required")
|
|
}
|
|
if subtle.ConstantTimeCompare([]byte(supplied), []byte(expected)) != 1 {
|
|
return fmt.Errorf("receiver token invalid")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Receiver) annotateWorkspace(payload map[string]interface{}) {
|
|
if r == nil || r.workspaceProvider == nil || payload == nil {
|
|
return
|
|
}
|
|
if _, ok := payload["workspaceRootPath"]; ok {
|
|
return
|
|
}
|
|
workspaceRoot := strings.TrimSpace(r.workspaceProvider())
|
|
if workspaceRoot == "" {
|
|
return
|
|
}
|
|
payload["workspaceRootPath"] = workspaceRoot
|
|
payload["workspaceName"] = workspaceRoot
|
|
}
|
|
|
|
func (p CapturePayload) Validate() error {
|
|
if p.SchemaVersion != 1 {
|
|
return fmt.Errorf("unsupported schemaVersion")
|
|
}
|
|
if strings.TrimSpace(p.CaptureID) == "" {
|
|
return fmt.Errorf("captureId is required")
|
|
}
|
|
if err := validateCaptureText(p.CaptureID, "captureId", maxCaptureIDBytes); err != nil {
|
|
return err
|
|
}
|
|
if strings.TrimSpace(p.CapturedAt) == "" {
|
|
return fmt.Errorf("capturedAt is required")
|
|
}
|
|
if err := validateCaptureText(p.CapturedAt, "capturedAt", maxCapturedAtBytes); err != nil {
|
|
return err
|
|
}
|
|
if p.Kind != "page" && p.Kind != "selection" && p.Kind != "link" && p.Kind != "file" {
|
|
return fmt.Errorf("unsupported kind")
|
|
}
|
|
if strings.TrimSpace(p.Page.URL) == "" {
|
|
return fmt.Errorf("page.url is required")
|
|
}
|
|
if err := validateCaptureText(p.Source, "source", maxCaptureSourceBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.Page.URL, "page.url", maxPageURLBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.Page.Title, "page.title", maxPageTitleBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.Page.Domain, "page.domain", maxPageDomainBytes); err != nil {
|
|
return err
|
|
}
|
|
if p.Browser != nil {
|
|
if err := validateCaptureText(p.Browser.Name, "browser.name", maxBrowserNameBytes); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if p.Kind == "selection" && (p.Selection == nil || strings.TrimSpace(p.Selection.Text) == "") {
|
|
return fmt.Errorf("selection.text is required")
|
|
}
|
|
if p.Kind == "selection" {
|
|
if err := validateCaptureText(p.Selection.Text, "selection.text", maxSelectionTextBytes); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if p.Kind == "link" {
|
|
if p.Link == nil || strings.TrimSpace(p.Link.URL) == "" {
|
|
return fmt.Errorf("link.url is required")
|
|
}
|
|
if err := validateCaptureText(p.Link.URL, "link.url", maxPageURLBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.Link.Text, "link.text", maxLinkTextBytes); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if p.Kind == "file" {
|
|
if err := p.validateFile(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// NormalizeAndValidate validates a batch before it is made durable and replaces
|
|
// each submitted hostname with the shared canonical A-label form.
|
|
func (p *ActivityBatchPayload) NormalizeAndValidate() error {
|
|
if p == nil || p.SchemaVersion != 1 {
|
|
return fmt.Errorf("unsupported schemaVersion")
|
|
}
|
|
if strings.TrimSpace(p.BatchID) == "" {
|
|
return fmt.Errorf("batchId is required")
|
|
}
|
|
if err := validateCaptureText(p.BatchID, "batchId", maxCaptureIDBytes); err != nil {
|
|
return err
|
|
}
|
|
if strings.TrimSpace(p.CreatedAt) == "" {
|
|
return fmt.Errorf("createdAt is required")
|
|
}
|
|
if _, err := time.Parse(time.RFC3339, p.CreatedAt); err != nil {
|
|
return fmt.Errorf("createdAt is invalid")
|
|
}
|
|
if err := validateCaptureText(p.CreatedAt, "createdAt", maxCapturedAtBytes); err != nil {
|
|
return err
|
|
}
|
|
if strings.TrimSpace(p.Source) == "" {
|
|
return fmt.Errorf("source is required")
|
|
}
|
|
if err := validateCaptureText(p.Source, "source", maxCaptureSourceBytes); err != nil {
|
|
return err
|
|
}
|
|
if len(p.Entries) == 0 || len(p.Entries) > maxActivityEntries {
|
|
return fmt.Errorf("entries must contain between 1 and %d items", maxActivityEntries)
|
|
}
|
|
for index := range p.Entries {
|
|
entry := &p.Entries[index]
|
|
canonical := hostname.NormalizeHostnameV1(entry.Hostname)
|
|
if canonical == "" {
|
|
return fmt.Errorf("entries[%d].hostname is invalid", index)
|
|
}
|
|
startedAt, err := time.Parse(time.RFC3339, entry.StartedAt)
|
|
if err != nil {
|
|
return fmt.Errorf("entries[%d].startedAt is invalid", index)
|
|
}
|
|
endedAt, err := time.Parse(time.RFC3339, entry.EndedAt)
|
|
if err != nil {
|
|
return fmt.Errorf("entries[%d].endedAt is invalid", index)
|
|
}
|
|
interval := endedAt.Sub(startedAt)
|
|
if interval <= 0 || interval > maxActivityDuration {
|
|
return fmt.Errorf("entries[%d] interval must be between 1 second and %s", index, maxActivityDuration)
|
|
}
|
|
if entry.DurationSeconds <= 0 || entry.DurationSeconds > int64(maxActivityDuration/time.Second) || time.Duration(entry.DurationSeconds)*time.Second > interval {
|
|
return fmt.Errorf("entries[%d].durationSeconds is invalid", index)
|
|
}
|
|
entry.Hostname = canonical
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p ActivityBatchPayload) EventPayload() map[string]interface{} {
|
|
entries := make([]map[string]interface{}, 0, len(p.Entries))
|
|
for _, entry := range p.Entries {
|
|
entries = append(entries, map[string]interface{}{
|
|
"hostname": entry.Hostname,
|
|
"startedAt": entry.StartedAt,
|
|
"endedAt": entry.EndedAt,
|
|
"durationSeconds": entry.DurationSeconds,
|
|
})
|
|
}
|
|
return map[string]interface{}{
|
|
"batchId": strings.TrimSpace(p.BatchID),
|
|
"createdAt": strings.TrimSpace(p.CreatedAt),
|
|
"source": strings.TrimSpace(p.Source),
|
|
"entries": entries,
|
|
}
|
|
}
|
|
|
|
func (p CapturePayload) validateFile() error {
|
|
if p.File == nil || strings.TrimSpace(p.File.Name) == "" {
|
|
return fmt.Errorf("file.name is required")
|
|
}
|
|
if p.File.Text == "" && strings.TrimSpace(p.File.DataBase64) == "" {
|
|
return fmt.Errorf("file.text or file.dataBase64 is required")
|
|
}
|
|
if p.File.Size < 0 || p.File.Size > maxFileBytes {
|
|
return fmt.Errorf("file.size exceeds limit")
|
|
}
|
|
if err := validateCaptureText(p.File.Name, "file.name", maxFileNameBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.File.Mime, "file.mime", maxFileMimeBytes); err != nil {
|
|
return err
|
|
}
|
|
if err := validateCaptureText(p.File.Text, "file.text", maxFileTextBytes); err != nil {
|
|
return err
|
|
}
|
|
dataBase64 := strings.TrimSpace(p.File.DataBase64)
|
|
if dataBase64 == "" {
|
|
return nil
|
|
}
|
|
if len(dataBase64) > maxFileDataBase64Bytes {
|
|
return fmt.Errorf("file.dataBase64 exceeds limit")
|
|
}
|
|
data, err := base64.StdEncoding.DecodeString(dataBase64)
|
|
if err != nil {
|
|
return fmt.Errorf("file.dataBase64 is invalid")
|
|
}
|
|
if len(data) > maxFileBytes {
|
|
return fmt.Errorf("file.dataBase64 exceeds limit")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateCaptureText(value, field string, maxBytes int) error {
|
|
if len(value) > maxBytes {
|
|
return fmt.Errorf("%s exceeds limit", field)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p CapturePayload) EventPayload() map[string]interface{} {
|
|
pageURL := strings.TrimSpace(p.Page.URL)
|
|
result := map[string]interface{}{
|
|
"captureId": strings.TrimSpace(p.CaptureID),
|
|
"capturedAt": strings.TrimSpace(p.CapturedAt),
|
|
"source": strings.TrimSpace(p.Source),
|
|
"kind": p.Kind,
|
|
"url": pageURL,
|
|
"title": strings.TrimSpace(p.Page.Title),
|
|
"domain": captureDomain(pageURL, p.Page.Domain),
|
|
}
|
|
if p.Browser != nil {
|
|
result["browserName"] = strings.TrimSpace(p.Browser.Name)
|
|
}
|
|
if p.Context != nil {
|
|
result["context"] = p.Context
|
|
}
|
|
|
|
switch p.Kind {
|
|
case "selection":
|
|
result["text"] = strings.TrimSpace(p.Selection.Text)
|
|
case "link":
|
|
linkURL := strings.TrimSpace(p.Link.URL)
|
|
result["url"] = linkURL
|
|
result["title"] = strings.TrimSpace(p.Link.Text)
|
|
result["domain"] = captureDomain(linkURL, "")
|
|
case "file":
|
|
result["fileName"] = strings.TrimSpace(p.File.Name)
|
|
result["fileMime"] = strings.TrimSpace(p.File.Mime)
|
|
result["fileSize"] = p.File.Size
|
|
result["fileText"] = p.File.Text
|
|
result["fileDataBase64"] = strings.TrimSpace(p.File.DataBase64)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func captureDomain(rawURL, fallback string) string {
|
|
if normalized := hostname.NormalizeURLHostnameV1(rawURL); normalized != "" {
|
|
return normalized
|
|
}
|
|
return hostname.NormalizeHostnameV1(fallback)
|
|
}
|
|
|
|
func writeActivityDecodeError(w http.ResponseWriter, err error) {
|
|
var maxBytesErr *http.MaxBytesError
|
|
if errors.As(err, &maxBytesErr) {
|
|
writeError(w, http.StatusRequestEntityTooLarge, "activity payload exceeds limit")
|
|
return
|
|
}
|
|
writeError(w, http.StatusBadRequest, "invalid JSON")
|
|
}
|
|
|
|
func writeError(w http.ResponseWriter, status int, message string) {
|
|
w.WriteHeader(status)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"error": message})
|
|
}
|