red-dwarf-server / main.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"time"

	did "github.com/whyrusleeping/go-did"
	"tangled.org/whey.party/red-dwarf-server/auth"
	"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
	"tangled.org/whey.party/red-dwarf-server/microcosm/slingshot"
	appbskyactordefs "tangled.org/whey.party/red-dwarf-server/shims/lex/app/bsky/actor/defs"
	"tangled.org/whey.party/red-dwarf-server/shims/utils"
	"tangled.org/whey.party/red-dwarf-server/sticket"
	"tangled.org/whey.party/red-dwarf-server/store"

	// "github.com/bluesky-social/indigo/atproto/atclient"
	// comatproto "github.com/bluesky-social/indigo/api/atproto"
	appbsky "github.com/bluesky-social/indigo/api/bsky"
	// "github.com/bluesky-social/indigo/atproto/atclient"
	// "github.com/bluesky-social/indigo/atproto/identity"
	// "github.com/bluesky-social/indigo/atproto/syntax"
	"github.com/bluesky-social/indigo/api/agnostic"
	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
	// "github.com/bluesky-social/jetstream/pkg/models"
)

var (
	JETSTREAM_URL     string
	SPACEDUST_URL     string
	SLINGSHOT_URL     string
	CONSTELLATION_URL string
)

func initURLs(prod bool) {
	if !prod {
		JETSTREAM_URL = "wss://jetstream.whey.party/subscribe"
		SPACEDUST_URL = "wss://spacedust.whey.party/subscribe"
		SLINGSHOT_URL = "https://slingshot.whey.party"
		CONSTELLATION_URL = "https://constellation.whey.party"
	} else {
		JETSTREAM_URL = "ws://localhost:6008/subscribe"
		SPACEDUST_URL = "ws://localhost:9998/subscribe"
		SLINGSHOT_URL = "http://localhost:7729"
		CONSTELLATION_URL = "http://localhost:7728"
	}
}

const (
	BSKYIMAGECDN_URL = "https://cdn.bsky.app"
	BSKYVIDEOCDN_URL = "https://video.bsky.app"
	serviceWebDID    = "did:web:server.reddwarf.app"
	serviceWebHost   = "https://server.reddwarf.app"
)

