feat(wip): create or update post handler & command

cmd/publication_commands.go

···
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/spf13/cobra"
 	"github.com/stormlightlabs/noteleaf/internal/handlers"
···
 	}
 	root.AddCommand(statusCmd)
 
+	postCmd := &cobra.Command{
+		Use:   "post [note-id]",
+		Short: "Create a new document on leaflet",
+		Long: `Publish a local note to leaflet.pub as a new document.
+
+This command converts your markdown note to leaflet's block format and creates
+a new document on the platform. The note will be linked to the leaflet document
+for future updates via the patch command.
+
+Examples:
+  noteleaf pub post 123                # Publish note 123
+  noteleaf pub post 123 --draft        # Create as draft
+  noteleaf pub post 123 --preview      # Preview without posting
+  noteleaf pub post 123 --validate     # Validate conversion only`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			noteID, err := parseNoteID(args[0])
+			if err != nil {
+				return err
+			}
+
+			isDraft, _ := cmd.Flags().GetBool("draft")
+			preview, _ := cmd.Flags().GetBool("preview")
+			validate, _ := cmd.Flags().GetBool("validate")
+
+			defer c.handler.Close()
+
+			if preview {
+				return c.handler.PostPreview(cmd.Context(), noteID, isDraft)
+			}
+
+			if validate {
+				return c.handler.PostValidate(cmd.Context(), noteID, isDraft)
+			}
+
+			return c.handler.Post(cmd.Context(), noteID, isDraft)
+		},
+	}
+	postCmd.Flags().Bool("draft", false, "Create as draft instead of publishing")
+	postCmd.Flags().Bool("preview", false, "Show what would be posted without actually posting")
+	postCmd.Flags().Bool("validate", false, "Validate markdown conversion without posting")
+	root.AddCommand(postCmd)
+
+	patchCmd := &cobra.Command{
+		Use:   "patch [note-id]",
+		Short: "Update an existing document on leaflet",
+		Long: `Update an existing leaflet document from a local note.
+
+This command converts your markdown note to leaflet's block format and updates
+the existing document on the platform. The note must have been previously posted
+or pulled from leaflet (it needs a leaflet record key).
+
+The document's draft/published status is preserved from the note's current state.
+
+Examples:
+  noteleaf pub patch 123            # Update existing document
+  noteleaf pub patch 123 --preview  # Preview without updating
+  noteleaf pub patch 123 --validate # Validate conversion only`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			noteID, err := parseNoteID(args[0])
+			if err != nil {
+				return err
+			}
+
+			preview, _ := cmd.Flags().GetBool("preview")
+			validate, _ := cmd.Flags().GetBool("validate")
+
+			defer c.handler.Close()
+
+			if preview {
+				return c.handler.PatchPreview(cmd.Context(), noteID)
+			}
+
+			if validate {
+				return c.handler.PatchValidate(cmd.Context(), noteID)
+			}
+
+			return c.handler.Patch(cmd.Context(), noteID)
+		},
+	}
+	patchCmd.Flags().Bool("preview", false, "Show what would be updated without actually patching")
+	patchCmd.Flags().Bool("validate", false, "Validate markdown conversion without patching")
+	root.AddCommand(patchCmd)
+
 	return root
 }
+
+func parseNoteID(arg string) (int64, error) {
+	noteID, err := strconv.ParseInt(arg, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid note ID '%s': must be a number", arg)
+	}
+	return noteID, nil
+}

cmd/publication_commands_test.go

···
 				"pull",
 				"list [--published|--draft|--all]",
 				"status",
+				"post [note-id]",
+				"patch [note-id]",
 			}
 
 			for _, expected := range expectedSubcommands {
···
 				t.Error("Expected pull to fail when not authenticated")
 			}
 			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Post Command", func(t *testing.T) {
