Add xrpc endpoints to satisfy running the main bluesky app against this

events.go

···
 		p.InThread = thread
 
 		if p.ReplyToUsr == b.s.myrepo.ID {
-			if err := b.s.AddNotification(ctx, b.s.myrepo.ID, p.Author, uri, NotifKindReply); err != nil {
+			if err := b.s.AddNotification(ctx, b.s.myrepo.ID, p.Author, uri, cc, NotifKindReply); err != nil {
 				slog.Warn("failed to create notification", "uri", uri, "error", err)
 			}
 		}
···
 
 					// Create notification if the mentioned user is the current user
 					if mentionedRepo.ID == b.s.myrepo.ID {
-						if err := b.s.AddNotification(ctx, b.s.myrepo.ID, p.Author, uri, NotifKindMention); err != nil {
+						if err := b.s.AddNotification(ctx, b.s.myrepo.ID, p.Author, uri, cc, NotifKindMention); err != nil {
 							slog.Warn("failed to create mention notification", "uri", uri, "error", err)
 						}
 					}
···
 	// Create notification if the liked post belongs to the current user
 	if pinfo.Author == b.s.myrepo.ID {
 		uri := fmt.Sprintf("at://%s/app.bsky.feed.like/%s", repo.Did, rkey)
-		if err := b.s.AddNotification(ctx, b.s.myrepo.ID, repo.ID, uri, NotifKindLike); err != nil {
+		if err := b.s.AddNotification(ctx, b.s.myrepo.ID, repo.ID, uri, cc, NotifKindLike); err != nil {
 			slog.Warn("failed to create like notification", "uri", uri, "error", err)
 		}
 	}
···
 	// Create notification if the reposted post belongs to the current user
 	if pinfo.Author == b.s.myrepo.ID {
 		uri := fmt.Sprintf("at://%s/app.bsky.feed.repost/%s", repo.Did, rkey)
-		if err := b.s.AddNotification(ctx, b.s.myrepo.ID, repo.ID, uri, NotifKindRepost); err != nil {
+		if err := b.s.AddNotification(ctx, b.s.myrepo.ID, repo.ID, uri, cc, NotifKindRepost); err != nil {
 			slog.Warn("failed to create repost notification", "uri", uri, "error", err)
 		}
 	}

go.mod

···
 
 require (
 	github.com/bluesky-social/indigo v0.0.0-20250909204019-c5eaa30f683f
+	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/gorilla/websocket v1.5.1
 	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/ipfs/go-cid v0.4.1
 	github.com/jackc/pgx/v5 v5.6.0
 	github.com/labstack/echo/v4 v4.11.3
+	github.com/labstack/gommon v0.4.1
 	github.com/prometheus/client_golang v1.19.1
 	github.com/urfave/cli/v2 v2.27.7
 	github.com/whyrusleeping/market v0.0.0-20250711215409-cc684a207f15
···
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
-	github.com/labstack/gommon v0.4.1 // indirect
 	github.com/lestrrat-go/blackmagic v1.0.1 // indirect
 	github.com/lestrrat-go/httpcc v1.0.1 // indirect
 	github.com/lestrrat-go/httprc v1.0.4 // indirect

go.sum

···
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
 github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=

handlers.go

···
 
 	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	"github.com/bluesky-social/indigo/xrpc"
+	xrpclib "github.com/bluesky-social/indigo/xrpc"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	"github.com/labstack/gommon/log"
···
 	e := echo.New()
 	e.Use(middleware.CORS())
 	e.GET("/debug", s.handleGetDebugInfo)
+	e.GET("/reldids", s.handleGetRelevantDids)
 
 	views := e.Group("/api")
 	views.GET("/me", s.handleGetMe)
···
 
 	return e.JSON(200, map[string]any{
 		"seq": seq,
+	})
+}
+
+func (s *Server) handleGetRelevantDids(e echo.Context) error {
+	return e.JSON(200, map[string]any{
+		"dids": s.backend.relevantDids,
 	})
 }
 
···
 	}
 
 	var resp createRecordResponse
-	if err := s.client.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &resp); err != nil {
+	if err := s.client.Do(ctx, xrpclib.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &resp); err != nil {
 		slog.Error("failed to create record", "error", err)
 		return e.JSON(500, map[string]any{
 			"error":   "failed to create record",

hydration/actor.go

···
+package hydration
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+)
+
+// ActorInfo contains hydrated actor information
+type ActorInfo struct {
+	DID     string
+	Handle  string
+	Profile *bsky.ActorProfile
+}
+
+// HydrateActor hydrates full actor information
+func (h *Hydrator) HydrateActor(ctx context.Context, did string) (*ActorInfo, error) {
+	// Look up handle
+	resp, err := h.dir.LookupDID(ctx, syntax.DID(did))
+	if err != nil {
+		return nil, fmt.Errorf("failed to lookup DID: %w", err)
+	}
+
+	info := &ActorInfo{
+		DID:    did,
+		Handle: resp.Handle.String(),
+	}
+
+	// Load profile from database
+	var dbProfile struct {
+		Repo uint
+		Raw  []byte
+	}
+	err = h.db.Raw("SELECT repo, raw FROM profiles WHERE repo = (SELECT id FROM repos WHERE did = ?)", did).
+		Scan(&dbProfile).Error
+	if err != nil {
+		slog.Error("failed to fetch user profile", "error", err)
+	} else {
+		if len(dbProfile.Raw) > 0 {
+			var profile bsky.ActorProfile
+			if err := profile.UnmarshalCBOR(bytes.NewReader(dbProfile.Raw)); err == nil {
+				info.Profile = &profile
+			}
+		} else {
+			h.addMissingActor(did)
+		}
+	}
+
+	return info, nil
+}
+
+// HydrateActors hydrates multiple actors
+func (h *Hydrator) HydrateActors(ctx context.Context, dids []string) (map[string]*ActorInfo, error) {
+	result := make(map[string]*ActorInfo, len(dids))
+	for _, did := range dids {
+		info, err := h.HydrateActor(ctx, did)
+		if err != nil {
+			// Skip actors that fail to hydrate rather than failing the whole batch
+			continue
+		}
+		result[did] = info
+	}
+	return result, nil
+}
+
+// ResolveDID resolves a handle or DID to a DID
+func (h *Hydrator) ResolveDID(ctx context.Context, actor string) (string, error) {
+	// If it's already a DID, return it
+	if strings.HasPrefix(actor, "did:") {
+		return actor, nil
+	}
+
+	// Otherwise, resolve the handle
+	resp, err := h.dir.LookupHandle(ctx, syntax.Handle(actor))
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve handle: %w", err)
+	}
+
+	return resp.DID.String(), nil
+}

hydration/hydrator.go

···
+package hydration
+
+import (
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"gorm.io/gorm"
+)
+
+// Hydrator handles data hydration from the database
+type Hydrator struct {
+	db  *gorm.DB
+	dir identity.Directory
+
+	missingActorCallback func(string)
+	missingPostCallback  func(string)
+}
+
+// NewHydrator creates a new Hydrator
+func NewHydrator(db *gorm.DB, dir identity.Directory) *Hydrator {
+	return &Hydrator{
+		db:  db,
+		dir: dir,
+	}
+}
+
+func (h *Hydrator) SetMissingActorCallback(fn func(string)) {
+	h.missingActorCallback = fn
+}
+
+func (h *Hydrator) addMissingActor(did string) {
+	if h.missingActorCallback != nil {
+		h.missingActorCallback(did)
+	}
+}
+
+// HydrateCtx contains context for hydration operations
+type HydrateCtx struct {
+	Viewer string
+}
+
+// NewHydrateCtx creates a new hydration context
+func NewHydrateCtx(viewer string) *HydrateCtx {
+	return &HydrateCtx{
+		Viewer: viewer,
+	}
+}

hydration/post.go

···
+package hydration
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+)
+
+// PostInfo contains hydrated post information
+type PostInfo struct {
+	URI         string
+	Cid         string
+	Post        *bsky.FeedPost
+	Author      string // DID
+	ReplyTo     uint
+	ReplyToUsr  uint
+	InThread    uint
+	LikeCount   int
+	RepostCount int
+	ReplyCount  int
+	ViewerLike  string // URI of viewer's like, if any
+}
+
+const fakeCid = "bafyreiapw4hagb5ehqgoeho4v23vf7fhlqey4b7xvjpy76krgkqx7xlolu"
+
+// HydratePost hydrates a single post by URI
+func (h *Hydrator) HydratePost(ctx context.Context, uri string, viewerDID string) (*PostInfo, error) {
+	// Query post from database
+	var dbPost struct {
+		ID         uint
+		Cid        string
+		Raw        []byte
+		NotFound   bool
+		ReplyTo    uint
+		ReplyToUsr uint
+		InThread   uint
+		AuthorID   uint
+	}
+
+	err := h.db.Raw(`
+		SELECT p.id, p.cid, p.raw, p.not_found, p.reply_to, p.reply_to_usr, p.in_thread, p.author as author_id
+		FROM posts p
+		WHERE p.id = (
+			SELECT id FROM posts
+			WHERE author = (SELECT id FROM repos WHERE did = ?)
+			AND rkey = ?
+		)
+	`, extractDIDFromURI(uri), extractRkeyFromURI(uri)).Scan(&dbPost).Error
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to query post: %w", err)
+	}
+
+	if dbPost.NotFound || len(dbPost.Raw) == 0 {
+		return nil, fmt.Errorf("post not found")
+	}
+
+	// Unmarshal post record
+	var feedPost bsky.FeedPost
+	if err := feedPost.UnmarshalCBOR(bytes.NewReader(dbPost.Raw)); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal post: %w", err)
+	}
+
+	// Get author DID
+	var authorDID string
+	h.db.Raw("SELECT did FROM repos WHERE id = ?", dbPost.AuthorID).Scan(&authorDID)
+
+	// Get engagement counts
+	var likes, reposts, replies int
+	h.db.Raw("SELECT COUNT(*) FROM likes WHERE subject = ?", dbPost.ID).Scan(&likes)
+	h.db.Raw("SELECT COUNT(*) FROM reposts WHERE subject = ?", dbPost.ID).Scan(&reposts)
+	h.db.Raw("SELECT COUNT(*) FROM posts WHERE reply_to = ?", dbPost.ID).Scan(&replies)
+
+	info := &PostInfo{
+		URI:         uri,
+		Cid:         dbPost.Cid,
+		Post:        &feedPost,
+		Author:      authorDID,
+		ReplyTo:     dbPost.ReplyTo,
+		ReplyToUsr:  dbPost.ReplyToUsr,
+		InThread:    dbPost.InThread,
+		LikeCount:   likes,
+		RepostCount: reposts,
+		ReplyCount:  replies,
+	}
+
+	if info.Cid == "" {
+		slog.Error("MISSING CID", "uri", uri)
+		info.Cid = fakeCid
+	}
+
+	// Check if viewer liked this post
+	if viewerDID != "" {
+		var likeRkey string
+		h.db.Raw(`
+			SELECT l.rkey FROM likes l
+			WHERE l.subject = ?
+			AND l.author = (SELECT id FROM repos WHERE did = ?)
+		`, dbPost.ID, viewerDID).Scan(&likeRkey)
+		if likeRkey != "" {
+			info.ViewerLike = fmt.Sprintf("at://%s/app.bsky.feed.like/%s", viewerDID, likeRkey)
+		}
+	}
+
+	return info, nil
+}
+
+// HydratePosts hydrates multiple posts
+func (h *Hydrator) HydratePosts(ctx context.Context, uris []string, viewerDID string) (map[string]*PostInfo, error) {
+	result := make(map[string]*PostInfo, len(uris))
+	for _, uri := range uris {
+		info, err := h.HydratePost(ctx, uri, viewerDID)
+		if err != nil {
+			// Skip posts that fail to hydrate
+			continue
+		}
+		result[uri] = info
+	}
+	return result, nil
+}
+
+// Helper functions to extract DID and rkey from AT URI
+func extractDIDFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	parts := []rune(uri[5:])
+	for i, r := range parts {
+		if r == '/' {
+			return string(parts[:i])
+		}
+	}
+	return string(parts)
+}
+
+func extractRkeyFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	// Find last slash
+	for i := len(uri) - 1; i >= 5; i-- {
+		if uri[i] == '/' {
+			return uri[i+1:]
+		}
+	}
+	return ""
+}

