switch sequence number tracking to database, other changes

frontend/src/components/PostView.tsx

···
 import { PostResponse } from '../types';
 import { ApiClient } from '../api';
 import { PostCard } from './PostCard';
+import { EngagementModal } from './EngagementModal';
 import './PostView.css';
 
 export const PostView: React.FC = () => {
···
   const [threadPosts, setThreadPosts] = useState<PostResponse[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
+  const [showEngagementModal, setShowEngagementModal] = useState<'likes' | 'reposts' | 'replies' | null>(null);
 
   useEffect(() => {
     // Scroll to top when navigating to a post
···
           <PostCard postResponse={mainPost} showThreadIndicator={false} />
         </div>
 
+        {mainPost.counts && (mainPost.counts.likes > 0 || mainPost.counts.reposts > 0 || mainPost.counts.replies > 0) && (
+          <div className="post-engagement-detail">
+            {mainPost.counts.likes > 0 && (
+              <button
+                className="engagement-detail-item"
+                onClick={() => setShowEngagementModal('likes')}
+              >
+                <span className="engagement-detail-count">{mainPost.counts.likes}</span>
+                <span className="engagement-detail-label">{mainPost.counts.likes === 1 ? 'Like' : 'Likes'}</span>
+              </button>
+            )}
+            {mainPost.counts.reposts > 0 && (
+              <button
+                className="engagement-detail-item"
+                onClick={() => setShowEngagementModal('reposts')}
+              >
+                <span className="engagement-detail-count">{mainPost.counts.reposts}</span>
+                <span className="engagement-detail-label">{mainPost.counts.reposts === 1 ? 'Repost' : 'Reposts'}</span>
+              </button>
+            )}
+            {mainPost.counts.replies > 0 && (
+              <button
+                className="engagement-detail-item"
+                onClick={() => setShowEngagementModal('replies')}
+              >
+                <span className="engagement-detail-count">{mainPost.counts.replies}</span>
+                <span className="engagement-detail-label">{mainPost.counts.replies === 1 ? 'Reply' : 'Replies'}</span>
+              </button>
+            )}
+          </div>
+        )}
+
         {threadPosts.length > 0 && (
           <div className="thread-replies">
             <div className="replies-header">
···
           </div>
         )}
       </div>
+
+      {showEngagementModal && (
+        <EngagementModal
+          postId={mainPost.id}
+          type={showEngagementModal}
+          onClose={() => setShowEngagementModal(null)}
+        />
+      )}
     </div>
   );
 };

handlers.go

···
 		view.Langs = fp.Langs
 	}
 
-	// Hydrate embed if present
 	if fp.Embed != nil {
-		slog.Info("processing embed", "hasImages", fp.Embed.EmbedImages != nil, "hasExternal", fp.Embed.EmbedExternal != nil, "hasRecord", fp.Embed.EmbedRecord != nil)
-		if fp.Embed.EmbedImages != nil {
-			view.Embed = fp.Embed.EmbedImages
-		} else if fp.Embed.EmbedExternal != nil {
-			view.Embed = fp.Embed.EmbedExternal
-		} else if fp.Embed.EmbedRecord != nil {
-			// Hydrate quoted post
-			quotedURI := fp.Embed.EmbedRecord.Record.Uri
-			quotedCid := fp.Embed.EmbedRecord.Record.Cid
-			slog.Info("hydrating quoted post", "uri", quotedURI, "cid", quotedCid)
+		view.Embed = s.hydrateEmbed(ctx, fp.Embed)
+	}
+
+	return view
+}
 
-			quotedPost, err := s.backend.getPostByUri(ctx, quotedURI, "*")
-			if err != nil {
-				slog.Warn("failed to get quoted post", "uri", quotedURI, "error", err)
-			}
-			if err == nil && quotedPost != nil && quotedPost.Raw != nil && len(quotedPost.Raw) > 0 && !quotedPost.NotFound {
-				slog.Info("found quoted post, hydrating")
-				var quotedFP bsky.FeedPost
-				if err := quotedFP.UnmarshalCBOR(bytes.NewReader(quotedPost.Raw)); err == nil {
-					quotedRepo, err := s.backend.getRepoByID(ctx, quotedPost.Author)
-					if err == nil {
-						quotedAuthor, err := s.getAuthorInfo(ctx, quotedRepo)
-						if err == nil {
-							view.Embed = map[string]interface{}{
-								"$type": "app.bsky.embed.record",
-								"record": &embedRecordView{
-									Type:   "app.bsky.embed.record#viewRecord",
-									Uri:    quotedURI,
-									Cid:    quotedCid,
-									Author: quotedAuthor,
-									Value:  &quotedFP,
-								},
-							}
-						}
-					}
-				}
-			}
+func (s *Server) hydrateEmbed(ctx context.Context, embed *bsky.FeedPost_Embed) interface{} {
+	switch {
+	case embed.EmbedImages != nil:
+		return embed.EmbedImages
+	case embed.EmbedExternal != nil:
+		return embed.EmbedExternal
+	case embed.EmbedRecord != nil:
+		return s.hydrateQuotedPost(ctx, embed.EmbedRecord)
+	case embed.EmbedRecordWithMedia != nil:
+		return s.hydrateRecordWithMedia(ctx, embed.EmbedRecordWithMedia)
+	default:
+		return nil
+	}
+}
+
+func (s *Server) hydrateRecordWithMedia(ctx context.Context, rwm *bsky.EmbedRecordWithMedia) interface{} {
+	result := map[string]interface{}{
+		"$type": "app.bsky.embed.recordWithMedia",
+	}
 
-			// Fallback if hydration failed - show basic info
-			if view.Embed == nil {
-				slog.Info("quoted post not in database, using fallback")
-				view.Embed = map[string]interface{}{
-					"$type": "app.bsky.embed.record",
-					"record": map[string]interface{}{
-						"uri": quotedURI,
-						"cid": quotedCid,
-					},
-				}
-			}
+	// Hydrate media
+	if rwm.Media != nil {
+		if rwm.Media.EmbedImages != nil {
+			result["media"] = rwm.Media.EmbedImages
+		} else if rwm.Media.EmbedExternal != nil {
+			result["media"] = rwm.Media.EmbedExternal
 		}
 	}
 
-	return view
+	// Hydrate record
+	if rwm.Record != nil {
+		result["record"] = s.hydrateQuotedPost(ctx, rwm.Record)
+	}
+
+	return result
+}
+
+func (s *Server) hydrateQuotedPost(ctx context.Context, embedRecord *bsky.EmbedRecord) interface{} {
+	quotedURI := embedRecord.Record.Uri
+	quotedCid := embedRecord.Record.Cid
+
+	quotedPost, err := s.backend.getPostByUri(ctx, quotedURI, "*")
+	if err != nil {
+		slog.Warn("failed to get quoted post", "uri", quotedURI, "error", err)
+		s.addMissingPost(ctx, quotedURI)
+		return s.buildQuoteFallback(quotedURI, quotedCid)
+	}
+
+	if quotedPost == nil || quotedPost.Raw == nil || len(quotedPost.Raw) == 0 || quotedPost.NotFound {
+		s.addMissingPost(ctx, quotedURI)
+		return s.buildQuoteFallback(quotedURI, quotedCid)
+	}
+
+	var quotedFP bsky.FeedPost
+	if err := quotedFP.UnmarshalCBOR(bytes.NewReader(quotedPost.Raw)); err != nil {
+		slog.Warn("failed to unmarshal quoted post", "error", err)
+		return s.buildQuoteFallback(quotedURI, quotedCid)
+	}
+
+	quotedRepo, err := s.backend.getRepoByID(ctx, quotedPost.Author)
+	if err != nil {
+		slog.Warn("failed to get quoted post author", "error", err)
+		return s.buildQuoteFallback(quotedURI, quotedCid)
+	}
+
+	quotedAuthor, err := s.getAuthorInfo(ctx, quotedRepo)
+	if err != nil {
+		slog.Warn("failed to get quoted post author info", "error", err)
+		return s.buildQuoteFallback(quotedURI, quotedCid)
+	}
+
+	return map[string]interface{}{
+		"$type": "app.bsky.embed.record",
+		"record": &embedRecordView{
+			Type:   "app.bsky.embed.record#viewRecord",
+			Uri:    quotedURI,
+			Cid:    quotedCid,
+			Author: quotedAuthor,
+			Value:  &quotedFP,
+		},
+	}
+}
+
+func (s *Server) buildQuoteFallback(uri, cid string) map[string]interface{} {
+	return map[string]interface{}{
+		"$type": "app.bsky.embed.record",
+		"record": map[string]interface{}{
+			"uri": uri,
+			"cid": cid,
+		},
+	}
 }
 
 func (s *Server) handleGetThread(e echo.Context) error {

main.go

···
 		db.AutoMigrate(StarterPack{})
 		db.AutoMigrate(SyncInfo{})
 		db.AutoMigrate(Notification{})
+		db.AutoMigrate(SequenceTracker{})
 
 		ctx := context.TODO()
 
···
 		go s.missingProfileFetcher()
 		go s.missingPostFetcher()
 
-		seqno, err := loadLastSeq("sequence.txt")
+		seqno, err := loadLastSeq(db, "firehose_seq")
 		if err != nil {
 			fmt.Println("failed to load sequence number, starting over", err)
 		}
 
-		return s.startLiveTail(ctx, seqno, 10, 20)
+		return s.startLiveTail(ctx, int(seqno), 10, 20)
 	}
 
 	app.RunAndExitOnError()
···
 				s.lastSeq = evt.Seq
 
 				if evt.Seq%1000 == 0 {
-					if err := storeLastSeq("sequence.txt", int(evt.Seq)); err != nil {
+					if err := storeLastSeq(s.backend.db, "firehose_seq", evt.Seq); err != nil {
 						fmt.Println("failed to store seqno: ", err)
 					}
 				}

missing.go

···
 	"bytes"
 	"context"
 	"fmt"
+	"log/slog"
 	"strings"
 
 	"github.com/bluesky-social/indigo/api/atproto"
···
 }
 
 func (s *Server) addMissingPost(ctx context.Context, uri string) {
+	slog.Info("adding missing post to fetch queue", "uri", uri)
 	select {
 	case s.missingPosts <- uri:
 	case <-ctx.Done():

models.go

···
 	Source string
 	Kind   string
 }
+
+type SequenceTracker struct {
+	ID     uint   `gorm:"primarykey"`
+	Key    string `gorm:"uniqueIndex"`
+	IntVal int64
+}

seqno.go

···
 package main
 
 import (
-	"fmt"
-	"io/ioutil"
-	"strconv"
-	"strings"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
-func storeLastSeq(filename string, seq int) error {
-	data := fmt.Sprint(seq)
-	return ioutil.WriteFile(filename, []byte(data), 0644)
+func storeLastSeq(db *gorm.DB, key string, seq int64) error {
+	return db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "key"}},
+		DoUpdates: clause.AssignmentColumns([]string{"int_val"}),
+	}).Create(&SequenceTracker{
+		Key:    key,
+		IntVal: seq,
+	}).Error
 }
 
-func loadLastSeq(filename string) (int, error) {
-	data, err := ioutil.ReadFile(filename)
-	if err != nil {
+func loadLastSeq(db *gorm.DB, key string) (int64, error) {
+	var info SequenceTracker
+	if err := db.Where("key = ?", key).First(&info).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
 		return 0, err
 	}
-
-	seqStr := strings.TrimSpace(string(data))
-	seq, err := strconv.Atoi(seqStr)
-	if err != nil {
-		return 0, err
-	}
-
-	return seq, nil
+	return info.IntVal, nil
 }