+		t.Run("requires note ID argument", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for missing note ID")
+			}
+		})
+
+		t.Run("rejects invalid note ID", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "not-a-number"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for invalid note ID")
+			}
+			if !strings.Contains(err.Error(), "invalid note ID") {
+				t.Errorf("Expected 'invalid note ID' error, got: %v", err)
+			}
+		})
+
+		t.Run("fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("preview mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--preview"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --preview to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("validate mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--validate"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --validate to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("accepts draft flag", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--draft"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --draft to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("accepts preview and draft flags together", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"post", "123", "--preview", "--draft"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected post --preview --draft to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+	})
+
+	t.Run("Patch Command", func(t *testing.T) {
+		t.Run("requires note ID argument", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for missing note ID")
+			}
+		})
+
+		t.Run("rejects invalid note ID", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "not-a-number"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected error for invalid note ID")
+			}
+			if !strings.Contains(err.Error(), "invalid note ID") {
+				t.Errorf("Expected 'invalid note ID' error, got: %v", err)
+			}
+		})
+
+		t.Run("fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("preview mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123", "--preview"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch --preview to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got: %v", err)
+			}
+		})
+
+		t.Run("validate mode fails when not authenticated", func(t *testing.T) {
+			handler, cleanup := createTestPublicationHandler(t)
+			defer cleanup()
+
+			cmd := NewPublicationCommand(handler).Create()
+			cmd.SetArgs([]string{"patch", "123", "--validate"})
+			err := cmd.Execute()
+
+			if err == nil {
+				t.Error("Expected patch --validate to fail when not authenticated")
+			}
+			if !strings.Contains(err.Error(), "not authenticated") {
 				t.Errorf("Expected 'not authenticated' error, got: %v", err)
 			}
 		})

internal/handlers/publication.go

···
 //
 // TODO: Post (create 1)
 // TODO: Patch (update 1)
-// TODO: Push (create or update - more than 1)
+// TODO: Push
+//   - Builds on Post & Patch (create or update - more than 1)
+//
 // TODO: Add TUI viewing for document details
+//   - interactive list, read Markdown with glamour
+//
+// TODO: Add TUI for confirming post
+//   - proofread post with glamour
+//
 // TODO: Repost - "Reblog" - post to BlueSky
 package handlers
 
···
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
 
-	note, err := h.repos.Notes.Get(ctx, noteID)
-	if err != nil {
-		return fmt.Errorf("failed to get note: %w", err)
-	}
-
-	if note.HasLeafletAssociation() {
-		return fmt.Errorf("note already published - use patch to update")
-	}
-
-	session, err := h.atproto.GetSession()
-	if err != nil {
-		return fmt.Errorf("failed to get session: %w", err)
-	}
-
 	// TODO: Implement image handling for markdown conversion
 	// 1. Extract note's directory from filepath/database
 	// 2. Create LocalImageResolver with BlobUploader that calls h.atproto.UploadBlob()
 	// 3. Use converter.WithImageResolver(resolver, noteDir) before ToLeaflet()
 	// This will upload images to AT Protocol and get real CIDs/dimensions
-	converter := public.NewMarkdownConverter()
-	blocks, err := converter.ToLeaflet(note.Content)
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, isDraft, false)
 	if err != nil {
-		return fmt.Errorf("failed to convert markdown to leaflet format: %w", err)
-	}
-
-	doc := public.Document{
-		Author:      session.DID,
-		Title:       note.Title,
-		Description: "",
-		Pages: []public.LinearDocument{
-			{
-				Type:   public.TypeLinearDocument,
-				Blocks: blocks,
-			},
-		},
-	}
-
-	if !isDraft {
-		now := time.Now()
-		doc.PublishedAt = now.Format(time.RFC3339)
+		return err
 	}
 
 	ui.Infoln("Creating document '%s' on leaflet...", note.Title)
 
-	result, err := h.atproto.PostDocument(ctx, doc, isDraft)
+	result, err := h.atproto.PostDocument(ctx, *doc, isDraft)
 	if err != nil {
 		return fmt.Errorf("failed to post document: %w", err)
 	}
···
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
 