main.go

···
 	"github.com/bluesky-social/indigo/cmd/relay/stream"
 	"github.com/bluesky-social/indigo/cmd/relay/stream/schedulers/parallel"
 	"github.com/bluesky-social/indigo/util/cliutil"
-	"github.com/bluesky-social/indigo/xrpc"
+	xrpclib "github.com/bluesky-social/indigo/xrpc"
 	"github.com/gorilla/websocket"
 	lru "github.com/hashicorp/golang-lru/v2"
+	"github.com/ipfs/go-cid"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/urfave/cli/v2"
+	"github.com/whyrusleeping/konbini/xrpc"
 	"gorm.io/gorm/logger"
 )
 
···
 		}
 		mydid := resp.DID.String()
 
-		cc := &xrpc.Client{
+		cc := &xrpclib.Client{
 			Host: resp.PDSEndpoint(),
 		}
 
···
 			return err
 		}
 
-		cc.Auth = &xrpc.AuthInfo{
+		cc.Auth = &xrpclib.AuthInfo{
 			AccessJwt:  nsess.AccessJwt,
 			Did:        mydid,
 			Handle:     nsess.Handle,
···
 			missingProfiles: make(chan string, 1024),
 			missingPosts:    make(chan string, 1024),
 		}
+		fmt.Println("MY DID: ", s.mydid)
 
 		pgb := &PostgresBackend{
 			relevantDids:  make(map[string]bool),
···
 			return fmt.Errorf("failed to load relevant dids set: %w", err)
 		}
 
+		// Start custom API server (for the custom frontend)
 		go func() {
 			if err := s.runApiServer(); err != nil {
 				fmt.Println("failed to start api server: ", err)
 			}
 		}()
 
+		// Start XRPC server (for official Bluesky app compatibility)
+		go func() {
+			xrpcServer := xrpc.NewServer(db, dir, pgb)
+			if err := xrpcServer.Start(":4446"); err != nil {
+				fmt.Println("failed to start XRPC server: ", err)
+			}
+		}()
+
+		// Start pprof server
 		go func() {
 			http.ListenAndServe(":4445", nil)
 		}()
···
 
 	dir identity.Directory
 
-	client *xrpc.Client
+	client *xrpclib.Client
 	mydid  string
 	myrepo *Repo
 
···
 	missingPosts    chan string
 }
 
-func (s *Server) getXrpcClient() (*xrpc.Client, error) {
+func (s *Server) getXrpcClient() (*xrpclib.Client, error) {
 	// TODO: handle refreshing the token periodically
 	return s.client, nil
 }
···
 	NotifKindRepost  = "repost"
 )
 
-func (s *Server) AddNotification(ctx context.Context, forUser, author uint, recordUri string, kind string) error {
+func (s *Server) AddNotification(ctx context.Context, forUser, author uint, recordUri string, recordCid cid.Cid, kind string) error {
 	return s.backend.db.Create(&Notification{
-		For:    forUser,
-		Author: author,
-		Source: recordUri,
-		Kind:   kind,
+		For:       forUser,
+		Author:    author,
+		Source:    recordUri,
+		SourceCid: recordCid.String(),
+		Kind:      kind,
 	}).Error
 }
+
+func (s *Server) rescanRepo(ctx context.Context, did string) error {
+	resp, err := s.dir.LookupDID(ctx, syntax.DID(did))
+	if err != nil {
+		return err
+	}
+
+	_ = resp
+	return nil
+
+}

missing.go

···
 	"github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	"github.com/bluesky-social/indigo/xrpc"
+	xrpclib "github.com/bluesky-social/indigo/xrpc"
 	"github.com/ipfs/go-cid"
 	"github.com/labstack/gommon/log"
 )
···
 		return err
 	}
 
-	c := &xrpc.Client{
+	c := &xrpclib.Client{
 		Host: resp.PDSEndpoint(),
 	}
 
···
 		return err
 	}
 
-	c := &xrpc.Client{
+	c := &xrpclib.Client{
 		Host: resp.PDSEndpoint(),
 	}
 

models.go

···
 	gorm.Model
 	For uint
 
-	Author uint
-	Source string
-	Kind   string
+	Author    uint
+	Source    string
+	SourceCid string
+	Kind      string
 }
 
 type SequenceTracker struct {

pgbackend.go

···
 
 	return &r, nil
 }
+
+func (b *PostgresBackend) TrackMissingActor(did string) {
+	b.s.addMissingProfile(context.TODO(), did)
+}

views/actor.go

···
+package views
+
+import (
+	"fmt"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/lex/util"
+	"github.com/whyrusleeping/konbini/hydration"
+)
+
+// ProfileViewBasic builds a basic profile view (app.bsky.actor.defs#profileViewBasic)
+func ProfileViewBasic(actor *hydration.ActorInfo) *bsky.ActorDefs_ProfileViewBasic {
+	view := &bsky.ActorDefs_ProfileViewBasic{
+		Did:    actor.DID,
+		Handle: actor.Handle,
+	}
+
+	if actor.Profile != nil {
+		if actor.Profile.DisplayName != nil && *actor.Profile.DisplayName != "" {
+			view.DisplayName = actor.Profile.DisplayName
+		}
+		if actor.Profile.Avatar != nil {
+			avatarURL := formatBlobRef(actor.DID, actor.Profile.Avatar)
+			if avatarURL != "" {
+				view.Avatar = &avatarURL
+			}
+		}
+	}
+
+	return view
+}
+
+// ProfileView builds a profile view (app.bsky.actor.defs#profileView)
+func ProfileView(actor *hydration.ActorInfo) *bsky.ActorDefs_ProfileView {
+	view := &bsky.ActorDefs_ProfileView{
+		Did:    actor.DID,
+		Handle: actor.Handle,
+	}
+
+	if actor.Profile != nil {
+		if actor.Profile.DisplayName != nil && *actor.Profile.DisplayName != "" {
+			view.DisplayName = actor.Profile.DisplayName
+		}
+		if actor.Profile.Description != nil && *actor.Profile.Description != "" {
+			view.Description = actor.Profile.Description
+		}
+		if actor.Profile.Avatar != nil {
+			avatarURL := formatBlobRef(actor.DID, actor.Profile.Avatar)
+			if avatarURL != "" {
+				view.Avatar = &avatarURL
+			}
+		}
+		// Note: CreatedAt is typically set on the profile record itself
+	}
+
+	return view
+}
+
+// ProfileViewDetailed builds a detailed profile view (app.bsky.actor.defs#profileViewDetailed)
+func ProfileViewDetailed(actor *hydration.ActorInfo, followerCount, followsCount, postsCount int) *bsky.ActorDefs_ProfileViewDetailed {
+	view := &bsky.ActorDefs_ProfileViewDetailed{
+		Did:    actor.DID,
+		Handle: actor.Handle,
+	}
+
+	if actor.Profile != nil {
+		if actor.Profile.DisplayName != nil && *actor.Profile.DisplayName != "" {
+			view.DisplayName = actor.Profile.DisplayName
+		}
+		if actor.Profile.Description != nil && *actor.Profile.Description != "" {
+			view.Description = actor.Profile.Description
+		}
+		if actor.Profile.Avatar != nil {
+			avatarURL := formatBlobRef(actor.DID, actor.Profile.Avatar)
+			if avatarURL != "" {
+				view.Avatar = &avatarURL
+			}
+		}
+		if actor.Profile.Banner != nil {
+			bannerURL := formatBlobRef(actor.DID, actor.Profile.Banner)
+			if bannerURL != "" {
+				view.Banner = &bannerURL
+			}
+		}
+	}
+
+	// Add counts
+	fc := int64(followerCount)
+	fsc := int64(followsCount)
+	pc := int64(postsCount)
+	view.FollowersCount = &fc
+	view.FollowsCount = &fsc
+	view.PostsCount = &pc
+
+	return view
+}
+
+func formatBlobRef(did string, blob *util.LexBlob) string {
+	return fmt.Sprintf("https://cdn.bsky.app/img/avatar_thumbnail/plain/%s/%s@jpeg", did, blob.Ref.String())
+}

