extremely terrible basic getFeed

main.go

···
 	"log"
 	"net/http"
 	"os"
+	"strings"
 	"sync"
 	"time"
 
···
 	// spacedust is type definitions only
 	// jetstream types is probably available from jetstream/pkg/models
 
-	router := gin.New()
-	router.Use(gin.Logger())
-	router.Use(gin.Recovery())
-	router.Use(cors.Default())
+	r_unsafe := gin.New()
+	r_unsafe.Use(gin.Logger())
+	r_unsafe.Use(gin.Recovery())
+	r_unsafe.Use(cors.Default())
 
-	router.GET("/.well-known/did.json", GetWellKnownDID)
+	r_unsafe.GET("/.well-known/did.json", GetWellKnownDID)
 
 	auther, err := auth.NewAuth(
 		100_000,
···
 		log.Fatalf("Failed to create Auth: %v", err)
 	}
 
+	router := r_unsafe.Group("/")
+	router.Use(auther.AuthenticateGinRequestViaJWT)
 	router.Use(auther.AuthenticateGinRequestViaJWT)
 
 	responsewow, err := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.actor.profile", "did:web:did12.whey.party", "self")
···
 			})
 		})
 
+	r_unsafe.GET("/xrpc/app.bsky.feed.getFeed",
+		func(c *gin.Context) {
+			ctx := c.Request.Context()
+
+			feedGenAturiRaw := c.Query("feed")
+			if feedGenAturiRaw == "" {
+				c.JSON(http.StatusBadRequest, gin.H{"error": "Missing feed param"})
+				return
+			}
+
+			feedGenAturi, err := syntax.ParseATURI(feedGenAturiRaw)
+			if err != nil {
+				return
+			}
+
+			feedGeneratorRecordResponse, err := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.feed.generator", feedGenAturi.Authority().String(), feedGenAturi.RecordKey().String())
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{"error": fmt.Sprintf("Failed to resolve feed generator record: %v", err)})
+				return
+			}
+
+			var feedGeneratorRecord appbsky.FeedGenerator
+			if err := json.Unmarshal(*feedGeneratorRecordResponse.Value, &feedGeneratorRecord); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to parse feed generator record JSON"})
+				return
+			}
+
+			feedGenDID := feedGeneratorRecord.Did
+
+			didDoc, err := ResolveDID(feedGenDID)
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{"error": fmt.Sprintf("Failed to resolve DID: %v", err)})
+				return
+			}
+
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{"error": fmt.Sprintf("Failed to resolve DID: %v", err)})
+				return
+			}
+
+			var targetEndpoint string
+			for _, svc := range didDoc.Service {
+				if svc.Type == "BskyFeedGenerator" && strings.HasSuffix(svc.ID, "#bsky_fg") {
+					targetEndpoint = svc.ServiceEndpoint
+					break
+				}
+			}
+			if targetEndpoint == "" {
+				c.JSON(http.StatusBadGateway, gin.H{"error": "Feed Generator service endpoint not found in DID document"})
+				return
+			}
+			upstreamURL := fmt.Sprintf("%s/xrpc/app.bsky.feed.getFeedSkeleton?%s",
+				strings.TrimSuffix(targetEndpoint, "/"),
+				c.Request.URL.RawQuery,
+			)
+			req, err := http.NewRequestWithContext(ctx, "GET", upstreamURL, nil)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create upstream request"})
+				return
+			}
+			headersToForward := []string{"Authorization", "Content-Type", "Accept", "User-Agent"}
+			for _, k := range headersToForward {
+				if v := c.GetHeader(k); v != "" {
+					req.Header.Set(k, v)
+				}
+			}
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{"error": fmt.Sprintf("Upstream request failed: %v", err)})
+				return
+			}
+			defer resp.Body.Close()
+
+			bodyBytes, err := io.ReadAll(resp.Body)
+			if err != nil {
+				c.JSON(http.StatusBadGateway, gin.H{"error": "Failed to read upstream body"})
+				return
+			}
+			if resp.StatusCode != http.StatusOK {
+				// Forward the upstream error raw
+				c.Data(resp.StatusCode, resp.Header.Get("Content-Type"), bodyBytes)
+				return
+			}
+
+			var feekskeleton appbsky.FeedGetFeedSkeleton_Output
+			if err := json.Unmarshal(bodyBytes, &feekskeleton); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to parse upstream JSON"})
+				return
+			}
+
+			skeletonposts := feekskeleton.Feed
+
+			type result struct {
+				view *appbsky.FeedDefs_FeedViewPost
+			}
+
+			results := make([]result, len(skeletonposts))
+
+			var wg sync.WaitGroup
+			wg.Add(len(skeletonposts))
+
+			for i, raw := range skeletonposts {
+				go func(i int, raw appbsky.FeedDefs_SkeletonFeedPost) {
+					defer wg.Done()
+
+					post, _, err := appbskyfeeddefs.PostView(ctx, raw.Post, sl, BSKYIMAGECDN_URL)
+					if err != nil || post == nil {
+						return
+					}
+
+					feedviewpost := &appbsky.FeedDefs_FeedViewPost{
+						// FeedContext *string                       `json:"feedContext,omitempty" cborgen:"feedContext,omitempty"`
+						// Post        *FeedDefs_PostView            `json:"post" cborgen:"post"`
+						Post: post,
+						// Reason      *FeedDefs_FeedViewPost_Reason `json:"reason,omitempty" cborgen:"reason,omitempty"`
+						// Reason: &appbsky.FeedDefs_FeedViewPost_Reason{
+						// 	// FeedDefs_ReasonRepost *FeedDefs_ReasonRepost
+						// 	FeedDefs_ReasonRepost: &appbsky.FeedDefs_ReasonRepost{
+						// 		// LexiconTypeID string                      `json:"$type" cborgen:"$type,const=app.bsky.feed.defs#reasonRepost"`
+						// 		LexiconTypeID: "app.bsky.feed.defs#reasonRepost",
+						// 		// By            *ActorDefs_ProfileViewBasic `json:"by" cborgen:"by"`
+						// 		// Cid           *string                     `json:"cid,omitempty" cborgen:"cid,omitempty"`
+						// 		// IndexedAt     string                      `json:"indexedAt" cborgen:"indexedAt"`
+						// 		// Uri           *string                     `json:"uri,omitempty" cborgen:"uri,omitempty"`
+						// 		Uri: &raw.Reason.FeedDefs_SkeletonReasonRepost.Repost,
+						// 	},
+						// 	// FeedDefs_ReasonPin    *FeedDefs_ReasonPin
+						// 	FeedDefs_ReasonPin: &appbsky.FeedDefs_ReasonPin{
+						// 		// LexiconTypeID string `json:"$type" cborgen:"$type,const=app.bsky.feed.defs#reasonPin"`
+						// 		LexiconTypeID: "app.bsky.feed.defs#reasonPin",
+						// 	},
+						// },
+						// Reply       *FeedDefs_ReplyRef            `json:"reply,omitempty" cborgen:"reply,omitempty"`
+						// // reqId: Unique identifier per request that may be passed back alongside interactions.
+						// ReqId *string `json:"reqId,omitempty" cborgen:"reqId,omitempty"`
+
+					}
+
+					results[i].view = feedviewpost
+				}(i, *raw)
+			}
+
+			wg.Wait()
+
+			// build final slice
+			out := make([]*appbsky.FeedDefs_FeedViewPost, 0, len(results))
+			for _, r := range results {
+				if r.view != nil && r.view.Post != nil {
+					out = append(out, r.view)
+				}
+			}
+
+			c.JSON(http.StatusOK, &appbsky.FeedGetFeed_Output{
+				Cursor: feekskeleton.Cursor,
+				Feed:   out,
+			})
+		})
+
 	yourJSONBytes, _ := os.ReadFile("./public/getConfig.json")
 	router.GET("/xrpc/app.bsky.unspecced.getConfig", func(c *gin.Context) {
 		c.DataFromReader(200, -1, "application/json",
···
 			}(clientUUID)
 		}
 	})
-	router.Run(":7152")
+	r_unsafe.Run(":7152")
 }
 
 func getPostThreadV2(w http.ResponseWriter, r *http.Request) {

utils.go

···
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+type DIDDocument struct {
+	ID      string `json:"id"`
+	Service []struct {
+		ID              string `json:"id"`
+		Type            string `json:"type"`
+		ServiceEndpoint string `json:"serviceEndpoint"`
+	} `json:"service"`
+}
+
+func ResolveDID(did string) (*DIDDocument, error) {
+	var url string
+
+	if strings.HasPrefix(did, "did:plc:") {
+		// Resolve via PLC Directory
+		url = "https://plc.directory/" + did
+	} else if strings.HasPrefix(did, "did:web:") {
+		// Resolve via Web (simplified)
+		domain := strings.TrimPrefix(did, "did:web:")
+		url = "https://" + domain + "/.well-known/did.json"
+	} else {
+		return nil, fmt.Errorf("unsupported DID format: %s", did)
+	}
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("resolver returned status: %d", resp.StatusCode)
+	}
+
+	var doc DIDDocument
+	if err := json.NewDecoder(resp.Body).Decode(&doc); err != nil {
+		return nil, err
+	}
+
+	return &doc, nil
+}