Add CommentUpdate handler for resolution toggle

cmd/server/main.go

···
 	mux.HandleFunc("GET /docs/{rkey}/accept", h.AcceptInvite)
 	mux.HandleFunc("POST /api/docs/{rkey}/comments", h.CommentCreate)
 	mux.HandleFunc("GET /api/docs/{rkey}/comments", h.CommentList)
+	mux.HandleFunc("PATCH /api/docs/{rkey}/comments/{commentId}", h.CommentUpdate)
 	mux.HandleFunc("POST /api/docs/{rkey}/steps", h.SubmitSteps)
 	mux.HandleFunc("GET /api/docs/{rkey}/steps", h.GetSteps)
 

internal/handler/handler.go

···
 		return
 	}
 
-	value, _, err := ownerClient.GetRecord(ownerDID, collectionDocument, rKey)
+	records, _, err := ownerClient.ListComments(ownerDID, rKey, 100, "")
 	if err != nil {
-		log.Printf("CommentList: GetRecord: %v", err)
-		http.Error(w, "Document not found", http.StatusNotFound)
+		log.Printf("CommentList: ListComments: %v", err)
+		h.jsonResponse(w, []model.CommentRecord{}, http.StatusOK)
+		return
+	}
+
+	comments := make([]model.CommentRecord, 0, len(records))
+	for _, rec := range records {
+		var comment model.CommentRecord
+		if err := json.Unmarshal(rec.Value, &comment); err != nil {
+			log.Printf("CommentList: unmarshal comment: %v", err)
+			continue
+		}
+		comment.ID = model.RKeyFromURI(rec.URI)
+		comments = append(comments, comment)
+	}
+
+	h.jsonResponse(w, comments, http.StatusOK)
+}
+
+func (h *Handler) CommentUpdate(w http.ResponseWriter, r *http.Request) {
+	user, _ := h.currentUser(r)
+	if user == nil {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
 		return
 	}
-	var doc model.Document
-	if err := json.Unmarshal(value, &doc); err != nil {
-		http.Error(w, "Failed to parse document", http.StatusInternalServerError)
+
+	rKey := r.PathValue("rkey")
+	commentID := r.PathValue("commentId")
+	if rKey == "" || commentID == "" {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
 		return
 	}
 
-	comments := doc.Comments
-	if comments == nil {
-		comments = []model.EmbeddedComment{}
+	var req struct {
+		OwnerDID string `json:"ownerDID"`
+		Resolved bool   `json:"resolved"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
 	}
-	h.jsonResponse(w, comments, http.StatusOK)
+
+	session, err := h.DB.GetATProtoSession(user.ID)
+	if err != nil || session == nil {
+		http.Error(w, "Not authenticated with ATProto", http.StatusUnauthorized)
+		return
+	}
+
+	ownerUserID := user.ID
+	ownerDID := session.DID
+	if req.OwnerDID != "" && req.OwnerDID != session.DID {
+		ownerUser, err := h.DB.GetUserByDID(req.OwnerDID)
+		if err != nil {
+			http.Error(w, "Owner not found", http.StatusBadRequest)
+			return
+		}
+		ownerUserID = ownerUser.ID
+		ownerDID = req.OwnerDID
+	}
+
+	ownerClient, err := h.xrpcClient(ownerUserID)
+	if err != nil {
+		http.Error(w, "Failed to connect to owner PDS", http.StatusInternalServerError)
+		return
+	}
+
+	value, _, err := ownerClient.GetRecord(ownerDID, model.CollectionComment, commentID)
+	if err != nil {
+		log.Printf("CommentUpdate: GetRecord: %v", err)
+		http.Error(w, "Comment not found", http.StatusNotFound)
+		return
+	}
+
+	var comment model.CommentRecord
+	if err := json.Unmarshal(value, &comment); err != nil {
+		http.Error(w, "Failed to parse comment", http.StatusInternalServerError)
+		return
+	}
+
+	comment.Resolved = req.Resolved
+
+	_, _, err = ownerClient.UpdateComment(commentID, comment)
+	if err != nil {
+		log.Printf("CommentUpdate: UpdateComment: %v", err)
+		http.Error(w, "Failed to update comment", http.StatusInternalServerError)
+		return
+	}
+
+	h.jsonResponse(w, comment, http.StatusOK)
 }
 
 // --- API: Render markdown ---

internal/model/models.go

···
 }
 
 type CommentRecord struct {
+	ID           string `json:"id"`                // record key (rkey)
 	ThreadID     string `json:"threadId"`          // groups replies into threads
 	DocRKey      string `json:"docRKey"`           // document rkey this comment belongs to
 	DocOwnerDID  string `json:"docOwnerDid"`       // owner DID for quick filtering