views/feed.go

···
+package views
+
+import (
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/lex/util"
+	"github.com/whyrusleeping/konbini/hydration"
+)
+
+// PostView builds a post view (app.bsky.feed.defs#postView)
+func PostView(post *hydration.PostInfo, author *hydration.ActorInfo) *bsky.FeedDefs_PostView {
+	view := &bsky.FeedDefs_PostView{
+		LexiconTypeID: "app.bsky.feed.defs#postView",
+		Uri:           post.URI,
+		Cid:           post.Cid,
+		Author:        ProfileViewBasic(author),
+		Record: &util.LexiconTypeDecoder{
+			Val: post.Post,
+		},
+		IndexedAt: post.Post.CreatedAt, // Using createdAt as indexedAt for now
+	}
+
+	// Add engagement counts
+	if post.LikeCount > 0 {
+		lc := int64(post.LikeCount)
+		view.LikeCount = &lc
+	}
+	if post.RepostCount > 0 {
+		rc := int64(post.RepostCount)
+		view.RepostCount = &rc
+	}
+	if post.ReplyCount > 0 {
+		rpc := int64(post.ReplyCount)
+		view.ReplyCount = &rpc
+	}
+
+	// Add viewer state
+	if post.ViewerLike != "" {
+		view.Viewer = &bsky.FeedDefs_ViewerState{
+			Like: &post.ViewerLike,
+		}
+	}
+
+	// TODO: Add embed handling - need to convert embed types to proper views
+	// if post.Post.Embed != nil {
+	// 	view.Embed = formatEmbed(post.Post.Embed)
+	// }
+
+	return view
+}
+
+// FeedViewPost builds a feed view post (app.bsky.feed.defs#feedViewPost)
+func FeedViewPost(post *hydration.PostInfo, author *hydration.ActorInfo) *bsky.FeedDefs_FeedViewPost {
+	return &bsky.FeedDefs_FeedViewPost{
+		Post: PostView(post, author),
+	}
+}
+
+// ThreadViewPost builds a thread view post (app.bsky.feed.defs#threadViewPost)
+func ThreadViewPost(post *hydration.PostInfo, author *hydration.ActorInfo, parent, replies interface{}) *bsky.FeedDefs_ThreadViewPost {
+	view := &bsky.FeedDefs_ThreadViewPost{
+		LexiconTypeID: "app.bsky.feed.defs#threadViewPost",
+		Post:          PostView(post, author),
+	}
+
+	// TODO: Type parent and replies properly as union types
+	// For now leaving them as interface{} to be handled by handlers
+
+	return view
+}

xrpc/actor/getPreferences.go

···
+package actor
+
+import (
+	"net/http"
+
+	"github.com/bluesky-social/indigo/api/bsky"
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"gorm.io/gorm"
+)
+
+// HandleGetPreferences implements app.bsky.actor.getPreferences
+// This is typically a PDS endpoint, not an AppView endpoint.
+// For now, return empty preferences.
+func HandleGetPreferences(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	// Get viewer from authentication
+	viewer := c.Get("viewer")
+	if viewer == nil {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	out := bsky.ActorGetPreferences_Output{
+		Preferences: []bsky.ActorDefs_Preferences_Elem{
+			{
+				ActorDefs_AdultContentPref: &bsky.ActorDefs_AdultContentPref{
+					Enabled: true,
+				},
+			},
+			{
+				ActorDefs_ContentLabelPref: &bsky.ActorDefs_ContentLabelPref{
+					Label:      "nsfw",
+					Visibility: "warn",
+				},
+			},
+			/*
+				{
+					ActorDefs_LabelersPref: &bsky.ActorDefs_LabelersPref{
+						Labelers: []*bsky.ActorDefs_LabelerPrefItem{},
+					},
+				},
+			*/
+			{
+				ActorDefs_BskyAppStatePref: &bsky.ActorDefs_BskyAppStatePref{
+					Nuxs: []*bsky.ActorDefs_Nux{
+						{
+							Id:        "NeueTypography",
+							Completed: true,
+						},
+						{
+							Id:        "PolicyUpdate202508",
+							Completed: true,
+						},
+					},
+				},
+			},
+			{
+				ActorDefs_SavedFeedsPrefV2: &bsky.ActorDefs_SavedFeedsPrefV2{
+					Items: []*bsky.ActorDefs_SavedFeed{
+						{
+							Id:     "3m2k6cbfsq22n",
+							Pinned: true,
+							Type:   "timeline",
+							Value:  "following",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return c.JSON(http.StatusOK, out)
+}
+
+/*
+{
+            "nuxs": [
+                {
+                    "id": "TenMillionDialog",
+                    "completed": true
+                },
+                {
+                    "id": "NeueTypography",
+                    "completed": true
+                },
+                {
+                    "id": "NeueChar",
+                    "completed": true
+                },
+                {
+                    "id": "InitialVerificationAnnouncement",
+                    "completed": true
+                },
+                {
+                    "id": "ActivitySubscriptions",
+                    "completed": true
+                },
+                {
+                    "id": "BookmarksAnnouncement",
+                    "completed": true
+                },
+                {
+                    "id": "PolicyUpdate202508",
+                    "completed": true
+                }
+            ],
+            "$type": "app.bsky.actor.defs#bskyAppStatePref"
+        }
+*/

xrpc/actor/getProfile.go

···
+package actor
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+)
+
+// HandleGetProfile implements app.bsky.actor.getProfile
+func HandleGetProfile(c echo.Context, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve actor to DID
+	did, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Hydrate actor info
+	actorInfo, err := hydrator.HydrateActor(ctx, did)
+	if err != nil {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "failed to load actor",
+		})
+	}
+
+	// Get follower/follows/posts counts
+	// TODO: These queries should be optimized
+	var followerCount, followsCount, postsCount int
+
+	// We'll return 0 for now - can optimize later
+	followerCount = 0
+	followsCount = 0
+	postsCount = 0
+
+	// Build response
+	profile := views.ProfileViewDetailed(actorInfo, followerCount, followsCount, postsCount)
+
+	return c.JSON(http.StatusOK, profile)
+}

xrpc/actor/getProfiles.go

···
+package actor
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetProfiles implements app.bsky.actor.getProfiles
+func HandleGetProfiles(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	// Parse actors parameter (can be multiple)
+	actors := c.QueryParams()["actors"]
+	if len(actors) == 0 {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actors parameter is required",
+		})
+	}
+
+	// Limit to reasonable batch size
+	if len(actors) > 25 {
+		actors = actors[:25]
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve all actors to DIDs and hydrate profiles
+	profiles := make([]interface{}, 0)
+	for _, actor := range actors {
+		// Resolve actor to DID
+		did, err := hydrator.ResolveDID(ctx, actor)
+		if err != nil {
+			// Skip actors that can't be resolved
+			continue
+		}
+
+		// Hydrate actor info
+		actorInfo, err := hydrator.HydrateActor(ctx, did)
+		if err != nil {
+			// Skip actors that can't be hydrated
+			continue
+		}
+
+		// Get counts for the profile
+		type counts struct {
+			Followers int
+			Follows   int
+			Posts     int
+		}
+		var c counts
+		db.Raw(`
+			SELECT
+				(SELECT COUNT(*) FROM follows WHERE subject = (SELECT id FROM repos WHERE did = ?)) as followers,
+				(SELECT COUNT(*) FROM follows WHERE author = (SELECT id FROM repos WHERE did = ?)) as follows,
+				(SELECT COUNT(*) FROM posts WHERE author = (SELECT id FROM repos WHERE did = ?)) as posts
+		`, did, did, did).Scan(&c)
+
+		profiles = append(profiles, views.ProfileViewDetailed(actorInfo, c.Followers, c.Follows, c.Posts))
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"profiles": profiles,
+	})
+}

xrpc/actor/putPreferences.go

···
+package actor
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"gorm.io/gorm"
+)
+
+// HandlePutPreferences implements app.bsky.actor.putPreferences
+// Stubbed out for now - just returns success without doing anything
+func HandlePutPreferences(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	// Get viewer from authentication
+	viewer := c.Get("viewer")
+	if viewer == nil {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// For now, just return success without storing anything
+	return c.JSON(http.StatusOK, map[string]interface{}{})
+}

xrpc/auth.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/labstack/echo/v4"
+	"github.com/lestrrat-go/jwx/v2/jwt"
+)
+
+// requireAuth is middleware that requires authentication
+func (s *Server) requireAuth(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		viewer, err := s.authenticate(c)
+		if err != nil {
+			return XRPCError(c, http.StatusUnauthorized, "AuthenticationRequired", err.Error())
+		}
+		c.Set("viewer", viewer)
+		return next(c)
+	}
+}
+
+// optionalAuth is middleware that optionally authenticates
+func (s *Server) optionalAuth(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		viewer, _ := s.authenticate(c)
+		if viewer != "" {
+			c.Set("viewer", viewer)
+		}
+		return next(c)
+	}
+}
+
+// authenticate extracts and validates the JWT from the Authorization header
+// Returns the viewer DID if valid, empty string otherwise
+func (s *Server) authenticate(c echo.Context) (string, error) {
+	authHeader := c.Request().Header.Get("Authorization")
+	if authHeader == "" {
+		return "", fmt.Errorf("missing authorization header")
+	}
+
+	// Extract Bearer token
+	parts := strings.Split(authHeader, " ")
+	if len(parts) != 2 || parts[0] != "Bearer" {
+		return "", fmt.Errorf("invalid authorization header format")
+	}
+
+	tokenString := parts[1]
+
+	// Parse JWT without signature validation (for development)
+	// In production, you'd want to validate the signature using the issuer's public key
+	token, err := jwt.Parse([]byte(tokenString), jwt.WithVerify(false), jwt.WithValidate(false))
+	if err != nil {
+		return "", fmt.Errorf("failed to parse token: %w", err)
+	}
+
+	// Extract the user's DID - try both "sub" (PDS tokens) and "iss" (service tokens)
+	var userDID string
+
+	// First try "sub" claim (used by PDS tokens and entryway tokens)
+	sub := token.Subject()
+	if sub != "" && strings.HasPrefix(sub, "did:") {
+		userDID = sub
+	} else {
+		// Fall back to "iss" claim (used by some service tokens)
+		iss := token.Issuer()
+		if iss != "" && strings.HasPrefix(iss, "did:") {
+			userDID = iss
+		}
+	}
+
+	if userDID == "" {
+		return "", fmt.Errorf("missing 'sub' or 'iss' claim with DID in token")
+	}
+
+	// Optional: check scope if present
+	scope, ok := token.Get("scope")
+	if ok {
+		scopeStr, _ := scope.(string)
+		// Valid scopes are: com.atproto.access, com.atproto.appPass, com.atproto.appPassPrivileged
+		if scopeStr != "com.atproto.access" && scopeStr != "com.atproto.appPass" && scopeStr != "com.atproto.appPassPrivileged" {
+			return "", fmt.Errorf("invalid token scope: %s", scopeStr)
+		}
+	}
+
+	return userDID, nil
+}
+
+// resolveActor resolves an actor identifier (handle or DID) to a DID
+func (s *Server) resolveActor(ctx context.Context, actor string) (string, error) {
+	// If it's already a DID, return it
+	if strings.HasPrefix(actor, "did:") {
+		return actor, nil
+	}
+
+	// Otherwise, resolve the handle
+	resp, err := s.dir.LookupHandle(ctx, syntax.Handle(actor))
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve handle: %w", err)
+	}
+
+	return resp.DID.String(), nil
+}

