+85

README.md

··· 109 109 110 110 The frontend will be available at http://localhost:3000 and will connect to the API at http://localhost:4444. 111 111 112 112 + ## Running the Bluesky App against Konbini 113 113 + 114 114 + Konbini implements a large portion of the app.bsky.\* appview endpoints that 115 115 + are required for pointing the main app to it and having it work reasonably 116 116 + well. 117 117 + 118 118 + To accomplish this you will need a few things: 119 119 + 120 120 + ### Service DID 121 121 + 122 122 + You will need a DID, preferably a did:web for your appview that points at a 123 123 + public endpoint where your appview is accessible via https. 124 124 + I'll get into the https proxy next, but for the did, I've just pointed a domain 125 125 + I own (in my case appview1.bluesky.day) to a VPS, and used caddy to host a file 126 126 + at `/.well-known/did.json`. 127 127 + That file should look like this: 128 128 + 129 129 + ```json 130 130 + { 131 131 + "@context": [ 132 132 + "https://www.w3.org/ns/did/v1", 133 133 + "https://w3id.org/security/multikey/v1" 134 134 + ], 135 135 + "id": "did:web:appview1.bluesky.day", 136 136 + "verificationMethod": [ 137 137 + { 138 138 + "id": "did:web:api.bsky.app#atproto", 139 139 + "type": "Multikey", 140 140 + "controller": "did:web:api.bsky.app", 141 141 + "publicKeyMultibase": "zQ3shpRzb2NDriwCSSsce6EqGxG23kVktHZc57C3NEcuNy1jg" 142 142 + } 143 143 + ], 144 144 + "service": [ 145 145 + { 146 146 + "id": "#bsky_notif", 147 147 + "type": "BskyNotificationService", 148 148 + "serviceEndpoint": "YOUR APPVIEW HTTPS URL" 149 149 + }, 150 150 + { 151 151 + "id": "#bsky_appview", 152 152 + "type": "BskyAppView", 153 153 + "serviceEndpoint": "YOUR APPVIEW HTTPS URL" 154 154 + } 155 155 + ] 156 156 + } 157 157 + ``` 158 158 + 159 159 + The verificationMethod isn't used but i'm not sure if _something_ is required 160 160 + there or not, so i'm just leaving that there, it works on my machine. 161 161 + 162 162 + ### HTTPS Endpoint 163 163 + 164 164 + I've been using ngrok to proxy traffic from a publicly accessible https url to my appview. 165 165 + You can simply run `ngrok http 4446` and it will give you an https url that you 166 166 + can then put in your DID doc above. 167 167 + 168 168 + ### The Social App 169 169 + 170 170 + Now, clone and build the social app: 171 171 + 172 172 + ``` 173 173 + git clone https://github.com/bluesky-social/social-app 174 174 + cd social-app 175 175 + yarn 176 176 + ``` 177 177 + 178 178 + And then set this environment variable that tells it to use your appview: 179 179 + 180 180 + ``` 181 181 + export EXPO_PUBLIC_BLUESKY_PROXY_DID=did:web:YOURDIDWEB 182 182 + ``` 183 183 + 184 184 + And finally run the app: 185 185 + 186 186 + ``` 187 187 + yarn web 188 188 + ``` 189 189 + 190 190 + This takes a while on first load since its building everything. 191 191 + After that, load the localhost url it gives you and it _should_ work. 192 192 + 112 193 ## License 113 194 114 195 MIT (whyrusleeping) 196 196 + 197 197 + ``` 198 198 + 199 199 + ```

+33 -12

main.go