-	note, err := h.repos.Notes.Get(ctx, noteID)
+	tempNote, err := h.repos.Notes.Get(ctx, noteID)
 	if err != nil {
 		return fmt.Errorf("failed to get note: %w", err)
 	}
 
-	if !note.HasLeafletAssociation() {
-		return fmt.Errorf("note not published - use post to create")
-	}
-
-	session, err := h.atproto.GetSession()
-	if err != nil {
-		return fmt.Errorf("failed to get session: %w", err)
-	}
-
 	// TODO: Implement image handling for markdown conversion (same as Post method)
 	// 1. Extract note's directory from filepath/database
 	// 2. Create LocalImageResolver with BlobUploader that calls h.atproto.UploadBlob()
 	// 3. Use converter.WithImageResolver(resolver, noteDir) before ToLeaflet()
 	// This will upload images to AT Protocol and get real CIDs/dimensions
-	converter := public.NewMarkdownConverter()
-	blocks, err := converter.ToLeaflet(note.Content)
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, tempNote.IsDraft, true)
 	if err != nil {
-		return fmt.Errorf("failed to convert markdown to leaflet format: %w", err)
+		return err
 	}
 
-	doc := public.Document{
-		Author:      session.DID,
-		Title:       note.Title,
-		Description: "",
-		Pages: []public.LinearDocument{
-			{
-				Type:   public.TypeLinearDocument,
-				Blocks: blocks,
-			},
-		},
-	}
-
-	if !note.IsDraft && note.PublishedAt != nil {
-		doc.PublishedAt = note.PublishedAt.Format(time.RFC3339)
-	} else if !note.IsDraft {
-		now := time.Now()
-		doc.PublishedAt = now.Format(time.RFC3339)
-		note.PublishedAt = &now
+	// Update note.PublishedAt if we set a new timestamp
+	if !note.IsDraft && note.PublishedAt == nil && doc.PublishedAt != "" {
+		publishedAt, err := time.Parse(time.RFC3339, doc.PublishedAt)
+		if err == nil {
+			note.PublishedAt = &publishedAt
+		}
 	}
 
 	ui.Infoln("Updating document '%s' on leaflet...", note.Title)
 
-	result, err := h.atproto.PatchDocument(ctx, *note.LeafletRKey, doc, note.IsDraft)
+	result, err := h.atproto.PatchDocument(ctx, *note.LeafletRKey, *doc, note.IsDraft)
 	if err != nil {
 		return fmt.Errorf("failed to patch document: %w", err)
 	}
···
 	}
 
 	ui.Successln("Document deleted successfully!")