xrpc/feed/getActorLikes.go

···
+package feed
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetActorLikes implements app.bsky.feed.getActorLikes
+func HandleGetActorLikes(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve actor to DID
+	actorDID, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Check authentication - user can only view their own likes
+	viewer := c.Get("viewer")
+	if viewer == nil || viewer.(string) != actorDID {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "you can only view your own likes",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (like ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	// Query likes
+	type likeRow struct {
+		ID      uint
+		Subject string // post URI
+	}
+	var rows []likeRow
+
+	query := `
+		SELECT l.id, 'at://' || r.did || '/app.bsky.feed.post/' || p.rkey as subject
+		FROM likes l
+		JOIN posts p ON p.id = l.subject
+		JOIN repos r ON r.id = p.author
+		WHERE l.author = (SELECT id FROM repos WHERE did = ?)
+	`
+	if cursor > 0 {
+		query += ` AND l.id < ?`
+	}
+	query += ` ORDER BY l.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, actorDID)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query likes",
+		})
+	}
+
+	// Hydrate posts
+	feed := make([]interface{}, 0)
+	for _, row := range rows {
+		postInfo, err := hydrator.HydratePost(ctx, row.Subject, actorDID)
+		if err != nil {
+			continue
+		}
+
+		// Hydrate the post author
+		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+		if err != nil {
+			continue
+		}
+
+		feed = append(feed, views.FeedViewPost(postInfo, authorInfo))
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"feed":   feed,
+		"cursor": nextCursor,
+	})
+}

xrpc/feed/getAuthorFeed.go

···
+package feed
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetAuthorFeed implements app.bsky.feed.getAuthorFeed
+func HandleGetAuthorFeed(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (timestamp)
+	cursor := time.Now()
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if t, err := time.Parse(time.RFC3339, cursorParam); err == nil {
+			cursor = t
+		}
+	}
+
+	// Parse filter (posts_with_replies, posts_no_replies, posts_with_media, etc.)
+	filter := c.QueryParam("filter")
+	if filter == "" {
+		filter = "posts_with_replies" // default
+	}
+
+	ctx := c.Request().Context()
+	viewer := getUserDID(c)
+
+	// Resolve actor to DID
+	did, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Build query based on filter
+	var query string
+	switch filter {
+	case "posts_no_replies", "posts_and_author_threads":
+		query = `
+			SELECT
+				'at://' || r.did || '/app.bsky.feed.post/' || p.rkey as uri,
+				p.author as author_id
+			FROM posts p
+			JOIN repos r ON r.id = p.author
+			WHERE p.author = (SELECT id FROM repos WHERE did = ?)
+			AND p.reply_to = 0
+			AND p.created < ?
+			AND p.not_found = false
+			ORDER BY p.created DESC
+			LIMIT ?
+		`
+	default: // posts_with_replies
+		query = `
+			SELECT
+				'at://' || r.did || '/app.bsky.feed.post/' || p.rkey as uri,
+				p.author as author_id
+			FROM posts p
+			JOIN repos r ON r.id = p.author
+			WHERE p.author = (SELECT id FROM repos WHERE did = ?)
+			AND p.created < ?
+			AND p.not_found = false
+			ORDER BY p.created DESC
+			LIMIT ?
+		`
+	}
+
+	type postRow struct {
+		URI      string
+		AuthorID uint
+	}
+	var rows []postRow
+	if err := db.Raw(query, did, cursor, limit).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query author feed",
+		})
+	}
+
+	// Hydrate posts
+	feed := make([]interface{}, 0)
+	for _, row := range rows {
+		postInfo, err := hydrator.HydratePost(ctx, row.URI, viewer)
+		if err != nil {
+			continue
+		}
+
+		// Hydrate author
+		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+		if err != nil {
+			continue
+		}
+
+		feedItem := views.FeedViewPost(postInfo, authorInfo)
+		feed = append(feed, feedItem)
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		lastURI := rows[len(rows)-1].URI
+		postInfo, err := hydrator.HydratePost(ctx, lastURI, viewer)
+		if err == nil && postInfo.Post != nil {
+			t, err := time.Parse(time.RFC3339, postInfo.Post.CreatedAt)
+			if err == nil {
+				nextCursor = t.Format(time.RFC3339)
+			}
+		}
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"feed":   feed,
+		"cursor": nextCursor,
+	})
+}

xrpc/feed/getLikes.go

···
+package feed
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetLikes implements app.bsky.feed.getLikes
+func HandleGetLikes(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	uriParam := c.QueryParam("uri")
+	if uriParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "uri parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (like ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Get post ID from URI
+	var postID uint
+	db.Raw(`
+		SELECT id FROM posts
+		WHERE author = (SELECT id FROM repos WHERE did = ?)
+		AND rkey = ?
+	`, extractDIDFromURI(uriParam), extractRkeyFromURI(uriParam)).Scan(&postID)
+
+	if postID == 0 {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "post not found",
+		})
+	}
+
+	// Query likes
+	type likeRow struct {
+		ID        uint
+		AuthorDid string
+		Rkey      string
+		Created   string
+	}
+	var rows []likeRow
+
+	query := `
+		SELECT l.id, r.did as author_did, l.rkey, l.created
+		FROM likes l
+		JOIN repos r ON r.id = l.author
+		WHERE l.subject = ?
+	`
+	if cursor > 0 {
+		query += ` AND l.id < ?`
+	}
+	query += ` ORDER BY l.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, postID)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query likes",
+		})
+	}
+
+	// Hydrate actors
+	likes := make([]interface{}, 0)
+	for _, row := range rows {
+		actorInfo, err := hydrator.HydrateActor(ctx, row.AuthorDid)
+		if err != nil {
+			continue
+		}
+
+		like := map[string]interface{}{
+			"actor":     views.ProfileView(actorInfo),
+			"createdAt": row.Created,
+			"indexedAt": row.Created,
+		}
+		likes = append(likes, like)
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"uri":    uriParam,
+		"likes":  likes,
+		"cursor": nextCursor,
+	})
+}