··· 1 1 package main 2 2 3 3 import ( 4 4 + "bytes" 4 5 "context" 5 6 "fmt" 6 7 "log" ··· 19 20 "github.com/bluesky-social/indigo/atproto/syntax" 20 21 "github.com/bluesky-social/indigo/cmd/relay/stream" 21 22 "github.com/bluesky-social/indigo/cmd/relay/stream/schedulers/parallel" 23 23 + "github.com/bluesky-social/indigo/repo" 22 24 "github.com/bluesky-social/indigo/util/cliutil" 23 25 xrpclib "github.com/bluesky-social/indigo/xrpc" 24 26 "github.com/gorilla/websocket" ··· 153 155 client: cc, 154 156 dir: dir, 155 157 156 156 - missingProfiles: make(chan string, 1024), 157 157 - missingPosts: make(chan string, 1024), 158 158 - missingFeedGenerators: make(chan string, 1024), 158 158 + missingRecords: make(chan MissingRecord, 1024), 159 159 } 160 160 fmt.Println("MY DID: ", s.mydid) 161 161 ··· 200 200 http.ListenAndServe(":4445", nil) 201 201 }() 202 202 203 203 - go s.missingProfileFetcher() 204 204 - go s.missingPostFetcher() 205 205 - go s.missingFeedGeneratorFetcher() 203 203 + go s.missingRecordFetcher() 206 204 207 205 seqno, err := loadLastSeq(db, "firehose_seq") 208 206 if err != nil { ··· 227 225 seqLk sync.Mutex 228 226 lastSeq int64 229 227 230 230 - mpLk sync.Mutex 231 231 - missingProfiles chan string 232 232 - missingPosts chan string 233 233 - missingFeedGenerators chan string 228 228 + mpLk sync.Mutex 229 229 + missingRecords chan MissingRecord 234 230 } 235 231 236 232 func (s *Server) getXrpcClient() (*xrpclib.Client, error) { ··· 369 365 return err 370 366 } 371 367 372 372 - _ = resp 373 373 - return nil 368 368 + c := &xrpclib.Client{ 369 369 + Host: resp.PDSEndpoint(), 370 370 + } 371 371 + 372 372 + repob, err := atproto.SyncGetRepo(ctx, c, did, "") 373 373 + if err != nil { 374 374 + return err 375 375 + } 376 376 + 377 377 + rep, err := repo.ReadRepoFromCar(ctx, bytes.NewReader(repob)) 378 378 + if err != nil { 379 379 + return err 380 380 + } 381 381 + 382 382 + return rep.ForEach(ctx, "", func(k string, v cid.Cid) error { 383 383 + blk, err := rep.Blockstore().Get(ctx, v) 384 384 + if err != nil { 385 385 + slog.Error("record missing in repo", "path", k, "cid", v, "error", err) 386 386 + return nil 387 387 + } 388 388 + 389 389 + d := blk.RawData() 390 390 + if err := s.backend.HandleCreate(ctx, did, "", k, &d, &v); err != nil { 391 391 + slog.Error("failed to index record", "path", k, "cid", v, "error", err) 392 392 + } 393 393 + return nil 394 394 + }) 374 395 375 396 }

+61 -47

missing.go