func main() {
	log.Println("red-dwarf-server started")
	prod := flag.Bool("prod", false, "use production URLs instead of localhost")
	flag.Parse()

	initURLs(*prod)

	ctx := context.Background()
	mailbox := sticket.New()
	sl := slingshot.NewSlingshot(SLINGSHOT_URL)
	cs := constellation.NewConstellation(CONSTELLATION_URL)
	// 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())

	router.GET("/.well-known/did.json", GetWellKnownDID)

	auther, err := auth.NewAuth(
		100_000,
		time.Hour*12,
		5,
		serviceWebDID, //+"#bsky_appview",
	)
	if err != nil {
		log.Fatalf("Failed to create Auth: %v", err)
	}

	router.Use(auther.AuthenticateGinRequestViaJWT)

	responsewow, err := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.actor.profile", "did:web:did12.whey.party", "self")
	if err != nil {
		log.Println(err)
	}

	log.Println(responsewow.Uri)

	var didtest *utils.DID
	didval, errdid := utils.NewDID("did:web:did12.whey.party")
	if errdid != nil {
		didtest = nil
	} else {
		didtest = &didval
	}
	profiletest, _, _ := appbskyactordefs.ProfileViewBasic(ctx, *didtest, sl, BSKYIMAGECDN_URL)

	log.Println(*profiletest.DisplayName)
	log.Println(*profiletest.Avatar)

	router.GET("/ws", func(c *gin.Context) {
		mailbox.HandleWS(c.Writer, c.Request)
	})

	kv := store.NewKV()

	// sad attempt to get putpref working. tldr it wont work without a client fork
	// https://bsky.app/profile/did:web:did12.whey.party/post/3m75xtomd722n
	router.GET("/xrpc/app.bsky.actor.putPreferences", func(c *gin.Context) {
		c.Status(200)
	})
	router.PUT("/xrpc/app.bsky.actor.putPreferences", func(c *gin.Context) {
		c.Status(200)
	})
	router.POST("/xrpc/app.bsky.actor.putPreferences", func(c *gin.Context) {
		c.Status(200)

		userDID := c.GetString("user_did")
		body, err := io.ReadAll(c.Request.Body)
		if err != nil {
			c.JSON(400, gin.H{"error": "invalid body"})
			return
		}

		kv.Set(userDID, body)

	})

	router.GET("/xrpc/app.bsky.actor.getPreferences", func(c *gin.Context) {
		userDID := c.GetString("user_did")
		val, ok := kv.Get(userDID)
		if !ok {
			c.JSON(200, gin.H{"preferences": []any{}})
			return
		}

		c.Data(200, "application/json", val)

	})

	bskyappdid, _ := utils.NewDID("did:plc:z72i7hdynmk6r22z27h6tvur")

	profiletest2, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, bskyappdid, sl, cs, BSKYIMAGECDN_URL)

	data, err := json.MarshalIndent(profiletest2, "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))

	router.GET("/xrpc/app.bsky.actor.getProfiles",
		func(c *gin.Context) {
			actors := c.QueryArray("actors")

			profiles := make([]*appbsky.ActorDefs_ProfileViewDetailed, 0, len(actors))

			for _, v := range actors {
				did, err := utils.NewDID(v)
				if err != nil {
					continue
				}
				profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL)
				profiles = append(profiles, profile)
			}

			c.JSON(http.StatusOK, &appbsky.ActorGetProfiles_Output{
				Profiles: profiles,
			})
		})

	router.GET("/xrpc/app.bsky.actor.getProfile",
		func(c *gin.Context) {
			actor := c.Query("actor")
			did, err := utils.NewDID(actor)
			if err != nil {
				c.JSON(http.StatusBadRequest, nil)
				return
			}
			profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL)
			c.JSON(http.StatusOK, profile)
		})

	// really bad actually
	router.GET("/xrpc/app.bsky.notification.listNotifications",
		func(c *gin.Context) {
			c.JSON(http.StatusOK, nil)
		})

	router.GET("/", func(c *gin.Context) {
		log.Println("hello worldio !")
		clientUUID := sticket.GetUUIDFromRequest(c.Request)
		hasSticket := clientUUID != ""
		if hasSticket {
			go func(targetUUID string) {
				// simulated heavy processing
				time.Sleep(2 * time.Second)

				lateData := map[string]any{
					"postId": 101,
					"newComments": []string{
						"Wow great tutorial!",
						"I am stuck on step 1.",
					},
				}

				success := mailbox.SendToClient(targetUUID, "post_thread_update", lateData)
				if success {
					log.Println("Successfully sent late data via Sticket")
				} else {
					log.Println("Failed to send late data (client disconnected?)")
				}
			}(clientUUID)
		}
	})
	router.Run(":7152")
}

func getPostThreadV2(w http.ResponseWriter, r *http.Request) {
	log.Println("hello worldio !")
}

type DidResponse struct {
	Context []string      `json:"@context"`
	ID      string        `json:"id"`
	Service []did.Service `json:"service"`
}

/*
	{
		id: "#bsky_appview",
		type: "BskyAppView",
		serviceEndpoint: endpoint,
	},
*/
func GetWellKnownDID(c *gin.Context) {
	// Use a custom struct to fix missing omitempty on did.Document
	serviceEndpoint := serviceWebHost
	serviceDID, err := did.ParseDID(serviceWebDID)
	if err != nil {
		log.Println(fmt.Errorf("error parsing serviceDID: %w", err))
		return
	}
	serviceID, err := did.ParseDID("#bsky_appview")
	if err != nil {
		panic(err)
	}
	didDoc := did.Document{
		Context: []string{did.CtxDIDv1},
		ID:      serviceDID,
		Service: []did.Service{
			{
				ID:              serviceID,
				Type:            "BskyAppView",
				ServiceEndpoint: serviceEndpoint,
			},
		},
	}
	didResponse := DidResponse{
		Context: didDoc.Context,
		ID:      didDoc.ID.String(),
		Service: didDoc.Service,
	}
	c.JSON(http.StatusOK, didResponse)
}