xrpc/feed/getPostThread.go

···
+package feed
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetPostThread implements app.bsky.feed.getPostThread
+func HandleGetPostThread(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	uriParam := c.QueryParam("uri")
+	if uriParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "uri parameter is required",
+		})
+	}
+
+	ctx := c.Request().Context()
+	viewer := getUserDID(c)
+
+	// Hydrate the requested post
+	postInfo, err := hydrator.HydratePost(ctx, uriParam, viewer)
+	if err != nil {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "post not found",
+		})
+	}
+
+	// Determine the root post ID for the thread
+	rootPostID := postInfo.InThread
+	if rootPostID == 0 {
+		// This post is the root
+		// Query to find what the post's internal ID is
+		var postID uint
+		db.Raw(`
+			SELECT id FROM posts
+			WHERE author = (SELECT id FROM repos WHERE did = ?)
+			AND rkey = ?
+		`, extractDIDFromURI(uriParam), extractRkeyFromURI(uriParam)).Scan(&postID)
+		rootPostID = postID
+	}
+
+	// Query all posts in this thread
+	type threadPost struct {
+		ID         uint
+		Rkey       string
+		ReplyTo    uint
+		InThread   uint
+		AuthorDID  string
+	}
+	var threadPosts []threadPost
+	db.Raw(`
+		SELECT p.id, p.rkey, p.reply_to, p.in_thread, r.did as author_did
+		FROM posts p
+		JOIN repos r ON r.id = p.author
+		WHERE (p.id = ? OR p.in_thread = ?)
+		AND p.not_found = false
+		ORDER BY p.created ASC
+	`, rootPostID, rootPostID).Scan(&threadPosts)
+
+	// Build a map of posts by ID for easy lookup
+	postsByID := make(map[uint]*threadPostNode)
+	for _, tp := range threadPosts {
+		uri := fmt.Sprintf("at://%s/app.bsky.feed.post/%s", tp.AuthorDID, tp.Rkey)
+		postsByID[tp.ID] = &threadPostNode{
+			id:       tp.ID,
+			uri:      uri,
+			replyTo:  tp.ReplyTo,
+			inThread: tp.InThread,
+			replies:  []interface{}{},
+		}
+	}
+
+	// Build the thread tree structure
+	for _, node := range postsByID {
+		if node.replyTo != 0 {
+			parent := postsByID[node.replyTo]
+			if parent != nil {
+				parent.replies = append(parent.replies, node)
+			}
+		}
+	}
+
+	// Find the root node
+	var rootNode *threadPostNode
+	for _, node := range postsByID {
+		if node.inThread == 0 || node.id == rootPostID {
+			rootNode = node
+			break
+		}
+	}
+
+	if rootNode == nil {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "thread root not found",
+		})
+	}
+
+	// Build the response by traversing the tree
+	thread := buildThreadView(ctx, db, rootNode, postsByID, hydrator, viewer, nil)
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"thread": thread,
+	})
+}
+
+type threadPostNode struct {
+	id       uint
+	uri      string
+	replyTo  uint
+	inThread uint
+	replies  []interface{}
+}
+
+func buildThreadView(ctx context.Context, db *gorm.DB, node *threadPostNode, allNodes map[uint]*threadPostNode, hydrator *hydration.Hydrator, viewer string, parent interface{}) interface{} {
+	// Hydrate this post
+	postInfo, err := hydrator.HydratePost(ctx, node.uri, viewer)
+	if err != nil {
+		// Return a notFound post
+		return map[string]interface{}{
+			"$type": "app.bsky.feed.defs#notFoundPost",
+			"uri":   node.uri,
+		}
+	}
+
+	// Hydrate author
+	authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+	if err != nil {
+		return map[string]interface{}{
+			"$type": "app.bsky.feed.defs#notFoundPost",
+			"uri":   node.uri,
+		}
+	}
+
+	// Build replies
+	var replies []interface{}
+	for _, replyNode := range node.replies {
+		if rn, ok := replyNode.(*threadPostNode); ok {
+			replyView := buildThreadView(ctx, db, rn, allNodes, hydrator, viewer, nil)
+			replies = append(replies, replyView)
+		}
+	}
+
+	// Build the thread view post
+	var repliesForView interface{}
+	if len(replies) > 0 {
+		repliesForView = replies
+	}
+
+	return views.ThreadViewPost(postInfo, authorInfo, parent, repliesForView)
+}
+
+func extractDIDFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	parts := []rune(uri[5:])
+	for i, r := range parts {
+		if r == '/' {
+			return string(parts[:i])
+		}
+	}
+	return string(parts)
+}
+
+func extractRkeyFromURI(uri string) string {
+	// URI format: at://did:plc:xxx/collection/rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return ""
+	}
+	// Find last slash
+	for i := len(uri) - 1; i >= 5; i-- {
+		if uri[i] == '/' {
+			return uri[i+1:]
+		}
+	}
+	return ""
+}

xrpc/feed/getPosts.go

···
+package feed
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+)
+
+// HandleGetPosts implements app.bsky.feed.getPosts
+func HandleGetPosts(c echo.Context, hydrator *hydration.Hydrator) error {
+	// Get URIs from query params (can be multiple)
+	urisParam := c.QueryParam("uris")
+	if urisParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "uris parameter is required",
+		})
+	}
+
+	// Parse URIs (they come as a comma-separated list or as multiple query params)
+	var uris []string
+	if strings.Contains(urisParam, ",") {
+		uris = strings.Split(urisParam, ",")
+	} else {
+		// Check for multiple uri query params
+		uris = c.QueryParams()["uris"]
+		if len(uris) == 0 {
+			uris = []string{urisParam}
+		}
+	}
+
+	// Limit to reasonable number
+	if len(uris) > 25 {
+		uris = uris[:25]
+	}
+
+	ctx := c.Request().Context()
+	viewer := getUserDID(c)
+
+	// Hydrate posts
+	postsMap, err := hydrator.HydratePosts(ctx, uris, viewer)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to load posts",
+		})
+	}
+
+	// Build response - need to maintain order of requested URIs
+	posts := make([]interface{}, 0)
+	for _, uri := range uris {
+		postInfo, ok := postsMap[uri]
+		if !ok {
+			// Post not found, skip it
+			continue
+		}
+
+		// Hydrate author
+		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+		if err != nil {
+			continue
+		}
+
+		postView := views.PostView(postInfo, authorInfo)
+		posts = append(posts, postView)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"posts": posts,
+	})
+}
+
+func getUserDID(c echo.Context) string {
+	did := c.Get("viewer")
+	if did == nil {
+		return ""
+	}
+	if s, ok := did.(string); ok {
+		return s
+	}
+	return ""
+}

xrpc/feed/getRepostedBy.go

···
+package feed
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetRepostedBy implements app.bsky.feed.getRepostedBy
+func HandleGetRepostedBy(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	uriParam := c.QueryParam("uri")
+	if uriParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "uri parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (repost ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Get post ID from URI
+	var postID uint
+	db.Raw(`
+		SELECT id FROM posts
+		WHERE author = (SELECT id FROM repos WHERE did = ?)
+		AND rkey = ?
+	`, extractDIDFromURI(uriParam), extractRkeyFromURI(uriParam)).Scan(&postID)
+
+	if postID == 0 {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "NotFound",
+			"message": "post not found",
+		})
+	}
+
+	// Query reposts
+	type repostRow struct {
+		ID        uint
+		AuthorDid string
+		Rkey      string
+		Created   string
+	}
+	var rows []repostRow
+
+	query := `
+		SELECT rp.id, r.did as author_did, rp.rkey, rp.created
+		FROM reposts rp
+		JOIN repos r ON r.id = rp.author
+		WHERE rp.subject = ?
+	`
+	if cursor > 0 {
+		query += ` AND rp.id < ?`
+	}
+	query += ` ORDER BY rp.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, postID)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query reposts",
+		})
+	}
+
+	// Hydrate actors
+	repostedBy := make([]interface{}, 0)
+	for _, row := range rows {
+		actorInfo, err := hydrator.HydrateActor(ctx, row.AuthorDid)
+		if err != nil {
+			continue
+		}
+		repostedBy = append(repostedBy, views.ProfileView(actorInfo))
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"uri":        uriParam,
+		"repostedBy": repostedBy,
+		"cursor":     nextCursor,
+	})
+}

xrpc/feed/getTimeline.go

···
+package feed
+
+import (
+	"log/slog"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetTimeline implements app.bsky.feed.getTimeline
+func HandleGetTimeline(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	viewer := getUserDID(c)
+	if viewer == "" {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (timestamp)
+	cursor := time.Now()
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if t, err := time.Parse(time.RFC3339, cursorParam); err == nil {
+			cursor = t
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Get viewer's repo ID
+	var viewerRepoID uint
+	if err := db.Raw("SELECT id FROM repos WHERE did = ?", viewer).Scan(&viewerRepoID).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to load viewer",
+		})
+	}
+
+	// Query posts from followed users
+	type postRow struct {
+		URI      string
+		AuthorID uint
+	}
+	var rows []postRow
+	err := db.Raw(`
+		SELECT
+			'at://' || r.did || '/app.bsky.feed.post/' || p.rkey as uri,
+			p.author as author_id
+		FROM posts p
+		JOIN repos r ON r.id = p.author
+		WHERE p.reply_to = 0
+		AND p.author IN (SELECT subject FROM follows WHERE author = ?)
+		AND p.created < ?
+		AND p.not_found = false
+		ORDER BY p.created DESC
+		LIMIT ?
+	`, viewerRepoID, cursor, limit).Scan(&rows).Error
+
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query timeline",
+		})
+	}
+
+	// Hydrate posts
+	feed := make([]interface{}, 0)
+	for _, row := range rows {
+		postInfo, err := hydrator.HydratePost(ctx, row.URI, viewer)
+		if err != nil {
+			continue
+		}
+
+		// Hydrate author
+		authorInfo, err := hydrator.HydrateActor(ctx, postInfo.Author)
+		if err != nil {
+			slog.Error("failed to hydrate actor", "author", postInfo.Author, "error", err)
+			continue
+		}
+
+		feedItem := views.FeedViewPost(postInfo, authorInfo)
+		feed = append(feed, feedItem)
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		// Get the created time of the last post
+		var lastCreated time.Time
+		lastURI := rows[len(rows)-1].URI
+		postInfo, err := hydrator.HydratePost(ctx, lastURI, viewer)
+		if err == nil && postInfo.Post != nil {
+			t, err := time.Parse(time.RFC3339, postInfo.Post.CreatedAt)
+			if err == nil {
+				lastCreated = t
+				nextCursor = lastCreated.Format(time.RFC3339)
+			}
+		}
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"feed":   feed,
+		"cursor": nextCursor,
+	})
+}

xrpc/graph/getBlocks.go

···
+package graph
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetBlocks implements app.bsky.graph.getBlocks
+func HandleGetBlocks(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	// Get viewer from authentication
+	viewer := c.Get("viewer")
+	if viewer == nil {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+	viewerDID := viewer.(string)
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (block ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Query blocks
+	type blockRow struct {
+		ID         uint
+		SubjectDid string
+	}
+	var rows []blockRow
+
+	query := `
+		SELECT b.id, r.did as subject_did
+		FROM blocks b
+		LEFT JOIN repos r ON r.id = b.subject
+		WHERE b.author = (SELECT id FROM repos WHERE did = ?)
+	`
+	if cursor > 0 {
+		query += ` AND b.id < ?`
+	}
+	query += ` ORDER BY b.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, viewerDID)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query blocks",
+		})
+	}
+
+	// Hydrate blocked actors
+	blocks := make([]interface{}, 0)
+	for _, row := range rows {
+		actorInfo, err := hydrator.HydrateActor(ctx, row.SubjectDid)
+		if err != nil {
+			fmt.Println("Hydrating actor failed: ", err)
+			continue
+		}
+		blocks = append(blocks, views.ProfileView(actorInfo))
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"blocks": blocks,
+		"cursor": nextCursor,
+	})
+}