+
+	return nil
+}
+
+// prepareDocumentForPublish prepares a note for publication by converting to Leaflet format
+func (h *PublicationHandler) prepareDocumentForPublish(ctx context.Context, noteID int64, isDraft bool, forPatch bool) (*models.Note, *public.Document, error) {
+	note, err := h.repos.Notes.Get(ctx, noteID)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get note: %w", err)
+	}
+
+	if !forPatch && note.HasLeafletAssociation() {
+		return nil, nil, fmt.Errorf("note already published - use patch to update")
+	}
+
+	if forPatch && !note.HasLeafletAssociation() {
+		return nil, nil, fmt.Errorf("note not published - use post to create")
+	}
+
+	session, err := h.atproto.GetSession()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to get session: %w", err)
+	}
+
+	converter := public.NewMarkdownConverter()
+	blocks, err := converter.ToLeaflet(note.Content)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to convert markdown to leaflet format: %w", err)
+	}
+
+	doc := &public.Document{
+		Author:      session.DID,
+		Title:       note.Title,
+		Description: "",
+		Pages: []public.LinearDocument{
+			{
+				Type:   public.TypeLinearDocument,
+				Blocks: blocks,
+			},
+		},
+	}
+
+	if !isDraft {
+		if forPatch && note.PublishedAt != nil {
+			doc.PublishedAt = note.PublishedAt.Format(time.RFC3339)
+		} else {
+			now := time.Now()
+			doc.PublishedAt = now.Format(time.RFC3339)
+		}
+	}
+
+	return note, doc, nil
+}
+
+// PostPreview shows what would be posted without actually posting
+func (h *PublicationHandler) PostPreview(ctx context.Context, noteID int64, isDraft bool) error {
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, isDraft, false)
+	if err != nil {
+		return err
+	}
+
+	status := "published"
+	if isDraft {
+		status = "draft"
+	}
+
+	ui.Infoln("Preview: Would create document on leaflet")
+	ui.Infoln("  Title: %s", doc.Title)
+	ui.Infoln("  Status: %s", status)
+	ui.Infoln("  Pages: %d", len(doc.Pages))
+	ui.Infoln("  Blocks: %d", len(doc.Pages[0].Blocks))
+	if doc.PublishedAt != "" {
+		ui.Infoln("  PublishedAt: %s", doc.PublishedAt)
+	}
+	ui.Infoln("  Note ID: %d", note.ID)
+	ui.Successln("Preview complete - no changes made")
+
+	return nil
+}
+
+// PostValidate validates markdown conversion without posting
+func (h *PublicationHandler) PostValidate(ctx context.Context, noteID int64, isDraft bool) error {
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, isDraft, false)
+	if err != nil {
+		return err
+	}
+
+	ui.Infoln("Validating markdown conversion for note %d...", note.ID)
+	ui.Successln("Validation successful!")
+	ui.Infoln("  Title: %s", doc.Title)
+	ui.Infoln("  Blocks converted: %d", len(doc.Pages[0].Blocks))
+
+	return nil
+}
+
+// PatchPreview shows what would be patched without actually patching
+func (h *PublicationHandler) PatchPreview(ctx context.Context, noteID int64) error {
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	tempNote, err := h.repos.Notes.Get(ctx, noteID)
+	if err != nil {
+		return fmt.Errorf("failed to get note: %w", err)
+	}
+
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, tempNote.IsDraft, true)
+	if err != nil {
+		return err
+	}
+
+	status := "published"
+	if note.IsDraft {
+		status = "draft"
+	}
+
+	ui.Infoln("Preview: Would update document on leaflet")
+	ui.Infoln("  Title: %s", doc.Title)
+	ui.Infoln("  Status: %s", status)
+	ui.Infoln("  RKey: %s", *note.LeafletRKey)
+	ui.Infoln("  Pages: %d", len(doc.Pages))
+	ui.Infoln("  Blocks: %d", len(doc.Pages[0].Blocks))
+	if doc.PublishedAt != "" {
+		ui.Infoln("  PublishedAt: %s", doc.PublishedAt)
+	}
+	ui.Successln("Preview complete - no changes made")
+
+	return nil
+}
+
+// PatchValidate validates markdown conversion without patching
+func (h *PublicationHandler) PatchValidate(ctx context.Context, noteID int64) error {
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	tempNote, err := h.repos.Notes.Get(ctx, noteID)
+	if err != nil {
+		return fmt.Errorf("failed to get note: %w", err)
+	}
+
+	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, tempNote.IsDraft, true)
+	if err != nil {
+		return err
+	}
+
+	ui.Infoln("Validating markdown conversion for note %d...", note.ID)
+	ui.Successln("Validation successful!")
+	ui.Infoln("  Title: %s", doc.Title)
+	ui.Infoln("  RKey: %s", *note.LeafletRKey)
+	ui.Infoln("  Blocks converted: %d", len(doc.Pages[0].Blocks))
 
 	return nil
 }

internal/handlers/publication_test.go

···
 		})
 	})
 