··· 5 5 "context" 6 6 "fmt" 7 7 "log/slog" 8 8 - "strings" 9 8 10 9 "github.com/bluesky-social/indigo/api/atproto" 11 10 "github.com/bluesky-social/indigo/api/bsky" 12 11 "github.com/bluesky-social/indigo/atproto/syntax" 13 12 xrpclib "github.com/bluesky-social/indigo/xrpc" 14 13 "github.com/ipfs/go-cid" 15 15 - "github.com/labstack/gommon/log" 16 14 ) 17 15 18 18 - func (s *Server) addMissingProfile(ctx context.Context, did string) { 16 16 + type MissingRecordType string 17 17 + 18 18 + const ( 19 19 + MissingRecordTypeProfile MissingRecordType = "profile" 20 20 + MissingRecordTypePost MissingRecordType = "post" 21 21 + MissingRecordTypeFeedGenerator MissingRecordType = "feedgenerator" 22 22 + ) 23 23 + 24 24 + type MissingRecord struct { 25 25 + Type MissingRecordType 26 26 + Identifier string // DID for profiles, AT-URI for posts/feedgens 27 27 + } 28 28 + 29 29 + func (s *Server) addMissingRecord(ctx context.Context, rec MissingRecord) { 19 30 select { 20 20 - case s.missingProfiles <- did: 31 31 + case s.missingRecords <- rec: 21 32 case <-ctx.Done(): 22 33 } 23 34 } 24 35 25 25 - func (s *Server) missingProfileFetcher() { 26 26 - for did := range s.missingProfiles { 27 27 - if err := s.fetchMissingProfile(context.TODO(), did); err != nil { 28 28 - log.Warn("failed to fetch missing profile", "did", did, "error", err) 36 36 + // Legacy methods for backward compatibility 37 37 + func (s *Server) addMissingProfile(ctx context.Context, did string) { 38 38 + s.addMissingRecord(ctx, MissingRecord{ 39 39 + Type: MissingRecordTypeProfile, 40 40 + Identifier: did, 41 41 + }) 42 42 + } 43 43 + 44 44 + func (s *Server) addMissingPost(ctx context.Context, uri string) { 45 45 + slog.Info("adding missing post to fetch queue", "uri", uri) 46 46 + s.addMissingRecord(ctx, MissingRecord{ 47 47 + Type: MissingRecordTypePost, 48 48 + Identifier: uri, 49 49 + }) 50 50 + } 51 51 + 52 52 + func (s *Server) addMissingFeedGenerator(ctx context.Context, uri string) { 53 53 + slog.Info("adding missing feed generator to fetch queue", "uri", uri) 54 54 + s.addMissingRecord(ctx, MissingRecord{ 55 55 + Type: MissingRecordTypeFeedGenerator, 56 56 + Identifier: uri, 57 57 + }) 58 58 + } 59 59 + 60 60 + func (s *Server) missingRecordFetcher() { 61 61 + for rec := range s.missingRecords { 62 62 + var err error 63 63 + switch rec.Type { 64 64 + case MissingRecordTypeProfile: 65 65 + err = s.fetchMissingProfile(context.TODO(), rec.Identifier) 66 66 + case MissingRecordTypePost: 67 67 + err = s.fetchMissingPost(context.TODO(), rec.Identifier) 68 68 + case MissingRecordTypeFeedGenerator: 69 69 + err = s.fetchMissingFeedGenerator(context.TODO(), rec.Identifier) 70 70 + default: 71 71 + slog.Error("unknown missing record type", "type", rec.Type) 72 72 + continue 73 73 + } 74 74 + 75 75 + if err != nil { 76 76 + slog.Warn("failed to fetch missing record", "type", rec.Type, "identifier", rec.Identifier, "error", err) 29 77 } 30 78 } 31 79 } ··· 68 116 return s.backend.HandleUpdateProfile(ctx, repo, "self", "", buf.Bytes(), cc) 69 117 } 70 118 71 71 - func (s *Server) addMissingPost(ctx context.Context, uri string) { 72 72 - slog.Info("adding missing post to fetch queue", "uri", uri) 73 73 - select { 74 74 - case s.missingPosts <- uri: 75 75 - case <-ctx.Done(): 76 76 - } 77 77 - } 78 78 - 79 79 - func (s *Server) missingPostFetcher() { 80 80 - for uri := range s.missingPosts { 81 81 - if err := s.fetchMissingPost(context.TODO(), uri); err != nil { 82 82 - log.Warn("failed to fetch missing post", "uri", uri, "error", err) 83 83 - } 84 84 - } 85 85 - } 86 86 - 87 119 func (s *Server) fetchMissingPost(ctx context.Context, uri string) error { 88 88 - // Parse AT URI: at://did:plc:xxx/app.bsky.feed.post/rkey 89 89 - parts := strings.Split(uri, "/") 90 90 - if len(parts) < 5 || !strings.HasPrefix(parts[2], "did:") { 120 120 + puri, err := syntax.ParseATURI(uri) 121 121 + if err != nil { 91 122 return fmt.Errorf("invalid AT URI: %s", uri) 92 123 } 93 124 94 94 - did := parts[2] 95 95 - collection := parts[3] 96 96 - rkey := parts[4] 125 125 + did := puri.Authority().String() 126 126 + collection := puri.Collection().String() 127 127 + rkey := puri.RecordKey().String() 97 128 98 129 repo, err := s.backend.getOrCreateRepo(ctx, did) 99 130 if err != nil { ··· 132 163 return s.backend.HandleCreatePost(ctx, repo, rkey, buf.Bytes(), cc) 133 164 } 134 165 135 135 - func (s *Server) addMissingFeedGenerator(ctx context.Context, uri string) { 136 136 - slog.Info("adding missing feed generator to fetch queue", "uri", uri) 137 137 - select { 138 138 - case s.missingFeedGenerators <- uri: 139 139 - case <-ctx.Done(): 140 140 - } 141 141 - } 142 142 - 143 143 - func (s *Server) missingFeedGeneratorFetcher() { 144 144 - for uri := range s.missingFeedGenerators { 145 145 - if err := s.fetchMissingFeedGenerator(context.TODO(), uri); err != nil { 146 146 - log.Warn("failed to fetch missing feed generator", "uri", uri, "error", err) 147 147 - } 148 148 - } 149 149 - } 150 150 - 151 166 func (s *Server) fetchMissingFeedGenerator(ctx context.Context, uri string) error { 152 152 - // Parse AT URI: at://did:plc:xxx/app.bsky.feed.generator/rkey 153 167 puri, err := syntax.ParseATURI(uri) 154 168 if err != nil { 155 169 return fmt.Errorf("invalid AT URI: %s", uri)

+31 -8

xrpc/feed/getFeed.go

··· 23 23 // Parse parameters 24 24 feedURI := c.QueryParam("feed") 25 25 if feedURI == "" { 26 26 - return c.JSON(http.StatusBadRequest, map[string]interface{}{ 26 26 + return c.JSON(http.StatusBadRequest, map[string]any{ 27 27 "error": "InvalidRequest", 28 28 "message": "feed parameter is required", 29 29 }) ··· 49 49 rkey := extractRkeyFromURI(feedURI) 50 50 51 51 if did == "" || rkey == "" { 52 52 - return c.JSON(http.StatusBadRequest, map[string]interface{}{ 52 52 + return c.JSON(http.StatusBadRequest, map[string]any{ 53 53 "error": "InvalidRequest", 54 54 "message": "invalid feed URI format", 55 55 }) ··· 65 65 66 66 if feedGen.ID == 0 { 67 67 hydrator.AddMissingFeedGenerator(feedURI) 68 68 - return c.JSON(http.StatusNotFound, map[string]interface{}{ 68 68 + return c.JSON(http.StatusNotFound, map[string]any{ 69 69 "error": "NotFound", 70 70 "message": "feed generator not found", 71 71 }) ··· 75 75 var feedGenRecord bsky.FeedGenerator 76 76 if err := feedGenRecord.UnmarshalCBOR(bytes.NewReader(feedGen.Raw)); err != nil { 77 77 slog.Error("failed to decode feed generator record", "error", err) 78 78 - return c.JSON(http.StatusInternalServerError, map[string]interface{}{ 78 78 + return c.JSON(http.StatusInternalServerError, map[string]any{ 79 79 "error": "InternalError", 80 80 "message": "failed to decode feed generator record", 81 81 }) ··· 85 85 serviceDID, err := syntax.ParseDID(feedGenRecord.Did) 86 86 if err != nil { 87 87 slog.Error("invalid service DID in feed generator", "error", err, "did", feedGenRecord.Did) 88 88 - return c.JSON(http.StatusInternalServerError, map[string]interface{}{ 88 88 + return c.JSON(http.StatusInternalServerError, map[string]any{ 89 89 "error": "InternalError", 90 90 "message": "invalid service DID", 91 91 }) ··· 95 95 serviceIdent, err := dir.LookupDID(ctx, serviceDID) 96 96 if err != nil { 97 97 slog.Error("failed to resolve service DID", "error", err, "did", serviceDID) 98 98 - return c.JSON(http.StatusInternalServerError, map[string]interface{}{ 98 98 + return c.JSON(http.StatusInternalServerError, map[string]any{ 99 99 "error": "InternalError", 100 100 "message": "failed to resolve service endpoint", 101 101 }) ··· 104 104 serviceEndpoint := serviceIdent.GetServiceEndpoint("bsky_fg") 105 105 if serviceEndpoint == "" { 106 106 slog.Error("service has no bsky_fg endpoint", "did", serviceDID) 107 107 - return c.JSON(http.StatusInternalServerError, map[string]interface{}{ 107 107 + return c.JSON(http.StatusInternalServerError, map[string]any{ 108 108 "error": "InternalError", 109 109 "message": "service has no endpoint", 110 110 }) 111 111 } 112 112 113 113 // Create XRPC client for the feed generator service 114 114 + // Pass through headers from the original request so feed generators can 115 115 + // customize feeds based on the viewer 116 116 + headers := make(map[string]string) 117 117 + 118 118 + // Set User-Agent to identify konbini 119 119 + headers["User-Agent"] = "konbini/0.0.1" 120 120 + 121 121 + // Pass through Authorization header if present (for authenticated feed requests) 122 122 + if authHeader := c.Request().Header.Get("Authorization"); authHeader != "" { 123 123 + headers["Authorization"] = authHeader 124 124 + } 125 125 + 126 126 + // Pass through Accept-Language header if present 127 127 + if langHeader := c.Request().Header.Get("Accept-Language"); langHeader != "" { 128 128 + headers["Accept-Language"] = langHeader 129 129 + } 130 130 + 131 131 + // Pass through X-Bsky-Topics header if present 132 132 + if topicsHeader := c.Request().Header.Get("X-Bsky-Topics"); topicsHeader != "" { 133 133 + headers["X-Bsky-Topics"] = topicsHeader 134 134 + } 135 135 + 114 136 client := &xrpc.Client{ 115 115 - Host: serviceEndpoint, 137 137 + Host: serviceEndpoint, 138 138 + Headers: headers, 116 139 } 117 140 118 141 // Call getFeedSkeleton on the service