xrpc/graph/getFollowers.go

···
+package graph
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetFollowers implements app.bsky.graph.getFollowers
+func HandleGetFollowers(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (follow ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve actor to DID
+	did, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Get the subject actor info
+	subjectInfo, err := hydrator.HydrateActor(ctx, did)
+	if err != nil {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "failed to load actor",
+		})
+	}
+
+	// Query followers
+	type followerRow struct {
+		ID        uint
+		AuthorDid string
+	}
+	var rows []followerRow
+
+	query := `
+		SELECT f.id, r.did as author_did
+		FROM follows f
+		JOIN repos r ON r.id = f.author
+		WHERE f.subject = (SELECT id FROM repos WHERE did = ?)
+	`
+	if cursor > 0 {
+		query += ` AND f.id < ?`
+	}
+	query += ` ORDER BY f.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, did)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query followers",
+		})
+	}
+
+	// Hydrate follower actors
+	followers := make([]interface{}, 0)
+	for _, row := range rows {
+		actorInfo, err := hydrator.HydrateActor(ctx, row.AuthorDid)
+		if err != nil {
+			continue
+		}
+		followers = append(followers, views.ProfileView(actorInfo))
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"subject":   views.ProfileView(subjectInfo),
+		"followers": followers,
+		"cursor":    nextCursor,
+	})
+}

xrpc/graph/getFollows.go

···
+package graph
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleGetFollows implements app.bsky.graph.getFollows
+func HandleGetFollows(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (follow ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve actor to DID
+	did, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Get the subject actor info (the person whose follows we're listing)
+	subjectInfo, err := hydrator.HydrateActor(ctx, did)
+	if err != nil {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "failed to load actor",
+		})
+	}
+
+	// Query follows
+	type followRow struct {
+		ID         uint
+		SubjectDid string
+	}
+	var rows []followRow
+
+	query := `
+		SELECT f.id, r.did as subject_did
+		FROM follows f
+		JOIN repos r ON r.id = f.subject
+		WHERE f.author = (SELECT id FROM repos WHERE did = ?)
+	`
+	if cursor > 0 {
+		query += ` AND f.id < ?`
+	}
+	query += ` ORDER BY f.id DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, did)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query follows",
+		})
+	}
+
+	// Hydrate followed actors
+	follows := make([]interface{}, 0)
+	for _, row := range rows {
+		actorInfo, err := hydrator.HydrateActor(ctx, row.SubjectDid)
+		if err != nil {
+			continue
+		}
+		follows = append(follows, views.ProfileView(actorInfo))
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"subject": views.ProfileView(subjectInfo),
+		"follows": follows,
+		"cursor":  nextCursor,
+	})
+}

xrpc/graph/getMutes.go

···
+package graph
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"gorm.io/gorm"
+)
+
+// HandleGetMutes implements app.bsky.graph.getMutes
+// NOTE: Mutes are typically stored as user preferences/settings, not as repo records.
+// This implementation returns an empty list as mute tracking is not yet implemented
+// in the database schema.
+func HandleGetMutes(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	// Get viewer from authentication
+	viewer := c.Get("viewer")
+	if viewer == nil {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// TODO: Implement mute tracking in the database
+	// Mutes are different from blocks - they're typically stored as preferences
+	// rather than as repo records. Would need a new table like:
+	// CREATE TABLE user_mutes (
+	//   id SERIAL PRIMARY KEY,
+	//   actor_did TEXT NOT NULL,
+	//   muted_did TEXT NOT NULL,
+	//   created_at TIMESTAMP NOT NULL,
+	//   UNIQUE(actor_did, muted_did)
+	// );
+
+	// For now, return empty list
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"mutes":  []interface{}{},
+		"cursor": "",
+	})
+}

xrpc/graph/getRelationships.go

···
+package graph
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"gorm.io/gorm"
+)
+
+// HandleGetRelationships implements app.bsky.graph.getRelationships
+func HandleGetRelationships(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	actorParam := c.QueryParam("actor")
+	if actorParam == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "actor parameter is required",
+		})
+	}
+
+	// Parse others parameter (can be multiple)
+	others := c.QueryParams()["others"]
+	if len(others) == 0 {
+		return c.JSON(http.StatusOK, map[string]interface{}{
+			"actor":         actorParam,
+			"relationships": []interface{}{},
+		})
+	}
+
+	// Limit to reasonable batch size
+	if len(others) > 30 {
+		others = others[:30]
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve actor to DID
+	actorDID, err := hydrator.ResolveDID(ctx, actorParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "ActorNotFound",
+			"message": "actor not found",
+		})
+	}
+
+	// Build relationships for each "other" actor
+	relationships := make([]interface{}, 0, len(others))
+
+	for _, other := range others {
+		// Resolve other to DID
+		otherDID, err := hydrator.ResolveDID(ctx, other)
+		if err != nil {
+			// Actor not found
+			relationships = append(relationships, map[string]interface{}{
+				"$type":    "app.bsky.graph.defs#notFoundActor",
+				"actor":    other,
+				"notFound": true,
+			})
+			continue
+		}
+
+		// Check if actor follows other
+		var following string
+		err = db.Raw(`
+			SELECT 'at://' || r1.did || '/app.bsky.graph.follow/' || f.rkey as uri
+			FROM follows f
+			JOIN repos r1 ON r1.id = f.author
+			JOIN repos r2 ON r2.id = f.subject
+			WHERE r1.did = ? AND r2.did = ?
+			LIMIT 1
+		`, actorDID, otherDID).Scan(&following).Error
+		if err != nil {
+			following = ""
+		}
+
+		// Check if other follows actor
+		var followedBy string
+		err = db.Raw(`
+			SELECT 'at://' || r1.did || '/app.bsky.graph.follow/' || f.rkey as uri
+			FROM follows f
+			JOIN repos r1 ON r1.id = f.author
+			JOIN repos r2 ON r2.id = f.subject
+			WHERE r1.did = ? AND r2.did = ?
+			LIMIT 1
+		`, otherDID, actorDID).Scan(&followedBy).Error
+		if err != nil {
+			followedBy = ""
+		}
+
+		relationships = append(relationships, map[string]interface{}{
+			"$type":      "app.bsky.graph.defs#relationship",
+			"did":        otherDID,
+			"following":  following,
+			"followedBy": followedBy,
+		})
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"actor":         actorDID,
+		"relationships": relationships,
+	})
+}

xrpc/identity.go

···
+package xrpc
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/labstack/echo/v4"
+)
+
+// handleResolveHandle implements com.atproto.identity.resolveHandle
+func (s *Server) handleResolveHandle(c echo.Context) error {
+	handle := c.QueryParam("handle")
+	if handle == "" {
+		return XRPCError(c, http.StatusBadRequest, "InvalidRequest", "handle parameter is required")
+	}
+
+	// Clean up handle (remove @ prefix if present)
+	handle = strings.TrimPrefix(handle, "@")
+
+	// Resolve handle to DID
+	resp, err := s.dir.LookupHandle(c.Request().Context(), syntax.Handle(handle))
+	if err != nil {
+		return XRPCError(c, http.StatusBadRequest, "HandleNotFound", "handle not found")
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"did": resp.DID.String(),
+	})
+}

