kot.pink
1package state
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "log/slog"
8 "net/http"
9 "strings"
10 "time"
11
12 comatproto "github.com/bluesky-social/indigo/api/atproto"
13 lexutil "github.com/bluesky-social/indigo/lex/util"
14 securejoin "github.com/cyphar/filepath-securejoin"
15 "github.com/go-chi/chi/v5"
16 "github.com/posthog/posthog-go"
17 "tangled.sh/tangled.sh/core/api/tangled"
18 "tangled.sh/tangled.sh/core/appview"
19 "tangled.sh/tangled.sh/core/appview/cache"
20 "tangled.sh/tangled.sh/core/appview/cache/session"
21 "tangled.sh/tangled.sh/core/appview/config"
22 "tangled.sh/tangled.sh/core/appview/db"
23 "tangled.sh/tangled.sh/core/appview/notify"
24 "tangled.sh/tangled.sh/core/appview/oauth"
25 "tangled.sh/tangled.sh/core/appview/pages"
26 posthogService "tangled.sh/tangled.sh/core/appview/posthog"
27 "tangled.sh/tangled.sh/core/appview/reporesolver"
28 "tangled.sh/tangled.sh/core/eventconsumer"
29 "tangled.sh/tangled.sh/core/idresolver"
30 "tangled.sh/tangled.sh/core/jetstream"
31 tlog "tangled.sh/tangled.sh/core/log"
32 "tangled.sh/tangled.sh/core/rbac"
33 "tangled.sh/tangled.sh/core/tid"
34 // xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"
35)
36
37type State struct {
38 db *db.DB
39 notifier notify.Notifier
40 oauth *oauth.OAuth
41 enforcer *rbac.Enforcer
42 pages *pages.Pages
43 sess *session.SessionStore
44 idResolver *idresolver.Resolver
45 posthog posthog.Client
46 jc *jetstream.JetstreamClient
47 config *config.Config
48 repoResolver *reporesolver.RepoResolver
49 knotstream *eventconsumer.Consumer
50 spindlestream *eventconsumer.Consumer
51}
52
53func Make(ctx context.Context, config *config.Config) (*State, error) {
54 d, err := db.Make(config.Core.DbPath)
55 if err != nil {
56 return nil, fmt.Errorf("failed to create db: %w", err)
57 }
58
59 enforcer, err := rbac.NewEnforcer(config.Core.DbPath)
60 if err != nil {
61 return nil, fmt.Errorf("failed to create enforcer: %w", err)
62 }
63
64 res, err := idresolver.RedisResolver(config.Redis.ToURL())
65 if err != nil {
66 log.Printf("failed to create redis resolver: %v", err)
67 res = idresolver.DefaultResolver()
68 }
69
70 pgs := pages.NewPages(config, res)
71
72 cache := cache.New(config.Redis.Addr)
73 sess := session.New(cache)
74
75 oauth := oauth.NewOAuth(config, sess)
76
77 posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})
78 if err != nil {
79 return nil, fmt.Errorf("failed to create posthog client: %w", err)
80 }
81
82 repoResolver := reporesolver.New(config, enforcer, res, d)
83
84 wrapper := db.DbWrapper{d}
85 jc, err := jetstream.NewJetstreamClient(
86 config.Jetstream.Endpoint,
87 "appview",
88 []string{
89 tangled.GraphFollowNSID,
90 tangled.FeedStarNSID,
91 tangled.PublicKeyNSID,
92 tangled.RepoArtifactNSID,
93 tangled.ActorProfileNSID,
94 tangled.SpindleMemberNSID,
95 tangled.SpindleNSID,
96 tangled.StringNSID,
97 },
98 nil,
99 slog.Default(),
100 wrapper,
101 false,
102
103 // in-memory filter is inapplicalble to appview so
104 // we'll never log dids anyway.
105 false,
106 )
107 if err != nil {
108 return nil, fmt.Errorf("failed to create jetstream client: %w", err)
109 }
110
111 ingester := appview.Ingester{
112 Db: wrapper,
113 Enforcer: enforcer,
114 IdResolver: res,
115 Config: config,
116 Logger: tlog.New("ingester"),
117 }
118 err = jc.StartJetstream(ctx, ingester.Ingest())
119 if err != nil {
120 return nil, fmt.Errorf("failed to start jetstream watcher: %w", err)
121 }
122
123 knotstream, err := Knotstream(ctx, config, d, enforcer, posthog)
124 if err != nil {
125 return nil, fmt.Errorf("failed to start knotstream consumer: %w", err)
126 }
127 knotstream.Start(ctx)
128
129 spindlestream, err := Spindlestream(ctx, config, d, enforcer)
130 if err != nil {
131 return nil, fmt.Errorf("failed to start spindlestream consumer: %w", err)
132 }
133 spindlestream.Start(ctx)
134
135 var notifiers []notify.Notifier
136 if !config.Core.Dev {
137 notifiers = append(notifiers, posthogService.NewPosthogNotifier(posthog))
138 }
139 notifier := notify.NewMergedNotifier(notifiers...)
140
141 state := &State{
142 d,
143 notifier,
144 oauth,
145 enforcer,
146 pgs,
147 sess,
148 res,
149 posthog,
150 jc,
151 config,
152 repoResolver,
153 knotstream,
154 spindlestream,
155 }
156
157 return state, nil
158}
159
160func (s *State) Favicon(w http.ResponseWriter, r *http.Request) {
161 w.Header().Set("Content-Type", "image/svg+xml")
162 w.Header().Set("Cache-Control", "public, max-age=31536000") // one year
163 w.Header().Set("ETag", `"favicon-svg-v1"`)
164
165 if match := r.Header.Get("If-None-Match"); match == `"favicon-svg-v1"` {
166 w.WriteHeader(http.StatusNotModified)
167 return
168 }
169
170 s.pages.Favicon(w)
171}
172
173func (s *State) TermsOfService(w http.ResponseWriter, r *http.Request) {
174 user := s.oauth.GetUser(r)
175 s.pages.TermsOfService(w, pages.TermsOfServiceParams{
176 LoggedInUser: user,
177 })
178}
179
180func (s *State) PrivacyPolicy(w http.ResponseWriter, r *http.Request) {
181 user := s.oauth.GetUser(r)
182 s.pages.PrivacyPolicy(w, pages.PrivacyPolicyParams{
183 LoggedInUser: user,
184 })
185}
186
187func (s *State) Timeline(w http.ResponseWriter, r *http.Request) {
188 user := s.oauth.GetUser(r)
189
190 timeline, err := db.MakeTimeline(s.db)
191 if err != nil {
192 log.Println(err)
193 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.")
194 }
195
196 repos, err := db.GetTopStarredReposLastWeek(s.db)
197 if err != nil {
198 log.Println(err)
199 s.pages.Notice(w, "topstarredrepos", "Unable to load.")
200 return
201 }
202
203 s.pages.Timeline(w, pages.TimelineParams{
204 LoggedInUser: user,
205 Timeline: timeline,
206 Repos: repos,
207 })
208}
209
210func (s *State) Keys(w http.ResponseWriter, r *http.Request) {
211 user := chi.URLParam(r, "user")
212 user = strings.TrimPrefix(user, "@")
213
214 if user == "" {
215 w.WriteHeader(http.StatusBadRequest)
216 return
217 }
218
219 id, err := s.idResolver.ResolveIdent(r.Context(), user)
220 if err != nil {
221 w.WriteHeader(http.StatusInternalServerError)
222 return
223 }
224
225 pubKeys, err := db.GetPublicKeysForDid(s.db, id.DID.String())
226 if err != nil {
227 w.WriteHeader(http.StatusNotFound)
228 return
229 }
230
231 if len(pubKeys) == 0 {
232 w.WriteHeader(http.StatusNotFound)
233 return
234 }
235
236 for _, k := range pubKeys {
237 key := strings.TrimRight(k.Key, "\n")
238 w.Write([]byte(fmt.Sprintln(key)))
239 }
240}
241
242func validateRepoName(name string) error {
243 // check for path traversal attempts
244 if name == "." || name == ".." ||
245 strings.Contains(name, "/") || strings.Contains(name, "\\") {
246 return fmt.Errorf("Repository name contains invalid path characters")
247 }
248
249 // check for sequences that could be used for traversal when normalized
250 if strings.Contains(name, "./") || strings.Contains(name, "../") ||
251 strings.HasPrefix(name, ".") || strings.HasSuffix(name, ".") {
252 return fmt.Errorf("Repository name contains invalid path sequence")
253 }
254
255 // then continue with character validation
256 for _, char := range name {
257 if !((char >= 'a' && char <= 'z') ||
258 (char >= 'A' && char <= 'Z') ||
259 (char >= '0' && char <= '9') ||
260 char == '-' || char == '_' || char == '.') {
261 return fmt.Errorf("Repository name can only contain alphanumeric characters, periods, hyphens, and underscores")
262 }
263 }
264
265 // additional check to prevent multiple sequential dots
266 if strings.Contains(name, "..") {
267 return fmt.Errorf("Repository name cannot contain sequential dots")
268 }
269
270 // if all checks pass
271 return nil
272}
273
274func stripGitExt(name string) string {
275 return strings.TrimSuffix(name, ".git")
276}
277
278func (s *State) NewRepo(w http.ResponseWriter, r *http.Request) {
279 switch r.Method {
280 case http.MethodGet:
281 user := s.oauth.GetUser(r)
282 knots, err := s.enforcer.GetKnotsForUser(user.Did)
283 if err != nil {
284 s.pages.Notice(w, "repo", "Invalid user account.")
285 return
286 }
287
288 s.pages.NewRepo(w, pages.NewRepoParams{
289 LoggedInUser: user,
290 Knots: knots,
291 })
292
293 case http.MethodPost:
294 user := s.oauth.GetUser(r)
295
296 domain := r.FormValue("domain")
297 if domain == "" {
298 s.pages.Notice(w, "repo", "Invalid form submission—missing knot domain.")
299 return
300 }
301
302 repoName := r.FormValue("name")
303 if repoName == "" {
304 s.pages.Notice(w, "repo", "Repository name cannot be empty.")
305 return
306 }
307
308 if err := validateRepoName(repoName); err != nil {
309 s.pages.Notice(w, "repo", err.Error())
310 return
311 }
312
313 repoName = stripGitExt(repoName)
314
315 defaultBranch := r.FormValue("branch")
316 if defaultBranch == "" {
317 defaultBranch = "main"
318 }
319
320 description := r.FormValue("description")
321
322 ok, err := s.enforcer.E.Enforce(user.Did, domain, domain, "repo:create")
323 if err != nil || !ok {
324 s.pages.Notice(w, "repo", "You do not have permission to create a repo in this knot.")
325 return
326 }
327
328 existingRepo, err := db.GetRepo(s.db, user.Did, repoName)
329 if err == nil && existingRepo != nil {
330 l.Info("repo exists")
331 s.pages.Notice(w, "repo", fmt.Sprintf("You already have a repository by this name on %s", existingRepo.Knot))
332 return
333 }
334
335 client, err := s.oauth.ServiceClient(
336 r,
337 oauth.WithService(domain),
338 oauth.WithLxm(tangled.RepoCreateNSID),
339 oauth.WithDev(s.config.Core.Dev),
340 )
341
342 if err != nil {
343 s.pages.Notice(w, "repo", "Failed to connect to knot server.")
344 return
345 }
346
347 rkey := tid.TID()
348 repo := &db.Repo{
349 Did: user.Did,
350 Name: repoName,
351 Knot: domain,
352 Rkey: rkey,
353 Description: description,
354 }
355
356 xrpcClient, err := s.oauth.AuthorizedClient(r)
357 if err != nil {
358 s.pages.Notice(w, "repo", "Failed to write record to PDS.")
359 return
360 }
361
362 createdAt := time.Now().Format(time.RFC3339)
363 atresp, err := xrpcClient.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
364 Collection: tangled.RepoNSID,
365 Repo: user.Did,
366 Rkey: rkey,
367 Record: &lexutil.LexiconTypeDecoder{
368 Val: &tangled.Repo{
369 Knot: repo.Knot,
370 Name: repoName,
371 CreatedAt: createdAt,
372 Owner: user.Did,
373 }},
374 })
375 if err != nil {
376 log.Printf("failed to create record: %s", err)
377 s.pages.Notice(w, "repo", "Failed to announce repository creation.")
378 return
379 }
380 log.Println("created repo record: ", atresp.Uri)
381
382 tx, err := s.db.BeginTx(r.Context(), nil)
383 if err != nil {
384 log.Println(err)
385 s.pages.Notice(w, "repo", "Failed to save repository information.")
386 return
387 }
388 defer func() {
389 tx.Rollback()
390 err = s.enforcer.E.LoadPolicy()
391 if err != nil {
392 log.Println("failed to rollback policies")
393 }
394 }()
395
396 xe := tangled.RepoCreate(
397 r.Context(),
398 client,
399 &tangled.RepoCreate_Input{
400 Rkey: rkey,
401 },
402 )
403 if err != nil {
404 xe, err := xrpcerr.Unmarshal(err.Error())
405 if err != nil {
406 log.Println(err)
407 s.pages.Notice(w, "repo", "Failed to create repository on knot server.")
408 return
409 }
410
411 log.Println(xe.Error())
412 s.pages.Notice(w, "repo", fmt.Sprintf("Failed to create repository on knot server: %s.", xe.Message))
413 return
414 }
415
416 err = db.AddRepo(tx, repo)
417 if err != nil {
418 log.Println(err)
419 s.pages.Notice(w, "repo", "Failed to save repository information.")
420 return
421 }
422
423 // acls
424 p, _ := securejoin.SecureJoin(user.Did, repoName)
425 err = s.enforcer.AddRepo(user.Did, domain, p)
426 if err != nil {
427 log.Println(err)
428 s.pages.Notice(w, "repo", "Failed to set up repository permissions.")
429 return
430 }
431
432 err = tx.Commit()
433 if err != nil {
434 log.Println("failed to commit changes", err)
435 http.Error(w, err.Error(), http.StatusInternalServerError)
436 return
437 }
438
439 err = s.enforcer.E.SavePolicy()
440 if err != nil {
441 log.Println("failed to update ACLs", err)
442 http.Error(w, err.Error(), http.StatusInternalServerError)
443 return
444 }
445
446 s.notifier.NewRepo(r.Context(), repo)
447
448 s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s", user.Handle, repoName))
449 return
450 }
451}