package server import ( "context" "crypto/ecdsa" "errors" "fmt" "log/slog" "net/http" "os" "time" "github.com/bluesky-social/indigo/atproto/syntax" "github.com/bluesky-social/indigo/events" "github.com/bluesky-social/indigo/util" "github.com/go-playground/validator" "github.com/ipfs/go-cid" "github.com/labstack/echo/v4" "github.com/labstack/echo/v4/middleware" slogecho "github.com/samber/slog-echo" "gorm.io/driver/sqlite" "gorm.io/gorm" "tangled.org/pdewey.com/chrysalis/identity" "tangled.org/pdewey.com/chrysalis/internal/db" "tangled.org/pdewey.com/chrysalis/internal/helpers" "tangled.org/pdewey.com/chrysalis/models" "tangled.org/pdewey.com/chrysalis/oauth/client" "tangled.org/pdewey.com/chrysalis/oauth/constants" "tangled.org/pdewey.com/chrysalis/oauth/dpop" "tangled.org/pdewey.com/chrysalis/oauth/provider" "tangled.org/pdewey.com/chrysalis/plc" ) type Server struct { http *http.Client httpd *http.Server echo *echo.Echo db *db.DB plcClient plc.PLCClient plcURL string logger *slog.Logger config *config privateKey *ecdsa.PrivateKey repoman *RepoMan oauthProvider *provider.Provider evtman *events.EventManager passport *identity.Passport dbName string } type Args struct { Logger *slog.Logger LogLevel slog.Level Addr string DbName string Did string Hostname string RotationKeyPath string JwkPath string ContactEmail string AdminPassword string BlockstoreVariant BlockstoreVariant // Embedding overrides: point at a custom PLC or swap the outbound // HTTP client. All optional; fall back to defaults when unset. PLCUrl string // defaults to https://plc.directory HTTPClient *http.Client // defaults to util.RobustHTTPClient() // PdsScheme overrides the URL scheme recorded in this PDS's DID docs. // Defaults to "https"; test setups without TLS should pass "http". PdsScheme string // Test / multi-instance overrides. PLCClient plc.PLCClient // replaces the real PLC client entirely; PLCUrl is ignored } type config struct { LogLevel slog.Level Did string Hostname string ContactEmail string AdminPassword string BlockstoreVariant BlockstoreVariant } type CustomValidator struct { validator *validator.Validate } type ValidationError struct { error Field string Tag string } func (cv *CustomValidator) Validate(i any) error { if err := cv.validator.Struct(i); err != nil { var validateErrors validator.ValidationErrors if errors.As(err, &validateErrors) && len(validateErrors) > 0 { first := validateErrors[0] return ValidationError{ error: err, Field: first.Field(), Tag: first.Tag(), } } return err } return nil } type filteredHandler struct { level slog.Level handler slog.Handler } func (h *filteredHandler) Enabled(ctx context.Context, level slog.Level) bool { return level >= h.level && h.handler.Enabled(ctx, level) } func (h *filteredHandler) Handle(ctx context.Context, r slog.Record) error { return h.handler.Handle(ctx, r) } func (h *filteredHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return &filteredHandler{level: h.level, handler: h.handler.WithAttrs(attrs)} } func (h *filteredHandler) WithGroup(name string) slog.Handler { return &filteredHandler{level: h.level, handler: h.handler.WithGroup(name)} } func New(args *Args) (*Server, error) { if args.Logger == nil { args.Logger = slog.Default() } if args.LogLevel != 0 { args.Logger = slog.New(&filteredHandler{ level: args.LogLevel, handler: args.Logger.Handler(), }) } logger := args.Logger.With("name", "New") if args.Addr == "" { return nil, fmt.Errorf("addr must be set") } if args.DbName == "" { return nil, fmt.Errorf("db name must be set") } if args.Did == "" { return nil, fmt.Errorf("did must be set") } if args.ContactEmail == "" { return nil, fmt.Errorf("contact email is required") } if _, err := syntax.ParseDID(args.Did); err != nil { return nil, fmt.Errorf("error parsing did: %w", err) } if args.Hostname == "" { return nil, fmt.Errorf("hostname must be set") } if args.AdminPassword == "" { return nil, fmt.Errorf("admin password must be set") } e := echo.New() e.Pre(middleware.RemoveTrailingSlash()) e.Pre(slogecho.New(args.Logger.With("component", "slogecho"))) e.Use(middleware.CORSWithConfig(middleware.CORSConfig{ AllowOrigins: []string{"*"}, AllowHeaders: []string{"*"}, AllowMethods: []string{"*"}, AllowCredentials: true, MaxAge: 100_000_000, })) vdtor := validator.New() vdtor.RegisterValidation("atproto-handle", func(fl validator.FieldLevel) bool { if _, err := syntax.ParseHandle(fl.Field().String()); err != nil { return false } return true }) vdtor.RegisterValidation("atproto-did", func(fl validator.FieldLevel) bool { if _, err := syntax.ParseDID(fl.Field().String()); err != nil { return false } return true }) vdtor.RegisterValidation("atproto-rkey", func(fl validator.FieldLevel) bool { if _, err := syntax.ParseRecordKey(fl.Field().String()); err != nil { return false } return true }) vdtor.RegisterValidation("atproto-nsid", func(fl validator.FieldLevel) bool { if _, err := syntax.ParseNSID(fl.Field().String()); err != nil { return false } return true }) e.Validator = &CustomValidator{validator: vdtor} httpd := &http.Server{ Addr: args.Addr, Handler: e, // shitty defaults but okay for now, needed for import repo ReadTimeout: 5 * time.Minute, WriteTimeout: 5 * time.Minute, IdleTimeout: 5 * time.Minute, } gdb, err := gorm.Open(sqlite.Open(args.DbName), &gorm.Config{}) if err != nil { return nil, fmt.Errorf("failed to open sqlite database: %w", err) } gdb.Exec("PRAGMA journal_mode=WAL") gdb.Exec("PRAGMA synchronous=NORMAL") logger.Info("connected to SQLite database", "path", args.DbName) dbw := db.NewDB(gdb) rkbytes, err := os.ReadFile(args.RotationKeyPath) if err != nil { return nil, err } h := args.HTTPClient if h == nil { h = util.RobustHTTPClient() } var plcClient plc.PLCClient if args.PLCClient != nil { plcClient = args.PLCClient } else { plcClient, err = plc.NewClient(&plc.ClientArgs{ H: h, Service: args.PLCUrl, PdsHostname: args.Hostname, PdsScheme: args.PdsScheme, RotationKey: rkbytes, }) if err != nil { return nil, err } } jwkbytes, err := os.ReadFile(args.JwkPath) if err != nil { return nil, err } key, err := helpers.ParseJWKFromBytes(jwkbytes) if err != nil { return nil, err } var pkey ecdsa.PrivateKey if err := key.Raw(&pkey); err != nil { return nil, err } oauthCli := &http.Client{ Timeout: 10 * time.Second, } evtPersister, err := NewDbPersister(gdb, 72*time.Hour) if err != nil { return nil, fmt.Errorf("failed to create event persister: %w", err) } s := &Server{ http: h, httpd: httpd, echo: e, logger: args.Logger, db: dbw, plcClient: plcClient, privateKey: &pkey, config: &config{ LogLevel: args.LogLevel, Did: args.Did, Hostname: args.Hostname, ContactEmail: args.ContactEmail, AdminPassword: args.AdminPassword, BlockstoreVariant: args.BlockstoreVariant, }, evtman: events.NewEventManager(evtPersister), passport: identity.NewPassport(h, identity.NewMemCache(10_000), args.PLCUrl), plcURL: args.PLCUrl, dbName: args.DbName, oauthProvider: provider.NewProvider(provider.Args{ Hostname: args.Hostname, ClientManagerArgs: client.ManagerArgs{ Cli: oauthCli, Logger: args.Logger.With("component", "oauth-client-manager"), }, DpopManagerArgs: dpop.ManagerArgs{ NonceSecret: nil, // nonces are in-memory only for test PDS NonceRotationInterval: constants.NonceMaxRotationInterval / 3, Logger: args.Logger.With("component", "dpop-manager"), Hostname: args.Hostname, }, }), } s.repoman = NewRepoMan(s) return s, nil } func (s *Server) addRoutes() { s.echo.GET("/xrpc/_health", s.handleHealth) s.echo.GET("/.well-known/did.json", s.handleWellKnown) s.echo.GET("/.well-known/atproto-did", s.handleAtprotoDid) s.echo.GET("/.well-known/oauth-protected-resource", s.handleOauthProtectedResource) s.echo.GET("/.well-known/oauth-authorization-server", s.handleOauthAuthorizationServer) // public s.echo.GET("/xrpc/com.atproto.identity.resolveHandle", s.handleResolveHandle) s.echo.POST("/xrpc/com.atproto.server.createAccount", s.handleCreateAccount) s.echo.POST("/xrpc/com.atproto.server.createSession", s.handleCreateSession) s.echo.GET("/xrpc/com.atproto.server.describeServer", s.handleDescribeServer) s.echo.POST("/xrpc/com.atproto.server.reserveSigningKey", s.handleServerReserveSigningKey) s.echo.GET("/xrpc/com.atproto.repo.describeRepo", s.handleDescribeRepo) s.echo.GET("/xrpc/com.atproto.sync.listRepos", s.handleListRepos) s.echo.GET("/xrpc/com.atproto.repo.listRecords", s.handleListRecords) s.echo.GET("/xrpc/com.atproto.repo.getRecord", s.handleRepoGetRecord) s.echo.GET("/xrpc/com.atproto.sync.getRecord", s.handleSyncGetRecord) s.echo.GET("/xrpc/com.atproto.sync.getBlocks", s.handleGetBlocks) s.echo.GET("/xrpc/com.atproto.sync.getLatestCommit", s.handleSyncGetLatestCommit) s.echo.GET("/xrpc/com.atproto.sync.getRepoStatus", s.handleSyncGetRepoStatus) s.echo.GET("/xrpc/com.atproto.sync.getRepo", s.handleSyncGetRepo) s.echo.GET("/xrpc/com.atproto.sync.subscribeRepos", s.handleSyncSubscribeRepos) s.echo.GET("/xrpc/com.atproto.sync.listBlobs", s.handleSyncListBlobs) s.echo.GET("/xrpc/com.atproto.sync.getBlob", s.handleSyncGetBlob) // labels s.echo.GET("/xrpc/com.atproto.label.queryLabels", s.handleLabelQueryLabels) // oauth s.echo.GET("/oauth/jwks", s.handleOauthJwks) // oauth authorization s.echo.POST("/oauth/par", s.handleOauthPar, s.oauthProvider.BaseMiddleware) s.echo.POST("/oauth/token", s.handleOauthToken, s.oauthProvider.BaseMiddleware) // authed s.echo.GET("/xrpc/com.atproto.server.getSession", s.handleGetSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.server.refreshSession", s.handleRefreshSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.server.deleteSession", s.handleDeleteSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.GET("/xrpc/com.atproto.identity.getRecommendedDidCredentials", s.handleGetRecommendedDidCredentials, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.identity.updateHandle", s.handleIdentityUpdateHandle, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.identity.requestPlcOperationSignature", s.handleIdentityRequestPlcOperationSignature, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.identity.signPlcOperation", s.handleSignPlcOperation, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.identity.submitPlcOperation", s.handleSubmitPlcOperation, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.GET("/xrpc/com.atproto.server.getServiceAuth", s.handleServerGetServiceAuth, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.GET("/xrpc/com.atproto.server.checkAccountStatus", s.handleServerCheckAccountStatus, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.server.deactivateAccount", s.handleServerDeactivateAccount, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.server.activateAccount", s.handleServerActivateAccount, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.server.deleteAccount", s.handleServerDeleteAccount) // repo s.echo.GET("/xrpc/com.atproto.repo.listMissingBlobs", s.handleListMissingBlobs, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.repo.createRecord", s.handleCreateRecord, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.repo.putRecord", s.handlePutRecord, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.repo.deleteRecord", s.handleDeleteRecord, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.repo.applyWrites", s.handleApplyWrites, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/com.atproto.repo.uploadBlob", s.handleRepoUploadBlob, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) // bsky compat s.echo.GET("/xrpc/app.bsky.actor.getPreferences", s.handleActorGetPreferences, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.POST("/xrpc/app.bsky.actor.putPreferences", s.handleActorPutPreferences, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) s.echo.GET("/xrpc/app.bsky.ageassurance.getState", s.handleAgeAssurance, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) } func (s *Server) Serve(ctx context.Context) error { logger := s.logger.With("name", "Serve") s.addRoutes() logger.Info("migrating...") s.db.AutoMigrate( &models.Actor{}, &models.Repo{}, &models.Token{}, &models.RefreshToken{}, &models.Block{}, &models.Record{}, &models.Blob{}, &models.BlobPart{}, &models.ReservedKey{}, &provider.OauthToken{}, &provider.OauthAuthorizationRequest{}, ) logger.Info("starting chrysalis") listenErr := make(chan error, 1) go func() { if err := s.httpd.ListenAndServe(); err != nil && err != http.ErrServerClosed { listenErr <- err } }() go func() { <-ctx.Done() }() select { case err := <-listenErr: return err case <-ctx.Done(): } shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := s.httpd.Shutdown(shutdownCtx); err != nil { logger.Error("error shutting down http server", "err", err) } logger.Info("shut down") return nil } func (s *Server) UpdateRepo(ctx context.Context, did string, root cid.Cid, rev string) error { if err := s.db.Exec(ctx, "UPDATE repos SET root = ?, rev = ? WHERE did = ?", nil, root.Bytes(), rev, did).Error; err != nil { return err } return nil }