xrpc/labeler/getServices.go

···
+package labeler
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+// HandleGetServices implements app.bsky.labeler.getServices
+// Returns information about labeler services
+func HandleGetServices(c echo.Context) error {
+	// For now, return empty views since we don't have labeler support
+	// A full implementation would parse the "dids" query parameter
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"views": []interface{}{},
+	})
+}

xrpc/notification/listNotifications.go

···
+package notification
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/views"
+	"gorm.io/gorm"
+)
+
+// HandleListNotifications implements app.bsky.notification.listNotifications
+func HandleListNotifications(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	viewer := getUserDID(c)
+	if viewer == "" {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// Parse limit
+	limit := 50
+	if limitParam := c.QueryParam("limit"); limitParam != "" {
+		if l, err := strconv.Atoi(limitParam); err == nil && l > 0 && l <= 100 {
+			limit = l
+		}
+	}
+
+	// Parse cursor (notification ID)
+	var cursor uint
+	if cursorParam := c.QueryParam("cursor"); cursorParam != "" {
+		if c, err := strconv.ParseUint(cursorParam, 10, 64); err == nil {
+			cursor = uint(c)
+		}
+	}
+
+	ctx := c.Request().Context()
+
+	// Query notifications for viewer with CIDs from source records
+	type notifRow struct {
+		ID        uint
+		Kind      string
+		AuthorDid string
+		Source    string
+		SourceCid string
+		CreatedAt string
+	}
+	var rows []notifRow
+
+	// This query tries to fetch the CID from the source record
+	// depending on the notification kind (like, repost, reply, etc.)
+	query := `
+		SELECT
+			n.id,
+			n.kind,
+			r.did as author_did,
+			n.source,
+			n.source_cid,
+			n.created_at
+		FROM notifications n
+		JOIN repos r ON r.id = n.author
+		LEFT JOIN repos r2 ON r2.id = n.author
+		WHERE n.for = (SELECT id FROM repos WHERE did = ?)
+	`
+	if cursor > 0 {
+		query += ` AND n.id < ?`
+	}
+	query += ` ORDER BY n.created_at DESC LIMIT ?`
+
+	var queryArgs []interface{}
+	queryArgs = append(queryArgs, viewer)
+	if cursor > 0 {
+		queryArgs = append(queryArgs, cursor)
+	}
+	queryArgs = append(queryArgs, limit)
+
+	if err := db.Raw(query, queryArgs...).Scan(&rows).Error; err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error":   "InternalError",
+			"message": "failed to query notifications",
+		})
+	}
+
+	// Hydrate notifications
+	notifications := make([]interface{}, 0)
+	for _, row := range rows {
+		authorInfo, err := hydrator.HydrateActor(ctx, row.AuthorDid)
+		if err != nil {
+			continue
+		}
+
+		notif := map[string]interface{}{
+			"uri":       row.Source,
+			"author":    views.ProfileView(authorInfo),
+			"reason":    mapNotifKind(row.Kind),
+			"record":    nil, // Could hydrate the source record here
+			"isRead":    false,
+			"indexedAt": row.CreatedAt,
+			"labels":    []interface{}{},
+		}
+
+		// Only include CID if we have one (required field)
+		if row.SourceCid != "" {
+			notif["cid"] = row.SourceCid
+		} else {
+			// Skip notifications without CIDs as they're invalid
+			continue
+		}
+
+		notifications = append(notifications, notif)
+	}
+
+	// Generate next cursor
+	var nextCursor string
+	if len(rows) > 0 {
+		nextCursor = strconv.FormatUint(uint64(rows[len(rows)-1].ID), 10)
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"notifications": notifications,
+		"cursor":        nextCursor,
+	})
+}
+
+// HandleGetUnreadCount implements app.bsky.notification.getUnreadCount
+func HandleGetUnreadCount(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	viewer := getUserDID(c)
+	if viewer == "" {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// For now, return 0 - we'd need to track read state in the database
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"count": 0,
+	})
+}
+
+// HandleUpdateSeen implements app.bsky.notification.updateSeen
+func HandleUpdateSeen(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	viewer := getUserDID(c)
+	if viewer == "" {
+		return c.JSON(http.StatusUnauthorized, map[string]interface{}{
+			"error":   "AuthenticationRequired",
+			"message": "authentication required",
+		})
+	}
+
+	// For now, just return success - we'd need to track seen timestamps in the database
+	return c.JSON(http.StatusOK, map[string]interface{}{})
+}
+
+func getUserDID(c echo.Context) string {
+	did := c.Get("viewer")
+	if did == nil {
+		return ""
+	}
+	if s, ok := did.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func mapNotifKind(kind string) string {
+	switch kind {
+	case "reply":
+		return "reply"
+	case "like":
+		return "like"
+	case "repost":
+		return "repost"
+	case "mention":
+		return "mention"
+	default:
+		return kind
+	}
+}

xrpc/repo/getRecord.go

···
+package repo
+
+import (
+	"fmt"
+	"net/http"
+
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/labstack/echo/v4"
+	"github.com/whyrusleeping/konbini/hydration"
+	"gorm.io/gorm"
+)
+
+// HandleGetRecord implements com.atproto.repo.getRecord
+func HandleGetRecord(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
+	repoParam := c.QueryParam("repo")
+	collection := c.QueryParam("collection")
+	rkey := c.QueryParam("rkey")
+	cidParam := c.QueryParam("cid")
+
+	if repoParam == "" || collection == "" || rkey == "" {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": "repo, collection, and rkey parameters are required",
+		})
+	}
+
+	ctx := c.Request().Context()
+
+	// Resolve repo to DID
+	repoDID, err := hydrator.ResolveDID(ctx, repoParam)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": fmt.Sprintf("could not find repo: %s", repoParam),
+		})
+	}
+
+	// Build URI
+	uri := fmt.Sprintf("at://%s/%s/%s", repoDID, collection, rkey)
+
+	// Query the record based on collection type
+	var recordCID string
+	var recordRaw []byte
+
+	switch collection {
+	case "app.bsky.feed.post":
+		type postRecord struct {
+			CID string
+			Raw []byte
+		}
+		var post postRecord
+		err = db.Raw(`
+			SELECT COALESCE(p.cid, '') as cid, p.raw
+			FROM posts p
+			JOIN repos r ON r.id = p.author
+			WHERE r.did = ? AND p.rkey = ?
+			LIMIT 1
+		`, repoDID, rkey).Scan(&post).Error
+		if err != nil || len(post.Raw) == 0 {
+			return c.JSON(http.StatusNotFound, map[string]interface{}{
+				"error":   "RecordNotFound",
+				"message": fmt.Sprintf("could not locate record: %s", uri),
+			})
+		}
+		recordCID = post.CID // May be empty
+		recordRaw = post.Raw
+
+	case "app.bsky.actor.profile":
+		type profileRecord struct {
+			CID string
+			Raw []byte
+		}
+		var profile profileRecord
+		err = db.Raw(`
+			SELECT p.cid, p.raw
+			FROM profiles p
+			JOIN repos r ON r.id = p.repo
+			WHERE r.did = ? AND p.rkey = ?
+		`, repoDID, rkey).Scan(&profile).Error
+		if err != nil || profile.CID == "" {
+			return c.JSON(http.StatusNotFound, map[string]interface{}{
+				"error":   "RecordNotFound",
+				"message": fmt.Sprintf("could not locate record: %s", uri),
+			})
+		}
+		recordCID = profile.CID
+		recordRaw = profile.Raw
+
+	case "app.bsky.graph.follow":
+		type followRecord struct {
+			CID string
+			Raw []byte
+		}
+		var follow followRecord
+		err = db.Raw(`
+			SELECT f.cid, f.raw
+			FROM follows f
+			JOIN repos r ON r.id = f.author
+			WHERE r.did = ? AND f.rkey = ?
+		`, repoDID, rkey).Scan(&follow).Error
+		if err != nil || follow.CID == "" {
+			return c.JSON(http.StatusNotFound, map[string]interface{}{
+				"error":   "RecordNotFound",
+				"message": fmt.Sprintf("could not locate record: %s", uri),
+			})
+		}
+		recordCID = follow.CID
+		recordRaw = follow.Raw
+
+	case "app.bsky.feed.like":
+		type likeRecord struct {
+			CID string
+			Raw []byte
+		}
+		var like likeRecord
+		err = db.Raw(`
+			SELECT l.cid, l.raw
+			FROM likes l
+			JOIN repos r ON r.id = l.author
+			WHERE r.did = ? AND l.rkey = ?
+		`, repoDID, rkey).Scan(&like).Error
+		if err != nil || like.CID == "" {
+			return c.JSON(http.StatusNotFound, map[string]interface{}{
+				"error":   "RecordNotFound",
+				"message": fmt.Sprintf("could not locate record: %s", uri),
+			})
+		}
+		recordCID = like.CID
+		recordRaw = like.Raw
+
+	case "app.bsky.feed.repost":
+		type repostRecord struct {
+			CID string
+			Raw []byte
+		}
+		var repost repostRecord
+		err = db.Raw(`
+			SELECT rp.cid, rp.raw
+			FROM reposts rp
+			JOIN repos r ON r.id = rp.author
+			WHERE r.did = ? AND rp.rkey = ?
+		`, repoDID, rkey).Scan(&repost).Error
+		if err != nil || repost.CID == "" {
+			return c.JSON(http.StatusNotFound, map[string]interface{}{
+				"error":   "RecordNotFound",
+				"message": fmt.Sprintf("could not locate record: %s", uri),
+			})
+		}
+		recordCID = repost.CID
+		recordRaw = repost.Raw
+
+	default:
+		return c.JSON(http.StatusBadRequest, map[string]interface{}{
+			"error":   "InvalidRequest",
+			"message": fmt.Sprintf("unsupported collection: %s", collection),
+		})
+	}
+
+	// Check CID if provided
+	if cidParam != "" && recordCID != cidParam {
+		return c.JSON(http.StatusNotFound, map[string]interface{}{
+			"error":   "RecordNotFound",
+			"message": fmt.Sprintf("could not locate record: %s", uri),
+		})
+	}
+
+	// Decode the CBOR record
+	// For now, return a placeholder - full CBOR decoding would require
+	// type-specific unmarshalers for each collection type
+	var value interface{}
+	if len(recordRaw) > 0 {
+		rec, err := lexutil.CborDecodeValue(recordRaw)
+		if err != nil {
+			return err
+		}
+
+		value = rec
+	}
+
+	// Suppress unused import warning
+	_ = cbg.CborNull
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"uri":   uri,
+		"cid":   recordCID,
+		"value": value,
+	})
+}

