package store import ( "context" "database/sql" "encoding/json" "html" "path" "regexp" "strings" "time" "unicode" "unicode/utf8" "github.com/google/uuid" ) func ValidTaskWikiPrefix(p string) bool { if p == "" { return true } if len(p) > 500 || !utf8.ValidString(p) || !strings.HasPrefix(p, "/") || path.Clean(p) != p || strings.ContainsAny(p, "\\?#%:") || strings.IndexFunc(p, unicode.IsControl) >= 0 { return false } for _, part := range strings.Split(p, "/") { if part == "_" || part == ".." || part == "." { return false } } first := strings.Split(strings.TrimPrefix(p, "/"), "/")[0] switch first { case "-", "v", "e", "o", "r", "static", "raw": return false } return true } // Expand only the documented placeholders. Subject is one safe path component, // never a source of separators or URI operators. Callers choose the timezone. func ExpandWikiPrefix(template, subject string, now time.Time) (string, error) { if len(template) > 500 || !utf8.ValidString(template) || !utf8.ValidString(subject) { return "", ErrTaskInvalid } name := strings.Map(func(r rune) rune { if unicode.IsControl(r) || unicode.IsSpace(r) || strings.ContainsRune(`/\?#%:{}<>"|`, r) { return '-' } return r }, subject) name = strings.Trim(name, " .-_") for len(name) > 180 { _, n := utf8.DecodeLastRuneInString(name) name = name[:len(name)-n] } name = strings.Trim(name, " .-_") if name == "" { name = "untitled" } result := strings.NewReplacer("{YYYY}", now.Format("2006"), "{MM}", now.Format("01"), "{DD}", now.Format("02"), "{Subject}", name).Replace(template) if strings.ContainsAny(result, "{}") || !ValidTaskWikiPrefix(result) { return "", ErrTaskInvalid } return result, nil } // The CLI derives the request UUID from origin, user and Message-ID (or a raw // mail hash). Keep subjects in the title, never in the URL's identity segment. func TaskCaptureWikiPath(prefix, title, request string) string { return strings.TrimRight(prefix, "/") + "/mail-" + request } var mailListSuffix = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,99}/(0|[1-9][0-9]{0,19})$`) var mailMonthSuffix = regexp.MustCompile(`^[0-9]{4}/(0[1-9]|1[0-2])/([0-9a-f]{64}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$`) // Only the two mail layouts are accepted; no arbitrary relative path traversal. func ValidTaskMailSuffix(s string) bool { return mailListSuffix.MatchString(s) || (mailMonthSuffix.MatchString(s) && !strings.HasPrefix(s, "0000/")) } func validCapturedTaskWiki(target, body string) bool { return target != "" && ValidTaskWikiPrefix(path.Dir(target)) && path.Clean(target) == target && len(body) <= 256<<10 && utf8.ValidString(body) && strings.IndexByte(body, 0) < 0 } func (s *Store) createCapturedTaskWiki(ctx context.Context, tx *sql.Tx, domain, actor string, item *TaskRecord, target, body string) error { if !validCapturedTaskWiki(target, body) || item.PageUUID != "" { return ErrTaskInvalid } var exists bool if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND path=`+s.sqlParam(2)+`)`, domain, target).Scan(&exists); err != nil { return err } if exists { return ErrTaskNoteExists } item.PageUUID = uuid.NewString() // Mail is data, never HTML or executable wiki macros (including {{...}}). escape := func(v string) string { return strings.NewReplacer("{", "{", "}", "}").Replace(html.EscapeString(v)) } content := "
" + escape(body) + "\n" return s.createTaskWikiPageTx(ctx, tx, domain, actor, item.PageUUID, target, content, "Capture attributed text as Wiki") } // The caller holds the task/namespace writer lock and has checked target ACLs. // Page metadata, task linkage, receipt and both outbox events commit together. // Canonical payloads remain immutable; a rollback may leave an unreferenced // blob, never a partially visible Page. Native serving/GC remain gated pending // the common payload-pin protocol, as for the task body's existing writer. func (s *Store) createTaskWikiPageTx(ctx context.Context, tx *sql.Tx, domain, actor, object, target, content, message string, embeddedHashes ...string) error { now := time.Now() if _, err := tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES(`+s.sqlParam(1)+`,'page',`+s.sqlParam(2)+`)`, object, now.Unix()); err != nil { return err } if s.sqlBackend == storePostgreSQL { if s.DocumentRoot == "" { return ErrDocumentStoreRequired } if _, err := tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES($1,$2,$3)`, object, domain, now.Unix()); err != nil { return err } } if _, err := tx.ExecContext(ctx, `INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES(`+s.sqlValues(4)+`,1)`, domain, target, object, now.Unix()); err != nil { return err } rev := &Revision{UUID: uuid.NewString(), ObjectUUID: object, DocumentHash: revisionHash(content), Language: "und", ContentType: "text/html; charset=utf-8", Body: content, Message: message, CreatedAt: now.Unix(), CreatedAtMS: now.UnixMilli()} if s.sqlBackend == storePostgreSQL { docs, err := s.documentStorage() if err != nil { return err } if err = docs.PutIfAbsent(ctx, rev.DocumentHash, int64(len(content)), strings.NewReader(content)); err != nil { return err } if _, err = tx.ExecContext(ctx, `INSERT INTO revisions(uuid,object_uuid,body,document_hash,lang,content_type,filename,message,created_at_ms,created_at) VALUES($1,$2,'',$3,$4,$5,'',$6,$7,$8)`, rev.UUID, object, rev.DocumentHash, rev.Language, rev.ContentType, rev.Message, rev.CreatedAtMS, rev.CreatedAt); err != nil { return err } for _, hash := range embeddedHashes { if _, err = tx.ExecContext(ctx, `INSERT INTO revision_document_refs(revision_uuid,document_hash) VALUES($1,$2)`, rev.UUID, hash); err != nil { return err } } payload, _ := json.Marshal(map[string]string{"revision_uuid": rev.UUID, "object_uuid": object, "document_hash": rev.DocumentHash, "content_type": rev.ContentType, "filename": ""}) if err = s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{DomainUUID: domain, ActorUUID: actor, EventType: "revision.created", TargetKind: "revision", TargetUUID: rev.UUID, Payload: string(payload), IdempotencyKey: "revision.created:" + rev.UUID}); err != nil { return err } } else { if err := s.persistDocument(rev.DocumentHash, rev.Body); err != nil { return err } if err := insertRevision(tx, rev, embeddedHashes); err != nil { return err } if err := s.appendRevisionActivityOutboxIfAvailable(tx, rev); err != nil { return err } } payload, _ := json.Marshal(map[string]string{"path": target, "object_uuid": object}) return s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{DomainUUID: domain, ActorUUID: actor, EventType: "page.created", TargetKind: "page", TargetUUID: object, Payload: string(payload), IdempotencyKey: "page.created:" + object}) }