+	t.Run("PostPreview", func(t *testing.T) {
+		t.Run("returns error when not authenticated", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			err := handler.PostPreview(ctx, 1, false)
+			if err == nil {
+				t.Error("Expected error when not authenticated")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got '%v'", err)
+			}
+		})
+
+		t.Run("returns error when note does not exist", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err := handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PostPreview(ctx, 999, false)
+			if err == nil {
+				t.Error("Expected error when note does not exist")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "failed to get note") {
+				t.Errorf("Expected 'failed to get note' error, got '%v'", err)
+			}
+		})
+
+		t.Run("returns error when note already published", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			rkey := "existing_rkey"
+			cid := "existing_cid"
+			note := &models.Note{
+				Title:       "Already Published",
+				Content:     "# Test content",
+				LeafletRKey: &rkey,
+				LeafletCID:  &cid,
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PostPreview(ctx, id, false)
+			if err == nil {
+				t.Error("Expected error when note already published")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "already published") {
+				t.Errorf("Expected 'already published' error, got '%v'", err)
+			}
+		})
+
+		t.Run("shows preview for valid note", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note := &models.Note{
+				Title:   "Test Note",
+				Content: "# Test content\n\nThis is a test.",
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PostPreview(ctx, id, false)
+			suite.AssertNoError(err, "preview should succeed")
+		})
+
+		t.Run("shows preview for draft", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note := &models.Note{
+				Title:   "Draft Note",
+				Content: "# Draft content",
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PostPreview(ctx, id, true)
+			suite.AssertNoError(err, "preview draft should succeed")
+		})
+	})
+
+	t.Run("PostValidate", func(t *testing.T) {
+		t.Run("returns error when not authenticated", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			err := handler.PostValidate(ctx, 1, false)
+			if err == nil {
+				t.Error("Expected error when not authenticated")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got '%v'", err)
+			}
+		})
+
+		t.Run("validates markdown conversion successfully", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note := &models.Note{
+				Title:   "Test Note",
+				Content: "# Test content\n\nValid markdown here.",
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PostValidate(ctx, id, false)
+			suite.AssertNoError(err, "validation should succeed")
+		})
+	})
+
+	t.Run("PatchPreview", func(t *testing.T) {
+		t.Run("returns error when not authenticated", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			err := handler.PatchPreview(ctx, 1)
+			if err == nil {
+				t.Error("Expected error when not authenticated")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got '%v'", err)
+			}
+		})
+
+		t.Run("returns error when note does not exist", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err := handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PatchPreview(ctx, 999)
+			if err == nil {
+				t.Error("Expected error when note does not exist")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "failed to get note") {
+				t.Errorf("Expected 'failed to get note' error, got '%v'", err)
+			}
+		})
+
+		t.Run("returns error when note not published", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note := &models.Note{
+				Title:   "Not Published",
+				Content: "# Test content",
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PatchPreview(ctx, id)
+			if err == nil {
+				t.Error("Expected error when note not published")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not published") {
+				t.Errorf("Expected 'not published' error, got '%v'", err)
+			}
+		})
+
+		t.Run("shows preview for published note", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			rkey := "test_rkey"
+			cid := "test_cid"
+			publishedAt := time.Now().Add(-24 * time.Hour)
+			note := &models.Note{
+				Title:       "Published Note",
+				Content:     "# Updated content",
+				LeafletRKey: &rkey,
+				LeafletCID:  &cid,
+				PublishedAt: &publishedAt,
+				IsDraft:     false,
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PatchPreview(ctx, id)
+			suite.AssertNoError(err, "preview should succeed")
+		})
+	})
+
+	t.Run("PatchValidate", func(t *testing.T) {
+		t.Run("returns error when not authenticated", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			err := handler.PatchValidate(ctx, 1)
+			if err == nil {
+				t.Error("Expected error when not authenticated")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got '%v'", err)
+			}
+		})
+
+		t.Run("validates markdown conversion successfully", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			rkey := "test_rkey"
+			cid := "test_cid"
+			note := &models.Note{
+				Title:       "Published Note",
+				Content:     "# Updated content\n\nValid markdown here.",
+				LeafletRKey: &rkey,
+				LeafletCID:  &cid,
+				IsDraft:     false,
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.PatchValidate(ctx, id)
+			suite.AssertNoError(err, "validation should succeed")
+		})
+	})
+
 	t.Run("Delete", func(t *testing.T) {
 		t.Run("returns error when not authenticated", func(t *testing.T) {
 			suite := NewHandlerTestSuite(t)