xrpc/server.go

···
+package xrpc
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"github.com/whyrusleeping/konbini/hydration"
+	"github.com/whyrusleeping/konbini/xrpc/actor"
+	"github.com/whyrusleeping/konbini/xrpc/feed"
+	"github.com/whyrusleeping/konbini/xrpc/graph"
+	"github.com/whyrusleeping/konbini/xrpc/labeler"
+	"github.com/whyrusleeping/konbini/xrpc/notification"
+	"github.com/whyrusleeping/konbini/xrpc/repo"
+	"github.com/whyrusleeping/konbini/xrpc/unspecced"
+	"gorm.io/gorm"
+)
+
+// Server represents the XRPC API server
+type Server struct {
+	e        *echo.Echo
+	db       *gorm.DB
+	dir      identity.Directory
+	backend  Backend
+	hydrator *hydration.Hydrator
+}
+
+// Backend interface for data access
+type Backend interface {
+	// Add methods as needed for data access
+
+	TrackMissingActor(did string)
+}
+
+// NewServer creates a new XRPC server
+func NewServer(db *gorm.DB, dir identity.Directory, backend Backend) *Server {
+	e := echo.New()
+	e.HidePort = true
+	e.HideBanner = true
+
+	// CORS middleware
+	e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
+		AllowOrigins: []string{"*"},
+		AllowMethods: []string{http.MethodGet, http.MethodPost, http.MethodOptions},
+		AllowHeaders: []string{"*"},
+	}))
+
+	// Logging middleware
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+
+	s := &Server{
+		e:        e,
+		db:       db,
+		dir:      dir,
+		backend:  backend,
+		hydrator: hydration.NewHydrator(db, dir),
+	}
+
+	s.hydrator.SetMissingActorCallback(backend.TrackMissingActor)
+
+	// Register XRPC endpoints
+	s.registerEndpoints()
+
+	return s
+}
+
+// Start starts the XRPC server
+func (s *Server) Start(addr string) error {
+	slog.Info("starting XRPC server", "addr", addr)
+	return s.e.Start(addr)
+}
+
+// registerEndpoints registers all XRPC endpoints
+func (s *Server) registerEndpoints() {
+	// XRPC endpoints follow the pattern: /xrpc/<namespace>.<method>
+	xrpcGroup := s.e.Group("/xrpc")
+
+	// com.atproto.identity.*
+	xrpcGroup.GET("/com.atproto.identity.resolveHandle", s.handleResolveHandle)
+
+	// com.atproto.repo.*
+	xrpcGroup.GET("/com.atproto.repo.getRecord", func(c echo.Context) error {
+		return repo.HandleGetRecord(c, s.db, s.hydrator)
+	})
+
+	// app.bsky.actor.*
+	xrpcGroup.GET("/app.bsky.actor.getProfile", func(c echo.Context) error {
+		return actor.HandleGetProfile(c, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.actor.getProfiles", func(c echo.Context) error {
+		return actor.HandleGetProfiles(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.actor.getPreferences", func(c echo.Context) error {
+		return actor.HandleGetPreferences(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.POST("/app.bsky.actor.putPreferences", func(c echo.Context) error {
+		return actor.HandlePutPreferences(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.actor.searchActors", s.handleSearchActors)
+	xrpcGroup.GET("/app.bsky.actor.searchActorsTypeahead", s.handleSearchActorsTypeahead)
+
+	// app.bsky.feed.*
+	xrpcGroup.GET("/app.bsky.feed.getTimeline", func(c echo.Context) error {
+		return feed.HandleGetTimeline(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.feed.getAuthorFeed", func(c echo.Context) error {
+		return feed.HandleGetAuthorFeed(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getPostThread", func(c echo.Context) error {
+		return feed.HandleGetPostThread(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getPosts", func(c echo.Context) error {
+		return feed.HandleGetPosts(c, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getLikes", func(c echo.Context) error {
+		return feed.HandleGetLikes(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getRepostedBy", func(c echo.Context) error {
+		return feed.HandleGetRepostedBy(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.feed.getActorLikes", func(c echo.Context) error {
+		return feed.HandleGetActorLikes(c, s.db, s.hydrator)
+	}, s.requireAuth)
+
+	// app.bsky.graph.*
+	xrpcGroup.GET("/app.bsky.graph.getFollows", func(c echo.Context) error {
+		return graph.HandleGetFollows(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.graph.getFollowers", func(c echo.Context) error {
+		return graph.HandleGetFollowers(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.graph.getBlocks", func(c echo.Context) error {
+		return graph.HandleGetBlocks(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.graph.getMutes", func(c echo.Context) error {
+		return graph.HandleGetMutes(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.graph.getRelationships", func(c echo.Context) error {
+		return graph.HandleGetRelationships(c, s.db, s.hydrator)
+	})
+	xrpcGroup.GET("/app.bsky.graph.getLists", s.handleGetLists)
+	xrpcGroup.GET("/app.bsky.graph.getList", s.handleGetList)
+
+	// app.bsky.notification.*
+	xrpcGroup.GET("/app.bsky.notification.listNotifications", func(c echo.Context) error {
+		return notification.HandleListNotifications(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.GET("/app.bsky.notification.getUnreadCount", func(c echo.Context) error {
+		return notification.HandleGetUnreadCount(c, s.db, s.hydrator)
+	}, s.requireAuth)
+	xrpcGroup.POST("/app.bsky.notification.updateSeen", func(c echo.Context) error {
+		return notification.HandleUpdateSeen(c, s.db, s.hydrator)
+	}, s.requireAuth)
+
+	// app.bsky.labeler.*
+	xrpcGroup.GET("/app.bsky.labeler.getServices", func(c echo.Context) error {
+		return labeler.HandleGetServices(c)
+	})
+
+	// app.bsky.unspecced.*
+	xrpcGroup.GET("/app.bsky.unspecced.getConfig", func(c echo.Context) error {
+		return unspecced.HandleGetConfig(c)
+	})
+	xrpcGroup.GET("/app.bsky.unspecced.getTrendingTopics", func(c echo.Context) error {
+		return unspecced.HandleGetTrendingTopics(c)
+	})
+}
+
+// XRPCError creates a properly formatted XRPC error response
+func XRPCError(c echo.Context, statusCode int, errType, message string) error {
+	return c.JSON(statusCode, map[string]interface{}{
+		"error":   errType,
+		"message": message,
+	})
+}
+
+// getUserDID extracts the viewer DID from the request context
+// Returns empty string if not authenticated
+func getUserDID(c echo.Context) string {
+	did := c.Get("viewer")
+	if did == nil {
+		return ""
+	}
+	if s, ok := did.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func (s *Server) handleSearchActors(c echo.Context) error {
+	return XRPCError(c, http.StatusNotImplemented, "NotImplemented", "Not yet implemented")
+}
+
+func (s *Server) handleSearchActorsTypeahead(c echo.Context) error {
+	return XRPCError(c, http.StatusNotImplemented, "NotImplemented", "Not yet implemented")
+}
+
+func (s *Server) handleGetLists(c echo.Context) error {
+	return XRPCError(c, http.StatusNotImplemented, "NotImplemented", "Not yet implemented")
+}
+
+func (s *Server) handleGetList(c echo.Context) error {
+	return XRPCError(c, http.StatusNotImplemented, "NotImplemented", "Not yet implemented")
+}

xrpc/unspecced/getConfig.go

···
+package unspecced
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+// HandleGetConfig implements app.bsky.unspecced.getConfig
+// Returns basic configuration for the app
+func HandleGetConfig(c echo.Context) error {
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"checkEmailConfirmed": false,
+		"liveNow":             []any{},
+	})
+}

xrpc/unspecced/getTrendingTopics.go

···
+package unspecced
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+// HandleGetTrendingTopics implements app.bsky.unspecced.getTrendingTopics
+// Returns trending topics (empty for now)
+func HandleGetTrendingTopics(c echo.Context) error {
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"topics":    []interface{}{},
+		"suggested": []interface{}{},
+	})
+}